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

Documentación de las funciones miembro

QStyle::QStyle()

Construye un objeto de estilo.

[virtual noexcept] QStyle::~QStyle()

Destruye el objeto de estilo.

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

Devuelve un nuevo rectángulo del size especificado que está alineado con el rectangle dado según los alignment y direction especificados.

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

Devuelve el espaciado que debe utilizarse entre controls1 y controls2 en un diseño. orientation especifica si los controles se disponen uno al lado del otro o apilados verticalmente. El parámetro option puede utilizarse para pasar información adicional sobre el widget padre. El parámetro widget es opcional y también puede utilizarse si option es nullptr.

controls1 y controls2 son combinaciones OR de cero o más control types.

Esta función es llamada por el sistema de diseño. Sólo se utiliza si PM_LayoutHorizontalSpacing o PM_LayoutVerticalSpacing devuelven un valor negativo.

Véase también layoutSpacing().

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

Dibuja el control dado utilizando el painter proporcionado con las opciones de estilo especificadas por option.

El argumento widget es opcional y puede utilizarse como ayuda para dibujar el control.

El parámetro option es un puntero a un objeto QStyleOptionComplex que puede ser convertido a la subclase correcta utilizando la función qstyleoption_cast(). Tenga en cuenta que el miembro rect del option especificado debe estar en coordenadas lógicas. Las reimplementaciones de esta función deben utilizar visualRect() para cambiar las coordenadas lógicas a coordenadas de pantalla antes de llamar a la función drawPrimitive() o drawControl().

En la tabla siguiente se enumeran los elementos de control complejos y su subclase de opción de estilo asociada. Las opciones de estilo contienen todos los parámetros necesarios para dibujar los controles, incluyendo QStyleOption::state que contiene los style flags que se utilizan al dibujar. La tabla también describe las banderas que se activan al asignar la option dada a la subclase apropiada.

Véase también drawPrimitive() y drawControl().

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

Dibuja el element dado con el painter proporcionado con las opciones de estilo especificadas por option.

El argumento widget es opcional y puede utilizarse como ayuda para dibujar el control. El parámetro option es un puntero a un objeto QStyleOption que puede ser convertido a la subclase correcta utilizando la función qstyleoption_cast().

En la tabla siguiente se enumeran los elementos de control y su subclase de opción de estilo asociada. Las opciones de estilo contienen todos los parámetros necesarios para dibujar los controles, incluyendo QStyleOption::state que contiene las banderas de estilo que se utilizan al dibujar. La tabla también describe las banderas que se activan al asignar la opción dada a la subclase apropiada.

Ten en cuenta que si un elemento de control no aparece en la lista, es porque utiliza un objeto QStyleOption.

Véase también drawPrimitive() y drawComplexControl().

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

Dibuja el pixmap dado en el rectangle especificado , de acuerdo con el alignment especificado , utilizando el painter proporcionado .

Véase también 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

Dibuja el texto text en el campo rectangle utilizando los campos painter y palette.

El texto se dibuja utilizando el lápiz del pintor, y se alinea y envuelve de acuerdo con el alignment especificado. Si se especifica un textRole explícito, el texto se dibuja utilizando el color palette's para el papel dado. El parámetro enabled indica si el elemento está habilitado o no; al reimplementar esta función, el parámetro enabled debería influir en cómo se dibuja el elemento.

Véase también Qt::Alignment y drawItemPixmap().

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

Dibuja la primitiva dada element con la proporcionada painter utilizando las opciones de estilo especificadas por option.

El argumento widget es opcional y puede contener un widget que ayude a dibujar el elemento primitivo.

En la tabla siguiente se enumeran los elementos primitivos y sus subclases de opciones de estilo asociadas. Las opciones de estilo contienen todos los parámetros necesarios para dibujar los elementos, incluyendo QStyleOption::state que contiene las banderas de estilo que se utilizan al dibujar. La tabla también describe las banderas que se activan al asignar la opción dada a la subclase apropiada.

Ten en cuenta que si un elemento primitivo no aparece en la lista, es porque utiliza un objeto plano QStyleOption.

Véase también drawComplexControl() y drawControl().

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

Devuelve una copia del pixmap dado , estilizado para ajustarse al iconMode especificado y teniendo en cuenta la paleta especificada por option.

El parámetro option puede incluir información adicional, pero debe contener una paleta.

Tenga en cuenta que no todos los mapas de píxeles serán conformes, en cuyo caso el mapa de píxeles devuelto será una copia sin formato.

Véase también QIcon.

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

