Home · All Classes · Modules

QStyle Class Reference
^{[QtGui module]}

The QStyle class is an abstract base class that encapsulates the look and feel of a GUI. More...

Inherits QObject.

Types

• enum ComplexControl { CC_SpinBox, CC_ComboBox, CC_ScrollBar, CC_Slider, ..., CC_CustomBase }
• enum ContentsType { CT_PushButton, CT_CheckBox, CT_RadioButton, CT_ToolButton, ..., CT_CustomBase }
• enum ControlElement { CE_PushButton, CE_PushButtonBevel, CE_PushButtonLabel, CE_CheckBox, ..., CE_CustomBase }
• enum PixelMetric { PM_ButtonMargin, PM_ButtonDefaultIndicator, PM_MenuButtonIndicator, PM_ButtonShiftHorizontal, ..., PM_CustomBase }
• enum PrimitiveElement { PE_Q3CheckListController, PE_Q3CheckListExclusiveIndicator, PE_Q3CheckListIndicator, PE_Q3DockWindowSeparator, ..., PE_CustomBase }
• enum StandardPixmap { SP_TitleBarMenuButton, SP_TitleBarMinButton, SP_TitleBarMaxButton, SP_TitleBarCloseButton, ..., SP_CustomBase }
• class State
• enum StateFlag { State_None, State_Enabled, State_Raised, State_Sunken, ..., State_ReadOnly }
• enum StyleHint { SH_EtchDisabledText, SH_DitherDisabledText, SH_ScrollBar_MiddleClickAbsolutePosition, SH_ScrollBar_ScrollWhenPointerLeavesControl, ..., SH_CustomBase }
• enum SubControl { SC_None, SC_ScrollBarAddLine, SC_ScrollBarSubLine, SC_ScrollBarAddPage, ..., SC_All }
• class SubControls
• enum SubElement { SE_PushButtonContents, SE_PushButtonFocusRect, SE_CheckBoxIndicator, SE_CheckBoxContents, ..., SE_CustomBase }

Methods

• __init__ (self)
• drawComplexControl (self, ComplexControl cc, QStyleOptionComplex opt, QPainter p, QWidget widget = None)
• drawControl (self, ControlElement element, QStyleOption opt, QPainter p, QWidget w = None)
• drawItemPixmap (self, QPainter painter, QRect rect, int alignment, QPixmap pixmap)
• drawItemText (self, QPainter painter, QRect rect, int flags, QPalette pal, bool enabled, QString text, QPalette.ColorRole textRole = QPalette.NoRole)
• drawPrimitive (self, PrimitiveElement pe, QStyleOption opt, QPainter p, QWidget w = None)
• QPixmap generatedIconPixmap (self, QIcon.Mode iconMode, QPixmap pixmap, QStyleOption opt)
• SubControl hitTestComplexControl (self, ComplexControl cc, QStyleOptionComplex opt, QPoint pt, QWidget widget = None)
• QRect itemPixmapRect (self, QRect r, int flags, QPixmap pixmap)
• QRect itemTextRect (self, QFontMetrics fm, QRect r, int flags, bool enabled, QString text)
• int pixelMetric (self, PixelMetric metric, QStyleOption option = None, QWidget widget = None)
• polish (self, QWidget)
• polish (self, QApplication)
• QPalette polish (self, QPalette)
• QSize sizeFromContents (self, ContentsType ct, QStyleOption opt, QSize contentsSize, QWidget w = None)
• QIcon standardIcon (self, StandardPixmap standardIcon, QStyleOption option = None, QWidget widget = None)
• QIcon standardIconImplementation (self, StandardPixmap standardIcon, QStyleOption opt = None, QWidget widget = None)
• QPalette standardPalette (self)
• QPixmap standardPixmap (self, StandardPixmap standardPixmap, QStyleOption opt = None, QWidget widget = None)
• int styleHint (self, StyleHint stylehint, QStyleOption opt = None, QWidget widget = None, QStyleHintReturn returnData = None)
• QRect subControlRect (self, ComplexControl cc, QStyleOptionComplex opt, SubControl sc, QWidget widget = None)
• QRect subElementRect (self, SubElement subElement, QStyleOption option, QWidget widget = None)
• unpolish (self, QWidget)
• unpolish (self, QApplication)

