QStyleSheetStyle Class Reference

#include <qstylesheetstyle_p.h>

Inheritance diagram for QStyleSheetStyle:

[legend]Collaboration diagram for QStyleSheetStyle:

[legend]List of all members.

---

Detailed Description

Definition at line 52 of file qstylesheetstyle_p.h.

Public Member Functions
	QStyleSheetStyle (QStyle *baseStyle)
void	drawComplexControl (ComplexControl cc, const QStyleOptionComplex *opt, QPainter *p, const QWidget *w=0) const
void	drawControl (ControlElement element, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
void	drawItemPixmap (QPainter *painter, const QRect &rect, int alignment, const QPixmap &pixmap) const
void	drawItemText (QPainter *painter, const QRect &rect, int alignment, const QPalette &pal, bool enabled, const QString &text, QPalette::ColorRole textRole=QPalette::NoRole) const
void	drawPrimitive (PrimitiveElement pe, const QStyleOption *opt, QPainter *p, const QWidget *w=0) const
QPixmap	generatedIconPixmap (QIcon::Mode iconMode, const QPixmap &pixmap, const QStyleOption *option) const
SubControl	hitTestComplexControl (ComplexControl cc, const QStyleOptionComplex *opt, const QPoint &pt, const QWidget *w=0) const
QRect	itemPixmapRect (const QRect &rect, int alignment, const QPixmap &pixmap) const
QRect	itemTextRect (const QFontMetrics &metrics, const QRect &rect, int alignment, bool enabled, const QString &text) const
int	pixelMetric (PixelMetric metric, const QStyleOption *option=0, const QWidget *widget=0) const
void	polish (QWidget *widget)
void	polish (QApplication *app)
void	polish (QPalette &pal)
QSize	sizeFromContents (ContentsType ct, const QStyleOption *opt, const QSize &contentsSize, const QWidget *widget=0) const
QIcon	standardIcon (StandardPixmap standardIcon, const QStyleOption *option, const QWidget *w=0) const
QPalette	standardPalette () const
QPixmap	standardPixmap (StandardPixmap standardPixmap, const QStyleOption *option=0, const QWidget *w=0) const
int	styleHint (StyleHint sh, const QStyleOption *opt=0, const QWidget *w=0, QStyleHintReturn *shret=0) const
QRect	subElementRect (SubElement r, const QStyleOption *opt, const QWidget *widget=0) const
QRect	subControlRect (ComplexControl cc, const QStyleOptionComplex *opt, SubControl sc, const QWidget *w=0) const
void	setBaseStyle (QStyle *style)
QStyle *	baseStyle () const
void	repolish (QWidget *widget)
void	repolish (QApplication *app)
void	unpolish (QWidget *widget)
void	unpolish (QApplication *app)
void	ref ()
void	deref ()
Public Attributes
QStyle *	base
Protected Slots
QIcon	standardIconImplementation (StandardPixmap standardIcon, const QStyleOption *opt=0, const QWidget *widget=0) const
Private Types
typedef QWindowsStyle	ParentStyle
Private Slots
void	widgetDestroyed (QObject *)
Private Member Functions
void	setPalette (QWidget *w)
QRenderRule	renderRule (const QWidget *, const QString &, QStyle::State=QStyle::State_None) const
QRenderRule	renderRule (const QWidget *, int, QStyle::State=QStyle::State_None) const
QRenderRule	renderRule (const QWidget *, const QStyleOption *, int=0) const
bool	hasStyleRule (const QWidget *, int=0) const
Private Attributes
int	refcount

---

Member Typedef Documentation

typedef QWindowsStyle QStyleSheetStyle::ParentStyle [private]

Definition at line 54 of file qstylesheetstyle_p.h.

---

Constructor & Destructor Documentation

QStyleSheetStyle::QStyleSheetStyle

(

QStyle *

baseStyle

)

Definition at line 1642 of file qstylesheetstyle.cpp.

References initStatics().

: base(base), refcount(1)
{
    initStatics();
}

Here is the call graph for this function:

---

Member Function Documentation

void QStyleSheetStyle::drawComplexControl	(	ComplexControl	cc,
		const QStyleOptionComplex *	opt,
		QPainter *	p,
		const QWidget *	w = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 1756 of file qstylesheetstyle.cpp.

References Qt::AlignCenter, QRenderRule::background(), baseStyle(), QRenderRule::boxRect(), QStyle::CC_ComboBox, QStyle::CC_GroupBox, QStyle::CC_SpinBox, QRenderRule::configurePalette(), QStyle::drawComplexControl(), QRenderRule::drawFrame(), drawItemText(), drawPrimitive(), QRenderRule::drawRule(), QRenderRule::hasBackground(), QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasDrawable(), hasStyleRule(), QStyleSheetBackgroundData::isTransparent(), p, QStyle::PE_IndicatorCheckBox, positionRect(), PseudoElement_DropDown, PseudoElement_DropDownArrow, PseudoElement_GroupBoxTitle, PseudoElement_SpinBoxDownArrow, PseudoElement_SpinBoxDownButton, PseudoElement_SpinBoxUpArrow, PseudoElement_SpinBoxUpButton, QStyleOption::rect, renderRule(), QStyle::SC_GroupBoxCheckBox, QStyle::SC_GroupBoxLabel, QPalette::setColor(), QStyle::SH_UnderlineShortcut, QStyle::State_Enabled, styleHint(), subControlRect(), Qt::TextHideMnemonic, QRect::united(), w, QPalette::Window, and QPalette::WindowText.

{
    if (!hasStyleRule(w)) {
        baseStyle()->drawComplexControl(cc, opt, p, w);
        return;
    }

    QRenderRule rule = renderRule(w, opt);

    switch (cc) {
    case CC_ComboBox:
        if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
            if (rule.hasBorder() || rule.hasBox() || hasStyleRule(w, PseudoElement_DropDown)) {
                rule.drawFrame(p, opt->rect);
                QRenderRule subRule = renderRule(w, opt, PseudoElement_DropDown);
                QRect r = positionRect(rule, subRule, PseudoElement_DropDown, opt->rect, opt->direction);
                subRule.drawRule(p, r);

                QRenderRule subRule2 = renderRule(w, opt, PseudoElement_DropDownArrow);
                r = positionRect(subRule, subRule2, PseudoElement_DropDownArrow, r, opt->direction);
                subRule2.drawRule(p, r);
            } else {
                baseStyle()->drawComplexControl(cc, cb, p, w);
            }
            return;
        }
        break;

    case CC_SpinBox:
        if (rule.hasBorder() || rule.hasBox() || hasStyleRule(w, PseudoElement_SpinBoxDownButton)
            || hasStyleRule(w, PseudoElement_SpinBoxUpButton)) {
            rule.drawFrame(p, opt->rect);

            // down button
            QRenderRule subRule1 = renderRule(w, opt, PseudoElement_SpinBoxDownButton);
            QRect r = positionRect(rule, subRule1, PseudoElement_SpinBoxDownButton, opt->rect, opt->direction);
            subRule1.drawRule(p, r);

            // down arrow
            QRenderRule subRule2 = renderRule(w, opt, PseudoElement_SpinBoxDownArrow);
            r = positionRect(subRule1, subRule2, PseudoElement_SpinBoxDownArrow, r, opt->direction);
            subRule2.drawRule(p, r);

            // up button border
            QRenderRule subRule3 = renderRule(w, opt, PseudoElement_SpinBoxUpButton);
            r = positionRect(rule, subRule3, PseudoElement_SpinBoxUpButton, opt->rect, opt->direction);
            subRule3.drawRule(p, r);

            // up arrow
            QRenderRule subRule4 = renderRule(w, opt, PseudoElement_SpinBoxUpArrow);
            r = positionRect(subRule3, subRule4, PseudoElement_SpinBoxUpArrow, r, opt->direction);
            subRule4.drawRule(p, r);

            return;
        }
        break;

    case CC_GroupBox:
        if (rule.hasDrawable() || rule.hasBox() || hasStyleRule(w, PseudoElement_GroupBoxTitle)) {
            if (const QStyleOptionGroupBox *gb = qstyleoption_cast<const QStyleOptionGroupBox *>(opt)) {
                QRect labelRect, checkBoxRect, titleRect;
                bool hasTitle = (gb->subControls & QStyle::SC_GroupBoxCheckBox) || !gb->text.isEmpty();
                QRenderRule titleRule = renderRule(w, opt, PseudoElement_GroupBoxTitle);

                bool clipSet = false;

                if (hasTitle) {
                    labelRect = subControlRect(CC_GroupBox, opt, SC_GroupBoxLabel, w);
                    if (gb->subControls & QStyle::SC_GroupBoxCheckBox) {
                        checkBoxRect = subControlRect(CC_GroupBox, opt, SC_GroupBoxCheckBox, w);
                        titleRect = titleRule.boxRect(checkBoxRect.united(labelRect));
                    } else {
                        titleRect = titleRule.boxRect(labelRect);
                    }
                    if (titleRule.hasBackground() && !titleRule.background()->isTransparent()) {
                        clipSet = true;
                        p->save();
                        p->setClipRegion(QRegion(opt->rect) - titleRect);
                    }
                }

                rule.drawRule(p, opt->rect);

                if (clipSet)
                    p->restore();

                // draw background and frame of the title
                if (hasTitle)
                    titleRule.drawRule(p, titleRect);

                // draw the indicator
                if (gb->subControls & QStyle::SC_GroupBoxCheckBox) {
                    QStyleOptionButton box;
                    box.QStyleOption::operator=(*gb);
                    box.rect = checkBoxRect;
                    drawPrimitive(PE_IndicatorCheckBox, &box, p, w);
                    drawPrimitive(PE_IndicatorCheckBox, &box, p, w);
                }

                // draw the text
                if (!gb->text.isEmpty()) {
                    int alignment = int(Qt::AlignCenter);
                    if (!styleHint(QStyle::SH_UnderlineShortcut, opt, w))
                        alignment |= Qt::TextHideMnemonic;

                    QPalette pal = gb->palette;
                    pal.setColor(QPalette::WindowText, gb->textColor);
                    titleRule.configurePalette(&pal, QPalette::WindowText, QPalette::Window);
                    drawItemText(p, labelRect,  alignment, pal, gb->state & State_Enabled,
                                 gb->text, QPalette::WindowText);
                }
            }
            return;
        }
        break;

    default:
        break;
    }

    baseStyle()->drawComplexControl(cc, opt, p, w);
}

Here is the call graph for this function:

void QStyleSheetStyle::drawControl	(	ControlElement	element,
		const QStyleOption *	opt,
		QPainter *	p,
		const QWidget *	w = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 1880 of file qstylesheetstyle.cpp.

References QRect::adjusted(), Qt::AlignCenter, QStyle::alignedRect(), Qt::AlignLeft, Qt::AlignVCenter, b, QRenderRule::background(), QPalette::Base, baseStyle(), QRenderRule::borderRect(), Qt::BottomLeftCorner, Qt::BottomRightCorner, QStyleSheetBackgroundData::brush, QPalette::Button, QPalette::ButtonText, QStyle::CC_ComboBox, QStyle::CE_CheckBox, QStyle::CE_CheckBoxLabel, QStyle::CE_ComboBoxLabel, QStyle::CE_MenuBarEmptyArea, QStyle::CE_MenuBarItem, QStyle::CE_MenuEmptyArea, QStyle::CE_MenuItem, QStyle::CE_PushButton, QStyle::CE_PushButtonBevel, QStyle::CE_PushButtonLabel, QStyle::CE_RadioButton, QStyle::CE_RadioButtonLabel, QStyle::CE_SizeGrip, QStyle::CE_Splitter, QStyle::CE_ToolBar, QRenderRule::configurePalette(), QRenderRule::contentsRect(), QIcon::Disabled, QRenderRule::drawBackground(), QRenderRule::drawBorder(), QWindowsStyle::drawControl(), QStyle::drawControl(), QCommonStyle::drawControl(), QRenderRule::drawFrame(), QRenderRule::drawImage(), drawItemPixmap(), drawItemText(), QStyle::drawPrimitive(), QRenderRule::drawRule(), QStyleOptionButton::features, QRenderRule::hasBackground(), QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasDrawable(), QRenderRule::hasImage(), QStyleOptionButton::HasMenu, hasStyleRule(), QPixmap::isNull(), QApplication::layoutDirection(), m, QIcon::Normal, p, QStyleOption::palette, QStyle::PE_IndicatorArrowDown, QStyleSheetBackgroundData::pixmap, positionRect(), PseudoElement_Item, PseudoElement_MenuIndicator, QStyleOption::rect, renderRule(), Qt::RightToLeft, QStyle::SC_ComboBoxEditField, QPalette::setBrush(), QRect::setWidth(), QRect::size(), QStyle::State_Enabled, subControlRect(), tb, Qt::TopLeftCorner, Qt::TopRightCorner, QRect::translate(), and w.

{
    if (!hasStyleRule(w)) {
        baseStyle()->drawControl(ce, opt, p, w);
        return;
    }

    QRenderRule rule = renderRule(w, opt);

    switch (ce) {
    // Push button
    case CE_PushButton:
        ParentStyle::drawControl(ce, opt, p, w);
        return;

    case CE_PushButtonBevel:
        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
            QStyleOptionButton btnOpt(*btn);
            btnOpt.rect = rule.borderRect(opt->rect);
            if (rule.hasBox() || rule.hasDrawable()
                || ((btn->features & QStyleOptionButton::HasMenu) && hasStyleRule(w, PseudoElement_MenuIndicator))) {
                if (rule.hasBox() || rule.hasDrawable()) {
                    rule.drawFrame(p, opt->rect);
                } else {
                    btnOpt.features &= ~QStyleOptionButton::HasMenu;
                    baseStyle()->drawControl(ce, &btnOpt, p, w);
                }

                if (btn->features & QStyleOptionButton::HasMenu) {
                    QRenderRule subRule = renderRule(w, opt, PseudoElement_MenuIndicator);
                    QRect ir = positionRect(rule, subRule, PseudoElement_MenuIndicator, opt->rect, opt->direction);
                    if (subRule.hasImage()) {
                        subRule.drawImage(p, ir);
                    } else {
                        btnOpt.rect = ir;
                        baseStyle()->drawPrimitive(PE_IndicatorArrowDown, &btnOpt, p, w);
                    }
                }
            } else {
                baseStyle()->drawControl(ce, &btnOpt, p, w);
            }
        }
        return;

    case CE_PushButtonLabel:
        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
            QStyleOptionButton butOpt(*btn);
            rule.configurePalette(&butOpt.palette, QPalette::ButtonText, QPalette::Button);
            ParentStyle::drawControl(ce, &butOpt, p, w);
        }
        return;

    case CE_RadioButton:
    case CE_CheckBox:
        rule.drawFrame(p, opt->rect);
        ParentStyle::drawControl(ce, opt, p, w);
        return;

    case CE_RadioButtonLabel:
    case CE_CheckBoxLabel:
        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
            QStyleOptionButton butOpt(*btn);
            rule.configurePalette(&butOpt.palette, QPalette::ButtonText, QPalette::Button);
            ParentStyle::drawControl(ce, &butOpt, p, w);
        }
        return;

    case CE_Splitter:
        if (rule.hasDrawable()) {
            rule.drawRule(p, opt->rect);
            return;
        }
        break;

    case CE_ToolBar:
        if (rule.hasBackground()) {
            rule.drawBackground(p, opt->rect);
        }
        if (rule.hasBorder()) {
            rule.drawBorder(p, rule.borderRect(opt->rect));
        } else {
#ifndef QT_NO_TOOLBAR
            if (const QStyleOptionToolBar *tb = qstyleoption_cast<const QStyleOptionToolBar *>(opt)) {
                QStyleOptionToolBar newTb(*tb);
                newTb.rect = rule.borderRect(opt->rect);
                baseStyle()->drawControl(ce, &newTb, p, w);
            }
#endif // QT_NO_TOOLBAR
        }
        return;

    case CE_MenuEmptyArea:
    case CE_MenuBarEmptyArea:
        if (rule.hasBackground()) {
            rule.drawBackground(p, opt->rect);
            return;
        }
        break;

    case CE_MenuBarItem:
    case CE_MenuItem:
        if (const QStyleOptionMenuItem *m = qstyleoption_cast<const QStyleOptionMenuItem *>(opt)) {
            QStyleOptionMenuItem mi(*m);
            QRenderRule subRule = renderRule(w, opt, PseudoElement_Item);
            mi.rect = subRule.contentsRect(opt->rect);
            rule.configurePalette(&mi.palette, QPalette::ButtonText, QPalette::Button);
            subRule.configurePalette(&mi.palette, QPalette::ButtonText, QPalette::Button);

            if (rule.hasBackground() || subRule.hasDrawable()) {
                if (rule.hasBackground() && !subRule.hasDrawable()) {
                    QBrush b;
                    if (!rule.background()->pixmap.isNull())
                        mi.palette.setBrush(QPalette::Button, QBrush(rule.background()->pixmap));
                    else
                        mi.palette.setBrush(QPalette::Button, QBrush(rule.background()->brush));
                    ParentStyle::drawControl(ce, &mi, p, w);
                }  else {
                    subRule.drawRule(p, opt->rect);   // item
                    QCommonStyle::drawControl(ce, &mi, p, w);          // text
                }
            } else {
                baseStyle()->drawControl(ce, &mi, p, w);
            }
        }
        return;

#ifndef QT_NO_COMBOBOX
    case CE_ComboBoxLabel:
        if (const QStyleOptionComboBox *cb = qstyleoption_cast<const QStyleOptionComboBox *>(opt)) {
            if (!rule.hasBox() && !rule.hasBorder())
                break;
            QRect editRect = subControlRect(CC_ComboBox, cb, SC_ComboBoxEditField, w);
            p->save();
            p->setClipRect(editRect);
            if (!cb->currentIcon.isNull()) {
                QIcon::Mode mode = cb->state & State_Enabled ? QIcon::Normal
                                                             : QIcon::Disabled;
                QPixmap pixmap = cb->currentIcon.pixmap(cb->iconSize, mode);
                QRect iconRect(editRect);
                iconRect.setWidth(cb->iconSize.width() + 4);
                iconRect = alignedRect(QApplication::layoutDirection(),
                                       Qt::AlignLeft | Qt::AlignVCenter,
                                       iconRect.size(), editRect);
                if (cb->editable)
                    p->fillRect(iconRect, opt->palette.brush(QPalette::Base));
                drawItemPixmap(p, iconRect, Qt::AlignCenter, pixmap);

                if (cb->direction == Qt::RightToLeft)
                    editRect.translate(-4 - cb->iconSize.width(), 0);
                else
                    editRect.translate(cb->iconSize.width() + 4, 0);
            }
            if (!cb->currentText.isEmpty() && !cb->editable) {
                drawItemText(p, editRect.adjusted(0, 0, 0, 0), Qt::AlignLeft | Qt::AlignVCenter, cb->palette,
                             cb->state & State_Enabled, cb->currentText);
            }
            p->restore();
            return;
        }
        break;
#endif // QT_NO_COMBOBOX

    case CE_SizeGrip:
        if (!rule.hasImage())
            break;
        if (const QStyleOptionSizeGrip *sgOpt = qstyleoption_cast<const QStyleOptionSizeGrip *>(opt)) {
            p->save();
            switch (sgOpt->corner) {
            case Qt::BottomRightCorner: break;
            case Qt::BottomLeftCorner: p->rotate(90); break;
            case Qt::TopLeftCorner: p->rotate(180); break;
            case Qt::TopRightCorner: p->rotate(270); break;
            default: break;
            }
            rule.drawImage(p, opt->rect);
            p->restore();
            return;
        }
        break;

    default:
        break;
    }

    baseStyle()->drawControl(ce, opt, p, w);
}

