--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/src/gui/styles/qstyleoption.cpp Mon Jan 11 14:00:40 2010 +0000
@@ -0,0 +1,5379 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** All rights reserved.
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the QtGui module of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** No Commercial Usage
+** This file contains pre-release code and may not be distributed.
+** You may use this file in accordance with the terms and conditions
+** contained in the Technology Preview License Agreement accompanying
+** this package.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Nokia gives you certain additional
+** rights. These rights are described in the Nokia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** If you have questions regarding the use of this file, please contact
+** Nokia at qt-info@nokia.com.
+**
+**
+**
+**
+**
+**
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#include "qstyleoption.h"
+#include "qapplication.h"
+#ifdef Q_WS_MAC
+# include "private/qt_mac_p.h"
+# include "qmacstyle_mac.h"
+#endif
+#ifndef QT_NO_DEBUG
+#include <qdebug.h>
+#endif
+#include <QtCore/qmath.h>
+
+QT_BEGIN_NAMESPACE
+
+/*!
+ \class QStyleOption
+ \brief The QStyleOption class stores the parameters used by QStyle functions.
+
+ \ingroup appearance
+
+ QStyleOption and its subclasses contain all the information that
+ QStyle functions need to draw a graphical element.
+
+ For performance reasons, there are few member functions and the
+ access to the member variables is direct (i.e., using the \c . or
+ \c -> operator). This low-level feel makes the structures
+ straightforward to use and emphasizes that these are simply
+ parameters used by the style functions.
+
+ The caller of a QStyle function usually creates QStyleOption
+ objects on the stack. This combined with Qt's extensive use of
+ \l{implicit sharing} for types such as QString, QPalette, and
+ QColor ensures that no memory allocation needlessly takes place.
+
+ The following code snippet shows how to use a specific
+ QStyleOption subclass to paint a push button:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 0
+
+ In our example, the control is a QStyle::CE_PushButton, and
+ according to the QStyle::drawControl() documentation the
+ corresponding class is QStyleOptionButton.
+
+ When reimplementing QStyle functions that take a QStyleOption
+ parameter, you often need to cast the QStyleOption to a subclass.
+ For safety, you can use qstyleoption_cast() to ensure that the
+ pointer type is correct. For example:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 4
+
+ The qstyleoption_cast() function will return 0 if the object to
+ which \c option points is not of the correct type.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyle, QStylePainter
+*/
+
+/*!
+ \enum QStyleOption::OptionType
+
+ This enum is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \value SO_Button \l QStyleOptionButton
+ \value SO_ComboBox \l QStyleOptionComboBox
+ \value SO_Complex \l QStyleOptionComplex
+ \value SO_Default QStyleOption
+ \value SO_DockWidget \l QStyleOptionDockWidget
+ \value SO_FocusRect \l QStyleOptionFocusRect
+ \value SO_Frame \l QStyleOptionFrame \l QStyleOptionFrameV2
+ \value SO_GraphicsItem \l QStyleOptionGraphicsItem
+ \value SO_GroupBox \l QStyleOptionGroupBox
+ \value SO_Header \l QStyleOptionHeader
+ \value SO_MenuItem \l QStyleOptionMenuItem
+ \value SO_ProgressBar \l QStyleOptionProgressBar \l QStyleOptionProgressBarV2
+ \value SO_RubberBand \l QStyleOptionRubberBand
+ \value SO_SizeGrip \l QStyleOptionSizeGrip
+ \value SO_Slider \l QStyleOptionSlider
+ \value SO_SpinBox \l QStyleOptionSpinBox
+ \value SO_Tab \l QStyleOptionTab
+ \value SO_TabBarBase \l QStyleOptionTabBarBase
+ \value SO_TabWidgetFrame \l QStyleOptionTabWidgetFrame
+ \value SO_TitleBar \l QStyleOptionTitleBar
+ \value SO_ToolBar \l QStyleOptionToolBar
+ \value SO_ToolBox \l QStyleOptionToolBox
+ \value SO_ToolButton \l QStyleOptionToolButton
+ \value SO_ViewItem \l QStyleOptionViewItem (used in Interviews)
+
+ The following values are used for custom controls:
+
+ \value SO_CustomBase Reserved for custom QStyleOptions;
+ all custom controls values must be above this value
+ \value SO_ComplexCustomBase Reserved for custom QStyleOptions;
+ all custom complex controls values must be above this value
+
+ Some style options are defined for various Qt3Support controls:
+
+ \value SO_Q3DockWindow \l QStyleOptionQ3DockWindow
+ \value SO_Q3ListView \l QStyleOptionQ3ListView
+ \value SO_Q3ListViewItem \l QStyleOptionQ3ListViewItem
+
+ \sa type
+*/
+
+/*!
+ Constructs a QStyleOption with the specified \a version and \a
+ type.
+
+ The version has no special meaning for QStyleOption; it can be
+ used by subclasses to distinguish between different version of
+ the same option type.
+
+ The \l state member variable is initialized to
+ QStyle::State_None.
+
+ \sa version, type
+*/
+
+QStyleOption::QStyleOption(int version, int type)
+ : version(version), type(type), state(QStyle::State_None),
+ direction(QApplication::layoutDirection()), fontMetrics(QFont())
+{
+}
+
+
+/*!
+ Destroys this style option object.
+*/
+QStyleOption::~QStyleOption()
+{
+}
+
+/*!
+ \fn void QStyleOption::initFrom(const QWidget *widget)
+ \since 4.1
+
+ Initializes the \l state, \l direction, \l rect, \l palette, and
+ \l fontMetrics member variables based on the specified \a widget.
+
+ This is a convenience function; the member variables can also be
+ initialized manually.
+
+ \sa QWidget::layoutDirection(), QWidget::rect(),
+ QWidget::palette(), QWidget::fontMetrics()
+*/
+
+/*!
+ \obsolete
+
+ Use initFrom(\a widget) instead.
+*/
+void QStyleOption::init(const QWidget *widget)
+{
+ QWidget *window = widget->window();
+ state = QStyle::State_None;
+ if (widget->isEnabled())
+ state |= QStyle::State_Enabled;
+ if (widget->hasFocus())
+ state |= QStyle::State_HasFocus;
+ if (window->testAttribute(Qt::WA_KeyboardFocusChange))
+ state |= QStyle::State_KeyboardFocusChange;
+ if (widget->underMouse())
+ state |= QStyle::State_MouseOver;
+ if (window->isActiveWindow())
+ state |= QStyle::State_Active;
+ if (widget->isWindow())
+ state |= QStyle::State_Window;
+#ifdef Q_WS_MAC
+ extern bool qt_mac_can_clickThrough(const QWidget *w); //qwidget_mac.cpp
+ if (!(state & QStyle::State_Active) && !qt_mac_can_clickThrough(widget))
+ state &= ~QStyle::State_Enabled;
+
+ switch (QMacStyle::widgetSizePolicy(widget)) {
+ case QMacStyle::SizeSmall:
+ state |= QStyle::State_Small;
+ break;
+ case QMacStyle::SizeMini:
+ state |= QStyle::State_Mini;
+ break;
+ default:
+ ;
+ }
+#endif
+#ifdef QT_KEYPAD_NAVIGATION
+ if (widget->hasEditFocus())
+ state |= QStyle::State_HasEditFocus;
+#endif
+
+ direction = widget->layoutDirection();
+ rect = widget->rect();
+ palette = widget->palette();
+ fontMetrics = widget->fontMetrics();
+}
+
+/*!
+ Constructs a copy of \a other.
+*/
+QStyleOption::QStyleOption(const QStyleOption &other)
+ : version(Version), type(Type), state(other.state),
+ direction(other.direction), rect(other.rect), fontMetrics(other.fontMetrics),
+ palette(other.palette)
+{
+}
+
+/*!
+ Assign \a other to this QStyleOption.
+*/
+QStyleOption &QStyleOption::operator=(const QStyleOption &other)
+{
+ state = other.state;
+ direction = other.direction;
+ rect = other.rect;
+ fontMetrics = other.fontMetrics;
+ palette = other.palette;
+ return *this;
+}
+
+/*!
+ \enum QStyleOption::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Default} for
+ this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOption::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOption::palette
+ \brief the palette that should be used when painting the control
+
+ By default, the application's default palette is used.
+
+ \sa initFrom()
+*/
+
+/*!
+ \variable QStyleOption::direction
+ \brief the text layout direction that should be used when drawing text in the control
+
+ By default, the layout direction is Qt::LeftToRight.
+
+ \sa initFrom()
+*/
+
+/*!
+ \variable QStyleOption::fontMetrics
+ \brief the font metrics that should be used when drawing text in the control
+
+ By default, the application's default font is used.
+
+ \sa initFrom()
+*/
+
+/*!
+ \variable QStyleOption::rect
+ \brief the area that should be used for various calculations and painting
+
+ This can have different meanings for different types of elements.
+ For example, for a \l QStyle::CE_PushButton element it would be
+ the rectangle for the entire button, while for a \l
+ QStyle::CE_PushButtonLabel element it would be just the area for
+ the push button label.
+
+ The default value is a null rectangle, i.e. a rectangle with both
+ the width and the height set to 0.
+
+ \sa initFrom()
+*/
+
+/*!
+ \variable QStyleOption::state
+ \brief the style flags that are used when drawing the control
+
+ The default value is QStyle::State_None.
+
+ \sa initFrom(), QStyle::drawPrimitive(), QStyle::drawControl(),
+ QStyle::drawComplexControl(), QStyle::State
+*/
+
+/*!
+ \variable QStyleOption::type
+ \brief the option type of the style option
+
+ The default value is SO_Default.
+
+ \sa OptionType
+*/
+
+/*!
+ \variable QStyleOption::version
+ \brief the version of the style option
+
+ This value can be used by subclasses to implement extensions
+ without breaking compatibility. If you use the qstyleoption_cast()
+ function, you normally do not need to check it.
+
+ The default value is 1.
+*/
+
+/*!
+ \class QStyleOptionFocusRect
+ \brief The QStyleOptionFocusRect class is used to describe the
+ parameters for drawing a focus rectangle with QStyle.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionFocusRect, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionFocusRect::QStyleOptionFocusRect()
+ : QStyleOption(Version, SO_FocusRect)
+{
+ state |= QStyle::State_KeyboardFocusChange; // assume we had one, will be corrected in initFrom()
+}
+
+/*!
+ \internal
+*/
+QStyleOptionFocusRect::QStyleOptionFocusRect(int version)
+ : QStyleOption(version, SO_FocusRect)
+{
+ state |= QStyle::State_KeyboardFocusChange; // assume we had one, will be corrected in initFrom()
+}
+
+/*!
+ \enum QStyleOptionFocusRect::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_FocusRect} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionFocusRect::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \fn QStyleOptionFocusRect::QStyleOptionFocusRect(const QStyleOptionFocusRect &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \variable QStyleOptionFocusRect::backgroundColor
+ \brief the background color on which the focus rectangle is being drawn
+
+ The default value is an invalid color with the RGB value (0, 0,
+ 0). An invalid color is a color that is not properly set up for
+ the underlying window system.
+*/
+
+/*!
+ \class QStyleOptionFrame
+ \brief The QStyleOptionFrame class is used to describe the
+ parameters for drawing a frame.
+
+ QStyleOptionFrame is used for drawing several built-in Qt widgets,
+ including QFrame, QGroupBox, QLineEdit, and QMenu. Note that to
+ describe the parameters necessary for drawing a frame in Qt 4.1 or
+ above, you must use the QStyleOptionFrameV2 subclass.
+
+ An instance of the QStyleOptionFrame class has
+ \l{QStyleOption::type} {type} SO_Frame and \l{QStyleOption::version}
+ {version} 1.
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles. The
+ version is used by QStyleOption subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast(),
+ you normally do not need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionFrame and QStyleOptionFrameV2.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionFrameV2, QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionFrame, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionFrame::QStyleOptionFrame()
+ : QStyleOption(Version, SO_Frame), lineWidth(0), midLineWidth(0)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionFrame::QStyleOptionFrame(int version)
+ : QStyleOption(version, SO_Frame), lineWidth(0), midLineWidth(0)
+{
+}
+
+/*!
+ \fn QStyleOptionFrame::QStyleOptionFrame(const QStyleOptionFrame &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionFrame::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Frame} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionFrame::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionFrame::lineWidth
+ \brief the line width for drawing the frame
+
+ The default value is 0.
+
+ \sa QFrame::lineWidth
+*/
+
+/*!
+ \variable QStyleOptionFrame::midLineWidth
+ \brief the mid-line width for drawing the frame
+
+ This is usually used in drawing sunken or raised frames.
+
+ The default value is 0.
+
+ \sa QFrame::midLineWidth
+*/
+
+/*!
+ \class QStyleOptionFrameV2
+ \brief The QStyleOptionFrameV2 class is used to describe the
+ parameters necessary for drawing a frame in Qt 4.1 or above.
+
+ \since 4.1
+
+ QStyleOptionFrameV2 inherits QStyleOptionFrame which is used for
+ drawing several built-in Qt widgets, including QFrame, QGroupBox,
+ QLineEdit, and QMenu.
+
+ An instance of the QStyleOptionFrameV2 class has
+ \l{QStyleOption::type} {type} SO_Frame and
+ \l{QStyleOption::version} {version} 2. The type is used
+ internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles. The
+ version is used by QStyleOption subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast(),
+ you normally do not need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionFrame and QStyleOptionFrameV2. One way to achieve this
+ is to use the QStyleOptionFrameV2 copy constructor. For example:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 1
+
+ In the example above: If the \c frameOption's version is 1, \l
+ FrameFeature is set to \l None for \c frameOptionV2. If \c
+ frameOption's version is 2, the constructor will simply copy the
+ \c frameOption's \l FrameFeature value.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionFrame, QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionFrameV2 object.
+*/
+QStyleOptionFrameV2::QStyleOptionFrameV2()
+ : QStyleOptionFrame(Version), features(None)
+{
+}
+
+/*!
+ \fn QStyleOptionFrameV2::QStyleOptionFrameV2(const QStyleOptionFrameV2 &other)
+
+ Constructs a QStyleOptionFrameV2 copy of the \a other style option.
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionFrameV2::QStyleOptionFrameV2(int version)
+ : QStyleOptionFrame(version), features(None)
+{
+}
+
+/*!
+ Constructs a QStyleOptionFrameV2 copy of the \a other style option
+ which can be either of the QStyleOptionFrameV2 or
+ QStyleOptionFrame types.
+
+ If the \a other style option's version is 1, the new style option's \l
+ FrameFeature value is set to \l QStyleOptionFrameV2::None. If its
+ version is 2, its \l FrameFeature value is simply copied to the
+ new style option.
+
+ \sa version
+*/
+QStyleOptionFrameV2::QStyleOptionFrameV2(const QStyleOptionFrame &other)
+{
+ QStyleOptionFrame::operator=(other);
+
+ const QStyleOptionFrameV2 *f2 = qstyleoption_cast<const QStyleOptionFrameV2 *>(&other);
+ features = f2 ? f2->features : FrameFeatures(QStyleOptionFrameV2::None);
+ version = Version;
+}
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be either of the QStyleOptionFrameV2 or
+ QStyleOptionFrame types.
+
+ If the \a{other} style option's version is 1, this style option's
+ \l FrameFeature value is set to \l QStyleOptionFrameV2::None. If
+ its version is 2, its \l FrameFeature value is simply copied to
+ this style option.
+*/
+QStyleOptionFrameV2 &QStyleOptionFrameV2::operator=(const QStyleOptionFrame &other)
+{
+ QStyleOptionFrame::operator=(other);
+
+ const QStyleOptionFrameV2 *f2 = qstyleoption_cast<const QStyleOptionFrameV2 *>(&other);
+ features = f2 ? f2->features : FrameFeatures(QStyleOptionFrameV2::None);
+ version = Version;
+ return *this;
+}
+
+/*!
+ \enum QStyleOptionFrameV2::FrameFeature
+
+ This enum describes the different types of features a frame can have.
+
+ \value None Indicates a normal frame.
+ \value Flat Indicates a flat frame.
+*/
+
+/*!
+ \variable QStyleOptionFrameV2::features
+ \brief a bitwise OR of the features that describe this frame.
+
+ \sa FrameFeature
+*/
+
+/*!
+ \enum QStyleOptionFrameV2::StyleOptionVersion
+
+ This enum is used to hold information about the version of the
+ style option, and is defined for each QStyleOption subclass.
+
+ \value Version 2
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \class QStyleOptionFrameV3
+ \brief The QStyleOptionFrameV3 class is used to describe the
+ parameters necessary for drawing a frame in Qt 4.1 or above.
+
+ \since 4.5
+
+ QStyleOptionFrameV3 inherits QStyleOptionFrameV2
+
+ An instance of the QStyleOptionFrameV3 class has
+ \l{QStyleOption::type} {type} SO_Frame and
+ \l{QStyleOption::version} {version} 3. The type is used
+ internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles. The
+ version is used by QStyleOption subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast(),
+ you normally do not need to check it.
+
+ \sa QStyleOptionFrameV2, QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionFrameV3 object.
+*/
+QStyleOptionFrameV3::QStyleOptionFrameV3()
+ : QStyleOptionFrameV2(Version), frameShape(QFrame::NoFrame), unused(0)
+{
+}
+
+/*!
+ \fn QStyleOptionFrameV3::QStyleOptionFrameV3(const QStyleOptionFrameV3 &other)
+
+ Constructs a QStyleOptionFrameV3 copy of the \a other style option.
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionFrameV3::QStyleOptionFrameV3(int version)
+ : QStyleOptionFrameV2(version), frameShape(QFrame::NoFrame), unused(0)
+{
+}
+
+/*!
+ Constructs a QStyleOptionFrameV3 copy of the \a other style option
+ which can be either of the QStyleOptionFrameV3 or
+ QStyleOptionFrame types.
+
+ If the \a other style option's version is 1, the new style
+ option's \l FrameFeature value is set to
+ \l{QStyleOptionFrameV2::None}. If its version is 2 or lower,
+ \l{QStyleOptionFrameV3::frameShape} value is QFrame::NoFrame
+
+ \sa version
+*/
+QStyleOptionFrameV3::QStyleOptionFrameV3(const QStyleOptionFrame &other)
+{
+ operator=(other);
+}
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be either of the QStyleOptionFrameV3,
+ QStyleOptionFrameV2 or QStyleOptionFrame types.
+
+ If the \a other style option's version is 1, the new style
+ option's \l FrameFeature value is set to
+ \l{QStyleOptionFrameV2::None}. If its version is 2 or lower,
+ \l{QStyleOptionFrameV3::frameShape} value is QFrame::NoFrame
+*/
+QStyleOptionFrameV3 &QStyleOptionFrameV3::operator=(const QStyleOptionFrame &other)
+{
+ QStyleOptionFrameV2::operator=(other);
+
+ const QStyleOptionFrameV3 *f3 = qstyleoption_cast<const QStyleOptionFrameV3 *>(&other);
+ frameShape = f3 ? f3->frameShape : QFrame::NoFrame;
+ version = Version;
+ return *this;
+}
+
+
+/*!
+ \variable QStyleOptionFrameV3::frameShape
+ \brief This property holds the frame shape value of the frame.
+
+ \sa QFrame::frameShape
+*/
+
+/*!
+ \enum QStyleOptionFrameV3::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 3
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \class QStyleOptionViewItemV2
+ \brief The QStyleOptionViewItemV2 class is used to describe the
+ parameters necessary for drawing a frame in Qt 4.2 or above.
+ \since 4.2
+
+ QStyleOptionViewItemV2 inherits QStyleOptionViewItem.
+
+ An instance of the QStyleOptionViewItemV2 class has
+ \l{QStyleOption::type} {type} SO_ViewItem and
+ \l{QStyleOption::version} {version} 2. The type is used internally
+ by QStyleOption, its subclasses, and qstyleoption_cast() to
+ determine the type of style option. In general you do not need to
+ worry about this unless you want to create your own QStyleOption
+ subclass and your own styles. The version is used by QStyleOption
+ subclasses to implement extensions without breaking
+ compatibility. If you use qstyleoption_cast(), you normally do not
+ need to check it.
+
+ See QStyleOptionFrameV2's detailed description for a discussion
+ of how to handle "V2" classes.
+
+ \sa QStyleOptionViewItem, QStyleOption
+*/
+
+/*!
+ \enum QStyleOptionViewItemV2::StyleOptionVersion
+
+ This enum is used to hold information about the version of the
+ style option, and is defined for each QStyleOption subclass.
+
+ \value Version 2
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionViewItemV2::features
+ \brief a bitwise OR of the features that describe this view item
+
+ \sa ViewItemFeature
+*/
+
+/*!
+ Constructs a QStyleOptionViewItemV2 object.
+*/
+QStyleOptionViewItemV2::QStyleOptionViewItemV2()
+ : QStyleOptionViewItem(Version), features(None)
+{
+}
+
+/*!
+ \fn QStyleOptionViewItemV2::QStyleOptionViewItemV2(const QStyleOptionViewItemV2 &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ Constructs a QStyleOptionViewItemV2 copy of the \a other style option
+ which can be either of the QStyleOptionViewItemV2 or
+ QStyleOptionViewItem types.
+
+ If the \a other style option's version is 1, the new style option's \l
+ ViewItemFeature value is set to \l QStyleOptionViewItemV2::None. If its
+ version is 2, its \l ViewItemFeature value is simply copied to the
+ new style option.
+
+ \sa version
+*/
+QStyleOptionViewItemV2::QStyleOptionViewItemV2(const QStyleOptionViewItem &other)
+ : QStyleOptionViewItem(Version)
+{
+ (void)QStyleOptionViewItemV2::operator=(other);
+}
+
+/*!
+ \internal
+*/
+QStyleOptionViewItemV2::QStyleOptionViewItemV2(int version)
+ : QStyleOptionViewItem(version)
+{
+
+}
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be either of the QStyleOptionViewItemV2 or
+ QStyleOptionViewItem types.
+
+ If the \a{other} style option's version is 1, this style option's
+ \l ViewItemFeature value is set to \l QStyleOptionViewItemV2::None.
+ If its version is 2, its \l ViewItemFeature value is simply copied
+ to this style option.
+*/
+QStyleOptionViewItemV2 &QStyleOptionViewItemV2::operator=(const QStyleOptionViewItem &other)
+{
+ QStyleOptionViewItem::operator=(other);
+ const QStyleOptionViewItemV2 *v2 = qstyleoption_cast<const QStyleOptionViewItemV2 *>(&other);
+ features = v2 ? v2->features : ViewItemFeatures(QStyleOptionViewItemV2::None);
+ return *this;
+}
+
+/*!
+ \enum QStyleOptionViewItemV2::ViewItemFeature
+
+ This enum describes the different types of features an item can have.
+
+ \value None Indicates a normal item.
+ \value WrapText Indicates an item with wrapped text.
+ \value Alternate Indicates that the item's background is rendered using alternateBase.
+ \value HasCheckIndicator Indicates that the item has a check state indicator.
+ \value HasDisplay Indicates that the item has a display role.
+ \value HasDecoration Indicates that the item has a decoration role.
+*/
+
+
+
+/*!
+ \class QStyleOptionViewItemV3
+ \brief The QStyleOptionViewItemV3 class is used to describe the
+ parameters necessary for drawing a frame in Qt 4.3 or above.
+ \since 4.3
+
+ QStyleOptionViewItemV3 inherits QStyleOptionViewItem.
+
+ An instance of the QStyleOptionViewItemV3 class has
+ \l{QStyleOption::type} {type} SO_ViewItem and \l{QStyleOption::version}
+ {version} 3. The type is used internally by QStyleOption, its subclasses,
+ and qstyleoption_cast() to determine the type of style option. In general
+ you do not need to worry about this unless you want to create your own
+ QStyleOption subclass and your own styles. The version is used by
+ QStyleOption subclasses to implement extensions without breaking
+ compatibility. If you use qstyleoption_cast(), you normally do not need to
+ check it.
+
+ See QStyleOptionFrameV2's detailed description for a discussion
+ of how to handle "V2" and other versioned classes.
+
+ \sa QStyleOptionViewItem, QStyleOption
+*/
+
+/*!
+ \enum QStyleOptionViewItemV3::StyleOptionVersion
+
+ This enum is used to hold information about the version of the
+ style option, and is defined for each QStyleOption subclass.
+
+ \value Version 3
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ Constructs a QStyleOptionViewItemV3 object.
+*/
+QStyleOptionViewItemV3::QStyleOptionViewItemV3()
+ : QStyleOptionViewItemV2(Version), widget(0)
+{
+}
+
+/*!
+ Constructs a copy of \a other.
+*/
+QStyleOptionViewItemV3::QStyleOptionViewItemV3(const QStyleOptionViewItem &other)
+ : QStyleOptionViewItemV2(Version), widget(0)
+{
+ (void)QStyleOptionViewItemV3::operator=(other);
+}
+
+/*!
+ \fn QStyleOptionViewItemV3::QStyleOptionViewItemV3(const QStyleOptionViewItemV3 &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be an instance of the QStyleOptionViewItemV2,
+ QStyleOptionViewItemV3 or QStyleOptionViewItem types.
+*/
+QStyleOptionViewItemV3 &QStyleOptionViewItemV3::operator = (const QStyleOptionViewItem &other)
+{
+ QStyleOptionViewItemV2::operator=(other);
+ const QStyleOptionViewItemV3 *v3 = qstyleoption_cast<const QStyleOptionViewItemV3*>(&other);
+ locale = v3 ? v3->locale : QLocale();
+ widget = v3 ? v3->widget : 0;
+ return *this;
+}
+
+/*!
+ \internal
+*/
+QStyleOptionViewItemV3::QStyleOptionViewItemV3(int version)
+ : QStyleOptionViewItemV2(version), widget(0)
+{
+}
+
+#ifndef QT_NO_ITEMVIEWS
+
+/*!
+ \class QStyleOptionViewItemV4
+ \brief The QStyleOptionViewItemV4 class is used to describe the
+ parameters necessary for drawing a frame in Qt 4.4 or above.
+ \since 4.4
+
+ QStyleOptionViewItemV4 inherits QStyleOptionViewItemV3.
+
+ An instance of the QStyleOptionViewItemV4 class has
+ \l{QStyleOption::type} {type} SO_ViewItem and
+ \l{QStyleOption::version} {version} 4. The type is used internally
+ by QStyleOption, its subclasses, and qstyleoption_cast() to
+ determine the type of style option. In general you do not need to
+ worry about this unless you want to create your own QStyleOption
+ subclass and your own styles. The version is used by QStyleOption
+ subclasses to implement extensions without breaking
+ compatibility. If you use qstyleoption_cast(), you normally do not
+ need to check it.
+
+ See QStyleOptionViewItemV3's detailed description for a discussion
+ of how to handle "V3" classes.
+
+ \sa QStyleOptionViewItem, QStyleOption
+*/
+
+/*!
+ \variable QStyleOptionViewItemV4::index
+
+ The model index that is to be drawn.
+*/
+
+/*!
+ \variable QStyleOptionViewItemV4::checkState
+
+ If this view item is checkable, i.e.,
+ ViewItemFeature::HasCheckIndicator is true, \c checkState is true
+ if the item is checked; otherwise, it is false.
+
+*/
+
+/*!
+ \variable QStyleOptionViewItemV4::icon
+
+ The icon (if any) to be drawn in the view item.
+*/
+
+
+/*!
+ \variable QStyleOptionViewItemV4::text
+
+ The text (if any) to be drawn in the view item.
+*/
+
+/*!
+ \variable QStyleOptionViewItemV4::backgroundBrush
+
+ The QBrush that should be used to paint the view items
+ background.
+*/
+
+/*!
+ \variable QStyleOptionViewItemV4::viewItemPosition
+
+ Gives the position of this view item relative to other items. See
+ the \l{QStyleOptionViewItemV4::}{ViewItemPosition} enum for the
+ details.
+*/
+
+/*!
+ \enum QStyleOptionViewItemV4::StyleOptionVersion
+
+ This enum is used to hold information about the version of the
+ style option, and is defined for each QStyleOption subclass.
+
+ \value Version 4
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \enum QStyleOptionViewItemV4::ViewItemPosition
+
+ This enum is used to represent the placement of the item on
+ a row. This can be used to draw items differently depending
+ on their placement, for example by putting rounded edges at
+ the beginning and end, and straight edges in between.
+
+ \value Invalid The ViewItemPosition is unknown and should be
+ disregarded.
+ \value Beginning The item appears at the beginning of the row.
+ \value Middle The item appears in the middle of the row.
+ \value End The item appears at the end of the row.
+ \value OnlyOne The item is the only one on the row, and is
+ therefore both at the beginning and the end.
+*/
+
+
+/*!
+ Constructs a QStyleOptionViewItemV4 object.
+*/
+QStyleOptionViewItemV4::QStyleOptionViewItemV4()
+: QStyleOptionViewItemV3(Version), checkState(Qt::Unchecked), viewItemPosition(QStyleOptionViewItemV4::Invalid)
+{
+}
+
+/*!
+ \fn QStyleOptionViewItemV4::QStyleOptionViewItemV4(const QStyleOptionViewItemV4 &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ Constructs a QStyleOptionViewItemV4 copy of the \a other style option
+ which can be either of the QStyleOptionViewItemV3 or
+ QStyleOptionViewItem types.
+
+ \sa version
+*/
+QStyleOptionViewItemV4::QStyleOptionViewItemV4(const QStyleOptionViewItem &other)
+ : QStyleOptionViewItemV3(Version)
+{
+ (void)QStyleOptionViewItemV4::operator=(other);
+}
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be either of the QStyleOptionViewItemV3 or
+ QStyleOptionViewItem types.
+*/
+QStyleOptionViewItemV4 &QStyleOptionViewItemV4::operator = (const QStyleOptionViewItem &other)
+{
+ QStyleOptionViewItemV3::operator=(other);
+ if (const QStyleOptionViewItemV4 *v4 = qstyleoption_cast<const QStyleOptionViewItemV4*>(&other)) {
+ index = v4->index;
+ checkState = v4->checkState;
+ text = v4->text;
+ viewItemPosition = v4->viewItemPosition;
+ backgroundBrush = v4->backgroundBrush;
+ icon = v4->icon;
+ } else {
+ viewItemPosition = QStyleOptionViewItemV4::Invalid;
+ checkState = Qt::Unchecked;
+ }
+ return *this;
+}
+
+/*!
+ \internal
+*/
+QStyleOptionViewItemV4::QStyleOptionViewItemV4(int version)
+ : QStyleOptionViewItemV3(version)
+{
+}
+#endif // QT_NO_ITEMVIEWS
+
+/*!
+ \class QStyleOptionGroupBox
+ \brief The QStyleOptionGroupBox class describes the parameters for
+ drawing a group box.
+
+ \since 4.1
+
+ QStyleOptionButton contains all the information that QStyle
+ functions need the various graphical elements of a group box.
+
+ It holds the lineWidth and the midLineWidth for drawing the panel,
+ the group box's \l {text}{title} and the title's \l
+ {textAlignment}{alignment} and \l {textColor}{color}.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionComplex, QGroupBox
+*/
+
+/*!
+ \enum QStyleOptionGroupBox::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_GroupBox} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionGroupBox::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionGroupBox::lineWidth
+ \brief the line width for drawing the panel
+
+ The value of this variable is, currently, always 1.
+
+ \sa QFrame::lineWidth
+*/
+
+/*!
+ \variable QStyleOptionGroupBox::midLineWidth
+ \brief the mid-line width for drawing the panel
+
+ The mid-line width is usually used when drawing sunken or raised
+ group box frames. The value of this variable is, currently, always 0.
+
+ \sa QFrame::midLineWidth
+*/
+
+/*!
+ \variable QStyleOptionGroupBox::text
+ \brief the text of the group box
+
+ The default value is an empty string.
+
+ \sa QGroupBox::title
+*/
+
+/*!
+ \variable QStyleOptionGroupBox::textAlignment
+ \brief the alignment of the group box title
+
+ The default value is Qt::AlignLeft.
+
+ \sa QGroupBox::alignment
+*/
+
+/*!
+ \variable QStyleOptionGroupBox::features
+ \brief the features of the group box frame
+
+ The frame is flat by default.
+
+ \sa QStyleOptionFrameV2::FrameFeature
+*/
+
+/*!
+ \variable QStyleOptionGroupBox::textColor
+ \brief the color of the group box title
+
+ The default value is an invalid color with the RGB value (0, 0,
+ 0). An invalid color is a color that is not properly set up for
+ the underlying window system.
+*/
+
+/*!
+ Constructs a QStyleOptionGroupBox, initializing the members
+ variables to their default values.
+*/
+QStyleOptionGroupBox::QStyleOptionGroupBox()
+ : QStyleOptionComplex(Version, Type), features(QStyleOptionFrameV2::None),
+ textAlignment(Qt::AlignLeft), lineWidth(0), midLineWidth(0)
+{
+}
+
+/*!
+ \fn QStyleOptionGroupBox::QStyleOptionGroupBox(const QStyleOptionGroupBox &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionGroupBox::QStyleOptionGroupBox(int version)
+ : QStyleOptionComplex(version, Type), features(QStyleOptionFrameV2::None),
+ textAlignment(Qt::AlignLeft), lineWidth(0), midLineWidth(0)
+{
+}
+
+/*!
+ \class QStyleOptionHeader
+ \brief The QStyleOptionHeader class is used to describe the
+ parameters for drawing a header.
+
+ QStyleOptionHeader contains all the information that QStyle
+ functions need to draw the item views' header pane, header sort
+ arrow, and header label.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionHeader, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionHeader::QStyleOptionHeader()
+ : QStyleOption(QStyleOptionHeader::Version, SO_Header),
+ section(0), textAlignment(Qt::AlignLeft), iconAlignment(Qt::AlignLeft),
+ position(QStyleOptionHeader::Beginning),
+ selectedPosition(QStyleOptionHeader::NotAdjacent), sortIndicator(None),
+ orientation(Qt::Horizontal)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionHeader::QStyleOptionHeader(int version)
+ : QStyleOption(version, SO_Header),
+ section(0), textAlignment(Qt::AlignLeft), iconAlignment(Qt::AlignLeft),
+ position(QStyleOptionHeader::Beginning),
+ selectedPosition(QStyleOptionHeader::NotAdjacent), sortIndicator(None),
+ orientation(Qt::Horizontal)
+{
+}
+
+/*!
+ \variable QStyleOptionHeader::orientation
+ \brief the header's orientation (horizontal or vertical)
+
+ The default orientation is Qt::Horizontal
+*/
+
+/*!
+ \fn QStyleOptionHeader::QStyleOptionHeader(const QStyleOptionHeader &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionHeader::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Header} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionHeader::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionHeader::section
+ \brief which section of the header is being painted
+
+ The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionHeader::text
+ \brief the text of the header
+
+ The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionHeader::textAlignment
+ \brief the alignment flags for the text of the header
+
+ The default value is Qt::AlignLeft.
+*/
+
+/*!
+ \variable QStyleOptionHeader::icon
+ \brief the icon of the header
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+*/
+
+/*!
+ \variable QStyleOptionHeader::iconAlignment
+ \brief the alignment flags for the icon of the header
+
+ The default value is Qt::AlignLeft.
+*/
+
+/*!
+ \variable QStyleOptionHeader::position
+ \brief the section's position in relation to the other sections
+
+ The default value is QStyleOptionHeader::Beginning.
+*/
+
+/*!
+ \variable QStyleOptionHeader::selectedPosition
+ \brief the section's position in relation to the selected section
+
+ The default value is QStyleOptionHeader::NotAdjacent
+*/
+
+/*!
+ \variable QStyleOptionHeader::sortIndicator
+ \brief the direction the sort indicator should be drawn
+
+ The default value is QStyleOptionHeader::None.
+*/
+
+/*!
+ \enum QStyleOptionHeader::SectionPosition
+
+ This enum lets you know where the section's position is in relation to the other sections.
+
+ \value Beginning At the beginining of the header
+ \value Middle In the middle of the header
+ \value End At the end of the header
+ \value OnlyOneSection Only one header section
+
+ \sa position
+*/
+
+/*!
+ \enum QStyleOptionHeader::SelectedPosition
+
+ This enum lets you know where the section's position is in relation to the selected section.
+
+ \value NotAdjacent Not adjacent to the selected section
+ \value NextIsSelected The next section is selected
+ \value PreviousIsSelected The previous section is selected
+ \value NextAndPreviousAreSelected Both the next and previous section are selected
+
+ \sa selectedPosition
+*/
+
+/*!
+ \enum QStyleOptionHeader::SortIndicator
+
+ Indicates which direction the sort indicator should be drawn
+
+ \value None No sort indicator is needed
+ \value SortUp Draw an up indicator
+ \value SortDown Draw a down indicator
+
+ \sa sortIndicator
+*/
+
+/*!
+ \class QStyleOptionButton
+ \brief The QStyleOptionButton class is used to describe the
+ parameters for drawing buttons.
+
+ QStyleOptionButton contains all the information that QStyle
+ functions need to draw graphical elements like QPushButton,
+ QCheckBox, and QRadioButton.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionToolButton
+*/
+
+/*!
+ \enum QStyleOptionButton::ButtonFeature
+
+ This enum describes the different types of features a push button can have.
+
+ \value None Indicates a normal push button.
+ \value Flat Indicates a flat push button.
+ \value HasMenu Indicates that the button has a drop down menu.
+ \value DefaultButton Indicates that the button is a default button.
+ \value AutoDefaultButton Indicates that the button is an auto default button.
+ \value CommandLinkButton Indicates that the button is a Windows Vista type command link.
+
+ \sa features
+*/
+
+/*!
+ Constructs a QStyleOptionButton, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionButton::QStyleOptionButton()
+ : QStyleOption(QStyleOptionButton::Version, SO_Button), features(None)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionButton::QStyleOptionButton(int version)
+ : QStyleOption(version, SO_Button), features(None)
+{
+}
+
+/*!
+ \fn QStyleOptionButton::QStyleOptionButton(const QStyleOptionButton &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionButton::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Button} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionButton::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionButton::features
+ \brief a bitwise OR of the features that describe this button
+
+ \sa ButtonFeature
+*/
+
+/*!
+ \variable QStyleOptionButton::text
+ \brief the text of the button
+
+ The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionButton::icon
+ \brief the icon of the button
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+
+ \sa iconSize
+*/
+
+/*!
+ \variable QStyleOptionButton::iconSize
+ \brief the size of the icon for the button
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+*/
+
+
+#ifndef QT_NO_TOOLBAR
+/*!
+ \class QStyleOptionToolBar
+ \brief The QStyleOptionToolBar class is used to describe the
+ parameters for drawing a toolbar.
+
+ \since 4.1
+
+ QStyleOptionToolBar contains all the information that QStyle
+ functions need to draw QToolBar.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ The QStyleOptionToolBar class holds the lineWidth and the
+ midLineWidth for drawing the widget. It also stores information
+ about which \l {toolBarArea}{area} the toolbar should be located
+ in, whether it is movable or not, which position the toolbar line
+ should have (positionOfLine), and the toolbar's position within
+ the line (positionWithinLine).
+
+ In addition, the class provides a couple of enums: The
+ ToolBarFeature enum is used to describe whether a toolbar is
+ movable or not, and the ToolBarPosition enum is used to describe
+ the position of a toolbar line, as well as the toolbar's position
+ within the line.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionToolBar, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionToolBar::QStyleOptionToolBar()
+ : QStyleOption(Version, SO_ToolBar), positionOfLine(OnlyOne), positionWithinLine(OnlyOne),
+ toolBarArea(Qt::TopToolBarArea), features(None), lineWidth(0), midLineWidth(0)
+{
+}
+
+/*!
+ \fn QStyleOptionToolBar::QStyleOptionToolBar(const QStyleOptionToolBar &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionToolBar::QStyleOptionToolBar(int version)
+: QStyleOption(version, SO_ToolBar), positionOfLine(OnlyOne), positionWithinLine(OnlyOne),
+ toolBarArea(Qt::TopToolBarArea), features(None), lineWidth(0), midLineWidth(0)
+{
+
+}
+
+/*!
+ \enum QStyleOptionToolBar::ToolBarPosition
+
+ \image qstyleoptiontoolbar-position.png
+
+ This enum is used to describe the position of a toolbar line, as
+ well as the toolbar's position within the line.
+
+ The order of the positions within a line starts at the top of a
+ vertical line, and from the left within a horizontal line. The
+ order of the positions for the lines is always from the the
+ parent widget's boundary edges.
+
+ \value Beginning The toolbar is located at the beginning of the line,
+ or the toolbar line is the first of several lines. There can
+ only be one toolbar (and only one line) with this position.
+ \value Middle The toolbar is located in the middle of the line,
+ or the toolbar line is in the middle of several lines. There can
+ several toolbars (and lines) with this position.
+ \value End The toolbar is located at the end of the line,
+ or the toolbar line is the last of several lines. There can
+ only be one toolbar (and only one line) with this position.
+ \value OnlyOne There is only one toolbar or line. This is the default value
+ of the positionOfLine and positionWithinLine variables.
+
+ \sa positionWithinLine, positionOfLine
+*/
+
+/*!
+ \enum QStyleOptionToolBar::ToolBarFeature
+
+ This enum is used to describe whether a toolbar is movable or not.
+
+ \value None The toolbar cannot be moved. The default value.
+ \value Movable The toolbar is movable, and a handle will appear when
+ holding the cursor over the toolbar's boundary.
+
+ \sa features, QToolBar::isMovable()
+*/
+
+/*!
+ \variable QStyleOptionToolBar::positionOfLine
+
+ This variable holds the position of the toolbar line.
+
+ The default value is QStyleOptionToolBar::OnlyOne.
+*/
+
+/*!
+ \variable QStyleOptionToolBar::positionWithinLine
+
+ This variable holds the position of the toolbar within a line.
+
+ The default value is QStyleOptionToolBar::OnlyOne.
+*/
+
+/*!
+ \variable QStyleOptionToolBar::toolBarArea
+
+ This variable holds the location for drawing the toolbar.
+
+ The default value is Qt::TopToolBarArea.
+
+ \sa Qt::ToolBarArea
+*/
+
+/*!
+ \variable QStyleOptionToolBar::features
+
+ This variable holds whether the toolbar is movable or not.
+
+ The default value is \l None.
+*/
+
+/*!
+ \variable QStyleOptionToolBar::lineWidth
+
+ This variable holds the line width for drawing the toolbar.
+
+ The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionToolBar::midLineWidth
+
+ This variable holds the mid-line width for drawing the toolbar.
+
+ The default value is 0.
+*/
+
+/*!
+ \enum QStyleOptionToolBar::StyleOptionType
+
+ This enum is used to hold information about the type of the style
+ option, and is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ToolBar} for
+ this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionToolBar::StyleOptionVersion
+
+ This enum is used to hold information about the version of the
+ style option, and is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+#endif
+
+#ifndef QT_NO_TABBAR
+/*!
+ \class QStyleOptionTab
+ \brief The QStyleOptionTab class is used to describe the
+ parameters for drawing a tab bar.
+
+ The QStyleOptionTab class is used for drawing several built-in Qt
+ widgets including \l QTabBar and the panel for \l QTabWidget. Note
+ that to describe the parameters necessary for drawing a frame in
+ Qt 4.1 or above, you must use the QStyleOptionFrameV2 subclass.
+
+ An instance of the QStyleOptiontabV2 class has
+ \l{QStyleOption::type} {type} \l SO_Tab and
+ \l{QStyleOption::version} {version} 1. The type is used internally
+ by QStyleOption, its subclasses, and qstyleoption_cast() to
+ determine the type of style option. In general you do not need to
+ worry about this unless you want to create your own QStyleOption
+ subclass and your own styles. The version is used by QStyleOption
+ subclasses to implement extensions without breaking
+ compatibility. If you use qstyleoption_cast(), you normally do not
+ need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionTab and QStyleOptionTabV2.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionTabV2, QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionTab object, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionTab::QStyleOptionTab()
+ : QStyleOption(QStyleOptionTab::Version, SO_Tab),
+ shape(QTabBar::RoundedNorth),
+ row(0),
+ position(Beginning),
+ selectedPosition(NotAdjacent), cornerWidgets(QStyleOptionTab::NoCornerWidgets)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionTab::QStyleOptionTab(int version)
+ : QStyleOption(version, SO_Tab),
+ shape(QTabBar::RoundedNorth),
+ row(0),
+ position(Beginning),
+ selectedPosition(NotAdjacent), cornerWidgets(QStyleOptionTab::NoCornerWidgets)
+{
+}
+
+/*!
+ \fn QStyleOptionTab::QStyleOptionTab(const QStyleOptionTab &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionTab::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Tab} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionTab::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \enum QStyleOptionTab::TabPosition
+
+ This enum describes the position of the tab.
+
+ \value Beginning The tab is the first tab in the tab bar.
+ \value Middle The tab is neither the first nor the last tab in the tab bar.
+ \value End The tab is the last tab in the tab bar.
+ \value OnlyOneTab The tab is both the first and the last tab in the tab bar.
+
+ \sa position
+*/
+
+/*!
+ \enum QStyleOptionTab::CornerWidget
+
+ These flags indicate the corner widgets in a tab.
+
+ \value NoCornerWidgets There are no corner widgets
+ \value LeftCornerWidget Left corner widget
+ \value RightCornerWidget Right corner widget
+
+ \sa cornerWidgets
+*/
+
+/*! \enum QStyleOptionTab::SelectedPosition
+
+ This enum describes the position of the selected tab. Some styles
+ need to draw a tab differently depending on whether or not it is
+ adjacent to the selected tab.
+
+ \value NotAdjacent The tab is not adjacent to a selected tab (or is the selected tab).
+ \value NextIsSelected The next tab (typically the tab on the right) is selected.
+ \value PreviousIsSelected The previous tab (typically the tab on the left) is selected.
+
+ \sa selectedPosition
+*/
+
+/*!
+ \variable QStyleOptionTab::selectedPosition
+ \brief the position of the selected tab in relation to this tab
+
+ The default value is NotAdjacent, i.e. the tab is not adjacent to
+ a selected tab nor is it the selected tab.
+*/
+
+/*!
+ \variable QStyleOptionTab::cornerWidgets
+ \brief an OR combination of CornerWidget values indicating the
+ corner widgets of the tab bar
+
+ The default value is NoCornerWidgets.
+
+ \sa CornerWidget
+*/
+
+
+/*!
+ \variable QStyleOptionTab::shape
+ \brief the tab shape used to draw the tab; by default
+ QTabBar::RoundedNorth
+
+ \sa QTabBar::Shape
+*/
+
+/*!
+ \variable QStyleOptionTab::text
+ \brief the text of the tab
+
+ The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionTab::icon
+ \brief the icon for the tab
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+*/
+
+/*!
+ \variable QStyleOptionTab::row
+ \brief which row the tab is currently in
+
+ The default value is 0, indicating the front row. Currently this
+ property can only be 0.
+*/
+
+/*!
+ \variable QStyleOptionTab::position
+ \brief the position of the tab in the tab bar
+
+ The default value is \l Beginning, i.e. the tab is the first tab
+ in the tab bar.
+*/
+
+/*!
+ \class QStyleOptionTabV2
+ \brief The QStyleOptionTabV2 class is used to describe the
+ parameters necessary for drawing a tabs in Qt 4.1 or above.
+
+ \since 4.1
+
+ An instance of the QStyleOptionTabV2 class has
+ \l{QStyleOption::type} {type} \l SO_Tab and
+ \l{QStyleOption::version} {version} 2. The type is used internally
+ by QStyleOption, its subclasses, and qstyleoption_cast() to
+ determine the type of style option. In general you do not need to
+ worry about this unless you want to create your own QStyleOption
+ subclass and your own styles. The version is used by QStyleOption
+ subclasses to implement extensions without breaking
+ compatibility. If you use qstyleoption_cast(), you normally do not
+ need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionTab and QStyleOptionTabV2. One way to achieve this is
+ to use the QStyleOptionTabV2 copy constructor. For example:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 3
+
+ In the example above: If \c tabOption's version is 1, the extra
+ member (\l iconSize) will be set to an invalid size for \c tabV2.
+ If \c tabOption's version is 2, the constructor will simply copy
+ the \c tab's iconSize.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionTab, QStyleOption
+*/
+
+/*!
+ \enum QStyleOptionTabV2::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 2
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionTabV2::iconSize
+ \brief the size for the icons
+
+ The default value is QSize(-1, -1), i.e. an invalid size; use
+ QStyle::pixelMetric() to find the default icon size for tab bars.
+
+ \sa QTabBar::iconSize()
+*/
+
+/*!
+ Constructs a QStyleOptionTabV2.
+*/
+QStyleOptionTabV2::QStyleOptionTabV2()
+ : QStyleOptionTab(Version)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionTabV2::QStyleOptionTabV2(int version)
+ : QStyleOptionTab(version)
+{
+}
+
+/*!
+ \fn QStyleOptionTabV2::QStyleOptionTabV2(const QStyleOptionTabV2 &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ Constructs a QStyleOptionTabV2 copy of the \a other style option
+ which can be either of the QStyleOptionTabV2 or QStyleOptionTab
+ types.
+
+ If the other style option's version is 1, the new style option's
+ \c iconSize is set to an invalid value. If its version is 2, its
+ \c iconSize value is simply copied to the new style option.
+*/
+QStyleOptionTabV2::QStyleOptionTabV2(const QStyleOptionTab &other)
+ : QStyleOptionTab(Version)
+{
+ if (const QStyleOptionTabV2 *tab = qstyleoption_cast<const QStyleOptionTabV2 *>(&other)) {
+ *this = *tab;
+ } else {
+ *((QStyleOptionTab *)this) = other;
+ version = Version;
+ }
+}
+
+/*!
+ Assigns the \a other style option to this QStyleOptionTabV2. The
+ \a other style option can be either of the QStyleOptionTabV2 or
+ QStyleOptionTab types.
+
+ If the other style option's version is 1, this style option's \c
+ iconSize is set to an invalid size. If its version is 2, its \c
+ iconSize value is simply copied to this style option.
+*/
+QStyleOptionTabV2 &QStyleOptionTabV2::operator=(const QStyleOptionTab &other)
+{
+ QStyleOptionTab::operator=(other);
+
+ if (const QStyleOptionTabV2 *tab = qstyleoption_cast<const QStyleOptionTabV2 *>(&other))
+ iconSize = tab->iconSize;
+ else
+ iconSize = QSize();
+ return *this;
+}
+
+/*!
+ \class QStyleOptionTabV3
+ \brief The QStyleOptionTabV3 class is used to describe the
+ parameters necessary for drawing a tabs in Qt 4.5 or above.
+
+ \since 4.5
+
+ An instance of the QStyleOptionTabV3 class has
+ \l{QStyleOption::type} {type} \l SO_Tab and
+ \l{QStyleOption::version} {version} 3. The type is used internally
+ by QStyleOption, its subclasses, and qstyleoption_cast() to
+ determine the type of style option. In general you do not need to
+ worry about this unless you want to create your own QStyleOption
+ subclass and your own styles. The version is used by QStyleOption
+ subclasses to implement extensions without breaking
+ compatibility. If you use qstyleoption_cast(), you normally do not
+ need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionTab, QStyleOptionTabV2 and QStyleOptionTabV3.
+ One way to achieve this is to use the QStyleOptionTabV3 copy
+ constructor. For example:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 3
+
+ In the example above: If \c tabOption's version is 1, the extra
+ member (\l{QStyleOptionTabV2::iconSize}{iconSize}) will be set to
+ an invalid size for \c tabV2. If \c tabOption's version is 2, the
+ constructor will simply copy the \c tab's iconSize.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionTab, QStyleOption
+*/
+
+/*!
+ \enum QStyleOptionTabV3::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 3
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionTabV3::documentMode
+ \brief whether the tabbar is in document mode.
+
+ The default value is false;
+*/
+
+/*!
+ \variable QStyleOptionTabV3::leftButtonSize
+ \brief the size for the left widget on the tab.
+
+ The default value is QSize(-1, -1), i.e. an invalid size;
+*/
+
+/*!
+ \variable QStyleOptionTabV3::rightButtonSize
+ \brief the size for the right widget on the tab.
+
+ The default value is QSize(-1, -1), i.e. an invalid size;
+*/
+
+/*!
+ Constructs a QStyleOptionTabV3.
+*/
+
+QStyleOptionTabV3::QStyleOptionTabV3()
+ : QStyleOptionTabV2(Version)
+ , documentMode(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionTabV3::QStyleOptionTabV3(int version)
+ : QStyleOptionTabV2(version)
+{
+}
+
+/*!
+ \fn QStyleOptionTabV3::QStyleOptionTabV3(const QStyleOptionTabV3 &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \fn QStyleOptionTabV3::QStyleOptionTabV3(const QStyleOptionTabV2 &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ Constructs a QStyleOptionTabV3 copy of the \a other style option
+ which can be either of the QStyleOptionTabV3, QStyleOptionTabV2
+ or QStyleOptionTab types.
+
+ If the other style option's version is 1 or 2, the new style option's
+ \c leftButtonSize and \c rightButtonSize is set to an invalid value. If
+ its version is 3, its \c leftButtonSize and \c rightButtonSize values
+ are simply copied to the new style option.
+*/
+QStyleOptionTabV3::QStyleOptionTabV3(const QStyleOptionTab &other)
+ : QStyleOptionTabV2(Version)
+{
+ if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(&other)) {
+ *this = *tab;
+ } else {
+ *((QStyleOptionTabV2 *)this) = other;
+ version = Version;
+ }
+}
+
+/*!
+ Assigns the \a other style option to this QStyleOptionTabV3. The
+ \a other style option can be either of the QStyleOptionTabV3,
+ QStyleOptionTabV2 or QStyleOptionTab types.
+
+ If the other style option's version is 1 or 2, the new style option's
+ \c leftButtonSize and \c rightButtonSize is set to an invalid value. If
+ its version is 3, its \c leftButtonSize and \c rightButtonSize values
+ are simply copied to the new style option.
+*/
+QStyleOptionTabV3 &QStyleOptionTabV3::operator=(const QStyleOptionTab &other)
+{
+ QStyleOptionTabV2::operator=(other);
+
+ if (const QStyleOptionTabV3 *tab = qstyleoption_cast<const QStyleOptionTabV3 *>(&other)) {
+ leftButtonSize = tab->leftButtonSize;
+ rightButtonSize = tab->rightButtonSize;
+ } else {
+ leftButtonSize = QSize();
+ rightButtonSize = QSize();
+ documentMode = false;
+ }
+ return *this;
+}
+
+#endif // QT_NO_TABBAR
+
+/*!
+ \class QStyleOptionProgressBar
+ \brief The QStyleOptionProgressBar class is used to describe the
+ parameters necessary for drawing a progress bar.
+
+ Since Qt 4.1, Qt uses the QStyleOptionProgressBarV2 subclass for
+ drawing QProgressBar.
+
+ An instance of the QStyleOptionProgressBar class has type
+ SO_ProgressBar and version 1.
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles. The
+ version is used by QStyleOption subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast(),
+ you normally do not need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionProgressBar and QStyleOptionProgressBarV2.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionProgressBarV2, QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionProgressBar, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionProgressBar::QStyleOptionProgressBar()
+ : QStyleOption(QStyleOptionProgressBar::Version, SO_ProgressBar),
+ minimum(0), maximum(0), progress(0), textAlignment(Qt::AlignLeft), textVisible(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionProgressBar::QStyleOptionProgressBar(int version)
+ : QStyleOption(version, SO_ProgressBar),
+ minimum(0), maximum(0), progress(0), textAlignment(Qt::AlignLeft), textVisible(false)
+{
+}
+
+/*!
+ \fn QStyleOptionProgressBar::QStyleOptionProgressBar(const QStyleOptionProgressBar &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionProgressBar::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ProgressBar} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionProgressBar::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionProgressBar::minimum
+ \brief the minimum value for the progress bar
+
+ This is the minimum value in the progress bar. The default value
+ is 0.
+
+ \sa QProgressBar::minimum
+*/
+
+/*!
+ \variable QStyleOptionProgressBar::maximum
+ \brief the maximum value for the progress bar
+
+ This is the maximum value in the progress bar. The default value
+ is 0.
+
+ \sa QProgressBar::maximum
+*/
+
+/*!
+ \variable QStyleOptionProgressBar::text
+ \brief the text for the progress bar
+
+ The progress bar text is usually just the progress expressed as a
+ string. An empty string indicates that the progress bar has not
+ started yet. The default value is an empty string.
+
+ \sa QProgressBar::text
+*/
+
+/*!
+ \variable QStyleOptionProgressBar::textVisible
+ \brief a flag indicating whether or not text is visible
+
+ If this flag is true then the text is visible. Otherwise, the text
+ is not visible. The default value is false.
+
+ \sa QProgressBar::textVisible
+*/
+
+
+/*!
+ \variable QStyleOptionProgressBar::textAlignment
+ \brief the text alignment for the text in the QProgressBar
+
+ This can be used as a guide on where the text should be in the
+ progress bar. The default value is Qt::AlignLeft.
+*/
+
+/*!
+ \variable QStyleOptionProgressBar::progress
+ \brief the current progress for the progress bar
+
+ The current progress. A value of QStyleOptionProgressBar::minimum
+ - 1 indicates that the progress hasn't started yet. The default
+ value is 0.
+
+ \sa QProgressBar::value
+*/
+
+/*!
+ \class QStyleOptionProgressBarV2
+ \brief The QStyleOptionProgressBarV2 class is used to describe the
+ parameters necessary for drawing a progress bar in Qt 4.1 or above.
+
+ \since 4.1
+
+ An instance of this class has \l{QStyleOption::type} {type}
+ SO_ProgressBar and \l{QStyleOption::version} {version} 2.
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles. The
+ version is used by QStyleOption subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast(),
+ you normally do not need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionProgressBar and QStyleOptionProgressBarV2. One way
+ to achieve this is to use the QStyleOptionProgressBarV2 copy
+ constructor. For example:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 2
+
+ In the example above: If the \c progressBarOption's version is 1,
+ the extra members (\l orientation, \l invertedAppearance, and \l
+ bottomToTop) are set to default values for \c progressBarV2. If
+ the \c progressBarOption's version is 2, the constructor will
+ simply copy the extra members to progressBarV2.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionProgressBar, QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionProgressBarV2, initializing he members
+ variables to their default values.
+*/
+
+QStyleOptionProgressBarV2::QStyleOptionProgressBarV2()
+ : QStyleOptionProgressBar(2),
+ orientation(Qt::Horizontal), invertedAppearance(false), bottomToTop(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionProgressBarV2::QStyleOptionProgressBarV2(int version)
+ : QStyleOptionProgressBar(version),
+ orientation(Qt::Horizontal), invertedAppearance(false), bottomToTop(false)
+{
+}
+
+/*!
+ Constructs a copy of the \a other style option which can be either
+ of the QStyleOptionProgressBar and QStyleOptionProgressBarV2
+ types.
+
+ If the \a{other} style option's version is 1, the extra members (\l
+ orientation, \l invertedAppearance, and \l bottomToTop) are set
+ to default values for the new style option. If \a{other}'s version
+ is 2, the extra members are simply copied.
+
+ \sa version
+*/
+QStyleOptionProgressBarV2::QStyleOptionProgressBarV2(const QStyleOptionProgressBar &other)
+ : QStyleOptionProgressBar(2), orientation(Qt::Horizontal), invertedAppearance(false), bottomToTop(false)
+{
+ const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(&other);
+ if (pb2)
+ *this = *pb2;
+ else
+ *((QStyleOptionProgressBar *)this) = other;
+}
+
+/*!
+ Constructs a copy of the \a other style option.
+*/
+QStyleOptionProgressBarV2::QStyleOptionProgressBarV2(const QStyleOptionProgressBarV2 &other)
+ : QStyleOptionProgressBar(2), orientation(Qt::Horizontal), invertedAppearance(false), bottomToTop(false)
+{
+ *this = other;
+}
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be either of the QStyleOptionProgressBarV2
+ or QStyleOptionProgressBar types.
+
+ If the \a{other} style option's version is 1, the extra members
+ (\l orientation, \l invertedAppearance, and \l bottomToTop) are
+ set to default values for this style option. If \a{other}'s
+ version is 2, the extra members are simply copied to this style
+ option.
+*/
+QStyleOptionProgressBarV2 &QStyleOptionProgressBarV2::operator=(const QStyleOptionProgressBar &other)
+{
+ QStyleOptionProgressBar::operator=(other);
+
+ const QStyleOptionProgressBarV2 *pb2 = qstyleoption_cast<const QStyleOptionProgressBarV2 *>(&other);
+ orientation = pb2 ? pb2->orientation : Qt::Horizontal;
+ invertedAppearance = pb2 ? pb2->invertedAppearance : false;
+ bottomToTop = pb2 ? pb2->bottomToTop : false;
+ return *this;
+}
+
+/*!
+ \variable QStyleOptionProgressBarV2::orientation
+ \brief the progress bar's orientation (horizontal or vertical);
+ the default orentation is Qt::Horizontal
+
+ \sa QProgressBar::orientation
+*/
+
+/*!
+ \variable QStyleOptionProgressBarV2::invertedAppearance
+ \brief whether the progress bar's appearance is inverted
+
+ The default value is false.
+
+ \sa QProgressBar::invertedAppearance
+*/
+
+/*!
+ \variable QStyleOptionProgressBarV2::bottomToTop
+ \brief whether the text reads from bottom to top when the progress
+ bar is vertical
+
+ The default value is false.
+
+ \sa QProgressBar::textDirection
+*/
+
+/*!
+ \enum QStyleOptionProgressBarV2::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ProgressBar} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionProgressBarV2::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 2
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+
+/*!
+ \class QStyleOptionMenuItem
+ \brief The QStyleOptionMenuItem class is used to describe the
+ parameter necessary for drawing a menu item.
+
+ QStyleOptionMenuItem contains all the information that QStyle
+ functions need to draw the menu items from \l QMenu. It is also
+ used for drawing other menu-related widgets.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionMenuItem, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionMenuItem::QStyleOptionMenuItem()
+ : QStyleOption(QStyleOptionMenuItem::Version, SO_MenuItem), menuItemType(Normal),
+ checkType(NotCheckable), checked(false), menuHasCheckableItems(true), maxIconWidth(0), tabWidth(0)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionMenuItem::QStyleOptionMenuItem(int version)
+ : QStyleOption(version, SO_MenuItem), menuItemType(Normal),
+ checkType(NotCheckable), checked(false), menuHasCheckableItems(true), maxIconWidth(0), tabWidth(0)
+{
+}
+
+/*!
+ \fn QStyleOptionMenuItem::QStyleOptionMenuItem(const QStyleOptionMenuItem &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionMenuItem::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_MenuItem} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionMenuItem::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \enum QStyleOptionMenuItem::MenuItemType
+
+ This enum indicates the type of menu item that the structure describes.
+
+ \value Normal A normal menu item.
+ \value DefaultItem A menu item that is the default action as specified with \l QMenu::defaultAction().
+ \value Separator A menu separator.
+ \value SubMenu Indicates the menu item points to a sub-menu.
+ \value Scroller A popup menu scroller (currently only used on Mac OS X).
+ \value TearOff A tear-off handle for the menu.
+ \value Margin The margin of the menu.
+ \value EmptyArea The empty area of the menu.
+
+ \sa menuItemType
+*/
+
+/*!
+ \enum QStyleOptionMenuItem::CheckType
+
+ This enum is used to indicate whether or not a check mark should be
+ drawn for the item, or even if it should be drawn at all.
+
+ \value NotCheckable The item is not checkable.
+ \value Exclusive The item is an exclusive check item (like a radio button).
+ \value NonExclusive The item is a non-exclusive check item (like a check box).
+
+ \sa checkType, QAction::checkable, QAction::checked, QActionGroup::exclusive
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::menuItemType
+ \brief the type of menu item
+
+ The default value is \l Normal.
+
+ \sa MenuItemType
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::checkType
+ \brief the type of checkmark of the menu item
+
+ The default value is \l NotCheckable.
+
+ \sa CheckType
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::checked
+ \brief whether the menu item is checked or not
+
+ The default value is false.
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::menuHasCheckableItems
+ \brief whether the menu as a whole has checkable items or not
+
+ The default value is true.
+
+ If this option is set to false, then the menu has no checkable
+ items. This makes it possible for GUI styles to save some
+ horizontal space that would normally be used for the check column.
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::menuRect
+ \brief the rectangle for the entire menu
+
+ The default value is a null rectangle, i.e. a rectangle with both
+ the width and the height set to 0.
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::text
+ \brief the text for the menu item
+
+ Note that the text format is something like this "Menu
+ text\bold{\\t}Shortcut".
+
+ If the menu item doesn't have a shortcut, it will just contain the
+ menu item's text. The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::icon
+ \brief the icon for the menu item
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::maxIconWidth
+ \brief the maximum icon width for the icon in the menu item
+
+ This can be used for drawing the icon into the correct place or
+ properly aligning items. The variable must be set regardless of
+ whether or not the menu item has an icon. The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionMenuItem::tabWidth
+ \brief the tab width for the menu item
+
+ The tab width is the distance between the text of the menu item
+ and the shortcut. The default value is 0.
+*/
+
+
+/*!
+ \variable QStyleOptionMenuItem::font
+ \brief the font used for the menu item text
+
+ This is the font that should be used for drawing the menu text
+ minus the shortcut. The shortcut is usually drawn using the
+ painter's font. By default, the application's default font is
+ used.
+*/
+
+/*!
+ \class QStyleOptionComplex
+ \brief The QStyleOptionComplex class is used to hold parameters that are
+ common to all complex controls.
+
+ This class is not used on its own. Instead it is used to derive
+ other complex control options, for example QStyleOptionSlider and
+ QStyleOptionSpinBox.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator).
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionComplex of the specified \a type and \a
+ version, initializing the member variables to their default
+ values. This constructor is usually called by subclasses.
+*/
+
+QStyleOptionComplex::QStyleOptionComplex(int version, int type)
+ : QStyleOption(version, type), subControls(QStyle::SC_All), activeSubControls(QStyle::SC_None)
+{
+}
+
+/*!
+ \fn QStyleOptionComplex::QStyleOptionComplex(const QStyleOptionComplex &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionComplex::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Complex} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionComplex::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionComplex::subControls
+ \brief a bitwise OR of the various sub-controls that need to be
+ drawn for the complex control
+
+ The default value is QStyle::SC_All.
+
+ \sa QStyle::SubControl
+*/
+
+/*!
+ \variable QStyleOptionComplex::activeSubControls
+ \brief a bitwise OR of the various sub-controls that are active
+ (pressed) for the complex control
+
+ The default value is QStyle::SC_None.
+
+ \sa QStyle::SubControl
+*/
+
+#ifndef QT_NO_SLIDER
+/*!
+ \class QStyleOptionSlider
+ \brief The QStyleOptionSlider class is used to describe the
+ parameters needed for drawing a slider.
+
+ QStyleOptionSlider contains all the information that QStyle
+ functions need to draw QSlider and QScrollBar.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionComplex, QSlider, QScrollBar
+*/
+
+/*!
+ Constructs a QStyleOptionSlider, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionSlider::QStyleOptionSlider()
+ : QStyleOptionComplex(Version, SO_Slider), orientation(Qt::Horizontal), minimum(0), maximum(0),
+ tickPosition(QSlider::NoTicks), tickInterval(0), upsideDown(false),
+ sliderPosition(0), sliderValue(0), singleStep(0), pageStep(0), notchTarget(0.0),
+ dialWrapping(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionSlider::QStyleOptionSlider(int version)
+ : QStyleOptionComplex(version, SO_Slider), orientation(Qt::Horizontal), minimum(0), maximum(0),
+ tickPosition(QSlider::NoTicks), tickInterval(0), upsideDown(false),
+ sliderPosition(0), sliderValue(0), singleStep(0), pageStep(0), notchTarget(0.0),
+ dialWrapping(false)
+{
+}
+
+/*!
+ \fn QStyleOptionSlider::QStyleOptionSlider(const QStyleOptionSlider &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionSlider::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Slider} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionSlider::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionSlider::orientation
+ \brief the slider's orientation (horizontal or vertical)
+
+ The default orientation is Qt::Horizontal.
+
+ \sa Qt::Orientation
+*/
+
+/*!
+ \variable QStyleOptionSlider::minimum
+ \brief the minimum value for the slider
+
+ The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionSlider::maximum
+ \brief the maximum value for the slider
+
+ The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionSlider::tickPosition
+ \brief the position of the slider's tick marks, if any
+
+ The default value is QSlider::NoTicks.
+
+ \sa QSlider::TickPosition
+*/
+
+/*!
+ \variable QStyleOptionSlider::tickInterval
+ \brief the interval that should be drawn between tick marks
+
+ The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionSlider::notchTarget
+ \brief the number of pixel between notches
+
+ The default value is 0.0.
+
+ \sa QDial::notchTarget()
+*/
+
+/*!
+ \variable QStyleOptionSlider::dialWrapping
+ \brief whether the dial should wrap or not
+
+ The default value is false, i.e. the dial is not wrapped.
+
+ \sa QDial::wrapping()
+*/
+
+/*!
+ \variable QStyleOptionSlider::upsideDown
+ \brief the slider control orientation
+
+ Normally a slider increases as it moves up or to the right;
+ upsideDown indicates that it should do the opposite (increase as
+ it moves down or to the left). The default value is false,
+ i.e. the slider increases as it moves up or to the right.
+
+ \sa QStyle::sliderPositionFromValue(),
+ QStyle::sliderValueFromPosition(),
+ QAbstractSlider::invertedAppearance
+*/
+
+/*!
+ \variable QStyleOptionSlider::sliderPosition
+ \brief the position of the slider handle
+
+ If the slider has active feedback (i.e.,
+ QAbstractSlider::tracking is true), this value will be the same as
+ \l sliderValue. Otherwise, it will have the current position of
+ the handle. The default value is 0.
+
+ \sa QAbstractSlider::tracking, sliderValue
+*/
+
+/*!
+ \variable QStyleOptionSlider::sliderValue
+ \brief the value of the slider
+
+ If the slider has active feedback (i.e.,
+ QAbstractSlider::tracking is true), this value will be the same
+ as \l sliderPosition. Otherwise, it will have the value the
+ slider had before the mouse was pressed.
+
+ The default value is 0.
+
+ \sa QAbstractSlider::tracking sliderPosition
+*/
+
+/*!
+ \variable QStyleOptionSlider::singleStep
+ \brief the size of the single step of the slider
+
+ The default value is 0.
+
+ \sa QAbstractSlider::singleStep
+*/
+
+/*!
+ \variable QStyleOptionSlider::pageStep
+ \brief the size of the page step of the slider
+
+ The default value is 0.
+
+ \sa QAbstractSlider::pageStep
+*/
+#endif // QT_NO_SLIDER
+
+#ifndef QT_NO_SPINBOX
+/*!
+ \class QStyleOptionSpinBox
+ \brief The QStyleOptionSpinBox class is used to describe the
+ parameters necessary for drawing a spin box.
+
+ QStyleOptionSpinBox contains all the information that QStyle
+ functions need to draw QSpinBox and QDateTimeEdit.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionComplex
+*/
+
+/*!
+ Constructs a QStyleOptionSpinBox, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionSpinBox::QStyleOptionSpinBox()
+ : QStyleOptionComplex(Version, SO_SpinBox), buttonSymbols(QAbstractSpinBox::UpDownArrows),
+ stepEnabled(QAbstractSpinBox::StepNone), frame(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionSpinBox::QStyleOptionSpinBox(int version)
+ : QStyleOptionComplex(version, SO_SpinBox), buttonSymbols(QAbstractSpinBox::UpDownArrows),
+ stepEnabled(QAbstractSpinBox::StepNone), frame(false)
+{
+}
+
+/*!
+ \fn QStyleOptionSpinBox::QStyleOptionSpinBox(const QStyleOptionSpinBox &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionSpinBox::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_SpinBox} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionSpinBox::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionSpinBox::buttonSymbols
+ \brief the type of button symbols to draw for the spin box
+
+ The default value is QAbstractSpinBox::UpDownArrows specufying
+ little arrows in the classic style.
+
+ \sa QAbstractSpinBox::ButtonSymbols
+*/
+
+/*!
+ \variable QStyleOptionSpinBox::stepEnabled
+ \brief which buttons of the spin box that are enabled
+
+ The default value is QAbstractSpinBox::StepNone.
+
+ \sa QAbstractSpinBox::StepEnabled
+*/
+
+/*!
+ \variable QStyleOptionSpinBox::frame
+ \brief whether the spin box has a frame
+
+ The default value is false, i.e. the spin box has no frame.
+*/
+#endif // QT_NO_SPINBOX
+
+/*!
+ \class QStyleOptionQ3ListViewItem
+ \brief The QStyleOptionQ3ListViewItem class is used to describe an
+ item drawn in a Q3ListView.
+
+ This class is used for drawing the compatibility Q3ListView's
+ items. \bold {It is not recommended for new classes}.
+
+ QStyleOptionQ3ListViewItem contains all the information that
+ QStyle functions need to draw the Q3ListView items.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionQ3ListView, Q3ListViewItem
+*/
+
+/*!
+ \enum QStyleOptionQ3ListViewItem::Q3ListViewItemFeature
+
+ This enum describes the features a list view item can have.
+
+ \value None A standard item.
+ \value Expandable The item has children that can be shown.
+ \value MultiLine The item is more than one line tall.
+ \value Visible The item is visible.
+ \value ParentControl The item's parent is a type of item control (Q3CheckListItem::Controller).
+
+ \sa features, Q3ListViewItem::isVisible(), Q3ListViewItem::multiLinesEnabled(),
+ Q3ListViewItem::isExpandable()
+*/
+
+/*!
+ Constructs a QStyleOptionQ3ListViewItem, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionQ3ListViewItem::QStyleOptionQ3ListViewItem()
+ : QStyleOption(Version, SO_Q3ListViewItem), features(None), height(0), totalHeight(0),
+ itemY(0), childCount(0)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionQ3ListViewItem::QStyleOptionQ3ListViewItem(int version)
+ : QStyleOption(version, SO_Q3ListViewItem), features(None), height(0), totalHeight(0),
+ itemY(0), childCount(0)
+{
+}
+
+/*!
+ \fn QStyleOptionQ3ListViewItem::QStyleOptionQ3ListViewItem(const QStyleOptionQ3ListViewItem &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionQ3ListViewItem::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Q3ListViewItem} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionQ3ListViewItem::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionQ3ListViewItem::features
+ \brief the features for this item
+
+ This variable is a bitwise OR of the features of the item. The deafult value is \l None.
+
+ \sa Q3ListViewItemFeature
+*/
+
+/*!
+ \variable QStyleOptionQ3ListViewItem::height
+ \brief the height of the item
+
+ This doesn't include the height of the item's children. The default height is 0.
+
+ \sa Q3ListViewItem::height()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListViewItem::totalHeight
+ \brief the total height of the item, including its children
+
+ The default total height is 0.
+
+ \sa Q3ListViewItem::totalHeight()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListViewItem::itemY
+ \brief the Y-coordinate for the item
+
+ The default value is 0.
+
+ \sa Q3ListViewItem::itemPos()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListViewItem::childCount
+ \brief the number of children the item has
+*/
+
+/*!
+ \class QStyleOptionQ3ListView
+ \brief The QStyleOptionQ3ListView class is used to describe the
+ parameters for drawing a Q3ListView.
+
+ This class is used for drawing the compatibility Q3ListView. \bold
+ {It is not recommended for new classes}.
+
+ QStyleOptionQ3ListView contains all the information that QStyle
+ functions need to draw Q3ListView.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOptionComplex, Q3ListView, QStyleOptionQ3ListViewItem
+*/
+
+/*!
+ Creates a QStyleOptionQ3ListView, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionQ3ListView::QStyleOptionQ3ListView()
+ : QStyleOptionComplex(Version, SO_Q3ListView), viewportBGRole(QPalette::Base),
+ sortColumn(0), itemMargin(0), treeStepSize(0), rootIsDecorated(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionQ3ListView::QStyleOptionQ3ListView(int version)
+ : QStyleOptionComplex(version, SO_Q3ListView), viewportBGRole(QPalette::Base),
+ sortColumn(0), itemMargin(0), treeStepSize(0), rootIsDecorated(false)
+{
+}
+
+/*!
+ \fn QStyleOptionQ3ListView::QStyleOptionQ3ListView(const QStyleOptionQ3ListView &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionQ3ListView::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Q3ListView} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionQ3ListView::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::items
+ \brief a list of items in the Q3ListView
+
+ This is a list of \l {QStyleOptionQ3ListViewItem}s. The first item
+ can be used for most of the calculation that are needed for
+ drawing a list view. Any additional items are the children of
+ this first item, which may be used for additional information.
+
+ \sa QStyleOptionQ3ListViewItem
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::viewportPalette
+ \brief the palette of Q3ListView's viewport
+
+ By default, the application's default palette is used.
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::viewportBGRole
+ \brief the background role of Q3ListView's viewport
+
+ The default value is QPalette::Base.
+
+ \sa QWidget::backgroundRole()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::sortColumn
+ \brief the sort column of the list view
+
+ The default value is 0.
+
+ \sa Q3ListView::sortColumn()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::itemMargin
+ \brief the margin for items in the list view
+
+ The default value is 0.
+
+ \sa Q3ListView::itemMargin()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::treeStepSize
+ \brief the number of pixel to offset children items from their
+ parents
+
+ The default value is 0.
+
+ \sa Q3ListView::treeStepSize()
+*/
+
+/*!
+ \variable QStyleOptionQ3ListView::rootIsDecorated
+ \brief whether root items are decorated
+
+ The default value is false.
+
+ \sa Q3ListView::rootIsDecorated()
+*/
+
+/*!
+ \class QStyleOptionQ3DockWindow
+ \brief The QStyleOptionQ3DockWindow class is used to describe the
+ parameters for drawing various parts of a Q3DockWindow.
+
+ This class is used for drawing the old Q3DockWindow and its
+ parts. \bold {It is not recommended for new classes}.
+
+ QStyleOptionQ3DockWindow contains all the information that QStyle
+ functions need to draw Q3DockWindow and its parts.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, Q3DockWindow
+*/
+
+/*!
+ Constructs a QStyleOptionQ3DockWindow, initializing the member
+ variables to their default values.
+*/
+
+QStyleOptionQ3DockWindow::QStyleOptionQ3DockWindow()
+ : QStyleOption(Version, SO_Q3DockWindow), docked(false), closeEnabled(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionQ3DockWindow::QStyleOptionQ3DockWindow(int version)
+ : QStyleOption(version, SO_Q3DockWindow), docked(false), closeEnabled(false)
+{
+}
+
+/*!
+ \fn QStyleOptionQ3DockWindow::QStyleOptionQ3DockWindow(const QStyleOptionQ3DockWindow &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionQ3DockWindow::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_Q3DockWindow} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionQ3DockWindow::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionQ3DockWindow::docked
+ \brief whether the dock window is currently docked
+
+ The default value is false.
+*/
+
+/*!
+ \variable QStyleOptionQ3DockWindow::closeEnabled
+ \brief whether the dock window has a close button
+
+ The default value is false.
+*/
+
+/*!
+ \class QStyleOptionDockWidget
+ \brief The QStyleOptionDockWidget class is used to describe the
+ parameters for drawing a dock widget.
+
+ QStyleOptionDockWidget contains all the information that QStyle
+ functions need to draw graphical elements like QDockWidget.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption
+*/
+
+/*!
+ Constructs a QStyleOptionDockWidget, initializing the member
+ variables to their default values.
+*/
+
+QStyleOptionDockWidget::QStyleOptionDockWidget()
+ : QStyleOption(Version, SO_DockWidget), closable(false),
+ movable(false), floatable(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionDockWidget::QStyleOptionDockWidget(int version)
+ : QStyleOption(version, SO_DockWidget), closable(false),
+ movable(false), floatable(false)
+{
+}
+
+QStyleOptionDockWidgetV2::QStyleOptionDockWidgetV2()
+ : QStyleOptionDockWidget(Version), verticalTitleBar(false)
+{
+}
+
+QStyleOptionDockWidgetV2::QStyleOptionDockWidgetV2(
+ const QStyleOptionDockWidget &other)
+ : QStyleOptionDockWidget(Version)
+{
+ (void)QStyleOptionDockWidgetV2::operator=(other);
+}
+
+QStyleOptionDockWidgetV2 &QStyleOptionDockWidgetV2::operator = (
+ const QStyleOptionDockWidget &other)
+{
+ QStyleOptionDockWidget::operator=(other);
+ const QStyleOptionDockWidgetV2 *v2
+ = qstyleoption_cast<const QStyleOptionDockWidgetV2*>(&other);
+ verticalTitleBar = v2 ? v2->verticalTitleBar : false;
+ return *this;
+}
+
+QStyleOptionDockWidgetV2::QStyleOptionDockWidgetV2(int version)
+ : QStyleOptionDockWidget(version), verticalTitleBar(false)
+{
+}
+
+/*!
+ \fn QStyleOptionDockWidget::QStyleOptionDockWidget(const QStyleOptionDockWidget &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionDockWidget::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_DockWidget} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionDockWidget::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionDockWidget::title
+ \brief the title of the dock window
+
+ The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionDockWidget::closable
+ \brief whether the dock window is closable
+
+ The default value is true.
+*/
+
+/*!
+ \variable QStyleOptionDockWidget::movable
+ \brief whether the dock window is movable
+
+ The default value is false.
+*/
+
+/*!
+ \variable QStyleOptionDockWidget::floatable
+ \brief whether the dock window is floatable
+
+ The default value is true.
+*/
+
+/*!
+ \class QStyleOptionToolButton
+ \brief The QStyleOptionToolButton class is used to describe the
+ parameters for drawing a tool button.
+
+ QStyleOptionToolButton contains all the information that QStyle
+ functions need to draw QToolButton.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionComplex, QStyleOptionButton
+*/
+
+/*!
+ \enum QStyleOptionToolButton::ToolButtonFeature
+ Describes the various features that a tool button can have.
+
+ \value None A normal tool button.
+ \value Arrow The tool button is an arrow.
+ \value Menu The tool button has a menu.
+ \value PopupDelay There is a delay to showing the menu.
+ \value HasMenu The button has a popup menu.
+ \value MenuButtonPopup The button should display an arrow to
+ indicate that a menu is present.
+
+ \sa features, QToolButton::toolButtonStyle(), QToolButton::popupMode()
+*/
+
+/*!
+ Constructs a QStyleOptionToolButton, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionToolButton::QStyleOptionToolButton()
+ : QStyleOptionComplex(Version, SO_ToolButton), features(None), arrowType(Qt::DownArrow)
+ , toolButtonStyle(Qt::ToolButtonIconOnly)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionToolButton::QStyleOptionToolButton(int version)
+ : QStyleOptionComplex(version, SO_ToolButton), features(None), arrowType(Qt::DownArrow)
+ , toolButtonStyle(Qt::ToolButtonIconOnly)
+
+{
+}
+
+/*!
+ \fn QStyleOptionToolButton::QStyleOptionToolButton(const QStyleOptionToolButton &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionToolButton::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ToolButton} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionToolButton::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionToolButton::features
+ \brief an OR combination of the tool button's features
+
+ The default value is \l None.
+
+ \sa ToolButtonFeature
+*/
+
+/*!
+ \variable QStyleOptionToolButton::icon
+ \brief the icon for the tool button
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+
+ \sa iconSize
+*/
+
+/*!
+ \variable QStyleOptionToolButton::iconSize
+ \brief the size of the icon for the tool button
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+*/
+
+/*!
+ \variable QStyleOptionToolButton::text
+ \brief the text of the tool button
+
+ This value is only used if toolButtonStyle is
+ Qt::ToolButtonTextUnderIcon, Qt::ToolButtonTextBesideIcon, or
+ Qt::ToolButtonTextOnly. The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionToolButton::arrowType
+ \brief the direction of the arrow for the tool button
+
+ This value is only used if \l features includes \l Arrow. The
+ default value is Qt::DownArrow.
+*/
+
+/*!
+ \variable QStyleOptionToolButton::toolButtonStyle
+ \brief a Qt::ToolButtonStyle value describing the appearance of
+ the tool button
+
+ The default value is Qt::ToolButtonIconOnly.
+
+ \sa QToolButton::toolButtonStyle()
+*/
+
+/*!
+ \variable QStyleOptionToolButton::pos
+ \brief the position of the tool button
+
+ The default value is a null point, i.e. (0, 0)
+*/
+
+/*!
+ \variable QStyleOptionToolButton::font
+ \brief the font that is used for the text
+
+ This value is only used if toolButtonStyle is
+ Qt::ToolButtonTextUnderIcon, Qt::ToolButtonTextBesideIcon, or
+ Qt::ToolButtonTextOnly. By default, the application's default font
+ is used.
+*/
+
+/*!
+ \class QStyleOptionComboBox
+ \brief The QStyleOptionComboBox class is used to describe the
+ parameter for drawing a combobox.
+
+ QStyleOptionButton contains all the information that QStyle
+ functions need to draw QComboBox.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionComplex, QComboBox
+*/
+
+/*!
+ Creates a QStyleOptionComboBox, initializing the members variables
+ to their default values.
+*/
+
+QStyleOptionComboBox::QStyleOptionComboBox()
+ : QStyleOptionComplex(Version, SO_ComboBox), editable(false), frame(true)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionComboBox::QStyleOptionComboBox(int version)
+ : QStyleOptionComplex(version, SO_ComboBox), editable(false), frame(true)
+{
+}
+
+/*!
+ \fn QStyleOptionComboBox::QStyleOptionComboBox(const QStyleOptionComboBox &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionComboBox::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ComboBox} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionComboBox::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionComboBox::editable
+ \brief whether or not the combobox is editable or not
+
+ the default
+ value is false
+
+ \sa QComboBox::isEditable()
+*/
+
+
+/*!
+ \variable QStyleOptionComboBox::frame
+ \brief whether the combo box has a frame
+
+ The default value is true.
+*/
+
+/*!
+ \variable QStyleOptionComboBox::currentText
+ \brief the text for the current item of the combo box
+
+ The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionComboBox::currentIcon
+ \brief the icon for the current item of the combo box
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+*/
+
+/*!
+ \variable QStyleOptionComboBox::iconSize
+ \brief the icon size for the current item of the combo box
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+*/
+
+/*!
+ \variable QStyleOptionComboBox::popupRect
+ \brief the popup rectangle for the combobox
+
+ The default value is a null rectangle, i.e. a rectangle with both
+ the width and the height set to 0.
+
+ This variable is currently unused. You can safely ignore it.
+
+ \sa QStyle::SC_ComboBoxListBoxPopup
+*/
+
+/*!
+ \class QStyleOptionToolBox
+ \brief The QStyleOptionToolBox class is used to describe the
+ parameters needed for drawing a tool box.
+
+ QStyleOptionToolBox contains all the information that QStyle
+ functions need to draw QToolBox.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QToolBox
+*/
+
+/*!
+ Creates a QStyleOptionToolBox, initializing the members variables
+ to their default values.
+*/
+
+QStyleOptionToolBox::QStyleOptionToolBox()
+ : QStyleOption(Version, SO_ToolBox)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionToolBox::QStyleOptionToolBox(int version)
+ : QStyleOption(version, SO_ToolBox)
+{
+}
+
+/*!
+ \fn QStyleOptionToolBox::QStyleOptionToolBox(const QStyleOptionToolBox &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionToolBox::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ToolBox} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionToolBox::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionToolBox::icon
+ \brief the icon for the tool box tab
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+*/
+
+/*!
+ \variable QStyleOptionToolBox::text
+ \brief the text for the tool box tab
+
+ The default value is an empty string.
+*/
+
+/*!
+ \class QStyleOptionToolBoxV2
+ \brief The QStyleOptionToolBoxV2 class is used to describe the parameters necessary for drawing a frame in Qt 4.3 or above.
+
+ \since 4.3
+ QStyleOptionToolBoxV2 inherits QStyleOptionToolBox which is used for
+ drawing the tabs in a QToolBox.
+
+ An instance of the QStyleOptionToolBoxV2 class has
+ \l{QStyleOption::type} {type} SO_ToolBox and
+ \l{QStyleOption::version} {version} 2. The type is used
+ internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles. The
+ version is used by QStyleOption subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast(),
+ you normally do not need to check it.
+
+ If you create your own QStyle subclass, you should handle both
+ QStyleOptionToolBox and QStyleOptionToolBoxV2.
+
+ \sa QStyleOptionToolBox, QStyleOption
+*/
+
+/*!
+ Contsructs a QStyleOptionToolBoxV2 object.
+*/
+QStyleOptionToolBoxV2::QStyleOptionToolBoxV2()
+ : QStyleOptionToolBox(Version), position(Beginning), selectedPosition(NotAdjacent)
+{
+}
+
+/*!
+ \fn QStyleOptionToolBoxV2::QStyleOptionToolBoxV2(const QStyleOptionToolBoxV2 &other)
+
+ Constructs a QStyleOptionToolBoxV2 copy of the \a other style option.
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionToolBoxV2::QStyleOptionToolBoxV2(int version)
+ : QStyleOptionToolBox(version), position(Beginning), selectedPosition(NotAdjacent)
+{
+}
+
+/*!
+ Constructs a QStyleOptionToolBoxV2 copy of the \a other style option
+ which can be either of the QStyleOptionToolBoxV2 or
+ QStyleOptionToolBox types.
+
+ If the \a other style option's version is 1, the new style
+ option's \l{QStyleOptionTab::position} {position} value is set to
+ \l QStyleOptionToolBoxV2::Beginning and \l selectedPosition is set
+ to \l QStyleOptionToolBoxV2::NotAdjacent. If its version is 2, the
+ \l{QStyleOptionTab::position} {position} selectedPosition values
+ are simply copied to the new style option.
+
+ \sa version
+*/
+QStyleOptionToolBoxV2::QStyleOptionToolBoxV2(const QStyleOptionToolBox &other)
+{
+ QStyleOptionToolBox::operator=(other);
+
+ const QStyleOptionToolBoxV2 *f2 = qstyleoption_cast<const QStyleOptionToolBoxV2 *>(&other);
+ position = f2 ? f2->position : Beginning;
+ selectedPosition = f2 ? f2->selectedPosition : NotAdjacent;
+ version = Version;
+}
+
+/*!
+ Assigns the \a other style option to this style option. The \a
+ other style option can be either of the QStyleOptionToolBoxV2 or
+ QStyleOptionToolBox types.
+
+ If the \a{other} style option's version is 1, this style option's
+ \l{QStyleOptionTab::position} {position} and \l selectedPosition
+ values are set to \l QStyleOptionToolBoxV2::Beginning and \l
+ QStyleOptionToolBoxV2::NotAdjacent respectively. If its
+ \l{QStyleOption::version} {version} is 2, these values are simply
+ copied to this style option.
+*/
+QStyleOptionToolBoxV2 &QStyleOptionToolBoxV2::operator=(const QStyleOptionToolBox &other)
+{
+ QStyleOptionToolBox::operator=(other);
+
+ const QStyleOptionToolBoxV2 *f2 = qstyleoption_cast<const QStyleOptionToolBoxV2 *>(&other);
+ position = f2 ? f2->position : Beginning;
+ selectedPosition = f2 ? f2->selectedPosition : NotAdjacent;
+ version = Version;
+ return *this;
+}
+
+
+/*!
+ \enum QStyleOptionToolBoxV2::SelectedPosition
+
+ This enum describes the position of the selected tab. Some styles
+ need to draw a tab differently depending on whether or not it is
+ adjacent to the selected tab.
+
+ \value NotAdjacent The tab is not adjacent to a selected tab (or is the selected tab).
+ \value NextIsSelected The next tab (typically the tab on the right) is selected.
+ \value PreviousIsSelected The previous tab (typically the tab on the left) is selected.
+
+ \sa selectedPosition
+*/
+
+/*!
+ \enum QStyleOptionToolBoxV2::StyleOptionVersion
+
+ This enum holds the version of this style option
+
+ \value Version 2
+*/
+
+/*!
+ \enum QStyleOptionToolBoxV2::TabPosition
+
+ This enum describes tab positions relative to other tabs.
+
+ \value Beginning The tab is the first (i.e., top-most) tab in
+ the toolbox.
+ \value Middle The tab is placed in the middle of the toolbox.
+ \value End The tab is placed at the bottom of the toolbox.
+ \value OnlyOneTab There is only one tab in the toolbox.
+*/
+
+/*!
+ \variable QStyleOptionToolBoxV2::selectedPosition
+ \brief the position of the selected tab in relation to this tab
+
+ The default value is NotAdjacent, i.e. the tab is not adjacent to
+ a selected tab nor is it the selected tab.
+*/
+
+#ifndef QT_NO_RUBBERBAND
+/*!
+ \class QStyleOptionRubberBand
+ \brief The QStyleOptionRubberBand class is used to describe the
+ parameters needed for drawing a rubber band.
+
+ QStyleOptionRubberBand contains all the information that
+ QStyle functions need to draw QRubberBand.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QRubberBand
+*/
+
+/*!
+ Creates a QStyleOptionRubberBand, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionRubberBand::QStyleOptionRubberBand()
+ : QStyleOption(Version, SO_RubberBand), shape(QRubberBand::Line), opaque(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionRubberBand::QStyleOptionRubberBand(int version)
+ : QStyleOption(version, SO_RubberBand), shape(QRubberBand::Line), opaque(false)
+{
+}
+
+/*!
+ \fn QStyleOptionRubberBand::QStyleOptionRubberBand(const QStyleOptionRubberBand &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionRubberBand::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_RubberBand} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionRubberBand::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionRubberBand::shape
+ \brief the shape of the rubber band
+
+ The default shape is QRubberBand::Line.
+*/
+
+/*!
+ \variable QStyleOptionRubberBand::opaque
+ \brief whether the rubber band is required to be drawn in an opaque style
+
+ The default value is true.
+*/
+#endif // QT_NO_RUBBERBAND
+
+/*!
+ \class QStyleOptionTitleBar
+ \brief The QStyleOptionTitleBar class is used to describe the
+ parameters for drawing a title bar.
+
+ QStyleOptionTitleBar contains all the information that QStyle
+ functions need to draw the title bar of a QMdiSubWindow.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionComplex, QMdiSubWindow
+*/
+
+/*!
+ Constructs a QStyleOptionTitleBar, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionTitleBar::QStyleOptionTitleBar()
+ : QStyleOptionComplex(Version, SO_TitleBar), titleBarState(0), titleBarFlags(0)
+{
+}
+
+/*!
+ \fn QStyleOptionTitleBar::QStyleOptionTitleBar(const QStyleOptionTitleBar &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionTitleBar::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_TitleBar} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionTitleBar::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionTitleBar::QStyleOptionTitleBar(int version)
+ : QStyleOptionComplex(version, SO_TitleBar), titleBarState(0), titleBarFlags(0)
+{
+}
+
+
+/*!
+ \variable QStyleOptionTitleBar::text
+ \brief the text of the title bar
+
+ The default value is an empty string.
+*/
+
+/*!
+ \variable QStyleOptionTitleBar::icon
+ \brief the icon for the title bar
+
+ The default value is an empty icon, i.e. an icon with neither a
+ pixmap nor a filename.
+*/
+
+/*!
+ \variable QStyleOptionTitleBar::titleBarState
+ \brief the state of the title bar
+
+ This is basically the window state of the underlying widget. The
+ default value is 0.
+
+ \sa QWidget::windowState()
+*/
+
+/*!
+ \variable QStyleOptionTitleBar::titleBarFlags
+ \brief the widget flags for the title bar
+
+ The default value is Qt::Widget.
+
+ \sa Qt::WindowFlags
+*/
+
+/*!
+ \class QStyleOptionViewItem
+ \brief The QStyleOptionViewItem class is used to describe the
+ parameters used to draw an item in a view widget.
+
+ QStyleOptionViewItem contains all the information that QStyle
+ functions need to draw the items for Qt's model/view classes.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, {model-view-programming.html}{Model/View
+ Programming}
+*/
+
+/*!
+ \enum QStyleOptionViewItem::Position
+
+ This enum describes the position of the item's decoration.
+
+ \value Left On the left of the text.
+ \value Right On the right of the text.
+ \value Top Above the text.
+ \value Bottom Below the text.
+
+ \sa decorationPosition
+*/
+
+/*!
+ \variable QStyleOptionViewItem::showDecorationSelected
+ \brief whether the decoration should be highlighted on selected
+ items
+
+ If this option is true, the branch and any decorations on selected items
+ should be highlighted, indicating that the item is selected; otherwise, no
+ highlighting is required. The default value is false.
+
+ \sa QStyle::SH_ItemView_ShowDecorationSelected, QAbstractItemView
+*/
+
+/*!
+ \variable QStyleOptionViewItem::textElideMode
+ \brief where ellipsis should be added for text that is too long to fit
+ into an item
+
+ The default value is Qt::ElideMiddle, i.e. the ellipsis appears in
+ the middle of the text.
+
+ \sa Qt::TextElideMode, QStyle::SH_ItemView_EllipsisLocation
+*/
+
+/*!
+ Constructs a QStyleOptionViewItem, initializing the members
+ variables to their default values.
+*/
+
+QStyleOptionViewItem::QStyleOptionViewItem()
+ : QStyleOption(Version, SO_ViewItem),
+ displayAlignment(Qt::AlignLeft), decorationAlignment(Qt::AlignLeft),
+ textElideMode(Qt::ElideMiddle), decorationPosition(Left),
+ showDecorationSelected(false)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionViewItem::QStyleOptionViewItem(int version)
+ : QStyleOption(version, SO_ViewItem),
+ displayAlignment(Qt::AlignLeft), decorationAlignment(Qt::AlignLeft),
+ textElideMode(Qt::ElideMiddle), decorationPosition(Left),
+ showDecorationSelected(false)
+{
+}
+
+/*!
+ \fn QStyleOptionViewItem::QStyleOptionViewItem(const QStyleOptionViewItem &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \enum QStyleOptionViewItem::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_ViewItem} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionViewItem::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionViewItem::displayAlignment
+ \brief the alignment of the display value for the item
+
+ The default value is Qt::AlignLeft.
+*/
+
+/*!
+ \variable QStyleOptionViewItem::decorationAlignment
+ \brief the alignment of the decoration for the item
+
+ The default value is Qt::AlignLeft.
+*/
+
+/*!
+ \variable QStyleOptionViewItem::decorationPosition
+ \brief the position of the decoration for the item
+
+ The default value is \l Left.
+
+ \sa Position
+*/
+
+/*!
+ \variable QStyleOptionViewItem::decorationSize
+ \brief the size of the decoration for the item
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+
+ \sa decorationAlignment, decorationPosition
+*/
+
+/*!
+ \variable QStyleOptionViewItem::font
+ \brief the font used for the item
+
+ By default, the application's default font is used.
+
+ \sa QFont
+*/
+
+/*!
+ \fn T qstyleoption_cast<T>(const QStyleOption *option)
+ \relates QStyleOption
+
+ Returns a T or 0 depending on the \l{QStyleOption::type}{type} and
+ \l{QStyleOption::version}{version} of the given \a option.
+
+ Example:
+
+ \snippet doc/src/snippets/qstyleoption/main.cpp 4
+
+ \sa QStyleOption::type, QStyleOption::version
+*/
+
+/*!
+ \fn T qstyleoption_cast<T>(QStyleOption *option)
+ \overload
+ \relates QStyleOption
+
+ Returns a T or 0 depending on the type of the given \a option.
+*/
+
+#ifndef QT_NO_TABWIDGET
+/*!
+ \class QStyleOptionTabWidgetFrame
+ \brief The QStyleOptionTabWidgetFrame class is used to describe the
+ parameters for drawing the frame around a tab widget.
+
+ QStyleOptionTabWidgetFrame contains all the information that
+ QStyle functions need to draw the frame around QTabWidget.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QTabWidget
+*/
+
+/*!
+ Constructs a QStyleOptionTabWidgetFrame, initializing the members
+ variables to their default values.
+*/
+QStyleOptionTabWidgetFrame::QStyleOptionTabWidgetFrame()
+ : QStyleOption(Version, SO_TabWidgetFrame), lineWidth(0), midLineWidth(0),
+ shape(QTabBar::RoundedNorth)
+{
+}
+
+/*!
+ \fn QStyleOptionTabWidgetFrame::QStyleOptionTabWidgetFrame(const QStyleOptionTabWidgetFrame &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*! \internal */
+QStyleOptionTabWidgetFrame::QStyleOptionTabWidgetFrame(int version)
+ : QStyleOption(version, SO_TabWidgetFrame), lineWidth(0), midLineWidth(0),
+ shape(QTabBar::RoundedNorth)
+{
+}
+
+/*!
+ \enum QStyleOptionTabWidgetFrame::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_TabWidgetFrame} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionTabWidgetFrame::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionTabWidgetFrame::lineWidth
+ \brief the line width for drawing the panel
+
+ The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionTabWidgetFrame::midLineWidth
+ \brief the mid-line width for drawing the panel
+
+ The mid line width is usually used in drawing sunken or raised
+ frames. The default value is 0.
+*/
+
+/*!
+ \variable QStyleOptionTabWidgetFrame::shape
+ \brief the tab shape used to draw the tabs
+
+ The default value is QTabBar::RoundedNorth.
+*/
+
+/*!
+ \variable QStyleOptionTabWidgetFrame::tabBarSize
+ \brief the size of the tab bar
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+*/
+
+/*!
+ \variable QStyleOptionTabWidgetFrame::rightCornerWidgetSize
+ \brief the size of the right-corner widget
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+*/
+
+/*! \variable QStyleOptionTabWidgetFrame::leftCornerWidgetSize
+ \brief the size of the left-corner widget
+
+ The default value is QSize(-1, -1), i.e. an invalid size.
+*/
+#endif // QT_NO_TABWIDGET
+
+#ifndef QT_NO_TABBAR
+
+/*!
+ \class QStyleOptionTabBarBase
+ \brief The QStyleOptionTabBarBase class is used to describe
+ the base of a tab bar, i.e. the part that the tab bar usually
+ overlaps with.
+
+ QStyleOptionTabBarBase contains all the information that QStyle
+ functions need to draw the tab bar base. Note that this is only
+ drawn for a standalone QTabBar (one that isn't part of a
+ QTabWidget).
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QTabBar::drawBase()
+*/
+
+/*!
+ Construct a QStyleOptionTabBarBase, initializing the members
+ vaiables to their default values.
+*/
+QStyleOptionTabBarBase::QStyleOptionTabBarBase()
+ : QStyleOption(Version, SO_TabBarBase), shape(QTabBar::RoundedNorth)
+{
+}
+
+/*! \internal */
+QStyleOptionTabBarBase::QStyleOptionTabBarBase(int version)
+ : QStyleOption(version, SO_TabBarBase), shape(QTabBar::RoundedNorth)
+{
+}
+
+/*!
+ \fn QStyleOptionTabBarBase::QStyleOptionTabBarBase(const QStyleOptionTabBarBase &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ \enum QStyleOptionTabBarBase::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_TabBarBase} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionTabBarBase::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionTabBarBase::shape
+ \brief the shape of the tab bar
+
+ The default value is QTabBar::RoundedNorth.
+*/
+
+/*!
+ \variable QStyleOptionTabBarBase::tabBarRect
+ \brief the rectangle containing all the tabs
+
+ The default value is a null rectangle, i.e. a rectangle with both
+ the width and the height set to 0.
+*/
+
+/*!
+ \variable QStyleOptionTabBarBase::selectedTabRect
+ \brief the rectangle containing the selected tab
+
+ This rectangle is contained within the tabBarRect. The default
+ value is a null rectangle, i.e. a rectangle with both the width
+ and the height set to 0.
+*/
+
+
+/*!
+ \class QStyleOptionTabBarBaseV2
+ \brief The QStyleOptionTabBarBaseV2 class is used to describe
+ the base of a tab bar, i.e. the part that the tab bar usually
+ overlaps with.
+ \since 4.5
+
+ QStyleOptionTabBarBase contains all the information that QStyle
+ functions need to draw the tab bar base.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QTabBar::drawBase()
+*/
+
+/*!
+ \enum QStyleOptionTabBarBaseV2::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 2
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleOptionTabBarBaseV2::documentMode
+ \brief whether the tabbar is in document mode.
+
+ The default value is false;
+*/
+
+/*!
+ Construct a QStyleOptionTabBarBaseV2, initializing the members
+ vaiables to their default values.
+*/
+QStyleOptionTabBarBaseV2::QStyleOptionTabBarBaseV2()
+ : QStyleOptionTabBarBase(Version)
+ , documentMode(false)
+{
+}
+
+/*!
+ \fn QStyleOptionTabBarBaseV2::QStyleOptionTabBarBaseV2(const QStyleOptionTabBarBaseV2 &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ Constructs a copy of \a other.
+*/
+QStyleOptionTabBarBaseV2::QStyleOptionTabBarBaseV2(const QStyleOptionTabBarBase &other)
+ : QStyleOptionTabBarBase(Version)
+{
+ (void)QStyleOptionTabBarBaseV2::operator=(other);
+}
+
+/*!
+ Constructs a QStyleOptionTabBarBaseV2 copy of the \a other style option
+ which can be either of the QStyleOptionTabBarBaseV2, or QStyleOptionTabBarBase types.
+
+ If the other style option's version is not 1, the new style option's
+ \c documentMode is set to false. If its version is 2, its \c documentMode value
+ is simply copied to the new style option.
+*/
+QStyleOptionTabBarBaseV2 &QStyleOptionTabBarBaseV2::operator = (const QStyleOptionTabBarBase &other)
+{
+ QStyleOptionTabBarBase::operator=(other);
+ const QStyleOptionTabBarBaseV2 *v2 = qstyleoption_cast<const QStyleOptionTabBarBaseV2*>(&other);
+ documentMode = v2 ? v2->documentMode : false;
+ return *this;
+}
+
+/*! \internal */
+QStyleOptionTabBarBaseV2::QStyleOptionTabBarBaseV2(int version)
+ : QStyleOptionTabBarBase(version), documentMode(false)
+{
+}
+
+#endif // QT_NO_TABBAR
+
+#ifndef QT_NO_SIZEGRIP
+/*!
+ \class QStyleOptionSizeGrip
+ \brief The QStyleOptionSizeGrip class is used to describe the
+ parameter for drawing a size grip.
+ \since 4.2
+
+ QStyleOptionButton contains all the information that QStyle
+ functions need to draw QSizeGrip.
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters used by the style functions.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QStyleOptionComplex, QSizeGrip
+*/
+
+/*!
+ Constructs a QStyleOptionSizeGrip.
+*/
+QStyleOptionSizeGrip::QStyleOptionSizeGrip()
+ : QStyleOptionComplex(Version, Type), corner(Qt::BottomRightCorner)
+{
+}
+
+/*!
+ \fn QStyleOptionSizeGrip::QStyleOptionSizeGrip(const QStyleOptionSizeGrip &other)
+
+ Constructs a copy of the \a other style option.
+*/
+
+/*!
+ \internal
+*/
+QStyleOptionSizeGrip::QStyleOptionSizeGrip(int version)
+ : QStyleOptionComplex(version, Type), corner(Qt::BottomRightCorner)
+{
+}
+
+/*!
+ \variable QStyleOptionSizeGrip::corner
+
+ The corner in which the size grip is located.
+*/
+
+/*!
+ \enum QStyleOptionSizeGrip::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l{SO_TabBarBase} for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionSizeGrip::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+#endif // QT_NO_SIZEGRIP
+
+/*!
+ \class QStyleOptionGraphicsItem
+ \brief The QStyleOptionGraphicsItem class is used to describe
+ the parameters needed to draw a QGraphicsItem.
+ \since 4.2
+ \ingroup graphicsview-api
+
+ For performance reasons, the access to the member variables is
+ direct (i.e., using the \c . or \c -> operator). This low-level feel
+ makes the structures straightforward to use and emphasizes that
+ these are simply parameters.
+
+ For an example demonstrating how style options can be used, see
+ the \l {widgets/styles}{Styles} example.
+
+ \sa QStyleOption, QGraphicsItem::paint()
+*/
+
+/*!
+ \enum QStyleOptionGraphicsItem::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Type The type of style option provided (\l SO_GraphicsItem for this class).
+
+ The type is used internally by QStyleOption, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleOption subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleOptionGraphicsItem::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleOption subclass.
+
+ \value Version 1
+
+ The version is used by QStyleOption subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ Constructs a QStyleOptionGraphicsItem.
+*/
+QStyleOptionGraphicsItem::QStyleOptionGraphicsItem()
+ : QStyleOption(Version, Type), levelOfDetail(1)
+{
+}
+
+/*!
+ \internal
+*/
+QStyleOptionGraphicsItem::QStyleOptionGraphicsItem(int version)
+ : QStyleOption(version, Type), levelOfDetail(1)
+{
+}
+
+/*!
+ \since 4.6
+
+ Returns the level of detail from the \a worldTransform.
+
+ Its value represents the maximum value of the height and
+ width of a unity rectangle, mapped using the \a worldTransform
+ of the painter used to draw the item. By default, if no
+ transformations are applied, its value is 1. If zoomed out 1:2, the level
+ of detail will be 0.5, and if zoomed in 2:1, its value is 2.
+*/
+qreal QStyleOptionGraphicsItem::levelOfDetailFromTransform(const QTransform &worldTransform)
+{
+ if (worldTransform.type() <= QTransform::TxTranslate)
+ return 1; // Translation only? The LOD is 1.
+
+ // Two unit vectors.
+ QLineF v1(0, 0, 1, 0);
+ QLineF v2(0, 0, 0, 1);
+ // LOD is the transformed area of a 1x1 rectangle.
+ return qSqrt(worldTransform.map(v1).length() * worldTransform.map(v2).length());
+}
+
+/*!
+ \fn QStyleOptionGraphicsItem::QStyleOptionGraphicsItem(const QStyleOptionGraphicsItem &other)
+
+ Constructs a copy of \a other.
+*/
+
+/*!
+ \variable QStyleOptionGraphicsItem::exposedRect
+ \brief the exposed rectangle, in item coordinates
+
+ Make use of this rectangle to speed up item drawing when only parts of the
+ item are exposed. If the whole item is exposed, this rectangle will be the
+ same as QGraphicsItem::boundingRect().
+
+ This member is only initialized for items that have the
+ QGraphicsItem::ItemUsesExtendedStyleOption flag set.
+*/
+
+/*!
+ \variable QStyleOptionGraphicsItem::matrix
+ \brief the complete transformation matrix for the item
+ \obsolete
+
+ The QMatrix provided through this member does include information about
+ any perspective transformations applied to the view or item. To get the
+ correct transformation matrix, use QPainter::transform() on the painter
+ passed into the QGraphicsItem::paint() implementation.
+
+ This matrix is the combination of the item's scene matrix and the matrix
+ of the painter used for drawing the item. It is provided for convenience,
+ allowing anvanced level-of-detail metrics that can be used to speed up
+ item drawing.
+
+ To find the dimensions of an item in screen coordinates (i.e., pixels),
+ you can use the mapping functions of QMatrix, such as QMatrix::map().
+
+ This member is only initialized for items that have the
+ QGraphicsItem::ItemUsesExtendedStyleOption flag set.
+
+ \sa QStyleOptionGraphicsItem::levelOfDetailFromTransform()
+*/
+
+/*!
+ \variable QStyleOptionGraphicsItem::levelOfDetail
+ \obsolete
+
+ Use QStyleOptionGraphicsItem::levelOfDetailFromTransform()
+ together with QPainter::worldTransform() instead.
+*/
+
+/*!
+ \class QStyleHintReturn
+ \brief The QStyleHintReturn class provides style hints that return more
+ than basic data types.
+
+ \ingroup appearance
+
+ QStyleHintReturn and its subclasses are used to pass information
+ from a style back to the querying widget. This is most useful
+ when the return value from QStyle::styleHint() does not provide enough
+ detail; for example, when a mask is to be returned.
+
+ \omit
+ ### --Sam
+ \endomit
+*/
+
+/*!
+ \enum QStyleHintReturn::HintReturnType
+
+ \value SH_Default QStyleHintReturn
+ \value SH_Mask \l QStyle::SH_RubberBand_Mask QStyle::SH_FocusFrame_Mask
+ \value SH_Variant \l QStyle::SH_TextControl_FocusIndicatorTextCharFormat
+*/
+
+/*!
+ \enum QStyleHintReturn::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleHintReturn subclass.
+
+ \value Type The type of style option provided (\l SH_Default for
+ this class).
+
+ The type is used internally by QStyleHintReturn, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleHintReturn subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleHintReturn::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleHintReturn subclass.
+
+ \value Version 1
+
+ The version is used by QStyleHintReturn subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \variable QStyleHintReturn::type
+ \brief the type of the style hint container
+
+ \sa HintReturnType
+*/
+
+/*!
+ \variable QStyleHintReturn::version
+ \brief the version of the style hint return container
+
+ This value can be used by subclasses to implement extensions
+ without breaking compatibility. If you use qstyleoption_cast<T>(), you
+ normally do not need to check it.
+*/
+
+/*!
+ Constructs a QStyleHintReturn with version \a version and type \a
+ type.
+
+ The version has no special meaning for QStyleHintReturn; it can be
+ used by subclasses to distinguish between different version of
+ the same hint type.
+
+ \sa QStyleOption::version, QStyleOption::type
+*/
+
+QStyleHintReturn::QStyleHintReturn(int version, int type)
+ : version(version), type(type)
+{
+}
+
+/*!
+ \internal
+*/
+
+QStyleHintReturn::~QStyleHintReturn()
+{
+
+}
+
+/*!
+ \class QStyleHintReturnMask
+ \brief The QStyleHintReturnMask class provides style hints that return a QRegion.
+
+ \ingroup appearance
+
+ \omit
+ ### --Sam
+ \endomit
+*/
+
+/*!
+ \variable QStyleHintReturnMask::region
+ \brief the region for style hints that return a QRegion
+*/
+
+/*!
+ Constructs a QStyleHintReturnMask. The member variables are
+ initialized to default values.
+*/
+QStyleHintReturnMask::QStyleHintReturnMask() : QStyleHintReturn(Version, Type)
+{
+}
+
+/*!
+ \enum QStyleHintReturnMask::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleHintReturn subclass.
+
+ \value Type The type of style option provided (\l{SH_Mask} for
+ this class).
+
+ The type is used internally by QStyleHintReturn, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleHintReturn subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleHintReturnMask::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleHintReturn subclass.
+
+ \value Version 1
+
+ The version is used by QStyleHintReturn subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \class QStyleHintReturnVariant
+ \brief The QStyleHintReturnVariant class provides style hints that return a QVariant.
+ \since 4.3
+ \ingroup appearance
+*/
+
+/*!
+ \variable QStyleHintReturnVariant::variant
+ \brief the variant for style hints that return a QVariant
+*/
+
+/*!
+ Constructs a QStyleHintReturnVariant. The member variables are
+ initialized to default values.
+*/
+QStyleHintReturnVariant::QStyleHintReturnVariant() : QStyleHintReturn(Version, Type)
+{
+}
+
+/*!
+ \enum QStyleHintReturnVariant::StyleOptionType
+
+ This enum is used to hold information about the type of the style option, and
+ is defined for each QStyleHintReturn subclass.
+
+ \value Type The type of style option provided (\l{SH_Variant} for
+ this class).
+
+ The type is used internally by QStyleHintReturn, its subclasses, and
+ qstyleoption_cast() to determine the type of style option. In
+ general you do not need to worry about this unless you want to
+ create your own QStyleHintReturn subclass and your own styles.
+
+ \sa StyleOptionVersion
+*/
+
+/*!
+ \enum QStyleHintReturnVariant::StyleOptionVersion
+
+ This enum is used to hold information about the version of the style option, and
+ is defined for each QStyleHintReturn subclass.
+
+ \value Version 1
+
+ The version is used by QStyleHintReturn subclasses to implement
+ extensions without breaking compatibility. If you use
+ qstyleoption_cast(), you normally do not need to check it.
+
+ \sa StyleOptionType
+*/
+
+/*!
+ \fn T qstyleoption_cast<T>(const QStyleHintReturn *hint)
+ \relates QStyleHintReturn
+
+ Returns a T or 0 depending on the \l{QStyleHintReturn::type}{type}
+ and \l{QStyleHintReturn::version}{version} of \a hint.
+
+ Example:
+
+ \snippet doc/src/snippets/code/src_gui_styles_qstyleoption.cpp 0
+
+ \sa QStyleHintReturn::type, QStyleHintReturn::version
+*/
+
+/*!
+ \fn T qstyleoption_cast<T>(QStyleHintReturn *hint)
+ \overload
+ \relates QStyleHintReturn
+
+ Returns a T or 0 depending on the type of \a hint.
+*/
+
+#if !defined(QT_NO_DEBUG) && !defined(QT_NO_DEBUG_STREAM)
+QDebug operator<<(QDebug debug, const QStyleOption::OptionType &optionType)
+{
+ switch (optionType) {
+ case QStyleOption::SO_Default:
+ debug << "SO_Default"; break;
+ case QStyleOption::SO_FocusRect:
+ debug << "SO_FocusRect"; break;
+ case QStyleOption::SO_Button:
+ debug << "SO_Button"; break;
+ case QStyleOption::SO_Tab:
+ debug << "SO_Tab"; break;
+ case QStyleOption::SO_MenuItem:
+ debug << "SO_MenuItem"; break;
+ case QStyleOption::SO_Frame:
+ debug << "SO_Frame"; break;
+ case QStyleOption::SO_ProgressBar:
+ debug << "SO_ProgressBar"; break;
+ case QStyleOption::SO_ToolBox:
+ debug << "SO_ToolBox"; break;
+ case QStyleOption::SO_Header:
+ debug << "SO_Header"; break;
+ case QStyleOption::SO_Q3DockWindow:
+ debug << "SO_Q3DockWindow"; break;
+ case QStyleOption::SO_DockWidget:
+ debug << "SO_DockWidget"; break;
+ case QStyleOption::SO_Q3ListViewItem:
+ debug << "SO_Q3ListViewItem"; break;
+ case QStyleOption::SO_ViewItem:
+ debug << "SO_ViewItem"; break;
+ case QStyleOption::SO_TabWidgetFrame:
+ debug << "SO_TabWidgetFrame"; break;
+ case QStyleOption::SO_TabBarBase:
+ debug << "SO_TabBarBase"; break;
+ case QStyleOption::SO_RubberBand:
+ debug << "SO_RubberBand"; break;
+ case QStyleOption::SO_Complex:
+ debug << "SO_Complex"; break;
+ case QStyleOption::SO_Slider:
+ debug << "SO_Slider"; break;
+ case QStyleOption::SO_SpinBox:
+ debug << "SO_SpinBox"; break;
+ case QStyleOption::SO_ToolButton:
+ debug << "SO_ToolButton"; break;
+ case QStyleOption::SO_ComboBox:
+ debug << "SO_ComboBox"; break;
+ case QStyleOption::SO_Q3ListView:
+ debug << "SO_Q3ListView"; break;
+ case QStyleOption::SO_TitleBar:
+ debug << "SO_TitleBar"; break;
+ case QStyleOption::SO_CustomBase:
+ debug << "SO_CustomBase"; break;
+ case QStyleOption::SO_GroupBox:
+ debug << "SO_GroupBox"; break;
+ case QStyleOption::SO_ToolBar:
+ debug << "SO_ToolBar"; break;
+ case QStyleOption::SO_ComplexCustomBase:
+ debug << "SO_ComplexCustomBase"; break;
+ case QStyleOption::SO_SizeGrip:
+ debug << "SO_SizeGrip"; break;
+ case QStyleOption::SO_GraphicsItem:
+ debug << "SO_GraphicsItem"; break;
+ }
+ return debug;
+}
+
+QDebug operator<<(QDebug debug, const QStyleOption &option)
+{
+ debug << "QStyleOption(";
+ debug << QStyleOption::OptionType(option.type);
+ debug << ',' << (option.direction == Qt::RightToLeft ? "RightToLeft" : "LeftToRight");
+ debug << ',' << option.state;
+ debug << ',' << option.rect;
+ debug << ')';
+ return debug;
+}
+#endif
+
+QT_END_NAMESPACE