Static Methods

• QRect alignedRect (Qt.LayoutDirection direction, Qt.Alignment alignment, QSize size, QRect rectangle)
• int sliderPositionFromValue (int min, int max, int val, int space, bool upsideDown = False)
• int sliderValueFromPosition (int min, int max, int pos, int space, bool upsideDown = False)
• Qt.Alignment visualAlignment (Qt.LayoutDirection direction, Qt.Alignment alignment)
• QPoint visualPos (Qt.LayoutDirection direction, QRect boundingRect, QPoint logicalPos)
• QRect visualRect (Qt.LayoutDirection direction, QRect boundingRect, QRect logicalRect)

Qt contains a set of QStyle subclasses that emulate the styles of the different platforms supported by Qt (QWindowsStyle, QMacStyle, QMotifStyle, etc.). By default, these styles are built into the QtGui library. Styles can also be made available as plugins.

Qt's built-in widgets use QStyle to perform nearly all of their drawing, ensuring that they look exactly like the equivalent native widgets. The diagram below shows a QComboBox in eight different styles.

Topics:

• Setting a Style
• Developing Style-Aware Custom Widgets
• Creating a Custom Style
• Using a Custom Style
• Right-to-Left Desktops

The style of the entire application can be set using QApplication.setStyle(). It can also be specified by the user of the application, using the -style command-line option:

    ./myapplication -style motif

If no style is specified, Qt will choose the most appropriate style for the user's platform or desktop environment.

A style can also be set on an individual widget using QWidget.setStyle().

If you are developing custom widgets and want them to look good on all platforms, you can use QStyle functions to perform parts of the widget drawing, such as drawItem(), drawPrimitive(), drawControl(), and drawComplexControl().

Most QStyle draw functions take four arguments:

• an enum value specifying which graphical element to draw
• a QStyleOption specifying how and where to render that element
• a QPainter that should be used to draw the element
• a QWidget on which the drawing is performed (optional)

For example, if you want to draw a focus rectangle on your widget, you can write:

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

QStyle gets all the information it needs to render the graphical element from QStyleOption. The widget is passed as the last argument in case the style needs it to perform special effects (such as animated default buttons on Mac OS X), but it isn't mandatory. In fact, you can use QStyle to draw on any paint device, not just widgets, by setting the QPainter properly.

QStyleOption has various subclasses for the various types of graphical elements that can be drawn. For example, PE_FrameFocusRect expects a QStyleOptionFocusRect argument. This is documented for each enum value.

To ensure that drawing operations are as fast as possible, QStyleOption and its subclasses have public data members. See the QStyleOption class documentation for details on how to use it.

For convenience, Qt provides the QStylePainter class, which combines a QStyle, a QPainter, and a QWidget. This makes it possible to write

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

instead of

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

