src/gui/styles/qstylesheetstyle.cpp File Reference

#include "qstylesheetstyle_p.h"
#include <qdebug.h>
#include <qapplication.h>
#include <qmenu.h>
#include <qmenubar.h>
#include <qpainter.h>
#include <qstyleoption.h>
#include <qlineedit.h>
#include <qwindowsstyle.h>
#include <qcombobox.h>
#include <qplastiquestyle.h>
#include "private/qcssparser_p.h"
#include "private/qmath_p.h"
#include <qabstractscrollarea.h>
#include <qtooltip.h>
#include <qshareddata.h>
#include <qradiobutton.h>
#include "moc_qstylesheetstyle_p.cpp"

Include dependency graph for qstylesheetstyle.cpp:

Go to the source code of this file.

Classes
struct	QStyleSheetBorderImageData
struct	QStyleSheetBackgroundData
struct	QStyleSheetBorderData
struct	QStyleSheetBoxData
struct	QStyleSheetPaletteData
struct	QStyleSheetGeometryData
struct	QStyleSheetPositionData
class	QRenderRule
class	QStyleSheetStyleSelector
struct	PseudoElementInfo
Defines
#define	ceil(x)   ((int)(x) + ((x) > 0 && (x) != (int)(x)))
#define	WIDGET(x)   (static_cast<QWidget *>(x.ptr))
Typedefs
typedef QHash< QString, QHash< int, QRenderRule > >	QRenderRules
Enumerations
enum	PseudoElement
Functions
static void	initStatics ()
static QPen	qPenFromStyle (const QBrush &b, qreal width, BorderStyle s)
static void	qDrawRoundedCorners (QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2, const QSizeF &r1, const QSizeF &r2, Edge edge, BorderStyle s, QColor c)
void	qDrawEdge (QPainter *p, qreal x1, qreal y1, qreal x2, qreal y2, qreal dw1, qreal dw2, Edge edge, BorderStyle style, QColor c)
static void	qDrawCenterTiledPixmap (QPainter *p, const QRectF &r, const QPixmap &pix)
static QVector< QCss::StyleRule >	styleRules (QWidget *w)
static Qt::Alignment	defaultPosition (int pe)
static QSize	expandedSize (QSize sz, const QRect &rect, int pe)
static QRect	positionRect (const QRenderRule &rule1, const QRenderRule &rule2, int pe, const QRect &rect, Qt::LayoutDirection dir)
static QWidget *	embeddedWidget (QWidget *w)
static void	unsetPalette (QWidget *w)
static void	updateWidget (QWidget *widget)
static void	updateWidgets (const QList< const QWidget * > &widgets)
static bool	unstylable (QWidget *w)
Variables
static QHash< const QWidget *, QVector< StyleRule > > *	styleRulesCache = 0
static QHash< const QWidget *, QRenderRules > *	renderRulesCache = 0
static QHash< const QWidget *, int > *	customPaletteWidgets = 0
static QHash< const QWidget *, int > *	customFontWidgets = 0
static QHash< const QWidget *, StyleSheet > *	styleSheetCache = 0
static const char *	knownStyleHints []
static const char **	endKnownStyleHints = knownStyleHints + sizeof(knownStyleHints)/sizeof(char *)
static struct PseudoElementInfo	knownPseudoElements [NumPseudoElements]

---

Define Documentation

#define ceil

(

x

)

((int)(x) + ((x) > 0 && (x) != (int)(x)))

Definition at line 55 of file qstylesheetstyle.cpp.

Referenced by QFontEngine::alphaMapForGlyph(), QSvgAnimateColor::apply(), DocumentShape::DocumentShape(), QPainterPrivate::draw_helper(), QRenderRule::drawBorderImage(), QPaintEngine::drawImage(), drawTextItemDecoration(), ImageShape::ImageShape(), pathArc(), qt_curves_for_arc(), QSvgAnimateTransform::resolveMatrix(), and QPicturePaintEngine::writeCmdLength().

#define WIDGET

(

x

)

(static_cast<QWidget *>(x.ptr))

Definition at line 1179 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyleSelector::attribute(), QStyleSheetStyleSelector::hasAttribute(), QStyleSheetStyleSelector::nodeIds(), QStyleSheetStyleSelector::nodeNameEquals(), and QStyleSheetStyleSelector::parentNode().

---

Typedef Documentation

typedef QHash<QString, QHash<int, QRenderRule> > QRenderRules

Definition at line 49 of file qstylesheetstyle.cpp.

---

