qcssparser.cpp File Reference

#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"
#include "qcssscanner.cpp"

Go to the source code of this file.

Classes
struct	QCssKnownValue

Functions
static QBrush	brushFromData (const BrushData &c, const QPalette &pal)
static QColor	colorFromData (const ColorData &c, const QPalette &pal)
static quint64	findKnownValue (const QString &name, const QCssKnownValue *start, int numValues)
static bool	intValueHelper (const QCss::Value &v, int *i, const char *unit)
static bool	isHexDigit (const char c)
static int	lengthValueFromData (const LengthData &data, const QFont &f)
Q_STATIC_GLOBAL_OPERATOR bool	operator< (const QString &name, const QCssKnownValue &prop)
Q_STATIC_GLOBAL_OPERATOR bool	operator< (const QCssKnownValue &prop, const QString &name)
static Qt::Alignment	parseAlignment (const QCss::Value *values, int count)
static BrushData	parseBrushValue (const QCss::Value &v, const QPalette &pal)
static ColorData	parseColorValue (QCss::Value v)
static void	parseShorthandBackgroundProperty (const QVector< QCss::Value > &values, BrushData *brush, QString *image, Repeat *repeat, Qt::Alignment *alignment, const QPalette &pal)
static void	parseShorthandFontProperty (const QVector< QCss::Value > &values, QFont *font, int *fontSizeAdjustment)
static BorderStyle	parseStyleValue (QCss::Value v)
static void	removeOptionalQuotes (QString *str)
static bool	setFontFamilyFromValues (const QVector< QCss::Value > &values, QFont *font, int start=0)
static bool	setFontSizeFromValue (QCss::Value value, QFont *font, int *fontSizeAdjustment)
static bool	setFontStyleFromValue (const QCss::Value &value, QFont *font)
static void	setFontVariantFromValue (const QCss::Value &value, QFont *font)
static bool	setFontWeightFromValue (const QCss::Value &value, QFont *font)
static void	setTextDecorationFromValues (const QVector< QCss::Value > &values, QFont *font)
static void	setTextTransformFromValue (const QCss::Value &value, QFont *font)

Variables
static const QCssKnownValue	attachments [NumKnownAttachments - 1]
static const short	indexOfId [NumKnownValues]
static const QCssKnownValue	origins [NumKnownOrigins - 1]
static const QCssKnownValue	positions [NumKnownPositionModes - 1]
static const QCssKnownValue	properties [NumProperties - 1]
static const QCssKnownValue	pseudos [NumPseudos - 1]
static const QCssKnownValue	repeats [NumKnownRepeats - 1]
static const QCssKnownValue	styleFeatures [NumKnownStyleFeatures - 1]
static const QCssKnownValue	tileModes [NumKnownTileModes - 1]
static const QCssKnownValue	values [NumKnownValues - 1]

Function Documentation

brushFromData()

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

static

Definition at line 850 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::borderValue(), and QCss::ValueExtractor::extractBackground().

{
    if (c.type == BrushData::Role) {
        return pal.color(c.role);
    } else {
        return c.brush;
    }
}

colorFromData()

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

static

Definition at line 731 of file qcssparser.cpp.

Referenced by parseBrushValue().

{
    if (c.type == ColorData::Color) {
        return c.color;
    } else if (c.type == ColorData::Role) {
        return pal.color(c.role);
    }
    return QColor();
}

findKnownValue()

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

static

Definition at line 357 of file qcssparser.cpp.

Referenced by QCss::Declaration::attachmentValue(), QCss::Declaration::borderImageValue(), QCss::ValueExtractor::extractBackground(), QCss::Declaration::originValue(), parseColorValue(), QCss::Parser::parseProperty(), parseShorthandBackgroundProperty(), QCss::Parser::parseTerm(), QCss::Declaration::positionValue(), QCss::Declaration::repeatValue(), and QCss::Declaration::styleFeaturesValue().

{
    const QCssKnownValue *end = &start[numValues - 1];
    const QCssKnownValue *prop = qBinaryFind(start, end, name);
    if (prop == end)
        return 0;
    return prop->id;
}

intValueHelper()

static bool intValueHelper ( const QCss::Value &  v, int *  i, const char *  unit  )

static

Definition at line 1414 of file qcssparser.cpp.

