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

**

** Copyright (C) 2010 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 <qglobal.h>

#ifndef QT_NO_STYLE_STYLESHEET

#include "qstylesheetstyle_p.h"

#include "private/qcssutil_p.h"

#include <qdebug.h>

#include <qapplication.h>

#include <qmenu.h>

#include <qmenubar.h>

#include <qpainter.h>

#include <qstyleoption.h>

#include <qlineedit.h>

#include <qwindowsstyle.h>

#include <qcombobox.h>

#include <qwindowsstyle.h>

#include <qplastiquestyle.h>

#include "private/qcssparser_p.h"

#include "private/qmath_p.h"

#include <qabstractscrollarea.h>

#include "private/qabstractscrollarea_p.h"

#include <qtooltip.h>

#include <qshareddata.h>

#include <qradiobutton.h>

#include <qtoolbutton.h>

#include <qscrollbar.h>

#include <qstring.h>

#include <qfile.h>

#include <qcheckbox.h>

#include <qstatusbar.h>

#include <qheaderview.h>

#include <qprogressbar.h>

#include <private/qwindowsstyle_p.h>

#include <qtabbar.h>

#include <QMetaProperty>

#include <qmainwindow.h>

#include <qdockwidget.h>

#include <qmdisubwindow.h>

#include <qdialog.h>

#include <private/qwidget_p.h>

#include <QAbstractSpinBox>

#include <QLabel>

#include "qdrawutil.h"

#include <limits.h>

#include <QtGui/qtoolbar.h>

QT_BEGIN_NAMESPACE

using namespace QCss;

class QStyleSheetStylePrivate : public QWindowsStylePrivate

{

    Q_DECLARE_PUBLIC(QStyleSheetStyle)

public:

    QStyleSheetStylePrivate() { }

};

static QHash<const QWidget *, QVector<StyleRule> > *styleRulesCache = 0;

static QHash<const QWidget *, QHash<int, bool> > *hasStyleRuleCache = 0;

typedef QHash<int, QHash<quint64, QRenderRule> > QRenderRules;

static QHash<const QWidget *, QRenderRules> *renderRulesCache = 0;

static QHash<const QWidget *, QPalette> *customPaletteWidgets = 0; // widgets whose palette we tampered

static QHash<const void *, StyleSheet> *styleSheetCache = 0; // parsed style sheets

static QSet<const QWidget *> *autoFillDisabledWidgets = 0;

/* RECURSION_GUARD:

 * the QStyleSheetStyle is a proxy. If used with others proxy style, we may end up with something like:

 * QStyleSheetStyle -> ProxyStyle -> QStyleSheetStyle -> OriginalStyle

 * Recursion may happen if the style call the widget()->style() again.

 * Not to mention the performence penalty of having two lookup of rules.

 *

 * The first instance of QStyleSheetStyle will set globalStyleSheetStyle to itself. The second one

 * will notice the globalStyleSheetStyle is not istelf and call its base style directly.

 */

static const QStyleSheetStyle *globalStyleSheetStyle = 0;

class QStyleSheetStyleRecursionGuard

{

    public:

        QStyleSheetStyleRecursionGuard(const QStyleSheetStyle *that)

            :  guarded(globalStyleSheetStyle == 0)

            {

                if (guarded) globalStyleSheetStyle = that;

            }

        ~QStyleSheetStyleRecursionGuard() { if (guarded) globalStyleSheetStyle = 0; }

        bool guarded;

};

#define RECURSION_GUARD(RETURN) \

    if (globalStyleSheetStyle != 0 && globalStyleSheetStyle != this) { RETURN; } \

    QStyleSheetStyleRecursionGuard recursion_guard(this);

#define ceil(x) ((int)(x) + ((x) > 0 && (x) != (int)(x)))

enum PseudoElement {

    PseudoElement_None,

    PseudoElement_DownArrow,

    PseudoElement_UpArrow,

    PseudoElement_LeftArrow,

    PseudoElement_RightArrow,

    PseudoElement_Indicator,

    PseudoElement_ExclusiveIndicator,

    PseudoElement_PushButtonMenuIndicator,