Enumeration Type Documentation

enum PseudoElement

Definition at line 1270 of file qstylesheetstyle.cpp.

                   {
    PseudoElement_None,
    PseudoElement_DownArrow,
    PseudoElement_UpArrow,
    PseudoElement_LeftArrow,
    PseudoElement_RightArrow,
    PseudoElement_Indicator,
    PseudoElement_MenuIndicator,
    PseudoElement_DropDown,
    PseudoElement_DropDownArrow,
    PseudoElement_Item,
    PseudoElement_SpinBoxUpButton,
    PseudoElement_SpinBoxUpArrow,
    PseudoElement_SpinBoxDownButton,
    PseudoElement_SpinBoxDownArrow,
    PseudoElement_GroupBoxTitle,
    PseudoElement_GroupBoxIndicator,
    NumPseudoElements
};

---

Function Documentation

static Qt::Alignment defaultPosition

(

int

pe

)

[static]

Definition at line 1447 of file qstylesheetstyle.cpp.

References Qt::AlignBottom, Qt::AlignCenter, Qt::AlignLeft, Qt::AlignRight, Qt::AlignTop, Qt::AlignVCenter, PseudoElement_DownArrow, PseudoElement_DropDown, PseudoElement_DropDownArrow, PseudoElement_GroupBoxIndicator, PseudoElement_GroupBoxTitle, PseudoElement_Indicator, PseudoElement_MenuIndicator, PseudoElement_SpinBoxDownArrow, PseudoElement_SpinBoxDownButton, PseudoElement_SpinBoxUpArrow, and PseudoElement_SpinBoxUpButton.

Referenced by positionRect().

{
    switch (pe) {
    case PseudoElement_SpinBoxUpButton:
    case PseudoElement_SpinBoxDownButton:
        return (pe == PseudoElement_SpinBoxUpButton) ? Qt::AlignTop | Qt::AlignRight
                                                     : Qt::AlignBottom | Qt::AlignRight;
    case PseudoElement_Indicator:
        return Qt::AlignLeft | Qt::AlignVCenter;
    case PseudoElement_DropDown:
        return Qt::AlignTop | Qt::AlignRight;
    case PseudoElement_DropDownArrow:
    case PseudoElement_SpinBoxDownArrow:
    case PseudoElement_SpinBoxUpArrow:
    case PseudoElement_DownArrow:
        return Qt::AlignCenter;
    case PseudoElement_MenuIndicator:
        return Qt::AlignBottom | Qt::AlignRight;
    case PseudoElement_GroupBoxTitle:
    case PseudoElement_GroupBoxIndicator:
        return Qt::AlignTop | Qt::AlignLeft;
    default:
        return 0;
    }
}

static QWidget* embeddedWidget

(

QWidget *

w

)

[static]

Definition at line 1534 of file qstylesheetstyle.cpp.

References w.

Referenced by QStyleSheetStyle::setPalette().

{
#ifndef QT_NO_COMBOBOX
    if (QComboBox *cmb = qobject_cast<QComboBox *>(w))
        if (cmb->isEditable())
            return cmb->lineEdit();
        else
            return cmb;
#endif

#ifndef QT_NO_SPINBOX
    if (QAbstractSpinBox *sb = qobject_cast<QAbstractSpinBox *>(w))
        return qFindChild<QLineEdit *>(sb);
#endif

#ifndef QT_NO_SCROLLAREA
    if (QAbstractScrollArea *sa = qobject_cast<QAbstractScrollArea *>(w))
        return sa->viewport();
#endif

    return w;
}

static QSize expandedSize	(	QSize	sz,
		const QRect &	rect,
		int	pe
	)			[static]

Definition at line 1473 of file qstylesheetstyle.cpp.

References QRect::height(), QSize::height(), PseudoElement_DropDown, PseudoElement_SpinBoxDownButton, PseudoElement_SpinBoxUpButton, QSize::setHeight(), QSize::setWidth(), QRect::width(), and QSize::width().

Referenced by positionRect().

{
    // some magic for relative positioning since we don't support % metrics yet
    switch (pe) {
    case PseudoElement_SpinBoxUpButton:
    case PseudoElement_SpinBoxDownButton:
        if (sz.height() == -1) 
            sz.setHeight(rect.height()/2);
        break;
    case PseudoElement_DropDown:
        if (sz.height() == -1) 
            sz.setHeight(rect.height());
        break;
    default:
        break;
    }

    // expand to rectangle
    if (sz.height() == -1)
        sz.setHeight(rect.height());
    if (sz.width() == -1)
        sz.setWidth(rect.width());

    return sz;
}

