// Copyright (C) 2016 The Qt Company Ltd.

// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only

// Qt-Security score:critical reason:data-parser

#include "qcssparser_p.h"

#include <QtCore/qmap.h>

#include <qdebug.h>

#include <qicon.h>

#include <qcolor.h>

#include <qfont.h>

#include <qfileinfo.h>

#include <qfontmetrics.h>

#include <qbrush.h>

#include <qimagereader.h>

#include <qtextformat.h>

#include <QtCore/q20algorithm.h>

#ifndef QT_NO_CSSPARSER

QT_BEGIN_NAMESPACE

using namespace Qt::StringLiterals;

QT_IMPL_METATYPE_EXTERN_TAGGED(QCss::BackgroundData, QCss__BackgroundData)

QT_IMPL_METATYPE_EXTERN_TAGGED(QCss::LengthData, QCss__LengthData)

QT_IMPL_METATYPE_EXTERN_TAGGED(QCss::BorderData, QCss__BorderData)

#include "qcssscanner.cpp"

using namespace QCss;

struct QCssKnownValue

{

    const char name[28];

    quint64 id;

    struct ByName;

};

struct QCssKnownValue::ByName

{

    constexpr bool operator()(const QCssKnownValue &lhs, const QCssKnownValue &rhs) const noexcept

    { return std::string_view{lhs.name} < std::string_view{rhs.name}; }

};

#if !defined(Q_CC_GNU_ONLY) || Q_CC_GNU >= 1000

#  define NOT_OLD_GCCs(...) __VA_ARGS__

#else

#  define NOT_OLD_GCCs(...) /* nothing */

#endif

#define CHECK_ARRAY_IS_SORTED(array, Num) \

    static_assert(std::size(array) == Num); \

    NOT_OLD_GCCs( \

    static_assert(q20::is_sorted(std::begin(array), std::end(array), \

                                 QCssKnownValue::ByName{})); \

    ) /* NOT_OLD_GCCs */ \

    /* end */

// This array is sorted alphabetically.

