![]() |
Home · Overviews · Examples |
Qt's style API is responsible for performing the widget drawing for built-in widgets. The Qt 4 style API has been revised to make it possible for a style to draw widgets without calling any functions on the widget.
Because Qt 4 is split across multiple libraries, Qt needed this update to be able to draw widgets from other libraries than QtGui. For application developers, this has other benefits, such as more managable parameter lists and the possibility of drawing any graphical element without having a widget of a specific type.General Overview
The QStyle class is an abstract base class that encapsulates the look and feel of a GUI. Qt's built-in widgets use it to perform nearly all of their drawing, ensuring that they look exactly like the equivalent native widgets.
Most draw functions now take four arguments:
Thanks to QStyleOption, it is now possible to make QStyle draw widgets without linking in any code for the widget. This is how Qt's built-in styles can draw Qt 3 widgets such as Q3ListView without necessarily linking against the Qt3Support library. Another significant benefit of the new approach is that it's now possible to use QStyle's draw functions on other widgets than the built-in widgets; for example, you can draw a combobox on any widget, not just on a QComboBox.
QStyleOption has various subclasses for the various types of graphical elements that can be drawn, and it's possible to create custom subclasses. For example, the QStyle::PE_FrameFocusRect element expects a QStyleOptionFocusRect argument. This is documented for each enum value.
When reimplementing QStyle functions that take a QStyleOption parameter, you often need to cast the QStyleOption to a subclass (e.g., QStyleOptionFocusRect). For safety, you can use qstyleoption_cast() to ensure that the pointer type is correct. If the object isn't of the right type, qstyleoption_cast() returns 0. For example:
const QStyleOptionFocusRect *focusRectOption = qstyleoption_cast<const QStyleOptionFocusRect *>(option); if (focusRectOption) { ... }For performance reasons, there are few member functions and the access to the variables is direct. This "low-level" feel makes the structures use straightforward and emphasizes that these are simply parameters used by the style functions. In addition, the caller of a QStyle function usually creates QStyleOption objects on the stack. This combined with Qt's extensive use of implicit sharing for types such as QString, QPalette, and QColor ensures that no memory allocation needlessly takes place. (Dynamic memory allocation can be an expensive operation, especially when drawing very often in a short time.)
void MyWidget::paintEvent(QPaintEvent *event) { QPainter painter(this); ... QStyleOptionFocusRect option(1); option.init(this); option.backgroundColor = palette().color(QPalette::Window); style().drawPrimitive(QStyle::PE_FrameFocusRect, &option, &painter, this); }The next example shows how to derive from an existing style to customize the look of a graphical element:
public class CustomStyle extends QWindowsStyle { public CustomStyle() { ... } public void drawPrimitive(QStyle.PrimitiveElement element, QStyleOption option, QPainter painter, QWidget widget) { ... } }See also the Styles Example for a more detailed description of how custom styles can be created.
public void drawPrimitive(QStyle.PrimitiveElement element, QStyleOption option, QPainter painter, QWidget widget) { if (element.equals(QStyle.PrimitiveElement.PE_IndicatorSpinUp) || element.equals(QStyle.PrimitiveElement.PE_IndicatorSpinDown)) { QPolygon points = new QPolygon(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.equals(QStyle.PrimitiveElement.PE_IndicatorSpinUp)) { points.add(new QPoint(x, y + h)); points.add(new QPoint(x + w, y + h)); points.add(new QPoint(x + w / 2, y)); } else { // PE_SpinBoxDown points.add(new QPoint(x, y)); points.add(new QPoint(x + w, y)); points.add(new QPoint(x + w / 2, y + h)); } if (option.state().isSet(QStyle.StateFlag.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 { super.drawPrimitive(element, option, painter, widget); } }
void drawControl(ControlElement element, QPainter *painter, const QWidget *widget, const QRect &rect, const QColorGroup &colorGroup, SFlags how = Style_Default, const QStyleOption &option = QStyleOption::Default) const;Here's the signature of the same function in Qt 4:
void drawControl(ControlElement element, const QStyleOption *option, QPainter *painter, const QWidget *widget = 0) const;In Qt 3, some of the information required to draw a graphical element was stored in a QStyleOption parameter, while the rest was deduced by querying the widget. In Qt 4, everything is stored in the QStyleOption parameter.
Copyright © 2008 Trolltech | Trademarks | Qt Jambi 4.4.0_01 |