Devuelve el subcontrol en el position dado en el complejo dado control (con las opciones de estilo especificadas por option).

Tenga en cuenta que position se expresa en coordenadas de pantalla.

El argumento option es un puntero a un objeto QStyleOptionComplex (o a una de sus subclases). El objeto se puede convertir al tipo apropiado mediante la función qstyleoption_cast(). Véase drawComplexControl() para más detalles. El argumento widget es opcional y puede contener información adicional para la función.

Véase también drawComplexControl() y subControlRect().

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

Devuelve el área dentro del rectangle dado en la que dibujar el pixmap especificado según el alignment definido.

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

Devuelve el área dentro del rectangle dado en la que dibujar el text proporcionado de acuerdo con la fuente especificada metrics y alignment. El parámetro enabled indica si el elemento asociado está activado o no.

Si el rectangle dado es mayor que el área necesaria para dibujar el text, el rectángulo devuelto se desplazará dentro de rectangle según el alignment especificado. Por ejemplo, si alignment es Qt::AlignCenter, el rectángulo devuelto estará centrado dentro de rectangle. Si rectangle es menor que el área necesaria, el rectángulo devuelto será el rectángulo más pequeño lo suficientemente grande como para representar text.

Véase también 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

Devuelve el espaciado que debe utilizarse entre control1 y control2 en un diseño. orientation especifica si los controles se disponen uno al lado del otro o apilados verticalmente. El parámetro option puede utilizarse para pasar información adicional sobre el widget padre. El parámetro widget es opcional y también puede utilizarse si option es nullptr.

Esta función es llamada por el sistema de diseño. Sólo se utiliza si PM_LayoutHorizontalSpacing o PM_LayoutVerticalSpacing devuelven un valor negativo.

Véase también combinedLayoutSpacing().

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

Devuelve el nombre del estilo.

Este valor se puede utilizar para crear un estilo con QStyleFactory::create().

Esta función se introdujo en Qt 6.1.

Véase también QStyleFactory::create().

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

Devuelve el valor del píxel dado metric.

Los valores option y widget especificados pueden utilizarse para calcular la métrica. option se puede convertir al tipo apropiado mediante la función qstyleoption_cast(). Tenga en cuenta que option puede ser cero incluso para PixelMetrics que puedan utilizarlo. Consulte la tabla siguiente para conocer las conversiones apropiadas de option:

Algunas métricas de píxeles son llamadas desde widgets y otras sólo son llamadas internamente por el estilo. Si la métrica no es llamada por un widget, es discreción del autor del estilo hacer uso de ella. Para algunos estilos, esto puede no ser apropiado.

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

Inicializa la apariencia del widget widget.

Esta función es llamada para cada widget en algún momento después de que haya sido completamente creado pero justo antes de que se muestre por primera vez.

Tenga en cuenta que la implementación por defecto no hace nada. Acciones razonables en esta función podrían ser llamar a la función QWidget::setBackgroundMode() para el widget. No uses la función para establecer, por ejemplo, la geometría. Reimplementar esta función proporciona una puerta trasera a través de la cual se puede cambiar la apariencia de un widget, pero con el motor de estilo de Qt raramente es necesario implementar esta función; reimplemente drawItemPixmap(), drawItemText(), drawPrimitive(), etc. en su lugar.

La función QWidget::inherits() puede proporcionar suficiente información para permitir personalizaciones específicas de clase. Pero como se espera que las nuevas subclases de QStyle funcionen razonablemente con todos los widgets actuales y futuros, se recomienda un uso limitado de la personalización mediante código duro.

Véase también unpolish().

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

Inicialización tardía del objeto application dado.

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

Cambia la dirección palette de acuerdo con los requisitos específicos del estilo para las paletas de colores (si existen).

Véase también QPalette y QApplication::setPalette().

const QStyle *QStyle::proxy() const

Esta función devuelve el proxy actual para este estilo. Por defecto, la mayoría de los estilos se devuelven a sí mismos. Sin embargo, cuando un estilo proxy está en uso, permitirá que el estilo devuelva la llamada a su proxy.

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

Devuelve el tamaño del elemento descrito por option y type especificados, basándose en contentsSize.

El argumento option es un puntero a QStyleOption o a una de sus subclases. option puede convertirse al tipo apropiado mediante la función qstyleoption_cast(). widget es un argumento opcional y puede contener información adicional utilizada para calcular el tamaño.

En la tabla siguiente se indican los tipos apropiados de option:

Véase también ContentsType y QStyleOption.

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