static constexpr QCssKnownValue properties[] = {

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

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

    { "-qt-fg-texture-cachekey", QtForegroundTextureCacheKey },

    { "-qt-foreground", QtForeground },

    { "-qt-line-height-type", QtLineHeightType },

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

    { "-qt-list-number-prefix", QtListNumberPrefix },

    { "-qt-list-number-suffix", QtListNumberSuffix },

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

    { "-qt-stroke-color", QtStrokeColor },

    { "-qt-stroke-dasharray", QtStrokeDashArray },

    { "-qt-stroke-dashoffset", QtStrokeDashOffset },

    { "-qt-stroke-linecap", QtStrokeLineCap },

    { "-qt-stroke-linejoin", QtStrokeLineJoin },

    { "-qt-stroke-miterlimit", QtStrokeMiterLimit },

    { "-qt-stroke-width", QtStrokeWidth },

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

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

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

    { "accent-color", QtAccent },

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

    { "background", Background },

    { "background-attachment", BackgroundAttachment },

    { "background-clip", BackgroundClip },

    { "background-color", BackgroundColor },

    { "background-image", BackgroundImage },

    { "background-origin", BackgroundOrigin },

    { "background-position", BackgroundPosition },

    { "background-repeat", BackgroundRepeat },

    { "border", Border },

    { "border-bottom", BorderBottom },

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

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

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

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

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

    { "border-collapse", BorderCollapse },

    { "border-color", BorderColor },

    { "border-image", BorderImage },

    { "border-left", BorderLeft },

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

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

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

    { "border-radius", BorderRadius },

    { "border-right", BorderRight },

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

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

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

    { "border-style", BorderStyles },

    { "border-top", BorderTop },

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

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

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

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

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

    { "border-width", BorderWidth },

    { "bottom", Bottom },

    { "color", Color },

    { "float", Float },

    { "font", Font },

    { "font-family", FontFamily },

    { "font-kerning", FontKerning },

    { "font-size", FontSize },

    { "font-style", FontStyle },

    { "font-variant", FontVariant },

    { "font-weight", FontWeight },

    { "height", Height },

    { "icon", QtIcon },

    { "image", QtImage },

    { "image-position", QtImageAlignment },

    { "left", Left },

    { "letter-spacing", LetterSpacing },

    { "line-height", LineHeight },

    { "list-style", ListStyle },

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

    { "margin" , Margin },

    { "margin-bottom", MarginBottom },

    { "margin-left", MarginLeft },

    { "margin-right", MarginRight },

    { "margin-top", MarginTop },

    { "max-height", MaximumHeight },

    { "max-width", MaximumWidth },

    { "min-height", MinimumHeight },

    { "min-width", MinimumWidth },

    { "outline", Outline },

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

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

    { "outline-color", OutlineColor },

    { "outline-offset", OutlineOffset },

    { "outline-radius", OutlineRadius },

    { "outline-style", OutlineStyle },

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

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

    { "outline-width", OutlineWidth },

    { "padding", Padding },

    { "padding-bottom", PaddingBottom },

    { "padding-left", PaddingLeft },

    { "padding-right", PaddingRight },

    { "padding-top", PaddingTop },

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

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

    { "placeholder-text-color", QtPlaceHolderTextColor },

    { "position", Position },

    { "right", Right },

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

    { "selection-color", QtSelectionForeground },

    { "spacing", QtSpacing },

    { "subcontrol-origin", QtOrigin },

    { "subcontrol-position", QtPosition },

    { "text-align", TextAlignment },

    { "text-decoration", TextDecoration },

    { "text-decoration-color", TextDecorationColor },

    { "text-indent", TextIndent },

    { "text-transform", TextTransform },

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

    { "top", Top },

    { "vertical-align", VerticalAlignment },

    { "white-space", Whitespace },

    { "width", Width },

    { "word-spacing", WordSpacing }

};

CHECK_ARRAY_IS_SORTED(properties, size_t(NumProperties) - 1)

static constexpr QCssKnownValue values[] = {

    { "accent", Value_Accent },

    { "active", Value_Active },

    { "alternate-base", Value_AlternateBase },

    { "always", Value_Always },

    { "auto", Value_Auto },

    { "base", Value_Base },

    { "beveljoin", Value_BevelJoin},

    { "bold", Value_Bold },

    { "bottom", Value_Bottom },

    { "bright-text", Value_BrightText },

    { "button", Value_Button },

    { "button-text", Value_ButtonText },

    { "center", Value_Center },

    { "circle", Value_Circle },

    { "dark", Value_Dark },

    { "dashed", Value_Dashed },

    { "decimal", Value_Decimal },

    { "disabled", Value_Disabled },

    { "disc", Value_Disc },

    { "dot-dash", Value_DotDash },

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

    { "dotted", Value_Dotted },

    { "double", Value_Double },

    { "flatcap", Value_FlatCap},

    { "groove", Value_Groove },

    { "highlight", Value_Highlight },

    { "highlighted-text", Value_HighlightedText },

    { "inset", Value_Inset },

    { "italic", Value_Italic },

    { "large", Value_Large },

    { "left", Value_Left },

    { "light", Value_Light },

    { "line-through", Value_LineThrough },

    { "link", Value_Link },

    { "link-visited", Value_LinkVisited },

    { "lower-alpha", Value_LowerAlpha },

    { "lower-roman", Value_LowerRoman },

    { "lowercase", Value_Lowercase },

    { "medium", Value_Medium },

    { "mid", Value_Mid },

    { "middle", Value_Middle },

    { "midlight", Value_Midlight },

    { "miterjoin", Value_MiterJoin},

    { "native", Value_Native },

    { "no-role", Value_NoRole },

    { "none", Value_None },

    { "normal", Value_Normal },

    { "nowrap", Value_NoWrap },

    { "oblique", Value_Oblique },

    { "off", Value_Off },

    { "on", Value_On },

    { "outset", Value_Outset },

    { "overline", Value_Overline },

    { "placeholder-text", Value_PlaceholderText },

    { "pre", Value_Pre },

    { "pre-line", Value_PreLine },

    { "pre-wrap", Value_PreWrap },

    { "ridge", Value_Ridge },

    { "right", Value_Right },

    { "roundcap", Value_RoundCap},

    { "roundjoin", Value_RoundJoin},

    { "selected", Value_Selected },

    { "shadow", Value_Shadow },

    { "small" , Value_Small },

    { "small-caps", Value_SmallCaps },

    { "solid", Value_Solid },

    { "square", Value_Square },

    { "squarecap", Value_SquareCap},

    { "sub", Value_Sub },

    { "super", Value_Super },

    { "svgmiterjoin", Value_SvgMiterJoin},

    { "text", Value_Text },

    { "tooltip-base", Value_ToolTipBase },

    { "tooltip-text", Value_ToolTipText },

    { "top", Value_Top },

    { "transparent", Value_Transparent },

    { "underline", Value_Underline },

    { "upper-alpha", Value_UpperAlpha },

    { "upper-roman", Value_UpperRoman },

    { "uppercase", Value_Uppercase },

    { "wave", Value_Wave },

    { "window", Value_Window },

    { "window-text", Value_WindowText },

    { "x-large", Value_XLarge },

    { "xx-large", Value_XXLarge }

};

