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);
}

Documentation des fonctions membres

QStyle::QStyle()

Construit un objet de style.

[virtual noexcept] QStyle::~QStyle()

Détruit l'objet style.

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

Renvoie un nouveau rectangle de l'adresse size spécifiée qui est aligné sur l'adresse rectangle donnée selon les adresses alignment et direction spécifiées.

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

Renvoie l'espacement à utiliser entre controls1 et controls2 dans une présentation. orientation spécifie si les contrôles sont disposés côte à côte ou empilés verticalement. Le paramètre option peut être utilisé pour transmettre des informations supplémentaires sur le widget parent. Le paramètre widget est facultatif et peut également être utilisé si option est nullptr.

controls1 et controls2 sont des combinaisons OU de zéro ou plusieurs control types.

Cette fonction est appelée par le système de mise en page. Elle n'est utilisée que si PM_LayoutHorizontalSpacing ou PM_LayoutVerticalSpacing renvoie une valeur négative.

Voir aussi layoutSpacing().

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

Dessine l'objet control en utilisant l'objet painter avec les options de style spécifiées par option.

L'argument widget est facultatif et peut être utilisé pour aider à dessiner le contrôle.

Le paramètre option est un pointeur sur un objet QStyleOptionComplex qui peut être converti dans la sous-classe correcte à l'aide de la fonction qstyleoption_cast(). Notez que le membre rect de l'objet option spécifié doit être en coordonnées logiques. Les réimplémentations de cette fonction doivent utiliser visualRect() pour convertir les coordonnées logiques en coordonnées d'écran avant d'appeler la fonction drawPrimitive() ou drawControl().

Le tableau ci-dessous répertorie les éléments de contrôle complexes et leur sous-classe d'option de style associée. Les options de style contiennent tous les paramètres nécessaires pour dessiner les contrôles, y compris QStyleOption::state qui contient les style flags utilisés lors du dessin. Le tableau décrit également les drapeaux qui sont activés lors du moulage de l'élément option dans la sous-classe appropriée.

Voir également drawPrimitive() et drawControl().

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

Dessine l'objet element avec l'objet painter et les options de style spécifiées par option.

L'argument widget est facultatif et peut être utilisé pour aider à dessiner le contrôle. Le paramètre option est un pointeur sur un objet QStyleOption qui peut être converti dans la sous-classe correcte à l'aide de la fonction qstyleoption_cast().

Le tableau ci-dessous répertorie les éléments de contrôle et leur sous-classe d'option de style associée. Les options de style contiennent tous les paramètres nécessaires pour dessiner les contrôles, y compris QStyleOption::state qui contient les drapeaux de style utilisés lors du dessin. Le tableau décrit également les drapeaux qui sont activés lors de l'attribution de l'option donnée à la sous-classe appropriée.

Notez que si un élément de contrôle n'est pas listé ici, c'est parce qu'il utilise un simple objet QStyleOption.

Voir également drawPrimitive() et drawComplexControl().

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

Dessine l'objet pixmap dans l'objet rectangle, selon l'objet alignment, en utilisant l'objet painter.

Voir aussi 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

Dessine le texte donné text dans l'espace spécifié rectangle en utilisant les éléments fournis painter et palette.

Le texte est dessiné à l'aide de la plume du peintre, aligné et enveloppé conformément à alignment. Si un textRole explicite est spécifié, le texte est dessiné en utilisant la couleur du palette pour le rôle donné. Le paramètre enabled indique si l'élément est activé ou non ; lors de la réimplémentation de cette fonction, le paramètre enabled devrait influencer la manière dont l'élément est dessiné.

Voir également Qt::Alignment et drawItemPixmap().

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

Dessine l'élément primitif donné element avec l'élément fourni painter en utilisant les options de style spécifiées par option.

L'argument widget est facultatif et peut contenir un widget qui peut aider à dessiner l'élément primitif.

Le tableau ci-dessous répertorie les éléments primitifs et leurs sous-classes d'options de style associées. Les options de style contiennent tous les paramètres nécessaires pour dessiner les éléments, y compris QStyleOption::state qui contient les drapeaux de style utilisés lors du dessin. Le tableau décrit également les drapeaux qui sont activés lors du moulage de l'option donnée dans la sous-classe appropriée.

Notez que si un élément primitif n'est pas listé ici, c'est parce qu'il utilise un simple objet QStyleOption.

Voir également drawComplexControl() et drawControl().

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

Renvoie une copie de la page pixmap donnée, stylisée pour se conformer à la page iconMode spécifiée et en tenant compte de la palette spécifiée par option.

Le paramètre option peut contenir des informations supplémentaires, mais il doit contenir une palette.

Notez que toutes les pixmaps ne sont pas conformes, auquel cas la pixmap renvoyée est une copie simple.

Voir aussi QIcon.

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

