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 sur les fonctions membres

QStyle::QStyle()

Crée un objet de style.

[virtual noexcept] QStyle::~QStyle()

Supprime l'objet de style.

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

Renvoie un nouveau rectangle aux dimensions spécifiées ( size ) aligné sur l'rectangle, conformément aux paramètres spécifiés ( alignment et direction).

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 mise en page. orientation spécifie si les contrôles sont disposés côte à côte ou empilés verticalement. Le paramètre option permet de 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 une combinaison OU d’un 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 également layoutSpacing().

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

Dessine l'control donné à l'aide de l'painter fourni, avec les options de style spécifiées par option.

L'argument ` widget ` est facultatif et peut servir d'aide au tracé du contrôle.

Le paramètre ` option ` est un pointeur vers un objet ` QStyleOptionComplex ` qui peut être converti en sous-classe appropriée à l’aide de la fonction ` qstyleoption_cast()`. Notez que le membre ` rect ` de l’` option ` spécifié doit être exprimé 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’options de style associée. Les options de style contiennent tous les paramètres nécessaires au tracé des contrôles, y compris ` QStyleOption::state `, qui contient les ` style flags ` utilisées lors du tracé. Le tableau décrit également les indicateurs qui sont activés lors de la conversion de l’ option donnée vers 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'element donné à l'aide de l'painter fourni, en utilisant les options de style spécifiées par option.

L'argument ` widget ` est facultatif et peut servir d'aide au tracé du contrôle. Le paramètre ` option ` est un pointeur vers un objet ` QStyleOption ` qui peut être converti en sous-classe appropriée à l'aide de la fonction ` qstyleoption_cast()`.

Le tableau ci-dessous répertorie les éléments de contrôle et leur sous-classe d’options de style associée. Les options de style contiennent tous les paramètres nécessaires au dessin des contrôles, y compris ` QStyleOption::state ` qui contient les indicateurs de style utilisés lors du dessin. Le tableau décrit également quels indicateurs sont activés lors de la conversion de l’option donnée vers la sous-classe appropriée.

Notez que si un élément de contrôle ne figure pas dans cette liste, c’est parce qu’il utilise un objet ` QStyleOption ` standard.

Voir également drawPrimitive() et drawComplexControl().

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

Dessine l'pixmap donnée dans l'rectangle spécifiée, conformément à l'alignment spécifiée, à l'aide de l'painter fournie.

Voir également 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 l'text fournie dans l'rectangle spécifiée à l'aide des paramètres painter et palette fournis.

Le texte est tracé à l’aide du stylo du peintre, puis aligné et ajusté selon l’ alignment spécifiée. Si une textRole explicite est spécifiée, le texte est tracé en utilisant la couleur de l’ 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 doit influencer la manière dont l’élément est tracé.

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 la primitive element fournie à l'aide de l'painter, en utilisant les options de style spécifiées par option.

L'argument ` widget ` est facultatif et peut contenir un widget pouvant faciliter le dessin de 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 au dessin des éléments, y compris QStyleOption::state qui contient les indicateurs de style utilisés lors du dessin. Le tableau décrit également quels indicateurs sont activés lors de la conversion de l’option donnée vers la sous-classe appropriée.

Notez que si un élément primitif ne figure pas dans cette liste, c’est parce qu’il utilise un objet ` QStyleOption ` simple.

Voir également drawComplexControl() et drawControl().

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

Renvoie une copie de l'pixmap fournie, dont le style est adapté pour se conformer à la 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 obligatoirement contenir une palette.

Notez que toutes les images pixmap ne sont pas conformes ; dans ce cas, l’image pixmap renvoyée est une simple copie.

Voir également 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 situé à l'position indiquée, dans l'control complexe spécifiée (avec les options de style définies par option).

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

L'argument ` option ` est un pointeur vers un objet ` QStyleOptionComplex ` (ou l'une de ses sous-classes). L'objet peut être converti au 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, au sein de l'rectangle, dans laquelle dessiner l'pixmap spécifiée, conformément à l'alignment définie.

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

Renvoie la zone, au sein de l’ rectangle donnée, dans laquelle dessiner l’ text fournie selon la police spécifiée metrics et alignment. Le paramètre enabled indique si l’élément associé est activé ou non.

Si l’ rectangle fournie est plus grande que la zone nécessaire au rendu de l’ text, le rectangle renvoyé sera décalé au sein de rectangle conformément à la valeur spécifiée dans alignment. Par exemple, si alignment est défini sur Qt::AlignCenter, le rectangle renvoyé sera centré au sein de rectangle. Si l’ rectangle fournie est plus petite que la zone nécessaire, le rectangle renvoyé sera le plus petit rectangle suffisamment grand pour afficher l’ text.