CHECK_ARRAY_IS_SORTED(values, size_t(NumKnownValues) - 1)

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

static constexpr uchar indexOfId[] = {

    0, 46, 54, 47, 55, 56, 63, 38, 29, 83, 84, 28, 48, 7, 76, 52,

    32, 68, 69, 30, 58, 74, 8, 12, 43, 65, 21, 15, 19, 20, 22, 24, 57, 27, 51, 80, 40, 4, 3, 45, 75, 18, 13,

    66, 16, 35, 77, 36, 78, 64, 79, 37, 67, 23, 59, 42, 6, 60, 70, 82, 10, 31, 41, 14, 39, 71, 9, 11, 5, 81,

    62, 25, 26, 33, 34, 2, 44, 72, 73, 53, 0, 17, 1, 61, 50, 49 };

static_assert(std::size(indexOfId) == size_t(NumKnownValues));

QString Value::toString() const

{

    if (type == KnownIdentifier) {

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

    } else {

        return variant.toString();

    }

}

static constexpr QCssKnownValue pseudos[] = {

    { "active", PseudoClass_Active },

    { "adjoins-item", PseudoClass_Item },

    { "alternate", PseudoClass_Alternate },

    { "bottom", PseudoClass_Bottom },

    { "checked", PseudoClass_Checked },

    { "closable", PseudoClass_Closable },

    { "closed", PseudoClass_Closed },

    { "default", PseudoClass_Default },

    { "disabled", PseudoClass_Disabled },

    { "edit-focus", PseudoClass_EditFocus },

    { "editable", PseudoClass_Editable },

    { "enabled", PseudoClass_Enabled },

    { "exclusive", PseudoClass_Exclusive },

    { "first", PseudoClass_First },

    { "flat", PseudoClass_Flat },

    { "floatable", PseudoClass_Floatable },

    { "focus", PseudoClass_Focus },

    { "has-children", PseudoClass_Children },

    { "has-siblings", PseudoClass_Sibling },

    { "horizontal", PseudoClass_Horizontal },

    { "hover", PseudoClass_Hover },

    { "indeterminate" , PseudoClass_Indeterminate },

    { "last", PseudoClass_Last },

    { "left", PseudoClass_Left },

    { "maximized", PseudoClass_Maximized },

    { "middle", PseudoClass_Middle },

    { "minimized", PseudoClass_Minimized },

    { "movable", PseudoClass_Movable },

    { "next-selected", PseudoClass_NextSelected },

    { "no-frame", PseudoClass_Frameless },

    { "non-exclusive", PseudoClass_NonExclusive },

    { "off", PseudoClass_Unchecked },

    { "on", PseudoClass_Checked },

    { "only-one", PseudoClass_OnlyOne },

    { "open", PseudoClass_Open },

    { "pressed", PseudoClass_Pressed },

    { "previous-selected", PseudoClass_PreviousSelected },

    { "read-only", PseudoClass_ReadOnly },

    { "right", PseudoClass_Right },

    { "selected", PseudoClass_Selected },

    { "top", PseudoClass_Top },

    { "unchecked" , PseudoClass_Unchecked },

    { "vertical", PseudoClass_Vertical },

    { "window", PseudoClass_Window }

};