Here is the call graph for this function:

static void initStatics

(

)

[static]

Definition at line 57 of file qstylesheetstyle.cpp.

References customFontWidgets, customPaletteWidgets, renderRulesCache, styleRulesCache, and styleSheetCache.

Referenced by QStyleSheetStyle::QStyleSheetStyle().

{
    static bool initialized = false;
    if (initialized)
        return;
    initialized = true;
    styleRulesCache = new QHash<const QWidget *, QVector<StyleRule> >;
    renderRulesCache = new QHash<const QWidget *, QRenderRules>;
    customPaletteWidgets = new QHash<const QWidget *, int>;
    customFontWidgets = new QHash<const QWidget *, int>;
    styleSheetCache = new QHash<const QWidget *, StyleSheet>;
}

static QRect positionRect	(	const QRenderRule &	rule1,
		const QRenderRule &	rule2,
		int	pe,
		const QRect &	rect,
		Qt::LayoutDirection	dir
	)			[static]

Definition at line 1499 of file qstylesheetstyle.cpp.

References QStyle::alignedRect(), defaultPosition(), expandedSize(), QSize::expandedTo(), QRenderRule::hasContentsSize(), QTextStream::left(), Qt::LeftToRight, QRenderRule::minimumContentsSize(), QCss::Origin_Padding, QCss::Origin_Unknown, QRenderRule::originRect(), p, QRenderRule::position(), QCss::PositionMode_Absolute, QCss::PositionMode_Static, and QRenderRule::size().

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

{
    Origin defOrigin = Origin_Padding;
    Qt::Alignment defPosition = defaultPosition(pe);

    const QStyleSheetPositionData *p = rule2.position();
    Origin origin = (p && p->origin != Origin_Unknown) ? p->origin : defOrigin;
    QRect originRect = rule1.originRect(rect, origin);
    PositionMode mode = p ? p->mode : PositionMode_Static;
    Qt::Alignment position = (p && p->position != 0) ? p->position : defPosition;
    QRect r;

    if (mode != PositionMode_Absolute) {
        QSize sz = expandedSize(rule2.size(), originRect, pe);
        sz = sz.expandedTo(rule2.minimumContentsSize());
        r = QStyle::alignedRect(dir, position, sz, originRect);
        if (p) {
            int left = p->left ? p->left : -p->right;
            int top = p->top ? p->top : -p->bottom;
            r.translate(dir == Qt::LeftToRight ? left : -left, top);
        }
    } else {
        if (p)
            r = originRect.adjusted(dir == Qt::LeftToRight ? p->left : p->right, p->top, 
                                    dir == Qt::LeftToRight ? -p->right : -p->left, -p->bottom);
        if (rule2.hasContentsSize()) {
            QSize sz = expandedSize(rule2.size(), r, pe);
            sz = sz.expandedTo(rule2.minimumContentsSize());
            r = QStyle::alignedRect(dir, position, sz, r);
        }
    }
    return r;
}

Here is the call graph for this function:

static void qDrawCenterTiledPixmap	(	QPainter *	p,
		const QRectF &	r,
		const QPixmap &	pix
	)			[static]

Definition at line 804 of file qstylesheetstyle.cpp.

References QRectF::height(), QPixmap::height(), int, p, QPixmap::width(), and QRectF::width().

Referenced by QRenderRule::drawBorderImage().

{
    p->drawTiledPixmap(r, pix, QPoint(pix.width() - int(r.width())%pix.width(),
                                      pix.height() - int(r.height())%pix.height()));
}

Here is the call graph for this function:

void qDrawEdge	(	QPainter *	p,
		qreal	x1,
		qreal	y1,
		qreal	x2,
		qreal	y2,
		qreal	dw1,
		qreal	dw2,
		Edge	edge,
		BorderStyle	style,
		QColor	c
	)

Definition at line 659 of file qstylesheetstyle.cpp.

References QPainter::Antialiasing, QCss::BorderStyle_Dashed, QCss::BorderStyle_DotDash, QCss::BorderStyle_DotDotDash, QCss::BorderStyle_Dotted, QCss::BorderStyle_Double, QCss::BorderStyle_Groove, QCss::BorderStyle_Inset, QCss::BorderStyle_Outset, QCss::BorderStyle_Ridge, QCss::BorderStyle_Solid, QCss::BottomEdge, c, QCss::LeftEdge, Qt::NoPen, p, qFloor(), qPenFromStyle(), qRound(), QCss::RightEdge, s1, s2, and QCss::TopEdge.

