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

**

** 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$

**

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

#ifndef QCSSPARSER_P_H

#define QCSSPARSER_P_H

//

//  W A R N I N G

//  -------------

//

// This file is not part of the Qt API.  It exists for the convenience

// of the QLibrary class.  This header file may change from

// version to version without notice, or even be removed.

//

// We mean it.

//

#include <QtCore/QStringList>

#include <QtCore/QVector>

#include <QtCore/QVariant>

#include <QtCore/QPair>

#include <QtCore/QSize>

#include <QtCore/QMultiHash>

#include <QtGui/QFont>

#include <QtGui/QPalette>

#include <QtGui/QIcon>

#include <QtCore/QSharedData>

#ifndef QT_NO_CSSPARSER

// VxWorks defines NONE as (-1) "for times when NULL won't do"

#if defined(Q_OS_VXWORKS) && defined(NONE)

#  undef NONE

#endif

QT_BEGIN_NAMESPACE

namespace QCss

{

enum Property {

    UnknownProperty,

    BackgroundColor,

    Color,

    Float,

    Font,

    FontFamily,

    FontSize,

    FontStyle,

    FontWeight,

    Margin,

    MarginBottom,

    MarginLeft,

    MarginRight,

    MarginTop,

    QtBlockIndent,

    QtListIndent,

    QtParagraphType,

    QtTableType,

    QtUserState,

    TextDecoration,

    TextIndent,

    TextUnderlineStyle,

    VerticalAlignment,

    Whitespace,

    QtSelectionForeground,

    QtSelectionBackground,

    Border,

    BorderLeft,

    BorderRight,

    BorderTop,

    BorderBottom,

    Padding,

    PaddingLeft,

    PaddingRight,

    PaddingTop,

    PaddingBottom,

    PageBreakBefore,

    PageBreakAfter,

    QtAlternateBackground,

    BorderLeftStyle,

    BorderRightStyle,

    BorderTopStyle,

    BorderBottomStyle,

    BorderStyles,

    BorderLeftColor,

    BorderRightColor,

    BorderTopColor,

    BorderBottomColor,

    BorderColor,

    BorderLeftWidth,

    BorderRightWidth,

    BorderTopWidth,

    BorderBottomWidth,

    BorderWidth,

    BorderTopLeftRadius,

    BorderTopRightRadius,

    BorderBottomLeftRadius,

    BorderBottomRightRadius,

    BorderRadius,

    Background,

    BackgroundOrigin,

    BackgroundClip,

    BackgroundRepeat,

    BackgroundPosition,

    BackgroundAttachment,

    BackgroundImage,

    BorderImage,

    QtSpacing,

    Width,

    Height,

    MinimumWidth,

    MinimumHeight,

    MaximumWidth,

    MaximumHeight,

    QtImage,

    Left,

    Right,

    Top,

    Bottom,

    QtOrigin,

    QtPosition,

    Position,

    QtStyleFeatures,

    QtBackgroundRole,

    ListStyleType,

    ListStyle,

    QtImageAlignment,

    TextAlignment,

    Outline,

    OutlineOffset,

    OutlineWidth,

    OutlineColor,

    OutlineStyle,

    OutlineRadius,

    OutlineTopLeftRadius,

    OutlineTopRightRadius,

    OutlineBottomLeftRadius,

    OutlineBottomRightRadius,

    FontVariant,

    TextTransform,

    NumProperties

};

enum KnownValue {

    UnknownValue,

    Value_Normal,

    Value_Pre,

    Value_NoWrap,

    Value_PreWrap,

    Value_Small,

    Value_Medium,

    Value_Large,

    Value_XLarge,

    Value_XXLarge,

    Value_Italic,

    Value_Oblique,

    Value_Bold,

    Value_Underline,

    Value_Overline,

    Value_LineThrough,

    Value_Sub,

    Value_Super,

    Value_Left,

    Value_Right,

