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

**

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

** All rights reserved.

** Contact: Nokia Corporation (developer.feedback@nokia.com)

**

** This file is part of the HbCore module of the UI Extensions for Mobile.

**

** GNU Lesser General Public License Usage

** 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 developer.feedback@nokia.com.

**

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

#include "hbcssparser_p.h"

#include <new>

#include <qdebug.h>

#include <qcolor.h>

#include <qfont.h>

#include <qfileinfo.h>

#include <qfontmetrics.h>

#include <qbrush.h>

#include <qimagereader.h>

#include <qgraphicswidget.h>

#include <hbfontspec.h>

//QT_BEGIN_NAMESPACE

//#define CSSSTACKS_DEBUG 

#include "hbcssscanner_p.cpp"

#include "hbmemoryutils_p.h"

#include "hblayeredstyleloader_p.h"

using namespace HbCss;

const QString GLOBAL_CSS_SELECTOR = "*";

const char *Scanner::tokenName(HbCss::TokenType t)

{

    switch (t) {

        case NONE: return "NONE";

        case S: return "S";

        case CDO: return "CDO";

        case CDC: return "CDC";

        case INCLUDES: return "INCLUDES";

        case DASHMATCH: return "DASHMATCH";

        case LBRACE: return "LBRACE";

        case PLUS: return "PLUS";

        case GREATER: return "GREATER";

        case COMMA: return "COMMA";

        case STRING: return "STRING";

        case INVALID: return "INVALID";

        case IDENT: return "IDENT";

        case HASH: return "HASH";

        case ATKEYWORD_SYM: return "ATKEYWORD_SYM";

        case EXCLAMATION_SYM: return "EXCLAMATION_SYM";

        case LENGTH: return "LENGTH";

        case PERCENTAGE: return "PERCENTAGE";

        case NUMBER: return "NUMBER";

        case FUNCTION: return "FUNCTION";

        case COLON: return "COLON";

        case SEMICOLON: return "SEMICOLON";

        case RBRACE: return "RBRACE";

        case SLASH: return "SLASH";

        case MINUS: return "MINUS";

        case DOT: return "DOT";

        case STAR: return "STAR";

        case LBRACKET: return "LBRACKET";

        case RBRACKET: return "RBRACKET";

        case EQUAL: return "EQUAL";

        case LPAREN: return "LPAREN";

        case RPAREN: return "RPAREN";

        case OR: return "OR";

    }

    return "";

}

struct HbCssKnownValue

{

    const char *name;

    quint64 id;

};