Here is the call graph for this function:

void QStyleSheetStyle::drawItemPixmap	(	QPainter *	painter,
		const QRect &	rect,
		int	alignment,
		const QPixmap &	pixmap
	)			const [virtual]

Draws the given pixmap in the specified rectangle, according to the specified alignment, using the provided painter.

See also:

drawItemText()

Reimplemented from QStyle.

Definition at line 2068 of file qstylesheetstyle.cpp.

References baseStyle(), QStyle::drawItemPixmap(), and p.

Referenced by drawControl().

{
    baseStyle()->drawItemPixmap(p, rect, alignment, pixmap);
}

Here is the call graph for this function:

void QStyleSheetStyle::drawItemText	(	QPainter *	painter,
		const QRect &	rect,
		int	alignment,
		const QPalette &	pal,
		bool	enabled,
		const QString &	text,
		QPalette::ColorRole	textRole = QPalette::NoRole
	)			const [virtual]

Draws the given text in the specified rectangle using the provided painter and palette.

The text is drawn using the painter's pen, and aligned and wrapped according to the specified alignment. If an explicit textRole is specified, the text is drawn using the palette's color for the given role. The enabled parameter indicates whether or not the item is enabled; when reimplementing this function, the enabled parameter should influence how the item is drawn.

See also:

