/****************************************************************************

**

** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** Contact: Nokia Corporation (qt-info@nokia.com)

**

** This file is part of the QtGui module of the Qt Toolkit.

**

** $QT_BEGIN_LICENSE:LGPL$

** No Commercial Usage

** This file contains pre-release code and may not be distributed.

** You may use this file in accordance with the terms and conditions

** contained in the Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

#include "qcommonstyle.h"

#include "qcommonstyle_p.h"

#include <qfile.h>

#include <qapplication.h>

#include <qbitmap.h>

#include <qcache.h>

#include <qdockwidget.h>

#include <qdrawutil.h>

#include <qdialogbuttonbox.h>

#include <qformlayout.h>

#include <qgroupbox.h>

#include <qmath.h>

#include <qmenu.h>

#include <qpainter.h>

#include <qpaintengine.h>

#include <qpainterpath.h>

#include <qslider.h>

#include <qstyleoption.h>

#include <qtabbar.h>

#include <qtabwidget.h>

#include <qtoolbar.h>

#include <qtoolbutton.h>

#include <qrubberband.h>

#include <private/qcommonstylepixmaps_p.h>

#include <private/qmath_p.h>

#include <private/qstylehelper_p.h>

#include <qdebug.h>

#include <qtextformat.h>

#include <qwizard.h>

#include <qtabbar.h>

#include <qfileinfo.h>

#include <qdir.h>

#include <qsettings.h>

#include <qpixmapcache.h>

#include <private/qguiplatformplugin_p.h>

#include <limits.h>

#ifndef QT_NO_ITEMVIEWS

#   include "private/qtextengine_p.h"

#endif

#ifdef Q_WS_X11

#   include <private/qt_x11_p.h>

#elif defined(Q_WS_MAC)

#   include <private/qt_cocoa_helpers_mac_p.h>

#endif

QT_BEGIN_NAMESPACE

/*!

    \class QCommonStyle

    \brief The QCommonStyle class encapsulates the common Look and Feel of a GUI.

    \ingroup appearance

    This abstract class implements some of the widget's look and feel

    that is common to all GUI styles provided and shipped as part of

    Qt.

    Since QCommonStyle inherits QStyle, all of its functions are fully documented

    in the QStyle documentation.

    \omit

    , although the

    extra functions that QCommonStyle provides, e.g.

    drawComplexControl(), drawControl(), drawPrimitive(),

    hitTestComplexControl(), subControlRect(), sizeFromContents(), and

    subElementRect() are documented here.

    \endomit

    \sa QStyle, QMotifStyle, QWindowsStyle

*/

/*!

    Constructs a QCommonStyle.

*/

QCommonStyle::QCommonStyle()

    : QStyle(*new QCommonStylePrivate)

{ }

/*! \internal

*/

QCommonStyle::QCommonStyle(QCommonStylePrivate &dd)

    : QStyle(dd)

{ }

/*!

    Destroys the style.

*/

QCommonStyle::~QCommonStyle()

{ }

/*!

    \reimp

*/

void QCommonStyle::drawPrimitive(PrimitiveElement pe, const QStyleOption *opt, QPainter *p,

                                 const QWidget *widget) const

