QCss::ValueExtractor Struct Reference

#include <qcssparser_p.h>

Public Functions
bool	extractBackground (QBrush *, QString *, Repeat *, Qt::Alignment *, QCss::Origin *, QCss::Attachment *, QCss::Origin *)
bool	extractBorder (int *borders, QBrush *colors, BorderStyle *Styles, QSize *radii)
bool	extractBox (int *margins, int *paddings, int *spacing=0)
bool	extractFont (QFont *font, int *fontSizeAdjustment)
bool	extractGeometry (int *w, int *h, int *minw, int *minh, int *maxw, int *maxh)
bool	extractImage (QIcon *icon, Qt::Alignment *a, QSize *size)
bool	extractOutline (int *borders, QBrush *colors, BorderStyle *Styles, QSize *radii, int *offsets)
bool	extractPalette (QBrush *fg, QBrush *sfg, QBrush *sbg, QBrush *abg)
bool	extractPosition (int *l, int *t, int *r, int *b, QCss::Origin *, Qt::Alignment *, QCss::PositionMode *, Qt::Alignment *)
int	extractStyleFeatures ()
int	lengthValue (const Declaration &decl)
	ValueExtractor (const QVector< Declaration > &declarations, const QPalette &=QPalette())

Private Functions
void	borderValue (const Declaration &decl, int *width, QCss::BorderStyle *style, QBrush *color)
void	extractFont ()
LengthData	lengthValue (const Value &v)
void	lengthValues (const Declaration &decl, int *m)
QSize	sizeValue (const Declaration &decl)
void	sizeValues (const Declaration &decl, QSize *radii)

Properties
int	adjustment
QVector< Declaration >	declarations
QFont	f
int	fontExtracted
QPalette	pal

Detailed Description

Definition at line 568 of file qcssparser_p.h.

Constructors and Destructors

ValueExtractor()

ValueExtractor::ValueExtractor	(	const QVector< Declaration > &	declarations,
		const QPalette &	pal = QPalette()
	)

Definition at line 368 of file qcssparser.cpp.

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

Functions

borderValue()

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

private

Definition at line 895 of file qcssparser.cpp.

Referenced by extractBorder(), and extractOutline().

{
    if (decl.d->parsed.isValid()) {
        BorderData data = qvariant_cast<BorderData>(decl.d->parsed);
        *width = lengthValueFromData(data.width, f);
        *style = data.style;
        *color = data.color.type != BrushData::Invalid ? brushFromData(data.color, pal) : QBrush(QColor());
        return;
    }

    *width = 0;
    *style = BorderStyle_None;
    *color = QColor();

    if (decl.d->values.isEmpty())
        return;
    
    BorderData data;
    data.width.number = 0;
    data.width.unit = LengthData::None;
    data.style = BorderStyle_None;

    int i = 0;
    if (decl.d->values.at(i).type == Value::Length || decl.d->values.at(i).type == Value::Number) {
        data.width = lengthValue(decl.d->values.at(i));
        *width = lengthValueFromData(data.width, f);
        if (++i >= decl.d->values.count()) {
            decl.d->parsed = QVariant::fromValue<BorderData>(data);
            return;
        }
    }

    data.style = parseStyleValue(decl.d->values.at(i));
    if (data.style != BorderStyle_Unknown) {
        *style = data.style;
        if (++i >= decl.d->values.count()) {
            decl.d->parsed = QVariant::fromValue<BorderData>(data);
            return;
        }
    } else {
        data.style = BorderStyle_None;
    }

     data.color = parseBrushValue(decl.d->values.at(i), pal);
     *color = brushFromData(data.color, pal);
     if (data.color.type != BrushData::DependsOnThePalette)
         decl.d->parsed = QVariant::fromValue<BorderData>(data);
}

extractBackground()

bool ValueExtractor::extractBackground	(	QBrush *	brush,
		QString *	image,
		Repeat *	repeat,
		Qt::Alignment *	alignment,
		QCss::Origin *	origin,
		QCss::Attachment *	attachment,
		QCss::Origin *	clip
	)

