QStyle Class

./myapplication -style windows

void MyWidget::paintEvent(QPaintEvent * /* event */)
{
    QPainter painter(this);

    QStyleOptionFocusRect option;
    option.initFrom(this);
    option.backgroundColor = palette().color(QPalette::Background);

    style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter, this);
}

    QStylePainter painter(this);
    ...
    painter.drawPrimitive(QStyle::PE_FrameFocusRect, option);

    QPainter painter(this);
    ...
    style()->drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter, this);

class CustomStyle : public QProxyStyle
{
    Q_OBJECT

public:
    CustomStyle(const QWidget *widget);
    ~CustomStyle() {}

    void drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                       QPainter *painter, const QWidget *widget) const override;
};

void CustomStyle::drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                                QPainter *painter, const QWidget *widget) const
{
    if (element == PE_IndicatorSpinUp || element == PE_IndicatorSpinDown) {
        QPolygon points(3);
        int x = option->rect.x();
        int y = option->rect.y();
        int w = option->rect.width() / 2;
        int h = option->rect.height() / 2;
        x += (option->rect.width() - w) / 2;
        y += (option->rect.height() - h) / 2;

        if (element == PE_IndicatorSpinUp) {
            points[0] = QPoint(x, y + h);
            points[1] = QPoint(x + w, y + h);
            points[2] = QPoint(x + w / 2, y);
        } else { // PE_SpinBoxDown
            points[0] = QPoint(x, y);
            points[1] = QPoint(x + w, y);
            points[2] = QPoint(x + w / 2, y + h);
        }

        if (option->state & State_Enabled) {
            painter->setPen(option->palette.mid().color());
            painter->setBrush(option->palette.buttonText());
        } else {
            painter->setPen(option->palette.buttonText().color());
            painter->setBrush(option->palette.mid());
        }
        painter->drawPolygon(points);
    } else {
        QProxyStyle::drawPrimitive(element, option, painter, widget);
    }
}

    const QSpinBox *spinBox = qobject_cast<const QSpinBox *>(widget);
    if (spinBox) {
    ...
    }

#include <QtWidgets>

#include "customstyle.h"

int main(int argc, char *argv[])
{
    QApplication::setStyle(new CustomStyle);
    QApplication app(argc, argv);
    QSpinBox spinBox;
    spinBox.show();
    return app.exec();
}

./myapplication -style custom

    switch (element) {
        case (PE_PanelItemViewItem): {
            painter->save();

            QPoint topLeft = option->rect.topLeft();
            QPoint bottomRight = option->rect.topRight();
            QLinearGradient backgroundGradient(topLeft, bottomRight);
            backgroundGradient.setColorAt(0.0, QColor(Qt::yellow).lighter(190));
            backgroundGradient.setColorAt(1.0, Qt::white);
            painter->fillRect(option->rect, QBrush(backgroundGradient));

            painter->restore();
        break;
        }
        default:
            QProxyStyle::drawPrimitive(element, option, painter, widget);
    }

Dokumentation der Mitgliedsfunktionen

QStyle::QStyle()

Konstruiert ein Style-Objekt.

[virtual noexcept] QStyle::~QStyle()

Zerstört das Stilobjekt.

[static] QRect QStyle::alignedRect(Qt::LayoutDirection direction, Qt::Alignment alignment, const QSize &size, const QRect &rectangle)

Gibt ein neues Rechteck mit dem angegebenen size zurück, das gemäß den angegebenen alignment und direction an dem angegebenen rectangle ausgerichtet ist.

int QStyle::combinedLayoutSpacing(QSizePolicy::ControlTypes controls1, QSizePolicy::ControlTypes controls2, Qt::Orientation orientation, QStyleOption *option = nullptr, QWidget *widget = nullptr) const

