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

**

** 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 "qcssparser_p.h"

#include <qdebug.h>

#include <qcolor.h>

#include <qfont.h>

#include <qfileinfo.h>

#include <qfontmetrics.h>

#include <qbrush.h>

#include <qimagereader.h>

#include "private/qfunctions_p.h"

#ifndef QT_NO_CSSPARSER

QT_BEGIN_NAMESPACE

#include "qcssscanner.cpp"

using namespace QCss;

struct QCssKnownValue

{

    const char *name;

    quint64 id;

};

static const QCssKnownValue properties[NumProperties - 1] = {

    { "-qt-background-role", QtBackgroundRole },

    { "-qt-block-indent", QtBlockIndent },

    { "-qt-list-indent", QtListIndent },

    { "-qt-paragraph-type", QtParagraphType },

    { "-qt-style-features", QtStyleFeatures },

    { "-qt-table-type", QtTableType },

    { "-qt-user-state", QtUserState },

    { "alternate-background-color", QtAlternateBackground },

    { "background", Background },

    { "background-attachment", BackgroundAttachment },

    { "background-clip", BackgroundClip },

    { "background-color", BackgroundColor },

    { "background-image", BackgroundImage },

    { "background-origin", BackgroundOrigin },

    { "background-position", BackgroundPosition },

    { "background-repeat", BackgroundRepeat },

    { "border", Border },

    { "border-bottom", BorderBottom },

    { "border-bottom-color", BorderBottomColor },

    { "border-bottom-left-radius", BorderBottomLeftRadius },

    { "border-bottom-right-radius", BorderBottomRightRadius },

    { "border-bottom-style", BorderBottomStyle },

    { "border-bottom-width", BorderBottomWidth },

    { "border-color", BorderColor },

    { "border-image", BorderImage },

    { "border-left", BorderLeft },

    { "border-left-color", BorderLeftColor },

    { "border-left-style", BorderLeftStyle },

    { "border-left-width", BorderLeftWidth },

    { "border-radius", BorderRadius },

    { "border-right", BorderRight },

    { "border-right-color", BorderRightColor },

    { "border-right-style", BorderRightStyle },

    { "border-right-width", BorderRightWidth },

    { "border-style", BorderStyles },

    { "border-top", BorderTop },

    { "border-top-color", BorderTopColor },

    { "border-top-left-radius", BorderTopLeftRadius },

    { "border-top-right-radius", BorderTopRightRadius },

    { "border-top-style", BorderTopStyle },

    { "border-top-width", BorderTopWidth },

    { "border-width", BorderWidth },

    { "bottom", Bottom },

    { "color", Color },

    { "float", Float },

    { "font", Font },

    { "font-family", FontFamily },

    { "font-size", FontSize },

    { "font-style", FontStyle },

    { "font-variant", FontVariant },

    { "font-weight", FontWeight },

    { "height", Height },

    { "image", QtImage },

    { "image-position", QtImageAlignment },

    { "left", Left },

    { "list-style", ListStyle },

    { "list-style-type", ListStyleType },

    { "margin" , Margin },

    { "margin-bottom", MarginBottom },

    { "margin-left", MarginLeft },

    { "margin-right", MarginRight },

    { "margin-top", MarginTop },

    { "max-height", MaximumHeight },

    { "max-width", MaximumWidth },

    { "min-height", MinimumHeight },

    { "min-width", MinimumWidth },

    { "outline", Outline },

    { "outline-bottom-left-radius", OutlineBottomLeftRadius },

    { "outline-bottom-right-radius", OutlineBottomRightRadius },

    { "outline-color", OutlineColor },

    { "outline-offset", OutlineOffset },

    { "outline-radius", OutlineRadius },

    { "outline-style", OutlineStyle },

    { "outline-top-left-radius", OutlineTopLeftRadius },

    { "outline-top-right-radius", OutlineTopRightRadius },

    { "outline-width", OutlineWidth },

    { "padding", Padding },

    { "padding-bottom", PaddingBottom },

    { "padding-left", PaddingLeft },

    { "padding-right", PaddingRight },

    { "padding-top", PaddingTop },

    { "page-break-after", PageBreakAfter },

    { "page-break-before", PageBreakBefore },

    { "position", Position },

    { "right", Right },

    { "selection-background-color", QtSelectionBackground },

    { "selection-color", QtSelectionForeground },

    { "spacing", QtSpacing },

    { "subcontrol-origin", QtOrigin },

    { "subcontrol-position", QtPosition },

    { "text-align", TextAlignment },

    { "text-decoration", TextDecoration },

    { "text-indent", TextIndent },

    { "text-transform", TextTransform },

    { "text-underline-style", TextUnderlineStyle },

    { "top", Top },

    { "vertical-align", VerticalAlignment },

    { "white-space", Whitespace },

    { "width", Width }

};