Referenced by QCss::Declaration::intValue(), and QCss::Declaration::sizeValue().

{
    if (unit && v.type != Value::Length)
        return false;
    QString s = v.variant.toString();
    if (unit) {
        if (!s.endsWith(QLatin1String(unit), Qt::CaseInsensitive))
            return false;
        s.chop(qstrlen(unit));
    }
    bool ok = false;
    int val = s.toInt(&ok);
    if (ok)
        *i = val;
    return ok;
}

isHexDigit()

static bool isHexDigit ( const char  c )

inlinestatic

Definition at line 2004 of file qcssparser.cpp.

Referenced by QCss::Scanner::preprocess().

{
    return (c >= '0' && c <= '9')
           || (c >= 'a' && c <= 'f')
           || (c >= 'A' && c <= 'F')
           ;
}

lengthValueFromData()

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

static

Definition at line 393 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::borderValue(), QCss::ValueExtractor::lengthValue(), QCss::ValueExtractor::lengthValues(), and QCss::ValueExtractor::sizeValue().

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

operator<() [1/2]

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

Definition at line 347 of file qcssparser.cpp.

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

operator<() [2/2]

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

Definition at line 352 of file qcssparser.cpp.

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

parseAlignment()

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

static

Definition at line 652 of file qcssparser.cpp.

Referenced by QCss::Declaration::alignmentValue(), and parseShorthandBackgroundProperty().

{
    Qt::Alignment a[2] = { 0, 0 };
    for (int i = 0; i < qMin(2, count); i++) {
        if (values[i].type != Value::KnownIdentifier)
            break;
        switch (values[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];
}

parseBrushValue()

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

static

Definition at line 741 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::borderValue(), QCss::Declaration::brushValue(), QCss::Declaration::brushValues(), and parseShorthandBackgroundProperty().

{
    ColorData c = parseColorValue(v);
    if (c.type == ColorData::Color) {
        return QBrush(c.color);
    } else if (c.type == ColorData::Role) {
        return c.role;
    }

    if (v.type != Value::Function)
        return BrushData();

    QStringList lst = v.variant.toStringList();
    if (lst.count() != 2)
        return BrushData();

    QStringList gradFuncs;
    gradFuncs << QLatin1String("qlineargradient") << QLatin1String("qradialgradient") << QLatin1String("qconicalgradient") << QLatin1String("qgradient");
    int gradType = -1;

    if ((gradType = gradFuncs.indexOf(lst.at(0).toLower())) == -1)
        return BrushData();

    QHash<QString, qreal> vars;
    QVector<QGradientStop> stops;

    int spread = -1;
    QStringList spreads;
    spreads << QLatin1String("pad") << QLatin1String("reflect") << QLatin1String("repeat");

    bool dependsOnThePalette = false;
    Parser parser(lst.at(1));
    while (parser.hasNext()) {
        parser.skipSpace();
        if (!parser.test(IDENT))
            return BrushData();
        QString attr = parser.lexem();
        parser.skipSpace();
        if (!parser.test(COLON))
            return BrushData();
        parser.skipSpace();
        if (attr.compare(QLatin1String("stop"), Qt::CaseInsensitive) == 0) {
            QCss::Value stop, color;
            parser.next();
            if (!parser.parseTerm(&stop)) return BrushData();
            parser.skipSpace();
            parser.next();
            if (!parser.parseTerm(&color)) return BrushData();
            ColorData cd = parseColorValue(color);
            if(cd.type == ColorData::Role)
                dependsOnThePalette = true;
            stops.append(QGradientStop(stop.variant.toReal(), colorFromData(cd, pal)));
        } else {
            parser.next();
            QCss::Value value;
            (void)parser.parseTerm(&value);
            if (attr.compare(QLatin1String("spread"), Qt::CaseInsensitive) == 0) {
                spread = spreads.indexOf(value.variant.toString());
            } else {
                vars[attr] = value.variant.toReal();
            }
        }
        parser.skipSpace();
        (void)parser.test(COMMA);
    }

    if (gradType == 0) {
        QLinearGradient lg(vars.value(QLatin1String("x1")), vars.value(QLatin1String("y1")),
                           vars.value(QLatin1String("x2")), vars.value(QLatin1String("y2")));
        lg.setCoordinateMode(QGradient::ObjectBoundingMode);
        lg.setStops(stops);
        if (spread != -1)
            lg.setSpread(QGradient::Spread(spread));
        BrushData bd = QBrush(lg);
        if (dependsOnThePalette)
            bd.type = BrushData::DependsOnThePalette;
        return bd;
    }

    if (gradType == 1) {
        QRadialGradient rg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),
                           vars.value(QLatin1String("radius")), vars.value(QLatin1String("fx")),
                           vars.value(QLatin1String("fy")));
        rg.setCoordinateMode(QGradient::ObjectBoundingMode);
        rg.setStops(stops);
        if (spread != -1)
            rg.setSpread(QGradient::Spread(spread));
        BrushData bd = QBrush(rg);
        if (dependsOnThePalette)
            bd.type = BrushData::DependsOnThePalette;
        return bd;
    }

    if (gradType == 2) {
        QConicalGradient cg(vars.value(QLatin1String("cx")), vars.value(QLatin1String("cy")),
                            vars.value(QLatin1String("angle")));
        cg.setCoordinateMode(QGradient::ObjectBoundingMode);
        cg.setStops(stops);
        if (spread != -1)
            cg.setSpread(QGradient::Spread(spread));
        BrushData bd = QBrush(cg);
        if (dependsOnThePalette)
            bd.type = BrushData::DependsOnThePalette;
        return bd;
    }

    return BrushData();
}