Definition at line 990 of file qcssparser.cpp.

Referenced by QTextHtmlParserNode::applyCssDeclarations(), and QRenderRule::QRenderRule().

{
    bool hit = false;
    for (int i = 0; i < declarations.count(); ++i) {
        const Declaration &decl = declarations.at(i);
        if (decl.d->values.isEmpty())
            continue;
        const QCss::Value &val = decl.d->values.at(0);
        switch (decl.d->propertyId) {
            case BackgroundColor:
                    *brush = decl.brushValue();
                break;
            case BackgroundImage:
                if (val.type == Value::Uri)
                    *image = val.variant.toString();
                break;
            case BackgroundRepeat:
                if (decl.d->parsed.isValid()) {
                    *repeat = static_cast<Repeat>(decl.d->parsed.toInt());
                } else {
                    *repeat = static_cast<Repeat>(findKnownValue(val.variant.toString(),
                                                  repeats, NumKnownRepeats));
                    decl.d->parsed = *repeat;
                }
                break;
            case BackgroundPosition:
                *alignment = decl.alignmentValue();
                break;
            case BackgroundOrigin:
                *origin = decl.originValue();
                break;
            case BackgroundClip:
                *clip = decl.originValue();
                break;
            case Background:
                if (decl.d->parsed.isValid()) {
                    BackgroundData data = qvariant_cast<BackgroundData>(decl.d->parsed);
                    *brush = brushFromData(data.brush, pal);
                    *image = data.image;
                    *repeat = data.repeat;
                    *alignment = data.alignment;
                } else {
                    BrushData brushData;
                    parseShorthandBackgroundProperty(decl.d->values, &brushData, image, repeat, alignment, pal);
                    *brush = brushFromData(brushData, pal);
                    if (brushData.type != BrushData::DependsOnThePalette) {
                        BackgroundData data = { brushData, *image, *repeat, *alignment };
                        decl.d->parsed = QVariant::fromValue<BackgroundData>(data);
                    }
                }
                break;
            case BackgroundAttachment:
                *attachment = decl.attachmentValue();
                break;
            default: continue;
        }
        hit = true;
    }
    return hit;
}

extractBorder()

bool ValueExtractor::extractBorder	(	int *	borders,
		QBrush *	colors,
		BorderStyle *	Styles,
		QSize *	radii
	)

Definition at line 559 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    extractFont();
    bool hit = false;
    for (int i = 0; i < declarations.count(); i++) {
        const Declaration &decl = declarations.at(i);
        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;
}

extractBox()

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

Definition at line 492 of file qcssparser.cpp.

Referenced by QTextHtmlParserNode::applyCssDeclarations(), and QRenderRule::QRenderRule().