static const QCssKnownValue values[NumKnownValues - 1] = {

    { "active", Value_Active },

    { "alternate-base", Value_AlternateBase },

    { "always", Value_Always },

    { "auto", Value_Auto },

    { "base", Value_Base },

    { "bold", Value_Bold },

    { "bottom", Value_Bottom },

    { "bright-text", Value_BrightText },

    { "button", Value_Button },

    { "button-text", Value_ButtonText },

    { "center", Value_Center },

    { "circle", Value_Circle },

    { "dark", Value_Dark },

    { "dashed", Value_Dashed },

    { "decimal", Value_Decimal },

    { "disabled", Value_Disabled },

    { "disc", Value_Disc },

    { "dot-dash", Value_DotDash },

    { "dot-dot-dash", Value_DotDotDash },

    { "dotted", Value_Dotted },

    { "double", Value_Double },

    { "groove", Value_Groove },

    { "highlight", Value_Highlight },

    { "highlighted-text", Value_HighlightedText },

    { "inset", Value_Inset },

    { "italic", Value_Italic },

    { "large", Value_Large },

    { "left", Value_Left },

    { "light", Value_Light },

    { "line-through", Value_LineThrough },

    { "link", Value_Link },

    { "link-visited", Value_LinkVisited },

    { "lower-alpha", Value_LowerAlpha },

    { "lower-roman", Value_LowerRoman },

    { "lowercase", Value_Lowercase },

    { "medium", Value_Medium },

    { "mid", Value_Mid },

    { "middle", Value_Middle },

    { "midlight", Value_Midlight },

    { "native", Value_Native },

    { "none", Value_None },

    { "normal", Value_Normal },

    { "nowrap", Value_NoWrap },

    { "oblique", Value_Oblique },

    { "off", Value_Off },

    { "on", Value_On },

    { "outset", Value_Outset },

    { "overline", Value_Overline },

    { "pre", Value_Pre },

    { "pre-wrap", Value_PreWrap },

    { "ridge", Value_Ridge },

    { "right", Value_Right },

    { "selected", Value_Selected },

    { "shadow", Value_Shadow },

    { "small" , Value_Small },

    { "small-caps", Value_SmallCaps },

    { "solid", Value_Solid },

    { "square", Value_Square },

    { "sub", Value_Sub },

    { "super", Value_Super },

    { "text", Value_Text },

    { "top", Value_Top },

    { "transparent", Value_Transparent },

    { "underline", Value_Underline },

    { "upper-alpha", Value_UpperAlpha },

    { "upper-roman", Value_UpperRoman },

    { "uppercase", Value_Uppercase },

    { "wave", Value_Wave },

    { "window", Value_Window },

    { "window-text", Value_WindowText },

    { "x-large", Value_XLarge },

    { "xx-large", Value_XXLarge }

};

//Map id to strings as they appears in the 'values' array above

static const short indexOfId[NumKnownValues] = { 0, 41, 48, 42, 49, 54, 35, 26, 70, 71, 25, 43, 5, 63, 47,

    29, 58, 59, 27, 51, 61, 6, 10, 39, 56, 19, 13, 17, 18, 20, 21, 50, 24, 46, 67, 37, 3, 2, 40, 62, 16,

    11, 57, 14, 32, 64, 33, 65, 55, 66, 34, 69, 8, 28, 38, 12, 36, 60, 7, 9, 4, 68, 53, 22, 23, 30, 31,

    1, 15, 0, 52, 45, 44 };

QString Value::toString() const

{

    if (type == KnownIdentifier) {

        return QLatin1String(values[indexOfId[variant.toInt()]].name);

    } else {

        return variant.toString();

    }

}

