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

**

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

//QT_BEGIN_NAMESPACE

//#define CSSPARSER_DEBUG 

#include "hbcssscanner_p.cpp"

#include "hbmemoryutils_p.h"

#include "hblayeredstyleloader_p.h"

#include "hbthemeindex_p.h"

#include "hblayoutparameters_p.h"

using namespace HbCss;

const QString GLOBAL_CSS_SELECTOR = "*";

struct HbCssKnownValue

{

    const char *name;

    quint64 id;

};

static const HbCssKnownValue properties[NumProperties - 1] = {

    { "alignment", Property_Alignment },

    { "anchor-direction", Property_AnchorDirection },

    { "aspect-ratio", Property_AspectRatio },

    { "border-width", Property_BorderWidth },

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

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

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

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

    { "bottom", Property_Bottom },

    { "center-horizontal", Property_CenterHorizontal },

    { "center-vertical", Property_CenterVertical },

    { "color", Property_Color },

    { "fixed-height", Property_FixedHeight },

    { "fixed-length", Property_FixedLength },

    { "fixed-size", Property_FixedSize },

    { "fixed-width", Property_FixedWidth },

    { "font", Property_Font },

    { "font-family", Property_FontFamily },

    { "font-size", Property_FontSize },

    { "font-style", Property_FontStyle },

    { "font-variant", Property_FontVariant },

    { "font-weight", Property_FontWeight },

    { "layout", Property_Layout },

    { "layout-direction", Property_LayoutDirection },

    { "left", Property_Left },

    { "max-height", Property_MaximumHeight },

    { "max-length", Property_MaximumLength },

    { "max-size", Property_MaximumSize },

    { "max-width", Property_MaximumWidth },

    { "min-height", Property_MinimumHeight },

    { "min-length", Property_MinimumLength },

    { "min-size", Property_MinimumSize },

    { "min-width", Property_MinimumWidth },

    { "pref-height", Property_PreferredHeight },

    { "pref-length", Property_PreferredLength },

    { "pref-size", Property_PreferredSize },

    { "pref-width", Property_PreferredWidth },

    { "right", Property_Right },

    { "section", Property_Section },

    { "size-policy", Property_SizePolicy },

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

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

    { "text-align", Property_TextAlignment },

    { "text-decoration", Property_TextDecoration },

    { "text-height", Property_TextHeight },

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

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

    { "text-transform", Property_TextTransform },

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

    { "top", Property_Top },

    { "zvalue", Property_ZValue }

};

static const HbCssKnownValue values[NumKnownValues - 1] = {

    { "bold", Value_Bold },

    { "bottom", Value_Bottom },

    { "center", Value_Center },

    { "digital", Value_Digital },

    { "expanding", Value_Expanding },

    { "fixed", Value_Fixed },

    { "ignore", Value_Ignore },

    { "ignored", Value_Ignored },

    { "italic", Value_Italic },

    { "keep", Value_Keep },

    { "keep-expand", Value_KeepExpand },

    { "left", Value_Left },

    { "left-to-right", Value_LeftToRight },

    { "line-through", Value_LineThrough },

    { "lowercase", Value_Lowercase },

    { "maximum", Value_Maximum },

    { "minimum", Value_Minimum },

    { "minimum-expanding", Value_MinimumExpanding },

    { "negative", Value_Negative },

    { "no-wrap", Value_NoWrap },

    { "none", Value_None },

    { "normal", Value_Normal },

    { "oblique", Value_Oblique },

    { "overline", Value_Overline },

    { "parent", Value_Parent },

    { "positive", Value_Positive },

    { "preferred", Value_Preferred },

    { "primary", Value_Primary },

    { "primary-small", Value_PrimarySmall },

    { "right", Value_Right },

    { "right-to-left", Value_RightToLeft },

    { "secondary", Value_Secondary },

    { "small-caps", Value_SmallCaps },

    { "title", Value_Title },

    { "top", Value_Top },

    { "transparent", Value_Transparent },

    { "underline", Value_Underline },

    { "uppercase", Value_Uppercase },

    { "word-wrap", Value_WordWrap },

    { "wrap-anywhere", Value_WrapAnywhere }

};

