QRenderRule Class Reference

Public Types
enum	{ Margin = 1, Border = 2, Padding = 4, All =Margin|Border|Padding }

Public Functions
QSize	adjustSize (const QSize &sz)
const QStyleSheetBackgroundData *	background () const
bool	baseStyleCanDraw () const
const QStyleSheetBorderData *	border () const
QPainterPath	borderClip (QRect rect)
QRect	borderRect (const QRect &r) const
const QStyleSheetBoxData *	box () const
QRect	boxRect (const QRect &r, int flags=All) const
QSize	boxSize (const QSize &s, int flags=All) const
void	configurePalette (QPalette *, QPalette::ColorGroup, const QWidget *, bool)
void	configurePalette (QPalette *p, QPalette::ColorRole fr, QPalette::ColorRole br)
QRect	contentsRect (const QRect &r) const
QSize	contentsSize () const
QSize	contentsSize (const QSize &sz) const
void	drawBackground (QPainter *, const QRect &, const QPoint &=QPoint(0, 0))
void	drawBackgroundImage (QPainter *, const QRect &, QPoint=QPoint(0, 0))
void	drawBorder (QPainter *, const QRect &)
void	drawBorderImage (QPainter *, const QRect &)
void	drawFrame (QPainter *, const QRect &)
void	drawImage (QPainter *p, const QRect &rect)
void	drawOutline (QPainter *, const QRect &)
void	drawRule (QPainter *, const QRect &)
void	fixupBorder (int)
const QStyleSheetGeometryData *	geometry () const
bool	hasBackground () const
bool	hasBorder () const
bool	hasBox () const
bool	hasContentsSize () const
bool	hasDrawable () const
bool	hasGeometry () const
bool	hasGradientBackground () const
bool	hasImage () const
bool	hasNativeBorder () const
bool	hasNativeOutline () const
bool	hasOutline () const
bool	hasPalette () const
bool	hasPosition () const
bool	hasStyleHint (const QString &sh) const
QSize	minimumContentsSize () const
QSize	minimumSize () const
QRect	originRect (const QRect &rect, Origin origin) const
const QStyleSheetOutlineData *	outline () const
QRect	outlineRect (const QRect &r) const
QRect	paddingRect (const QRect &r) const
const QStyleSheetPaletteData *	palette () const
const QStyleSheetPositionData *	position () const
	QRenderRule ()
	QRenderRule (const QVector< QCss::Declaration > &, const QWidget *)
void	setClip (QPainter *p, const QRect &rect)
QSize	size () const
QSize	size (const QSize &sz) const
QVariant	styleHint (const QString &sh) const
void	unsetClip (QPainter *)
	~QRenderRule ()

Public Variables
QSharedDataPointer< QStyleSheetBoxData >	b
QSharedDataPointer< QStyleSheetBorderData >	bd
QSharedDataPointer< QStyleSheetBackgroundData >	bg
QPainterPath	clipPath
int	clipset
QBrush	defaultBackground
int	features
QFont	font
QSharedDataPointer< QStyleSheetGeometryData >	geo
bool	hasFont
QSharedDataPointer< QStyleSheetImageData >	img
QSharedDataPointer< QStyleSheetOutlineData >	ou
QSharedDataPointer< QStyleSheetPositionData >	p
QSharedDataPointer< QStyleSheetPaletteData >	pal
QHash< QString, QVariant >	styleHints

Detailed Description

Definition at line 468 of file qstylesheetstyle.cpp.

Enumerations

anonymous enum

anonymous enum

Enumerator
Margin
Border
Padding
All

Definition at line 480 of file qstylesheetstyle.cpp.

{ Margin = 1, Border = 2, Padding = 4, All=Margin|Border|Padding };

Constructors and Destructors

QRenderRule() [1/2]

QRenderRule::QRenderRule ( )

inline

Definition at line 471 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::renderRule().

: features(0), hasFont(false), pal(0), b(0), bg(0), bd(0), ou(0), geo(0), p(0), img(0), clipset(0) { }

QRenderRule() [2/2]

QRenderRule::QRenderRule	(	const QVector< QCss::Declaration > &	declarations,
		const QWidget *	widget
	)

Definition at line 863 of file qstylesheetstyle.cpp.