static const QCssKnownValue pseudos[NumPseudos - 1] = {

    { "active", PseudoClass_Active },

    { "adjoins-item", PseudoClass_Item },

    { "alternate", PseudoClass_Alternate },

    { "bottom", PseudoClass_Bottom },

    { "checked", PseudoClass_Checked },

    { "closable", PseudoClass_Closable },

    { "closed", PseudoClass_Closed },

    { "default", PseudoClass_Default },

    { "disabled", PseudoClass_Disabled },

    { "edit-focus", PseudoClass_EditFocus },

    { "editable", PseudoClass_Editable },

    { "enabled", PseudoClass_Enabled },

    { "exclusive", PseudoClass_Exclusive },

    { "first", PseudoClass_First },

    { "flat", PseudoClass_Flat },

    { "floatable", PseudoClass_Floatable },

    { "focus", PseudoClass_Focus },

    { "has-children", PseudoClass_Children },

    { "has-siblings", PseudoClass_Sibling },

    { "horizontal", PseudoClass_Horizontal },

    { "hover", PseudoClass_Hover },

    { "indeterminate" , PseudoClass_Indeterminate },

    { "last", PseudoClass_Last },

    { "left", PseudoClass_Left },

    { "maximized", PseudoClass_Maximized },

    { "middle", PseudoClass_Middle },

    { "minimized", PseudoClass_Minimized },

    { "movable", PseudoClass_Movable },

    { "next-selected", PseudoClass_NextSelected },

    { "no-frame", PseudoClass_Frameless },

    { "non-exclusive", PseudoClass_NonExclusive },

    { "off", PseudoClass_Unchecked },

    { "on", PseudoClass_Checked },

    { "only-one", PseudoClass_OnlyOne },

    { "open", PseudoClass_Open },

    { "pressed", PseudoClass_Pressed },

    { "previous-selected", PseudoClass_PreviousSelected },

    { "read-only", PseudoClass_ReadOnly },

    { "right", PseudoClass_Right },

    { "selected", PseudoClass_Selected },

    { "top", PseudoClass_Top },

    { "unchecked" , PseudoClass_Unchecked },

    { "vertical", PseudoClass_Vertical },

    { "window", PseudoClass_Window }

};

static const QCssKnownValue origins[NumKnownOrigins - 1] = {

    { "border", Origin_Border },

    { "content", Origin_Content },

    { "margin", Origin_Margin }, // not in css

    { "padding", Origin_Padding }

};

static const QCssKnownValue repeats[NumKnownRepeats - 1] = {

    { "no-repeat", Repeat_None },

    { "repeat-x", Repeat_X },

    { "repeat-xy", Repeat_XY },

    { "repeat-y", Repeat_Y }

};

static const QCssKnownValue tileModes[NumKnownTileModes - 1] = {

    { "repeat", TileMode_Repeat },

    { "round", TileMode_Round },

    { "stretch", TileMode_Stretch },

};

static const QCssKnownValue positions[NumKnownPositionModes - 1] = {

    { "absolute", PositionMode_Absolute },

    { "fixed", PositionMode_Fixed },

    { "relative", PositionMode_Relative },

    { "static", PositionMode_Static }

};

static const QCssKnownValue attachments[NumKnownAttachments - 1] = {

    { "fixed", Attachment_Fixed },

    { "scroll", Attachment_Scroll }

};

static const QCssKnownValue styleFeatures[NumKnownStyleFeatures - 1] = {

    { "background-color", StyleFeature_BackgroundColor },

    { "background-gradient", StyleFeature_BackgroundGradient },

    { "none", StyleFeature_None }

};

Q_STATIC_GLOBAL_OPERATOR bool operator<(const QString &name, const QCssKnownValue &prop)

{

    return QString::compare(name, QLatin1String(prop.name), Qt::CaseInsensitive) < 0;

}

Q_STATIC_GLOBAL_OPERATOR bool operator<(const QCssKnownValue &prop, const QString &name)

{

    return QString::compare(QLatin1String(prop.name), name, Qt::CaseInsensitive) < 0;

}

static quint64 findKnownValue(const QString &name, const QCssKnownValue *start, int numValues)

{

    const QCssKnownValue *end = &start[numValues - 1];

    const QCssKnownValue *prop = qBinaryFind(start, end, name);

    if (prop == end)

        return 0;

    return prop->id;

}

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

// Value Extractor

ValueExtractor::ValueExtractor(const QVector<Declaration> &decls, const QPalette &pal)

: declarations(decls), adjustment(0), fontExtracted(false), pal(pal)

{

}

LengthData ValueExtractor::lengthValue(const Value& v)

{

    QString s = v.variant.toString();

    s.reserve(s.length());

    LengthData data;

    data.unit = LengthData::None;

    if (s.endsWith(QLatin1String("px"), Qt::CaseInsensitive))

        data.unit = LengthData::Px;

    else if (s.endsWith(QLatin1String("ex"), Qt::CaseInsensitive))

        data.unit = LengthData::Ex;

    else if (s.endsWith(QLatin1String("em"), Qt::CaseInsensitive))

        data.unit = LengthData::Em;

    if (data.unit != LengthData::None)

        s.chop(2);

    data.number = s.toDouble();

    return data;

}

static int lengthValueFromData(const LengthData& data, const QFont& f)

{

    if (data.unit == LengthData::Ex)

        return qRound(QFontMetrics(f).xHeight() * data.number);

    else if (data.unit == LengthData::Em)

        return qRound(QFontMetrics(f).height() * data.number);

    return qRound(data.number);

}

int ValueExtractor::lengthValue(const Declaration &decl)