{
    extractFont();
    bool hit = false;
    for (int i = 0; i < declarations.count(); i++) {
        const Declaration &decl = declarations.at(i);
        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;
}

extractFont() [1/2]

bool ValueExtractor::extractFont	(	QFont *	font,
		int *	fontSizeAdjustment
	)

Definition at line 1216 of file qcssparser.cpp.

Referenced by QTextHtmlParserNode::applyCssDeclarations(), and QRenderRule::QRenderRule().

{
    if (fontExtracted) {
        *font = f;
        *fontSizeAdjustment = adjustment;
        return fontExtracted == 1;
    }

    bool hit = false;
    for (int i = 0; i < declarations.count(); ++i) {
        const Declaration &decl = declarations.at(i);
        if (decl.d->values.isEmpty())
            continue;
        const QCss::Value &val = decl.d->values.at(0);
        switch (decl.d->propertyId) {
            case FontSize: setFontSizeFromValue(val, font, fontSizeAdjustment); break;
            case FontStyle: setFontStyleFromValue(val, font); break;
            case FontWeight: setFontWeightFromValue(val, font); break;
            case FontFamily: setFontFamilyFromValues(decl.d->values, font); break;
            case TextDecoration: setTextDecorationFromValues(decl.d->values, font); break;
            case Font: parseShorthandFontProperty(decl.d->values, font, fontSizeAdjustment); break;
            case FontVariant: setFontVariantFromValue(val, font); break;
            case TextTransform: setTextTransformFromValue(val, font); break;
            default: continue;
        }
        hit = true;
    }

    f = *font;
    adjustment = *fontSizeAdjustment;
    fontExtracted = hit ? 1 : 2;
    return hit;
}

extractFont() [2/2]

void ValueExtractor::extractFont ( )

private

Definition at line 1267 of file qcssparser.cpp.

Referenced by extractBorder(), extractBox(), extractGeometry(), extractOutline(), and extractPosition().

{
    if (fontExtracted)
        return;
    int dummy = -255;
    extractFont(&f, &dummy);
}

extractGeometry()

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

Definition at line 447 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    extractFont();
    bool hit = false;
    for (int i = 0; i < declarations.count(); i++) {
        const Declaration &decl = declarations.at(i);
        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;
}

extractImage()

bool ValueExtractor::extractImage	(	QIcon *	icon,
		Qt::Alignment *	a,
		QSize *	size
	)

Definition at line 1275 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    bool hit = false;
    for (int i = 0; i < declarations.count(); ++i) {
        const Declaration &decl = declarations.at(i);
        switch (decl.d->propertyId) {
        case QtImage:
            *icon = decl.iconValue();
            if (decl.d->values.count() > 0 && decl.d->values.at(0).type == Value::Uri) {
                // try to pull just the size from the image...
                QImageReader imageReader(decl.d->values.at(0).variant.toString());
                if ((*size = imageReader.size()).isNull()) {
                    // but we'll have to load the whole image if the
                    // format doesn't support just reading the size
                    *size = imageReader.read().size();
                }
            }
            break;
        case QtImageAlignment: *a = decl.alignmentValue();  break;
        default: continue;
        }
        hit = true;
    }
    return hit;
}

extractOutline()

bool ValueExtractor::extractOutline	(	int *	borders,
		QBrush *	colors,
		BorderStyle *	Styles,
		QSize *	radii,
		int *	offsets
	)

Definition at line 618 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    extractFont();
    bool hit = false;
    for (int i = 0; i < declarations.count(); i++) {
        const Declaration &decl = declarations.at(i);
        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;
}

extractPalette()

bool ValueExtractor::extractPalette	(	QBrush *	fg,
		QBrush *	sfg,
		QBrush *	sbg,
		QBrush *	abg
	)

Definition at line 1250 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    bool hit = false;
    for (int i = 0; i < declarations.count(); ++i) {
        const Declaration &decl = declarations.at(i);
        switch (decl.d->propertyId) {
        case Color: *fg = decl.brushValue(pal); break;
        case QtSelectionForeground: *sfg = decl.brushValue(pal); break;
        case QtSelectionBackground: *sbg = decl.brushValue(pal); break;
        case QtAlternateBackground: *abg = decl.brushValue(pal); break;
        default: continue;
        }
        hit = true;
    }
    return hit;
}

extractPosition()

bool ValueExtractor::extractPosition	(	int *	l,
		int *	t,
		int *	r,
		int *	b,
		QCss::Origin *	origin,
		Qt::Alignment *	position,
		QCss::PositionMode *	mode,
		Qt::Alignment *	textAlignment
	)

Definition at line 468 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    extractFont();
    bool hit = false;
    for (int i = 0; i < declarations.count(); i++) {
        const Declaration &decl = declarations.at(i);
        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;
}

extractStyleFeatures()

int ValueExtractor::extractStyleFeatures

(

)

Definition at line 520 of file qcssparser.cpp.

Referenced by QRenderRule::QRenderRule().

{
    int features = StyleFeature_None;
    for (int i = 0; i < declarations.count(); i++) {
        const Declaration &decl = declarations.at(i);
        if (decl.d->propertyId == QtStyleFeatures)
            features = decl.styleFeaturesValue();
    }
    return features;
}

lengthValue() [1/2]

int ValueExtractor::lengthValue

(

const Declaration &

decl

)

Definition at line 402 of file qcssparser.cpp.