Referenced by QRenderRule::drawBorder().

{
    p->save();
    p->setRenderHint(QPainter::Antialiasing);
    const qreal width = (edge == TopEdge || edge == BottomEdge) ? (y2-y1) : (x2-x1);

    if (width <= 2 && style == BorderStyle_Double)
        style = BorderStyle_Solid;

    switch (style) {
    case BorderStyle_Inset:
    case BorderStyle_Outset:
        if (style == BorderStyle_Outset && (edge == TopEdge || edge == LeftEdge)
            || (style == BorderStyle_Inset && (edge == BottomEdge || edge == RightEdge)))
            c = c.light();
        // fall through!
    case BorderStyle_Solid: {
        p->setPen(Qt::NoPen);
        p->setBrush(c);
        if (width == 1 || (dw1 == 0 && dw2 == 0)) {
            p->drawRect(QRectF(x1, y1, x2-x1, y2-y1));
        } else { // draw trapezoid
            QPolygonF quad;
            switch (edge) {
            case TopEdge:
                quad << QPointF(x1, y1) << QPointF(x1 + dw1, y2)
                     << QPointF(x2 - dw2, y2) << QPointF(x2, y1);
                break;
            case BottomEdge:
                quad << QPointF(x1 + dw1, y1) << QPointF(x1, y2)
                     << QPointF(x2, y2) << QPointF(x2 - dw2, y1);
                break;
            case LeftEdge:
                quad << QPointF(x1, y1) << QPointF(x1, y2)
                     << QPointF(x2, y2 - dw2) << QPointF(x2, y1 + dw1);
                break;
            case RightEdge:
                quad << QPointF(x1, y1 + dw1) << QPointF(x1, y2 - dw2)
                     << QPointF(x2, y2) << QPointF(x2, y1);
                break;
            default:
                break;
            }
            p->drawConvexPolygon(quad);
        }
        break;
    }
    case BorderStyle_Dotted:
    case BorderStyle_Dashed:
    case BorderStyle_DotDash:
    case BorderStyle_DotDotDash:
        p->setPen(qPenFromStyle(c, width, style));
        if (width == 1)
            p->drawLine(QLineF(x1, y1, x2 - 1, y2 - 1));
        else if (edge == TopEdge || edge == BottomEdge)
            p->drawLine(QLineF(x1 + width/2, (y1 + y2)/2, x2 - width/2, (y1 + y2)/2));
        else
            p->drawLine(QLineF((x1+x2)/2, y1 + width/2, (x1+x2)/2, y2 - width/2));
        break;

    case BorderStyle_Double: {
        int wby3 = qRound(width/3);
        int dw1by3 = qRound(dw1/3);
        int dw2by3 = qRound(dw2/3);
        switch (edge) {
        case TopEdge:
            qDrawEdge(p, x1, y1, x2, y1 + wby3, dw1by3, dw2by3, TopEdge, BorderStyle_Solid, c);
            qDrawEdge(p, x1 + dw1 - dw1by3, y2 - wby3, x2 - dw2 + dw1by3, y2,
                      dw1by3, dw2by3, TopEdge, BorderStyle_Solid, c);
            break;
        case LeftEdge:
            qDrawEdge(p, x1, y1, x1 + wby3, y2, dw1by3, dw2by3, LeftEdge, BorderStyle_Solid, c);
            qDrawEdge(p, x2 - wby3, y1 + dw1 - dw1by3, x2, y2 - dw2 + dw2by3, dw1by3, dw2by3,
                      LeftEdge, BorderStyle_Solid, c);
            break;
        case BottomEdge:
            qDrawEdge(p, x1 + dw1 - dw1by3, y1, x2 - dw2 + dw2by3, y1 + wby3, dw1by3, dw2by3,
                      BottomEdge, BorderStyle_Solid, c);
            qDrawEdge(p, x1, y2 - wby3, x2, y2, dw1by3, dw2by3, BottomEdge, BorderStyle_Solid, c);
            break;
        case RightEdge:
            qDrawEdge(p, x2 - wby3, y1, x2, y2, dw1by3, dw2by3, RightEdge, BorderStyle_Solid, c);
            qDrawEdge(p, x1, y1 + dw1 - dw1by3, x1 + wby3, y2 - dw2 + dw2by3, dw1by3, dw2by3,
                      RightEdge, BorderStyle_Solid, c);
            break;
        default:
            break;
        }
        break;
    }
    case BorderStyle_Ridge:
    case BorderStyle_Groove: {
        BorderStyle s1, s2;
        if (style == BorderStyle_Groove) {
            s1 = BorderStyle_Inset;
            s2 = BorderStyle_Outset;
        } else {
            s1 = BorderStyle_Outset;
            s2 = BorderStyle_Inset;
        }
        int dw1by2 = qFloor(dw1/2), dw2by2 = qFloor(dw2/2);
        int wby2 = qRound(width/2);
        switch (edge) {
        case TopEdge:
            qDrawEdge(p, x1, y1, x2, y1 + wby2, dw1by2, dw2by2, TopEdge, s1, c);
            qDrawEdge(p, x1 + dw1by2, y1 + wby2, x2 - dw2by2, y2, dw1by2, dw2by2, TopEdge, s2, c);
            break;
        case BottomEdge:
            qDrawEdge(p, x1, y1 + wby2, x2, y2, dw1by2, dw2by2, BottomEdge, s1, c);
            qDrawEdge(p, x1 + dw1by2, y1, x2 - dw2by2, y1 + wby2, dw1by2, dw2by2, BottomEdge, s2, c);
            break;
        case LeftEdge:
            qDrawEdge(p, x1, y1, x1 + wby2, y2, dw1by2, dw2by2, LeftEdge, s1, c);
            qDrawEdge(p, x1 + wby2, y1 + dw1by2, x2, y2 - dw2by2, dw1by2, dw2by2, LeftEdge, s2, c);
            break;
        case RightEdge:
            qDrawEdge(p, x1 + wby2, y1, x2, y2, dw1by2, dw2by2, RightEdge, s1, c);
            qDrawEdge(p, x1, y1 + dw1by2, x1 + wby2, y2 - dw2by2, dw1by2, dw2by2, RightEdge, s2, c);
            break;
        default:
            break;
        }
    }
    default:
        break;
    }
    p->restore();
}

