QStyle Class

./myapplication -style windows

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

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

    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:
    explicit CustomStyle(const QWidget *widget = nullptr);
    ~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 zu Mitgliedsfunktionen

QStyle::QStyle()

Erstellt ein Stilobjekt.

[virtual noexcept] QStyle::~QStyle()

Löscht das Stilobjekt.

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

Gibt ein neues Rechteck mit den angegebenen Koordinaten „ size “ zurück, das entsprechend den angegebenen Werten „ alignment “ und „ direction “ an den angegebenen Koordinaten „ 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 in einem Layout zwischen controls1 und controls2 verwendet werden soll. orientation legt fest, ob die Steuerelemente nebeneinander oder vertikal übereinander angeordnet werden. 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 auf nullptr gesetzt ist.

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

Diese Funktion wird vom Layout-System aufgerufen. Sie wird nur verwendet, wenn „ PM_LayoutHorizontalSpacing “ oder „ PM_LayoutVerticalSpacing “ einen negativen Wert zurückgibt.

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 bereitgestellten ` painter ` mit den durch ` option` festgelegten 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 mithilfe der Funktion „ qstyleoption_cast()“ in die richtige Unterklasse umgewandelt werden kann. Beachten Sie, dass das Element „ rect “ des angegebenen „ option “ in logischen Koordinaten vorliegen muss. Neuimplementierungen dieser Funktion sollten „ visualRect()“ verwenden, um die logischen Koordinaten in Bildschirmkoordinaten umzuwandeln, bevor die Funktionen „ drawPrimitive()“ oder „ drawControl()“ aufgerufen werden.

Die folgende Tabelle listet die komplexen Steuerelemente und die zugehörigen Unterklassen der Stiloptionen auf. Die Stiloptionen enthalten alle Parameter, die zum Zeichnen der Steuerelemente erforderlich sind, einschließlich „ QStyleOption::state “, das die beim Zeichnen verwendeten „ style flags “ enthält. Die Tabelle beschreibt außerdem, welche Flags gesetzt werden, wenn das angegebene „ option “ in die entsprechende Unterklasse umgewandelt 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 “ unter Verwendung der durch „ option “ festgelegten 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 mithilfe der Funktion „ qstyleoption_cast()“ in die richtige Unterklasse umgewandelt werden kann.

Die folgende Tabelle listet die Steuerelemente und die ihnen zugeordneten Unterklassen der Stiloptionen auf. Die Stiloptionen enthalten alle zum Zeichnen der Steuerelemente erforderlichen Parameter, einschließlich „ QStyleOption::state “, das die beim Zeichnen verwendeten Stilflags enthält. Die Tabelle beschreibt außerdem, welche Flags gesetzt werden, wenn die jeweilige Option in die entsprechende Unterklasse umgewandelt wird.

Beachten Sie: Wenn ein Steuerelement hier nicht aufgeführt ist, liegt dies 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 “ im angegebenen „ rectangle “ gemäß den festgelegten „ alignment “ unter Verwendung der bereitgestellten „ 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 die angegebene „ text “ in der angegebenen „ rectangle “ unter Verwendung der bereitgestellten „ painter “ und „ palette “.

Der Text wird mit dem Zeichenstift des Painters gezeichnet und entsprechend dem angegebenen ` alignment` ausgerichtet und umgebrochen. Wenn ein expliziter ` textRole ` angegeben ist, wird der Text mit der Farbe des ` 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 ` Einfluss darauf haben, 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 die angegebene Primitive „ element “ mit dem bereitgestellten „ painter “ unter Verwendung der durch „ option “ festgelegten Stiloptionen.

Das Argument „ widget “ ist optional und kann ein Widget enthalten, das beim Zeichnen des Primitivelements hilfreich sein kann.

Die folgende Tabelle listet die primitiven Elemente und die ihnen zugeordneten Unterklassen der Stiloptionen auf. Die Stiloptionen enthalten alle Parameter, die zum Zeichnen der Elemente erforderlich sind, einschließlich „ QStyleOption::state “, das die beim Zeichnen verwendeten Stilflags enthält. Die Tabelle beschreibt außerdem, welche Flags gesetzt werden, wenn die angegebene Option in die entsprechende Unterklasse umgewandelt wird.

Beachten Sie: Wenn ein Primitivelement 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, deren Stil an die angegebene ` iconMode ` angepasst ist und die die durch ` option` festgelegte Palette berücksichtigt.

Der Parameter ` option ` kann zusätzliche Informationen enthalten, muss jedoch 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