Gibt den Abstand zurück, der zwischen controls1 und controls2 in einem Layout verwendet werden soll. orientation gibt an, ob die Steuerelemente nebeneinander oder vertikal gestapelt angeordnet sind. Der Parameter option kann verwendet werden, um zusätzliche Informationen über das übergeordnete Widget zu übergeben. Der Parameter widget ist optional und kann auch verwendet werden, wenn option nullptr ist.

controls1 und controls2 eine ODER-Kombination von null oder mehr control types sind.

Diese Funktion wird durch das Layoutsystem aufgerufen. Sie wird nur verwendet, wenn PM_LayoutHorizontalSpacing oder PM_LayoutVerticalSpacing einen negativen Wert liefert.

Siehe auch layoutSpacing().

[pure virtual] void QStyle::drawComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex *option, QPainter *painter, const QWidget *widget = nullptr) const

Zeichnet das angegebene control unter Verwendung des angegebenen painter mit den durch option angegebenen Stiloptionen.

Das Argument widget ist optional und kann als Hilfe beim Zeichnen des Steuerelements verwendet werden.

Der Parameter option ist ein Zeiger auf ein QStyleOptionComplex Objekt, das mit der Funktion qstyleoption_cast() in die richtige Unterklasse gecastet werden kann. Beachten Sie, dass der rect Member des angegebenen option in logischen Koordinaten vorliegen muss. Reimplementierungen dieser Funktion sollten visualRect() verwenden, um die logischen Koordinaten in Bildschirmkoordinaten umzuwandeln, bevor sie die Funktion drawPrimitive() oder drawControl() aufrufen.

In der folgenden Tabelle sind die komplexen Steuerelemente und die ihnen zugeordnete Unterklasse der Stiloptionen aufgeführt. Die Stiloptionen enthalten alle Parameter, die zum Zeichnen der Steuerelemente erforderlich sind, einschließlich QStyleOption::state, das die style flags enthält, die beim Zeichnen verwendet werden. Die Tabelle beschreibt auch die Flags, die gesetzt werden, wenn die angegebene option auf die entsprechende Unterklasse gecastet wird.

Siehe auch drawPrimitive() und drawControl().

[pure virtual] void QStyle::drawControl(QStyle::ControlElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget = nullptr) const

Zeichnet das angegebene element mit dem angegebenen painter mit den durch option angegebenen Stiloptionen.

Das Argument widget ist optional und kann als Hilfe beim Zeichnen des Steuerelements verwendet werden. Der Parameter option ist ein Zeiger auf ein QStyleOption Objekt, das mit der Funktion qstyleoption_cast() in die richtige Unterklasse umgewandelt werden kann.

In der nachstehenden Tabelle sind die Steuerelemente und die ihnen zugeordnete Unterklasse der Stiloptionen aufgeführt. Die Stiloptionen enthalten alle Parameter, die zum Zeichnen der Steuerelemente erforderlich sind, einschließlich QStyleOption::state, das die Stilflags enthält, die beim Zeichnen verwendet werden. Die Tabelle beschreibt auch die Flags, die gesetzt werden, wenn die gegebene Option auf die entsprechende Unterklasse gecastet wird.

Wenn ein Steuerelement hier nicht aufgeführt ist, liegt das daran, dass es ein einfaches QStyleOption Objekt verwendet.

Siehe auch drawPrimitive() und drawComplexControl().

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

Zeichnet die angegebene pixmap in der angegebenen rectangle, entsprechend der angegebenen alignment, unter Verwendung der angegebenen painter.

Siehe auch drawItemText().

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

Zeichnet den angegebenen text im angegebenen rectangle unter Verwendung der angegebenen painter und palette.

Der Text wird mit dem Stift des Malers gezeichnet und entsprechend der angegebenen alignment ausgerichtet und umbrochen. Wenn ein expliziter textRole angegeben wird, wird der Text mit der Farbe palette für die angegebene Rolle gezeichnet. Der Parameter enabled gibt an, ob das Element aktiviert ist oder nicht; bei der Neuimplementierung dieser Funktion sollte der Parameter enabled beeinflussen, wie das Element gezeichnet wird.