parseColorValue()

static ColorData parseColorValue ( QCss::Value  v )

static

Definition at line 675 of file qcssparser.cpp.

Referenced by QCss::Declaration::colorValue(), QCss::Declaration::colorValues(), and parseBrushValue().

{
    if (v.type == Value::Identifier || v.type == Value::String) {
        v.variant.convert(QVariant::Color);
        v.type = Value::Color;
    }

    if (v.type == Value::Color)
        return qvariant_cast<QColor>(v.variant);

    if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_Transparent)
        return QColor(Qt::transparent);

    if (v.type != Value::Function)
        return ColorData();

    QStringList lst = v.variant.toStringList();
    if (lst.count() != 2)
        return ColorData();

    if ((lst.at(0).compare(QLatin1String("palette"), Qt::CaseInsensitive)) == 0) {
        int role = findKnownValue(lst.at(1).trimmed(), values, NumKnownValues);
        if (role >= Value_FirstColorRole && role <= Value_LastColorRole)
            return (QPalette::ColorRole)(role-Value_FirstColorRole);

        return ColorData();
    }

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

    Parser p(lst.at(1));
    if (!p.testExpr())
        return ColorData();

    QVector<QCss::Value> colorDigits;
    if (!p.parseExpr(&colorDigits))
        return ColorData();

    for (int i = 0; i < qMin(colorDigits.count(), 7); i += 2) {
        if (colorDigits.at(i).type == Value::Percentage) {
            colorDigits[i].variant = colorDigits.at(i).variant.toReal() * (255. / 100.);
            colorDigits[i].type = Value::Number;
        } else if (colorDigits.at(i).type != Value::Number) {
            return ColorData();
        }
    }

    int v1 = colorDigits.at(0).variant.toInt();
    int v2 = colorDigits.at(2).variant.toInt();
    int v3 = colorDigits.at(4).variant.toInt();
    int alpha = colorDigits.count() >= 7 ? colorDigits.at(6).variant.toInt() : 255;

    return rgb ? QColor::fromRgb(v1, v2, v3, alpha)
               : QColor::fromHsv(v1, v2, v3, alpha);
}

parseShorthandBackgroundProperty()

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

static

Definition at line 944 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractBackground().

{
    *brush = BrushData();
    *image = QString();
    *repeat = Repeat_XY;
    *alignment = Qt::AlignTop | Qt::AlignLeft;

    for (int i = 0; i < values.count(); ++i) {
        const QCss::Value &v = values.at(i);
        if (v.type == Value::Uri) {
            *image = v.variant.toString();
            continue;
        } else if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_None) {
            *image = QString();
            continue;
        } else if (v.type == Value::KnownIdentifier && v.variant.toInt() == Value_Transparent) {
            *brush = QBrush(Qt::transparent);
        }

        Repeat repeatAttempt = static_cast<Repeat>(findKnownValue(v.variant.toString(),
                                                   repeats, NumKnownRepeats));
        if (repeatAttempt != Repeat_Unknown) {
            *repeat = repeatAttempt;
            continue;
        }

        if (v.type == Value::KnownIdentifier) {
            const int start = i;
            int count = 1;
            if (i < values.count() - 1
                && values.at(i + 1).type == Value::KnownIdentifier) {
                ++i;
                ++count;
            }
            Qt::Alignment a = parseAlignment(values.constData() + start, count);
            if (int(a) != 0) {
                *alignment = a;
                continue;
            }
            i -= count - 1;
        }

        *brush = parseBrushValue(v, pal);
    }
}