CHECK_ARRAY_IS_SORTED(pseudos, size_t(NumPseudos) - 1)

static constexpr QCssKnownValue origins[] = {

    { "border", Origin_Border },

    { "content", Origin_Content },

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

    { "padding", Origin_Padding }

};

CHECK_ARRAY_IS_SORTED(origins, size_t(NumKnownOrigins) - 1)

static constexpr QCssKnownValue repeats[] = {

    { "no-repeat", Repeat_None },

    { "repeat-x", Repeat_X },

    { "repeat-xy", Repeat_XY },

    { "repeat-y", Repeat_Y }

};

CHECK_ARRAY_IS_SORTED(repeats, size_t(NumKnownRepeats) - 1)

static constexpr QCssKnownValue tileModes[] = {

    { "repeat", TileMode_Repeat },

    { "round", TileMode_Round },

    { "stretch", TileMode_Stretch },

};

CHECK_ARRAY_IS_SORTED(tileModes, size_t(NumKnownTileModes) - 1)

static constexpr QCssKnownValue positions[] = {

    { "absolute", PositionMode_Absolute },

    { "fixed", PositionMode_Fixed },

    { "relative", PositionMode_Relative },

    { "static", PositionMode_Static }

};

CHECK_ARRAY_IS_SORTED(positions, size_t(NumKnownPositionModes) - 1)

static constexpr QCssKnownValue attachments[] = {

    { "fixed", Attachment_Fixed },

    { "scroll", Attachment_Scroll }

};

CHECK_ARRAY_IS_SORTED(attachments, size_t(NumKnownAttachments) - 1)

static constexpr QCssKnownValue styleFeatures[] = {

    { "background-color", StyleFeature_BackgroundColor },

    { "background-gradient", StyleFeature_BackgroundGradient },

    { "none", StyleFeature_None }

};

CHECK_ARRAY_IS_SORTED(styleFeatures, size_t(NumKnownStyleFeatures) - 1)

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

{

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

}

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

{

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

}

#undef CHECK_ARRAY_IS_SORTED

#undef NOT_OLD_GCCs

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

{

    const QCssKnownValue *end = start + (numValues - 1);

    const QCssKnownValue *prop = std::lower_bound(start, end, name);

    if ((prop == end) || (name < *prop))

        return 0;

    return prop->id;

}

static inline bool isInheritable(Property propertyId)

{

    switch (propertyId) {

    case Font:

    case FontKerning:

    case FontFamily:

    case FontSize:

    case FontStyle:

    case FontWeight:

    case TextIndent:

    case Whitespace:

    case ListStyleType:

    case ListStyle:

    case TextAlignment:

    case FontVariant:

    case TextTransform:

    case LineHeight:

    case LetterSpacing:

    case WordSpacing:

        return true;

    default:

        break;

    }

    return false;

}

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

// Value Extractor

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

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

{

}

LengthData ValueExtractor::lengthValue(const Value& v)

{

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

    QStringView s(str);

    LengthData data;

    data.unit = LengthData::None;

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

        data.unit = LengthData::Px;

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

        data.unit = LengthData::Ex;

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

        data.unit = LengthData::Em;

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

        s.chop(2);

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

        data.unit = LengthData::Percent;

    data.number = s.toDouble();

    return data;

}

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