    PseudoElement_ComboBoxDropDown,

    PseudoElement_ComboBoxArrow,

    PseudoElement_Item,

    PseudoElement_SpinBoxUpButton,

    PseudoElement_SpinBoxUpArrow,

    PseudoElement_SpinBoxDownButton,

    PseudoElement_SpinBoxDownArrow,

    PseudoElement_GroupBoxTitle,

    PseudoElement_GroupBoxIndicator,

    PseudoElement_ToolButtonMenu,

    PseudoElement_ToolButtonMenuArrow,

    PseudoElement_ToolButtonDownArrow,

    PseudoElement_ToolBoxTab,

    PseudoElement_ScrollBarSlider,

    PseudoElement_ScrollBarAddPage,

    PseudoElement_ScrollBarSubPage,

    PseudoElement_ScrollBarAddLine,

    PseudoElement_ScrollBarSubLine,

    PseudoElement_ScrollBarFirst,

    PseudoElement_ScrollBarLast,

    PseudoElement_ScrollBarUpArrow,

    PseudoElement_ScrollBarDownArrow,

    PseudoElement_ScrollBarLeftArrow,

    PseudoElement_ScrollBarRightArrow,

    PseudoElement_SplitterHandle,

    PseudoElement_ToolBarHandle,

    PseudoElement_ToolBarSeparator,

    PseudoElement_MenuScroller,

    PseudoElement_MenuTearoff,

    PseudoElement_MenuCheckMark,

    PseudoElement_MenuSeparator,

    PseudoElement_MenuIcon,

    PseudoElement_MenuRightArrow,

    PseudoElement_TreeViewBranch,

    PseudoElement_HeaderViewSection,

    PseudoElement_HeaderViewUpArrow,

    PseudoElement_HeaderViewDownArrow,

    PseudoElement_ProgressBarChunk,

    PseudoElement_TabBarTab,

    PseudoElement_TabBarScroller,

    PseudoElement_TabBarTear,

    PseudoElement_SliderGroove,

    PseudoElement_SliderHandle,

    PseudoElement_SliderAddPage,

    PseudoElement_SliderSubPage,

    PseudoElement_SliderTickmark,

    PseudoElement_TabWidgetPane,

    PseudoElement_TabWidgetTabBar,

    PseudoElement_TabWidgetLeftCorner,

    PseudoElement_TabWidgetRightCorner,

    PseudoElement_DockWidgetTitle,

    PseudoElement_DockWidgetCloseButton,

    PseudoElement_DockWidgetFloatButton,

    PseudoElement_DockWidgetSeparator,

    PseudoElement_MdiCloseButton,

    PseudoElement_MdiMinButton,

    PseudoElement_MdiNormalButton,

    PseudoElement_TitleBar,

    PseudoElement_TitleBarCloseButton,

    PseudoElement_TitleBarMinButton,

    PseudoElement_TitleBarMaxButton,

    PseudoElement_TitleBarShadeButton,

    PseudoElement_TitleBarUnshadeButton,

    PseudoElement_TitleBarNormalButton,

    PseudoElement_TitleBarContextHelpButton,

    PseudoElement_TitleBarSysMenu,

    PseudoElement_ViewItem,

    PseudoElement_ViewItemIcon,

    PseudoElement_ViewItemText,

    PseudoElement_ViewItemIndicator,

    PseudoElement_ScrollAreaCorner,

    PseudoElement_TabBarTabCloseButton,

    NumPseudoElements

};

struct PseudoElementInfo {

    QStyle::SubControl subControl;

    const char *name;

};