parseShorthandFontProperty()

static void parseShorthandFontProperty ( const QVector< QCss::Value > &  values, QFont *  font, int *  fontSizeAdjustment  )

static

Definition at line 1168 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont().

{
    font->setStyle(QFont::StyleNormal);
    font->setWeight(QFont::Normal);
    *fontSizeAdjustment = -255;

    int i = 0;
    while (i < values.count()) {
        if (setFontStyleFromValue(values.at(i), font)
            || setFontWeightFromValue(values.at(i), font))
            ++i;
        else
            break;
    }

    if (i < values.count()) {
        setFontSizeFromValue(values.at(i), font, fontSizeAdjustment);
        ++i;
    }

    if (i < values.count()) {
        setFontFamilyFromValues(values, font, i);
    }
}

parseStyleValue()

static BorderStyle parseStyleValue ( QCss::Value  v )

static

Definition at line 859 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::borderValue(), QCss::Declaration::styleValue(), and QCss::Declaration::styleValues().

{
    if (v.type == Value::KnownIdentifier) {
        switch (v.variant.toInt()) {
        case Value_None:
            return BorderStyle_None;
        case Value_Dotted:
            return BorderStyle_Dotted;
        case Value_Dashed:
            return BorderStyle_Dashed;
        case Value_Solid:
            return BorderStyle_Solid;
        case Value_Double:
            return BorderStyle_Double;
        case Value_DotDash:
            return BorderStyle_DotDash;
        case Value_DotDotDash:
            return BorderStyle_DotDotDash;
        case Value_Groove:
            return BorderStyle_Groove;
        case Value_Ridge:
            return BorderStyle_Ridge;
        case Value_Inset:
            return BorderStyle_Inset;
        case Value_Outset:
            return BorderStyle_Outset;
        case Value_Native:
            return BorderStyle_Native;
        default:
            break;
        }
    }

    return BorderStyle_Unknown;
}

removeOptionalQuotes()

static void removeOptionalQuotes ( QString *  str )

inlinestatic

Definition at line 2179 of file qcssparser.cpp.

Referenced by QCss::Parser::parseImport(), QCss::Parser::parseTerm(), and QCss::Parser::testAndParseUri().

{
    if (!str->startsWith(QLatin1Char('\''))
        && !str->startsWith(QLatin1Char('\"')))
        return;
    str->remove(0, 1);
    str->chop(1);
}

setFontFamilyFromValues()

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

static

Warning

This function is not part of the public interface. parse the font family from the values (starting from index start) and set it the font

Returns

true if a family was extracted.

Definition at line 1124 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont(), and parseShorthandFontProperty().

{
    QString family;
    bool shouldAddSpace = false;
    for (int i = start; i < values.count(); ++i) {
        const QCss::Value &v = values.at(i);
        if (v.type == Value::TermOperatorComma) {
            family += QLatin1Char(',');
            shouldAddSpace = false;
            continue;
        }
        const QString str = v.variant.toString();
        if (str.isEmpty())
            break;
        if (shouldAddSpace)
            family += QLatin1Char(' ');
        family += str;
        shouldAddSpace = true;
    }
    if (family.isEmpty())
        return false;
    font->setFamily(family);
    return true;
}

setFontSizeFromValue()

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

static

Definition at line 1053 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont(), and parseShorthandFontProperty().