Here is the call graph for this function:

static void qDrawRoundedCorners	(	QPainter *	p,
		qreal	x1,
		qreal	y1,
		qreal	x2,
		qreal	y2,
		const QSizeF &	r1,
		const QSizeF &	r2,
		Edge	edge,
		BorderStyle	s,
		QColor	c
	)			[static]

Definition at line 553 of file qstylesheetstyle.cpp.

References QPainter::Antialiasing, QCss::BorderStyle_Double, QCss::BorderStyle_Groove, QCss::BorderStyle_Inset, QCss::BorderStyle_Outset, QCss::BorderStyle_Ridge, QCss::BorderStyle_Solid, QCss::BottomEdge, c, QSizeF::height(), QSizeF::isEmpty(), QCss::LeftEdge, Qt::NoBrush, p, qPenFromStyle(), qRound(), QCss::RightEdge, s1, s2, QPen::setCapStyle(), Qt::SquareCap, QCss::TopEdge, and QSizeF::width().

Referenced by QRenderRule::drawBorder().

{
    const qreal pw = (edge == TopEdge || edge == BottomEdge) ? y2-y1 : x2-x1;
    if (s == BorderStyle_Double) {
        qreal wby3 = pw/3;
        switch (edge) {
        case TopEdge:
        case BottomEdge:
            qDrawRoundedCorners(p, x1, y1, x2, y1+wby3, r1, r2, edge, BorderStyle_Solid, c);
            qDrawRoundedCorners(p, x1, y2-wby3, x2, y2, r1, r2, edge, BorderStyle_Solid, c);
            break;
        case LeftEdge:
            qDrawRoundedCorners(p, x1, y1+1, x1+wby3, y2, r1, r2, LeftEdge, BorderStyle_Solid, c);
            qDrawRoundedCorners(p, x2-wby3, y1+1, x2, y2, r1, r2, LeftEdge, BorderStyle_Solid, c);
            break;
        case RightEdge:
            qDrawRoundedCorners(p, x1, y1+1, x1+wby3, y2, r1, r2, RightEdge, BorderStyle_Solid, c);
            qDrawRoundedCorners(p, x2-wby3, y1+1, x2, y2, r1, r2, RightEdge, BorderStyle_Solid, c);
            break;
        default:
            break;
        }
        return;
    } else if (s == BorderStyle_Ridge || s == BorderStyle_Groove) {
        BorderStyle s1, s2;
        if (s == BorderStyle_Groove) {
            s1 = BorderStyle_Inset;
            s2 = BorderStyle_Outset;
        } else {
            s1 = BorderStyle_Outset;
            s2 = BorderStyle_Inset;
        }
        int pwby2 = qRound(pw/2);
        switch (edge) {
        case TopEdge:
            qDrawRoundedCorners(p, x1, y1, x2, y1 + pwby2, r1, r2, TopEdge, s1, c);
            qDrawRoundedCorners(p, x1, y1 + pwby2, x2, y2, r1, r2, TopEdge, s2, c);
            break;
        case BottomEdge:
            qDrawRoundedCorners(p, x1, y1 + pwby2, x2, y2, r1, r2, BottomEdge, s1, c);
            qDrawRoundedCorners(p, x1, y1, x2, y2-pwby2, r1, r2, BottomEdge, s2, c);
            break;
        case LeftEdge:
            qDrawRoundedCorners(p, x1, y1, x1 + pwby2, y2, r1, r2, LeftEdge, s1, c);
            qDrawRoundedCorners(p, x1 + pwby2, y1, x2, y2, r1, r2, LeftEdge, s2, c);
            break;
        case RightEdge:
            qDrawRoundedCorners(p, x1 + pwby2, y1, x2, y2, r1, r2, RightEdge, s1, c);
            qDrawRoundedCorners(p, x1, y1, x2 - pwby2, y2, r1, r2, RightEdge, s2, c);
            break;
        default:
            break;
        }
    } else if ((s == BorderStyle_Outset && (edge == TopEdge || edge == LeftEdge))
            || (s == BorderStyle_Inset && (edge == BottomEdge || edge == RightEdge)))
            c = c.light();

    p->save();
    p->setRenderHint(QPainter::Antialiasing);
    qreal pwby2 = pw/2;
    p->setBrush(Qt::NoBrush);
    QPen pen = qPenFromStyle(c, pw, s);
    pen.setCapStyle(Qt::SquareCap); // this eliminates the offby1 errors that we might hit below
    p->setPen(pen);
    switch (edge) {
    case TopEdge:
        if (!r1.isEmpty())
            p->drawArc(QRectF(x1 - r1.width() + pwby2, y1 + pwby2,
                              2*r1.width() - pw, 2*r1.height() - pw), 135*16, -45*16);
        if (!r2.isEmpty())
            p->drawArc(QRectF(x2 - r2.width() + pwby2, y1 + pwby2,
                       2*r2.width() - pw, 2*r2.height() - pw), 45*16, 45*16);
        break;
    case BottomEdge:
        if (!r1.isEmpty())
            p->drawArc(QRectF(x1 - r1.width() + pwby2, y2 - 2*r1.height() + pwby2,
                              2*r1.width() - pw, 2*r1.height() - pw), -90 * 16, -45 * 16);
        if (!r2.isEmpty())
            p->drawArc(QRectF(x2 - r2.width() + pwby2, y2 - 2*r2.height() + pwby2,
                       2*r2.width() - pw, 2*r2.height() - pw), -90 * 16, 45 * 16);
        break;
    case LeftEdge:
        if (!r1.isEmpty())
            p->drawArc(QRectF(x1 + pwby2, y1 - r1.height() + pwby2,
                       2*r1.width() - pw, 2*r1.height() - pw), 135*16, 45*16);
        if (!r2.isEmpty())
            p->drawArc(QRectF(x1 + pwby2, y2 - r2.height() + pwby2,
                       2*r2.width() - pw, 2*r2.height() - pw), 180*16, 45*16);
        break;
    case RightEdge:
        if (!r1.isEmpty())
            p->drawArc(QRectF(x2 - 2*r1.width() + pwby2, y1 - r1.height() + pwby2,
                       2*r1.width() - pw, 2*r1.height() - pw), 45*16, -45*16);
        if (!r2.isEmpty())
            p->drawArc(QRectF(x2 - 2*r2.width() + pwby2, y2 - r2.height() + pwby2,
                       2*r2.width() - pw, 2*r2.height() - pw), 315*16, 45*16);
        break;
    default:
        break;
    }
    p->restore();
}

