1 /****************************************************************************

     2 **

     3 ** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).

     4 ** All rights reserved.

     5 ** Contact: Nokia Corporation (qt-info@nokia.com)

     6 **

     7 ** This file is part of the QtGui module of the Qt Toolkit.

     8 **

     9 ** $QT_BEGIN_LICENSE:LGPL$

    10 ** No Commercial Usage

    11 ** This file contains pre-release code and may not be distributed.

    12 ** You may use this file in accordance with the terms and conditions

    13 ** contained in the Technology Preview License Agreement accompanying

    14 ** this package.

    15 **

    16 ** GNU Lesser General Public License Usage

    17 ** Alternatively, this file may be used under the terms of the GNU Lesser

    18 ** General Public License version 2.1 as published by the Free Software

    19 ** Foundation and appearing in the file LICENSE.LGPL included in the

    20 ** packaging of this file.  Please review the following information to

    21 ** ensure the GNU Lesser General Public License version 2.1 requirements

    22 ** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

    23 **

    24 ** In addition, as a special exception, Nokia gives you certain additional

    25 ** rights.  These rights are described in the Nokia Qt LGPL Exception

    26 ** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

    27 **

    28 ** If you have questions regarding the use of this file, please contact

    29 ** Nokia at qt-info@nokia.com.

    30 **

    31 **

    32 **

    33 **

    34 **

    35 **

    36 **

    37 **

    38 ** $QT_END_LICENSE$

    39 **

    40 ****************************************************************************/

    41 

    42 #include "qcssparser_p.h"

    43 

    44 #include <qdebug.h>

    45 #include <qcolor.h>

    46 #include <qfont.h>

    47 #include <qfileinfo.h>

    48 #include <qfontmetrics.h>

    49 #include <qbrush.h>

    50 #include <qimagereader.h>

    51 #include "private/qfunctions_p.h"

    52 

    53 #ifndef QT_NO_CSSPARSER

    54 

    55 QT_BEGIN_NAMESPACE

    56 

    57 #include "qcssscanner.cpp"

    58 

    59 using namespace QCss;

    60 

    61 struct QCssKnownValue

    62 {

    63     const char *name;

    64     quint64 id;

    65 };

    66 

    67 static const QCssKnownValue properties[NumProperties - 1] = {

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

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

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

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

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

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

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

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

    76     { "background", Background },

    77     { "background-attachment", BackgroundAttachment },

    78     { "background-clip", BackgroundClip },

    79     { "background-color", BackgroundColor },

    80     { "background-image", BackgroundImage },

    81     { "background-origin", BackgroundOrigin },

    82     { "background-position", BackgroundPosition },

    83     { "background-repeat", BackgroundRepeat },

    84     { "border", Border },

    85     { "border-bottom", BorderBottom },

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

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

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

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

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

    91     { "border-color", BorderColor },

    92     { "border-image", BorderImage },

    93     { "border-left", BorderLeft },

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

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

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

    97     { "border-radius", BorderRadius },

    98     { "border-right", BorderRight },

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

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

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

   102     { "border-style", BorderStyles },

   103     { "border-top", BorderTop },

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

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

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

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

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

   109     { "border-width", BorderWidth },

   110     { "bottom", Bottom },

   111     { "color", Color },

   112     { "float", Float },

   113     { "font", Font },

   114     { "font-family", FontFamily },

   115     { "font-size", FontSize },

   116     { "font-style", FontStyle },

   117     { "font-variant", FontVariant },

   118     { "font-weight", FontWeight },

   119     { "height", Height },

   120     { "image", QtImage },

   121     { "image-position", QtImageAlignment },

   122     { "left", Left },

   123     { "list-style", ListStyle },

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

   125     { "margin" , Margin },

   126     { "margin-bottom", MarginBottom },

   127     { "margin-left", MarginLeft },

   128     { "margin-right", MarginRight },

   129     { "margin-top", MarginTop },

   130     { "max-height", MaximumHeight },

   131     { "max-width", MaximumWidth },

   132     { "min-height", MinimumHeight },

   133     { "min-width", MinimumWidth },

   134     { "outline", Outline },

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

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

   137     { "outline-color", OutlineColor },

   138     { "outline-offset", OutlineOffset },

   139     { "outline-radius", OutlineRadius },

   140     { "outline-style", OutlineStyle },

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

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

   143     { "outline-width", OutlineWidth },

   144     { "padding", Padding },

   145     { "padding-bottom", PaddingBottom },

   146     { "padding-left", PaddingLeft },

   147     { "padding-right", PaddingRight },

   148     { "padding-top", PaddingTop },

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

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

   151     { "position", Position },

   152     { "right", Right },

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

   154     { "selection-color", QtSelectionForeground },

   155     { "spacing", QtSpacing },

   156     { "subcontrol-origin", QtOrigin },

   157     { "subcontrol-position", QtPosition },

   158     { "text-align", TextAlignment },

   159     { "text-decoration", TextDecoration },

   160     { "text-indent", TextIndent },

   161     { "text-transform", TextTransform },

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

   163     { "top", Top },

   164     { "vertical-align", VerticalAlignment },

   165     { "white-space", Whitespace },

   166     { "width", Width }

   167 };

   168 

   169 static const QCssKnownValue values[NumKnownValues - 1] = {

   170     { "active", Value_Active },

   171     { "alternate-base", Value_AlternateBase },

   172     { "always", Value_Always },

   173     { "auto", Value_Auto },

   174     { "base", Value_Base },

   175     { "bold", Value_Bold },

   176     { "bottom", Value_Bottom },

   177     { "bright-text", Value_BrightText },

   178     { "button", Value_Button },

   179     { "button-text", Value_ButtonText },

   180     { "center", Value_Center },

   181     { "circle", Value_Circle },

   182     { "dark", Value_Dark },

   183     { "dashed", Value_Dashed },

   184     { "decimal", Value_Decimal },

   185     { "disabled", Value_Disabled },

   186     { "disc", Value_Disc },

   187     { "dot-dash", Value_DotDash },

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

   189     { "dotted", Value_Dotted },

   190     { "double", Value_Double },

   191     { "groove", Value_Groove },

   192     { "highlight", Value_Highlight },

   193     { "highlighted-text", Value_HighlightedText },

   194     { "inset", Value_Inset },

   195     { "italic", Value_Italic },

   196     { "large", Value_Large },

   197     { "left", Value_Left },

   198     { "light", Value_Light },

   199     { "line-through", Value_LineThrough },

   200     { "link", Value_Link },

   201     { "link-visited", Value_LinkVisited },

   202     { "lower-alpha", Value_LowerAlpha },

   203     { "lower-roman", Value_LowerRoman },

   204     { "lowercase", Value_Lowercase },

   205     { "medium", Value_Medium },

   206     { "mid", Value_Mid },

   207     { "middle", Value_Middle },

   208     { "midlight", Value_Midlight },

   209     { "native", Value_Native },

   210     { "none", Value_None },

   211     { "normal", Value_Normal },

   212     { "nowrap", Value_NoWrap },

   213     { "oblique", Value_Oblique },

   214     { "off", Value_Off },

   215     { "on", Value_On },

   216     { "outset", Value_Outset },

   217     { "overline", Value_Overline },

   218     { "pre", Value_Pre },

   219     { "pre-wrap", Value_PreWrap },

   220     { "ridge", Value_Ridge },

   221     { "right", Value_Right },

   222     { "selected", Value_Selected },

   223     { "shadow", Value_Shadow },

   224     { "small" , Value_Small },

   225     { "small-caps", Value_SmallCaps },

   226     { "solid", Value_Solid },

   227     { "square", Value_Square },

   228     { "sub", Value_Sub },

   229     { "super", Value_Super },

   230     { "text", Value_Text },

   231     { "top", Value_Top },

   232     { "transparent", Value_Transparent },

   233     { "underline", Value_Underline },

   234     { "upper-alpha", Value_UpperAlpha },

   235     { "upper-roman", Value_UpperRoman },

   236     { "uppercase", Value_Uppercase },

   237     { "wave", Value_Wave },

   238     { "window", Value_Window },

   239     { "window-text", Value_WindowText },

   240     { "x-large", Value_XLarge },

   241     { "xx-large", Value_XXLarge }

   242 };

   243 

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

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

   246     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,

   247     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,

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

   249 

   250 QString Value::toString() const

   251 {

   252     if (type == KnownIdentifier) {

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

   254     } else {

   255         return variant.toString();

   256     }

   257 }

   258 

   259 static const QCssKnownValue pseudos[NumPseudos - 1] = {

   260     { "active", PseudoClass_Active },

   261     { "adjoins-item", PseudoClass_Item },

   262     { "alternate", PseudoClass_Alternate },

   263     { "bottom", PseudoClass_Bottom },

   264     { "checked", PseudoClass_Checked },

   265     { "closable", PseudoClass_Closable },

   266     { "closed", PseudoClass_Closed },

   267     { "default", PseudoClass_Default },

   268     { "disabled", PseudoClass_Disabled },

   269     { "edit-focus", PseudoClass_EditFocus },

   270     { "editable", PseudoClass_Editable },

   271     { "enabled", PseudoClass_Enabled },

   272     { "exclusive", PseudoClass_Exclusive },

   273     { "first", PseudoClass_First },

   274     { "flat", PseudoClass_Flat },

   275     { "floatable", PseudoClass_Floatable },

   276     { "focus", PseudoClass_Focus },

   277     { "has-children", PseudoClass_Children },

   278     { "has-siblings", PseudoClass_Sibling },

   279     { "horizontal", PseudoClass_Horizontal },

   280     { "hover", PseudoClass_Hover },

   281     { "indeterminate" , PseudoClass_Indeterminate },

   282     { "last", PseudoClass_Last },

   283     { "left", PseudoClass_Left },

   284     { "maximized", PseudoClass_Maximized },

   285     { "middle", PseudoClass_Middle },

   286     { "minimized", PseudoClass_Minimized },

   287     { "movable", PseudoClass_Movable },

   288     { "next-selected", PseudoClass_NextSelected },

   289     { "no-frame", PseudoClass_Frameless },

   290     { "non-exclusive", PseudoClass_NonExclusive },

   291     { "off", PseudoClass_Unchecked },

   292     { "on", PseudoClass_Checked },

   293     { "only-one", PseudoClass_OnlyOne },

   294     { "open", PseudoClass_Open },

   295     { "pressed", PseudoClass_Pressed },

   296     { "previous-selected", PseudoClass_PreviousSelected },

   297     { "read-only", PseudoClass_ReadOnly },

   298     { "right", PseudoClass_Right },

   299     { "selected", PseudoClass_Selected },

   300     { "top", PseudoClass_Top },

   301     { "unchecked" , PseudoClass_Unchecked },

   302     { "vertical", PseudoClass_Vertical },

   303     { "window", PseudoClass_Window }

   304 };

   305 

   306 static const QCssKnownValue origins[NumKnownOrigins - 1] = {

   307     { "border", Origin_Border },

   308     { "content", Origin_Content },

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

   310     { "padding", Origin_Padding }

   311 };

   312 

   313 static const QCssKnownValue repeats[NumKnownRepeats - 1] = {

   314     { "no-repeat", Repeat_None },

   315     { "repeat-x", Repeat_X },

   316     { "repeat-xy", Repeat_XY },

   317     { "repeat-y", Repeat_Y }

   318 };

   319 

   320 static const QCssKnownValue tileModes[NumKnownTileModes - 1] = {

   321     { "repeat", TileMode_Repeat },

   322     { "round", TileMode_Round },

   323     { "stretch", TileMode_Stretch },

   324 };

   325 

   326 static const QCssKnownValue positions[NumKnownPositionModes - 1] = {

   327     { "absolute", PositionMode_Absolute },

   328     { "fixed", PositionMode_Fixed },

   329     { "relative", PositionMode_Relative },

   330     { "static", PositionMode_Static }

   331 };

   332 

   333 static const QCssKnownValue attachments[NumKnownAttachments - 1] = {

   334     { "fixed", Attachment_Fixed },

   335     { "scroll", Attachment_Scroll }

   336 };

   337 

   338 static const QCssKnownValue styleFeatures[NumKnownStyleFeatures - 1] = {

   339     { "background-color", StyleFeature_BackgroundColor },

   340     { "background-gradient", StyleFeature_BackgroundGradient },

   341     { "none", StyleFeature_None }

   342 };

   343 

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

   345 {

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

   347 }

   348 

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

   350 {

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

   352 }

   353 

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

   355 {

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

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

   358     if (prop == end)

   359         return 0;

   360     return prop->id;

   361 }

   362 

   363 ///////////////////////////////////////////////////////////////////////////////

   364 // Value Extractor

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

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

   367 {

   368 }

   369 

   370 LengthData ValueExtractor::lengthValue(const Value& v)

   371 {

   372     QString s = v.variant.toString();

   373     s.reserve(s.length());

   374     LengthData data;

   375     data.unit = LengthData::None;

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

   377         data.unit = LengthData::Px;

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

   379         data.unit = LengthData::Ex;

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

   381         data.unit = LengthData::Em;

   382 

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

   384         s.chop(2);

   385 

   386     data.number = s.toDouble();

   387     return data;

   388 }

   389 

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

   391 {

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

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

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

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

   396     return qRound(data.number);

   397 }

   398 

   399 int ValueExtractor::lengthValue(const Declaration &decl)

   400 {

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

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

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

   404         return 0;

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

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

   407     return lengthValueFromData(data,f);

   408 }

   409 

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

   411 {

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

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

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

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

   416         return;

   417     }

   418 

   419     LengthData datas[4];

   420     int i;

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

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

   423 

   424     if (i == 0) {

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

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

   427     } else if (i == 1) {

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

   429     } else if (i == 2) {

   430         datas[2] = datas[0];

   431         datas[3] = datas[1];

   432     } else if (i == 3) {

   433         datas[3] = datas[1];

   434     }

   435 

   436     QList<QVariant> v;

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

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

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

   440     }

   441     decl.d->parsed = v;

   442 }

   443 

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

   445 {

   446     extractFont();

   447     bool hit = false;

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

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

   450         switch (decl.d->propertyId) {

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

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

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

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

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

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

   457         default: continue;

   458         }

   459         hit = true;

   460     }

   461 

   462     return hit;

   463 }

   464 

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

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

   467 {

   468     extractFont();

   469     bool hit = false;

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

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

   472         switch (decl.d->propertyId) {

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

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

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

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

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

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

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

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

   481         default: continue;

   482         }

   483         hit = true;

   484     }

   485 

   486     return hit;

   487 }

   488 

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

   490 {

   491     extractFont();

   492     bool hit = false;

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

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

   495         switch (decl.d->propertyId) {

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

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

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

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

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

   501 

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

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

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

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

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

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

   508 

   509         default: continue;

   510         }

   511         hit = true;

   512     }

   513 

   514     return hit;

   515 }

   516 

   517 int ValueExtractor::extractStyleFeatures()

   518 {

   519     int features = StyleFeature_None;

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

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

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

   523             features = decl.styleFeaturesValue();

   524     }

   525     return features;

   526 }

   527 

   528 QSize ValueExtractor::sizeValue(const Declaration &decl)

   529 {

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

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

   532         return QSize(lengthValueFromData(qvariant_cast<LengthData>(v.at(0)), f),

   533                      lengthValueFromData(qvariant_cast<LengthData>(v.at(1)), f));

   534     }

   535 

   536     LengthData x[2] = { {0, LengthData::None }, {0, LengthData::None} };   

   537     if (decl.d->values.count() > 0)

   538         x[0] = lengthValue(decl.d->values.at(0));

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

   540         x[1] = lengthValue(decl.d->values.at(1));

   541     else

   542         x[1] = x[0];

   543     QList<QVariant> v;

   544     v << qVariantFromValue<LengthData>(x[0]) << qVariantFromValue<LengthData>(x[1]);

   545     decl.d->parsed = v;

   546     return QSize(lengthValueFromData(x[0], f), lengthValueFromData(x[1], f));

   547 }

   548 

   549 void ValueExtractor::sizeValues(const Declaration &decl, QSize *radii)

   550 {

   551     radii[0] = sizeValue(decl);

   552     for (int i = 1; i < 4; i++)

   553         radii[i] = radii[0];

   554 }

   555 

   556 bool ValueExtractor::extractBorder(int *borders, QBrush *colors, BorderStyle *styles,

   557                                    QSize *radii)

   558 {

   559     extractFont();

   560     bool hit = false;

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

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

   563         switch (decl.d->propertyId) {

   564         case BorderLeftWidth: borders[LeftEdge] = lengthValue(decl); break;

   565         case BorderRightWidth: borders[RightEdge] = lengthValue(decl); break;

   566         case BorderTopWidth: borders[TopEdge] = lengthValue(decl); break;

   567         case BorderBottomWidth: borders[BottomEdge] = lengthValue(decl); break;

   568         case BorderWidth: lengthValues(decl, borders); break;

   569 

   570         case BorderLeftColor: colors[LeftEdge] = decl.brushValue(pal); break;

   571         case BorderRightColor: colors[RightEdge] = decl.brushValue(pal); break;

   572         case BorderTopColor: colors[TopEdge] = decl.brushValue(pal); break;

   573         case BorderBottomColor: colors[BottomEdge] = decl.brushValue(pal); break;

   574         case BorderColor: decl.brushValues(colors, pal); break;

   575 

   576         case BorderTopStyle: styles[TopEdge] = decl.styleValue(); break;

   577         case BorderBottomStyle: styles[BottomEdge] = decl.styleValue(); break;

   578         case BorderLeftStyle: styles[LeftEdge] = decl.styleValue(); break;

   579         case BorderRightStyle: styles[RightEdge] = decl.styleValue(); break;

   580         case BorderStyles:  decl.styleValues(styles); break;

   581 

   582         case BorderTopLeftRadius: radii[0] = sizeValue(decl); break;

   583         case BorderTopRightRadius: radii[1] = sizeValue(decl); break;

   584         case BorderBottomLeftRadius: radii[2] = sizeValue(decl); break;

   585         case BorderBottomRightRadius: radii[3] = sizeValue(decl); break;

   586         case BorderRadius: sizeValues(decl, radii); break;

   587 

   588         case BorderLeft:

   589             borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

   590             break;

   591         case BorderTop:

   592             borderValue(decl, &borders[TopEdge], &styles[TopEdge], &colors[TopEdge]);

   593             break;

   594         case BorderRight:

   595             borderValue(decl, &borders[RightEdge], &styles[RightEdge], &colors[RightEdge]);

   596             break;

   597         case BorderBottom:

   598             borderValue(decl, &borders[BottomEdge], &styles[BottomEdge], &colors[BottomEdge]);

   599             break;

   600         case Border:

   601             borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

   602             borders[TopEdge] = borders[RightEdge] = borders[BottomEdge] = borders[LeftEdge];

   603             styles[TopEdge] = styles[RightEdge] = styles[BottomEdge] = styles[LeftEdge];

   604             colors[TopEdge] = colors[RightEdge] = colors[BottomEdge] = colors[LeftEdge];

   605             break;

   606 

   607         default: continue;

   608         }

   609         hit = true;

   610     }

   611 

   612     return hit;

   613 }

   614 

   615 bool ValueExtractor::extractOutline(int *borders, QBrush *colors, BorderStyle *styles,

   616                                    QSize *radii, int *offsets)

   617 {

   618     extractFont();

   619     bool hit = false;

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

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

   622         switch (decl.d->propertyId) {

   623         case OutlineWidth: lengthValues(decl, borders); break;

   624         case OutlineColor: decl.brushValues(colors, pal); break;

   625         case OutlineStyle:  decl.styleValues(styles); break;

   626 

   627         case OutlineTopLeftRadius: radii[0] = sizeValue(decl); break;

   628         case OutlineTopRightRadius: radii[1] = sizeValue(decl); break;

   629         case OutlineBottomLeftRadius: radii[2] = sizeValue(decl); break;

   630         case OutlineBottomRightRadius: radii[3] = sizeValue(decl); break;

   631         case OutlineRadius: sizeValues(decl, radii); break;

   632         case OutlineOffset: lengthValues(decl, offsets); break;

   633 

   634         case Outline:

   635             borderValue(decl, &borders[LeftEdge], &styles[LeftEdge], &colors[LeftEdge]);

   636             borders[TopEdge] = borders[RightEdge] = borders[BottomEdge] = borders[LeftEdge];

   637             styles[TopEdge] = styles[RightEdge] = styles[BottomEdge] = styles[LeftEdge];

   638             colors[TopEdge] = colors[RightEdge] = colors[BottomEdge] = colors[LeftEdge];

   639             break;

   640 

   641         default: continue;

   642         }

   643         hit = true;

   644     }

   645 

   646     return hit;

   647 }

   648 

   649 static Qt::Alignment parseAlignment(const Value *values, int count)

   650 {

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

   652     for (int i = 0; i < qMin(2, count); i++) {

   653         if (values[i].type != Value::KnownIdentifier)

   654             break;

   655         switch (values[i].variant.toInt()) {

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

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

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

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

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

   661         default: break;

   662         }

   663     }

   664 

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

   666         a[0] = (a[1] == Qt::AlignLeft || a[1] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

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

   668         a[1] = (a[0] == Qt::AlignLeft || a[0] == Qt::AlignRight) ? Qt::AlignVCenter : Qt::AlignHCenter;

   669     return a[0] | a[1];

   670 }

   671 

   672 static ColorData parseColorValue(Value v)

   673 {

   674     if (v.type == Value::Identifier || v.type == Value::String) {

   675         v.variant.convert(QVariant::Color);

   676         v.type = Value::Color;

   677     }

   678 

   679     if (v.type == Value::Color)

   680         return qvariant_cast<QColor>(v.variant);

   681 

   682     if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_Transparent)

   683         return QColor(Qt::transparent);

   684 

   685     if (v.type != Value::Function)

   686         return ColorData();

   687 

   688     QStringList lst = v.variant.toStringList();

   689     if (lst.count() != 2)

   690         return ColorData();

   691 

   692     if ((lst.at(0).compare(QLatin1String("palette"), Qt::CaseInsensitive)) == 0) {

   693         int role = findKnownValue(lst.at(1).trimmed(), values, NumKnownValues);

   694         if (role >= Value_FirstColorRole && role <= Value_LastColorRole)

   695             return (QPalette::ColorRole)(role-Value_FirstColorRole);

   696 

   697         return ColorData();

   698     }

   699 

   700     bool rgb = lst.at(0).startsWith(QLatin1String("rgb"));

   701 

   702     Parser p(lst.at(1));

   703     if (!p.testExpr())

   704         return ColorData();

   705 

   706     QVector<Value> colorDigits;

   707     if (!p.parseExpr(&colorDigits))

   708         return ColorData();

   709 

   710     for (int i = 0; i < qMin(colorDigits.count(), 7); i += 2) {

   711         if (colorDigits.at(i).type == Value::Percentage) {

   712             colorDigits[i].variant = colorDigits.at(i).variant.toReal() * (255. / 100.);

   713             colorDigits[i].type = Value::Number;

   714         } else if (colorDigits.at(i).type != Value::Number) {

   715             return ColorData();

   716         }

   717     }

   718 

   719     int v1 = colorDigits.at(0).variant.toInt();

   720     int v2 = colorDigits.at(2).variant.toInt();

   721     int v3 = colorDigits.at(4).variant.toInt();

   722     int alpha = colorDigits.count() >= 7 ? colorDigits.at(6).variant.toInt() : 255;

   723 

   724     return rgb ? QColor::fromRgb(v1, v2, v3, alpha)

   725                : QColor::fromHsv(v1, v2, v3, alpha);

   726 }

   727 

   728 static QColor colorFromData(const ColorData& c, const QPalette &pal)

   729 {

   730     if (c.type == ColorData::Color) {

   731         return c.color;

   732     } else if (c.type == ColorData::Role) {

   733         return pal.color(c.role);

   734     }

   735     return QColor();

   736 }

   737 

   738 static BrushData parseBrushValue(const Value &v, const QPalette &pal)

   739 {

   740     ColorData c = parseColorValue(v);

   741     if (c.type == ColorData::Color) {

   742         return QBrush(c.color);

   743     } else if (c.type == ColorData::Role) {

   744         return c.role;

   745     }

   746 

   747     if (v.type != Value::Function)

   748         return BrushData();

   749 

   750     QStringList lst = v.variant.toStringList();

   751     if (lst.count() != 2)

   752         return BrushData();

   753 

   754     QStringList gradFuncs;

   755     gradFuncs << QLatin1String("qlineargradient") << QLatin1String("qradialgradient") << QLatin1String("qconicalgradient") << QLatin1String("qgradient");

   756     int gradType = -1;

   757 

   758     if ((gradType = gradFuncs.indexOf(lst.at(0).toLower())) == -1)

   759         return BrushData();

   760 

   761     QHash<QString, qreal> vars;

   762     QVector<QGradientStop> stops;

   763 

   764     int spread = -1;

   765     QStringList spreads;

   766     spreads << QLatin1String("pad") << QLatin1String("reflect") << QLatin1String("repeat");

   767 

   768     bool dependsOnThePalette = false;

   769     Parser parser(lst.at(1));

   770     while (parser.hasNext()) {

   771         parser.skipSpace();

   772         if (!parser.test(IDENT))

   773             return BrushData();

   774         QString attr = parser.lexem();

   775         parser.skipSpace();

   776         if (!parser.test(COLON))

   777             return BrushData();

   778         parser.skipSpace();

   779         if (attr.compare(QLatin1String("stop"), Qt::CaseInsensitive) == 0) {

   780             Value stop, color;

   781             parser.next();

   782             if (!parser.parseTerm(&stop)) return BrushData();

   783             parser.skipSpace();

   784             parser.next();

   785             if (!parser.parseTerm(&color)) return BrushData();

   786             ColorData cd = parseColorValue(color);

   787             if(cd.type == ColorData::Role)

   788                 dependsOnThePalette = true;

   789             stops.append(QGradientStop(stop.variant.toReal(), colorFromData(cd, pal)));

   790         } else {

   791             parser.next();

   792             Value value;

   793             (void)parser.parseTerm(&value);

   794             if (attr.compare(QLatin1String("spread"), Qt::CaseInsensitive) == 0) {

   795                 spread = spreads.indexOf(value.variant.toString());

   796             } else {

   797                 vars[attr] = value.variant.toReal();

   798             }

   799         }

   800         parser.skipSpace();

   801         (void)parser.test(COMMA);

   802     }

   803 

   804     if (gradType == 0) {

   805         QLinearGradient lg(vars.value(QLatin1String("x1")), vars.value(QLatin1String("y1")),

   806                            vars.value(QLatin1String("x2")), vars.value(QLatin1String("y2")));

   807         lg.setCoordinateMode(QGradient::ObjectBoundingMode);

   808         lg.setStops(stops);

   809         if (spread != -1)

   810             lg.setSpread(QGradient::Spread(spread));

   811         BrushData bd = QBrush(lg);

   812         if (dependsOnThePalette)

   813             bd.type = BrushData::DependsOnThePalette;

   814         return bd;

   815     }

   816 

   817     if (gradType == 1) {

   818         QRadialGradient rg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),

   819                            vars.value(QLatin1String("radius")), vars.value(QLatin1String("fx")),

   820                            vars.value(QLatin1String("fy")));

   821         rg.setCoordinateMode(QGradient::ObjectBoundingMode);

   822         rg.setStops(stops);

   823         if (spread != -1)

   824             rg.setSpread(QGradient::Spread(spread));

   825         BrushData bd = QBrush(rg);

   826         if (dependsOnThePalette)

   827             bd.type = BrushData::DependsOnThePalette;

   828         return bd;

   829     }

   830 

   831     if (gradType == 2) {

   832         QConicalGradient cg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),

   833                             vars.value(QLatin1String("angle")));

   834         cg.setCoordinateMode(QGradient::ObjectBoundingMode);

   835         cg.setStops(stops);

   836         if (spread != -1)

   837             cg.setSpread(QGradient::Spread(spread));

   838         BrushData bd = QBrush(cg);

   839         if (dependsOnThePalette)

   840             bd.type = BrushData::DependsOnThePalette;

   841         return bd;

   842     }

   843 

   844     return BrushData();

   845 }

   846 

   847 static QBrush brushFromData(const BrushData& c, const QPalette &pal)

   848 {

   849     if (c.type == BrushData::Role) {

   850         return pal.color(c.role);

   851     } else {

   852         return c.brush;

   853     }

   854 }

   855 

   856 static BorderStyle parseStyleValue(Value v)

   857 {

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

   859         switch (v.variant.toInt()) {

   860         case Value_None:

   861             return BorderStyle_None;

   862         case Value_Dotted:

   863             return BorderStyle_Dotted;

   864         case Value_Dashed:

   865             return BorderStyle_Dashed;

   866         case Value_Solid:

   867             return BorderStyle_Solid;

   868         case Value_Double:

   869             return BorderStyle_Double;

   870         case Value_DotDash:

   871             return BorderStyle_DotDash;

   872         case Value_DotDotDash:

   873             return BorderStyle_DotDotDash;

   874         case Value_Groove:

   875             return BorderStyle_Groove;

   876         case Value_Ridge:

   877             return BorderStyle_Ridge;

   878         case Value_Inset:

   879             return BorderStyle_Inset;

   880         case Value_Outset:

   881             return BorderStyle_Outset;

   882         case Value_Native:

   883             return BorderStyle_Native;

   884         default:

   885             break;

   886         }

   887     }

   888 

   889     return BorderStyle_Unknown;

   890 }

   891 

   892 void ValueExtractor::borderValue(const Declaration &decl, int *width, QCss::BorderStyle *style, QBrush *color)

   893 {

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

   895         BorderData data = qvariant_cast<BorderData>(decl.d->parsed);

   896         *width = lengthValueFromData(data.width, f);

   897         *style = data.style;

   898         *color = brushFromData(data.color, pal);

   899         return;

   900     }

   901 

   902     *width = 0;

   903     *style = BorderStyle_None;

   904     *color = QColor();

   905 

   906     if (decl.d->values.isEmpty())

   907         return;

   908     

   909     BorderData data;

   910     data.width.number = 0;

   911     data.width.unit = LengthData::None;

   912     data.style = BorderStyle_None;

   913 

   914     int i = 0;

   915     if (decl.d->values.at(i).type == Value::Length || decl.d->values.at(i).type == Value::Number) {

   916         data.width = lengthValue(decl.d->values.at(i));

   917         *width = lengthValueFromData(data.width, f);

   918         if (++i >= decl.d->values.count()) {

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

   920             return;

   921         }

   922     }

   923 

   924     data.style = parseStyleValue(decl.d->values.at(i));

   925     if (data.style != BorderStyle_Unknown) {

   926         *style = data.style;

   927         if (++i >= decl.d->values.count()) {

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

   929             return;

   930         }

   931     } else {

   932         data.style = BorderStyle_None;

   933     }

   934 

   935      data.color = parseBrushValue(decl.d->values.at(i), pal);

   936      *color = brushFromData(data.color, pal);

   937      if (data.color.type != BrushData::DependsOnThePalette)

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

   939 }

   940 

   941 static void parseShorthandBackgroundProperty(const QVector<Value> &values, BrushData *brush, QString *image, Repeat *repeat, Qt::Alignment *alignment, const QPalette &pal)

   942 {

   943     *brush = BrushData();

   944     *image = QString();

   945     *repeat = Repeat_XY;

   946     *alignment = Qt::AlignTop | Qt::AlignLeft;

   947 

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

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

   950         if (v.type == Value::Uri) {

   951             *image = v.variant.toString();

   952             continue;

   953         } else if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_None) {

   954             *image = QString();

   955             continue;

   956         } else if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_Transparent) {

   957             *brush = QBrush(Qt::transparent);

   958         }

   959 

   960         Repeat repeatAttempt = static_cast<Repeat>(findKnownValue(v.variant.toString(),

   961                                                    repeats, NumKnownRepeats));

   962         if (repeatAttempt != Repeat_Unknown) {

   963             *repeat = repeatAttempt;

   964             continue;

   965         }

   966 

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

   968             const int start = i;

   969             int count = 1;

   970             if (i < values.count() - 1

   971                 && values.at(i + 1).type == Value::KnownIdentifier) {

   972                 ++i;

   973                 ++count;

   974             }

   975             Qt::Alignment a = parseAlignment(values.constData() + start, count);

   976             if (int(a) != 0) {

   977                 *alignment = a;

   978                 continue;

   979             }

   980             i -= count - 1;

   981         }

   982 

   983         *brush = parseBrushValue(v, pal);

   984     }

   985 }

   986 

   987 bool ValueExtractor::extractBackground(QBrush *brush, QString *image, Repeat *repeat,

   988                                        Qt::Alignment *alignment, Origin *origin, Attachment *attachment,

   989                                        Origin *clip)

   990 {

   991     bool hit = false;

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

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

   994         if (decl.d->values.isEmpty())

   995             continue;

   996         const Value &val = decl.d->values.at(0);

   997         switch (decl.d->propertyId) {

   998             case BackgroundColor:

   999                     *brush = decl.brushValue();

  1000                 break;

  1001             case BackgroundImage:

  1002                 if (val.type == Value::Uri)

  1003                     *image = val.variant.toString();

  1004                 break;

  1005             case BackgroundRepeat:

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

  1007                     *repeat = static_cast<Repeat>(decl.d->parsed.toInt());

  1008                 } else {

  1009                     *repeat = static_cast<Repeat>(findKnownValue(val.variant.toString(),

  1010                                                   repeats, NumKnownRepeats));

  1011                     decl.d->parsed = *repeat;

  1012                 }

  1013                 break;

  1014             case BackgroundPosition:

  1015                 *alignment = decl.alignmentValue();

  1016                 break;

  1017             case BackgroundOrigin:

  1018                 *origin = decl.originValue();

  1019                 break;

  1020             case BackgroundClip:

  1021                 *clip = decl.originValue();

  1022                 break;

  1023             case Background:

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

  1025                     BackgroundData data = qvariant_cast<BackgroundData>(decl.d->parsed);

  1026                     *brush = brushFromData(data.brush, pal);

  1027                     *image = data.image;

  1028                     *repeat = data.repeat;

  1029                     *alignment = data.alignment;

  1030                 } else {

  1031                     BrushData brushData;

  1032                     parseShorthandBackgroundProperty(decl.d->values, &brushData, image, repeat, alignment, pal);

  1033                     *brush = brushFromData(brushData, pal);

  1034                     if (brushData.type != BrushData::DependsOnThePalette) {

  1035 #if defined Q_CC_MSVC && _MSC_VER <= 1300

  1036                         BackgroundData data;

  1037                         data.brush = brushData;

  1038                         data.image = *image;

  1039                         data.repeat = *repeat;

  1040                         data.alignment = *alignment;

  1041 #else

  1042                         BackgroundData data = { brushData, *image, *repeat, *alignment };

  1043 #endif

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

  1045                     }

  1046                 }

  1047                 break;

  1048             case BackgroundAttachment:

  1049                 *attachment = decl.attachmentValue();

  1050                 break;

  1051             default: continue;

  1052         }

  1053         hit = true;

  1054     }

  1055     return hit;

  1056 }

  1057 

  1058 static bool setFontSizeFromValue(Value value, QFont *font, int *fontSizeAdjustment)

  1059 {

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

  1061         bool valid = true;

  1062         switch (value.variant.toInt()) {

  1063             case Value_Small: *fontSizeAdjustment = -1; break;

  1064             case Value_Medium: *fontSizeAdjustment = 0; break;

  1065             case Value_Large: *fontSizeAdjustment = 1; break;

  1066             case Value_XLarge: *fontSizeAdjustment = 2; break;

  1067             case Value_XXLarge: *fontSizeAdjustment = 3; break;

  1068             default: valid = false; break;

  1069         }

  1070         return valid;

  1071     }

  1072     if (value.type != Value::Length)

  1073         return false;

  1074 

  1075     bool valid = false;

  1076     QString s = value.variant.toString();

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

  1078         s.chop(2);

  1079         value.variant = s;

  1080         if (value.variant.convert((QVariant::Type)qMetaTypeId<qreal>())) {

  1081             font->setPointSizeF(value.variant.toReal());

  1082             valid = true;

  1083         }

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

  1085         s.chop(2);

  1086         value.variant = s;

  1087         if (value.variant.convert(QVariant::Int)) {

  1088             font->setPixelSize(value.variant.toInt());

  1089             valid = true;

  1090         }

  1091     }

  1092     return valid;

  1093 }

  1094 

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

  1096 {

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

  1098         return false ;

  1099     switch (value.variant.toInt()) {

  1100         case Value_Normal: font->setStyle(QFont::StyleNormal); return true;

  1101         case Value_Italic: font->setStyle(QFont::StyleItalic); return true;

  1102         case Value_Oblique: font->setStyle(QFont::StyleOblique); return true;

  1103         default: break;

  1104     }

  1105     return false;

  1106 }

  1107 

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

  1109 {

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

  1111         switch (value.variant.toInt()) {

  1112             case Value_Normal: font->setWeight(QFont::Normal); return true;

  1113             case Value_Bold: font->setWeight(QFont::Bold); return true;

  1114             default: break;

  1115         }

  1116         return false;

  1117     }

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

  1119         return false;

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

  1121     return true;

  1122 }

  1123 

  1124 /** \internal

  1125  * parse the font family from the values (starting from index \a start)

  1126  * and set it the \a font

  1127  * \returns true if a family was extracted.

  1128  */

  1129 static bool setFontFamilyFromValues(const QVector<Value> &values, QFont *font, int start = 0)

  1130 {

  1131     QString family;

  1132     for (int i = start; i < values.count(); ++i) {

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

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