Depending on which parts of the base style you want to change, you must reimplement the functions that are used to draw those parts of the interface. To illustrate this, we will modify the look of the spin box arrows drawn by QWindowsStyle. The arrows are primitive elements that are drawn by the drawPrimitive() function, so we need to reimplement that function. We need the following class declaration:

    class CustomStyle : public QWindowsStyle
    {
        Q_OBJECT

    public:
        CustomStyle() {}
        ~CustomStyle() {}

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

The PE_IndicatorSpinUp and PE_IndicatorSpinDown primitive elements are used by QSpinBox to draw its up and down arrows. Here's how to reimplement drawPrimitive() to draw them differently:

    void CustomStyle.drawPrimitive(PrimitiveElement element, const QStyleOption *option,
                                    QPainter *painter, const QWidget *widget) const
    {
        if (element == PE_IndicatorSpinUp || element == PE_IndicatorSpinDown) {
            QPointArray 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 & Style_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 {
            QWindowsStyle.drawPrimitive(element, option, painter, widget);
        }
    }

Notice that we don't use the widget argument, except to pass it on to QWindowStyle.drawPrimitive(). As mentioned earlier, the information about what is to be drawn and how it should be drawn is specified by a QStyleOption object, so there is no need to ask the widget.

If you need to use the widget argument to obtain additional information, be careful to ensure that it isn't 0 and that it is of the correct type before using it. For example:

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

When implementing a custom style, you cannot assume that the widget is a QSpinBox just because the enum value is called PE_IndicatorSpinUp or PE_IndicatorSpinUp.

The documentation for the Styles example covers this topic in more detail.

There are several ways of using a custom style in a Qt application. The simplest way is call the QApplication.setStyle() static function before creating the QApplication object:

    #include <QtGui>

    #include "customstyle.h"

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

You can call QApplication.setStyle() at any time, but by calling it before the constructor, you ensure that the user's preference, set using the -style command-line option, is respected.

You may want to make your style available for use in other applications, some of which may not be yours and are not available for you to recompile. The Qt Plugin system makes it possible to create styles as plugins. Styles created as plugins are loaded as shared objects at runtime by Qt itself. Please refer to the Qt Plugin documentation for more information on how to go about creating a style plugin.

Compile your plugin and put it into $QTDIR/plugins/styles. We now have a pluggable style that Qt can load automatically. To use your new style with existing applications, simply start the application with the following argument:

    ./myapplication -style custom

The application will use the look and feel from the custom style you implemented.

If you create a custom style, you should take special care when drawing asymmetric elements to make sure that they also look correct in a mirrored layout. An easy way to test your styles is to run applications with the -reverse command-line option or to call QApplication.setLayoutDirection() in your main() function.

Here are some things to keep in mind when making a style work well in a right-to-left environment:

• subControlRect() and subElementRect() return rectangles in screen coordinates
• QStyleOption.direction indicates in which direction the item should be drawn in
• If a style is not right-to-left aware it will display items as if it were left-to-right
• visualRect(), visualPos(), and visualAlignment() are helpful functions that will translate from logical to screen representations.
• alignedRect() will return a logical rect aligned for the current direction

See also QStyleOption and QStylePainter.

Type Documentation

QStyle.ComplexControl

This enum represents a ComplexControl. ComplexControls have different behavior depending upon where the user clicks on them or which keys are pressed.

See also SubControl and drawComplexControl().

QStyle.ContentsType

This enum represents a ContentsType. It is used to calculate sizes for the contents of various widgets.

See also sizeFromContents().

QStyle.ControlElement

This enum represents a ControlElement. A ControlElement is part of a widget that performs some action or displays information to the user.

See also drawControl().

QStyle.PixelMetric

This enum represents a PixelMetric. A PixelMetric is a style dependent size represented as a single pixel value.

See also pixelMetric().

QStyle.PrimitiveElement

This enum represents a style's PrimitiveElements. A PrimitiveElement is a common GUI element, such as a checkbox indicator or button bevel.

See also drawPrimitive().

QStyle.StandardPixmap

This enum represents a StandardPixmap. A StandardPixmap is a pixmap that can follow some existing GUI style or guideline.

See also standardPixmap().

QStyle.StateFlag

This enum represents flags for drawing PrimitiveElements. Not all primitives use all of these flags. Note that these flags may mean different things to different primitives.

The State type is a typedef for QFlags<StateFlag>. It stores an OR combination of StateFlag values.

See also drawPrimitive().

QStyle.StyleHint

This enum represents a StyleHint. A StyleHint is a general look and/or feel hint.

See also styleHint().

QStyle.SubControl

This enum represents a SubControl within a ComplexControl.

The SubControls type is a typedef for QFlags<SubControl>. It stores an OR combination of SubControl values.

See also ComplexControl.

QStyle.SubElement

This enum represents a sub-area of a widget. Style implementations use these areas to draw the different parts of a widget.

See also subElementRect().

Method Documentation

QStyle.__init__ (self)

QRect QStyle.alignedRect (Qt.LayoutDirection direction, Qt.Alignment alignment, QSize size, QRect rectangle)

Returns a new rectangle of size that is aligned to rectangle according to alignment and based on direction.

QStyle.drawComplexControl (self, ComplexControl cc, QStyleOptionComplex opt, QPainter p, QWidget widget = None)

This method is abstract and should be reimplemented in any sub-class.

Draws the ComplexControl control using painter with the style options specified by option.

The widget argument is optional and may contain a widget to aid in drawing control.

The option parameter is a pointer to a QStyleOptionComplex structure that can be cast to the correct structure. Note that the rect member of option must be in logical coordinates. Reimplementations of this function should use visualRect() to change the logical coordinates into screen coordinates before calling drawPrimitive() or drawControl().

Here is a table listing the elements and what they can be cast to, along with an explaination of the flags.

See also ComplexControl, SubControl, and QStyleOptionComplex.

QStyle.drawControl (self, ControlElement element, QStyleOption opt, QPainter p, QWidget w = None)

This method is abstract and should be reimplemented in any sub-class.

Draws the ControlElement element with painter with the style options specified by option.

The widget argument is optional and may contain a widget that may aid in drawing the control.

What follows is a table of the elements and the QStyleOption structure the option parameter can cast to. The flags stored in the QStyleOption state variable are also listed. If a ControlElement is not listed here, it uses a plain QStyleOption.

See also ControlElement, State, and QStyleOption.

QStyle.drawItemPixmap (self, QPainter painter, QRect rect, int alignment, QPixmap pixmap)

Draws the pixmap in rectangle rect with alignment alignment using painter.

QStyle.drawItemText (self, QPainter painter, QRect rect, int flags, QPalette pal, bool enabled, QString text, QPalette.ColorRole textRole = QPalette.NoRole)

Draws the text in rectangle rect using painter and palette pal.

Text is drawn using the painter's pen. If an explicit textRole is specified, then the text is drawn using the color specified in pal for the specified role. The enabled bool indicates whether or not the item is enabled; when reimplementing this bool should influence how the item is drawn.

The text is aligned and wrapped according to alignment.

See also Qt.Alignment.

QStyle.drawPrimitive (self, PrimitiveElement pe, QStyleOption opt, QPainter p, QWidget w = None)

This method is abstract and should be reimplemented in any sub-class.

Draw the primitive option elem with painter using the style options specified by option.

The widget argument is optional and may contain a widget that may aid in drawing the primitive.

What follows is a table of the elements and the QStyleOption structure the option parameter can be cast to. The flags stored in the QStyleOption state variable are also listed. If a PrimitiveElement is not listed here, it uses a plain QStyleOption.

The QStyleOption is the the following for the following types of PrimitiveElements.

See also PrimitiveElement, State, and QStyleOption.

QPixmap QStyle.generatedIconPixmap (self, QIcon.Mode iconMode, QPixmap pixmap, QStyleOption opt)

This method is abstract and should be reimplemented in any sub-class.

Returns a pixmap styled to conform to iconMode description out of pixmap, and taking into account the palette specified by option.

The option can pass extra information, but it must contain a palette.

Not all types of pixmaps will change from their input in which case the result will simply be the pixmap passed in.

SubControl QStyle.hitTestComplexControl (self, ComplexControl cc, QStyleOptionComplex opt, QPoint pt, QWidget widget = None)

This method is abstract and should be reimplemented in any sub-class.

Returns the SubControl in the ComplexControl control with the style options specified by option at the point pos. The option argument is a pointer to a QStyleOptionComplex structure or one of its subclasses. The structure can be cast to the appropriate type based on the value of control. See drawComplexControl() for details.

The widget argument is optional and can contain additional information for the functions.

Note that pos is expressed in screen coordinates.

See also drawComplexControl(), ComplexControl, SubControl, subControlRect(), and QStyleOptionComplex.

QRect QStyle.itemPixmapRect (self, QRect r, int flags, QPixmap pixmap)

Returns the appropriate area within rectangle rect in which to draw the pixmap with alignment defined in alignment.

QRect QStyle.itemTextRect (self, QFontMetrics fm, QRect r, int flags, bool enabled, QString text)

Returns the appropriate area (see below) within rectangle rect in which to draw text using the font metrics metrics.

The text is aligned in accordance with alignment. The enabled bool indicates whether or not the item is enabled.

If rect is larger than the area needed to render the text the rectangle that is returned will be offset within rect in accordance with the alignment alignment. For example, if alignment is Qt.AlignCenter, the returned rectangle will be centered within rect. If rect is smaller than the area needed, the rectangle that is returned will be larger than rect (the smallest rectangle large enough to render the text).

See also Qt.Alignment.

int QStyle.pixelMetric (self, PixelMetric metric, QStyleOption option = None, QWidget widget = None)

This method is abstract and should be reimplemented in any sub-class.

Returns the pixel metric for the given metric. The option and widget can be used for calculating the metric. The option can be cast to the appropriate type based on the value of metric. Note that option may be zero even for PixelMetrics that can make use of option. See the table below for the appropriate option casts:

In general, the widget argument is not used.

QStyle.polish (self, QWidget)

Initializes the appearance of widget.

This function is called for every widget at some point after it has been fully created but just before it is shown for the very first time.

Reasonable actions in this function might be to call QWidget.setBackgroundMode() for the widget. An example of highly unreasonable use would be setting the geometry! Reimplementing this function gives you a back-door through which you can change the appearance of a widget. With Qt 4.0's style engine you will rarely need to write your own polish(); instead reimplement drawItem(), drawPrimitive(), etc.

The QWidget.inherits() function may provide enough information to allow class-specific customizations. But be careful not to hard-code things too much because new QStyle subclasses are expected to work reasonably with all current and future widgets.

See also unpolish().

QStyle.polish (self, QApplication)

This is an overloaded member function, provided for convenience.

Late initialization of the QApplication object app.

See also unpolish().

QPalette QStyle.polish (self, QPalette)

This is an overloaded member function, provided for convenience.

The style may have certain requirements for color palettes. In this function it has the chance to change the palette pal according to these requirements.

See also QPalette and QApplication.setPalette().

QSize QStyle.sizeFromContents (self, ContentsType ct, QStyleOption opt, QSize contentsSize, QWidget w = None)

This method is abstract and should be reimplemented in any sub-class.

Returns the size of styled object described in option based on the contents size contentsSize.

The option argument is a pointer to a QStyleOption or one of its subclasses. The option can be cast to the appropriate type based on the value of type. The widget widget is optional argument and can contain extra information used for calculating the size. See the table below for the appropriate option usage:

See also ContentsType and QStyleOption.

int QStyle.sliderPositionFromValue (int min, int max, int val, int space, bool upsideDown = False)

Converts logicalValue to a pixel position. min maps to 0, max maps to span and other values are distributed evenly in-between.

See also sliderValueFromPosition().

int QStyle.sliderValueFromPosition (int min, int max, int pos, int space, bool upsideDown = False)

Converts the pixel position pos to a value. 0 maps to min, span maps to max and other values are distributed evenly in-between.

See also sliderPositionFromValue().

QIcon QStyle.standardIcon (self, StandardPixmap standardIcon, QStyleOption option = None, QWidget widget = None)

Returns an icon for standardIcon.

The option argument can be used to pass extra information required when determining the icon.

The widget argument is optional and may contain a widget that may aid determining the icon.

Warning: Because of binary compatibility constraints, this function is not virtual. If you want to provide your own icons in a QStyle subclass, add a slot called standardIconImplementation() to you subclass. The standardIcon() function will dynamically detect the slot and call it.

This function was introduced in Qt 4.1.

See also standardIconImplementation() and standardPixmap().

QIcon QStyle.standardIconImplementation (self, StandardPixmap standardIcon, QStyleOption opt = None, QWidget widget = None)

This method is also a Qt slot with the C++ signature QIcon standardIconImplementation(QStyle::StandardPixmap,const QStyleOption * = 0,const QWidget * = 0) const.

Returns an icon for standardIcon.

The option argument contains extra information required when determining the icon. The widget argument is optional and may contain a widget that may aid determining the icon.

The default implementation simply calls standardPixmap(standardIcon, option, widget).

Warning: Because of binary compatibility constraints, the standardIcon() function, introduced in Qt 4.1, isn't virtual. If you want to provide your own icons in a QStyle subclass, add a slot called standardIconImplementation() to your subclass. The standardIcon() function will dynamically detect the slot and call it.

This function was introduced in Qt 4.1.

See also standardIcon().

QPalette QStyle.standardPalette (self)

Returns the style's standard palette. On systems that support system colors, the style's standard palette is not used.

QPixmap QStyle.standardPixmap (self, StandardPixmap standardPixmap, QStyleOption opt = None, QWidget widget = None)

This method is abstract and should be reimplemented in any sub-class.

Returns a pixmap for standardPixmap.

The option argument can be used to pass extra information required when drawing the ControlElement.

The widget argument is optional and may contain a widget that may aid in drawing the control.

See also standardIcon().

int QStyle.styleHint (self, StyleHint stylehint, QStyleOption opt = None, QWidget widget = None, QStyleHintReturn returnData = None)

This method is abstract and should be reimplemented in any sub-class.

Returns the style hint hint for widget described in the QStyleOption option. Currently returnData and widget are not used; they are provided for future enhancement. The option parameter is used only in SH_ComboBox_Popup, SH_ComboBox_LayoutDirection, and SH_GroupBox_TextLabelColor.

For an explanation of the return value, see StyleHint.

QRect QStyle.subControlRect (self, ComplexControl cc, QStyleOptionComplex opt, SubControl sc, QWidget widget = None)

This method is abstract and should be reimplemented in any sub-class.

Returns the rectangle for the SubControl subControl in the ComplexControl control, with the style options specified by option in visual coordinates.

The option argument is a pointer to a QStyleOptionComplex or one of its subclasses. The structure can be cast to the appropriate type based on the value of control. See drawComplexControl() for details.

The widget is optional and can contain additional information for the function.

See also drawComplexControl(), ComplexControl, SubControl, and QStyleOptionComplex.

QRect QStyle.subElementRect (self, SubElement subElement, QStyleOption option, QWidget widget = None)

This method is abstract and should be reimplemented in any sub-class.

Returns the sub-area element as described in option in logical coordinates.

The widget argument is optional and may contain a widget that may aid determining the subRect.

The QStyleOption can be cast to the appropriate type based on the value of element. See the table below for the appropriate option casts:

See also SubElement and QStyleOption.

QStyle.unpolish (self, QWidget)

Undoes the initialization of widget widget's appearance.

This function is the counterpart to polish. It is called for every polished widget when the style is dynamically changed. The former style has to unpolish its settings before the new style can polish them again.

See also polish().

QStyle.unpolish (self, QApplication)

This is an overloaded member function, provided for convenience.

Undoes the polish of application app.

See also polish().

Qt.Alignment QStyle.visualAlignment (Qt.LayoutDirection direction, Qt.Alignment alignment)

Transforms an alignment of Qt.AlignLeft or Qt.AlignRight without Qt.AlignAbsolute into Qt.AlignLeft or Qt.AlignRight with Qt.AlignAbsolute according to the layout direction. The other alignment flags are left untouched.

If no horizontal aligment was specified, the function returns the default alignment for the layout direction.

QWidget.layoutDirection

QPoint QStyle.visualPos (Qt.LayoutDirection direction, QRect boundingRect, QPoint logicalPos)

Returns the point logicalPos converted to screen coordinates based on direction. The boundingRect rectangle is used to perform the translation.

See also QWidget.layoutDirection.

QRect QStyle.visualRect (Qt.LayoutDirection direction, QRect boundingRect, QRect logicalRect)

Returns the rectangle logicalRect converted to screen coordinates based on direction. The boundingRect rectangle is used to perform the translation.

This function is provided to aid style implementors in supporting right-to-left desktops. It typically is used in subControlRect().

See also QWidget.layoutDirection.