{

    Q_D(const QCommonStyle);

    switch (pe) {

    case PE_FrameButtonBevel:

    case PE_FrameButtonTool:

        qDrawShadeRect(p, opt->rect, opt->palette,

                       opt->state & (State_Sunken | State_On), 1, 0);

        break;

    case PE_PanelButtonCommand:

    case PE_PanelButtonBevel:

    case PE_PanelButtonTool:

    case PE_IndicatorButtonDropDown:

        qDrawShadePanel(p, opt->rect, opt->palette,

                        opt->state & (State_Sunken | State_On), 1,

                        &opt->palette.brush(QPalette::Button));

        break;

    case PE_IndicatorViewItemCheck:

        proxy()->drawPrimitive(PE_IndicatorCheckBox, opt, p, widget);

        break;

    case PE_IndicatorCheckBox:

        if (opt->state & State_NoChange) {

            p->setPen(opt->palette.foreground().color());

            p->fillRect(opt->rect, opt->palette.brush(QPalette::Button));

            p->drawRect(opt->rect);

            p->drawLine(opt->rect.topLeft(), opt->rect.bottomRight());

        } else {

            qDrawShadePanel(p, opt->rect.x(), opt->rect.y(), opt->rect.width(), opt->rect.height(),

                            opt->palette, opt->state & (State_Sunken | State_On), 1,

                            &opt->palette.brush(QPalette::Button));

        }

        break;

    case PE_IndicatorRadioButton: {

        QRect ir = opt->rect;

        p->setPen(opt->palette.dark().color());

        p->drawArc(opt->rect, 0, 5760);

        if (opt->state & (State_Sunken | State_On)) {

            ir.adjust(2, 2, -2, -2);

            p->setBrush(opt->palette.foreground());

            p->drawEllipse(ir);

        }

        break; }

    case PE_FrameFocusRect:

        if (const QStyleOptionFocusRect *fropt = qstyleoption_cast<const QStyleOptionFocusRect *>(opt)) {

            QColor bg = fropt->backgroundColor;

            QPen oldPen = p->pen();

            if (bg.isValid()) {

                int h, s, v;

                bg.getHsv(&h, &s, &v);

                if (v >= 128)

                    p->setPen(Qt::black);

                else

                    p->setPen(Qt::white);

            } else {

                p->setPen(opt->palette.foreground().color());

            }

            QRect focusRect = opt->rect.adjusted(1, 1, -1, -1);

            p->drawRect(focusRect.adjusted(0, 0, -1, -1)); //draw pen inclusive

            p->setPen(oldPen);

        }

        break;

    case PE_IndicatorMenuCheckMark: {

        const int markW = opt->rect.width() > 7 ? 7 : opt->rect.width();

        const int markH = markW;

        int posX = opt->rect.x() + (opt->rect.width() - markW)/2 + 1;

        int posY = opt->rect.y() + (opt->rect.height() - markH)/2;

        QVector<QLineF> a;

        a.reserve(markH);

        int i, xx, yy;

        xx = posX;

        yy = 3 + posY;

        for (i = 0; i < markW/2; ++i) {

            a << QLineF(xx, yy, xx, yy + 2);

            ++xx;

            ++yy;

        }

        yy -= 2;

        for (; i < markH; ++i) {

            a << QLineF(xx, yy, xx, yy + 2);

            ++xx;

            --yy;

        }

        if (!(opt->state & State_Enabled) && !(opt->state & State_On)) {

            int pnt;

            p->setPen(opt->palette.highlightedText().color());

            QPoint offset(1, 1);

            for (pnt = 0; pnt < a.size(); ++pnt)

                a[pnt].translate(offset.x(), offset.y());

            p->drawLines(a);

            for (pnt = 0; pnt < a.size(); ++pnt)

                a[pnt].translate(offset.x(), offset.y());

        }

        p->setPen(opt->palette.text().color());

        p->drawLines(a);

        break; }

    case PE_Frame:

    case PE_FrameMenu:

        if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {

            if (pe == PE_FrameMenu || (frame->state & State_Sunken) || (frame->state & State_Raised)) {

                qDrawShadePanel(p, frame->rect, frame->palette, frame->state & State_Sunken,

                                frame->lineWidth);

            } else {

                qDrawPlainRect(p, frame->rect, frame->palette.foreground().color(), frame->lineWidth);

            }

        }

        break;

#ifndef QT_NO_TOOLBAR

    case PE_PanelMenuBar:

        if (widget && qobject_cast<QToolBar *>(widget->parentWidget()))

            break;

        if (const QStyleOptionFrame *frame = qstyleoption_cast<const QStyleOptionFrame *>(opt)){

            qDrawShadePanel(p, frame->rect, frame->palette, false, frame->lineWidth,

                            &frame->palette.brush(QPalette::Button));

        }

        else if (const QStyleOptionToolBar *frame = qstyleoption_cast<const QStyleOptionToolBar *>(opt)){

            qDrawShadePanel(p, frame->rect, frame->palette, false, frame->lineWidth,

                            &frame->palette.brush(QPalette::Button));

        }

        break;

   case PE_PanelMenu:

        break;

    case PE_PanelToolBar:

       break;

#endif // QT_NO_TOOLBAR

#ifndef QT_NO_PROGRESSBAR

    case PE_IndicatorProgressChunk:

        {

            bool vertical = false;

            if (const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(opt))

                vertical = (pb2->orientation == Qt::Vertical);

            if (!vertical) {

                p->fillRect(opt->rect.x(), opt->rect.y() + 3, opt->rect.width() -2, opt->rect.height() - 6,

                            opt->palette.brush(QPalette::Highlight));

            } else {

                p->fillRect(opt->rect.x() + 2, opt->rect.y(), opt->rect.width() -6, opt->rect.height() - 2,

                            opt->palette.brush(QPalette::Highlight));

            }

        }

        break;

#endif // QT_NO_PROGRESSBAR

#ifdef QT3_SUPPORT

    case PE_Q3CheckListController:

#ifndef QT_NO_IMAGEFORMAT_XPM

        p->drawPixmap(opt->rect.topLeft(), QPixmap(check_list_controller_xpm));

#endif

        break;

    case PE_Q3CheckListExclusiveIndicator:

        if (const QStyleOptionQ3ListView *lv = qstyleoption_cast<const QStyleOptionQ3ListView *>(opt)) {

            if (lv->items.isEmpty())

                return;

            int x = lv->rect.x(),

                y = lv->rect.y();

#define INTARRLEN(x) sizeof(x)/(sizeof(int)*2)

            static const int pts1[] = {                // dark lines

                1,9, 1,8, 0,7, 0,4, 1,3, 1,2, 2,1, 3,1, 4,0, 7,0, 8,1, 9,1 };

            static const int pts2[] = {                // black lines

                2,8, 1,7, 1,4, 2,3, 2,2, 3,2, 4,1, 7,1, 8,2, 9,2 };

            static const int pts3[] = {                // background lines

                2,9, 3,9, 4,10, 7,10, 8,9, 9,9, 9,8, 10,7, 10,4, 9,3 };

            static const int pts4[] = {                // white lines

                2,10, 3,10, 4,11, 7,11, 8,10, 9,10, 10,9, 10,8, 11,7,

                11,4, 10,3, 10,2 };

            // static const int pts5[] = {                // inner fill

            //    4,2, 7,2, 9,4, 9,7, 7,9, 4,9, 2,7, 2,4 };

            //QPolygon a;

            if (lv->state & State_Enabled)

                p->setPen(lv->palette.text().color());

            else

                p->setPen(QPen(lv->viewportPalette.color(QPalette::Disabled, QPalette::Text)));

            QPolygon a(INTARRLEN(pts1), pts1);

            a.translate(x, y);

            //p->setPen(pal.dark());

            p->drawPolyline(a);

            a.setPoints(INTARRLEN(pts2), pts2);

            a.translate(x, y);

            p->drawPolyline(a);

            a.setPoints(INTARRLEN(pts3), pts3);

            a.translate(x, y);

            //                p->setPen(black);

            p->drawPolyline(a);

            a.setPoints(INTARRLEN(pts4), pts4);

            a.translate(x, y);

            //                        p->setPen(blue);

            p->drawPolyline(a);

            //                a.setPoints(INTARRLEN(pts5), pts5);

            //                a.translate(x, y);

            //        QColor fillColor = isDown() ? g.background() : g.base();

            //        p->setPen(fillColor);

            //        p->setBrush(fillColor);

            //        p->drawPolygon(a);

            if (opt->state & State_On) {

                p->setPen(Qt::NoPen);

                p->setBrush(opt->palette.text());

                p->drawRect(x + 5, y + 4, 2, 4);

                p->drawRect(x + 4, y + 5, 4, 2);

            }

#undef INTARRLEN

        }

        break;

    case PE_Q3CheckListIndicator:

        if (const QStyleOptionQ3ListView *lv = qstyleoption_cast<const QStyleOptionQ3ListView *>(opt)) {

            if(lv->items.isEmpty())

                break;

            QStyleOptionQ3ListViewItem item = lv->items.at(0);

            int x = lv->rect.x(),

                y = lv->rect.y(),

                w = lv->rect.width(),

                h = lv->rect.width(),

             marg = lv->itemMargin;

            if (lv->state & State_Enabled)

                p->setPen(QPen(lv->palette.text().color(), 2));

            else

                p->setPen(QPen(lv->viewportPalette.color(QPalette::Disabled, QPalette::Text), 2));

            if (opt->state & State_Selected && !lv->rootIsDecorated

                && !(item.features & QStyleOptionQ3ListViewItem::ParentControl)) {

                p->fillRect(0, 0, x + marg + w + 4, item.height,

                            lv->palette.brush(QPalette::Highlight));

                if (item.state & State_Enabled)

                    p->setPen(QPen(lv->palette.highlightedText().color(), 2));

            }

            if (lv->state & State_NoChange)

                p->setBrush(lv->palette.brush(QPalette::Button));

            p->drawRect(x + marg, y + 2, w - 4, h - 4);

            /////////////////////

                ++x;

                ++y;

                if (lv->state & State_On || lv->state & State_NoChange) {

                    QLineF lines[7];

                    int i,

                        xx = x + 1 + marg,

                        yy = y + 5;

                    for (i = 0; i < 3; ++i) {

                        lines[i] = QLineF(xx, yy, xx, yy + 2);

                        ++xx;

                        ++yy;

                    }

                    yy -= 2;

                    for (i = 3; i < 7; ++i) {

                        lines[i] = QLineF(xx, yy, xx, yy + 2);

                        ++xx;

                        --yy;

                    }

                    p->drawLines(lines, 7);

                }

        }

        break;

#endif // QT3_SUPPORT

    case PE_IndicatorBranch: {

        int mid_h = opt->rect.x() + opt->rect.width() / 2;

        int mid_v = opt->rect.y() + opt->rect.height() / 2;

        int bef_h = mid_h;

        int bef_v = mid_v;

        int aft_h = mid_h;

        int aft_v = mid_v;

#ifndef QT_NO_IMAGEFORMAT_XPM

        static const int decoration_size = 9;

        static QPixmap open(tree_branch_open_xpm);

        static QPixmap closed(tree_branch_closed_xpm);

        if (opt->state & State_Children) {

            int delta = decoration_size / 2;

            bef_h -= delta;

            bef_v -= delta;

            aft_h += delta;

            aft_v += delta;

            p->drawPixmap(bef_h, bef_v, opt->state & State_Open ? open : closed);

        }

#endif // QT_NO_IMAGEFORMAT_XPM

        if (opt->state & State_Item) {

            if (opt->direction == Qt::RightToLeft)

                p->drawLine(opt->rect.left(), mid_v, bef_h, mid_v);

            else

                p->drawLine(aft_h, mid_v, opt->rect.right(), mid_v);

        }

        if (opt->state & State_Sibling)

            p->drawLine(mid_h, aft_v, mid_h, opt->rect.bottom());

        if (opt->state & (State_Open | State_Children | State_Item | State_Sibling))

            p->drawLine(mid_h, opt->rect.y(), mid_h, bef_v);

        break; }

#ifdef QT3_SUPPORT

    case PE_Q3Separator:

        qDrawShadeLine(p, opt->rect.left(), opt->rect.top(), opt->rect.right(), opt->rect.bottom(),

                       opt->palette, opt->state & State_Sunken, 1, 0);

        break;

#endif // QT3_SUPPORT

    case PE_FrameStatusBarItem:

        qDrawShadeRect(p, opt->rect, opt->palette, true, 1, 0, 0);

        break;

    case PE_IndicatorHeaderArrow:

        if (const QStyleOptionHeader *header = qstyleoption_cast<const QStyleOptionHeader *>(opt)) {

            QPen oldPen = p->pen();

            if (header->sortIndicator & QStyleOptionHeader::SortUp) {

                QPolygon pa(3);

                p->setPen(QPen(opt->palette.light(), 0));

                p->drawLine(opt->rect.x() + opt->rect.width(), opt->rect.y(),

                            opt->rect.x() + opt->rect.width() / 2, opt->rect.y() + opt->rect.height());

                p->setPen(QPen(opt->palette.dark(), 0));

                pa.setPoint(0, opt->rect.x() + opt->rect.width() / 2, opt->rect.y() + opt->rect.height());

                pa.setPoint(1, opt->rect.x(), opt->rect.y());

                pa.setPoint(2, opt->rect.x() + opt->rect.width(), opt->rect.y());

                p->drawPolyline(pa);

            } else if (header->sortIndicator & QStyleOptionHeader::SortDown) {

                QPolygon pa(3);

                p->setPen(QPen(opt->palette.light(), 0));

                pa.setPoint(0, opt->rect.x(), opt->rect.y() + opt->rect.height());

                pa.setPoint(1, opt->rect.x() + opt->rect.width(), opt->rect.y() + opt->rect.height());

                pa.setPoint(2, opt->rect.x() + opt->rect.width() / 2, opt->rect.y());

                p->drawPolyline(pa);

                p->setPen(QPen(opt->palette.dark(), 0));

                p->drawLine(opt->rect.x(), opt->rect.y() + opt->rect.height(),

                            opt->rect.x() + opt->rect.width() / 2, opt->rect.y());

            }

            p->setPen(oldPen);

        }

        break;

#ifndef QT_NO_TABBAR

    case PE_FrameTabBarBase:

        if (const QStyleOptionTabBarBase *tbb

                = qstyleoption_cast<const QStyleOptionTabBarBase *>(opt)) {

            p->save();

            switch (tbb->shape) {

            case QTabBar::RoundedNorth:

            case QTabBar::TriangularNorth:

                p->setPen(QPen(tbb->palette.light(), 0));

                p->drawLine(tbb->rect.topLeft(), tbb->rect.topRight());

                break;

            case QTabBar::RoundedWest:

            case QTabBar::TriangularWest:

                p->setPen(QPen(tbb->palette.light(), 0));

                p->drawLine(tbb->rect.topLeft(), tbb->rect.bottomLeft());

                break;

            case QTabBar::RoundedSouth:

            case QTabBar::TriangularSouth:

                p->setPen(QPen(tbb->palette.shadow(), 0));

                p->drawLine(tbb->rect.left(), tbb->rect.bottom(),

                            tbb->rect.right(), tbb->rect.bottom());

                p->setPen(QPen(tbb->palette.dark(), 0));

                p->drawLine(tbb->rect.left(), tbb->rect.bottom() - 1,

                            tbb->rect.right() - 1, tbb->rect.bottom() - 1);

                break;

            case QTabBar::RoundedEast:

            case QTabBar::TriangularEast:

                p->setPen(QPen(tbb->palette.dark(), 0));

                p->drawLine(tbb->rect.topRight(), tbb->rect.bottomRight());

                break;

            }

            p->restore();

        }

        break;

    case PE_IndicatorTabClose: {

        if (d->tabBarcloseButtonIcon.isNull()) {

            d->tabBarcloseButtonIcon.addPixmap(QPixmap(

                        QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-closetab-16.png")),

                        QIcon::Normal, QIcon::Off);

            d->tabBarcloseButtonIcon.addPixmap(QPixmap(

                        QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-closetab-down-16.png")),

                        QIcon::Normal, QIcon::On);

            d->tabBarcloseButtonIcon.addPixmap(QPixmap(

                        QLatin1String(":/trolltech/styles/commonstyle/images/standardbutton-closetab-hover-16.png")),

                        QIcon::Active, QIcon::Off);

        }

        int size = proxy()->pixelMetric(QStyle::PM_SmallIconSize);

        QIcon::Mode mode = opt->state & State_Enabled ?

                            (opt->state & State_Raised ? QIcon::Active : QIcon::Normal)

                            : QIcon::Disabled;

        if (!(opt->state & State_Raised)

            && !(opt->state & State_Sunken)

            && !(opt->state & QStyle::State_Selected))

            mode = QIcon::Disabled;

        QIcon::State state = opt->state & State_Sunken ? QIcon::On : QIcon::Off;

        QPixmap pixmap = d->tabBarcloseButtonIcon.pixmap(size, mode, state);

        proxy()->drawItemPixmap(p, opt->rect, Qt::AlignCenter, pixmap);

        break;

    }

#endif // QT_NO_TABBAR

    case PE_FrameTabWidget:

    case PE_FrameWindow:

        qDrawWinPanel(p, opt->rect, opt->palette, false, 0);

        break;

    case PE_FrameLineEdit:

        proxy()->drawPrimitive(PE_Frame, opt, p, widget);