static const PseudoElementInfo knownPseudoElements[NumPseudoElements] = {

    { QStyle::SC_None, "" },

    { QStyle::SC_None, "down-arrow" },

    { QStyle::SC_None, "up-arrow" },

    { QStyle::SC_None, "left-arrow" },

    { QStyle::SC_None, "right-arrow" },

    { QStyle::SC_None, "indicator" },

    { QStyle::SC_None, "indicator" },

    { QStyle::SC_None, "menu-indicator" },

    { QStyle::SC_ComboBoxArrow, "drop-down" },

    { QStyle::SC_ComboBoxArrow, "down-arrow" },

    { QStyle::SC_None, "item" },

    { QStyle::SC_SpinBoxUp, "up-button" },

    { QStyle::SC_SpinBoxUp, "up-arrow" },

    { QStyle::SC_SpinBoxDown, "down-button" },

    { QStyle::SC_SpinBoxDown, "down-arrow" },

    { QStyle::SC_GroupBoxLabel, "title" },

    { QStyle::SC_GroupBoxCheckBox, "indicator" },

    { QStyle::SC_ToolButtonMenu, "menu-button" },

    { QStyle::SC_ToolButtonMenu, "menu-arrow" },

    { QStyle::SC_None, "menu-indicator" },

    { QStyle::SC_None, "tab" },

    { QStyle::SC_ScrollBarSlider, "handle" },

    { QStyle::SC_ScrollBarAddPage, "add-page" },

    { QStyle::SC_ScrollBarSubPage, "sub-page" },

    { QStyle::SC_ScrollBarAddLine, "add-line" },

    { QStyle::SC_ScrollBarSubLine, "sub-line" },

    { QStyle::SC_ScrollBarFirst, "first" },

    { QStyle::SC_ScrollBarLast, "last" },

    { QStyle::SC_ScrollBarSubLine, "up-arrow" },

    { QStyle::SC_ScrollBarAddLine, "down-arrow" },

    { QStyle::SC_ScrollBarSubLine, "left-arrow" },

    { QStyle::SC_ScrollBarAddLine, "right-arrow" },

    { QStyle::SC_None, "handle" },

    { QStyle::SC_None, "handle" },

    { QStyle::SC_None, "separator" },

    { QStyle::SC_None, "scroller" },

    { QStyle::SC_None, "tearoff" },

    { QStyle::SC_None, "indicator" },

    { QStyle::SC_None, "separator" },

    { QStyle::SC_None, "icon" },

    { QStyle::SC_None, "right-arrow" },

    { QStyle::SC_None, "branch" },

    { QStyle::SC_None, "section" },

    { QStyle::SC_None, "down-arrow" },

    { QStyle::SC_None, "up-arrow" },

    { QStyle::SC_None, "chunk" },

    { QStyle::SC_None, "tab" },

    { QStyle::SC_None, "scroller" },

    { QStyle::SC_None, "tear" },

    { QStyle::SC_SliderGroove, "groove" },

    { QStyle::SC_SliderHandle, "handle" },

    { QStyle::SC_None, "add-page" },

    { QStyle::SC_None, "sub-page"},

    { QStyle::SC_SliderTickmarks, "tick-mark" },

    { QStyle::SC_None, "pane" },

    { QStyle::SC_None, "tab-bar" },

    { QStyle::SC_None, "left-corner" },

    { QStyle::SC_None, "right-corner" },

    { QStyle::SC_None, "title" },

    { QStyle::SC_None, "close-button" },

    { QStyle::SC_None, "float-button" },

    { QStyle::SC_None, "separator" },

    { QStyle::SC_MdiCloseButton, "close-button" },

    { QStyle::SC_MdiMinButton, "minimize-button" },

    { QStyle::SC_MdiNormalButton, "normal-button" },

    { QStyle::SC_TitleBarLabel, "title" },

    { QStyle::SC_TitleBarCloseButton, "close-button" },

    { QStyle::SC_TitleBarMinButton, "minimize-button" },

    { QStyle::SC_TitleBarMaxButton, "maximize-button" },

    { QStyle::SC_TitleBarShadeButton, "shade-button" },

    { QStyle::SC_TitleBarUnshadeButton, "unshade-button" },

    { QStyle::SC_TitleBarNormalButton, "normal-button" },

    { QStyle::SC_TitleBarContextHelpButton, "contexthelp-button" },

    { QStyle::SC_TitleBarSysMenu, "sys-menu" },

    { QStyle::SC_None, "item" },

    { QStyle::SC_None, "icon" },

    { QStyle::SC_None, "text" },

    { QStyle::SC_None, "indicator" },

    { QStyle::SC_None, "corner" },

    { QStyle::SC_None, "close-button" },

};