Convierte el parámetro logicalValue en una posición de píxel. El parámetro min se asigna a 0, max se asigna a span y los demás valores se distribuyen uniformemente entre ambos.

Esta función puede manejar todo el rango de enteros sin desbordarse, siempre que span sea inferior a 4096.

Por defecto, esta función asume que el valor máximo está a la derecha para los elementos horizontales y en la parte inferior para los elementos verticales. Establezca el parámetro upsideDown en true para invertir este comportamiento.

Véase también sliderValueFromPosition().

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

Convierte el píxel dado position en un valor lógico. 0 corresponde al parámetro min, span corresponde a max y los demás valores se distribuyen uniformemente entre ambos.

Esta función puede manejar todo el rango de enteros sin desbordarse.

Por defecto, esta función asume que el valor máximo está a la derecha para los elementos horizontales y en la parte inferior para los elementos verticales. Establezca el parámetro upsideDown en true para invertir este comportamiento.

Véase también sliderPositionFromValue().

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

Devuelve un icono para la dirección standardIcon.

standardIcon es un mapa de píxeles estándar que puede seguir algún estilo o pauta de interfaz gráfica de usuario existente. El argumento option puede utilizarse para pasar información adicional necesaria a la hora de definir el icono apropiado. El argumento widget es opcional y también puede utilizarse para ayudar a determinar el icono.

[virtual] QPalette QStyle::standardPalette() const

Devuelve la paleta estándar del estilo.

Tenga en cuenta que en los sistemas que admiten los colores del sistema, no se utiliza la paleta estándar del estilo. En particular, los estilos Windows Vista y Mac no utilizan la paleta estándar, sino que hacen uso de motores de temas nativos. Con estos estilos, no debe establecer la paleta con QApplication::setPalette().

Véase también QApplication::setPalette().

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

Devuelve un entero que representa el estilo especificado hint para el widget dado descrito por el estilo proporcionado option.

returnData se utiliza cuando el widget que realiza la consulta necesita datos más detallados que el entero que devuelve styleHint(). Véase la descripción de la clase QStyleHintReturn para más detalles.

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

Devuelve el rectángulo que contiene el subControl especificado del complejo dado control (con el estilo especificado por option). El rectángulo se define en coordenadas de pantalla.

El argumento option es un puntero a QStyleOptionComplex o a una de sus subclases, y puede convertirse al tipo apropiado utilizando la función qstyleoption_cast(). Véase drawComplexControl() para más detalles. widget es opcional y puede contener información adicional para la función.

Véase también drawComplexControl().

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

Devuelve la subárea para el element dado como se describe en el estilo proporcionado option. El rectángulo devuelto se define en coordenadas de pantalla.

El argumento widget es opcional y puede utilizarse como ayuda para determinar el área. El objeto QStyleOption puede convertirse al tipo apropiado mediante la función qstyleoption_cast(). En la tabla siguiente se indican las conversiones correspondientes a option:

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

Desinicializa la apariencia de widget.

Esta función es la contrapartida de polish(). Es llamada para cada widget pulido cada vez que el estilo es cambiado dinámicamente; el estilo anterior tiene que despulir sus ajustes antes de que el nuevo estilo pueda pulirlos de nuevo.

Tenga en cuenta que unpolish() sólo será llamada si el widget es destruido. Esto puede causar problemas en algunos casos, por ejemplo, si se elimina un widget de la interfaz de usuario, se almacena en caché, y luego se vuelve a insertar después de que el estilo haya cambiado; algunas de las clases de Qt almacenan en caché sus widgets.

Véase también polish().

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

Desinicializa la dirección application.

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

Transforma un alignment de Qt::AlignLeft o Qt::AlignRight sin Qt::AlignAbsolute en Qt::AlignLeft o Qt::AlignRight con Qt::AlignAbsolute según la disposición direction. Los otros indicadores de alineación no se modifican.

Si no se especifica ninguna alineación horizontal, la función devuelve la alineación por defecto para el diseño dado direction.

QWidget::layoutDirection

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

Devuelve el logicalPosition dado convertido a coordenadas de pantalla basándose en el direction especificado. El boundingRectangle se utiliza al realizar la traducción.

Véase también QWidget::layoutDirection.

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

Devuelve el logicalRectangle dado convertido a coordenadas de pantalla basándose en el direction especificado. Se utiliza boundingRectangle al realizar la conversión.

Esta función se proporciona para soportar escritorios de derecha a izquierda, y se utiliza normalmente en implementaciones de la función subControlRect().

Véase también QWidget::layoutDirection.