{

    if (decl.d->parsed.isValid())

        return  lengthValueFromData(qvariant_cast<LengthData>(decl.d->parsed), f);

    if (decl.d->values.count() < 1)

        return 0;

    LengthData data = lengthValue(decl.d->values.at(0));

    decl.d->parsed = qVariantFromValue<LengthData>(data);

    return lengthValueFromData(data,f);

}

void ValueExtractor::lengthValues(const Declaration &decl, int *m)

{

    if (decl.d->parsed.isValid()) {

        QList<QVariant> v = decl.d->parsed.toList();

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

            m[i] = lengthValueFromData(qvariant_cast<LengthData>(v.at(i)), f);

        return;

    }

    LengthData datas[4];

    int i;

    for (i = 0; i < qMin(decl.d->values.count(), 4); i++)

        datas[i] = lengthValue(decl.d->values[i]);

    if (i == 0) {

        LengthData zero = {0.0, LengthData::None};

        datas[0] = datas[1] = datas[2] = datas[3] = zero;

    } else if (i == 1) {

        datas[3] = datas[2] = datas[1] = datas[0];

    } else if (i == 2) {

        datas[2] = datas[0];

        datas[3] = datas[1];

    } else if (i == 3) {

        datas[3] = datas[1];

    }

    QList<QVariant> v;

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

        v += qVariantFromValue<LengthData>(datas[i]);

        m[i] = lengthValueFromData(datas[i], f);

    }

    decl.d->parsed = v;

}

bool ValueExtractor::extractGeometry(int *w, int *h, int *minw, int *minh, int *maxw, int *maxh)

{

    extractFont();

    bool hit = false;

    for (int i = 0; i < declarations.count(); i++) {

        const Declaration &decl = declarations.at(i);

        switch (decl.d->propertyId) {

        case Width: *w = lengthValue(decl); break;

        case Height: *h = lengthValue(decl); break;

        case MinimumWidth: *minw = lengthValue(decl); break;

        case MinimumHeight: *minh = lengthValue(decl); break;

        case MaximumWidth: *maxw = lengthValue(decl); break;

        case MaximumHeight: *maxh = lengthValue(decl); break;

        default: continue;

        }

        hit = true;

    }

    return hit;

}

bool ValueExtractor::extractPosition(int *left, int *top, int *right, int *bottom, QCss::Origin *origin,

                                     Qt::Alignment *position, QCss::PositionMode *mode, Qt::Alignment *textAlignment)

{

    extractFont();

    bool hit = false;

    for (int i = 0; i < declarations.count(); i++) {

        const Declaration &decl = declarations.at(i);

        switch (decl.d->propertyId) {

        case Left: *left = lengthValue(decl); break;

        case Top: *top = lengthValue(decl); break;

        case Right: *right = lengthValue(decl); break;

        case Bottom: *bottom = lengthValue(decl); break;

        case QtOrigin: *origin = decl.originValue(); break;

        case QtPosition: *position = decl.alignmentValue(); break;

        case TextAlignment: *textAlignment = decl.alignmentValue(); break;

        case Position: *mode = decl.positionValue(); break;

        default: continue;

        }

        hit = true;

    }

    return hit;

}

bool ValueExtractor::extractBox(int *margins, int *paddings, int *spacing)

{

    extractFont();

    bool hit = false;

    for (int i = 0; i < declarations.count(); i++) {

        const Declaration &decl = declarations.at(i);

        switch (decl.d->propertyId) {

        case PaddingLeft: paddings[LeftEdge] = lengthValue(decl); break;

        case PaddingRight: paddings[RightEdge] = lengthValue(decl); break;

        case PaddingTop: paddings[TopEdge] = lengthValue(decl); break;

        case PaddingBottom: paddings[BottomEdge] = lengthValue(decl); break;

        case Padding: lengthValues(decl, paddings); break;

        case MarginLeft: margins[LeftEdge] = lengthValue(decl); break;

        case MarginRight: margins[RightEdge] = lengthValue(decl); break;

        case MarginTop: margins[TopEdge] = lengthValue(decl); break;

        case MarginBottom: margins[BottomEdge] = lengthValue(decl); break;

        case Margin: lengthValues(decl, margins); break;

        case QtSpacing: if (spacing) *spacing = lengthValue(decl); break;

        default: continue;

        }

        hit = true;

    }

    return hit;

}

int ValueExtractor::extractStyleFeatures()

{

    int features = StyleFeature_None;

    for (int i = 0; i < declarations.count(); i++) {

        const Declaration &decl = declarations.at(i);

        if (decl.d->propertyId == QtStyleFeatures)

            features = decl.styleFeaturesValue();

    }

    return features;

}

QSize ValueExtractor::sizeValue(const Declaration &decl)

{