struct QStyleSheetBorderImageData : public QSharedData

{

    QStyleSheetBorderImageData()

        : horizStretch(QCss::TileMode_Unknown), vertStretch(QCss::TileMode_Unknown)

    {

        for (int i = 0; i < 4; i++)

            cuts[i] = -1;

    }

    int cuts[4];

    QPixmap pixmap;

    QImage image;

    QCss::TileMode horizStretch, vertStretch;

};

struct QStyleSheetBackgroundData : public QSharedData

{

    QStyleSheetBackgroundData(const QBrush& b, const QPixmap& p, QCss::Repeat r,

                              Qt::Alignment a, QCss::Origin o, Attachment t, QCss::Origin c)

        : brush(b), pixmap(p), repeat(r), position(a), origin(o), attachment(t), clip(c) { }

    bool isTransparent() const {

        if (brush.style() != Qt::NoBrush)

            return !brush.isOpaque();

        return pixmap.isNull() ? false : pixmap.hasAlpha();

    }

    QBrush brush;

    QPixmap pixmap;

    QCss::Repeat repeat;

    Qt::Alignment position;

    QCss::Origin origin;

    QCss::Attachment attachment;

    QCss::Origin clip;

};

struct QStyleSheetBorderData : public QSharedData

{

    QStyleSheetBorderData() : bi(0)

    {

        for (int i = 0; i < 4; i++) {

            borders[i] = 0;

            styles[i] = QCss::BorderStyle_None;

        }

    }

    QStyleSheetBorderData(int *b, QBrush *c, QCss::BorderStyle *s, QSize *r) : bi(0)

    {

        for (int i = 0; i < 4; i++) {

            borders[i] = b[i];

            styles[i] = s[i];

            colors[i] = c[i];

            radii[i] = r[i];

        }

    }

    int borders[4];

    QBrush colors[4];

    QCss::BorderStyle styles[4];

    QSize radii[4]; // topleft, topright, bottomleft, bottomright

    const QStyleSheetBorderImageData *borderImage() const

    { return bi; }

    bool hasBorderImage() const { return bi!=0; }

    QSharedDataPointer<QStyleSheetBorderImageData> bi;

    bool isOpaque() const

    {

        for (int i = 0; i < 4; i++) {

            if (styles[i] == QCss::BorderStyle_Native || styles[i] == QCss::BorderStyle_None)

                continue;

            if (styles[i] >= QCss::BorderStyle_Dotted && styles[i] <= QCss::BorderStyle_DotDotDash

                && styles[i] != BorderStyle_Solid)

                return false;

            if (!colors[i].isOpaque())

                return false;

            if (!radii[i].isEmpty())

                return false;

        }

        if (bi != 0 && bi->pixmap.hasAlpha())

            return false;

        return true;

    }

};

struct QStyleSheetOutlineData : public QStyleSheetBorderData

{

    QStyleSheetOutlineData()

    {

        for (int i = 0; i < 4; i++) {

            offsets[i] = 0;

        }

    }

    QStyleSheetOutlineData(int *b, QBrush *c, QCss::BorderStyle *s, QSize *r, int *o)

            : QStyleSheetBorderData(b, c, s, r)

    {

        for (int i = 0; i < 4; i++) {

            offsets[i] = o[i];

        }

    }

    int offsets[4];

};

struct QStyleSheetBoxData : public QSharedData

{

    QStyleSheetBoxData(int *m, int *p, int s) : spacing(s)

    {

        for (int i = 0; i < 4; i++) {

            margins[i] = m[i];

            paddings[i] = p[i];

        }

    }

    int margins[4];

    int paddings[4];

    int spacing;

};

struct QStyleSheetPaletteData : public QSharedData

{

    QStyleSheetPaletteData(const QBrush &fg, const QBrush &sfg, const QBrush &sbg,

                           const QBrush &abg)

        : foreground(fg), selectionForeground(sfg), selectionBackground(sbg),

          alternateBackground(abg) { }

    QBrush foreground;