Gibt das Untersteuerelement an der angegebenen Koordinate ` position ` im angegebenen komplexen Koordinatensystem ` control ` zurück (mit den durch ` option` festgelegten 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 mithilfe der Funktion „ qstyleoption_cast()“ in den entsprechenden Typ umgewandelt werden. Weitere Informationen finden Sie unter „ drawComplexControl()“. 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 der angegebenen ` rectangle ` zurück, in dem die angegebene ` pixmap ` gemäß der definierten ` 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 der angegebenen „ rectangle “ zurück, in dem das bereitgestellte „ text “ gemäß der angegebenen Schriftart „ metrics “ und „ alignment “ gezeichnet werden soll. Der Parameter „ enabled “ gibt an, ob das zugehörige Element aktiviert ist oder nicht.

Ist das angegebene „ rectangle “ größer als der zum Rendern des „ text “ benötigte Bereich, wird das zurückgegebene Rechteck innerhalb von „ rectangle “ entsprechend dem angegebenen „ alignment “ versetzt. Ist beispielsweise „ alignment “ auf „ Qt::AlignCenter “ gesetzt, wird das zurückgegebene Rechteck innerhalb von „ rectangle “ zentriert. Ist das angegebene „ rectangle “ kleiner als der benötigte Bereich, ist das zurückgegebene Rechteck das kleinste Rechteck, das groß genug ist, um das „ text “ zu rendern.

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 in einem Layout zwischen control1 und control2 verwendet werden soll. orientation legt fest, ob die Steuerelemente nebeneinander oder vertikal übereinander angeordnet werden. 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 den Wert nullptr hat.

Diese Funktion wird vom Layout-System 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 mit ` QStyleFactory::create()` einen Stil 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 Werte „ option “ und „ widget “ können zur Berechnung der Metrik verwendet werden. Der Wert „ option “ kann mithilfe der Funktion „ qstyleoption_cast()“ in den entsprechenden Typ umgewandelt werden. Beachten Sie, dass der Wert „ option “ auch bei „PixelMetrics“, die diesen Wert nutzen können, Null sein kann. Die entsprechenden Umwandlungen für „ option “ entnehmen Sie bitte der folgenden Tabelle:

Einige Pixel-Metriken werden von Widgets aufgerufen, andere werden nur intern vom Stil aufgerufen. Wird die Metrik nicht von einem Widget aufgerufen, liegt es im Ermessen des Stilautors, sie zu nutzen. Bei manchen Stilen ist dies möglicherweise nicht angemessen.

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

Initialisiert das Erscheinungsbild des angegebenen „ widget “.

Diese Funktion wird für jedes Widget zu einem Zeitpunkt aufgerufen, der nach dessen vollständiger Erstellung, aber unmittelbar vor seiner allerersten Darstellung liegt.

Beachten Sie, dass die Standardimplementierung keine Aktion ausführt. Sinnvolle Maßnahmen in dieser Funktion könnten beispielsweise der Aufruf der Funktion `QWidget::setBackgroundMode()` für das Widget sein. Verwenden Sie die Funktion nicht, um beispielsweise die Geometrie festzulegen. Die Neuimplementierung dieser Funktion bietet eine Hintertür, über die das Erscheinungsbild eines Widgets geändert werden kann; mit der Qt-Style-Engine ist es jedoch selten notwendig, diese Funktion zu implementieren; implementieren Sie stattdessen drawItemPixmap(), drawItemText(), drawPrimitive() usw. neu.

Die Funktion ` QWidget::inherits()` liefert möglicherweise genügend Informationen, um klassenspezifische Anpassungen zu ermöglichen. Da jedoch erwartet wird, dass neue Unterklassen von ` QStyle ` mit allen aktuellen und zukünftigen Widgets einwandfrei funktionieren, wird empfohlen, fest codierte Anpassungen nur in begrenztem Umfang zu verwenden.

Siehe auch unpolish().

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

Verspätete Initialisierung des angegebenen „ application “-Objekts.

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

Passen Sie die Funktion „ palette “ entsprechend den stilspezifischen Anforderungen an Farbpaletten (sofern vorhanden) an.

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 geben die meisten Stile sich selbst zurück. Wenn jedoch ein Proxy-Stil verwendet wird, ermöglicht dies dem Stil, einen Rückruf an seinen Proxy auszuführen.

[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 Parameter ` option ` und ` type` beschrieben wird, basierend auf dem übergebenen ` contentsSize`.

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

Die folgenden Tabellen zeigen die entsprechenden Typumwandlungen für ` option `:

Siehe auch „ ContentsType “ und „ QStyleOption “.

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

Wandelt die angegebene „ logicalValue “ in eine Pixelposition um. Der Parameter „ min “ wird auf 0 abgebildet, „ max “ wird auf „ span “ abgebildet und die übrigen Werte werden gleichmäßig dazwischen verteilt.

Diese Funktion kann den gesamten Ganzzahlbereich ohne Überlauf verarbeiten, vorausgesetzt, „ span “ ist kleiner als 4096.

Standardmäßig geht diese Funktion davon aus, dass der Maximalwert 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 den angegebenen Pixel position n in einen logischen Wert um. 0 wird dem Parameter „ min “ zugeordnet, „ span “ dem Parameter „ max “ und alle anderen Werte werden gleichmäßig dazwischen verteilt.

Diese Funktion kann den gesamten Ganzzahlbereich ohne Überlauf verarbeiten.

Standardmäßig geht diese Funktion davon aus, dass der Maximalwert 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

Gibt ein Symbol für das angegebene „ standardIcon “ zurück.

Das „ standardIcon “ ist eine Standard-Pixmap, die einem bestehenden GUI-Stil oder einer Richtlinie entsprechen kann. Das Argument „ option “ kann verwendet werden, um zusätzliche Informationen zu übergeben, die zur Definition des entsprechenden Symbols erforderlich sind. Das Argument „ widget “ ist optional und kann ebenfalls zur Bestimmung des Symbols herangezogen werden.

[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 „Windows Vista“ und „Mac“ verwenden keine 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 das angegebene widget darstellt, das durch den bereitgestellten Stil- option beschrieben wird.

returnData Wird verwendet, wenn das abfragende Widget detailliertere Daten benötigt als die von styleHint() zurückgegebene Ganzzahl. Weitere Informationen finden Sie in der Klassenbeschreibung von „ QStyleHintReturn “.

[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 den angegebenen „ subControl “ des angegebenen komplexen „ control “ enthält (wobei der Stil durch „ option “ festgelegt wird). Das Rechteck wird in Bildschirmkoordinaten definiert.

Das Argument ` option ` ist ein Zeiger auf ` QStyleOptionComplex ` oder eine seiner Unterklassen und kann mithilfe der Funktion ` qstyleoption_cast()` in den entsprechenden Typ umgewandelt werden. Weitere Informationen finden Sie unter ` drawComplexControl()`. Das Argument ` 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

Gibt den Teilbereich für das angegebene „ element “ zurück, wie im bereitgestellten Stil „ option “ beschrieben. Das zurückgegebene Rechteck wird in Bildschirmkoordinaten definiert.

Das Argument ` widget ` ist optional und kann zur Bestimmung des Bereichs herangezogen werden. Das ` QStyleOption `-Objekt kann mithilfe der Funktion ` qstyleoption_cast()` in den entsprechenden Typ umgewandelt werden. Die entsprechenden Typumwandlungen für ` option ` entnehmen Sie bitte der folgenden Tabelle:

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

Die Darstellung des angegebenen „ widget “ wird zurückgesetzt.

Diese Funktion ist das Gegenstück zu ` polish()`. Sie wird für jedes „polierte“ Widget aufgerufen, sobald der Stil dynamisch geändert wird; der vorherige Stil muss seine Einstellungen zurücksetzen, bevor der neue Stil sie erneut „polieren“ kann.

Beachten Sie, dass unpolish() nur aufgerufen wird, wenn das Widget zerstört wird. Dies kann in manchen 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 sich der Stil geändert hat; einige Klassen von Qt speichern ihre Widgets im Cache.

Siehe auch ` polish()`.

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

Die angegebene Funktion „ application “ wird deinitialisiert.

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

Wandelt eine ` alignment ` vom Typ ` Qt::AlignLeft ` oder ` Qt::AlignRight ` ohne ` Qt::AlignAbsolute ` in ` Qt::AlignLeft ` oder ` Qt::AlignRight ` mit ` Qt::AlignAbsolute ` gemäß dem Layout ` direction` um. Die anderen Ausrichtungsflags bleiben unverändert.

Wurde keine horizontale Ausrichtung angegeben, 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 angegebenen Koordinaten ` logicalPosition ` zurück, die auf der Grundlage der angegebenen ` direction` in Bildschirmkoordinaten umgewandelt wurden. Bei der Transformation wird die ` boundingRectangle ` verwendet.

Siehe auch „ QWidget::layoutDirection “.

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

Gibt die angegebene „ logicalRectangle “ zurück, die basierend auf dem angegebenen „ direction “ in Bildschirmkoordinaten umgewandelt wurde. Bei der Transformation wird die „ boundingRectangle “ verwendet.

Diese Funktion dient zur Unterstützung von Desktops mit Rechts-nach-Links-Schriftrichtung und wird typischerweise bei der Implementierung der Funktion ` subControlRect()` verwendet.

Siehe auch QWidget::layoutDirection.