Renvoie le sous-contrôle à l'adresse position dans le complexe control (avec les options de style spécifiées par option).

Notez que l'adresse position est exprimée en coordonnées d'écran.

L'argument option est un pointeur sur un objet QStyleOptionComplex (ou l'une de ses sous-classes). L'objet peut être converti dans le type approprié à l'aide de la fonction qstyleoption_cast(). Voir drawComplexControl() pour plus de détails. L'argument widget est facultatif et peut contenir des informations supplémentaires pour la fonction.

Voir également drawComplexControl() et subControlRect().

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

Renvoie la zone à l'intérieur de l'adresse rectangle donnée dans laquelle dessiner l'adresse pixmap spécifiée selon l'adresse alignment définie.

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

Renvoie la zone à l'intérieur de l'adresse rectangle dans laquelle il faut dessiner l'adresse text en fonction des polices spécifiées metrics et alignment. Le paramètre enabled indique si l'élément associé est activé ou non.

Si la zone rectangle est plus grande que la zone nécessaire au rendu de text, le rectangle renvoyé sera décalé à l'intérieur de rectangle en fonction de alignment. Par exemple, si alignment est Qt::AlignCenter, le rectangle renvoyé sera centré sur rectangle. Si rectangle est plus petit que la zone nécessaire, le rectangle renvoyé sera le plus petit rectangle suffisamment grand pour rendre text.

Voir aussi 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

Renvoie l'espacement à utiliser entre control1 et control2 dans une présentation. orientation spécifie si les contrôles sont disposés côte à côte ou empilés verticalement. Le paramètre option peut être utilisé pour transmettre des informations supplémentaires sur le widget parent. Le paramètre widget est facultatif et peut également être utilisé si option est nullptr.

Cette fonction est appelée par le système de mise en page. Elle n'est utilisée que si PM_LayoutHorizontalSpacing ou PM_LayoutVerticalSpacing renvoie une valeur négative.

Voir également combinedLayoutSpacing().

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

Renvoie le nom du style.

Cette valeur peut être utilisée pour créer un style avec QStyleFactory::create().

Cette fonction a été introduite dans Qt 6.1.

Voir aussi QStyleFactory::create().

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

Renvoie la valeur du pixel donné metric.

Les valeurs spécifiées option et widget peuvent être utilisées pour calculer la métrique. La valeur option peut être convertie dans le type approprié à l'aide de la fonction qstyleoption_cast(). Notez que la valeur de option peut être nulle même pour les PixelMetrics qui peuvent l'utiliser. Voir le tableau ci-dessous pour les casts option appropriés :

Certaines métriques de pixels sont appelées par des widgets et d'autres ne sont appelées qu'en interne par le style. Si la métrique n'est pas appelée par un widget, il appartient à l'auteur du style de l'utiliser. Pour certains styles, cela peut ne pas être approprié.

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

Initialise l'apparence du widget widget.

Cette fonction est appelée pour chaque widget à un moment donné après sa création complète, mais juste avant qu' il ne soit affiché pour la toute première fois.

Notez que l'implémentation par défaut ne fait rien. Des actions raisonnables dans cette fonction pourraient être d'appeler la fonction QWidget::setBackgroundMode() pour le widget. N'utilisez pas cette fonction pour définir, par exemple, la géométrie. La réimplémentation de cette fonction fournit une porte dérobée par laquelle l'apparence d'un widget peut être modifiée, mais avec le moteur de style de Qt, il est rarement nécessaire d'implémenter cette fonction ; réimplémentez drawItemPixmap(), drawItemText(), drawPrimitive(), etc. à la place.

La fonction QWidget::inherits() peut fournir suffisamment d'informations pour permettre des personnalisations spécifiques à une classe. Mais comme les nouvelles sous-classes de QStyle sont censées fonctionner raisonnablement avec tous les widgets actuels et futurs, il est recommandé de limiter l'utilisation de la personnalisation codée en dur.

Voir aussi unpolish().

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

Initialisation tardive de l'objet application donné.

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

Modifie le site palette en fonction des exigences spécifiques du style en matière de palettes de couleurs (le cas échéant).

Voir aussi QPalette et QApplication::setPalette().

const QStyle *QStyle::proxy() const

Cette fonction renvoie le proxy actuel pour ce style. Par défaut, la plupart des styles se renvoient eux-mêmes. Cependant, lorsqu'un style mandataire est utilisé, cette fonction permet au style de rappeler son mandataire.

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

Renvoie la taille de l'élément décrit par option et type, sur la base de contentsSize.

L'argument option est un pointeur sur QStyleOption ou l'une de ses sous-classes. Le option peut être converti dans le type approprié à l'aide de la fonction qstyleoption_cast(). L'argument widget est facultatif et peut contenir des informations supplémentaires utilisées pour calculer la taille.

Voir le tableau ci-dessous pour les casts option appropriés :