Here is the call graph for this function:

static QPen qPenFromStyle	(	const QBrush &	b,
		qreal	width,
		BorderStyle	s
	)			[static]

Definition at line 524 of file qstylesheetstyle.cpp.

References b, QCss::BorderStyle_Dashed, QCss::BorderStyle_DotDash, QCss::BorderStyle_DotDotDash, QCss::BorderStyle_Dotted, QCss::BorderStyle_Inset, QCss::BorderStyle_Outset, QCss::BorderStyle_Solid, Qt::DashDotDotLine, Qt::DashDotLine, Qt::DashLine, Qt::DotLine, Qt::FlatCap, Qt::NoPen, and Qt::SolidLine.

Referenced by qDrawEdge(), and qDrawRoundedCorners().

{
    Qt::PenStyle ps = Qt::NoPen;

    switch (s) {
    case BorderStyle_Dotted:
        ps  = Qt::DotLine;
        break;
    case BorderStyle_Dashed:
        ps = width == 1 ? Qt::DotLine : Qt::DashLine;
        break;
    case BorderStyle_DotDash:
        ps = Qt::DashDotLine;
        break;
    case BorderStyle_DotDotDash:
        ps = Qt::DashDotDotLine;
        break;
    case BorderStyle_Inset:
    case BorderStyle_Outset:
    case BorderStyle_Solid:
        ps = Qt::SolidLine;
        break;
    default:
        break;
    }

    return QPen(b, width, ps, Qt::FlatCap);
}