Siehe auch Qt::Alignment und drawItemPixmap().

[pure virtual] void QStyle::drawPrimitive(QStyle::PrimitiveElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget = nullptr) const

Zeichnet das angegebene primitive element mit dem angegebenen painter unter Verwendung der durch option angegebenen Stiloptionen.

Das Argument widget ist optional und kann ein Widget enthalten, das beim Zeichnen des primitiven Elements helfen kann.

In der nachstehenden Tabelle sind die primitiven Elemente und die ihnen zugeordneten Unterklassen der Stiloptionen aufgeführt. Die Stiloptionen enthalten alle Parameter, die zum Zeichnen der Elemente erforderlich sind, einschließlich QStyleOption::state, das die Stilflags enthält, die beim Zeichnen verwendet werden. Die Tabelle beschreibt auch die Flags, die gesetzt werden, wenn die gegebene Option auf die entsprechende Unterklasse gecastet wird.

Wenn ein primitives Element hier nicht aufgeführt ist, liegt das daran, dass es ein einfaches QStyleOption Objekt verwendet.

Siehe auch drawComplexControl() und drawControl().

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

Gibt eine Kopie des angegebenen pixmap zurück, die so gestylt ist, dass sie dem angegebenen iconMode entspricht und die durch option angegebene Palette berücksichtigt.

Der Parameter option kann zusätzliche Informationen übergeben, muss aber eine Palette enthalten.

Beachten Sie, dass nicht alle Pixmaps konform sind. In diesem Fall ist die zurückgegebene Pixmap eine einfache Kopie.

Siehe auch QIcon.

[pure virtual] QStyle::SubControl QStyle::hitTestComplexControl(QStyle::ComplexControl control, const QStyleOptionComplex *option, const QPoint &position, const QWidget *widget = nullptr) const

Liefert das Untersteuerelement am angegebenen position im angegebenen Komplex control (mit den durch option angegebenen Stiloptionen).

Beachten Sie, dass die position in Bildschirmkoordinaten ausgedrückt wird.

Das Argument option ist ein Zeiger auf ein QStyleOptionComplex Objekt (oder eine seiner Unterklassen). Das Objekt kann mit der Funktion qstyleoption_cast() in den entsprechenden Typ umgewandelt werden. Siehe drawComplexControl() für Details. Das Argument widget ist optional und kann zusätzliche Informationen für die Funktion enthalten.

Siehe auch drawComplexControl() und subControlRect().

[virtual] QRect QStyle::itemPixmapRect(const QRect &rectangle, int alignment, const QPixmap &pixmap) const

Gibt den Bereich innerhalb des angegebenen rectangle zurück, in dem der angegebene pixmap gemäß der Definition alignment gezeichnet werden soll.

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

Gibt den Bereich innerhalb des angegebenen rectangle zurück, in dem der angegebene text entsprechend der angegebenen Schriftart metrics und alignment gezeichnet werden soll. Der Parameter enabled gibt an, ob das zugehörige Element aktiviert ist oder nicht.

Wenn der angegebene rectangle größer ist als der Bereich, der zum Rendern von text benötigt wird, wird das zurückgegebene Rechteck innerhalb von rectangle entsprechend dem angegebenen alignment versetzt. Wenn alignment beispielsweise Qt::AlignCenter ist, wird das zurückgegebene Rechteck innerhalb von rectangle zentriert. Wenn der angegebene rectangle kleiner als der benötigte Bereich ist, wird das zurückgegebene Rechteck das kleinste Rechteck sein, das groß genug ist, um text darzustellen.

Siehe auch Qt::Alignment.

[pure virtual] int QStyle::layoutSpacing(QSizePolicy::ControlType control1, QSizePolicy::ControlType control2, Qt::Orientation orientation, const QStyleOption *option = nullptr, const QWidget *widget = nullptr) const