Qt::Alignment, drawItemPixmap()

Reimplemented from QStyle.

Definition at line 2074 of file qstylesheetstyle.cpp.

References baseStyle(), and QStyle::drawItemText().

Referenced by drawComplexControl(), and drawControl().

{
    baseStyle()->drawItemText(painter, rect, alignment, pal, enabled, text, textRole);
}

Here is the call graph for this function:

void QStyleSheetStyle::drawPrimitive	(	PrimitiveElement	pe,
		const QStyleOption *	opt,
		QPainter *	p,
		const QWidget *	w = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 2080 of file qstylesheetstyle.cpp.

References QPalette::Base, baseStyle(), QRenderRule::borderRect(), QCss::BottomEdge, QRenderRule::box(), QRenderRule::configurePalette(), QRenderRule::drawBackground(), QRenderRule::drawBorder(), QRenderRule::drawFrame(), QStyle::drawPrimitive(), QRenderRule::drawRule(), QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasDrawable(), QRenderRule::hasGradientBackground(), hasStyleRule(), QCss::LeftEdge, m, QStyleSheetBoxData::margins, p, QStyleOption::palette, QStyle::PE_Frame, QStyle::PE_FrameDefaultButton, QStyle::PE_FrameGroupBox, QStyle::PE_FrameMenu, QStyle::PE_FrameStatusBar, QStyle::PE_IndicatorArrowDown, QStyle::PE_IndicatorArrowLeft, QStyle::PE_IndicatorArrowRight, QStyle::PE_IndicatorCheckBox, QStyle::PE_IndicatorMenuCheckMark, QStyle::PE_IndicatorRadioButton, QStyle::PE_IndicatorToolBarHandle, QStyle::PE_PanelButtonCommand, QStyle::PE_PanelLineEdit, QStyle::PE_PanelMenuBar, QStyle::PE_PanelTipLabel, QStyle::PE_Widget, PseudoElement_DownArrow, PseudoElement_Indicator, PseudoElement_Item, PseudoElement_None, QStyleOption::rect, renderRule(), QCss::RightEdge, QPalette::Text, QCss::TopEdge, and w.

Referenced by drawComplexControl().

{
    if (pe == PE_FrameStatusBar) {
        if (hasStyleRule(w->parentWidget())) {
            QRenderRule subRule = renderRule(w->parentWidget(), opt, PseudoElement_Item);
            if (subRule.hasDrawable()) {
                subRule.drawRule(p, opt->rect);
                return;
            }
        }
        baseStyle()->drawPrimitive(pe, opt, p, w);
        return;
    }

    if (!hasStyleRule(w)) {
        baseStyle()->drawPrimitive(pe, opt, p, w);
        return;
    }

    int pseudoElement = PseudoElement_None;

    QRenderRule rule = renderRule(w, opt);

    switch (pe) {
    case PE_IndicatorArrowDown:
        pseudoElement = PseudoElement_DownArrow;
        break;

    case PE_IndicatorRadioButton:
    case PE_IndicatorCheckBox:
        pseudoElement = PseudoElement_Indicator;
        break;

    case PE_PanelButtonCommand:
        if (!rule.hasBorder()) {
            baseStyle()->drawPrimitive(pe, opt, p, w);
        } else {
            rule.drawBorder(p, opt->rect);
        }
        return;

    // how do we specify these in the css?
    case PE_FrameDefaultButton:
        return;

    case PE_Frame:
    case PE_PanelLineEdit:
        if (const QStyleOptionFrame *frm = qstyleoption_cast<const QStyleOptionFrame *>(opt)) {
            // Only solid background brush is supported on a LineEdit
            if (!rule.hasBorder() && (pe == PE_Frame || !rule.hasGradientBackground())) {
                if (pe == PE_Frame)
                    rule.drawBackground(p, opt->rect);
                QStyleOptionFrame frmOpt(*frm);
                rule.configurePalette(&frmOpt.palette, QPalette::Text, QPalette::Base);
                frmOpt.rect = rule.borderRect(frmOpt.rect); // apply margin
                baseStyle()->drawPrimitive(pe, &frmOpt, p, w);
            } else {
                rule.drawFrame(p, opt->rect);
            }
        }
        return;

    case PE_Widget:
        rule.drawBackground(p, opt->rect);
        return;

    case PE_FrameMenu:
    case PE_PanelMenuBar:
        if (rule.hasBorder()) {
            rule.drawBorder(p, rule.borderRect(opt->rect));
            return;
        }
        break;

    case PE_IndicatorToolBarHandle:
        if (rule.hasDrawable()) {
            rule.drawRule(p, opt->rect);
            return;
        }
        break;

    // Menu stuff that would be nice to customize
    case PE_IndicatorMenuCheckMark:
    case PE_IndicatorArrowLeft:
    case PE_IndicatorArrowRight:
        baseStyle()->drawPrimitive(pe, opt, p, w);
        return;

    case PE_PanelTipLabel:
        if (rule.hasDrawable()) {
            rule.drawFrame(p, opt->rect);
            return;
        }
        break;

    case PE_FrameGroupBox:
        if (rule.hasBorder()) {
            QRect cr = opt->rect;
            if (rule.hasBox()) {
                const int *m = rule.box()->margins;
                cr = opt->rect.adjusted(-m[LeftEdge], -m[TopEdge], m[RightEdge], m[BottomEdge]);
            }
            rule.drawRule(p, cr);
            return;
        }
        break;

    default:
        break;
    }

    if (pseudoElement != PseudoElement_None) {
        QRenderRule subRule = renderRule(w, opt, pseudoElement);
        if (subRule.hasDrawable()) {
            subRule.drawRule(p, opt->rect);
        } else {
            baseStyle()->drawPrimitive(pe, opt, p, w);
        }
    } else {
        baseStyle()->drawPrimitive(pe, opt, p, w);
    }
}

Here is the call graph for this function:

QPixmap QStyleSheetStyle::generatedIconPixmap	(	QIcon::Mode	iconMode,
		const QPixmap &	pixmap,
		const QStyleOption *	option
	)			const [virtual]

Reimplemented from QCommonStyle.

Definition at line 2204 of file qstylesheetstyle.cpp.

References baseStyle(), and QStyle::generatedIconPixmap().

{
    return baseStyle()->generatedIconPixmap(iconMode, pixmap, option);
}

Here is the call graph for this function:

QStyle::SubControl QStyleSheetStyle::hitTestComplexControl	(	ComplexControl	cc,
		const QStyleOptionComplex *	opt,
		const QPoint &	pt,
		const QWidget *	w = 0
	)			const [virtual]

Reimplemented from QCommonStyle.

Definition at line 2210 of file qstylesheetstyle.cpp.

References baseStyle(), QStyle::CC_ComboBox, QStyle::CC_GroupBox, QStyle::CC_Slider, QCommonStyle::hitTestComplexControl(), QStyle::hitTestComplexControl(), and w.

{
    switch (cc) {
    case CC_GroupBox:
    case CC_ComboBox:
    case CC_Slider:
        return ParentStyle::hitTestComplexControl(cc, opt, pt, w);
    default:
        break;
    }

    return baseStyle()->hitTestComplexControl(cc, opt, pt, w);
}

Here is the call graph for this function:

QRect QStyleSheetStyle::itemPixmapRect	(	const QRect &	rect,
		int	alignment,
		const QPixmap &	pixmap
	)			const [virtual]

Returns the area within the given rectangle in which to draw the specified pixmap according to the defined alignment.

Reimplemented from QStyle.

Definition at line 2225 of file qstylesheetstyle.cpp.

References baseStyle(), and QStyle::itemPixmapRect().

{
    return baseStyle()->itemPixmapRect(rect, alignment, pixmap);
}

Here is the call graph for this function:

QRect QStyleSheetStyle::itemTextRect	(	const QFontMetrics &	metrics,
		const QRect &	rect,
		int	alignment,
		bool	enabled,
		const QString &	text
	)			const [virtual]

Returns the area within the given rectangle in which to draw the provided text according to the specified font metrics and alignment. The enabled parameter indicates whether or not the associated item is enabled.

If the given rectangle is larger than the area needed to render the text, the rectangle that is returned will be offset within rectangle according to the specified alignment. For example, if alignment is Qt::AlignCenter, the returned rectangle will be centered within rectangle. If the given rectangle is smaller than the area needed, the returned rectangle will be the smallest rectangle large enough to render the text.

See also:

Qt::Alignment

Reimplemented from QStyle.

Definition at line 2230 of file qstylesheetstyle.cpp.

References baseStyle(), QStyle::itemTextRect(), and metrics().

{
    return baseStyle()->itemTextRect(metrics, rect, alignment, enabled, text);
}

Here is the call graph for this function:

int QStyleSheetStyle::pixelMetric	(	PixelMetric	metric,
		const QStyleOption *	option = 0,
		const QWidget *	widget = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 2236 of file qstylesheetstyle.cpp.

References baseStyle(), QRenderRule::border(), QStyleSheetBorderData::borders, QRenderRule::box(), QRenderRule::boxSize(), QRenderRule::contentsSize(), QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasContentsSize(), QRenderRule::hasDrawable(), hasStyleRule(), QSize::height(), QCss::LeftEdge, QStyleSheetBoxData::margins, QRenderRule::minimumContentsSize(), QStyleSheetBoxData::paddings, QStyle::pixelMetric(), QStyle::PM_ButtonDefaultIndicator, QStyle::PM_ButtonMargin, QStyle::PM_ButtonShiftHorizontal, QStyle::PM_ButtonShiftVertical, QStyle::PM_CheckBoxLabelSpacing, QStyle::PM_DefaultFrameWidth, QStyle::PM_ExclusiveIndicatorHeight, QStyle::PM_ExclusiveIndicatorWidth, QStyle::PM_IndicatorHeight, QStyle::PM_IndicatorWidth, QStyle::PM_MenuBarHMargin, QStyle::PM_MenuBarItemSpacing, QStyle::PM_MenuBarPanelWidth, QStyle::PM_MenuBarVMargin, QStyle::PM_MenuButtonIndicator, QStyle::PM_MenuDesktopFrameWidth, QStyle::PM_MenuHMargin, QStyle::PM_MenuPanelWidth, QStyle::PM_MenuScrollerHeight, QStyle::PM_MenuTearoffHeight, QStyle::PM_MenuVMargin, QStyle::PM_SmallIconSize, QStyle::PM_SplitterWidth, QStyle::PM_ToolBarExtensionExtent, QStyle::PM_ToolBarFrameWidth, QStyle::PM_ToolBarHandleExtent, QStyle::PM_ToolBarItemMargin, QStyle::PM_ToolBarItemSpacing, QStyle::PM_ToolTipLabelFrameWidth, PseudoElement_GroupBoxTitle, PseudoElement_Indicator, PseudoElement_MenuIndicator, renderRule(), QStyleSheetBoxData::spacing, QCss::TopEdge, w, QSize::width(), and width.

Referenced by sizeFromContents(), and subControlRect().

{
    if (!hasStyleRule(w))
        return baseStyle()->pixelMetric(m, opt, w);

    QRenderRule rule = renderRule(w, opt);
    QRenderRule subRule;

    switch (m) {
    case PM_MenuButtonIndicator:
        subRule = renderRule(w, opt, PseudoElement_MenuIndicator);
        if (subRule.hasContentsSize())
            return subRule.contentsSize().width();
        break;

    case PM_ButtonShiftHorizontal:
    case PM_ButtonShiftVertical:
    case PM_ButtonMargin:
        // do it with the padding, if you want a shift
        if (rule.hasBox() || rule.hasDrawable())
            return 0;

    case PM_DefaultFrameWidth:
    case PM_ButtonDefaultIndicator:
        break;

    case PM_ExclusiveIndicatorWidth:
    case PM_IndicatorWidth:
    case PM_ExclusiveIndicatorHeight:
    case PM_IndicatorHeight:
        subRule = renderRule(w, PseudoElement_Indicator);
        if (subRule.hasContentsSize()) {
            return (m == PM_ExclusiveIndicatorWidth) || (m == PM_IndicatorWidth)
                        ? subRule.contentsSize().width()
                        : subRule.contentsSize().height();
        }
        break;

    case PM_ToolTipLabelFrameWidth: // border + margin + padding (support only one width)
    case PM_ToolBarFrameWidth:
        if (rule.hasBorder() || rule.hasBox())
            return (rule.border() ? rule.border()->borders[LeftEdge] : 0)
                   + (rule.hasBox() ? rule.box()->margins[LeftEdge] + rule.box()->paddings[LeftEdge]: 0);
        break;

    case PM_MenuPanelWidth:  // border + margin + padding (support only one width)
    case PM_MenuBarPanelWidth:
        if (rule.hasBorder() || rule.hasBox())
            return (rule.border() ? rule.border()->borders[LeftEdge] : 0)
                   + (rule.hasBox() ? rule.box()->margins[LeftEdge]: 0);
        break;


    case PM_MenuHMargin:
    case PM_MenuBarHMargin:
        if (rule.hasBox())
            return rule.box()->paddings[LeftEdge];
        break;

    case PM_ToolBarItemMargin:
    case PM_MenuVMargin:
    case PM_MenuBarVMargin:
        if (rule.hasBox())
            return rule.box()->paddings[TopEdge];
        break;

    case PM_ToolBarItemSpacing:
    case PM_MenuBarItemSpacing:
        if (rule.hasBox() && rule.box()->spacing != -1)
            return rule.box()->spacing;
        break;

    case PM_SmallIconSize:
    case PM_MenuDesktopFrameWidth:
    case PM_MenuTearoffHeight:
    case PM_MenuScrollerHeight:
        break;
    case PM_ToolBarExtensionExtent:
        break;

    case PM_ToolBarHandleExtent:
        if (rule.hasBox() || rule.hasBorder() || rule.hasContentsSize())
            return rule.boxSize(rule.contentsSize()).expandedTo(rule.minimumContentsSize()).width();

    case PM_SplitterWidth:
        if (rule.hasContentsSize())
            return rule.contentsSize().width();
        break;

    case PM_CheckBoxLabelSpacing: // group box
        subRule = renderRule(w, PseudoElement_GroupBoxTitle);
        if (subRule.hasBox() && subRule.box()->spacing != -1)
            return subRule.box()->spacing;
        break;

    default:
        break;
    }

    return baseStyle()->pixelMetric(m, opt, w);
}

Here is the call graph for this function:

void QStyleSheetStyle::polish

(

QWidget *

widget

)

[virtual]

Reimplemented from QWindowsStyle.

Definition at line 1691 of file qstylesheetstyle.cpp.

References baseStyle(), QObject::connect(), QObject::destroyed(), QVector< T >::isEmpty(), QStyle::polish(), renderRulesCache, setPalette(), SIGNAL, SLOT, styleRules(), styleRulesCache, unsetPalette(), unstylable(), updateWidget(), w, and widgetDestroyed().

{
    if (styleRulesCache->contains(w))
        return;

    baseStyle()->polish(w);
    if (unstylable(w))
        return;

    QObject::connect(w, SIGNAL(destroyed(QObject*)), this, SLOT(widgetDestroyed(QObject*)));
    renderRulesCache->remove(w);
    QVector<QCss::StyleRule> rules = styleRules(w);
    styleRulesCache->insert(w, rules);
    unsetPalette(w);
    if (!rules.isEmpty()) {
        setPalette(w);
    }
    updateWidget(w);
}

Here is the call graph for this function:

void QStyleSheetStyle::polish

(

QApplication *

app

)

[virtual]

Reimplemented from QWindowsStyle.

Definition at line 1711 of file qstylesheetstyle.cpp.

References baseStyle(), QStyle::polish(), renderRulesCache, and styleRulesCache.

{
    styleRulesCache->clear();
    renderRulesCache->clear();
    baseStyle()->polish(app);
}

Here is the call graph for this function:

void QStyleSheetStyle::polish

(

QPalette &

pal

)

[virtual]

Reimplemented from QWindowsStyle.

Definition at line 1718 of file qstylesheetstyle.cpp.

References baseStyle(), and QStyle::polish().

{
    baseStyle()->polish(pal);
}

Here is the call graph for this function:

QSize QStyleSheetStyle::sizeFromContents	(	ContentsType	ct,
		const QStyleOption *	opt,
		const QSize &	contentsSize,
		const QWidget *	widget = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 2338 of file qstylesheetstyle.cpp.

References baseStyle(), QRenderRule::box(), QRenderRule::boxSize(), QRenderRule::contentsSize(), QStyle::CT_CheckBox, QStyle::CT_ComboBox, QStyle::CT_GroupBox, QStyle::CT_LineEdit, QStyle::CT_Menu, QStyle::CT_MenuBar, QStyle::CT_MenuBarItem, QStyle::CT_MenuItem, QStyle::CT_ProgressBar, QStyle::CT_PushButton, QStyle::CT_RadioButton, QStyle::CT_SizeGrip, QStyle::CT_SpinBox, QStyle::CT_Splitter, QSize::expandedTo(), QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasContentsSize(), QRenderRule::hasDrawable(), QRenderRule::hasGradientBackground(), hasStyleRule(), QRenderRule::minimumContentsSize(), pixelMetric(), QStyle::PM_ExclusiveIndicatorHeight, QStyle::PM_ExclusiveIndicatorWidth, QStyle::PM_IndicatorHeight, QStyle::PM_IndicatorWidth, PseudoElement_GroupBoxIndicator, PseudoElement_GroupBoxTitle, PseudoElement_Indicator, PseudoElement_Item, qMax(), renderRule(), QSize::setHeight(), QStyle::sizeFromContents(), QWindowsStyle::sizeFromContents(), QStyleSheetBoxData::spacing, spacing, and w.

{
    if (!hasStyleRule(w)) {
#ifndef QT_NO_SPINBOX
        // don't touch the size of a embedded lineedit in a styled spin box
        if (ct == CT_LineEdit && w && qobject_cast<QAbstractSpinBox *>(w->parentWidget())
            && hasStyleRule(w->parentWidget())) {
            QRenderRule rule = renderRule(w->parentWidget(), opt);
            if (rule.hasBox() || rule.hasBorder())
                return csz;
        }
#endif
        return baseStyle()->sizeFromContents(ct, opt, csz, w);
    }

    QRenderRule rule = renderRule(w, opt);
    QSize sz = csz.expandedTo(rule.minimumContentsSize());

    switch (ct) {
    case CT_PushButton:
        if (rule.hasBorder() || rule.hasBox())
            return rule.boxSize(sz);
        break;

    case CT_LineEdit: // does not contains fw
        if (rule.hasBorder() || rule.hasGradientBackground()) {
            return rule.boxSize(sz);
        } else {
            // What follows is a really ugly hack to support padding with native frames
            QSize baseSize = baseStyle()->sizeFromContents(ct, opt, sz, w);
            if (!rule.hasBox())
                return baseSize;
            QSize parentSize = ParentStyle::sizeFromContents(ct, opt, sz, w);
            if (parentSize != baseSize)
                return baseSize;
            return rule.boxSize(baseSize);
        }
        break;

    case CT_CheckBox:
    case CT_RadioButton:
        if (const QStyleOptionButton *btn = qstyleoption_cast<const QStyleOptionButton *>(opt)) {
            if (rule.hasBox() || rule.hasBorder() || hasStyleRule(w, PseudoElement_Indicator)) {
                bool isRadio = (ct == CT_RadioButton);
                int iw = pixelMetric(isRadio ? PM_ExclusiveIndicatorWidth
                                             : PM_IndicatorWidth, btn, w);
                int ih = pixelMetric(isRadio ? PM_ExclusiveIndicatorHeight
                                             : PM_IndicatorHeight, btn, w);

                QSize margins(0, 0);
                if (!rule.hasBox() && !rule.hasBorder())
                    margins = QSize((!btn->icon.isNull() && btn->text.isEmpty()) ? 0 : 10, 4);
                int spacing = rule.hasBox() ? rule.box()->spacing : -1;
                if (spacing == -1)
                    spacing = 6;
                sz = sz + QSize(iw + spacing, 0) + margins;
                sz.setHeight(qMax(sz.height(), ih));
                return rule.boxSize(sz);
            }
        }
        break;

    case CT_GroupBox:
        if (rule.hasDrawable() || rule.hasBox() || hasStyleRule(w, PseudoElement_GroupBoxTitle)
            || hasStyleRule(w, PseudoElement_GroupBoxIndicator))
            return rule.boxSize(sz);
        break;

    case CT_Menu:
    case CT_MenuBar: // already has everything!
        if (rule.hasBox() || rule.hasBorder())
            return sz;
        break;

    case CT_MenuItem:
    case CT_MenuBarItem:
        if (hasStyleRule(w, PseudoElement_Item)) {
            QRenderRule subRule = renderRule(w, opt, PseudoElement_Item);
            if (subRule.hasBox() || subRule.hasBorder())
                return subRule.boxSize(sz);
        }
        break;

    case CT_ComboBox:
        if (rule.hasBox() || rule.hasBorder())
            return rule.boxSize(sz);
        break;

    case CT_SpinBox:
        if (rule.hasBox() || rule.hasBorder())
            return sz;

    case CT_SizeGrip:
        if (rule.hasContentsSize())
            return rule.contentsSize();
        break;

    case CT_Splitter:
    case CT_ProgressBar:
        if (rule.hasBorder() || rule.hasBox())
            return rule.boxSize(sz);
        break;

    default:
        break;
    }

    return baseStyle()->sizeFromContents(ct, opt, sz, w);
}

Here is the call graph for this function:

QIcon QStyleSheetStyle::standardIcon	(	StandardPixmap	standardIcon,
		const QStyleOption *	option,
		const QWidget *	w = 0
	)			const

Since:

4.1

Returns an icon for the given standardIcon.

The standardIcon is a standard pixmap which can follow some existing GUI style or guideline. The option argument can be used to pass extra information required when defining the appropriate icon. The widget argument is optional and can also be used to aid the determination of the icon.

Warning:

Because of binary compatibility constraints, this function is not virtual. If you want to provide your own icons in a QStyle subclass, reimplement the standardIconImplementation() slot in your subclass instead. The standardIcon() function will dynamically detect the slot and call it.

See also:

standardIconImplementation(), standardPixmap()

Reimplemented from QStyle.

Definition at line 2458 of file qstylesheetstyle.cpp.

References baseStyle(), QStyle::standardIcon(), and w.

{
    return baseStyle()->standardIcon(standardIcon, option, w);
}

Here is the call graph for this function:

QPalette QStyleSheetStyle::standardPalette

(

)

const [virtual]

Returns the style's standard palette.

Note that on systems that support system colors, the style's standard palette is not used.

Reimplemented from QStyle.

Definition at line 2464 of file qstylesheetstyle.cpp.

References baseStyle(), and QStyle::standardPalette().

{
    return baseStyle()->standardPalette();
}

Here is the call graph for this function:

QPixmap QStyleSheetStyle::standardPixmap	(	StandardPixmap	standardPixmap,
		const QStyleOption *	option = 0,
		const QWidget *	w = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 2469 of file qstylesheetstyle.cpp.

References baseStyle(), QStyle::standardPixmap(), and w.

{
    return baseStyle()->standardPixmap(standardPixmap, option, w);
}

Here is the call graph for this function:

int QStyleSheetStyle::styleHint	(	StyleHint	sh,
		const QStyleOption *	opt = 0,
		const QWidget *	w = 0,
		QStyleHintReturn *	shret = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 2475 of file qstylesheetstyle.cpp.

References baseStyle(), QStyleSheetPaletteData::foreground, QRenderRule::hasPalette(), QRenderRule::hasStyleHint(), hasStyleRule(), QColor::isValid(), QRenderRule::palette(), renderRule(), QColor::rgba(), s, QStyle::SH_ComboBox_ListMouseTracking, QStyle::SH_ComboBox_Popup, QStyle::SH_DialogButtonLayout, QStyle::SH_DitherDisabledText, QStyle::SH_DrawMenuBarSeparator, QStyle::SH_EtchDisabledText, QStyle::SH_GroupBox_TextLabelColor, QStyle::SH_ItemView_ActivateItemOnSingleClick, QStyle::SH_ItemView_ShowDecorationSelected, QStyle::SH_LineEdit_PasswordCharacter, QStyle::SH_MenuBar_AltKeyNavigation, QStyle::SH_MenuBar_MouseTracking, QStyle::SH_MessageBox_TextInteractionFlags, QStyle::SH_SpinBox_ClickAutoRepeatRate, QStyle::SH_SpinControls_DisableOnBounds, QStyle::SH_Table_GridLineColor, QStyle::SH_ToolTipLabel_Opacity, QStyle::styleHint(), QRenderRule::styleHint(), and w.

Referenced by drawComplexControl().

{
    if (!hasStyleRule(w))
        return baseStyle()->styleHint(sh, opt, w, shret);

    QRenderRule rule = renderRule(w, opt);
    QString s;
    switch (sh) {
        case SH_LineEdit_PasswordCharacter: s = "lineedit-password-character"; break;
        case SH_DitherDisabledText: s = "dither-disabled-text"; break;
        case SH_EtchDisabledText: s = "etch-disabled-text"; break;
        case SH_ItemView_ActivateItemOnSingleClick: s = "activate-on-singleclick"; break;
        case SH_ItemView_ShowDecorationSelected: s = "show-decoration-selected"; break;
        case SH_Table_GridLineColor: s = "gridline-color"; break;
        case SH_DialogButtonLayout: s = "button-layout"; break;
        case SH_ToolTipLabel_Opacity: s = "opacity"; break;
        case SH_ComboBox_Popup: s = "combobox-popup"; break;
        case SH_ComboBox_ListMouseTracking: s = "combobox-list-mousetracking"; break;
        case SH_MenuBar_AltKeyNavigation: s = "menubar-altkey-navigation"; break;
        case SH_DrawMenuBarSeparator: s = "menubar-separator"; break;
        case SH_MenuBar_MouseTracking: s = "mouse-tracking"; break;
        case SH_SpinBox_ClickAutoRepeatRate: s = "spinbox-click-autorepeat-rate"; break;
        case SH_SpinControls_DisableOnBounds: s = "spincontrol-disable-on-bounds"; break;
        case SH_MessageBox_TextInteractionFlags: s = "messagebox-text-interaction-flags"; break;
        case SH_GroupBox_TextLabelColor:
            if (rule.hasPalette() && rule.palette()->foreground.isValid())
                return rule.palette()->foreground.rgba();
        default: break;
    }
    if (!s.isEmpty() && rule.hasStyleHint(s)) {
        return rule.styleHint(s);
    }

    return baseStyle()->styleHint(sh, opt, w, shret);
}

Here is the call graph for this function:

QRect QStyleSheetStyle::subElementRect	(	SubElement	r,
		const QStyleOption *	opt,
		const QWidget *	widget = 0
	)			const [virtual]

Reimplemented from QWindowsStyle.

Definition at line 2614 of file qstylesheetstyle.cpp.

References baseStyle(), QRenderRule::box(), QRenderRule::contentsRect(), QStyleOption::direction, QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasGradientBackground(), hasStyleRule(), QRect::height(), QRect::left(), positionRect(), PseudoElement_Indicator, QStyleOption::rect, renderRule(), QStyle::SE_CheckBoxClickRect, QStyle::SE_CheckBoxContents, QStyle::SE_CheckBoxFocusRect, QStyle::SE_CheckBoxIndicator, QStyle::SE_FrameContents, QStyle::SE_LineEditContents, QStyle::SE_PushButtonContents, QStyle::SE_PushButtonFocusRect, QStyle::SE_RadioButtonClickRect, QStyle::SE_RadioButtonContents, QStyle::SE_RadioButtonFocusRect, QStyle::SE_RadioButtonIndicator, QRect::setRect(), QStyleSheetBoxData::spacing, spacing, QStyle::subElementRect(), QWindowsStyle::subElementRect(), QStyle::visualRect(), w, QRect::width(), and QRect::y().

{
    if (!hasStyleRule(w))
        return baseStyle()->subElementRect(se, opt, w);

    QRenderRule rule = renderRule(w, opt);
    QRenderRule subRule;

    switch (se) {
    // PushButton
    case SE_PushButtonContents:
    case SE_PushButtonFocusRect:
        if (rule.hasBorder() || rule.hasBox())
            return visualRect(opt->direction, opt->rect, rule.contentsRect(opt->rect));
        break;

    case SE_LineEditContents:
    case SE_FrameContents:
        if (rule.hasBorder() || (se != SE_FrameContents && rule.hasGradientBackground())) {
            return visualRect(opt->direction, opt->rect, rule.contentsRect(opt->rect));
        } else {
            // ugly hack to support native frames with padding
            QRect baseRect = baseStyle()->subElementRect(se, opt, w);
            if (!rule.hasBox())
                return baseRect;
            QRect parentRect = ParentStyle::subElementRect(se, opt, w);
            if (baseRect != parentRect)
                return baseRect;
            return visualRect(opt->direction, opt->rect, rule.contentsRect(baseRect));
        }
        break;

    case SE_CheckBoxIndicator:
    case SE_RadioButtonIndicator:
        if (rule.hasBox() || rule.hasBorder() || hasStyleRule(w, PseudoElement_Indicator)) {
            QRenderRule subRule = renderRule(w, opt, PseudoElement_Indicator);
            return positionRect(rule, subRule, PseudoElement_Indicator, opt->rect, opt->direction);
        }
        break;

    case SE_CheckBoxContents:
    case SE_RadioButtonContents:
        if (rule.hasBox() || rule.hasBorder() || hasStyleRule(w, PseudoElement_Indicator)) {
            bool isRadio = se == SE_RadioButtonContents;
            QRect ir = subElementRect(isRadio ? SE_RadioButtonIndicator : SE_CheckBoxIndicator,
                                      opt, w);
            ir = visualRect(opt->direction, opt->rect, ir);
            int spacing = rule.hasBox() ? rule.box()->spacing : -1;
            if (spacing == -1)
                spacing = 6;
            QRect cr = rule.contentsRect(opt->rect);
            ir.setRect(ir.left() + ir.width() + spacing, cr.y(),
                       cr.width() - ir.width() - spacing, cr.height());
            return visualRect(opt->direction, opt->rect, ir);
        }
        break;

    case SE_RadioButtonFocusRect:
    case SE_RadioButtonClickRect: // focusrect | indicator
    case SE_CheckBoxFocusRect:
    case SE_CheckBoxClickRect: // relies on indicator and contents
        return ParentStyle::subElementRect(se, opt, w);

    default:
        break;
    }

    return baseStyle()->subElementRect(se, opt, w);
}

Here is the call graph for this function:

QRect QStyleSheetStyle::subControlRect	(	ComplexControl	cc,
		const QStyleOptionComplex *	opt,
		SubControl	sc,
		const QWidget *	w = 0
	)			const [virtual]

Reimplemented from QCommonStyle.

Definition at line 2512 of file qstylesheetstyle.cpp.

References baseStyle(), QRenderRule::borderRect(), QStyle::CC_ComboBox, QStyle::CC_GroupBox, QStyle::CC_SpinBox, QRect::center(), QRenderRule::contentsRect(), QStyleOption::direction, QRenderRule::geo, QRenderRule::hasBorder(), QRenderRule::hasBox(), QRenderRule::hasDrawable(), QRenderRule::hasGeometry(), hasStyleRule(), QRect::left(), pixelMetric(), QStyle::PM_CheckBoxLabelSpacing, QStyle::PM_IndicatorHeight, QStyle::PM_IndicatorWidth, positionRect(), PseudoElement_DropDown, PseudoElement_GroupBoxIndicator, PseudoElement_GroupBoxTitle, PseudoElement_SpinBoxDownButton, PseudoElement_SpinBoxUpButton, qMax(), QStyleOption::rect, renderRule(), QStyle::SC_ComboBoxArrow, QStyle::SC_ComboBoxEditField, QStyle::SC_ComboBoxFrame, QStyle::SC_ComboBoxListBoxPopup, QStyle::SC_GroupBoxCheckBox, QStyle::SC_GroupBoxContents, QStyle::SC_GroupBoxFrame, QStyle::SC_GroupBoxLabel, QStyle::SC_SpinBoxDown, QStyle::SC_SpinBoxEditField, QStyle::SC_SpinBoxFrame, QStyle::SC_SpinBoxUp, QRect::setLeft(), QRect::setTop(), spacing, QStyle::subControlRect(), w, and QPoint::y().

Referenced by drawComplexControl(), and drawControl().

{
    if (!hasStyleRule(w))
        return baseStyle()->subControlRect(cc, opt, sc, w);

    QRenderRule rule = renderRule(w, opt);
    switch (cc) {
    case CC_ComboBox:
        if (rule.hasBorder() || rule.hasBox() || hasStyleRule(w, PseudoElement_DropDown)) {
            switch (sc) {
            case SC_ComboBoxArrow: {
                QRenderRule subRule = renderRule(w, PseudoElement_DropDown);
                return positionRect(rule, subRule, PseudoElement_DropDown, opt->rect, opt->direction);
                break;
                                   }
            case SC_ComboBoxEditField:
                return rule.contentsRect(opt->rect);
            case SC_ComboBoxFrame:
                return rule.contentsRect(opt->rect);
            case SC_ComboBoxListBoxPopup:
            default:
               return opt->rect;
            }
        }
        break;

    case CC_SpinBox:
        if (rule.hasBorder() || rule.hasBox() || hasStyleRule(w, PseudoElement_SpinBoxUpButton)
            || hasStyleRule(w, PseudoElement_SpinBoxDownButton)) {
            switch (sc) {
            case SC_SpinBoxUp:
            case SC_SpinBoxDown: {
                int pe = (sc == SC_SpinBoxUp ? PseudoElement_SpinBoxUpButton : PseudoElement_SpinBoxDownButton);
                QRenderRule subRule = renderRule(w, opt, pe);
                return positionRect(rule, subRule, pe, opt->rect, opt->direction);
            }
            case SC_SpinBoxEditField:
            case SC_SpinBoxFrame:
                return rule.contentsRect(opt->rect);
            default:
                return opt->rect;
            }
        }
        break;

    case CC_GroupBox:
        if (rule.hasDrawable() || rule.hasBox() || hasStyleRule(w, PseudoElement_GroupBoxTitle)
            || hasStyleRule(w, PseudoElement_GroupBoxIndicator)) {
            if (const QStyleOptionGroupBox *gb = qstyleoption_cast<const QStyleOptionGroupBox *>(opt)) {
                switch (sc) {
                case SC_GroupBoxFrame:
                    return rule.borderRect(opt->rect);
                case SC_GroupBoxContents:
                    return rule.contentsRect(opt->rect);
                default:
                case SC_GroupBoxLabel:
                case SC_GroupBoxCheckBox: {
                    QRenderRule labelRule = renderRule(w, opt, PseudoElement_GroupBoxTitle);
                    int tw = opt->fontMetrics.width(gb->text);
                    int th = opt->fontMetrics.height();
                    int spacing = pixelMetric(QStyle::PM_CheckBoxLabelSpacing, opt, w);
                    int iw = pixelMetric(QStyle::PM_IndicatorWidth, opt, w);
                    int ih = pixelMetric(QStyle::PM_IndicatorHeight, opt, w);

                    if (gb->subControls & QStyle::SC_GroupBoxCheckBox) {
                        tw = tw + iw + spacing;
                        th = qMax(th, ih);
                    }
                    if (!labelRule.hasGeometry()) {
                        labelRule.geo = new QStyleSheetGeometryData(tw, th, tw, th);
                    } else {
                        labelRule.geo->width = tw;
                        labelRule.geo->height = th;
                    }
                    QRect r = positionRect(rule, labelRule, PseudoElement_GroupBoxTitle,
                                          opt->rect, opt->direction);
                    if (gb->subControls & SC_GroupBoxCheckBox) {
                        r = labelRule.contentsRect(r);
                        if (sc == SC_GroupBoxLabel) {
                            r.setLeft(r.left() + iw + spacing);
                            r.setTop(r.center().y() - th/2);
                        } else {
                            r = QRect(r.left(), r.center().y() - ih/2, iw, ih);
                        }
                        return r;
                    } else {
                        return labelRule.contentsRect(r);
                    }
                }
                }
            }
        }
        break;

    default:
        break;
    }

    return baseStyle()->subControlRect(cc, opt, sc, w);
}

Here is the call graph for this function:

void QStyleSheetStyle::setBaseStyle

(

QStyle *

style

)

[inline]

Definition at line 93 of file qstylesheetstyle_p.h.

References base.

{ base = style; }

QStyle * QStyleSheetStyle::baseStyle

(

)

const

Definition at line 1648 of file qstylesheetstyle.cpp.

References base, and qApp.

Referenced by drawComplexControl(), drawControl(), drawItemPixmap(), drawItemText(), drawPrimitive(), generatedIconPixmap(), hitTestComplexControl(), itemPixmapRect(), itemTextRect(), pixelMetric(), polish(), renderRule(), sizeFromContents(), standardIcon(), standardPalette(), standardPixmap(), styleHint(), subControlRect(), subElementRect(), and unpolish().

{
    if (base)
        return base;
    if (QStyleSheetStyle *me = qobject_cast<QStyleSheetStyle *>(qApp->style()))
        return me->base;
    return qApp->style();
}

void QStyleSheetStyle::repolish

(

QWidget *

widget

)

Definition at line 1723 of file qstylesheetstyle.cpp.

References QList< T >::append(), QObject::children(), styleSheetCache, updateWidgets(), and w.

Referenced by QWidgetPrivate::inheritStyle(), QApplication::setStyleSheet(), and QWidget::setStyleSheet().

{
    QList<const QWidget *> children = qFindChildren<const QWidget *>(w, QString());
    children.append(w);
    styleSheetCache->remove(w);
    updateWidgets(children);
}

Here is the call graph for this function:

void QStyleSheetStyle::repolish

(

QApplication *

app

)

Definition at line 1731 of file qstylesheetstyle.cpp.

References styleRulesCache, styleSheetCache, and updateWidgets().

{
    styleSheetCache->remove(0);
    updateWidgets(styleRulesCache->keys());
}

Here is the call graph for this function:

void QStyleSheetStyle::unpolish

(

QWidget *

widget

)

[virtual]

Reimplemented from QWindowsStyle.

Definition at line 1737 of file qstylesheetstyle.cpp.

References baseStyle(), QObject::destroyed(), QObject::disconnect(), renderRulesCache, SIGNAL, SLOT, styleRulesCache, styleSheetCache, QStyle::unpolish(), unsetPalette(), w, and widgetDestroyed().

{
    styleRulesCache->remove(w);
    renderRulesCache->remove(w);
    styleSheetCache->remove(w);
    baseStyle()->unpolish(w);
    unsetPalette(w);
    QObject::disconnect(w, SIGNAL(destroyed(QObject*)),
                       this, SLOT(widgetDestroyed(QObject*)));
}

Here is the call graph for this function:

void QStyleSheetStyle::unpolish

(

QApplication *

app

)

[virtual]

Reimplemented from QWindowsStyle.

Definition at line 1748 of file qstylesheetstyle.cpp.

References baseStyle(), renderRulesCache, styleRulesCache, styleSheetCache, and QStyle::unpolish().

{
    styleRulesCache->clear();
    renderRulesCache->clear();
    styleSheetCache->remove(0);
    baseStyle()->unpolish(app);
}

Here is the call graph for this function:

void QStyleSheetStyle::ref

(

)

[inline]

Definition at line 102 of file qstylesheetstyle_p.h.

References refcount.

{ ++refcount; }

void QStyleSheetStyle::deref

(

)

[inline]

Definition at line 103 of file qstylesheetstyle_p.h.

References refcount.

{ Q_ASSERT(refcount > 0); if (!--refcount) delete this; }

QIcon QStyleSheetStyle::standardIconImplementation	(	StandardPixmap	standardIcon,
		const QStyleOption *	opt = 0,
		const QWidget *	widget = 0
	)			const [protected, slot]

Since:

4.1

Returns an icon for the given standardIcon.

Reimplement this slot to provide your own icons in a QStyle subclass; because of binary compatibility constraints, the standardIcon() function (introduced in Qt 4.1) is not virtual. Instead, standardIcon() will dynamically detect and call this slot. The default implementation simply calls the standardPixmap() function with the given parameters.

The standardIcon is a standard pixmap which can follow some existing GUI style or guideline. The option argument can be used to pass extra information required when defining the appropriate icon. The widget argument is optional and can also be used to aid the determination of the icon.

See also:

standardIcon()

Reimplemented from QWindowsStyle.

Definition at line 2452 of file qstylesheetstyle.cpp.

References QCommonStyle::standardIconImplementation().

{
    return QCommonStyle::standardIconImplementation(standardIcon, opt, widget);
}

void QStyleSheetStyle::widgetDestroyed

(

QObject *

)

[private, slot]

Definition at line 1657 of file qstylesheetstyle.cpp.

References customPaletteWidgets, o, renderRulesCache, and styleRulesCache.

Referenced by polish(), and unpolish().

{
    styleRulesCache->remove((const QWidget *)o);
    renderRulesCache->remove((const QWidget *)o);
    customPaletteWidgets->remove((const QWidget *)o);
}

void QStyleSheetStyle::setPalette

(

QWidget *

w

)

[private]

Definition at line 1558 of file qstylesheetstyle.cpp.

References QPalette::Active, customFontWidgets, customPaletteWidgets, QPalette::Disabled, embeddedWidget(), QRenderRule::hasDrawable(), i, QPalette::Inactive, p, PseudoElement_Item, PseudoElement_None, renderRule(), QStyle::State_Enabled, QStyle::State_MouseOver, QStyle::State_None, w, and Qt::WA_Hover.

Referenced by polish().

{
    const QRenderRule &hoverRule = renderRule(w, PseudoElement_None, QStyle::State_MouseOver);
    if (hoverRule.hasDrawable())
        w->setAttribute(Qt::WA_Hover);

    // put stuff for which palette is not set here
#ifndef QT_NO_MENUBAR
    if (qobject_cast<QMenuBar *>(w)) {
        // MenuBar has autoFillBackground set which does not play well with our stuff
        const QRenderRule& subRule = renderRule(w, PseudoElement_Item, QStyle::State_MouseOver);
        if (subRule.hasDrawable())
            w->setAttribute(Qt::WA_Hover);
        return;
    }
#endif

    struct RuleRoleMap {
        QStyle::StateFlag state;
        QPalette::ColorGroup group;
    } map[3] = {
        { QStyle::State_Enabled, QPalette::Active },
        { QStyle::State_None, QPalette::Disabled },
        { QStyle::State_Enabled, QPalette::Inactive }
    };

    QPalette p = w->palette();
    QWidget *ew = embeddedWidget(w);

    for (int i = 0; i < 3; i++) {
        QRenderRule rule = renderRule(w, PseudoElement_None, map[i].state);
        if (i == 0) {
            customFontWidgets->insert(w, rule.font.resolve() & ~w->font().resolve());
            w->setFont(rule.font);
        }

        rule.configurePalette(&p, map[i].group, ew, ew != w);
    }

    if (w->palette() != p) {
        customPaletteWidgets->insert(w, p.resolve() & ~w->palette().resolve());
        w->setPalette(p);
    }
}

Here is the call graph for this function:

QRenderRule QStyleSheetStyle::renderRule	(	const QWidget *	,
		const QString &	,
		QStyle::State	= QStyle::State_None
	)			const [private]

Definition at line 1312 of file qstylesheetstyle.cpp.

References QVector< T >::at(), baseStyle(), Qt::CaseInsensitive, QString::compare(), QHash< Key, T >::contains(), i, QCss::PseudoState_Disabled, QCss::PseudoState_Enabled, QCss::PseudoState_Focus, QCss::PseudoState_Hover, QCss::PseudoState_Indeterminate, QCss::PseudoState_Off, QCss::PseudoState_On, QCss::PseudoState_Pressed, QCss::PseudoState_Unspecified, QStyle::State_Enabled, QStyle::State_HasFocus, QStyle::State_MouseOver, QStyle::State_NoChange, QStyle::State_Off, QStyle::State_On, QStyle::State_Selected, QStyle::State_Sunken, styleRules(), styleRulesCache, and w.

Referenced by drawComplexControl(), drawControl(), drawPrimitive(), pixelMetric(), renderRule(), setPalette(), sizeFromContents(), styleHint(), subControlRect(), and subElementRect().

{
    Q_ASSERT(w);
    Q_ASSERT(styleRulesCache->contains(w)); // style sheet rules must have been computed!
    const QVector<StyleRule> styleRules = styleRulesCache->value(w);
    QHash<int, QRenderRule> &renderRules = (*renderRulesCache)[w][part];

    int pseudoState = (state & QStyle::State_Enabled)
                                 ? PseudoState_Enabled : PseudoState_Disabled;
    if (state & QStyle::State_Sunken)
        pseudoState |= PseudoState_Pressed;
    if (state & QStyle::State_MouseOver || state & QStyle::State_Selected)
        pseudoState |= PseudoState_Hover;
    if (state & QStyle::State_HasFocus)
        pseudoState |= PseudoState_Focus;
    if (state & QStyle::State_On)
        pseudoState |= PseudoState_On;
    if (state & QStyle::State_Off)
        pseudoState |= PseudoState_Off;
    if (state & QStyle::State_NoChange)
        pseudoState |= PseudoState_Indeterminate;

    if (renderRules.contains(pseudoState))
        return renderRules[pseudoState]; // already computed before

    QVector<Declaration> declarations;
    for (int i = 0; i < styleRules.count(); i++) {
        const Selector& selector = styleRules.at(i).selectors.at(0);
        // Rules with pseudo elements don't cascade. This is an intentional
        // diversion for CSS
        if (part.compare(selector.pseudoElement(), Qt::CaseInsensitive) != 0)
            continue;
        const int cssState = selector.pseudoState();
        if ((cssState == PseudoState_Unspecified) || ((cssState & pseudoState) == cssState))
            declarations += styleRules.at(i).declarations;
    }

    QRenderRule newRule(declarations, w, part, baseStyle());
    renderRules[pseudoState] = newRule;
    return newRule;
}

Here is the call graph for this function:

QRenderRule QStyleSheetStyle::renderRule	(	const QWidget *	,
		int	,
		QStyle::State	= QStyle::State_None
	)			const [private]

Definition at line 1355 of file qstylesheetstyle.cpp.

References knownPseudoElements, name, renderRule(), and w.

{
    return renderRule(w, knownPseudoElements[pseudoElement].name, state);
}

Here is the call graph for this function:

QRenderRule QStyleSheetStyle::renderRule	(	const QWidget *	,
		const QStyleOption *	,
		int	= 0
	)			const [private]

Definition at line 1360 of file qstylesheetstyle.cpp.

References knownPseudoElements, name, PseudoElement_DropDown, PseudoElement_DropDownArrow, PseudoElement_GroupBoxTitle, PseudoElement_None, PseudoElement_SpinBoxDownArrow, PseudoElement_SpinBoxDownButton, PseudoElement_SpinBoxUpArrow, PseudoElement_SpinBoxUpButton, renderRule(), QStyle::SC_ComboBoxEditField, QStyleOption::state, QStyle::State_Enabled, QStyle::State_MouseOver, QStyle::State_None, QStyle::State_Off, QStyle::State_On, QStyle::State_Sunken, QAbstractSpinBox::StepDownEnabled, QAbstractSpinBox::StepUpEnabled, styleRulesCache, PseudoElementInfo::subControl, and w.

{
    Q_ASSERT(w && !styleRulesCache->value(w).isEmpty());
    QStyle::State state = opt ? opt->state : QStyle::State(QStyle::State_None);

    if (const QStyleOptionComplex *complex = qstyleoption_cast<const QStyleOptionComplex *>(opt)) {
        if (pseudoElement != PseudoElement_None) {
            // if not an active subcontrol, just pass enabled/disabled
            QStyle::SubControl subControl = knownPseudoElements[pseudoElement].subControl;

            if (!(complex->activeSubControls & subControl))
                state = QStyle::State(opt->state & QStyle::State_Enabled);
        }

        switch (pseudoElement) {
        case PseudoElement_DropDown:
        case PseudoElement_DropDownArrow:
            state |= (opt->state & QStyle::State_On); // propagate popup state as on/off
            break;
        case PseudoElement_SpinBoxUpButton:
        case PseudoElement_SpinBoxDownButton:
        case PseudoElement_SpinBoxUpArrow:
        case PseudoElement_SpinBoxDownArrow:
#ifndef QT_NO_SPINBOX
            if (const QStyleOptionSpinBox *sb = qstyleoption_cast<const QStyleOptionSpinBox *>(opt)) {
                bool on = false;
                bool up = pseudoElement == PseudoElement_SpinBoxUpButton
                          || pseudoElement == PseudoElement_SpinBoxUpArrow;
                if ((sb->stepEnabled & QAbstractSpinBox::StepUpEnabled) && up)
                    on = true;
                else if ((sb->stepEnabled & QAbstractSpinBox::StepDownEnabled) && !up)
                    on = true;
                state |= (on ? QStyle::State_On : QStyle::State_Off);
            }
#endif // QT_NO_SPINBOX
            break;
        case PseudoElement_GroupBoxTitle:
            state |= (opt->state & (QStyle::State_MouseOver | QStyle::State_Sunken));
            break;
        case PseudoElement_None:
        default:
            // QStyle::State_On is set when the popup is being shown
            // Propagate EditField Pressed state
            if ((complex->activeSubControls & QStyle::SC_ComboBoxEditField)
                && (!(opt->state & QStyle::State_MouseOver)))
                state = opt->state | QStyle::State_Sunken;
        }
    } else {
        // Add hacks for simple controls here
#ifndef QT_NO_LINEEDIT
        // LineEdit sets Sunken flag to indicate Sunken frame (argh)
        if (qobject_cast<const QLineEdit *>(w)) {
            state &= ~QStyle::State_Sunken;
        } else
#endif
#ifndef QT_NO_MENUBAR
        if (qobject_cast<const QMenuBar *>(w)) {
            if (state & QStyle::State_Sunken) {
                state &= ~QStyle::State_Sunken;
                state |= QStyle::State_On;
            }
        } else
#endif
        { } // required for the above ifdef'ery
    }

    return renderRule(w, knownPseudoElements[pseudoElement].name, state);
}

Here is the call graph for this function:

bool QStyleSheetStyle::hasStyleRule	(	const QWidget *	,
		int	= 0
	)			const [private]

Definition at line 1429 of file qstylesheetstyle.cpp.

References QVector< T >::at(), Qt::CaseInsensitive, QString::compare(), QVector< T >::count(), i, QVector< T >::isEmpty(), knownPseudoElements, PseudoElementInfo::name, PseudoElement_None, QCss::StyleRule::selectors, styleRules(), styleRulesCache, and w.

Referenced by drawComplexControl(), drawControl(), drawPrimitive(), pixelMetric(), sizeFromContents(), styleHint(), subControlRect(), and subElementRect().

{
    const QVector<StyleRule> &styleRules = styleRulesCache->value(w);
    if (part == PseudoElement_None)
        return w && !styleRules.isEmpty();

    // ### cache the result
    QString pseudoElement = knownPseudoElements[part].name;
    QVector<Declaration> declarations;
    for (int i = 0; i < styleRules.count(); i++) {
        const Selector& selector = styleRules.at(i).selectors.at(0);
        if (pseudoElement.compare(selector.pseudoElement(), Qt::CaseInsensitive) == 0)
            return true;
    }

    return false;
}

Here is the call graph for this function:

---

Member Data Documentation

QStyle* QStyleSheetStyle::base

Definition at line 101 of file qstylesheetstyle_p.h.

Referenced by baseStyle(), QWidgetPrivate::inheritStyle(), and QApplication::setStyleSheet().

int QStyleSheetStyle::refcount [private]

Definition at line 118 of file qstylesheetstyle_p.h.

---

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

• src/gui/styles/qstylesheetstyle_p.h
• src/gui/styles/qstylesheetstyle.cpp

---