static QVector<QCss::StyleRule> styleRules

(

QWidget *

w

)

[static]

Definition at line 1221 of file qstylesheetstyle.cpp.

References QList< T >::count(), i, n, QCss::StyleSheet::origin, QList< T >::prepend(), qApp, qWarning(), QCss::StyleSelector::styleRulesForNode(), styleSheetCache, QCss::StyleSheetOrigin_Author, QCss::StyleSheetOrigin_Inline, QCss::StyleSelector::styleSheets, and w.

Referenced by QStyleSheetStyle::hasStyleRule(), QStyleSheetStyle::polish(), and QStyleSheetStyle::renderRule().

{
    QStyleSheetStyleSelector styleSelector;
    if (!qApp->styleSheet().isEmpty()) {
        StyleSheet appSs;
        if (!styleSheetCache->contains(0)) {
            Parser parser1(qApp->styleSheet());
            if (!parser1.parse(&appSs))
                qWarning("Could not parse application stylesheet");
           appSs.origin = StyleSheetOrigin_Author;
            styleSheetCache->insert(0, appSs);
        } else {
            appSs = styleSheetCache->value(0);
        }
        styleSelector.styleSheets += appSs;
    }

    QList<QCss::StyleSheet> widgetSs;
    for (QWidget *wid = w; wid; wid = wid->parentWidget()) {
        if (wid->styleSheet().isEmpty())
            continue;
        StyleSheet ss;
        if (!styleSheetCache->contains(wid)) {
            Parser parser(wid->styleSheet());
            if (!parser.parse(&ss) && wid == w) {
                Parser parser2(QLatin1String("* {") + wid->styleSheet() + QLatin1String("}"));
                if (!parser2.parse(&ss))
                   qWarning("Could not parse stylesheet of widget %p", wid);
            }
            ss.origin = StyleSheetOrigin_Inline;
            styleSheetCache->insert(wid, ss);
        } else {
            ss = styleSheetCache->value(wid);
        }
        widgetSs.prepend(ss);
    }

    for (int i = 0; i < widgetSs.count(); i++)
        widgetSs[i].depth = i + 1;

    styleSelector.styleSheets += widgetSs;

    StyleSelector::NodePtr n;
    n.ptr = w;
    return styleSelector.styleRulesForNode(n);
}

Here is the call graph for this function:

static void unsetPalette

(

QWidget *

w

)

[static]

Definition at line 1603 of file qstylesheetstyle.cpp.

References customFontWidgets, customPaletteWidgets, QApplication::font(), p, QApplication::palette(), QFont::resolve(), and w.

Referenced by QStyleSheetStyle::polish(), and QStyleSheetStyle::unpolish().

{
    if (customPaletteWidgets->contains(w)) {
        QPalette p = QApplication::palette(w);
        p.resolve(customPaletteWidgets->value(w));
        p.resolve(w->palette());
        w->setPalette(p);
        customPaletteWidgets->remove(w);
    }
    if (customFontWidgets->contains(w)) {
        QFont f = QApplication::font();
        f.resolve(customFontWidgets->value(w));
        f.resolve(w->font());
        w->setFont(f);
        customFontWidgets->remove(w);
    }
}

Here is the call graph for this function:

static bool unstylable

(

QWidget *

w

)

[static]

Definition at line 1664 of file qstylesheetstyle.cpp.

References Qt::Desktop, and w.

Referenced by QStyleSheetStyle::polish().