{
    if (value.type == Value::KnownIdentifier) {
        bool valid = true;
        switch (value.variant.toInt()) {
            case Value_Small: *fontSizeAdjustment = -1; break;
            case Value_Medium: *fontSizeAdjustment = 0; break;
            case Value_Large: *fontSizeAdjustment = 1; break;
            case Value_XLarge: *fontSizeAdjustment = 2; break;
            case Value_XXLarge: *fontSizeAdjustment = 3; break;
            default: valid = false; break;
        }
        return valid;
    }
    if (value.type != Value::Length)
        return false;

    bool valid = false;
    QString s = value.variant.toString();
    if (s.endsWith(QLatin1String("pt"), Qt::CaseInsensitive)) {
        s.chop(2);
        value.variant = s;
        if (value.variant.convert((QVariant::Type)qMetaTypeId<qreal>())) {
            font->setPointSizeF(value.variant.toReal());
            valid = true;
        }
    } else if (s.endsWith(QLatin1String("px"), Qt::CaseInsensitive)) {
        s.chop(2);
        value.variant = s;
        if (value.variant.convert(QVariant::Int)) {
            font->setPixelSize(value.variant.toInt());
            valid = true;
        }
    }
    return valid;
}

setFontStyleFromValue()

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

static

Definition at line 1090 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont(), and parseShorthandFontProperty().

{
    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;
}

setFontVariantFromValue()

static void setFontVariantFromValue ( const QCss::Value &  value, QFont *  font  )

static

Definition at line 1193 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont().

{
    if (value.type == Value::KnownIdentifier) {
        switch (value.variant.toInt()) {
            case Value_Normal: font->setCapitalization(QFont::MixedCase); break;
            case Value_SmallCaps: font->setCapitalization(QFont::SmallCaps); break;
            default: break;
        }
    }
}

setFontWeightFromValue()

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

static

Definition at line 1103 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont(), and parseShorthandFontProperty().

{
    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;
}

setTextDecorationFromValues()

static void setTextDecorationFromValues ( const QVector< QCss::Value > &  values, QFont *  font  )

static

Definition at line 1149 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont().

{
    for (int i = 0; i < values.count(); ++i) {
        if (values.at(i).type != Value::KnownIdentifier)
            continue;
        switch (values.at(i).variant.toInt()) {
            case Value_Underline: font->setUnderline(true); break;
            case Value_Overline: font->setOverline(true); break;
            case Value_LineThrough: font->setStrikeOut(true); break;
            case Value_None:
                font->setUnderline(false);
                font->setOverline(false);
                font->setStrikeOut(false);
                break;
            default: break;
        }
    }
}

setTextTransformFromValue()

static void setTextTransformFromValue ( const QCss::Value &  value, QFont *  font  )

static

Definition at line 1204 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractFont().

{
    if (value.type == Value::KnownIdentifier) {
        switch (value.variant.toInt()) {
            case Value_None: font->setCapitalization(QFont::MixedCase); break;
            case Value_Uppercase: font->setCapitalization(QFont::AllUppercase); break;
            case Value_Lowercase: font->setCapitalization(QFont::AllLowercase); break;
            default: break;
        }
    }
}

Variable Documentation

attachments

const QCssKnownValue attachments[NumKnownAttachments - 1]

static

Initial value:

= {
    { "fixed", Attachment_Fixed },
    { "scroll", Attachment_Scroll }
}

Definition at line 336 of file qcssparser.cpp.

Referenced by QCss::Declaration::attachmentValue().

indexOfId

const short indexOfId[NumKnownValues]

static

Initial value:

= { 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 }

Definition at line 248 of file qcssparser.cpp.

Referenced by QCss::Value::toString().

origins

const QCssKnownValue origins[NumKnownOrigins - 1]

static

Initial value:

= {
    { "border", Origin_Border },
    { "content", Origin_Content },
    { "margin", Origin_Margin }, 
    { "padding", Origin_Padding }
}

Definition at line 309 of file qcssparser.cpp.

Referenced by QCss::Declaration::originValue().

positions

const QCssKnownValue positions[NumKnownPositionModes - 1]

static

Initial value:

= {
    { "absolute", PositionMode_Absolute },
    { "fixed", PositionMode_Fixed },
    { "relative", PositionMode_Relative },
    { "static", PositionMode_Static }
}

Definition at line 329 of file qcssparser.cpp.