    Value_Top,

    Value_Bottom,

    Value_Center,

    Value_Native,

    Value_Solid,

    Value_Dotted,

    Value_Dashed,

    Value_DotDash,

    Value_DotDotDash,

    Value_Double,

    Value_Groove,

    Value_Ridge,

    Value_Inset,

    Value_Outset,

    Value_Wave,

    Value_Middle,

    Value_Auto,

    Value_Always,

    Value_None,

    Value_Transparent,

    Value_Disc,

    Value_Circle,

    Value_Square,

    Value_Decimal,

    Value_LowerAlpha,

    Value_UpperAlpha,

    Value_LowerRoman,

    Value_UpperRoman,

    Value_SmallCaps,

    Value_Uppercase,

    Value_Lowercase,

    /* keep these in same order as QPalette::ColorRole */

    Value_FirstColorRole,

    Value_WindowText = Value_FirstColorRole,

    Value_Button,

    Value_Light,

    Value_Midlight,

    Value_Dark,

    Value_Mid,

    Value_Text,

    Value_BrightText,

    Value_ButtonText,

    Value_Base,

    Value_Window,

    Value_Shadow,

    Value_Highlight,

    Value_HighlightedText,

    Value_Link,

    Value_LinkVisited,

    Value_AlternateBase,

    Value_LastColorRole = Value_AlternateBase,

    Value_Disabled,

    Value_Active,

    Value_Selected,

    Value_On,

    Value_Off,

    NumKnownValues

};

enum BorderStyle {

    BorderStyle_Unknown,

    BorderStyle_None,

    BorderStyle_Dotted,

    BorderStyle_Dashed,

    BorderStyle_Solid,

    BorderStyle_Double,

    BorderStyle_DotDash,

    BorderStyle_DotDotDash,

    BorderStyle_Groove,

    BorderStyle_Ridge,

    BorderStyle_Inset,

    BorderStyle_Outset,

    BorderStyle_Native,

    NumKnownBorderStyles

};

enum Edge {

    TopEdge,

    RightEdge,

    BottomEdge,

    LeftEdge,

    NumEdges

};

enum Corner {

    TopLeftCorner,

    TopRightCorner,

    BottomLeftCorner,

    BottomRightCorner

};

enum TileMode {

    TileMode_Unknown,

    TileMode_Round,

    TileMode_Stretch,

    TileMode_Repeat,

    NumKnownTileModes

};

enum Repeat {

    Repeat_Unknown,

    Repeat_None,

    Repeat_X,

    Repeat_Y,

    Repeat_XY,

    NumKnownRepeats

};

enum Origin {

    Origin_Unknown,

    Origin_Padding,

    Origin_Border,

    Origin_Content,

    Origin_Margin,

    NumKnownOrigins

};

enum PositionMode {

    PositionMode_Unknown,

    PositionMode_Static,

    PositionMode_Relative,

    PositionMode_Absolute,

    PositionMode_Fixed,

    NumKnownPositionModes

};

enum Attachment {

    Attachment_Unknown,

    Attachment_Fixed,

    Attachment_Scroll,

    NumKnownAttachments

};

enum StyleFeature {

    StyleFeature_None = 0,

    StyleFeature_BackgroundColor = 1,

    StyleFeature_BackgroundGradient = 2,

    NumKnownStyleFeatures = 4

};

struct Q_GUI_EXPORT Value

{

    enum Type {

        Unknown,

        Number,

        Percentage,

        Length,

        String,

        Identifier,

        KnownIdentifier,

        Uri,

        Color,

        Function,

        TermOperatorSlash,

        TermOperatorComma

    };

    inline Value() : type(Unknown) { }

    Type type;

    QVariant variant;

    QString toString() const;

};

struct ColorData {

    ColorData() : role(QPalette::NoRole), type(Invalid) {}

    ColorData(const QColor &col) : color(col), role(QPalette::NoRole), type(Color) {}