Voir également 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 mise en page. orientation spécifie si les contrôles sont disposés côte à côte ou empilés verticalement. Le paramètre option permet de 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 à l'aide de la fonction ` 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 indiqué metric.

Les paramètres ` option ` et ` widget ` spécifiés peuvent être utilisés pour calculer la métrique. La valeur ` option ` peut être convertie au type approprié à l’aide de la fonction ` qstyleoption_cast()`. Notez que la valeur ` option ` peut être nulle, même pour les `PixelMetrics` qui peuvent l’utiliser. Reportez-vous au tableau ci-dessous pour connaître les conversions ` option ` appropriées :

Certaines métriques de pixels sont appelées à partir de widgets, tandis que 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 décider s’il souhaite l’utiliser. Pour certains styles, cela peut ne pas être approprié.

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

Initialise l'apparence de l'widget spécifié.

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. Une utilisation raisonnable de cette fonction pourrait consister à 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 offre une porte dérobée permettant de modifier l'apparence d'un widget, mais avec le moteur de styles de Qt, il est rarement nécessaire de l'implémenter ; réimplémentez plutôt drawItemPixmap(), drawItemText(), drawPrimitive(), etc.

La fonction QWidget::inherits() peut fournir suffisamment d’informations pour permettre des personnalisations spécifiques à une classe. Cependant, comme les nouvelles sous-classes de QStyle sont censées fonctionner correctement avec tous les widgets actuels et futurs, il est recommandé de limiter le recours aux personnalisations codées en dur.

Voir également unpolish().

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

Initialisation tardive de l'objet ` application ` donné.

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

Modifie l’ palette ion en fonction des exigences spécifiques au style concernant les palettes de couleurs (le cas échéant).

Voir également ` QPalette ` et ` QApplication::setPalette()`.

const QStyle *QStyle::proxy() const

Cette fonction renvoie le proxy actuel associé à ce style. Par défaut, la plupart des styles renvoient leur propre instance. Toutefois, lorsqu'un style proxy est utilisé, cela permet au style d'appeler à nouveau son proxy.

[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 les paramètres ` option ` et ` type` spécifiés, en fonction de la valeur fournie par ` contentsSize`.

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

Consultez le tableau ci-dessous pour connaître les conversions appropriées de ` option ` :

Voir également ContentsType et QStyleOption.

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

Convertit l'logicalValue e fournie en une position en pixels. Le paramètre « min » correspond à 0, « max » correspond à span et les autres valeurs sont réparties uniformément entre ces deux valeurs.

Cette fonction peut traiter toute la plage des entiers sans débordement, à condition que l’ span soit inférieure à 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 sur true pour inverser ce comportement.

Voir aussi sliderValueFromPosition().

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

Convertit l'position de pixel fournie en une valeur logique. La valeur 0 correspond au paramètre min, la valeur span correspond à max et les autres valeurs sont réparties uniformément entre ces deux valeurs.

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

Par défaut, cette fonction considère 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 sur 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 correspondant à l'standardIcon.

L'standardIcon est une image bitmap standard pouvant respecter un style ou des directives d'interface graphique existants. 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 prenant en charge les couleurs 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 s'appuient sur des moteurs de thèmes natifs. Avec ces styles, vous ne devez pas définir la palette à l'aide de la fonction 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 entier représentant l'hint de style spécifiée pour l'widget donnée, décrite par le style fourni option.

returnData Cette méthode est utilisée lorsque le widget effectuant la requête a besoin de données plus détaillées que l'entier renvoyé par la méthode styleHint(). Pour plus de détails, consultez la description de la classe ` QStyleHintReturn `.

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

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

L'argument ` option ` est un pointeur vers ` QStyleOptionComplex ` ou l'une de ses sous-classes, et peut être converti au 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 correspondant à l'element donné, telle que 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 faciliter la détermination de la zone. L'objet ` QStyleOption ` peut être converti au type approprié à l'aide de la fonction ` qstyleoption_cast()`. Reportez-vous au tableau ci-dessous pour connaître les conversions appropriées de ` option ` :

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

Réinitialise l'apparence de l'widget donné.

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

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

Voir également ` polish()`.

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

Désinitialiser l'application.

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

Transforme une alignment de type Qt::AlignLeft ou Qt::AlignRight sans Qt::AlignAbsolute en Qt::AlignLeft ou Qt::AlignRight avec Qt::AlignAbsolute, conformément à la mise en page direction. Les autres indicateurs d'alignement restent inchangé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'logicalPosition e indiquée, convertie en coordonnées d'écran selon l'direction spécifiée. L'boundingRectangle est utilisée lors de la translation.

Voir également QWidget::layoutDirection.

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

Renvoie l'logicalRectangle e fournie, convertie en coordonnées d'écran selon l'direction spécifiée. L'boundingRectangle est utilisée lors de la translation.

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

Voir également QWidget::layoutDirection.