Referenced by QFontEngine::addOutlineToPath(), QFontEngineFT::addOutlineToPath(), QFontEngineBox::addOutlineToPath(), QFontEngineBox::boundingBox(), QProxyFontEngine::canRender(), QSplitterPrivate::collapsible(), QFontEngineMac::draw(), QFontEngineQPF::draw(), QFontEngineQPF1::draw(), draw_text_item_win(), QPaintEnginePrivate::drawBoxTextItem(), QRasterPaintEngine::drawCachedGlyphs(), QX11PaintEngine::drawFreetype(), QPainterPrivate::drawGlyphs(), QGL2PaintEngineEx::drawTextItem(), QOpenGLPaintEngine::drawTextItem(), QVGPaintEngine::drawTextItem(), QRasterPaintEngine::drawTextItem(), QPdfBaseEnginePrivate::drawTextItem(), QX11PaintEngine::drawXLFD(), QStaticTextPrivate::get(), QTextLine::glyphs(), QStaticTextPrivate::init(), QTextureGlyphCache::Coord::isNull(), QFontEngineFT::name(), QListModeViewBase::perItemScrollingPageSteps(), QCss::Declaration::positionValue(), QDeclarativeTextLayout::prepare(), QPainterReplayer::process(), QFontEngine::recalcAdvances(), QTextureGlyphCache::textureMapForGlyph(), and QVGPaintEngine::type().

properties

const QCssKnownValue properties[NumProperties - 1]

static

Definition at line 67 of file qcssparser.cpp.

Referenced by QScript::AST::ObjectLiteral::accept0(), QDeclarativeJS::AST::ObjectLiteral::accept0(), QDeclarativeAbstractAnimationPrivate::commence(), QTransportAuth::Data::connection(), QEglContext::createContext(), createContext(), QTransportAuth::Data::Data(), QDeclarativePropertyChangesPrivate::decode(), QEgl::defaultConfig(), QEgl::eglSwapBuffersRegion2NOK(), QPdfEnginePrivate::embedFont(), QPatternist::Expression::Expression(), QScript::DeclarativeObjectDelegate::getOwnPropertyNames(), QPatternist::Expression::has(), QTextFormat::isValid(), loadFontConfig(), ModelNode::object(), operator>>(), QFontconfigDatabase::populateFontDatabase(), QMetaObjectBuilder::property(), qt_egl_create_surface(), QWizardField::QWizardField(), QXcbWindow::QXcbWindow(), QMetaObjectBuilder::removeProperty(), QEglContext::setApi(), QTransportAuth::Data::setConnection(), QStyleSheetStyle::setProperties(), QMeeGoGraphicsSystem::setSurfaceFixedSize(), QTransportAuth::Data::setTrusted(), QTextEngine::shapeTextMac(), QTestLogger::stopLogging(), QFontSubset::toTruetype(), QFontSubset::toType1(), QTransportAuth::Data::trusted(), QFontSubset::type1AddedGlyphs(), and QFontSubset::widthArray().

pseudos

const QCssKnownValue pseudos[NumPseudos - 1]

static

Definition at line 262 of file qcssparser.cpp.

repeats

const QCssKnownValue repeats[NumKnownRepeats - 1]

static

Initial value:

= {
    { "no-repeat", Repeat_None },
    { "repeat-x", Repeat_X },
    { "repeat-xy", Repeat_XY },
    { "repeat-y", Repeat_Y }
}

Definition at line 316 of file qcssparser.cpp.

Referenced by QCss::ValueExtractor::extractBackground(), parseShorthandBackgroundProperty(), and QCss::Declaration::repeatValue().

styleFeatures

const QCssKnownValue styleFeatures[NumKnownStyleFeatures - 1]

static

Initial value:

= {
    { "background-color", StyleFeature_BackgroundColor },
    { "background-gradient", StyleFeature_BackgroundGradient },
    { "none", StyleFeature_None }
}

Definition at line 341 of file qcssparser.cpp.

Referenced by QCss::Declaration::styleFeaturesValue().

tileModes

const QCssKnownValue tileModes[NumKnownTileModes - 1]

static

Initial value:

= {
    { "repeat", TileMode_Repeat },
    { "round", TileMode_Round },
    { "stretch", TileMode_Stretch },
}

Definition at line 323 of file qcssparser.cpp.

Referenced by QCss::Declaration::borderImageValue().

values

const QCssKnownValue values[NumKnownValues - 1]

static

Definition at line 172 of file qcssparser.cpp.

Referenced by parseColorValue().