{

    const int scale = (data.unit == LengthData::Ex ? QFontMetrics(f).xHeight()

                      : data.unit == LengthData::Em ? QFontMetrics(f).height() : 1);

    // raised lower limit due to the implementation of qRound()

    return qRound(qBound(double(INT_MIN) + 0.1, scale * data.number, double(INT_MAX)));

}

QTextLength ValueExtractor::textLength(const Declaration &decl)

{

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

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

        return QTextLength(QTextLength::PercentageLength, data.number);

    return QTextLength(QTextLength::FixedLength, lengthValueFromData(data, f));

}

int ValueExtractor::lengthValue(const Declaration &decl)

{

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

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

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

        return 0;

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

    decl.d->parsed = QVariant::fromValue<LengthData>(data);

    return lengthValueFromData(data,f);

}

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

{

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

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

        Q_ASSERT(v.size() == 4);

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

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

        return;

    }

    LengthData datas[4];

    int i;

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

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

    if (i == 0) {

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

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

    } else if (i == 1) {

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

    } else if (i == 2) {

        datas[2] = datas[0];

        datas[3] = datas[1];

    } else if (i == 3) {

        datas[3] = datas[1];

    }

    QList<QVariant> v;

    v.reserve(4);

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

        v += QVariant::fromValue<LengthData>(datas[i]);

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

    }

    decl.d->parsed = v;

}

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

{

    extractFont();

    bool hit = false;

    for (const Declaration &decl : std::as_const(declarations)) {

        switch (decl.d->propertyId) {

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

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

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

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

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

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

        default: continue;

        }

        hit = true;

    }

    return hit;

}

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

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

{

    extractFont();

    bool hit = false;

    for (const Declaration &decl : std::as_const(declarations)) {

        switch (decl.d->propertyId) {

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

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

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

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

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

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

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

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

        default: continue;

        }

        hit = true;

    }

    return hit;

}

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

{

    extractFont();

    bool hit = false;

    for (const Declaration &decl : std::as_const(declarations)) {

        switch (decl.d->propertyId) {

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

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

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

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

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

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

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

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

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

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

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

        default: continue;

        }

        hit = true;

    }

    return hit;

}

int ValueExtractor::extractStyleFeatures() const

{

    int features = StyleFeature_None;

    for (const Declaration &decl : declarations) {

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

            features = decl.styleFeaturesValue();

    }

    return features;

}

QSize ValueExtractor::sizeValue(const Declaration &decl)

{

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

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

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

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

    }

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

    if (decl.d->values.size() > 0)

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

    if (decl.d->values.size() > 1)

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

    else

        x[1] = x[0];

    QList<QVariant> v;

    v << QVariant::fromValue<LengthData>(x[0]) << QVariant::fromValue<LengthData>(x[1]);

    decl.d->parsed = v;

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

}

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

{

    radii[0] = sizeValue(decl);

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

        radii[i] = radii[0];

}

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

                                   QSize *radii)

{

    extractFont();

    bool hit = false;

    for (const Declaration &decl : std::as_const(declarations)) {

        switch (decl.d->propertyId) {

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

        case BorderLeft:

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

            break;

        case BorderTop:

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

            break;

        case BorderRight:

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

            break;

        case BorderBottom:

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

            break;

        case Border:

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

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

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

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

            break;

        default: continue;

        }

        hit = true;

    }

    return hit;

}

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

                                   QSize *radii, int *offsets)

{

    extractFont();

    bool hit = false;

    for (const Declaration &decl : std::as_const(declarations)) {

        switch (decl.d->propertyId) {

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

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

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

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

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

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

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

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

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

        case Outline:

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

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

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

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

            break;

        default: continue;

        }

        hit = true;

    }

    return hit;

}

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

{

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

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

}

static ColorData parseColorValue(QCss::Value v)