    QBrush selectionForeground;

    QBrush selectionBackground;

    QBrush alternateBackground;

};

struct QStyleSheetGeometryData : public QSharedData

{

    QStyleSheetGeometryData(int w, int h, int minw, int minh, int maxw, int maxh)

        : minWidth(minw), minHeight(minh), width(w), height(h), maxWidth(maxw), maxHeight(maxh) { }

    int minWidth, minHeight, width, height, maxWidth, maxHeight;

};

struct QStyleSheetPositionData : public QSharedData

{

    QStyleSheetPositionData(int l, int t, int r, int b, Origin o, Qt::Alignment p, QCss::PositionMode m, Qt::Alignment a = 0)

        : left(l), top(t), bottom(b), right(r), origin(o), position(p), mode(m), textAlignment(a) { }

    int left, top, bottom, right;

    Origin origin;

    Qt::Alignment position;

    QCss::PositionMode mode;

    Qt::Alignment textAlignment;

};

struct QStyleSheetImageData : public QSharedData

{

    QStyleSheetImageData(const QIcon &i, Qt::Alignment a, const QSize &sz)

        : icon(i), alignment(a), size(sz) { }

    QIcon icon;

    Qt::Alignment alignment;

    QSize size;

};

class QRenderRule

{

public:

    QRenderRule() : features(0), hasFont(false), pal(0), b(0), bg(0), bd(0), ou(0), geo(0), p(0), img(0), clipset(0) { }

    QRenderRule(const QVector<QCss::Declaration> &, const QWidget *);

    ~QRenderRule() { }

    QRect borderRect(const QRect &r) const;

    QRect outlineRect(const QRect &r) const;

    QRect paddingRect(const QRect &r) const;

    QRect contentsRect(const QRect &r) const;

    enum { Margin = 1, Border = 2, Padding = 4, All=Margin|Border|Padding };

    QRect boxRect(const QRect &r, int flags = All) const;

    QSize boxSize(const QSize &s, int flags = All) const;

    QRect originRect(const QRect &rect, Origin origin) const;

    QPainterPath borderClip(QRect rect);

    void drawBorder(QPainter *, const QRect&);

    void drawOutline(QPainter *, const QRect&);

    void drawBorderImage(QPainter *, const QRect&);

    void drawBackground(QPainter *, const QRect&, const QPoint& = QPoint(0, 0));

    void drawBackgroundImage(QPainter *, const QRect&, QPoint = QPoint(0, 0));

    void drawFrame(QPainter *, const QRect&);

    void drawImage(QPainter *p, const QRect &rect);

    void drawRule(QPainter *, const QRect&);

    void configurePalette(QPalette *, QPalette::ColorGroup, const QWidget *, bool);

    void configurePalette(QPalette *p, QPalette::ColorRole fr, QPalette::ColorRole br);

    const QStyleSheetPaletteData *palette() const { return pal; }

    const QStyleSheetBoxData *box() const { return b; }

    const QStyleSheetBackgroundData *background() const { return bg; }

    const QStyleSheetBorderData *border() const { return bd; }

    const QStyleSheetOutlineData *outline() const { return ou; }

    const QStyleSheetGeometryData *geometry() const { return geo; }

    const QStyleSheetPositionData *position() const { return p; }

    bool hasPalette() const { return pal != 0; }

    bool hasBackground() const { return bg != 0 && (!bg->pixmap.isNull() || bg->brush.style() != Qt::NoBrush); }

    bool hasGradientBackground() const { return bg && bg->brush.style() >= Qt::LinearGradientPattern

                                                   && bg->brush.style() <= Qt::ConicalGradientPattern; }

    bool hasNativeBorder() const {

        return bd == 0

               || (!bd->hasBorderImage() && bd->styles[0] == BorderStyle_Native);

    }

    bool hasNativeOutline() const {

        return (ou == 0

                || (!ou->hasBorderImage() && ou->styles[0] == BorderStyle_Native));

    }

    bool baseStyleCanDraw() const {

        if (!hasBackground() || (background()->brush.style() == Qt::NoBrush && bg->pixmap.isNull()))