Gibt den Abstand zurück, der zwischen control1 und control2 in einem Layout verwendet werden soll. orientation gibt an, ob die Steuerelemente nebeneinander oder vertikal gestapelt angeordnet sind. Der Parameter option kann verwendet werden, um zusätzliche Informationen über das übergeordnete Widget zu übergeben. Der Parameter widget ist optional und kann auch verwendet werden, wenn option gleich nullptr ist.

Diese Funktion wird vom Layoutsystem aufgerufen. Sie wird nur verwendet, wenn PM_LayoutHorizontalSpacing oder PM_LayoutVerticalSpacing einen negativen Wert zurückgibt.

Siehe auch combinedLayoutSpacing().

[since 6.1] QString QStyle::name() const

Gibt den Namen des Stils zurück.

Dieser Wert kann verwendet werden, um einen Stil mit QStyleFactory::create() zu erstellen.

Diese Funktion wurde in Qt 6.1 eingeführt.

Siehe auch QStyleFactory::create().

[pure virtual] int QStyle::pixelMetric(QStyle::PixelMetric metric, const QStyleOption *option = nullptr, const QWidget *widget = nullptr) const

Gibt den Wert des angegebenen Pixels metric zurück.

Die angegebenen option und widget können für die Berechnung der Metrik verwendet werden. Der Wert option kann mit der Funktion qstyleoption_cast() in den entsprechenden Typ umgewandelt werden. Beachten Sie, dass die option auch bei PixelMetrics, die sie verwenden können, Null sein kann. In der folgenden Tabelle finden Sie die entsprechenden Umwandlungen von option:

Einige Pixelmetriken werden von Widgets aufgerufen und einige werden nur intern vom Stil aufgerufen. Wenn die Metrik nicht von einem Widget aufgerufen wird, liegt es im Ermessen des Stilautors, sie zu verwenden. Für einige Stile ist dies möglicherweise nicht sinnvoll.

[virtual] void QStyle::polish(QWidget *widget)

Initialisiert das Erscheinungsbild des angegebenen Widgets widget.

Diese Funktion wird für jedes Widget zu einem Zeitpunkt aufgerufen, nachdem es vollständig erstellt wurde, aber kurz bevor es zum ersten Mal angezeigt wird.

Beachten Sie, dass die Standardimplementierung nichts tut. Sinnvolle Aktionen in dieser Funktion könnten sein, die QWidget::setBackgroundMode() Funktion für das Widget aufzurufen. Verwenden Sie die Funktion nicht, um z.B. die Geometrie zu setzen. Die Reimplementierung dieser Funktion bietet eine Hintertür, durch die das Erscheinungsbild eines Widgets geändert werden kann, aber mit der Style-Engine von Qt ist es nur selten notwendig, diese Funktion zu implementieren; implementieren Sie stattdessen drawItemPixmap(), drawItemText(), drawPrimitive(), etc.

Die Funktion QWidget::inherits() kann genügend Informationen liefern, um klassenspezifische Anpassungen zu ermöglichen. Da aber von neuen QStyle Unterklassen erwartet wird, dass sie mit allen aktuellen und zukünftigen Widgets vernünftig funktionieren, wird eine begrenzte Verwendung von hart kodierten Anpassungen empfohlen.

Siehe auch unpolish().

[virtual] void QStyle::polish(QApplication *application)

Dies ist eine überladene Funktion.

Späte Initialisierung des angegebenen application Objekts.

[virtual] void QStyle::polish(QPalette &palette)

Dies ist eine überladene Funktion.

Ändert die palette gemäß den stil-spezifischen Anforderungen für Farbpaletten (falls vorhanden).

Siehe auch QPalette und QApplication::setPalette().

const QStyle *QStyle::proxy() const

Diese Funktion gibt den aktuellen Proxy für diesen Stil zurück. Standardmäßig werden die meisten Stile sich selbst zurückgeben. Wenn jedoch ein Proxy-Stil verwendet wird, erlaubt sie dem Stil, auf seinen Proxy zurückzugreifen.