    ColorData(QPalette::ColorRole r) : role(r), type(Role) {}

    QColor color;

    QPalette::ColorRole role;

    enum { Invalid, Color, Role} type;

};

struct BrushData {

    BrushData() : role(QPalette::NoRole), type(Invalid) {}

    BrushData(const QBrush &br) : brush(br), role(QPalette::NoRole), type(Brush) {}

    BrushData(QPalette::ColorRole r) : role(r), type(Role) {}

    QBrush brush;

    QPalette::ColorRole role;

    enum { Invalid, Brush, Role, DependsOnThePalette } type;

};

struct BackgroundData {

    BrushData brush;

    QString image;

    Repeat repeat;

    Qt::Alignment alignment;

};

struct LengthData {

    qreal number;

    enum { None, Px, Ex, Em } unit;

};

struct BorderData {

    LengthData width;

    BorderStyle style;

    BrushData color;

};

// 1. StyleRule - x:hover, y:clicked > z:checked { prop1: value1; prop2: value2; }

// 2. QVector<Selector> - x:hover, y:clicked z:checked

// 3. QVector<BasicSelector> - y:clicked z:checked

// 4. QVector<Declaration> - { prop1: value1; prop2: value2; }

// 5. Declaration - prop1: value1;

struct Q_AUTOTEST_EXPORT Declaration

{

    struct DeclarationData : public QSharedData

    {

        inline DeclarationData() : propertyId(UnknownProperty), important(false) {}

        QString property;

        Property propertyId;

        QVector<Value> values;

        QVariant parsed;

        bool important;

    };

    QExplicitlySharedDataPointer<DeclarationData> d;

    inline Declaration() : d(new DeclarationData()) {}

    inline bool isEmpty() const { return d->property.isEmpty() && d->propertyId == UnknownProperty; }

    // helper functions

    QColor colorValue(const QPalette & = QPalette()) const;

    void colorValues(QColor *c, const QPalette & = QPalette()) const;

    QBrush brushValue(const QPalette & = QPalette()) const;

    void brushValues(QBrush *c, const QPalette & = QPalette()) const;

    BorderStyle styleValue() const;

    void styleValues(BorderStyle *s) const;

    Origin originValue() const;

    Repeat repeatValue() const;

    Qt::Alignment alignmentValue() const;

    PositionMode positionValue() const;

    Attachment attachmentValue() const;

    int  styleFeaturesValue() const;

    bool intValue(int *i, const char *unit = 0) const;

    bool realValue(qreal *r, const char *unit = 0) const;

    QSize sizeValue() const;

    QRect rectValue() const;

    QString uriValue() const;

    QIcon iconValue() const;