static const HbCssKnownValue 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 },

    { "aspect-ratio", HbAspectRatio },

    { "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 },

    { "center-horizontal", HbCenterHorizontal },

    { "center-vertical", HbCenterVertical },

    { "color", Color },

    { "column-narrow-width", HbColumnNarrowWidth },

    { "column-wide-width", HbColumnWideWidth },

    { "fixed-height", HbFixedHeight },

    { "fixed-width", HbFixedWidth },

    { "float", Float },

    { "font", Font },

    { "font-family", FontFamily },

    { "font-size", FontSize },

    { "font-style", FontStyle },

    { "font-variant", FontVariant },

    { "font-weight", FontWeight },

    { "height", Height },

    { "icon-left-alignment-weight", HbIconLeftAlignmentWeight },

    { "image", QtImage },

    { "image-position", QtImageAlignment },

    { "indent", HbIndent },

    { "large-icon-size", HbLargeIconSize },

    { "layout", HbLayout },

    { "left", Left },

    { "list-style", ListStyle },

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

    { "margin" , Margin },

    { "margin-bottom", MarginBottom },

    { "margin-left", MarginLeft },

    { "margin-right", MarginRight },

    { "margin-top", MarginTop },

    { "margin-top-weight", HbTopMarginWeight },

    { "max-height", MaximumHeight },

    { "max-width", MaximumWidth },

    { "min-height", MinimumHeight },

    { "min-width", MinimumWidth },

    { "mirroring", Mirroring },

    { "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 },

    { "pref-height", HbPreferredHeight },

    { "pref-width", HbPreferredWidth },

    { "right", Right },

    { "section", HbSection },

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

    { "selection-color", QtSelectionForeground },

    { "size-policy", HbSizePolicy },

    { "size-policy-horizontal", HbSizePolicyHorizontal },

    { "size-policy-vertical", HbSizePolicyVertical },

    { "small-icon-size", HbSmallIconSize },

    { "spacing", QtSpacing },

    { "spacing-horizontal", HbSpacingHorizontal },

    { "spacing-vertical", HbSpacingVertical },

    { "stretchable", HbStretchable },

    { "subcontrol-origin", QtOrigin },

    { "subcontrol-position", QtPosition },

    { "text-align", TextAlignment },

    { "text-decoration", TextDecoration },

    { "text-height", HbTextHeight },

    { "text-indent", TextIndent },

    { "text-line-count-max", HbTextLineCountMax },

    { "text-line-count-min", HbTextLineCountMin },

    { "text-transform", TextTransform },

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

    { "text-wrap-mode", HbTextWrapMode },

    { "top", Top },

    { "vertical-align", VerticalAlignment },

    { "white-space", Whitespace },

    { "width", Width },

    { "zvalue", ZValue }

};

static const HbCssKnownValue 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 },

    { "digital", Value_Digital },

    { "disabled", Value_Disabled },

    { "disc", Value_Disc },

    { "dot-dash", Value_DotDash },

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

    { "dotted", Value_Dotted },

    { "double", Value_Double },

    { "expanding", Value_Expanding },

    { "fixed", Value_Fixed },

    { "groove", Value_Groove },

    { "highlight", Value_Highlight },

    { "highlighted-text", Value_HighlightedText },

    { "ignore", Value_Ignore },

    { "ignored", Value_Ignored },

    { "inset", Value_Inset },

    { "italic", Value_Italic },

    { "keep", Value_Keep },

    { "keep-expand", Value_KeepExpand },

    { "large", Value_Large },

    { "left", Value_Left },

    { "light", Value_Light },

    { "line-through", Value_LineThrough },

    { "link", Value_Link },

    { "link-visited", Value_LinkVisited },

    { "lower-alpha", Value_LowerAlpha },

    { "lowercase", Value_Lowercase },

    { "maximum", Value_Maximum },

    { "medium", Value_Medium },

    { "mid", Value_Mid },

    { "middle", Value_Middle },

    { "midlight", Value_Midlight },

    { "minimum", Value_Minimum },

    { "minimum-expanding", Value_MinimumExpanding },

    { "mirrored", Value_Mirrored },

    { "native", Value_Native },

    { "no-wrap", Value_NoWrap },

    { "none", Value_None },

    { "normal", Value_Normal },

    { "oblique", Value_Oblique },

    { "off", Value_Off },

    { "on", Value_On },

    { "outset", Value_Outset },

    { "overline", Value_Overline },

    { "pre", Value_Pre },

    { "preferred", Value_Preferred },

    { "primary", Value_Primary },

    { "primary-small", Value_PrimarySmall },

    { "ridge", Value_Ridge },

    { "right", Value_Right },

    { "secondary", Value_Secondary },

    { "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 },

    { "title", Value_Title },

    { "top", Value_Top },

    { "transparent", Value_Transparent },

    { "underline", Value_Underline },

    { "upper-alpha", Value_UpperAlpha },

    { "uppercase", Value_Uppercase },

    { "wave", Value_Wave },

    { "window", Value_Window },

    { "window-text", Value_WindowText },

    { "word-wrap", Value_WordWrap },

    { "wrap-anywhere", Value_WrapAnywhere },

    { "x-large", Value_XLarge },

    { "xx-large", Value_XXLarge }

};