[pure virtual] QSize QStyle::sizeFromContents(QStyle::ContentsType type, const QStyleOption *option, const QSize &contentsSize, const QWidget *widget = nullptr) const

Gibt die Größe des Elements zurück, das durch die angegebenen option und type beschrieben wird, basierend auf dem angegebenen contentsSize.

Das Argument option ist ein Zeiger auf eine QStyleOption oder eine ihrer Unterklassen. Die option kann mit der Funktion qstyleoption_cast() in den entsprechenden Typ umgewandelt werden. widget ist ein optionales Argument und kann zusätzliche Informationen enthalten, die zur Berechnung der Größe verwendet werden.

In der nachstehenden Tabelle finden Sie die entsprechenden Umwandlungen von option:

Siehe auch ContentsType und QStyleOption.

[static] int QStyle::sliderPositionFromValue(int min, int max, int logicalValue, int span, bool upsideDown = false)

Konvertiert die angegebene logicalValue in eine Pixelposition. Der Parameter min wird auf 0 abgebildet, max wird auf span abgebildet und die anderen Werte werden gleichmäßig dazwischen verteilt.

Diese Funktion kann den gesamten Integer-Bereich ohne Überlauf verarbeiten, vorausgesetzt, span ist kleiner als 4096.

Standardmäßig geht diese Funktion davon aus, dass der Höchstwert bei horizontalen Elementen rechts und bei vertikalen Elementen unten liegt. Setzen Sie den Parameter upsideDown auf true, um dieses Verhalten umzukehren.

Siehe auch sliderValueFromPosition().

[static] int QStyle::sliderValueFromPosition(int min, int max, int position, int span, bool upsideDown = false)

Wandelt das angegebene Pixel position in einen logischen Wert um. 0 entspricht dem Parameter min, span entspricht max und die anderen Werte werden gleichmäßig dazwischen verteilt.

Diese Funktion kann den gesamten Integer-Bereich ohne Überlauf verarbeiten.

Standardmäßig geht diese Funktion davon aus, dass der Höchstwert bei horizontalen Elementen rechts und bei vertikalen Elementen unten liegt. Setzen Sie den Parameter upsideDown auf true, um dieses Verhalten umzukehren.

Siehe auch sliderPositionFromValue().

[pure virtual] QIcon QStyle::standardIcon(QStyle::StandardPixmap standardIcon, const QStyleOption *option = nullptr, const QWidget *widget = nullptr) const

Liefert ein Symbol für das angegebene standardIcon.

Die standardIcon ist eine Standard-Pixmap, die einem bestehenden GUI-Stil oder einer Richtlinie folgen kann. Das Argument option kann verwendet werden, um zusätzliche Informationen zu übergeben, die bei der Definition des entsprechenden Symbols benötigt werden. Das Argument widget ist optional und kann ebenfalls verwendet werden, um die Bestimmung des Symbols zu unterstützen.

[virtual] QPalette QStyle::standardPalette() const

Gibt die Standardpalette des Stils zurück.

Beachten Sie, dass auf Systemen, die Systemfarben unterstützen, die Standardpalette des Stils nicht verwendet wird. Insbesondere die Stile für Windows Vista und Mac verwenden nicht die Standardpalette, sondern nutzen native Theme-Engines. Bei diesen Stilen sollten Sie die Palette nicht mit QApplication::setPalette() festlegen.

Siehe auch QApplication::setPalette().

[pure virtual] int QStyle::styleHint(QStyle::StyleHint hint, const QStyleOption *option = nullptr, const QWidget *widget = nullptr, QStyleHintReturn *returnData = nullptr) const

Gibt eine Ganzzahl zurück, die den angegebenen Stil hint für den gegebenen widget beschreibt, der durch den angegebenen Stil option beschrieben wird.

returnData wird verwendet, wenn das abfragende Widget detailliertere Daten benötigt als die Ganzzahl, die styleHint() zurückgibt. Siehe die QStyleHintReturn Klassenbeschreibung für Details.