: features(0), hasFont(false), pal(0), b(0), bg(0), bd(0), ou(0), geo(0), p(0), img(0), clipset(0)
{
    QPalette palette = QApplication::palette(); // ###: ideally widget's palette
    ValueExtractor v(declarations, palette);
    features = v.extractStyleFeatures();

    int w = -1, h = -1, minw = -1, minh = -1, maxw = -1, maxh = -1;
    if (v.extractGeometry(&w, &h, &minw, &minh, &maxw, &maxh))
        geo = new QStyleSheetGeometryData(w, h, minw, minh, maxw, maxh);

    int left = 0, top = 0, right = 0, bottom = 0;
    Origin origin = Origin_Unknown;
    Qt::Alignment position = 0;
    QCss::PositionMode mode = PositionMode_Unknown;
    Qt::Alignment textAlignment = 0;
    if (v.extractPosition(&left, &top, &right, &bottom, &origin, &position, &mode, &textAlignment))
        p = new QStyleSheetPositionData(left, top, right, bottom, origin, position, mode, textAlignment);

    int margins[4], paddings[4], spacing = -1;
    for (int i = 0; i < 4; i++)
        margins[i] = paddings[i] = 0;
    if (v.extractBox(margins, paddings, &spacing))
        b = new QStyleSheetBoxData(margins, paddings, spacing);

    int borders[4];
    QBrush colors[4];
    QCss::BorderStyle styles[4];
    QSize radii[4];
    for (int i = 0; i < 4; i++) {
        borders[i] = 0;
        styles[i] = BorderStyle_None;
    }
    if (v.extractBorder(borders, colors, styles, radii))
        bd = new QStyleSheetBorderData(borders, colors, styles, radii);

    int offsets[4];
    for (int i = 0; i < 4; i++) {
        borders[i] = offsets[i] = 0;
        styles[i] = BorderStyle_None;
    }
    if (v.extractOutline(borders, colors, styles, radii, offsets))
        ou = new QStyleSheetOutlineData(borders, colors, styles, radii, offsets);

    QBrush brush;
    QString uri;
    Repeat repeat = Repeat_XY;
    Qt::Alignment alignment = Qt::AlignTop | Qt::AlignLeft;
    Attachment attachment = Attachment_Scroll;
    origin = Origin_Padding;
    Origin clip = Origin_Border;
    if (v.extractBackground(&brush, &uri, &repeat, &alignment, &origin, &attachment, &clip))
        bg = new QStyleSheetBackgroundData(brush, QPixmap(uri), repeat, alignment, origin, attachment, clip);

    QBrush sfg, fg;
    QBrush sbg, abg;
    if (v.extractPalette(&fg, &sfg, &sbg, &abg))
        pal = new QStyleSheetPaletteData(fg, sfg, sbg, abg);

    QIcon icon;
    alignment = Qt::AlignCenter;
    QSize size;
    if (v.extractImage(&icon, &alignment, &size))
        img = new QStyleSheetImageData(icon, alignment, size);

    int adj = -255;
    hasFont = v.extractFont(&font, &adj);

#ifndef QT_NO_TOOLTIP
    if (widget && qstrcmp(widget->metaObject()->className(), "QTipLabel") == 0)
        palette = QToolTip::palette();
#endif

    for (int i = 0; i < declarations.count(); i++) {
        const Declaration& decl = declarations.at(i);
        if (decl.d->propertyId == BorderImage) {
            QString uri;
            QCss::TileMode horizStretch, vertStretch;
            int cuts[4];

            decl.borderImageValue(&uri, cuts, &horizStretch, &vertStretch);
            if (uri.isEmpty() || uri == QLatin1String("none")) {
                if (bd && bd->bi)
                    bd->bi->pixmap = QPixmap();
            } else {
                if (!bd)
                    bd = new QStyleSheetBorderData;
                if (!bd->bi)
                    bd->bi = new QStyleSheetBorderImageData;

                QStyleSheetBorderImageData *bi = bd->bi;
                bi->pixmap = QPixmap(uri);
                for (int i = 0; i < 4; i++)
                    bi->cuts[i] = cuts[i];
                bi->horizStretch = horizStretch;
                bi->vertStretch = vertStretch;
            }
        } else if (decl.d->propertyId == QtBackgroundRole) {
            if (bg && bg->brush.style() != Qt::NoBrush)
                continue;
            int role = decl.d->values.at(0).variant.toInt();
            if (role >= Value_FirstColorRole && role <= Value_LastColorRole)
                defaultBackground = palette.color((QPalette::ColorRole)(role-Value_FirstColorRole));
        } else if (decl.d->property.startsWith(QLatin1String("qproperty-"), Qt::CaseInsensitive)) {
            // intentionally left blank...
        } else if (decl.d->propertyId == UnknownProperty) {
            bool knownStyleHint = false;
            for (int i = 0; i < numKnownStyleHints; i++) {
                QLatin1String styleHint(knownStyleHints[i]);
                if (decl.d->property.compare(styleHint) == 0) {
                   QString hintName = QString(styleHint);
                   QVariant hintValue;
                   if (hintName.endsWith(QLatin1String("alignment"))) {
                       hintValue = (int) decl.alignmentValue();
                   } else if (hintName.endsWith(QLatin1String("color"))) {
                       hintValue = (int) decl.colorValue().rgba();
                   } else if (hintName.endsWith(QLatin1String("size"))) {
                       hintValue = decl.sizeValue();
                   } else if (hintName.endsWith(QLatin1String("icon"))) {
                       hintValue = decl.iconValue();
                   } else if (hintName == QLatin1String("button-layout")
                              && decl.d->values.count() != 0 && decl.d->values.at(0).type == Value::String) {
                       hintValue = subControlLayout(decl.d->values.at(0).variant.toString());
                   } else {
                       int integer;
                       decl.intValue(&integer);
                       hintValue = integer;
                   }
                   styleHints[decl.d->property] = hintValue;
                   knownStyleHint = true;
                   break;
                }
            }
            if (!knownStyleHint)
                qDebug("Unknown property %s", qPrintable(decl.d->property));
        }
    }

    if (widget) {
        QStyleSheetStyle *style = const_cast<QStyleSheetStyle *>(globalStyleSheetStyle);
        if (!style)
           style = qobject_cast<QStyleSheetStyle *>(widget->style());
        if (style)
            fixupBorder(style->nativeFrameWidth(widget));

    }
    if (hasBorder() && border()->hasBorderImage())
        defaultBackground = QBrush();
}