static const HbCssKnownValue 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 },

    { "landscape", PseudoClass_Landscape },

    { "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 },

    { "portrait", PseudoClass_Portrait },

    { "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 HbCssKnownValue origins[NumKnownOrigins - 1] = {

    { "border", Origin_Border },

    { "content", Origin_Content },

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

    { "padding", Origin_Padding }

};

static const HbCssKnownValue repeats[NumKnownRepeats - 1] = {

    { "no-repeat", Repeat_None },

    { "repeat-x", Repeat_X },

    { "repeat-xy", Repeat_XY },

    { "repeat-y", Repeat_Y }

};

static const HbCssKnownValue tileModes[NumKnownTileModes - 1] = {

    { "repeat", TileMode_Repeat },

    { "round", TileMode_Round },

    { "stretch", TileMode_Stretch },

};

static const HbCssKnownValue positions[NumKnownPositionModes - 1] = {

    { "absolute", PositionMode_Absolute },

    { "fixed", PositionMode_Fixed },

    { "relative", PositionMode_Relative },

    { "static", PositionMode_Static }

};

static const HbCssKnownValue attachments[NumKnownAttachments - 1] = {

    { "fixed", Attachment_Fixed },

    { "scroll", Attachment_Scroll }

};

static const HbCssKnownValue styleFeatures[NumKnownStyleFeatures - 1] = {

    { "background-color", StyleFeature_BackgroundColor },

    { "background-gradient", StyleFeature_BackgroundGradient },

    { "none", StyleFeature_None }

};

inline bool operator<(const QString &name, const HbCssKnownValue &prop)

{

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

}

inline bool operator<(const HbCssKnownValue &prop, const QString &name)

{

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

}

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

{

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

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

    if (prop == end)

        return 0;

    return prop->id;

}

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

// Value Extractor

ValueExtractor::ValueExtractor(const HbVector<Declaration> &decls, const HbDeviceProfile &profile, const QPalette &pal)

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

{

}

ValueExtractor::ValueExtractor(const HbVector<Declaration> &decls, const HbVector<Declaration> &varDeclarations,

                               const HbDeviceProfile &profile, const QPalette &pal)

: declarations(decls), variableDeclarations(varDeclarations), adjustment(0), 

  fontExtracted(false), pal(pal), currentProfile(profile)

{

}

ValueExtractor::ValueExtractor(const HbVector<Declaration> &varDecls, bool isVariable, const HbDeviceProfile &profile)

: variableDeclarations(varDecls), adjustment(0), fontExtracted(false), currentProfile(profile)

{

    Q_UNUSED(isVariable)

    // Initialize to some profile.

    if ( currentProfile.isNull() )

        currentProfile = HbDeviceProfile::current();

}

int ValueExtractor::lengthValue(const Value& v)

{

    return qRound(asReal(v));

}

qreal ValueExtractor::asReal(const Value& v)

{

    QString s = v.variant.toString();

    s.reserve(s.length());

    if (v.type == Value::Expression || v.type == Value::ExpressionNegative) {

        qreal factor = (v.type == Value::Expression) ? 1.0 : -1.0;

        qreal value = 0;

        extractExpressionValue(s, value);

        return factor * value;

    }

    return asReal(s, v.type);

}

qreal ValueExtractor::asReal(QString &s, Value::Type type)

{

    if (type == Value::Variable || type == Value::VariableNegative) {

        qreal factor = (type == Value::Variable) ? 1.0 : -1.0;

        HbVector<HbCss::Value> values;

        if (extractValue(s, values))

            return factor * asReal(values.first());

        else

            return 0;

    }

    enum { None, Px, Un, Mm } unit = None;

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

        unit = Un;

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

        unit = Px;

    } else if (s.endsWith(QLatin1String("mm"), Qt::CaseInsensitive)) {

        unit = Mm;

    }

    if (unit != None) {

        // Assuming all unit identifiers have two characters

        s.chop(2);

    }

    bool ok;

    qreal result = s.toDouble(&ok);

    if (!ok) {

        return 0;

    }

    if (unit == Un) {

        result = currentProfile.unitValue() * result;

    } else if (unit == Mm) {

        result = currentProfile.ppmValue() * result;

    } // else -> already in pixels

    return result;

}

bool ValueExtractor::asReal(QString &s, qreal &value)

{

    enum { None, Px, Un, Mm } unit = None;

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

        unit = Un;

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

        unit = Px;

    } else if (s.endsWith(QLatin1String("mm"), Qt::CaseInsensitive)) {

        unit = Mm;

    }

    if (unit != None) {

        // Assuming all unit identifiers have two characters

        s.chop(2);

    }

    bool ok;

    value = s.toDouble(&ok);

    if (!ok) {

        return false;

    }

    if (unit == Un) {

        value = currentProfile.unitValue() * value;