[pure virtual] QRect QStyle::subControlRect(QStyle::ComplexControl control, const QStyleOptionComplex *option, QStyle::SubControl subControl, const QWidget *widget = nullptr) const

Gibt das Rechteck zurück, das die angegebene subControl des angegebenen Komplexes control (mit dem durch option angegebenen Stil) enthält. Das Rechteck ist in Bildschirmkoordinaten definiert.

Das Argument option ist ein Zeiger auf QStyleOptionComplex oder eine seiner Unterklassen und kann mit der Funktion qstyleoption_cast() in den entsprechenden Typ umgewandelt werden. Siehe drawComplexControl() für Details. Das widget ist optional und kann zusätzliche Informationen für die Funktion enthalten.

Siehe auch drawComplexControl().

[pure virtual] QRect QStyle::subElementRect(QStyle::SubElement element, const QStyleOption *option, const QWidget *widget = nullptr) const

Liefert den Teilbereich für das angegebene element, wie im angegebenen Stil option beschrieben. Das zurückgegebene Rechteck ist in Bildschirmkoordinaten definiert.

Das Argument widget ist optional und kann als Hilfsmittel zur Bestimmung des Bereichs verwendet werden. Das Objekt QStyleOption kann mit der Funktion qstyleoption_cast() in den entsprechenden Typ umgewandelt werden. In der nachstehenden Tabelle finden Sie die entsprechenden Umwandlungen von option:

[virtual] void QStyle::unpolish(QWidget *widget)

Entinitialisiere das Aussehen der angegebenen widget.

Diese Funktion ist das Gegenstück zu polish(). Sie wird für jedes polierte Widget aufgerufen, wenn der Stil dynamisch geändert wird; der frühere Stil muss seine Einstellungen aufpolieren, bevor der neue Stil sie wieder polieren kann.

Beachten Sie, dass unpolish() nur aufgerufen wird, wenn das Widget zerstört wird. Dies kann in einigen Fällen zu Problemen führen, z.B. wenn Sie ein Widget aus der Benutzeroberfläche entfernen, es zwischenspeichern und dann wieder einfügen, nachdem der Stil geändert wurde; einige der Qt-Klassen zwischenspeichern ihre Widgets.

Siehe auch polish().

[virtual] void QStyle::unpolish(QApplication *application)

Dies ist eine überladene Funktion.

Entinitialisiert die angegebene application.

[static] Qt::Alignment QStyle::visualAlignment(Qt::LayoutDirection direction, Qt::Alignment alignment)

Wandelt ein alignment von Qt::AlignLeft oder Qt::AlignRight ohne Qt::AlignAbsolute in Qt::AlignLeft oder Qt::AlignRight mit Qt::AlignAbsolute entsprechend dem Layout direction um. Die anderen Ausrichtungsflags bleiben unberührt.

Wenn keine horizontale Ausrichtung angegeben wurde, gibt die Funktion die Standardausrichtung für das angegebene Layout direction zurück.

QWidget::layoutDirection

[static] QPoint QStyle::visualPos(Qt::LayoutDirection direction, const QRect &boundingRectangle, const QPoint &logicalPosition)

Gibt die angegebene logicalPosition in Bildschirmkoordinaten umgewandelt auf der Grundlage der angegebenen direction zurück. Die boundingRectangle wird bei der Übersetzung verwendet.

Siehe auch QWidget::layoutDirection.

[static] QRect QStyle::visualRect(Qt::LayoutDirection direction, const QRect &boundingRectangle, const QRect &logicalRectangle)

Gibt die angegebene logicalRectangle in Bildschirmkoordinaten umgewandelt auf der Grundlage der angegebenen direction zurück. Die boundingRectangle wird bei der Übersetzung verwendet.

Diese Funktion wird zur Unterstützung von Rechts-nach-Links-Desktops bereitgestellt und wird normalerweise in Implementierungen der Funktion subControlRect() verwendet.

Siehe auch QWidget::layoutDirection.