static const HbCssKnownValue pseudos[NumPseudos - 1] = {

    { "landscape", PseudoClass_Landscape },

    { "left-to-right", PseudoClass_LeftToRight },

    { "portrait", PseudoClass_Portrait },

    { "right-to-left", PseudoClass_RightToLeft }

};

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;

}

#ifndef HB_BIN_CSS

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

// Value Extractor

ValueExtractor::ValueExtractor(

    const HbDeviceProfile &profile)

{

}

{

    // Initialize to some profile.

    if ( currentProfile.isNull() ) {

        currentProfile = HbDeviceProfile::current();

    }

}

qreal ValueExtractor::asReal(const Value& v, bool *ok)

{

    if (ok) {

        *ok = true;

    }

    if (v.type == Value::LengthInUnits) {

        return currentProfile.unitValue() * v.variant.toDouble();

    } else if (v.type == Value::LengthInPixels) {

        return v.variant.toDouble();

    } else if (v.type == Value::LengthInMillimeters) {

        return currentProfile.ppmValue() * v.variant.toDouble();

    } else if (v.type == Value::Percentage) {

        return v.variant.toDouble() / 100.0;

    } else if (v.type == Value::Number) {

        return v.variant.toDouble();

    }

    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, ok);

}

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

{

    if (ok) {

        *ok = true;

    }

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

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

        HbCss::Value value;

        if (extractVariableValue(s, value))

            return factor * asReal(value, ok);

        else

            if (ok) {

                *ok = false;

            }

            return 0;

    } else if (type == Value::Percentage) {

        qreal result = s.toDouble(ok) / 100.0;

        if (ok && !(*ok)) {

            return 0;

        } else {

            return result;

        }

    }

    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);

    }

    qreal result = s.toDouble(ok);

    if (ok && !(*ok)) {

        return 0;

    }

    if (unit == Un) {

        result = currentProfile.unitValue() * result;

    } else if (unit == Mm) {

        result = currentProfile.ppmValue() * result;

    } // else -> already in pixels

    return result;

}

qreal ValueExtractor::asReal(const Declaration &decl, bool *ok)

{

    if (decl.values.count() < 1) {

        if (ok) {

            *ok = false;

        }

        return 0;

    }

    return asReal(decl.values.first(), ok);

}

bool ValueExtractor::asReals(const Declaration &decl, qreal *m)

{

    bool ok = true;

    int i;

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

        m[i] = asReal(decl.values[i], &ok);

        if (!ok) {

            return false;

        }

    }

    if (i == 0) m[0] = m[1] = m[2] = m[3] = 0;

    else if (i == 1) m[3] = m[2] = m[1] = m[0];

    else if (i == 2) m[2] = m[0], m[3] = m[1];

    else if (i == 3) m[3] = m[1];

    return true;

}

static QSizePolicy::Policy parseSizePolicy(const Value& v)

{

    QSizePolicy::Policy pol(QSizePolicy::Preferred);

    switch (v.variant.toInt())

        {

        case Value_Fixed: pol = QSizePolicy::Fixed; break;

        case Value_Minimum: pol = QSizePolicy::Minimum; break;

        case Value_Maximum: pol = QSizePolicy::Maximum; break;

        case Value_Preferred: pol = QSizePolicy::Preferred; break;

        case Value_Expanding: pol = QSizePolicy::Expanding; break;

        case Value_MinimumExpanding: pol = QSizePolicy::MinimumExpanding; break;

        case Value_Ignored: pol = QSizePolicy::Ignored; break;

        default: break;

        }

    return pol;

}

static HbCss::LayoutDirection parseLayoutDirectionValue(const Value v)

{

    HbCss::LayoutDirection retVal(HbCss::LayoutDirection_Parent); // Parent as default

    if(v.type == Value::KnownIdentifier) {

        switch(v.variant.toInt()) {

        case Value_RightToLeft:

            retVal = HbCss::LayoutDirection_RightToLeft;

            break;

        case Value_LeftToRight:

            retVal = HbCss::LayoutDirection_LeftToRight;

            break;

        case Value_Parent:

        default:

            break;

        }

    }

    return retVal;

}

static Qt::AspectRatioMode parseAspectRatioMode(const Value& v)

{

    Qt::AspectRatioMode mode = Qt::KeepAspectRatio;

    switch (v.variant.toInt()) {

    case Value_Ignore:

        mode = Qt::IgnoreAspectRatio;

        break;

    case Value_KeepExpand:

        mode = Qt::KeepAspectRatioByExpanding;

        break;

    case Value_Keep:

    default:

        break;

    }

    return mode;

}