{

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

        v.variant.convert(QMetaType::fromType<QColor>());

        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.size() != 2)

        return ColorData();

    const QString &identifier = lst.at(0);

    if ((identifier.compare("palette"_L1, Qt::CaseInsensitive)) == 0) {

        static_assert((Value_LastColorRole - Value_FirstColorRole + 1) == QPalette::ColorRole::NColorRoles);

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

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

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

        return ColorData();

    }

    const bool rgb = identifier.startsWith("rgb"_L1);

    const bool hsv = !rgb && identifier.startsWith("hsv"_L1);

    const bool hsl = !rgb && !hsv && identifier.startsWith("hsl"_L1);

    if (!rgb && !hsv && !hsl)

        return ColorData();

    const bool hasAlpha = identifier.size() == 4 && identifier.at(3) == u'a';

    if (identifier.size() > 3 && !hasAlpha)

        return ColorData();

    Parser p(lst.at(1));

    if (!p.testExpr())

        return ColorData();

    QList<QCss::Value> colorDigits;

    if (!p.parseExpr(&colorDigits))

        return ColorData();

    const int tokenCount = colorDigits.size();

    for (int i = 0; i < qMin(tokenCount, 7); i += 2) {

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

            const qreal maxRange = (rgb || i != 0) ? 255. : 359.;

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

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

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

            return ColorData();

        }

    }

    if (tokenCount < 5)

        return ColorData();

    if (hasAlpha && tokenCount != 7) {

        qWarning("QCssParser::parseColorValue: Specified color with alpha value but no alpha given: '%s'", qPrintable(lst.join(u' ')));

        return ColorData();

    }

    if (!hasAlpha && tokenCount != 5) {

        qWarning("QCssParser::parseColorValue: Specified color without alpha value but alpha given: '%s'", qPrintable(lst.join(u' ')));

        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 = 255;

    if (tokenCount == 7) {

        int alphaValue = colorDigits.at(6).variant.toInt();

        if (alphaValue <= 1)

            alpha = colorDigits.at(6).variant.toReal() * 255.;

        else

            alpha = alphaValue;

    }

    if (rgb)

        return QColor::fromRgb(v1, v2, v3, alpha);

    if (hsv)

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

    return QColor::fromHsl(v1, v2, v3, alpha);

}

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

{

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

        return c.color;

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

        return pal.color(c.role);

    }

    return QColor();

}

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

{

    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.size() != 2)

        return BrushData();

    QStringList gradFuncs;

    gradFuncs << "qlineargradient"_L1 << "qradialgradient"_L1 << "qconicalgradient"_L1 << "qgradient"_L1;

    int gradType = -1;

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

        return BrushData();

    QHash<QString, qreal> vars;

    QList<QGradientStop> stops;

    int spread = -1;

    QStringList spreads;

    spreads << "pad"_L1 << "reflect"_L1 << "repeat"_L1;

    int coordinateMode = -1;

    QStringList coordinateModes;

    coordinateModes << "logical"_L1 << "stretchtodevice"_L1 << "objectbounding"_L1 << "object"_L1;

    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("stop"_L1, 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("spread"_L1, Qt::CaseInsensitive) == 0)

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

            else if (attr.compare("coordinatemode"_L1, Qt::CaseInsensitive) == 0)

                coordinateMode = coordinateModes.indexOf(value.variant.toString());

            else

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

        }

        parser.skipSpace();

        (void)parser.test(COMMA);

    }

    if (gradType == 0) {

        QLinearGradient lg(vars.value("x1"_L1), vars.value("y1"_L1),

                           vars.value("x2"_L1), vars.value("y2"_L1));

        lg.setCoordinateMode(coordinateMode < 0 ? QGradient::ObjectBoundingMode : QGradient::CoordinateMode(coordinateMode));

        lg.setStops(stops);

        if (spread != -1)

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

        BrushData bd = QBrush(lg);

        if (dependsOnThePalette)

            bd.type = BrushData::DependsOnThePalette;

        return bd;

    }