    void borderImageValue(QString *image, int *cuts, TileMode *h, TileMode *v) const;

};

const quint64 PseudoClass_Unknown          = Q_UINT64_C(0x0000000000000000);

const quint64 PseudoClass_Enabled          = Q_UINT64_C(0x0000000000000001);

const quint64 PseudoClass_Disabled         = Q_UINT64_C(0x0000000000000002);

const quint64 PseudoClass_Pressed          = Q_UINT64_C(0x0000000000000004);

const quint64 PseudoClass_Focus            = Q_UINT64_C(0x0000000000000008);

const quint64 PseudoClass_Hover            = Q_UINT64_C(0x0000000000000010);

const quint64 PseudoClass_Checked          = Q_UINT64_C(0x0000000000000020);

const quint64 PseudoClass_Unchecked        = Q_UINT64_C(0x0000000000000040);

const quint64 PseudoClass_Indeterminate    = Q_UINT64_C(0x0000000000000080);

const quint64 PseudoClass_Unspecified      = Q_UINT64_C(0x0000000000000100);

const quint64 PseudoClass_Selected         = Q_UINT64_C(0x0000000000000200);

const quint64 PseudoClass_Horizontal       = Q_UINT64_C(0x0000000000000400);

const quint64 PseudoClass_Vertical         = Q_UINT64_C(0x0000000000000800);

const quint64 PseudoClass_Window           = Q_UINT64_C(0x0000000000001000);

const quint64 PseudoClass_Children         = Q_UINT64_C(0x0000000000002000);

const quint64 PseudoClass_Sibling          = Q_UINT64_C(0x0000000000004000);

const quint64 PseudoClass_Default          = Q_UINT64_C(0x0000000000008000);

const quint64 PseudoClass_First            = Q_UINT64_C(0x0000000000010000);

const quint64 PseudoClass_Last             = Q_UINT64_C(0x0000000000020000);

const quint64 PseudoClass_Middle           = Q_UINT64_C(0x0000000000040000);

const quint64 PseudoClass_OnlyOne          = Q_UINT64_C(0x0000000000080000);

const quint64 PseudoClass_PreviousSelected = Q_UINT64_C(0x0000000000100000);

const quint64 PseudoClass_NextSelected     = Q_UINT64_C(0x0000000000200000);

const quint64 PseudoClass_Flat             = Q_UINT64_C(0x0000000000400000);

const quint64 PseudoClass_Left             = Q_UINT64_C(0x0000000000800000);

const quint64 PseudoClass_Right            = Q_UINT64_C(0x0000000001000000);

const quint64 PseudoClass_Top              = Q_UINT64_C(0x0000000002000000);

const quint64 PseudoClass_Bottom           = Q_UINT64_C(0x0000000004000000);

const quint64 PseudoClass_Exclusive        = Q_UINT64_C(0x0000000008000000);

const quint64 PseudoClass_NonExclusive     = Q_UINT64_C(0x0000000010000000);

const quint64 PseudoClass_Frameless        = Q_UINT64_C(0x0000000020000000);

const quint64 PseudoClass_ReadOnly         = Q_UINT64_C(0x0000000040000000);

const quint64 PseudoClass_Active           = Q_UINT64_C(0x0000000080000000);

const quint64 PseudoClass_Closable         = Q_UINT64_C(0x0000000100000000);

const quint64 PseudoClass_Movable          = Q_UINT64_C(0x0000000200000000);

const quint64 PseudoClass_Floatable        = Q_UINT64_C(0x0000000400000000);

const quint64 PseudoClass_Minimized        = Q_UINT64_C(0x0000000800000000);

const quint64 PseudoClass_Maximized        = Q_UINT64_C(0x0000001000000000);

const quint64 PseudoClass_On               = Q_UINT64_C(0x0000002000000000);

const quint64 PseudoClass_Off              = Q_UINT64_C(0x0000004000000000);

const quint64 PseudoClass_Editable         = Q_UINT64_C(0x0000008000000000);

const quint64 PseudoClass_Item             = Q_UINT64_C(0x0000010000000000);

const quint64 PseudoClass_Closed           = Q_UINT64_C(0x0000020000000000);

const quint64 PseudoClass_Open             = Q_UINT64_C(0x0000040000000000);

const quint64 PseudoClass_EditFocus        = Q_UINT64_C(0x0000080000000000);

const quint64 PseudoClass_Alternate        = Q_UINT64_C(0x0000100000000000);

// The Any specifier is never generated, but can be used as a wildcard in searches.

const quint64 PseudoClass_Any              = Q_UINT64_C(0x0000ffffffffffff);

const int NumPseudos = 46;

struct Pseudo

{

    Pseudo() : type(0), negated(false) { }

    quint64 type;

    QString name;

    QString function;

    bool negated;

};

struct AttributeSelector

{

    enum ValueMatchType {

        NoMatch,

        MatchEqual,

        MatchContains,

        MatchBeginsWith

    };

    inline AttributeSelector() : valueMatchCriterium(NoMatch) {}

    QString name;

    QString value;

    ValueMatchType valueMatchCriterium;

};