static HbAnchor::Direction parseAnchorDirection(const Value& v)

{

    HbAnchor::Direction dir = HbAnchor::Positive;

    switch (v.variant.toInt()) {

    case Value_Negative:

        dir = HbAnchor::Negative;

        break;

    case Value_Positive:

    default:

        break;

    }

    return dir;

}

static Qt::Alignment parseAlignment(const Declaration &decl)

{

    if (decl.values.isEmpty() || decl.values.count() > 2)

        return Qt::AlignLeft | Qt::AlignTop;

    Qt::Alignment a[2] = { 0, 0 };

    for (int i = 0; i < qMin(2, decl.values.count()); i++) {

        if (decl.values.at(i).type != Value::KnownIdentifier)

            break;

        switch (decl.values.at(i).variant.toInt()) {

        case Value_Left: a[i] = Qt::AlignLeft; break;

        case Value_Right: a[i] = Qt::AlignRight; break;

        case Value_Top: a[i] = Qt::AlignTop; break;

        case Value_Bottom: a[i] = Qt::AlignBottom; break;

        case Value_Center: a[i] = Qt::AlignCenter; break;

        default: break;

        }

    }

    if (a[0] == Qt::AlignCenter && a[1] != 0 && a[1] != Qt::AlignCenter)

        a[0] = (a[1] == Qt::AlignLeft || 

            a[1] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

    if ((a[1] == 0 || a[1] == Qt::AlignCenter) && a[0] != Qt::AlignCenter)

        a[1] = (a[0] == Qt::AlignLeft || 

            a[0] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

    return a[0] | a[1];

}

static Hb::TextWrapping parseWrapMode(const Value v)

{

    Hb::TextWrapping mode(Hb::TextNoWrap);

    if (v.type == Value::KnownIdentifier) {

        switch(v.variant.toInt()) {

        case Value_WordWrap: mode = Hb::TextWordWrap; break;

        case Value_WrapAnywhere: mode = Hb::TextWrapAnywhere; break;

        case Value_NoWrap: // fall-through

        default: break;

        }

    }

    return mode;

}

static bool setFontSizeFromValue(Value value, QFont &font)

{

    if (value.type != Value::Length && value.type != Value::LengthInPixels) {

        return false;

    }

    bool valid = false;

    if (value.type == Value::LengthInPixels) {

        if (value.variant.convert(HbVariant::Int)) {

            font.setPixelSize(value.variant.toInt());

            return true;

        }

    }

    QString s = value.variant.toString();

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

        s.chop(2);

        value.variant = s;

        if (value.variant.convert(HbVariant::Double)) {

            font.setPointSizeF(value.variant.toDouble());

            valid = true;

        }

    }

    return valid;

}

static bool setFontStyleFromValue(const Value &value, QFont &font)

{

    if (value.type != Value::KnownIdentifier)

        return false ;

    switch (value.variant.toInt()) {

        case Value_Normal: font.setStyle(QFont::StyleNormal); return true;

        case Value_Italic: font.setStyle(QFont::StyleItalic); return true;

        case Value_Oblique: font.setStyle(QFont::StyleOblique); return true;

        default: break;

    }

    return false;

}

static bool setFontWeightFromValue(const Value &value, QFont &font)

{

    if (value.type == Value::KnownIdentifier) {

        switch (value.variant.toInt()) {

            case Value_Normal: font.setWeight(QFont::Normal); return true;

            case Value_Bold: font.setWeight(QFont::Bold); return true;

            default: break;

        }

        return false;

    }

    if (value.type != Value::Number)

        return false;

    font.setWeight(qMin(value.variant.toInt() / 8, 99));

    return true;

}

static bool setFontFamilyFromValues(const Declaration &decl, QFont &font)

{

    QString family;

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

        const Value &v = decl.values.at(i);

        if (v.type == Value::TermOperatorComma)

            break;

        const QString str = v.variant.toString();

        if (str.isEmpty())

            break;

        family += str;

        family += QLatin1Char(' ');

    }

    family = family.simplified();

    if (family.isEmpty())

        return false;

    font.setFamily(family);

    return true;

}

static void setTextDecorationFromValues(const Declaration &decl, QFont &font)