Referenced by QTextHtmlParserNode::applyCssDeclarations(), borderValue(), extractBorder(), extractBox(), extractGeometry(), extractPosition(), lengthValues(), and sizeValue().

{
    if (decl.d->parsed.isValid())
        return  lengthValueFromData(qvariant_cast<LengthData>(decl.d->parsed), f);
    if (decl.d->values.count() < 1)
        return 0;
    LengthData data = lengthValue(decl.d->values.at(0));
    decl.d->parsed = QVariant::fromValue<LengthData>(data);
    return lengthValueFromData(data,f);
}

lengthValue() [2/2]

LengthData ValueExtractor::lengthValue ( const Value &  v )

private

Definition at line 373 of file qcssparser.cpp.

{
    QString s = v.variant.toString();
    s.reserve(s.length());
    LengthData data;
    data.unit = LengthData::None;
    if (s.endsWith(QLatin1String("px"), Qt::CaseInsensitive))
        data.unit = LengthData::Px;
    else if (s.endsWith(QLatin1String("ex"), Qt::CaseInsensitive))
        data.unit = LengthData::Ex;
    else if (s.endsWith(QLatin1String("em"), Qt::CaseInsensitive))
        data.unit = LengthData::Em;

    if (data.unit != LengthData::None)
        s.chop(2);

    data.number = s.toDouble();
    return data;
}

lengthValues()

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

private

Definition at line 413 of file qcssparser.cpp.

Referenced by extractBorder(), extractBox(), and extractOutline().

{
    if (decl.d->parsed.isValid()) {
        QList<QVariant> v = decl.d->parsed.toList();
        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.count(), 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;
    for (i = 0; i < 4; i++) {
        v += QVariant::fromValue<LengthData>(datas[i]);
        m[i] = lengthValueFromData(datas[i], f);
    }
    decl.d->parsed = v;
}

sizeValue()

QSize ValueExtractor::sizeValue ( const Declaration &  decl )

private

Definition at line 531 of file qcssparser.cpp.

Referenced by extractBorder(), extractOutline(), and sizeValues().

{
    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.count() > 0)
        x[0] = lengthValue(decl.d->values.at(0));
    if (decl.d->values.count() > 1)
        x[1] = lengthValue(decl.d->values.at(1));
    else
        x[1] = x[0];
    QList<QVariant> v;
    v << QVariant::fromValue<LengthData>(x[0]) << qVariantFromValue<LengthData>(x[1]);
    decl.d->parsed = v;
    return QSize(lengthValueFromData(x[0], f), lengthValueFromData(x[1], f));
}

sizeValues()

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

private

Definition at line 552 of file qcssparser.cpp.

Referenced by extractBorder(), and extractOutline().

{
    radii[0] = sizeValue(decl);
    for (int i = 1; i < 4; i++)
        radii[i] = radii[0];
}

Properties

adjustment

int QCss::ValueExtractor::adjustment

private

Definition at line 597 of file qcssparser_p.h.

Referenced by extractFont().

declarations

QVector<Declaration> QCss::ValueExtractor::declarations

private

Definition at line 595 of file qcssparser_p.h.

Referenced by extractBackground(), extractBorder(), extractBox(), extractFont(), extractGeometry(), extractImage(), extractOutline(), extractPalette(), extractPosition(), and extractStyleFeatures().

f

QFont QCss::ValueExtractor::f

private

Definition at line 596 of file qcssparser_p.h.

Referenced by borderValue(), extractFont(), lengthValue(), lengthValues(), and sizeValue().

fontExtracted

int QCss::ValueExtractor::fontExtracted

private

Definition at line 598 of file qcssparser_p.h.

Referenced by extractFont().

pal

QPalette QCss::ValueExtractor::pal

private

Definition at line 599 of file qcssparser_p.h.

Referenced by borderValue(), QCss::Declaration::brushValue(), QCss::Declaration::brushValues(), extractBackground(), extractBorder(), extractOutline(), and extractPalette().

---

The documentation for this struct was generated from the following files:

• /src/gui/text/qcssparser_p.h
• /src/gui/text/qcssparser.cpp