~QRenderRule()

QRenderRule::~QRenderRule ( )

inline

Definition at line 473 of file qstylesheetstyle.cpp.

{ }

Functions

adjustSize()

QSize QRenderRule::adjustSize ( const QSize &  sz )

inline

Definition at line 558 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::sizeFromContents().

    {
        if (!geo)
            return sz;
        QSize csz = contentsSize();
        if (csz.width() == -1) csz.setWidth(sz.width());
        if (csz.height() == -1) csz.setHeight(sz.height());
        if (geo->maxWidth != -1 && csz.width() > geo->maxWidth) csz.setWidth(geo->maxWidth);
        if (geo->maxHeight != -1 && csz.height() > geo->maxHeight) csz.setHeight(geo->maxHeight);
        csz=csz.expandedTo(QSize(geo->minWidth, geo->minHeight));
        return csz;
    }

background()

const QStyleSheetBackgroundData* QRenderRule::background ( ) const

inline

Definition at line 499 of file qstylesheetstyle.cpp.

Referenced by configurePalette(), drawBackground(), drawBackgroundImage(), QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), and QStyleSheetStyle::polish().

{ return bg; }

baseStyleCanDraw()

bool QRenderRule::baseStyleCanDraw ( ) const

inline

Definition at line 520 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), QStyleSheetStyle::drawPrimitive(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

                                  {
        if (!hasBackground() || (background()->brush.style() == Qt::NoBrush && bg->pixmap.isNull()))
            return true;
        if (bg && !bg->pixmap.isNull())
            return false;
        if (hasGradientBackground())
            return features & StyleFeature_BackgroundGradient;
        return features & StyleFeature_BackgroundColor;
    }

border()

const QStyleSheetBorderData* QRenderRule::border ( ) const

inline

Definition at line 500 of file qstylesheetstyle.cpp.

Referenced by borderClip(), boxRect(), configurePalette(), drawBorder(), drawBorderImage(), fixupBorder(), paddingRect(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::polish(), QRenderRule(), and QStyleSheetStyle::styleHint().

{ return bd; }

borderClip()

QPainterPath QRenderRule::borderClip

(

QRect

rect

)

Definition at line 1237 of file qstylesheetstyle.cpp.

Referenced by drawBackground(), and setClip().

{
    if (!hasBorder())
        return QPainterPath();

    QSize tlr, trr, blr, brr;
    qNormalizeRadii(r, bd->radii, &tlr, &trr, &blr, &brr);
    if (tlr.isNull() && trr.isNull() && blr.isNull() && brr.isNull())
        return QPainterPath();

    const QRectF rect(r);
    const int *borders = border()->borders;
    QPainterPath path;
    qreal curY = rect.y() + borders[TopEdge]/qreal(2.0);
    path.moveTo(rect.x() + tlr.width(), curY);
    path.lineTo(rect.right() - trr.width(), curY);
    qreal curX = rect.right() - borders[RightEdge]/qreal(2.0);
    path.arcTo(curX - 2*trr.width() + borders[RightEdge], curY,
               trr.width()*2 - borders[RightEdge], trr.height()*2 - borders[TopEdge], 90, -90);

    path.lineTo(curX, rect.bottom() - brr.height());
    curY = rect.bottom() - borders[BottomEdge]/qreal(2.0);
    path.arcTo(curX - 2*brr.width() + borders[RightEdge], curY - 2*brr.height() + borders[BottomEdge],
               brr.width()*2 - borders[RightEdge], brr.height()*2 - borders[BottomEdge], 0, -90);

    path.lineTo(rect.x() + blr.width(), curY);
    curX = rect.left() + borders[LeftEdge]/qreal(2.0);
    path.arcTo(curX, rect.bottom() - 2*blr.height() + borders[BottomEdge]/2,
               blr.width()*2 - borders[LeftEdge], blr.height()*2 - borders[BottomEdge], 270, -90);

    path.lineTo(curX, rect.top() + tlr.height());
    path.arcTo(curX, rect.top() + borders[TopEdge]/2,
               tlr.width()*2 - borders[LeftEdge], tlr.height()*2 - borders[TopEdge], 180, -90);

    path.closeSubpath();
    return path;
}

borderRect()

QRect QRenderRule::borderRect

(

const QRect &

r

)

const

Definition at line 1013 of file qstylesheetstyle.cpp.

Referenced by drawBackgroundImage(), QStyleSheetStyle::drawControl(), drawFrame(), originRect(), outlineRect(), paddingRect(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

{
    if (!hasBox())
        return r;
    const int* m = box()->margins;
    return r.adjusted(m[LeftEdge], m[TopEdge], -m[RightEdge], -m[BottomEdge]);
}

box()

const QStyleSheetBoxData* QRenderRule::box ( ) const

inline

Definition at line 498 of file qstylesheetstyle.cpp.

Referenced by borderRect(), boxRect(), contentsRect(), and QStyleSheetStyle::pixelMetric().

{ return b; }

boxRect()

QRect QRenderRule::boxRect	(	const QRect &	r,
		int	flags = All
	)		const

Definition at line 1048 of file qstylesheetstyle.cpp.

Referenced by boxSize(), and QStyleSheetStyle::drawComplexControl().

{
    QRect r = cr;
    if (hasBox()) {
        if (flags & Margin) {
            const int *m = box()->margins;
            r.adjust(-m[LeftEdge], -m[TopEdge], m[RightEdge], m[BottomEdge]);
        }
        if (flags & Padding) {
            const int *p = box()->paddings;
            r.adjust(-p[LeftEdge], -p[TopEdge], p[RightEdge], p[BottomEdge]);
        }
    }
    if (hasBorder() && (flags & Border)) {
        const int *b = border()->borders;
        r.adjust(-b[LeftEdge], -b[TopEdge], b[RightEdge], b[BottomEdge]);
    }
    return r;
}

boxSize()

QSize QRenderRule::boxSize	(	const QSize &	s,
		int	flags = All
	)		const

Definition at line 1068 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::setGeometry(), and QStyleSheetStyle::sizeFromContents().

{
    QSize bs = boxRect(QRect(QPoint(0, 0), cs), flags).size();
    if (cs.width() < 0) bs.setWidth(-1);
    if (cs.height() < 0) bs.setHeight(-1);
    return bs;
}

configurePalette() [1/2]

void QRenderRule::configurePalette	(	QPalette *	p,
		QPalette::ColorGroup	cg,
		const QWidget *	w,
		bool	embedded
	)

Definition at line 1373 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::drawPrimitive(), QStyleSheetStyle::setPalette(), and QStyleSheetStyle::styleSheetPalette().

{
    if (bg && bg->brush.style() != Qt::NoBrush) {
        p->setBrush(cg, QPalette::Base, bg->brush); // for windows, windowxp
        p->setBrush(cg, QPalette::Button, bg->brush); // for plastique
        p->setBrush(cg, w->backgroundRole(), bg->brush);
        p->setBrush(cg, QPalette::Window, bg->brush);
    }

    if (embedded) {
        /* For embedded widgets (ComboBox, SpinBox and ScrollArea) we want the embedded widget
         * to be transparent when we have a transparent background or border image */
        if ((hasBackground() && background()->isTransparent())
            || (hasBorder() && border()->hasBorderImage() && !border()->borderImage()->pixmap.isNull()))
            p->setBrush(cg, w->backgroundRole(), Qt::NoBrush);
    }

    if (!hasPalette())
        return;

    if (pal->foreground.style() != Qt::NoBrush) {
        p->setBrush(cg, QPalette::ButtonText, pal->foreground);
        p->setBrush(cg, w->foregroundRole(), pal->foreground);
        p->setBrush(cg, QPalette::WindowText, pal->foreground);
        p->setBrush(cg, QPalette::Text, pal->foreground);
    }
    if (pal->selectionBackground.style() != Qt::NoBrush)
        p->setBrush(cg, QPalette::Highlight, pal->selectionBackground);
    if (pal->selectionForeground.style() != Qt::NoBrush)
        p->setBrush(cg, QPalette::HighlightedText, pal->selectionForeground);
    if (pal->alternateBackground.style() != Qt::NoBrush)
        p->setBrush(cg, QPalette::AlternateBase, pal->alternateBackground);
}

configurePalette() [2/2]

void QRenderRule::configurePalette	(	QPalette *	p,
		QPalette::ColorRole	fr,
		QPalette::ColorRole	br
	)

Definition at line 1342 of file qstylesheetstyle.cpp.

{
    if (bg && bg->brush.style() != Qt::NoBrush) {
        if (br != QPalette::NoRole)
            p->setBrush(br, bg->brush);
        p->setBrush(QPalette::Window, bg->brush);
        if (bg->brush.style() == Qt::SolidPattern) {
            p->setBrush(QPalette::Light, bg->brush.color().lighter(115));
            p->setBrush(QPalette::Midlight, bg->brush.color().lighter(107));
            p->setBrush(QPalette::Dark, bg->brush.color().darker(150));
            p->setBrush(QPalette::Shadow, bg->brush.color().darker(300));
        }
    }

    if (!hasPalette())
        return;

    if (pal->foreground.style() != Qt::NoBrush) {
        if (fr != QPalette::NoRole)
            p->setBrush(fr, pal->foreground);
        p->setBrush(QPalette::WindowText, pal->foreground);
        p->setBrush(QPalette::Text, pal->foreground);
    }
    if (pal->selectionBackground.style() != Qt::NoBrush)
        p->setBrush(QPalette::Highlight, pal->selectionBackground);
    if (pal->selectionForeground.style() != Qt::NoBrush)
        p->setBrush(QPalette::HighlightedText, pal->selectionForeground);
    if (pal->alternateBackground.style() != Qt::NoBrush)
        p->setBrush(QPalette::AlternateBase, pal->alternateBackground);
}

contentsRect()

QRect QRenderRule::contentsRect

(

const QRect &

r

)

const

Definition at line 1039 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), drawRule(), originRect(), QStyleSheetStyle::subControlRect(), QStyleSheetStyle::subElementRect(), and QStyleSheetStyle::titleBarLayout().

{
    QRect pr = paddingRect(r);
    if (!hasBox())
        return pr;
    const int *p = box()->paddings;
    return pr.adjusted(p[LeftEdge], p[TopEdge], -p[RightEdge], -p[BottomEdge]);
}

contentsSize() [1/2]

QSize QRenderRule::contentsSize ( ) const

inline

Definition at line 543 of file qstylesheetstyle.cpp.

    { return geo ? QSize(geo->width, geo->height)
                 : ((img && img->size.isValid()) ? img->size : QSize()); }

contentsSize() [2/2]

QSize QRenderRule::contentsSize ( const QSize &  sz ) const

inline

Definition at line 546 of file qstylesheetstyle.cpp.

    {
        QSize csz = contentsSize();
        if (csz.width() == -1) csz.setWidth(sz.width());
        if (csz.height() == -1) csz.setHeight(sz.height());
        return csz;
    }

drawBackground()

void QRenderRule::drawBackground	(	QPainter *	p,
		const QRect &	rect,
		const QPoint &	off = QPoint(0, 0)
	)

Definition at line 1297 of file qstylesheetstyle.cpp.

Referenced by drawFrame(), and QStyleSheetStyle::drawPrimitive().

{
    QBrush brush = hasBackground() ? background()->brush : QBrush();
    if (brush.style() == Qt::NoBrush)
        brush = defaultBackground;

    if (brush.style() != Qt::NoBrush) {
        Origin origin = hasBackground() ? background()->clip : Origin_Border;
        // ### fix for  gradients
        const QPainterPath &borderPath = borderClip(originRect(rect, origin));
        if (!borderPath.isEmpty()) {
            // Drawn intead of being used as clipping path for better visual quality
            bool wasAntialiased = p->renderHints() & QPainter::Antialiasing;
            p->setRenderHint(QPainter::Antialiasing);
            p->fillPath(borderPath, brush);
            p->setRenderHint(QPainter::Antialiasing, wasAntialiased);
        } else {
            p->fillRect(originRect(rect, origin), brush);
        }
    }

    drawBackgroundImage(p, rect, off);
}

drawBackgroundImage()

void QRenderRule::drawBackgroundImage	(	QPainter *	p,
		const QRect &	rect,
		QPoint	off = QPoint(0, 0)
	)

Definition at line 1157 of file qstylesheetstyle.cpp.

Referenced by drawBackground().

{
    if (!hasBackground())
        return;

    const QPixmap& bgp = background()->pixmap;
    if (bgp.isNull())
        return;

    setClip(p, borderRect(rect));

    if (background()->origin != background()->clip) {
        p->save();
        p->setClipRect(originRect(rect, background()->clip), Qt::IntersectClip);
    }

    if (background()->attachment == Attachment_Fixed)
        off = QPoint(0, 0);

    QRect r = originRect(rect, background()->origin);
    QRect aligned = QStyle::alignedRect(Qt::LeftToRight, background()->position, bgp.size(), r);
    QRect inter = aligned.translated(-off).intersected(r);

    switch (background()->repeat) {
    case Repeat_Y:
        p->drawTiledPixmap(inter.x(), r.y(), inter.width(), r.height(), bgp,
                           inter.x() - aligned.x() + off.x(),
                           bgp.height() - int(aligned.y() - r.y()) % bgp.height() + off.y());
        break;
    case Repeat_X:
        p->drawTiledPixmap(r.x(), inter.y(), r.width(), inter.height(), bgp,
                           bgp.width() - int(aligned.x() - r.x())%bgp.width() + off.x(),
                           inter.y() - aligned.y() + off.y());
        break;
    case Repeat_XY:
        p->drawTiledPixmap(r, bgp,
                           QPoint(bgp.width() - int(aligned.x() - r.x())% bgp.width() + off.x(),
                                  bgp.height() - int(aligned.y() - r.y())%bgp.height() + off.y()));
        break;
    case Repeat_None:
    default:
        p->drawPixmap(inter.x(), inter.y(), bgp, inter.x() - aligned.x() + off.x(),
                      inter.y() - aligned.y() + off.y(), inter.width(), inter.height());
        break;
    }


    if (background()->origin != background()->clip)
        p->restore();

    unsetClip(p);
}

drawBorder()

void QRenderRule::drawBorder	(	QPainter *	p,
		const QRect &	rect
	)

Definition at line 1221 of file qstylesheetstyle.cpp.

Referenced by drawFrame().

{
    if (!hasBorder())
        return;

    if (border()->hasBorderImage()) {
        drawBorderImage(p, rect);
        return;
    }

    bool wasAntialiased = p->renderHints() & QPainter::Antialiasing;
    p->setRenderHint(QPainter::Antialiasing);
    qDrawBorder(p, rect, bd->styles, bd->borders, bd->colors, bd->radii);
    p->setRenderHint(QPainter::Antialiasing, wasAntialiased);
}

drawBorderImage()

void QRenderRule::drawBorderImage	(	QPainter *	p,
		const QRect &	rect
	)

Definition at line 1119 of file qstylesheetstyle.cpp.

Referenced by drawBorder().

{
    setClip(p, rect);
    static const Qt::TileRule tileMode2TileRule[] = {
        Qt::StretchTile, Qt::RoundTile, Qt::StretchTile, Qt::RepeatTile, Qt::StretchTile };

    const QStyleSheetBorderImageData *borderImageData = border()->borderImage();
    const int *targetBorders = border()->borders;
    const int *sourceBorders = borderImageData->cuts;
    QMargins sourceMargins(sourceBorders[LeftEdge], sourceBorders[TopEdge],
                           sourceBorders[RightEdge], sourceBorders[BottomEdge]);
    QMargins targetMargins(targetBorders[LeftEdge], targetBorders[TopEdge],
                           targetBorders[RightEdge], targetBorders[BottomEdge]);

    bool wasSmoothPixmapTransform = p->renderHints() & QPainter::SmoothPixmapTransform;
    p->setRenderHint(QPainter::SmoothPixmapTransform);
    qDrawBorderPixmap(p, rect, targetMargins, borderImageData->pixmap,
                      QRect(QPoint(), borderImageData->pixmap.size()), sourceMargins,
                      QTileRules(tileMode2TileRule[borderImageData->horizStretch], tileMode2TileRule[borderImageData->vertStretch]));
    p->setRenderHint(QPainter::SmoothPixmapTransform, wasSmoothPixmapTransform);
    unsetClip(p);
}

drawFrame()

void QRenderRule::drawFrame	(	QPainter *	p,
		const QRect &	rect
	)

Definition at line 1321 of file qstylesheetstyle.cpp.

Referenced by drawRule().

{
    drawBackground(p, rect);
    if (hasBorder())
        drawBorder(p, borderRect(rect));
}

drawImage()

void QRenderRule::drawImage	(	QPainter *	p,
		const QRect &	rect
	)

Definition at line 1328 of file qstylesheetstyle.cpp.

Referenced by drawRule().

{
    if (!hasImage())
        return;
    img->icon.paint(p, rect, img->alignment);
}

drawOutline()

void QRenderRule::drawOutline	(	QPainter *	p,
		const QRect &	rect
	)

Definition at line 1210 of file qstylesheetstyle.cpp.

{
    if (!hasOutline())
        return;

    bool wasAntialiased = p->renderHints() & QPainter::Antialiasing;
    p->setRenderHint(QPainter::Antialiasing);
    qDrawBorder(p, rect, ou->styles, ou->borders, ou->colors, ou->radii);
    p->setRenderHint(QPainter::Antialiasing, wasAntialiased);
}

drawRule()

void QRenderRule::drawRule	(	QPainter *	p,
		const QRect &	rect
	)

Definition at line 1335 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), and QStyleSheetStyle::drawPrimitive().

{
    drawFrame(p, rect);
    drawImage(p, contentsRect(rect));
}

fixupBorder()

void QRenderRule::fixupBorder

(

int

nativeWidth

)

Definition at line 1076 of file qstylesheetstyle.cpp.

Referenced by QRenderRule().

{
    if (bd == 0)
        return;

    if (!bd->hasBorderImage() || bd->bi->pixmap.isNull()) {
        bd->bi = 0;
        // ignore the color, border of edges that have none border-style
        QBrush color = pal ? pal->foreground : QBrush();
        const bool hasRadius = bd->radii[0].isValid() || bd->radii[1].isValid()
                               || bd->radii[2].isValid() || bd->radii[3].isValid();
        for (int i = 0; i < 4; i++) {
            if ((bd->styles[i] == BorderStyle_Native) && hasRadius)
                bd->styles[i] = BorderStyle_None;

            switch (bd->styles[i]) {
            case BorderStyle_None:
                // border-style: none forces width to be 0
                bd->colors[i] = QBrush();
                bd->borders[i] = 0;
                break;
            case BorderStyle_Native:
                if (bd->borders[i] == 0)
                    bd->borders[i] = nativeWidth;
                // intentional fall through
            default:
                if (!bd->colors[i].style() != Qt::NoBrush) // auto-acquire 'color'
                    bd->colors[i] = color;
                break;
            }
        }

        return;
    }

    // inspect the border image
    QStyleSheetBorderImageData *bi = bd->bi;
    if (bi->cuts[0] == -1) {
        for (int i = 0; i < 4; i++) // assume, cut = border
            bi->cuts[i] = int(border()->borders[i]);
    }
}

geometry()

const QStyleSheetGeometryData* QRenderRule::geometry ( ) const

inline

Definition at line 502 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::setGeometry().

{ return geo; }

hasBackground()

bool QRenderRule::hasBackground ( ) const

inline

Definition at line 506 of file qstylesheetstyle.cpp.

Referenced by configurePalette(), drawBackground(), drawBackgroundImage(), QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::drawPrimitive(), and QStyleSheetStyle::polish().

{ return bg != 0 && (!bg->pixmap.isNull() || bg->brush.style() != Qt::NoBrush); }

hasBorder()

bool QRenderRule::hasBorder ( ) const

inline

Definition at line 531 of file qstylesheetstyle.cpp.

Referenced by borderClip(), boxRect(), configurePalette(), drawBorder(), QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), drawFrame(), QStyleSheetStyle::hitTestComplexControl(), paddingRect(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::polish(), QRenderRule(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::styleHint(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

{ return bd != 0; }

hasBox()

bool QRenderRule::hasBox ( ) const

inline

Definition at line 530 of file qstylesheetstyle.cpp.

Referenced by borderRect(), boxRect(), contentsRect(), QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::hitTestComplexControl(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::polish(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::styleHint(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

{ return b != 0; }

hasContentsSize()

bool QRenderRule::hasContentsSize ( ) const

inline

Definition at line 553 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::positionRect(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

    { return (geo && (geo->width != -1 || geo->height != -1)) || (img && img->size.isValid()); }

hasDrawable()

bool QRenderRule::hasDrawable ( ) const

inline

Definition at line 535 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::drawPrimitive(), QStyleSheetStyle::hitTestComplexControl(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::polish(), QStyleSheetStyle::styleHint(), and QStyleSheetStyle::subControlRect().

{ return !hasNativeBorder() || hasBackground() || hasImage(); }

hasGeometry()

bool QRenderRule::hasGeometry ( ) const

inline

Definition at line 534 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::setGeometry(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

{ return geo != 0; }

hasGradientBackground()

bool QRenderRule::hasGradientBackground ( ) const

inline

Definition at line 507 of file qstylesheetstyle.cpp.

                                       { return bg && bg->brush.style() >= Qt::LinearGradientPattern
                                                   && bg->brush.style() <= Qt::ConicalGradientPattern; }

hasImage()

bool QRenderRule::hasImage ( ) const

inline

Definition at line 536 of file qstylesheetstyle.cpp.

Referenced by drawImage().

{ return img != 0; }

hasNativeBorder()

bool QRenderRule::hasNativeBorder ( ) const

inline

Definition at line 510 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), QStyleSheetStyle::drawPrimitive(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::polish(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::styleHint(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

                                 {
        return bd == 0
               || (!bd->hasBorderImage() && bd->styles[0] == BorderStyle_Native);
    }

hasNativeOutline()

bool QRenderRule::hasNativeOutline ( ) const

inline

Definition at line 515 of file qstylesheetstyle.cpp.

                                  {
        return (ou == 0
                || (!ou->hasBorderImage() && ou->styles[0] == BorderStyle_Native));
    }

hasOutline()

bool QRenderRule::hasOutline ( ) const

inline

Definition at line 532 of file qstylesheetstyle.cpp.

Referenced by drawOutline(), and outlineRect().

{ return ou != 0; }

hasPalette()

bool QRenderRule::hasPalette ( ) const

inline

Definition at line 505 of file qstylesheetstyle.cpp.

Referenced by configurePalette(), QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::styleHint(), and QStyleSheetStyle::styleSheetPalette().

{ return pal != 0; }

hasPosition()

bool QRenderRule::hasPosition ( ) const

inline

Definition at line 533 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::styleHint(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

{ return p != 0; }

hasStyleHint()

bool QRenderRule::hasStyleHint ( const QString &  sh ) const

inline

Definition at line 577 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::standardIconImplementation(), QStyleSheetStyle::standardPixmap(), and QStyleSheetStyle::styleHint().

{ return styleHints.contains(sh); }

minimumContentsSize()

QSize QRenderRule::minimumContentsSize ( ) const

inline

Definition at line 538 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::pixelMetric(), and QStyleSheetStyle::positionRect().

    { return geo ? QSize(geo->minWidth, geo->minHeight) : QSize(0, 0); }

minimumSize()

QSize QRenderRule::minimumSize ( ) const

inline

Definition at line 540 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::pixelMetric().

    { return boxSize(minimumContentsSize()); }

originRect()

QRect QRenderRule::originRect	(	const QRect &	rect,
		Origin	origin
	)		const

Definition at line 1142 of file qstylesheetstyle.cpp.

Referenced by drawBackground(), drawBackgroundImage(), QStyleSheetStyle::positionRect(), and QStyleSheetStyle::subControlRect().

{
    switch (origin) {
    case Origin_Padding:
        return paddingRect(rect);
    case Origin_Border:
        return borderRect(rect);
    case Origin_Content:
        return contentsRect(rect);
    case Origin_Margin:
    default:
        return rect;
    }
}

outline()

const QStyleSheetOutlineData* QRenderRule::outline ( ) const

inline

Definition at line 501 of file qstylesheetstyle.cpp.

Referenced by outlineRect().

{ return ou; }

outlineRect()

QRect QRenderRule::outlineRect

(

const QRect &

r

)

const

Definition at line 1021 of file qstylesheetstyle.cpp.

{
    QRect br = borderRect(r);
    if (!hasOutline())
        return br;
    const int *b = outline()->borders;
    return r.adjusted(b[LeftEdge], b[TopEdge], -b[RightEdge], -b[BottomEdge]);
}

paddingRect()

QRect QRenderRule::paddingRect

(

const QRect &

r

)

const

Definition at line 1030 of file qstylesheetstyle.cpp.

Referenced by contentsRect(), and originRect().

{
    QRect br = borderRect(r);
    if (!hasBorder())
        return br;
    const int *b = border()->borders;
    return br.adjusted(b[LeftEdge], b[TopEdge], -b[RightEdge], -b[BottomEdge]);
}

palette()

const QStyleSheetPaletteData* QRenderRule::palette ( ) const

inline

Definition at line 497 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawComplexControl(), QRenderRule(), and QStyleSheetStyle::styleHint().

{ return pal; }

position()

const QStyleSheetPositionData* QRenderRule::position ( ) const

inline

Definition at line 503 of file qstylesheetstyle.cpp.

Referenced by drawBackgroundImage(), QStyleSheetStyle::drawControl(), QStyleSheetStyle::positionRect(), QRenderRule(), QStyleSheetStyle::styleHint(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::subElementRect().

{ return p; }

setClip()

void QRenderRule::setClip	(	QPainter *	p,
		const QRect &	rect
	)

Warning

This function is not part of the public interface. Clip the painter to the border (in case we are using radius border)

Definition at line 1278 of file qstylesheetstyle.cpp.

Referenced by drawBackgroundImage(), and drawBorderImage().

{
    if (clipset++)
        return;
    clipPath = borderClip(rect);
    if (!clipPath.isEmpty()) {
        p->save();
        p->setClipPath(clipPath, Qt::IntersectClip);
    }
}

size() [1/2]

QSize QRenderRule::size ( ) const

inline

Definition at line 556 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), QStyleSheetStyle::pixelMetric(), QStyleSheetStyle::positionRect(), QRenderRule(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::subControlRect(), QStyleSheetStyle::subElementRect(), and QStyleSheetStyle::titleBarLayout().

{ return boxSize(contentsSize()); }

size() [2/2]

QSize QRenderRule::size ( const QSize &  sz ) const

inline

Definition at line 557 of file qstylesheetstyle.cpp.

{ return boxSize(contentsSize(sz)); }

styleHint()

QVariant QRenderRule::styleHint ( const QString &  sh ) const

inline

Definition at line 578 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::pixelMetric(), QRenderRule(), QStyleSheetStyle::sizeFromContents(), QStyleSheetStyle::standardIconImplementation(), QStyleSheetStyle::standardPixmap(), QStyleSheetStyle::styleHint(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::titleBarLayout().

{ return styleHints.value(sh); }

unsetClip()

void QRenderRule::unsetClip

(

QPainter *

p

)

Definition at line 1289 of file qstylesheetstyle.cpp.

Referenced by drawBackgroundImage(), and drawBorderImage().

{
    if (--clipset)
        return;
    if (!clipPath.isEmpty())
        p->restore();
}

Properties

b

QSharedDataPointer<QStyleSheetBoxData> QRenderRule::b

Definition at line 583 of file qstylesheetstyle.cpp.

Referenced by boxRect(), outlineRect(), paddingRect(), and QRenderRule().

bd

QSharedDataPointer<QStyleSheetBorderData> QRenderRule::bd

Definition at line 585 of file qstylesheetstyle.cpp.

Referenced by borderClip(), drawBorder(), fixupBorder(), and QRenderRule().

bg

QSharedDataPointer<QStyleSheetBackgroundData> QRenderRule::bg

Definition at line 584 of file qstylesheetstyle.cpp.

Referenced by configurePalette(), QStyleSheetStyle::drawControl(), and QRenderRule().

clipPath

QPainterPath QRenderRule::clipPath

Definition at line 595 of file qstylesheetstyle.cpp.

Referenced by setClip(), and unsetClip().

clipset

int QRenderRule::clipset

Definition at line 594 of file qstylesheetstyle.cpp.

Referenced by setClip(), and unsetClip().

defaultBackground

QBrush QRenderRule::defaultBackground

Definition at line 572 of file qstylesheetstyle.cpp.

Referenced by drawBackground(), and QRenderRule().

features

int QRenderRule::features

Definition at line 571 of file qstylesheetstyle.cpp.

Referenced by QRenderRule().

font

QFont QRenderRule::font

Definition at line 573 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), QRenderRule(), and QStyleSheetStyle::updateStyleSheetFont().

geo

QSharedDataPointer<QStyleSheetGeometryData> QRenderRule::geo

Definition at line 587 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), QRenderRule(), QStyleSheetStyle::setGeometry(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::titleBarLayout().

hasFont

bool QRenderRule::hasFont

Definition at line 574 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::drawControl(), and QRenderRule().

img

QSharedDataPointer<QStyleSheetImageData> QRenderRule::img

Definition at line 589 of file qstylesheetstyle.cpp.

Referenced by drawImage(), QRenderRule(), and QStyleSheetStyle::subControlRect().

ou

QSharedDataPointer<QStyleSheetOutlineData> QRenderRule::ou

Definition at line 586 of file qstylesheetstyle.cpp.

Referenced by drawOutline(), and QRenderRule().

p

QSharedDataPointer<QStyleSheetPositionData> QRenderRule::p

Definition at line 588 of file qstylesheetstyle.cpp.

Referenced by boxRect(), contentsRect(), parentWidget(), QStyleSheetStyle::positionRect(), QRenderRule(), QStyleSheetStyle::setPalette(), QStyleSheetStyle::subControlRect(), and QStyleSheetStyle::unsetPalette().

pal

QSharedDataPointer<QStyleSheetPaletteData> QRenderRule::pal

Definition at line 582 of file qstylesheetstyle.cpp.

Referenced by configurePalette(), fixupBorder(), and QRenderRule().

styleHints

QHash<QString, QVariant> QRenderRule::styleHints

Definition at line 576 of file qstylesheetstyle.cpp.

Referenced by QRenderRule().

---

The documentation for this class was generated from the following file:

• /src/gui/styles/qstylesheetstyle.cpp