{
    if (w->windowType() == Qt::Desktop)
        return true;

#ifndef QT_NO_SCROLLAREA
    if (QAbstractScrollArea *sa = qobject_cast<QAbstractScrollArea *>(w->parentWidget())) {
        if (sa->viewport() == w)
            return true;
    } else
#endif
#ifndef QT_NO_LINEEDIT
    if (qobject_cast<QLineEdit *>(w)) {
        if (0
#ifndef QT_NO_COMBOBOX
            || qobject_cast<QComboBox *>(w->parentWidget())
#endif
#ifndef QT_NO_SPINBOX
            || qobject_cast<QAbstractSpinBox *>(w->parentWidget())
#endif
            )
            return true;
    }
#endif
    return false;
}

static void updateWidget

(

QWidget *

widget

)

[static]

Definition at line 1621 of file qstylesheetstyle.cpp.

References QCoreApplication::sendEvent(), QEvent::StyleChange, QWidget::update(), and QWidget::updateGeometry().

Referenced by QStyleSheetStyle::polish().

{
    QEvent e(QEvent::StyleChange);
    QApplication::sendEvent(widget, &e);
    widget->update();
    widget->updateGeometry();
}

Here is the call graph for this function:

static void updateWidgets

(

const QList< const QWidget * > &

widgets

)

[static]

Definition at line 1629 of file qstylesheetstyle.cpp.

References QList< T >::at(), i, renderRulesCache, QList< T >::size(), and styleRulesCache.

Referenced by QStyleSheetStyle::repolish().

{
    for (int i = 0; i < widgets.size(); ++i) {
        QWidget *widget = const_cast<QWidget *>(widgets.at(i));
        Q_ASSERT(widget);
        styleRulesCache->remove(widget);
        renderRulesCache->remove(widget);
        widget->style()->polish(widget);
    }
}

Here is the call graph for this function:

---

Variable Documentation

QHash<const QWidget *, int>* customFontWidgets = 0 [static]

Definition at line 52 of file qstylesheetstyle.cpp.

Referenced by initStatics(), QStyleSheetStyle::setPalette(), and unsetPalette().

QHash<const QWidget *, int>* customPaletteWidgets = 0 [static]

Definition at line 51 of file qstylesheetstyle.cpp.

Referenced by initStatics(), QStyleSheetStyle::setPalette(), unsetPalette(), and QStyleSheetStyle::widgetDestroyed().

const char** endKnownStyleHints = knownStyleHints + sizeof(knownStyleHints)/sizeof(char *) [static]

Definition at line 282 of file qstylesheetstyle.cpp.

Referenced by QRenderRule::QRenderRule().

struct PseudoElementInfo knownPseudoElements[NumPseudoElements] [static]

Referenced by QStyleSheetStyle::hasStyleRule(), and QStyleSheetStyle::renderRule().

const char* knownStyleHints[] [static]

Initial value:

 {
    "activate-on-singleclick",
    "button-layout",
    "combobox-list-mousetracking",
    "combobox-popup",
    "dither-disable-text",
    "etch-disabled-text",
    "gridline-color",
    "lineedit-password-character",
    "menubar-altkey-navigation",
    "menubar-separator",
    "messagebox-text-interaction-flags",
    "mouse-tracking",
    "opacity",
    "show-decoration-selected",
    "spinbox-click-autorepeat-rate",
    "spincontrol-disable-on-bounds"
}

Definition at line 263 of file qstylesheetstyle.cpp.

Referenced by QRenderRule::QRenderRule().

QHash<const QWidget *, QRenderRules>* renderRulesCache = 0 [static]

Definition at line 50 of file qstylesheetstyle.cpp.

Referenced by initStatics(), QStyleSheetStyle::polish(), QStyleSheetStyle::unpolish(), updateWidgets(), and QStyleSheetStyle::widgetDestroyed().

QHash<const QWidget *, QVector<StyleRule> >* styleRulesCache = 0 [static]

Definition at line 48 of file qstylesheetstyle.cpp.

Referenced by QStyleSheetStyle::hasStyleRule(), initStatics(), QStyleSheetStyle::polish(), QStyleSheetStyle::renderRule(), QStyleSheetStyle::repolish(), QStyleSheetStyle::unpolish(), updateWidgets(), and QStyleSheetStyle::widgetDestroyed().

QHash<const QWidget *, StyleSheet>* styleSheetCache = 0 [static]

Definition at line 53 of file qstylesheetstyle.cpp.

Referenced by initStatics(), QStyleSheetStyle::repolish(), styleRules(), and QStyleSheetStyle::unpolish().

---