Voir également ContentsType et QStyleOption.

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

Convertit la valeur logicalValue en une position en pixels. Le paramètre min correspond à 0, max correspond à span et les autres valeurs sont réparties uniformément entre les deux.

Cette fonction peut traiter l'ensemble de la plage des entiers sans débordement, à condition que span soit inférieur à 4096.

Par défaut, cette fonction suppose que la valeur maximale se trouve à droite pour les éléments horizontaux et en bas pour les éléments verticaux. Définissez le paramètre upsideDown à true pour inverser ce comportement.

Voir également sliderValueFromPosition().

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

Convertit le pixel donné position en une valeur logique. 0 correspond au paramètre min, span correspond à max et les autres valeurs sont réparties uniformément entre les deux.

Cette fonction peut traiter toute la gamme des nombres entiers sans débordement.

Par défaut, cette fonction suppose que la valeur maximale se trouve à droite pour les éléments horizontaux et en bas pour les éléments verticaux. Définissez le paramètre upsideDown à true pour inverser ce comportement.

Voir également sliderPositionFromValue().

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

Renvoie une icône pour l'adresse standardIcon.

L'adresse standardIcon est un pixmap standard qui peut suivre un style ou une ligne directrice d'interface graphique existante. L'argument option peut être utilisé pour transmettre des informations supplémentaires nécessaires à la définition de l'icône appropriée. L'argument widget est facultatif et peut également être utilisé pour faciliter la détermination de l'icône.

[virtual] QPalette QStyle::standardPalette() const

Renvoie la palette standard du style.

Notez que sur les systèmes qui prennent en charge les couleurs du système, la palette standard du style n'est pas utilisée. En particulier, les styles Windows Vista et Mac n'utilisent pas la palette standard, mais font appel à des moteurs de thèmes natifs. Avec ces styles, vous ne devez pas définir la palette avec QApplication::setPalette().

Voir également QApplication::setPalette().

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

Renvoie un nombre entier représentant le style spécifié hint pour le style donné widget décrit par le style fourni option.

returnData est utilisé lorsque le widget demandeur a besoin de données plus détaillées que l'entier renvoyé par styleHint(). Voir la description de la classe QStyleHintReturn pour plus de détails.

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

Renvoie le rectangle contenant le subControl spécifié du complexe donné control (avec le style spécifié par option). Le rectangle est défini en coordonnées d'écran.

L'argument option est un pointeur sur QStyleOptionComplex ou l'une de ses sous-classes, et peut être converti dans le type approprié à l'aide de la fonction qstyleoption_cast(). Voir drawComplexControl() pour plus de détails. L'argument widget est facultatif et peut contenir des informations supplémentaires pour la fonction.

Voir également drawComplexControl().

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

Renvoie la sous-zone de l'adresse element telle qu'elle est décrite dans le style fourni option. Le rectangle renvoyé est défini en coordonnées d'écran.

L'argument widget est facultatif et peut être utilisé pour aider à déterminer la zone. L'objet QStyleOption peut être converti dans le type approprié à l'aide de la fonction qstyleoption_cast(). Voir le tableau ci-dessous pour les casts option appropriés :

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

Désinitialise l'apparence de widget.

Cette fonction est la contrepartie de polish(). Elle est appelée pour chaque widget poli à chaque fois que le style est dynamiquement modifié ; l'ancien style doit dépolir ses paramètres avant que le nouveau style puisse les polir à nouveau.

Notez que unpolish() ne sera appelé que si le widget est détruit. Cela peut poser des problèmes dans certains cas, par exemple si vous retirez un widget de l'interface utilisateur, le mettez en cache, puis le réinsérez après que le style a changé ; certaines classes de Qt Widgets mettent leurs widgets en cache.

Voir aussi polish().

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

Désinitialise le site application.

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

Transforme un alignment de Qt::AlignLeft ou Qt::AlignRight sans Qt::AlignAbsolute en Qt::AlignLeft ou Qt::AlignRight avec Qt::AlignAbsolute selon la disposition direction. Les autres drapeaux d'alignement ne sont pas modifiés.

Si aucun alignement horizontal n'a été spécifié, la fonction renvoie l'alignement par défaut pour la mise en page donnée direction.

QWidget::layoutDirection

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

Renvoie l'adresse logicalPosition donnée convertie en coordonnées d'écran sur la base de l'adresse direction spécifiée. Le site boundingRectangle est utilisé lors de la traduction.

Voir aussi QWidget::layoutDirection.

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

Renvoie l'adresse logicalRectangle donnée convertie en coordonnées d'écran sur la base de l'adresse direction spécifiée. L'adresse boundingRectangle est utilisée pour effectuer la conversion.

Cette fonction est fournie pour prendre en charge les bureaux de droite à gauche et est généralement utilisée dans les implémentations de la fonction subControlRect().

Voir aussi QWidget::layoutDirection.