summaryrefslogtreecommitdiffstats
path: root/src/corelib/global/qnamespace.qdoc
diff options
context:
space:
mode:
Diffstat (limited to 'src/corelib/global/qnamespace.qdoc')
-rw-r--r--src/corelib/global/qnamespace.qdoc2754
1 files changed, 2754 insertions, 0 deletions
diff --git a/src/corelib/global/qnamespace.qdoc b/src/corelib/global/qnamespace.qdoc
new file mode 100644
index 0000000..d1c16e5
--- /dev/null
+++ b/src/corelib/global/qnamespace.qdoc
@@ -0,0 +1,2754 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Nokia Corporation (qt-info@nokia.com)
+**
+** This file is part of the documentation 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 either Technology Preview License Agreement or the
+** Beta Release License Agreement.
+**
+** 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.0, included in the file LGPL_EXCEPTION.txt in this
+** package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file. Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+** If you are unsure which license is appropriate for your use, please
+** contact the sales department at http://qt.nokia.com/contact.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+ \namespace Qt
+ \inmodule QtCore
+
+ \brief The Qt namespace contains miscellaneous identifiers
+ used throughout the Qt library.
+*/
+
+/*!
+ \enum Qt::Orientation
+
+ This type is used to signify an object's orientation.
+
+ \value Horizontal
+ \value Vertical
+
+ Orientation is used with QScrollBar for example.
+*/
+
+/*!
+ \enum Qt::AlignmentFlag
+
+ This enum type is used to describe alignment. It contains
+ horizontal and vertical flags that can be combined to produce
+ the required effect.
+
+ The \l{TextElideMode} enum can also be used in many situations
+ to fine-tune the appearance of aligned text.
+
+ The horizontal flags are:
+
+ \value AlignLeft Aligns with the left edge.
+ \value AlignRight Aligns with the right edge.
+ \value AlignHCenter Centers horizontally in the available space.
+ \value AlignJustify Justifies the text in the available space.
+ \omitvalue AlignAuto
+
+ The vertical flags are:
+
+ \value AlignTop Aligns with the top.
+ \value AlignBottom Aligns with the bottom.
+ \value AlignVCenter Centers vertically in the available space.
+
+ You can use only one of the horizontal flags at a time. There is
+ one two-dimensional flag:
+
+ \value AlignCenter Centers in both dimensions.
+
+ You can use at most one horizontal and one vertical flag at a
+ time. Qt::AlignCenter counts as both horizontal and vertical.
+
+ Three enum values are useful in applications that can be run in
+ right-to-left mode:
+
+ \value AlignAbsolute If the widget's layout direction is
+ Qt::RightToLeft (instead of Qt::LeftToRight, the default),
+ Qt::AlignLeft refers to the \e right edge and Qt::AlignRight
+ to the \e left edge. This is normally the desired behavior.
+ If you want Qt::AlignLeft to always mean "left" and
+ Qt::AlignRight to always mean "right", combine the flag with
+ Qt::AlignAbsolute.
+ \value AlignLeading Synonym for Qt::AlignLeft.
+ \value AlignTrailing Synonym for Qt::AlignRight.
+
+ Masks:
+
+ \value AlignHorizontal_Mask
+ \value AlignVertical_Mask
+
+ Conflicting combinations of flags have undefined meanings.
+*/
+
+/*!
+ \enum Qt::ApplicationAttribute
+
+ This enum describes attributes that change the behavior of
+ application-wide features. These are enabled and disabled using
+ QCoreApplication::setAttribute(), and can be tested for with
+ QCoreApplication::testAttribute().
+
+ \value AA_ImmediateWidgetCreation Ensures that widgets are created
+ as soon as they are constructed. By default, resources for
+ widgets are allocated on demand to improve efficiency and
+ minimize resource usage. Setting or clearing this attribute
+ affects widgets constructed after the change. Setting it
+ tells Qt to create toplevel windows immediately.
+ Therefore, if it is important to minimize resource
+ consumption, do not set this attribute.
+
+ \value AA_MSWindowsUseDirect3DByDefault This value is obsolete and
+ has no effect.
+
+ \value AA_DontShowIconsInMenus Actions with the Icon property won't be
+ shown in any menus unless specifically set by the
+ QAction::iconVisibleInMenu property.
+
+ Menus that are currently open or menus already created in the native
+ Mac OS X menubar \e{may not} pick up a change in this attribute. Changes
+ in the QAction::iconVisibleInMenu property will always be picked up.
+
+ \value AA_NativeWindows Ensures that widgets have native windows.
+
+ \value AA_DontCreateNativeWidgetSiblings Ensures that siblings of native
+ widgets stay non-native unless specifically set by the
+ Qt::WA_NativeWindow attribute.
+
+ \value AA_MacPluginApplication Stops the Qt mac application from doing
+ specific initializations that do not necessarily make sense when using Qt
+ to author a plugin. This includes avoiding loading our nib for the main
+ menu and not taking possession of the native menu bar. When setting this
+ attribute to true will also set the AA_DontUseNativeMenuBar attribute
+ to true.
+
+ \value AA_DontUseNativeMenuBar All menubars created while this attribute is
+ set to true won't be used as a native menubar (e.g, the menubar at
+ the top of the main screen on Mac OS X or at the bottom in Windows CE).
+
+ \value AA_MacDontSwapCtrlAndMeta On Mac OS X by default, Qt swaps the
+ Control and Meta (Command) keys (i.e., whenever Control is pressed, Qt
+ sends Meta and whenever Meta is pressed Control is sent. When this
+ attribute is true, Qt will not do the flip. QKeySequence::StandardShortcuts
+ will also flip accordingly (i.e., QKeySequence::Copy will be
+ Command+C on the keyboard regardless of the value set, though what is output for
+ QKeySequence::toString(QKeySequence::PortableText) will be different).
+
+ \omitvalue AA_AttributeCount
+*/
+
+/*!
+ \enum Qt::MouseButton
+
+ This enum type describes the different mouse buttons.
+
+ \value NoButton The button state does not refer to any
+ button (see QMouseEvent::button()).
+ \value LeftButton The left button is pressed, or an event refers
+ to the left button. (The left button may be the right button on
+ left-handed mice.)
+ \value RightButton The right button.
+ \value MidButton The middle button.
+ \value XButton1 The first X button.
+ \value XButton2 The second X button.
+
+ \omitvalue MouseButtonMask
+
+ \sa KeyboardModifier Modifier
+*/
+
+/*!
+ \enum Qt::KeyboardModifier
+
+ This enum describes the modifier keys.
+
+ \value NoModifier No modifier key is pressed.
+ \value ShiftModifier A Shift key on the keyboard is pressed.
+ \value ControlModifier A Ctrl key on the keyboard is pressed.
+ \value AltModifier An Alt key on the keyboard is pressed.
+ \value MetaModifier A Meta key on the keyboard is pressed.
+ \value KeypadModifier A keypad button is pressed.
+ \value GroupSwitchModifier X11 only. A Mode_switch key on the keyboard is pressed.
+
+ \omitvalue KeyboardModifierMask
+
+ \note On Mac OS X, the \c ControlModifier value corresponds to
+ the Command keys on the Macintosh keyboard, and the \c MetaModifier value
+ corresponds to the Control keys. The \c KeypadModifier value will also be set
+ when an arrow key is pressed as the arrow keys are considered part of the
+ keypad.
+
+ \note On Windows Keyboards, Qt::MetaModifier and Qt::Key_Meta are mapped
+ to the Windows key.
+
+ \sa MouseButton Modifier
+*/
+
+/*!
+ \enum Qt::Modifier
+
+ This enum provides shorter names for the keyboard modifier keys
+ supported by Qt.
+
+ \bold{Note:} On Mac OS X, the \c CTRL value corresponds to
+ the Command keys on the Macintosh keyboard, and the \c META value
+ corresponds to the Control keys.
+
+ \value SHIFT The Shift keys provided on all standard keyboards.
+ \value META The Meta keys.
+ \value CTRL The Ctrl keys.
+ \value ALT The normal Alt keys, but not keys like AltGr.
+ \value UNICODE_ACCEL The shortcut is specified as a Unicode code
+ point, not as a Qt Key.
+ \omitvalue MODIFIER_MASK
+
+ \sa KeyboardModifier MouseButton
+*/
+
+/*!
+ \enum Qt::GlobalColor
+
+ \raw HTML
+ <style type="text/css" id="colorstyles">
+ #white { background-color: #ffffff; color: #000000 }
+ #black { background-color: #000000; color: #ffffff }
+ #red { background-color: #ff0000; color: #000000 }
+ #darkRed { background-color: #800000; color: #ffffff }
+ #green { background-color: #00ff00; color: #000000 }
+ #darkGreen { background-color: #008000; color: #ffffff }
+ #blue { background-color: #0000ff; color: #ffffff }
+ #darkBlue { background-color: #000080; color: #ffffff }
+ #cyan { background-color: #00ffff; color: #000000 }
+ #darkCyan { background-color: #008080; color: #ffffff }
+ #magenta { background-color: #ff00ff; color: #000000 }
+ #darkMagenta { background-color: #800080; color: #ffffff }
+ #yellow { background-color: #ffff00; color: #000000 }
+ #darkYellow { background-color: #808000; color: #ffffff }
+ #gray { background-color: #a0a0a4; color: #000000 }
+ #darkGray { background-color: #808080; color: #ffffff }
+ #lightGray { background-color: #c0c0c0; color: #000000 }
+ </style>
+ \endraw
+
+ Qt's predefined QColor objects:
+
+ \value white \raw HTML
+ White <tt id="white">(#ffffff)</tt>
+ \endraw
+ \value black \raw HTML
+ Black <tt id="black">(#000000)</tt>
+ \endraw
+ \value red \raw HTML
+ Red <tt id="red">(#ff0000)</tt>
+ \endraw
+ \value darkRed \raw HTML
+ Dark red <tt id="darkRed">(#800000)</tt>
+ \endraw
+ \value green \raw HTML
+ Green <tt id="green">(#00ff00)</tt>
+ \endraw
+ \value darkGreen \raw HTML
+ Dark green <tt id="darkGreen">(#008000)</tt>
+ \endraw
+ \value blue \raw HTML
+ Blue <tt id="blue">(#0000ff)</tt>
+ \endraw
+ \value darkBlue \raw HTML
+ Dark blue <tt id="darkBlue">(#000080)</tt>
+ \endraw
+ \value cyan \raw HTML
+ Cyan <tt id="cyan">(#00ffff)</tt>
+ \endraw
+ \value darkCyan \raw HTML
+ Dark cyan <tt id="darkCyan">(#008080)</tt>
+ \endraw
+ \value magenta \raw HTML
+ Magenta <tt id="magenta">(#ff00ff)</tt>
+ \endraw
+ \value darkMagenta \raw HTML
+ Dark magenta <tt id="darkMagenta">(#800080)</tt>
+ \endraw
+ \value yellow \raw HTML
+ Yellow <tt id="yellow">(#ffff00)</tt>
+ \endraw
+ \value darkYellow \raw HTML
+ Dark yellow <tt id="darkYellow">(#808000)</tt>
+ \endraw
+ \value gray \raw HTML
+ Gray <tt id="gray">(#a0a0a4)</tt>
+ \endraw
+ \value darkGray \raw HTML
+ Dark gray <tt id="darkGray">(#808080)</tt>
+ \endraw
+ \value lightGray \raw HTML
+ Light gray <tt id="lightGray">(#c0c0c0)</tt>
+ \endraw
+ \value transparent a transparent black value (i.e., QColor(0, 0, 0, 0))
+ \value color0 0 pixel value (for bitmaps)
+ \value color1 1 pixel value (for bitmaps)
+
+ \sa QColor
+
+*/
+
+/*!
+ \enum Qt::PenStyle
+
+ This enum type defines the pen styles that can be drawn using
+ QPainter. The styles are:
+
+ \table
+ \row
+ \o \inlineimage qpen-solid.png
+ \o \inlineimage qpen-dash.png
+ \o \inlineimage qpen-dot.png
+ \row
+ \o Qt::SolidLine
+ \o Qt::DashLine
+ \o Qt::DotLine
+ \row
+ \o \inlineimage qpen-dashdot.png
+ \o \inlineimage qpen-dashdotdot.png
+ \o \inlineimage qpen-custom.png
+ \row
+ \o Qt::DashDotLine
+ \o Qt::DashDotDotLine
+ \o Qt::CustomDashLine
+ \endtable
+
+ \value NoPen no line at all. For example, QPainter::drawRect()
+ fills but does not draw any boundary line.
+
+ \value SolidLine A plain line.
+ \value DashLine Dashes separated by a few pixels.
+ \value DotLine Dots separated by a few pixels.
+ \value DashDotLine Alternate dots and dashes.
+ \value DashDotDotLine One dash, two dots, one dash, two dots.
+ \value CustomDashLine A custom pattern defined using
+ QPainterPathStroker::setDashPattern().
+
+ \omitvalue MPenStyle
+
+ \sa QPen
+*/
+
+/*!
+ \enum Qt::PenCapStyle
+
+ This enum type defines the pen cap styles supported by Qt, i.e.
+ the line end caps that can be drawn using QPainter.
+
+ \table
+ \row
+ \o \inlineimage qpen-square.png
+ \o \inlineimage qpen-flat.png
+ \o \inlineimage qpen-roundcap.png
+ \row
+ \o Qt::SquareCap
+ \o Qt::FlatCap
+ \o Qt::RoundCap
+ \endtable
+
+ \value FlatCap a square line end that does not cover the end
+ point of the line.
+ \value SquareCap a square line end that covers the end point and
+ extends beyond it by half the line width.
+ \value RoundCap a rounded line end.
+ \omitvalue MPenCapStyle
+
+ \sa QPen
+*/
+
+/*!
+ \enum Qt::PenJoinStyle
+
+ This enum type defines the pen join styles supported by Qt, i.e.
+ which joins between two connected lines can be drawn using
+ QPainter.
+
+ \table
+ \row
+ \o \inlineimage qpen-bevel.png
+ \o \inlineimage qpen-miter.png
+ \o \inlineimage qpen-roundjoin.png
+ \row
+ \o Qt::BevelJoin
+ \o Qt::MiterJoin
+ \o Qt::RoundJoin
+ \endtable
+
+ \value MiterJoin The outer edges of the lines are extended to
+ meet at an angle, and this area is filled.
+ \value BevelJoin The triangular notch between the two lines is filled.
+ \value RoundJoin A circular arc between the two lines is filled.
+ \value SvgMiterJoin A miter join corresponding to the definition of
+ a miter join in the \l{SVG 1.2 Tiny} specification.
+ \omitvalue MPenJoinStyle
+
+ \sa QPen
+*/
+
+/*!
+ \enum Qt::BrushStyle
+
+ This enum type defines the brush styles supported by Qt, i.e. the
+ fill pattern of shapes drawn using QPainter.
+
+ \image brush-styles.png Brush Styles
+
+ \value NoBrush No brush pattern.
+ \value SolidPattern Uniform color.
+ \value Dense1Pattern Extremely dense brush pattern.
+ \value Dense2Pattern Very dense brush pattern.
+ \value Dense3Pattern Somewhat dense brush pattern.
+ \value Dense4Pattern Half dense brush pattern.
+ \value Dense5Pattern Somewhat sparse brush pattern.
+ \value Dense6Pattern Very sparse brush pattern.
+ \value Dense7Pattern Extremely sparse brush pattern.
+ \value HorPattern Horizontal lines.
+ \value VerPattern Vertical lines.
+ \value CrossPattern Crossing horizontal and vertical lines.
+ \value BDiagPattern Backward diagonal lines.
+ \value FDiagPattern Forward diagonal lines.
+ \value DiagCrossPattern Crossing diagonal lines.
+ \value LinearGradientPattern Linear gradient (set using a dedicated QBrush constructor).
+ \value ConicalGradientPattern Conical gradient (set using a dedicated QBrush constructor).
+ \value RadialGradientPattern Radial gradient (set using a dedicated QBrush constructor).
+ \value TexturePattern Custom pattern (see QBrush::setTexture()).
+
+ \omitvalue CustomPattern
+
+ \sa QBrush
+*/
+
+/*!
+ \enum Qt::TextFlag
+
+ This enum type is used to define some modifier flags. Some of
+ these flags only make sense in the context of printing:
+
+ \value TextSingleLine Treats all whitespace as spaces and prints just
+ one line.
+ \value TextDontClip If it's impossible to stay within the given bounds,
+ it prints outside.
+ \value TextExpandTabs Makes the U+0009 (ASCII tab) character move to
+ the next tab stop.
+ \value TextShowMnemonic Displays the string "\&P" as \underline{P}
+ (see QButton for an example). For an ampersand, use "\&\&".
+ \value TextWordWrap Breaks lines at appropriate points, e.g. at word
+ boundaries.
+ \value TextWrapAnywhere Breaks lines anywhere, even within words.
+ \value TextHideMnemonic Same as Qt::TextShowMnemonic but doesn't draw the underlines.
+ \value TextDontPrint Treat this text as "hidden" and don't print
+ it.
+ \value IncludeTrailingSpaces When this option is set, QTextLine::naturalTextWidth() and naturalTextRect() will
+ return a value that includes the width of trailing spaces in the text; otherwise
+ this width is excluded.
+ \value TextIncludeTrailingSpaces Same as IncludeTrailingSpaces
+ \value TextJustificationForced Ensures that text lines are justified.
+
+ \omitvalue BreakAnywhere
+ \omitvalue DontClip
+ \omitvalue DontPrint
+ \omitvalue ExpandTabs
+ \omitvalue IncludeTrailingSpaces
+ \omitvalue NoAccel
+ \omitvalue ShowPrefix
+ \omitvalue SingleLine
+ \omitvalue WordBreak
+ \omitvalue TextForceLeftToRight
+ \omitvalue TextForceRightToLeft
+ \omitvalue TextLongestVariant Always use the longest variant when computing the size of a multi-variant string
+
+ You can use as many modifier flags as you want, except that
+ Qt::TextSingleLine and Qt::TextWordWrap cannot be combined.
+
+ Flags that are inappropriate for a given use are generally
+ ignored.
+*/
+
+/*!
+ \enum Qt::BGMode
+
+ Background mode:
+
+ \value TransparentMode
+ \value OpaqueMode
+*/
+
+/*!
+ \enum Qt::ConnectionType
+
+ This enum describes the types of connection that can be used between signals and
+ slots. In particular, it determines whether a particular signal is delivered to a
+ slot immediately or queued for delivery at a later time.
+
+ \value DirectConnection When emitted, the signal is immediately delivered to the slot.
+ \value QueuedConnection When emitted, the signal is queued until the event loop is
+ able to deliver it to the slot.
+ \value BlockingQueuedConnection
+ Same as QueuedConnection, except that the current thread blocks
+ until the slot has been delivered. This connection type should
+ only be used for receivers in a different thread. Note that misuse
+ of this type can lead to deadlocks in your application.
+ \value AutoConnection If the signal is emitted from the thread
+ in which the receiving object lives, the
+ slot is invoked directly, as with
+ Qt::DirectConnection; otherwise the
+ signal is queued, as with
+ Qt::QueuedConnection.
+ \value UniqueConnection Same as AutoConnection, but there will be a check that the signal is
+ not already connected to the same slot before connecting, otherwise,
+ the connection will fail.
+ This value was introduced in Qt 4.6.
+ \value AutoCompatConnection
+ The default connection type for signals and slots when Qt 3 support
+ is enabled. Equivalent to AutoConnection for connections but will cause warnings
+ to be output under certain circumstances. See
+ \l{Porting to Qt 4#Compatibility Signals and Slots}{Compatibility Signals and Slots}
+ for further information.
+
+ With queued connections, the parameters must be of types that are known to
+ Qt's meta-object system, because Qt needs to copy the arguments to store them
+ in an event behind the scenes. If you try to use a queued connection and
+ get the error message
+
+ \snippet doc/src/snippets/code/doc_src_qnamespace.qdoc 0
+
+ call qRegisterMetaType() to register the data type before you
+ establish the connection.
+
+ \sa {Thread Support in Qt}, QObject::connect(), qRegisterMetaType()
+*/
+
+/*!
+ \enum Qt::DateFormat
+
+ \value TextDate The default Qt format, which includes the day and month name,
+ the day number in the month, and the year in full. The day and month names will
+ be short, localized names. This is basically equivalent to using the date format
+ string, "ddd MMM d yyyy". See QDate::toString() for more information.
+
+ \value ISODate ISO 8601 extended format: either \c{YYYY-MM-DD} for dates or
+ \c{YYYY-MM-DDTHH:MM:SS} for combined dates and times.
+
+ \value SystemLocaleShortDate The \l{QLocale::ShortFormat}{short format} used
+ by the \l{QLocale::system()}{operating system}.
+
+ \value SystemLocaleLongDate The \l{QLocale::LongFormat}{long format} used
+ by the \l{QLocale::system()}{operating system}.
+
+ \value DefaultLocaleShortDate The \l{QLocale::ShortFormat}{short format} specified
+ by the \l{QLocale::setDefault()}{application's locale}.
+
+ \value DefaultLocaleLongDate The \l{QLocale::LongFormat}{long format} used
+ by the \l{QLocale::setDefault()}{application's locale}.
+
+ \value SystemLocaleDate \e{This enum value is deprecated.} Use Qt::SystemLocaleShortDate
+ instead (or Qt::SystemLocaleLongDate if you want long dates).
+
+ \value LocaleDate \e{This enum value is deprecated.} Use Qt::DefaultLocaleShortDate
+ instead (or Qt::DefaultLocaleLongDate if you want long dates).
+
+ \value LocalDate \e{This enum value is deprecated.} Use Qt::SystemLocaleShortDate
+ instead (or Qt::SystemLocaleLongDate if you want long dates).
+
+ \note For \c ISODate formats, each \c Y, \c M and \c D represents a single digit
+ of the year, month and day used to specify the date. Each \c H, \c M and \c S
+ represents a single digit of the hour, minute and second used to specify the time.
+ The presence of a literal \c T character is used to separate the date and time when
+ both are specified.
+*/
+
+
+/*!
+ \enum Qt::TimeSpec
+
+ \value LocalTime Locale dependent time (Timezones and Daylight Savings Time).
+ \value UTC Coordinated Universal Time, replaces Greenwich Mean Time.
+ \value OffsetFromUTC An offset in seconds from Coordinated Universal Time.
+*/
+
+/*!
+ \enum Qt::DayOfWeek
+
+ \value Monday
+ \value Tuesday
+ \value Wednesday
+ \value Thursday
+ \value Friday
+ \value Saturday
+ \value Sunday
+*/
+
+/*!
+ \enum Qt::CaseSensitivity
+
+ \value CaseInsensitive
+ \value CaseSensitive
+*/
+
+/*!
+ \enum Qt::ToolBarArea
+
+ \value LeftToolBarArea
+ \value RightToolBarArea
+ \value TopToolBarArea
+ \value BottomToolBarArea
+ \value AllToolBarAreas
+ \value NoToolBarArea
+
+ \omitvalue ToolBarArea_Mask
+*/
+
+/*!
+ \enum Qt::DockWidgetArea
+
+ \value LeftDockWidgetArea
+ \value RightDockWidgetArea
+ \value TopDockWidgetArea
+ \value BottomDockWidgetArea
+ \value AllDockWidgetAreas
+ \value NoDockWidgetArea
+
+ \omitvalue DockWidgetArea_Mask
+*/
+
+/*!
+ \enum Qt::BackgroundMode
+
+ \compat
+
+ \value FixedColor
+ \value FixedPixmap
+ \value NoBackground
+ \value PaletteForeground
+ \value PaletteButton
+ \value PaletteLight
+ \value PaletteMidlight
+ \value PaletteDark
+ \value PaletteMid
+ \value PaletteText
+ \value PaletteBrightText
+ \value PaletteBase
+ \value PaletteBackground
+ \value PaletteShadow
+ \value PaletteHighlight
+ \value PaletteHighlightedText
+ \value PaletteButtonText
+ \value PaletteLink
+ \value PaletteLinkVisited
+ \value X11ParentRelative
+*/
+
+/*!
+ \enum Qt::ImageConversionFlag
+
+ The options marked "(default)" are set if no other values from
+ the list are included (since the defaults are zero):
+
+ Color/Mono preference (ignored for QBitmap):
+
+ \value AutoColor (default) - If the image has \link
+ QImage::depth() depth\endlink 1 and contains only
+ black and white pixels, the pixmap becomes monochrome.
+ \value ColorOnly The pixmap is dithered/converted to the
+ \link QPixmap::defaultDepth() native display depth\endlink.
+ \value MonoOnly The pixmap becomes monochrome. If necessary,
+ it is dithered using the chosen dithering algorithm.
+
+ Dithering mode preference for RGB channels:
+
+ \value DiffuseDither (default) - A high-quality dither.
+ \value OrderedDither A faster, more ordered dither.
+ \value ThresholdDither No dithering; closest color is used.
+
+ Dithering mode preference for alpha channel:
+
+ \value ThresholdAlphaDither (default) - No dithering.
+ \value OrderedAlphaDither A faster, more ordered dither.
+ \value DiffuseAlphaDither A high-quality dither.
+ \omitvalue NoAlpha
+
+ Color matching versus dithering preference:
+
+ \value PreferDither (default when converting to a pixmap) - Always dither
+ 32-bit images when the image is converted to 8 bits.
+ \value AvoidDither (default when converting for the purpose of saving to
+ file) - Dither 32-bit images only if the image has more than 256
+ colors and it is being converted to 8 bits.
+ \omitvalue AutoDither
+
+ \omitvalue ColorMode_Mask
+ \omitvalue Dither_Mask
+ \omitvalue AlphaDither_Mask
+ \omitvalue DitherMode_Mask
+ \omitvalue NoOpaqueDetection
+*/
+
+/*! \enum Qt::GUIStyle
+
+ \compat
+
+ \value WindowsStyle
+ \value MotifStyle
+ \value MacStyle
+ \value Win3Style
+ \value PMStyle
+*/
+
+/*!
+ \enum Qt::UIEffect
+
+ This enum describes the available UI effects.
+
+ By default, Qt will try to use the platform specific desktop
+ settings for each effect. Use the
+ QApplication::setDesktopSettingsAware() function (passing \c false
+ as argument) to prevent this, and the
+ QApplication::setEffectEnabled() to enable or disable a particular
+ effect.
+
+ Note that all effects are disabled on screens running at less than
+ 16-bit color depth.
+
+ \omitvalue UI_General
+
+ \value UI_AnimateMenu Show animated menus.
+ \value UI_FadeMenu Show faded menus.
+ \value UI_AnimateCombo Show animated comboboxes.
+ \value UI_AnimateTooltip Show tooltip animations.
+ \value UI_FadeTooltip Show tooltip fading effects.
+ \value UI_AnimateToolBox Reserved
+
+ \sa QApplication::setEffectEnabled(), QApplication::setDesktopSettingsAware()
+*/
+
+/*! \enum Qt::AspectRatioMode
+
+ This enum type defines what happens to the aspect ratio when
+ scaling an rectangle.
+
+ \image qimage-scaling.png
+
+ \value IgnoreAspectRatio The size is scaled freely. The aspect
+ ratio is not preserved.
+ \value KeepAspectRatio The size is scaled to a rectangle as
+ large as possible inside a given
+ rectangle, preserving the aspect ratio.
+ \value KeepAspectRatioByExpanding The size is scaled to a
+ rectangle as small as possible
+ outside a given rectangle,
+ preserving the aspect ratio.
+
+ \omitvalue ScaleFree
+ \omitvalue ScaleMin
+ \omitvalue ScaleMax
+
+ \sa QSize::scale(), QImage::scaled()
+*/
+
+/*! \typedef Qt::ScaleMode
+ \compat
+
+ Use Qt::AspectRatioMode instead.
+
+ The enum values have been renamed as follows:
+
+ \table
+ \row \i Old enum value \i New enum value
+ \row \i Qt::ScaleFree \i Qt::IgnoreAspectRatio
+ \row \i Qt::ScaleMin \i Qt::KeepAspectRatio
+ \row \i Qt::ScaleMax \i Qt::KeepAspectRatioByExpanding
+ \endtable
+*/
+
+/*! \enum Qt::TransformationMode
+
+ This enum type defines whether image transformations (e.g.,
+ scaling) should be smooth or not.
+
+ \value FastTransformation The transformation is performed
+ quickly, with no smoothing.
+ \value SmoothTransformation The resulting image is transformed
+ using bilinear filtering.
+
+ \sa QImage::scaled()
+*/
+
+/*! \enum Qt::Axis
+
+ This enum type defines three values to represent the three
+ axes in the cartesian coordinate system.
+
+ \value XAxis The X axis.
+ \value YAxis The Y axis.
+ \value ZAxis The Z axis.
+
+ \sa QTransform::rotate(), QTransform::rotateRadians()
+ */
+
+/*!
+ \enum Qt::WidgetAttribute
+
+ \keyword widget attributes
+
+ This enum type is used to specify various widget attributes.
+ Attributes are set and cleared with QWidget::setAttribute(), and
+ queried with QWidget::testAttribute(), although some have special
+ convenience functions which are mentioned below.
+
+ \value WA_AcceptDrops Allows data from drag and drop operations
+ to be dropped onto the widget (see QWidget::setAcceptDrops()).
+
+ \value WA_AlwaysShowToolTips Enables tooltips for inactive windows.
+
+ \value WA_ContentsPropagated This flag is superfluous and
+ obsolete; it no longer has any effect. Since Qt 4.1, all widgets
+ that do not set WA_PaintOnScreen propagate their contents.
+
+ \value WA_CustomWhatsThis Indicates that the widget wants to
+ continue operating normally in "What's This?" mode. This is set by the
+ widget's author.
+
+ \value WA_DeleteOnClose Makes Qt delete this widget when the
+ widget has accepted the close event (see QWidget::closeEvent()).
+
+ \value WA_Disabled Indicates that the widget is disabled, i.e.
+ it does not receive any mouse or keyboard events. There is also a
+ getter functions QWidget::isEnabled(). This is set/cleared by the
+ Qt kernel.
+
+ \omitvalue WA_DropSiteRegistered
+ \omitvalue WA_ForceAcceptDrops
+
+ \value WA_ForceDisabled Indicates that the widget is
+ explicitly disabled, i.e. it will remain disabled even when all
+ its ancestors are set to the enabled state. This implies
+ WA_Disabled. This is set/cleared by QWidget::setEnabled() and
+ QWidget::setDisabled().
+
+ \value WA_ForceUpdatesDisabled Indicates that updates are
+ explicitly disabled for the widget; i.e. it will remain disabled
+ even when all its ancestors are set to the updates-enabled state.
+ This implies WA_UpdatesDisabled. This is set/cleared by
+ QWidget::setUpdatesEnabled().
+
+ \value WA_GroupLeader
+ \e{This attribute has been deprecated.} Use QWidget::windowModality
+ instead.
+
+ \value WA_Hover Forces Qt to generate paint events when the mouse
+ enters or leaves the widget. This feature is typically used when
+ implementing custom styles; see the \l{widgets/styles}{Styles}
+ example for details.
+
+ \value WA_InputMethodEnabled Enables input methods for Asian languages.
+ Must be set when creating custom text editing widgets.
+ On Windows CE this flag can be used in addition to
+ QApplication::autoSipEnabled to automatically display the SIP when
+ entering a widget.
+
+ \value WA_KeyboardFocusChange Set on a toplevel window when
+ the users changes focus with the keyboard (tab, backtab, or shortcut).
+
+ \value WA_KeyCompression Enables key event compression if set,
+ and disables it if not set. By default key compression is off, so
+ widgets receive one key press event for each key press (or more,
+ since autorepeat is usually on). If you turn it on and your
+ program doesn't keep up with key input, Qt may try to compress key
+ events so that more than one character can be processed in each
+ event.
+ For example, a word processor widget might receive 2, 3 or more
+ characters in each QKeyEvent::text(), if the layout recalculation
+ takes too long for the CPU.
+ If a widget supports multiple character unicode input, it is
+ always safe to turn the compression on.
+ Qt performs key event compression only for printable characters.
+ Qt::Modifier keys, cursor movement keys, function keys and
+ miscellaneous action keys (e.g. Escape, Enter, Backspace,
+ PrintScreen) will stop key event compression, even if there are
+ more compressible key events available.
+ Platforms other than Mac and X11 do not support this compression,
+ in which case turning it on will have no effect.
+ This is set/cleared by the widget's author.
+
+ \value WA_LayoutOnEntireRect Indicates that the widget
+ wants QLayout to operate on the entire QWidget::rect(), not only
+ on QWidget::contentsRect(). This is set by the widget's author.
+
+ \value WA_LayoutUsesWidgetRect Ignore the layout item rect from the style
+ when laying out this widget with QLayout. This makes a difference in
+ QMacStyle and QPlastiqueStyle for some widgets.
+
+ \value WA_MacNoClickThrough When a widget that has this attribute set
+ is clicked, and its window is inactive, the click will make the window
+ active but won't be seen by the widget. Typical use of this attribute
+ is on widgets with "destructive" actions, such as a "Delete" button.
+ WA_MacNoClickThrough also applies to all child widgets of the widget
+ that has it set.
+
+ \value WA_MacOpaqueSizeGrip Indicates that the native Carbon size grip
+ should be opaque instead of transparent (the default). This attribute
+ is only applicable to Mac OS X and is set by the widget's author.
+
+ \value WA_MacShowFocusRect Indicates that this widget should get a
+ QFocusFrame around it. Some widgets draw their own focus halo
+ regardless of this attribute. Not that the QWidget::focusPolicy
+ also plays the main role in whether something is given focus or
+ not, this only controls whether or not this gets the focus
+ frame. This attribute is only applicable to Mac OS X.
+
+ \value WA_MacNormalSize Indicates the widget should have the
+ normal size for widgets in Mac OS X. This attribute is only
+ applicable to Mac OS X.
+
+ \value WA_MacSmallSize Indicates the widget should have the small
+ size for widgets in Mac OS X. This attribute is only applicable to
+ Mac OS X.
+
+ \value WA_MacMiniSize Indicates the widget should have the mini
+ size for widgets in Mac OS X. This attribute is only applicable to
+ Mac OS X.
+
+ \value WA_MacVariableSize Indicates the widget can choose between
+ alternative sizes for widgets to avoid clipping.
+ This attribute is only applicable to Mac OS X.
+
+ \value WA_MacBrushedMetal Indicates the widget should be drawn in
+ the brushed metal style as supported by the windowing system. This
+ attribute is only applicable to Mac OS X.
+
+ \omitvalue WA_MacMetalStyle
+
+ \value WA_Mapped Indicates that the widget is mapped on screen.
+ This is set/cleared by the Qt kernel.
+
+ \value WA_MouseNoMask Makes the widget receive mouse events for
+ the entire widget regardless of the currently set mask,
+ overriding QWidget::setMask(). This is not applicable for
+ top-level windows.
+
+ \value WA_MouseTracking Indicates that the widget has mouse
+ tracking enabled. See QWidget::mouseTracking.
+
+ \value WA_Moved Indicates that the widget has an explicit
+ position. This is set/cleared by QWidget::move() and
+ by QWidget::setGeometry().
+
+ \value WA_MSWindowsUseDirect3D This value is obsolete and has no
+ effect.
+
+ \value WA_NoBackground This value is obsolete. Use
+ WA_OpaquePaintEvent instead.
+
+ \value WA_NoChildEventsForParent Indicates that the widget does
+ not want ChildAdded or ChildRemoved events sent to its
+ parent. This is rarely necessary but can help to avoid automatic
+ insertion widgets like splitters and layouts. This is set by a
+ widget's author.
+
+ \value WA_NoChildEventsFromChildren Indicates that the widget does
+ not want to receive ChildAdded or ChildRemoved events sent from its
+ children. This is set by a widget's author.
+
+ \value WA_NoMouseReplay Used for pop-up widgets. Indicates that the most
+ recent mouse press event should not be replayed when the pop-up widget
+ closes. The flag is set by the widget's author and cleared by the Qt kernel
+ every time the widget receives a new mouse event.
+
+ \value WA_NoMousePropagation Prohibits mouse events from being propagated
+ to the widget's parent. This attribute is disabled by default.
+
+ \value WA_TransparentForMouseEvents When enabled, this attribute disables
+ the delivery of mouse events to the widget and its children. Mouse events
+ are delivered to other widgets as if the widget and its children were not
+ present in the widget hierarchy; mouse clicks and other events effectively
+ "pass through" them. This attribute is disabled by default.
+
+ \value WA_NoSystemBackground Indicates that the widget has no background,
+ i.e. when the widget receives paint events, the background is not
+ automatically repainted. \note Unlike WA_OpaquePaintEvent, newly exposed
+ areas are \bold never filled with the background (e.g., after showing a
+ window for the first time the user can see "through" it until the
+ application processes the paint events). This flag is set or cleared by the
+ widget's author.
+
+ \value WA_OpaquePaintEvent Indicates that the widget paints all its pixels
+ when it receives a paint event. Thus, it is not required for operations
+ like updating, resizing, scrolling and focus changes to erase the widget
+ before generating paint events. The use of WA_OpaquePaintEvent provides a
+ small optimization by helping to reduce flicker on systems that do not
+ support double buffering and avoiding computational cycles necessary to
+ erase the background prior to painting. \note Unlike
+ WA_NoSystemBackground, WA_OpaquePaintEvent makes an effort to avoid
+ transparent window backgrounds. This flag is set or cleared by the widget's
+ author.
+
+ \value WA_OutsideWSRange Indicates that the widget is outside
+ the valid range of the window system's coordinate system. A widget
+ outside the valid range cannot be mapped on screen. This is
+ set/cleared by the Qt kernel.
+
+ \value WA_PaintOnScreen Indicates that the widget wants to draw directly
+ onto the screen. Widgets with this attribute set do not participate in
+ composition management, i.e. they cannot be semi-transparent or shine
+ through semi-transparent overlapping widgets. \note This flag is only
+ supported on X11 and it disables double buffering. On Qt for Embedded
+ Linux, the flag only works when set on a top-level widget and it relies on
+ support from the active screen driver. This flag is set or cleared by the
+ widget's author. To render outside of Qt's paint system, e.g., if you
+ require native painting primitives, you need to reimplement
+ QWidget::paintEngine() to return 0 and set this flag.
+
+ \value WA_PaintOutsidePaintEvent Makes it possible to use QPainter to
+ paint on the widget outside \l{QWidget::paintEvent()}{paintEvent()}. This
+ flag is not supported on Windows, Mac OS X or Embedded Linux. We recommend
+ that you use it only when porting Qt 3 code to Qt 4.
+
+ \value WA_PaintUnclipped Makes all painters operating on this widget
+ unclipped. Children of this widget or other widgets in front of it do not
+ clip the area the painter can paint on. This flag is only supported for
+ widgets with the WA_PaintOnScreen flag set. The preferred way to do this in
+ a cross platform way is to create a transparent widget that lies in front
+ of the other widgets.
+
+ \value WA_PendingMoveEvent Indicates that a move event is pending, e.g.,
+ when a hidden widget was moved. This flag is set or cleared by the Qt
+ kernel.
+
+ \value WA_PendingResizeEvent Indicates that a resize event is pending,
+ e.g., when a hidden widget was resized. This flag is set or cleared by the
+ Qt kernel.
+
+ \value WA_QuitOnClose Makes Qt quit the application when the last widget
+ with the attribute set has accepted closeEvent(). This behavior can be
+ modified with the QApplication::quitOnLastWindowClosed property. By default
+ this attribute is set for all widgets of type Qt::Window.
+
+ \value WA_Resized Indicates that the widget has an explicit size. This flag
+ is set or cleared by QWidget::resize() and QWidget::setGeometry().
+
+ \value WA_RightToLeft Indicates that the layout direction for the widget
+ is right to left.
+
+ \value WA_SetCursor Indicates that the widget has a cursor of its own. This
+ flag is set or cleared by QWidget::setCursor() and QWidget::unsetCursor().
+
+ \value WA_SetFont Indicates that the widget has a font of its own. This
+ flag is set or cleared by QWidget::setFont().
+
+ \value WA_SetPalette Indicates that the widget has a palette of its own.
+ This flag is set or cleared by QWidget::setPalette().
+
+ \value WA_SetStyle Indicates that the widget has a style of its own. This
+ flag is set or cleared by QWidget::setStyle().
+
+ \value WA_ShowModal \e{This attribute has been deprecated.} Use
+ QWidget::windowModality instead.
+
+ \value WA_StaticContents Indicates that the widget contents are north-west
+ aligned and static. On resize, such a widget will receive paint events only
+ for parts of itself that are newly visible. This flag is set or cleared by
+ the widget's author.
+
+ \value WA_StyleSheet Indicates that the widget is styled using a
+ \l{Qt Style Sheets}{style sheet}.
+
+ \value WA_TranslucentBackground Indicates that the widget should have a
+ translucent background, i.e., any non-opaque regions of the widgets will be
+ translucent because the widget will have an alpha channel. Setting this
+ flag causes WA_NoSystemBackground to be set. On Windows the
+ widget also needs the Qt::FramelessWindowHint window flag to be set.
+ This flag is set or cleared by the widget's author.
+
+ \value WA_UnderMouse Indicates that the widget is under the mouse cursor.
+ The value is not updated correctly during drag and drop operations. There
+ is also a getter function, QWidget::underMouse(). This flag is set or
+ cleared by the Qt kernel.
+
+ \value WA_UpdatesDisabled Indicates that updates are blocked (including the
+ system background). This flag is set or cleared by the Qt kernel.
+ \warning This flag must \e never be set or cleared by the widget's author.
+
+ \value WA_WindowModified Indicates that the window is marked as modified.
+ On some platforms this flag will do nothing, on others (including Mac OS X
+ and Windows) the window will take a modified appearance. This flag is set
+ or cleared by QWidget::setWindowModified().
+
+ \value WA_WindowPropagation Makes a toplevel window inherit font and
+ palette from its parent.
+
+ \value WA_MacAlwaysShowToolWindow On Mac OS X, show the tool window even
+ when the application is not active. By default, all tool windows are
+ hidden when the application is inactive.
+
+ \value WA_SetLocale Indicates the locale should be taken into consideration
+ in the widget.
+
+ \value WA_StyledBackground Indicates the widget should be drawn using a
+ styled background.
+
+ \value WA_ShowWithoutActivating Show the widget without making it active.
+
+ \value WA_NativeWindow Indicates that a native window is created for the
+ widget. Enabling this flag will also force a native window for the widget's
+ ancestors unless Qt::WA_DontCreateNativeAncestors is set.
+
+ \value WA_DontCreateNativeAncestors Indicates that the widget's ancestors
+ are kept non-native even though the widget itself is native.
+
+ \value WA_X11NetWmWindowTypeDesktop Adds _NET_WM_WINDOW_TYPE_DESKTOP to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms.
+
+ \value WA_X11NetWmWindowTypeDock Adds _NET_WM_WINDOW_TYPE_DOCK to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms.
+
+ \value WA_X11NetWmWindowTypeToolBar Adds _NET_WM_WINDOW_TYPE_TOOLBAR to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automaticaly sets this
+ attribute for QToolBar.
+
+ \value WA_X11NetWmWindowTypeMenu Adds _NET_WM_WINDOW_TYPE_MENU to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute for QMenu when torn-off.
+
+ \value WA_X11NetWmWindowTypeUtility Adds _NET_WM_WINDOW_TYPE_UTILITY to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute for the Qt::Tool window type.
+
+ \value WA_X11NetWmWindowTypeSplash Adds _NET_WM_WINDOW_TYPE_SPLASH to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute for the Qt::SplashScreen window type.
+
+ \value WA_X11NetWmWindowTypeDialog Adds _NET_WM_WINDOW_TYPE_DIALOG
+ to the window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This
+ attribute has no effect on non-X11 platforms. \note Qt automatically sets
+ this attribute for the Qt::Dialog and Qt::Sheet window types.
+
+ \value WA_X11NetWmWindowTypeDropDownMenu Adds
+ _NET_WM_WINDOW_TYPE_DROPDOWN_MENU to the window's
+ _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This
+ attribute has no effect on non-X11 platforms. \note Qt
+ automatically sets this attribute for QMenus added to a QMenuBar.
+
+ \value WA_X11NetWmWindowTypePopupMenu Adds _NET_WM_WINDOW_TYPE_POPUP_MENU
+ to the window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute for QMenu.
+
+ \value WA_X11NetWmWindowTypeToolTip Adds _NET_WM_WINDOW_TYPE_TOOLTIP to the
+ window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute for the Qt::ToolTip window type.
+
+ \value WA_X11NetWmWindowTypeNotification Adds
+ _NET_WM_WINDOW_TYPE_NOTIFICATION to the window's _NET_WM_WINDOW_TYPE X11
+ window property. See http://standards.freedesktop.org/wm-spec/ for more
+ details. This attribute has no effect on non-X11 platforms.
+
+ \value WA_X11NetWmWindowTypeCombo Adds _NET_WM_WINDOW_TYPE_COMBO
+ to the window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute for the QComboBox pop-up.
+
+ \value WA_X11NetWmWindowTypeDND Adds _NET_WM_WINDOW_TYPE_DND to
+ the window's _NET_WM_WINDOW_TYPE X11 window property. See
+ http://standards.freedesktop.org/wm-spec/ for more details. This attribute
+ has no effect on non-X11 platforms. \note Qt automatically sets this
+ attribute on the feedback widget used during a drag.
+
+ \value WA_MacFrameworkScaled Enables resolution independence aware mode
+ on Mac when using Carbon. This attribute has no effect on Cocoa.
+ The attribute is off by default and can be enabled on a per-window basis.
+
+ \value WA_AcceptTouchEvents Allows touch events (see QTouchEvent)
+ to be sent to the widget. Must be set on all widgets that can
+ handle touch events. Without this attribute set, events from a
+ touch device will be sent as mouse events.
+
+ \value WA_TouchPadAcceptSingleTouchEvents Allows touchpad single
+ touch events to be sent to the widget.
+
+ \omitvalue WA_SetLayoutDirection
+ \omitvalue WA_InputMethodTransparent
+ \omitvalue WA_WState_CompressKeys
+ \omitvalue WA_WState_ConfigPending
+ \omitvalue WA_WState_Created
+ \omitvalue WA_WState_DND
+ \omitvalue WA_WState_ExplicitShowHide
+ \omitvalue WA_WState_Hidden
+ \omitvalue WA_WState_InPaintEvent
+ \omitvalue WA_WState_OwnSizePolicy
+ \omitvalue WA_WState_Polished
+ \omitvalue WA_WState_Reparented
+ \omitvalue WA_WState_Visible
+ \omitvalue WA_SetWindowIcon
+ \omitvalue WA_PendingUpdate
+ \omitvalue WA_LaidOut
+ \omitvalue WA_GrabbedShortcut
+ \omitvalue WA_DontShowOnScreen
+ \omitvalue WA_InvalidSize
+ \omitvalue WA_ForceUpdatesDisabled
+ \omitvalue WA_NoX11EventCompression
+ \omitvalue WA_TintedBackground
+ \omitvalue WA_X11OpenGLOverlay
+ \omitvalue WA_CanHostQMdiSubWindowTitleBar
+ \omitvalue WA_AttributeCount
+ \omitvalue WA_StyleSheet
+ \omitvalue WA_X11BypassTransientForHint
+ \omitvalue WA_SetWindowModality
+ \omitvalue WA_WState_WindowOpacitySet
+ \omitvalue WA_WState_AcceptedTouchBeginEvent
+*/
+
+/*! \typedef Qt::HANDLE
+
+ Platform-specific handle type for system objects. This is
+ equivalent to \c{void *} on Mac OS X and embedded Linux,
+ and to \c{unsigned long} on X11. On Windows it is the
+ DWORD returned by the Win32 function getCurrentThreadId().
+
+ \warning Using this type is not portable.
+*/
+
+/*!
+ \enum Qt::Key
+
+ The key names used by Qt.
+
+ \value Key_Escape
+ \value Key_Tab
+ \value Key_Backtab
+ \omitvalue Key_BackTab
+ \value Key_Backspace
+ \omitvalue Key_BackSpace
+ \value Key_Return
+ \value Key_Enter Typically located on the keypad.
+ \value Key_Insert
+ \value Key_Delete
+ \value Key_Pause
+ \value Key_Print
+ \value Key_SysReq
+ \value Key_Clear
+ \value Key_Home
+ \value Key_End
+ \value Key_Left
+ \value Key_Up
+ \value Key_Right
+ \value Key_Down
+ \value Key_PageUp
+ \omitvalue Key_Prior
+ \value Key_PageDown
+ \omitvalue Key_Next
+ \value Key_Shift
+ \value Key_Control On Mac OS X, this corresponds to the Command keys.
+ \value Key_Meta On Mac OS X, this corresponds to the Control keys.
+ On Windows keyboards, this key is mapped to the
+ Windows key.
+ \value Key_Alt
+ \value Key_AltGr On Windows, when the KeyDown event for this key is
+ sent, the Ctrl+Alt modifiers are also set.
+ \value Key_CapsLock
+ \value Key_NumLock
+ \value Key_ScrollLock
+ \value Key_F1
+ \value Key_F2
+ \value Key_F3
+ \value Key_F4
+ \value Key_F5
+ \value Key_F6
+ \value Key_F7
+ \value Key_F8
+ \value Key_F9
+ \value Key_F10
+ \value Key_F11
+ \value Key_F12
+ \value Key_F13
+ \value Key_F14
+ \value Key_F15
+ \value Key_F16
+ \value Key_F17
+ \value Key_F18
+ \value Key_F19
+ \value Key_F20
+ \value Key_F21
+ \value Key_F22
+ \value Key_F23
+ \value Key_F24
+ \value Key_F25
+ \value Key_F26
+ \value Key_F27
+ \value Key_F28
+ \value Key_F29
+ \value Key_F30
+ \value Key_F31
+ \value Key_F32
+ \value Key_F33
+ \value Key_F34
+ \value Key_F35
+ \value Key_Super_L
+ \value Key_Super_R
+ \value Key_Menu
+ \value Key_Hyper_L
+ \value Key_Hyper_R
+ \value Key_Help
+ \value Key_Direction_L
+ \value Key_Direction_R
+ \value Key_Space
+ \value Key_Any
+ \value Key_Exclam
+ \value Key_QuoteDbl
+ \value Key_NumberSign
+ \value Key_Dollar
+ \value Key_Percent
+ \value Key_Ampersand
+ \value Key_Apostrophe
+ \value Key_ParenLeft
+ \value Key_ParenRight
+ \value Key_Asterisk
+ \value Key_Plus
+ \value Key_Comma
+ \value Key_Minus
+ \value Key_Period
+ \value Key_Slash
+ \value Key_0
+ \value Key_1
+ \value Key_2
+ \value Key_3
+ \value Key_4
+ \value Key_5
+ \value Key_6
+ \value Key_7
+ \value Key_8
+ \value Key_9
+ \value Key_Colon
+ \value Key_Semicolon
+ \value Key_Less
+ \value Key_Equal
+ \value Key_Greater
+ \value Key_Question
+ \value Key_At
+ \value Key_A
+ \value Key_B
+ \value Key_C
+ \value Key_D
+ \value Key_E
+ \value Key_F
+ \value Key_G
+ \value Key_H
+ \value Key_I
+ \value Key_J
+ \value Key_K
+ \value Key_L
+ \value Key_M
+ \value Key_N
+ \value Key_O
+ \value Key_P
+ \value Key_Q
+ \value Key_R
+ \value Key_S
+ \value Key_T
+ \value Key_U
+ \value Key_V
+ \value Key_W
+ \value Key_X
+ \value Key_Y
+ \value Key_Z
+ \value Key_BracketLeft
+ \value Key_Backslash
+ \value Key_BracketRight
+ \value Key_AsciiCircum
+ \value Key_Underscore
+ \value Key_QuoteLeft
+ \value Key_BraceLeft
+ \value Key_Bar
+ \value Key_BraceRight
+ \value Key_AsciiTilde
+ \value Key_nobreakspace
+ \value Key_exclamdown
+ \value Key_cent
+ \value Key_sterling
+ \value Key_currency
+ \value Key_yen
+ \value Key_brokenbar
+ \value Key_section
+ \value Key_diaeresis
+ \value Key_copyright
+ \value Key_ordfeminine
+ \value Key_guillemotleft
+ \value Key_notsign
+ \value Key_hyphen
+ \value Key_registered
+ \value Key_macron
+ \value Key_degree
+ \value Key_plusminus
+ \value Key_twosuperior
+ \value Key_threesuperior
+ \value Key_acute
+ \value Key_mu
+ \value Key_paragraph
+ \value Key_periodcentered
+ \value Key_cedilla
+ \value Key_onesuperior
+ \value Key_masculine
+ \value Key_guillemotright
+ \value Key_onequarter
+ \value Key_onehalf
+ \value Key_threequarters
+ \value Key_questiondown
+ \value Key_Agrave
+ \value Key_Aacute
+ \value Key_Acircumflex
+ \value Key_Atilde
+ \value Key_Adiaeresis
+ \value Key_Aring
+ \value Key_AE
+ \value Key_Ccedilla
+ \value Key_Egrave
+ \value Key_Eacute
+ \value Key_Ecircumflex
+ \value Key_Ediaeresis
+ \value Key_Igrave
+ \value Key_Iacute
+ \value Key_Icircumflex
+ \value Key_Idiaeresis
+ \value Key_ETH
+ \value Key_Ntilde
+ \value Key_Ograve
+ \value Key_Oacute
+ \value Key_Ocircumflex
+ \value Key_Otilde
+ \value Key_Odiaeresis
+ \value Key_multiply
+ \value Key_Ooblique
+ \value Key_Ugrave
+ \value Key_Uacute
+ \value Key_Ucircumflex
+ \value Key_Udiaeresis
+ \value Key_Yacute
+ \value Key_THORN
+ \value Key_ssharp
+ \omitvalue Key_agrave
+ \omitvalue Key_aacute
+ \omitvalue Key_acircumflex
+ \omitvalue Key_atilde
+ \omitvalue Key_adiaeresis
+ \omitvalue Key_aring
+ \omitvalue Key_ae
+ \omitvalue Key_ccedilla
+ \omitvalue Key_egrave
+ \omitvalue Key_eacute
+ \omitvalue Key_ecircumflex
+ \omitvalue Key_ediaeresis
+ \omitvalue Key_igrave
+ \omitvalue Key_iacute
+ \omitvalue Key_icircumflex
+ \omitvalue Key_idiaeresis
+ \omitvalue Key_eth
+ \omitvalue Key_ntilde
+ \omitvalue Key_ograve
+ \omitvalue Key_oacute
+ \omitvalue Key_ocircumflex
+ \omitvalue Key_otilde
+ \omitvalue Key_odiaeresis
+ \value Key_division
+ \omitvalue Key_oslash
+ \omitvalue Key_ugrave
+ \omitvalue Key_uacute
+ \omitvalue Key_ucircumflex
+ \omitvalue Key_udiaeresis
+ \omitvalue Key_yacute
+ \omitvalue Key_thorn
+ \value Key_ydiaeresis
+ \value Key_Multi_key
+ \value Key_Codeinput
+ \value Key_SingleCandidate
+ \value Key_MultipleCandidate
+ \value Key_PreviousCandidate
+ \value Key_Mode_switch
+ \value Key_Kanji
+ \value Key_Muhenkan
+ \value Key_Henkan
+ \value Key_Romaji
+ \value Key_Hiragana
+ \value Key_Katakana
+ \value Key_Hiragana_Katakana
+ \value Key_Zenkaku
+ \value Key_Hankaku
+ \value Key_Zenkaku_Hankaku
+ \value Key_Touroku
+ \value Key_Massyo
+ \value Key_Kana_Lock
+ \value Key_Kana_Shift
+ \value Key_Eisu_Shift
+ \value Key_Eisu_toggle
+ \value Key_Hangul
+ \value Key_Hangul_Start
+ \value Key_Hangul_End
+ \value Key_Hangul_Hanja
+ \value Key_Hangul_Jamo
+ \value Key_Hangul_Romaja
+ \value Key_Hangul_Jeonja
+ \value Key_Hangul_Banja
+ \value Key_Hangul_PreHanja
+ \value Key_Hangul_PostHanja
+ \value Key_Hangul_Special
+ \value Key_Dead_Grave
+ \value Key_Dead_Acute
+ \value Key_Dead_Circumflex
+ \value Key_Dead_Tilde
+ \value Key_Dead_Macron
+ \value Key_Dead_Breve
+ \value Key_Dead_Abovedot
+ \value Key_Dead_Diaeresis
+ \value Key_Dead_Abovering
+ \value Key_Dead_Doubleacute
+ \value Key_Dead_Caron
+ \value Key_Dead_Cedilla
+ \value Key_Dead_Ogonek
+ \value Key_Dead_Iota
+ \value Key_Dead_Voiced_Sound
+ \value Key_Dead_Semivoiced_Sound
+ \value Key_Dead_Belowdot
+ \value Key_Dead_Hook
+ \value Key_Dead_Horn
+ \value Key_Back
+ \value Key_Forward
+ \value Key_Stop
+ \value Key_Refresh
+ \value Key_VolumeDown
+ \value Key_VolumeMute
+ \value Key_VolumeUp
+ \value Key_BassBoost
+ \value Key_BassUp
+ \value Key_BassDown
+ \value Key_TrebleUp
+ \value Key_TrebleDown
+ \value Key_MediaPlay
+ \value Key_MediaStop
+ \value Key_MediaPrevious
+ \omitvalue Key_MediaPrev
+ \value Key_MediaNext
+ \value Key_MediaRecord
+ \value Key_HomePage
+ \value Key_Favorites
+ \value Key_Search
+ \value Key_Standby
+ \value Key_OpenUrl
+ \value Key_LaunchMail
+ \value Key_LaunchMedia
+ \value Key_Launch0
+ \value Key_Launch1
+ \value Key_Launch2
+ \value Key_Launch3
+ \value Key_Launch4
+ \value Key_Launch5
+ \value Key_Launch6
+ \value Key_Launch7
+ \value Key_Launch8
+ \value Key_Launch9
+ \value Key_LaunchA
+ \value Key_LaunchB
+ \value Key_LaunchC
+ \value Key_LaunchD
+ \value Key_LaunchE
+ \value Key_LaunchF
+ \value Key_MediaLast
+ \value Key_unknown
+
+ \value Key_Call
+ \value Key_Context1
+ \value Key_Context2
+ \value Key_Context3
+ \value Key_Context4
+ \value Key_Flip
+ \value Key_Hangup
+ \value Key_No
+ \value Key_Select
+ \value Key_Yes
+
+ \value Key_Execute
+ \value Key_Printer
+ \value Key_Play
+ \value Key_Sleep
+ \value Key_Zoom
+ \value Key_Cancel
+
+ \sa QKeyEvent::key()
+*/
+
+/*!
+ \enum Qt::HitTestAccuracy
+
+ This enum contains the types of accuracy that can be used by the
+ QTextDocument class when testing for mouse clicks on text documents.
+
+ \value ExactHit The point at which input occurred must coincide
+ exactly with input-sensitive parts of the document.
+ \value FuzzyHit The point at which input occurred can lie close to
+ input-sensitive parts of the document.
+
+ This enum is defined in the \c <QTextDocument> header file.
+*/
+
+/*!
+ \enum Qt::WhiteSpaceMode
+
+ This enum describes the types of whitespace mode that are used by
+ the QTextDocument class to meet the requirements of different kinds
+ of textual information.
+
+ \value WhiteSpaceNormal The whitespace mode used to display
+ normal word wrapped text in paragraphs.
+ \value WhiteSpacePre A preformatted text mode in which
+ whitespace is reproduced exactly.
+ \value WhiteSpaceNoWrap
+
+ \omitvalue WhiteSpaceModeUndefined
+
+ This enum is defined in the \c <QTextDocument> header file.
+*/
+
+/*!
+ \enum Qt::ButtonState_enum
+ \compat
+ \value ShiftButton
+ \value ControlButton
+ \value AltButton
+ \value MetaButton
+ \value Keypad
+ \value KeyButtonMask
+
+ Use Qt::KeyboardModifier instead.
+*/
+
+/*!
+ \typedef Qt::ButtonState
+ \compat
+
+ Use Qt::KeyboardModifier instead.
+*/
+
+/*!
+ \enum Qt::CheckState
+
+ This enum describes the state of checkable items, controls, and widgets.
+
+ \value Unchecked The item is unchecked.
+ \value PartiallyChecked The item is partially checked. Items in hierarchical models
+ may be partially checked if some, but not all, of their
+ children are checked.
+ \value Checked The item is checked.
+
+ \sa QCheckBox, Qt::ItemFlags, Qt::ItemDataRole
+*/
+
+
+/*!
+ \enum Qt::ToolButtonStyle
+
+ The style of the tool button, describing how the button's text and
+ icon should be displayed.
+
+ \value ToolButtonIconOnly Only display the icon.
+ \value ToolButtonTextOnly Only display the text.
+ \value ToolButtonTextBesideIcon The text appears beside the icon.
+ \value ToolButtonTextUnderIcon The text appears under the icon.
+ \value ToolButtonFollowStyle Follow the \l{QStyle::SH_ToolButtonStyle}{style}.
+*/
+
+/*!
+ \enum Qt::Corner
+
+ This enum type specifies a corner in a rectangle:
+
+ \value TopLeftCorner The top-left corner of the rectangle.
+ \value TopRightCorner The top-right corner of the rectangle.
+ \value BottomLeftCorner The bottom-left corner of the rectangle.
+ \value BottomRightCorner The bottom-right corner of the rectangle.
+
+ \omitvalue TopLeft
+ \omitvalue TopRight
+ \omitvalue BottomLeft
+ \omitvalue BottomRight
+*/
+
+/*!
+ \enum Qt::ScrollBarPolicy
+
+ This enum type describes the various modes of QAbstractScrollArea's scroll
+ bars.
+
+ \value ScrollBarAsNeeded QAbstractScrollArea shows a scroll bar when the
+ content is too large to fit and not otherwise. This is the
+ default.
+
+ \value ScrollBarAlwaysOff QAbstractScrollArea never shows a scroll bar.
+
+ \value ScrollBarAlwaysOn QAbstractScrollArea always shows a scroll bar.
+
+ (The modes for the horizontal and vertical scroll bars are
+ independent.)
+*/
+
+/*!
+ \enum Qt::ArrowType
+
+ \value NoArrow
+ \value UpArrow
+ \value DownArrow
+ \value LeftArrow
+ \value RightArrow
+*/
+
+/*!
+ \enum Qt::FocusReason
+
+ This enum specifies why the focus changed. It will be passed
+ through QWidget::setFocus and can be retrieved in the QFocusEvent
+ sent to the widget upon focus change.
+
+ \value MouseFocusReason A mouse action occurred.
+ \value TabFocusReason The Tab key was pressed.
+ \value BacktabFocusReason A Backtab occurred. The input for this may
+ include the Shift or Control keys;
+ e.g. Shift+Tab.
+ \value ActiveWindowFocusReason The window system made this window either
+ active or inactive.
+ \value PopupFocusReason The application opened/closed a pop-up that
+ grabbed/released the keyboard focus.
+ \value ShortcutFocusReason The user typed a label's buddy shortcut
+ \value MenuBarFocusReason The menu bar took focus.
+ \value OtherFocusReason Another reason, usually application-specific.
+
+ \omitvalue NoFocusReason
+
+ \sa {Keyboard Focus}
+*/
+
+/*!
+ \enum Qt::WindowState
+
+ \keyword window state
+
+ This enum type is used to specify the current state of a top-level
+ window.
+
+ The states are
+
+ \value WindowNoState The window has no state set (in normal state).
+ \value WindowMinimized The window is minimized (i.e. iconified).
+ \value WindowMaximized The window is maximized with a frame around it.
+ \value WindowFullScreen The window fills the entire screen without any frame around it.
+ \value WindowActive The window is the active window, i.e. it has keyboard focus.
+
+*/
+
+/*!
+ \enum Qt::ContextMenuPolicy
+
+ This enum type defines the various policies a widget can have with
+ respect to showing a context menu.
+
+ \value NoContextMenu the widget does not feature a context menu,
+ context menu handling is deferred to the widget's parent.
+ \value PreventContextMenu the widget does not feature a context
+ menu, and in contrast to \c NoContextMenu, the handling is \e not
+ deferred to the widget's parent. This means that all right mouse
+ button events are guaranteed to be delivered to the widget itself
+ through mousePressEvent(), and mouseReleaseEvent().
+ \value DefaultContextMenu the widget's QWidget::contextMenuEvent() handler is called.
+ \value ActionsContextMenu the widget displays its QWidget::actions() as context menu.
+ \value CustomContextMenu the widget emits the QWidget::customContextMenuRequested() signal.
+*/
+
+/*!
+ \enum Qt::FocusPolicy
+
+ This enum type defines the various policies a widget can have with
+ respect to acquiring keyboard focus.
+
+ \value TabFocus the widget accepts focus by tabbing.
+ \value ClickFocus the widget accepts focus by clicking.
+ \value StrongFocus the widget accepts focus by both tabbing
+ and clicking. On Mac OS X this will also
+ be indicate that the widget accepts tab focus
+ when in 'Text/List focus mode'.
+ \value WheelFocus like Qt::StrongFocus plus the widget accepts
+ focus by using the mouse wheel.
+ \value NoFocus the widget does not accept focus.
+
+*/
+
+/*!
+ \enum Qt::ShortcutContext
+
+ For a QEvent::Shortcut event to occur, the shortcut's key sequence
+ must be entered by the user in a context where the shortcut is
+ active. The possible contexts are these:
+
+ \value WidgetShortcut The shortcut is active when its
+ parent widget has focus.
+ \value WidgetWithChildrenShortcut The shortcut is active
+ when its parent widget, or any of its children has focus.
+ Children which are top-level widgets, except pop-ups, are
+ not affected by this shortcut context.
+ \value WindowShortcut The shortcut is active when its
+ parent widget is a logical subwidget of the
+ active top-level window.
+ \value ApplicationShortcut The shortcut is active when one of
+ the applications windows are active.
+*/
+
+/*!
+ \typedef Qt::WFlags
+
+ Synonym for Qt::WindowFlags.
+*/
+
+/*!
+ \enum Qt::WindowType
+
+ \keyword window flag
+
+ This enum type is used to specify various window-system properties
+ for the widget. They are fairly unusual but necessary in a few
+ cases. Some of these flags depend on whether the underlying window
+ manager supports them.
+
+ The main types are
+
+ \value Widget This is the default type for QWidget. Widgets of
+ this type are child widgets if they have a parent,
+ and independent windows if they have no parent.
+ See also Qt::Window and Qt::SubWindow.
+
+ \value Window Indicates that the widget is a window, usually
+ with a window system frame and a title bar,
+ irrespective of whether the widget has a parent or
+ not. Note that it is not possible to unset this
+ flag if the widget does not have a parent.
+
+ \value Dialog Indicates that the widget is a window that should
+ be decorated as a dialog (i.e., typically no
+ maximize or minimize buttons in the title bar).
+ This is the default type for QDialog. If you want
+ to use it as a modal dialog, it should be launched
+ from another window, or have a parent and used
+ with the QWidget::windowModality property. If you make
+ it modal, the dialog will prevent other top-level
+ windows in the application from getting any input.
+ We refer to a top-level window that has a parent
+ as a \e secondary window.
+
+ \value Sheet Indicates that the window is a Macintosh sheet. Since
+ using a sheet implies window modality, the recommended
+ way is to use QWidget::setWindowModality(), or
+ QDialog::open(), instead.
+
+ \value Drawer Indicates that the widget is a Macintosh drawer.
+
+ \value Popup Indicates that the widget is a pop-up top-level
+ window, i.e. that it is modal, but has a window
+ system frame appropriate for pop-up menus.
+
+ \value Tool Indicates that the widget is a tool window. A tool
+ window is often a small window with a smaller than
+ usual title bar and decoration, typically used for
+ collections of tool buttons. It there is a parent,
+ the tool window will always be kept on top of it.
+ If there isn't a parent, you may consider using
+ Qt::WindowStaysOnTopHint as well. If the window
+ system supports it, a tool window can be decorated
+ with a somewhat lighter frame. It can also be
+ combined with Qt::FramelessWindowHint.
+ \br
+ \br
+ On Mac OS X, tool windows correspond to the
+ \l{http://developer.apple.com/documentation/Carbon/Conceptual/HandlingWindowsControls/hitb-wind_cont_concept/chapter_2_section_2.html}{Floating}
+ class of windows. This means that the window lives on a
+ level above normal windows; it impossible to put a normal
+ window on top of it. By default, tool windows will disappear
+ when the application is inactive. This can be controlled by
+ the Qt::WA_MacAlwaysShowToolWindow attribute.
+
+ \value ToolTip Indicates that the widget is a tooltip. This is
+ used internally to implement
+ \l{QWidget::toolTip}{tooltips}.
+
+ \value SplashScreen Indicates that the window is a splash screen.
+ This is the default type for QSplashScreen.
+
+ \value Desktop Indicates that this widget is the desktop. This
+ is the type for QDesktopWidget.
+
+ \value SubWindow Indicates that this widget is a sub-window, such
+ as a QMdiSubWindow widget.
+
+ There are also a number of flags which you can use to customize
+ the appearance of top-level windows. These have no effect on other
+ windows:
+
+ \value MSWindowsFixedSizeDialogHint Gives the window a thin dialog border on Windows.
+ This style is traditionally used for fixed-size dialogs.
+
+ \value MSWindowsOwnDC Gives the window its own display
+ context on Windows.
+
+ \value X11BypassWindowManagerHint Bypass the window
+ manager completely. This results in a borderless window
+ that is not managed at all (i.e., no keyboard input unless
+ you call QWidget::activateWindow() manually).
+
+ \value FramelessWindowHint Produces a borderless window.
+ The user cannot move or resize a borderless window via the window
+ system. On X11, the result of the flag is dependent on the window manager and its
+ ability to understand Motif and/or NETWM hints. Most existing
+ modern window managers can handle this.
+
+ The \c CustomizeWindowHint flag is used to enable customization of
+ the window controls. This flag must be set to allow the \c
+ WindowTitleHint, \c WindowSystemMenuHint, \c
+ WindowMinimizeButtonHint, \c WindowMaximizeButtonHint and \c
+ WindowCloseButtonHint flags to be changed.
+
+ \value CustomizeWindowHint Turns off the default window title hints.
+
+ \value WindowTitleHint Gives the window a title bar.
+
+ \value WindowSystemMenuHint Adds a window system menu, and
+ possibly a close button (for example on Mac). If you need to hide
+ or show a close button, it is more portable to use \c
+ WindowCloseButtonHint.
+
+ \value WindowMinimizeButtonHint Adds a minimize button. On
+ some platforms this implies Qt::WindowSystemMenuHint for it to work.
+
+ \value WindowMaximizeButtonHint Adds a maximize button. On
+ some platforms this implies Qt::WindowSystemMenuHint for it to work.
+
+ \value WindowMinMaxButtonsHint Adds a minimize and a maximize
+ button. On some platforms this implies Qt::WindowSystemMenuHint for it to work.
+
+ \value WindowCloseButtonHint Adds a close button. On
+ some platforms this implies Qt::WindowSystemMenuHint for it
+ to work.
+
+ \value WindowContextHelpButtonHint Adds a context help button to dialogs.
+ On some platforms this implies Qt::WindowSystemMenuHint for it to work.
+
+ \value MacWindowToolBarButtonHint On Mac OS X adds a tool bar button (i.e.,
+ the oblong button that is on the top right of windows that have toolbars.
+
+ \value BypassGraphicsProxyWidget Prevents the window and its children from
+ automatically embedding themselves into a QGraphicsProxyWidget if the
+ parent widget is already embedded. You can set this flag if you
+ want your widget to always be a toplevel widget on the desktop,
+ regardless of whether the parent widget is embedded in a scene or
+ not.
+
+ \value WindowShadeButtonHint
+
+ \value WindowStaysOnTopHint Informs the window system that the
+ window should stay on top of all other windows. Note that
+ on some window managers on X11 you also have to pass
+ Qt::X11BypassWindowManagerHint for this flag to work
+ correctly.
+
+ \value WindowStaysOnBottomHint Informs the window system that the
+ window should stay on bottom of all other windows. Note
+ that on X11 this hint will work only in window managers
+ that support _NET_WM_STATE_BELOW atom. If a window always
+ on the bottom has a parent, the parent will also be left on
+ the bottom. This window hint is currently not implemented
+ for Mac OS X.
+
+ \value WindowOkButtonHint Adds an OK button to the window decoration of a dialog.
+ Only supported for Windows CE.
+
+ \value WindowCancelButtonHint Adds a Cancel button to the window decoration of a dialog.
+ Only supported for Windows CE.
+
+ \value WindowType_Mask A mask for extracting the window type
+ part of the window flags.
+
+ Obsolete flags:
+
+ \value WMouseNoMask Use Qt::WA_MouseNoMask instead.
+ \value WDestructiveClose Use Qt::WA_DeleteOnClose instead.
+ \value WStaticContents Use Qt::WA_StaticContents instead.
+ \value WGroupLeader No longer needed.
+ \value WShowModal Use QWidget::windowModality instead.
+ \value WNoMousePropagation Use Qt::WA_NoMousePropagation instead.
+ \value WType_TopLevel Use Qt::Window instead.
+ \value WType_Dialog Use Qt::Dialog instead.
+ \value WType_Popup Use Qt::Popup instead.
+ \value WType_Desktop Use Qt::Desktop instead.
+ \value WType_Mask Use Qt::WindowType_Mask instead.
+
+ \value WStyle_Customize No longer needed.
+ \value WStyle_NormalBorder No longer needed.
+ \value WStyle_DialogBorder Use Qt::MSWindowsFixedSizeDialogHint instead.
+ \value WStyle_NoBorder Use Qt::FramelessWindowHint instead.
+ \value WStyle_Title Use Qt::WindowTitleHint instead.
+ \value WStyle_SysMenu Use Qt::WindowSystemMenuHint instead.
+ \value WStyle_Minimize Use Qt::WindowMinimizeButtonHint instead.
+ \value WStyle_Maximize Use Qt::WindowMaximizeButtonHint instead.
+ \value WStyle_MinMax Use Qt::WindowMinMaxButtonsHint instead.
+ \value WStyle_Tool Use Qt::Tool instead.
+ \value WStyle_StaysOnTop Use Qt::WindowStaysOnTopHint instead.
+ \value WStyle_ContextHelp Use Qt::WindowContextHelpButtonHint instead.
+
+ \value WPaintDesktop No longer needed.
+ \value WPaintClever No longer needed.
+
+ \value WX11BypassWM Use Qt::X11BypassWindowManagerHint instead.
+ \value WWinOwnDC Use Qt::MSWindowsOwnDC instead.
+ \value WMacSheet Use Qt::Sheet instead.
+ \value WMacDrawer Use Qt::Drawer instead.
+
+ \value WStyle_Splash Use Qt::SplashScreen instead.
+
+ \value WNoAutoErase No longer needed.
+ \value WRepaintNoErase No longer needed.
+ \value WNorthWestGravity Use Qt::WA_StaticContents instead.
+ \value WType_Modal Use Qt::Dialog and QWidget::windowModality instead.
+ \value WStyle_Dialog Use Qt::Dialog instead.
+ \value WStyle_NoBorderEx Use Qt::FramelessWindowHint instead.
+ \value WResizeNoErase No longer needed.
+ \value WMacNoSheet No longer needed.
+
+ \sa QWidget::windowFlags, {Window Flags Example}
+*/
+
+/*!
+ \enum Qt::DropAction
+
+ \value CopyAction Copy the data to the target.
+ \value MoveAction Move the data from the source to the target.
+ \value LinkAction Create a link from the source to the target.
+ \value ActionMask
+ \value IgnoreAction Ignore the action (do nothing with the data).
+ \value TargetMoveAction On Windows, this value is used when the ownership of the D&D data
+ should be taken over by the target application,
+ i.e., the source application should not delete
+ the data.
+ \br
+ On X11 this value is used to do a move.
+ \br
+ TargetMoveAction is not used on the Mac.
+*/
+
+#if defined(Q_OS_WIN) && defined(QT3_SUPPORT)
+/*!
+ \enum Qt::WindowsVersion
+ \compat
+
+ \value WV_32s
+ \value WV_95
+ \value WV_98
+ \value WV_Me
+ \value WV_DOS_based
+ \value WV_NT
+ \value WV_2000
+ \value WV_XP
+ \value WV_2003
+ \value WV_NT_based
+ \value WV_CE
+ \value WV_CENET
+ \value WV_CE_based
+ \value WV_CE_5
+ \value WV_CE_6
+*/
+#endif
+
+#if defined(Q_OS_MAC) && defined(QT3_SUPPORT)
+/*!
+ \enum Qt::MacintoshVersion
+ \compat
+
+ \value MV_Unknown Use QSysInfo::MV_Unknown instead.
+ \value MV_9 Use QSysInfo::MV_9 instead.
+ \value MV_10_DOT_0 Use QSysInfo::MV_10_0 instead.
+ \value MV_10_DOT_1 Use QSysInfo::MV_10_1 instead.
+ \value MV_10_DOT_2 Use QSysInfo::MV_10_2 instead.
+ \value MV_10_DOT_3 Use QSysInfo::MV_10_3 instead.
+ \value MV_10_DOT_4 Use QSysInfo::MV_10_4 instead.
+
+ \value MV_CHEETAH Use QSysInfo::MV_10_0 instead.
+ \value MV_PUMA Use QSysInfo::MV_10_1 instead.
+ \value MV_JAGUAR Use QSysInfo::MV_10_2 instead.
+ \value MV_PANTHER Use QSysInfo::MV_10_3 instead.
+ \value MV_TIGER Use QSysInfo::MV_10_4 instead.
+
+ \sa QSysInfo::MacVersion
+*/
+#endif
+
+/*! \typedef Qt::ToolBarDock
+ \compat
+
+ Use Qt::Dock instead.
+*/
+
+/*!
+ \enum Qt::Dock
+ \compat
+
+ Each dock window can be in one of the following positions:
+
+ \value DockUnmanaged not managed by a Q3MainWindow.
+
+ \value DockTornOff the dock window floats as its own top level
+ window which always stays on top of the main window.
+
+ \value DockTop above the central widget, below the menu bar.
+
+ \value DockBottom below the central widget, above the status bar.
+
+ \value DockRight to the right of the central widget.
+
+ \value DockLeft to the left of the central widget.
+
+ \value DockMinimized the dock window is not shown (this is
+ effectively a 'hidden' dock area); the handles of all minimized
+ dock windows are drawn in one row below the menu bar.
+
+ \omitvalue Bottom
+ \omitvalue Left
+ \omitvalue Minimized
+ \omitvalue Right
+ \omitvalue Top
+ \omitvalue TornOff
+ \omitvalue Unmanaged
+*/
+
+/*!
+ \enum Qt::AnchorAttribute
+
+ An anchor has one or more of the following attributes:
+
+ \value AnchorName the name attribute of the anchor. This attribute is
+ used when scrolling to an anchor in the document.
+
+ \value AnchorHref the href attribute of the anchor. This attribute is
+ used when a link is clicked to determine what content to load.
+*/
+
+/*!
+ \enum Qt::SortOrder
+
+ This enum describes how the items in a widget are sorted.
+
+ \value AscendingOrder The items are sorted ascending e.g. starts with
+ 'AAA' ends with 'ZZZ' in Latin-1 locales
+
+ \value DescendingOrder The items are sorted descending e.g. starts with
+ 'ZZZ' ends with 'AAA' in Latin-1 locales
+
+ \omitvalue Ascending
+ \omitvalue Descending
+*/
+
+/*!
+ \enum Qt::ClipOperation
+
+ \value NoClip This operation turns clipping off.
+
+ \value ReplaceClip Replaces the current clip path/rect/region with
+ the one supplied in the function call.
+
+ \value IntersectClip Intersects the current clip path/rect/region
+ with the one supplied in the function call.
+
+ \value UniteClip Unites the current clip path/rect/region with the
+ one supplied in the function call.
+*/
+
+/*!
+ \enum Qt::ItemSelectionMode
+
+ This enum is used in QGraphicsItem, QGraphicsScene and QGraphicsView to
+ specify how items are selected, or how to determine if a shapes and items
+ collide.
+
+ \value ContainsItemShape The output list contains only items whose
+ \l{QGraphicsItem::shape()}{shape} is fully contained inside the
+ selection area. Items that intersect with the area's outline are
+ not included.
+
+ \value IntersectsItemShape The output list contains both items whose
+ \l{QGraphicsItem::shape()}{shape} is fully contained inside the
+ selection area, and items that intersect with the area's
+ outline. This is a common mode for rubber band selection.
+
+ \value ContainsItemBoundingRect The output list contains only items whose
+ \l{QGraphicsItem::boundingRect()}{bounding rectangle} is fully
+ contained inside the selection area. Items that intersect with the
+ area's outline are not included.
+
+ \value IntersectsItemBoundingRect The output list contains both items
+ whose \l{QGraphicsItem::boundingRect()}{bounding rectangle} is
+ fully contained inside the selection area, and items that intersect
+ with the area's outline. This method is commonly used for
+ determining areas that need redrawing.
+
+ \sa QGraphicsScene::items(), QGraphicsScene::collidingItems(),
+ QGraphicsView::items(), QGraphicsItem::collidesWithItem(),
+ QGraphicsItem::collidesWithPath()
+*/
+
+/*!
+ \enum Qt::FillRule
+
+ Specifies which method should be used to fill the paths and polygons.
+
+ \value OddEvenFill Specifies that the region is filled using the
+ odd even fill rule. With this rule, we determine whether a point
+ is inside the shape by using the following method.
+ Draw a horizontal line from the point to a location outside the shape,
+ and count the number of intersections. If the number of intersections
+ is an odd number, the point is inside the shape. This mode is the
+ default.
+
+ \value WindingFill Specifies that the region is filled using the
+ non zero winding rule. With this rule, we determine whether a
+ point is inside the shape by using the following method.
+ Draw a horizontal line from the point to a location outside the shape.
+ Determine whether the direction of the line at each intersection point
+ is up or down. The winding number is determined by summing the
+ direction of each intersection. If the number is non zero, the point
+ is inside the shape. This fill mode can also in most cases be considered
+ as the intersection of closed shapes.
+*/
+
+/*!
+ \enum Qt::PaintUnit
+
+ \compat
+
+ \value PixelUnit
+ \value LoMetricUnit Obsolete
+ \value HiMetricUnit Obsolete
+ \value LoEnglishUnit Obsolete
+ \value HiEnglishUnit Obsolete
+ \value TwipsUnit Obsolete
+*/
+
+/*!
+ \enum Qt::TextFormat
+
+ This enum is used in widgets that can display both plain text and
+ rich text, e.g. QLabel. It is used for deciding whether a text
+ string should be interpreted as one or the other. This is normally
+ done by passing one of the enum values to a setTextFormat()
+ function.
+
+ \value PlainText The text string is interpreted as a plain text
+ string.
+
+ \value RichText The text string is interpreted as a rich text
+ string.
+
+ \value AutoText The text string is interpreted as for
+ Qt::RichText if Qt::mightBeRichText() returns true, otherwise
+ as Qt::PlainText.
+
+ \value LogText A special, limited text format which is only used
+ by Q3TextEdit in an optimized mode.
+*/
+
+/*!
+ \enum Qt::CursorShape
+
+ This enum type defines the various cursors that can be used.
+
+ The standard arrow cursor is the default for widgets in a normal state.
+
+ \value ArrowCursor \inlineimage cursor-arrow.png
+ The standard arrow cursor.
+ \value UpArrowCursor \inlineimage cursor-uparrow.png
+ An arrow pointing upwards toward the top of the screen.
+ \value CrossCursor \inlineimage cursor-cross.png
+ A crosshair cursor, typically used to help the
+ user accurately select a point on the screen.
+ \value WaitCursor \inlineimage cursor-wait.png
+ An hourglass or watch cursor, usually shown during
+ operations that prevent the user from interacting with
+ the application.
+ \value IBeamCursor \inlineimage cursor-ibeam.png
+ A caret or ibeam cursor, indicating that a widget can
+ accept and display text input.
+ \value SizeVerCursor \inlineimage cursor-sizev.png
+ A cursor used for elements that are used to vertically
+ resize top-level windows.
+ \value SizeHorCursor \inlineimage cursor-sizeh.png
+ A cursor used for elements that are used to horizontally
+ resize top-level windows.
+ \value SizeBDiagCursor \inlineimage cursor-sizeb.png
+ A cursor used for elements that are used to diagonally
+ resize top-level windows at their top-right and
+ bottom-left corners.
+ \value SizeFDiagCursor \inlineimage cursor-sizef.png
+ A cursor used for elements that are used to diagonally
+ resize top-level windows at their top-left and
+ bottom-right corners.
+ \value SizeAllCursor \inlineimage cursor-sizeall.png
+ A cursor used for elements that are used to resize
+ top-level windows in any direction.
+ \value BlankCursor A blank/invisible cursor, typically used when the cursor
+ shape needs to be hidden.
+ \value SplitVCursor \inlineimage cursor-vsplit.png
+ A cursor used for vertical splitters, indicating that
+ a handle can be dragged horizontally to adjust the use
+ of available space.
+ \value SplitHCursor \inlineimage cursor-hsplit.png
+ A cursor used for horizontal splitters, indicating that
+ a handle can be dragged vertically to adjust the use
+ of available space.
+ \value PointingHandCursor \inlineimage cursor-hand.png
+ A pointing hand cursor that is typically used for
+ clickable elements such as hyperlinks.
+ \value ForbiddenCursor \inlineimage cursor-forbidden.png
+ A slashed circle cursor, typically used during drag
+ and drop operations to indicate that dragged content
+ cannot be dropped on particular widgets or inside
+ certain regions.
+ \value OpenHandCursor \inlineimage cursor-openhand.png
+ A cursor representing an open hand, typically used to
+ indicate that the area under the cursor is the visible
+ part of a canvas that the user can click and drag in
+ order to scroll around.
+ \value ClosedHandCursor \inlineimage cursor-closedhand.png
+ A cursor representing a closed hand, typically used to
+ indicate that a dragging operation is in progress that
+ involves scrolling.
+ \value WhatsThisCursor \inlineimage cursor-whatsthis.png
+ An arrow with a question mark, typically used to indicate
+ the presence of What's This? help for a widget.
+ \value BusyCursor \inlineimage cursor-wait.png
+ An hourglass or watch cursor, usually shown during
+ operations that allow the user to interact with
+ the application while they are performed in the
+ background.
+ \value BitmapCursor
+ \omitvalue LastCursor
+ \omitvalue CustomCursor
+
+ \omitvalue arrowCursor
+ \omitvalue upArrowCursor
+ \omitvalue crossCursor
+ \omitvalue waitCursor
+ \omitvalue ibeamCursor
+ \omitvalue sizeVerCursor
+ \omitvalue sizeHorCursor
+ \omitvalue sizeBDiagCursor
+ \omitvalue sizeFDiagCursor
+ \omitvalue sizeAllCursor
+ \omitvalue blankCursor
+ \omitvalue splitVCursor
+ \omitvalue splitHCursor
+ \omitvalue pointingHandCursor
+ \omitvalue forbiddenCursor
+ \omitvalue whatsThisCursor
+*/
+
+/*!
+ \typedef Qt::TextFlags
+ \compat
+
+ Use Qt::TextFlag instead.
+*/
+
+/*!
+ \enum Qt::LayoutDirection
+
+ Specifies the direction of Qt's layouts:
+
+ \value LeftToRight Left-to-right layout.
+ \value RightToLeft Right-to-left layout.
+
+ Right-to-left layouts are necessary for certain languages,
+ notably Arabic and Hebrew.
+
+ \sa QApplication::setLayoutDirection(), QWidget::setLayoutDirection()
+*/
+
+/*!
+ \enum Qt::InputMethodHint
+
+ \value ImhNone No hints.
+ \value ImhHiddenText Characters should be hidden, as is typically used when entering passwords.
+ This is automatically set when setting QLineEdit::echoMode to \c Password.
+ \value ImhNumbersOnly Only number input is allowed.
+ \value ImhUppercaseOnly Only upper case letter input is allowed.
+ \value ImhLowercaseOnly Only lower case letter input is allowed.
+ \value ImhNoAutoUppercase The input method should not try to automatically switch to upper case
+ when a sentence ends.
+ \value ImhPreferNumbers Numbers are preferred (but not required).
+ \value ImhPreferUppercase Upper case letters are preferred (but not required).
+ \value ImhPreferLowercase Lower case letters are preferred (but not required).
+ \value ImhNoPredictiveText Do not use predictive text (i.e. dictionary lookup) while typing.
+ \value ImhDialableCharactersOnly Only characters suitable for phone dialling are allowed.
+
+ \note If several flags ending with \c Only are ORed together, the resulting character set will
+ consist of the union of the specified sets. For instance specifying \c ImhNumbersOnly and
+ \c ImhUppercaseOnly would yield a set consisting of numbers and uppercase letters.
+
+ \sa QGraphicsItem::inputMethodHints()
+*/
+
+/*!
+ \enum Qt::InputMethodQuery
+
+ \value ImMicroFocus The rectangle covering the area of the input cursor in widget coordinates.
+ \value ImFont The currently used font for text input.
+ \value ImCursorPosition The logical position of the cursor within the text surrounding the input area (see ImSurroundingText).
+ If any text is selected, the position returned will be at the logical end of the
+ selection, even if the real cursor is located at the logical start.
+ \value ImSurroundingText The plain text around the input area, for example the current paragraph.
+ \value ImCurrentSelection The currently selected text.
+*/
+
+/*!
+ \enum Qt::ItemDataRole
+
+ Each item in the model has a set of data elements associated with
+ it, each with its own role. The roles are used by the view to indicate
+ to the model which type of data it needs. Custom models should return
+ data in these types.
+
+ The general purpose roles (and the associated types) are:
+
+ \value DisplayRole The key data to be rendered in the form of text. (QString)
+ \value DecorationRole The data to be rendered as a decoration in the form
+ of an icon. (QColor)
+ \value EditRole The data in a form suitable for editing in an
+ editor. (QString)
+ \value ToolTipRole The data displayed in the item's tooltip. (QString)
+ \value StatusTipRole The data displayed in the status bar. (QString)
+ \value WhatsThisRole The data displayed for the item in "What's This?"
+ mode. (QString)
+ \value SizeHintRole The size hint for the item that will be supplied
+ to views. (QSize)
+
+ Roles describing appearance and meta data (with associated types):
+
+ \value FontRole The font used for items rendered with the default
+ delegate. (QFont)
+ \value TextAlignmentRole The alignment of the text for items rendered with the
+ default delegate. (Qt::AlignmentFlag)
+ \value BackgroundRole The background brush used for items rendered with
+ the default delegate. (QBrush)
+ \value BackgroundColorRole This role is obsolete. Use BackgroundRole instead.
+ \value ForegroundRole The foreground brush (text color, typically)
+ used for items rendered with the default delegate.
+ (QBrush)
+ \value TextColorRole This role is obsolete. Use ForegroundRole instead.
+ \value CheckStateRole This role is used to obtain the checked state of
+ an item. (Qt::CheckState)
+
+ Accessibility roles (with associated types):
+
+ \value AccessibleTextRole The text to be used by accessibility
+ extensions and plugins, such as screen
+ readers. (QString)
+ \value AccessibleDescriptionRole A description of the item for accessibility
+ purposes. (QString)
+
+ User roles:
+
+ \value UserRole The first role that can be used for application-specific purposes.
+
+ \omitvalue DisplayPropertyRole
+ \omitvalue DecorationPropertyRole
+ \omitvalue ToolTipPropertyRole
+ \omitvalue StatusTipPropertyRole
+ \omitvalue WhatsThisPropertyRole
+
+ For user roles, it is up to the developer to decide which types to use and ensure that
+ components use the correct types when accessing and setting data.
+*/
+
+/*!
+ \enum Qt::ItemFlag
+
+ This enum describes the properties of an item:
+
+ \value NoItemFlags It does not have any properties set.
+ \value ItemIsSelectable It can be selected.
+ \value ItemIsEditable It can be edited.
+ \value ItemIsDragEnabled It can be dragged.
+ \value ItemIsDropEnabled It can be used as a drop target.
+ \value ItemIsUserCheckable It can be checked or unchecked by the user.
+ \value ItemIsEnabled The user can interact with the item.
+ \value ItemIsTristate The item is checkable with three separate states.
+
+ Note that checkable items need to be given both a suitable set of flags
+ and an initial state, indicating whether the item is checked or not.
+ This is handled automatically for model/view components, but needs
+ to be explicitly set for instances of QListWidgetItem, QTableWidgetItem,
+ and QTreeWidgetItem.
+
+ \sa QAbstractItemModel
+*/
+
+/*!
+ \enum Qt::MatchFlag
+
+ This enum describes the type of matches that can be used when searching
+ for items in a model.
+
+ \value MatchExactly Performs QVariant-based matching.
+ \value MatchFixedString Performs string-based matching.
+ String-based comparisons are case-insensitive unless the
+ \c MatchCaseSensitive flag is also specified.
+ \value MatchContains The search term is contained in the item.
+ \value MatchStartsWith The search term matches the start of the item.
+ \value MatchEndsWith The search term matches the end of the item.
+ \value MatchCaseSensitive The search is case sensitive.
+ \value MatchRegExp Performs string-based matching using a regular
+ expression as the search term.
+ \value MatchWildcard Performs string-based matching using a string with
+ wildcards as the search term.
+ \value MatchWrap Perform a search that wraps around, so that when
+ the search reaches the last item in the model, it begins again at
+ the first item and continues until all items have been examined.
+ \value MatchRecursive Searches the entire hierarchy.
+
+ \sa QString::compare(), QRegExp
+*/
+
+/*!
+ \enum Qt::TextElideMode
+
+ This enum specifies where the ellipsis should appear when
+ displaying texts that don't fit:
+
+ \value ElideLeft The ellipsis should appear at the beginning of the text.
+ \value ElideRight The ellipsis should appear at the end of the text.
+ \value ElideMiddle The ellipsis should appear in the middle of the text.
+ \value ElideNone Ellipsis should NOT appear in the text.
+
+ Qt::ElideMiddle is normally the most appropriate choice for URLs (e.g.,
+ "\l{http://qt.nokia.com/careers/movingto/brisbane/}{http://qt.nok...ovingto/brisbane/}"),
+ whereas Qt::ElideRight is appropriate
+ for other strings (e.g.,
+ "\l{http://qt.nokia.com/doc/qq/qq09-mac-deployment.html}{Deploying Applications on Ma...}").
+
+ \sa QAbstractItemView::textElideMode, QFontMetrics::elidedText(), AlignmentFlag QTabBar::elideMode
+*/
+
+/*!
+ \enum Qt::WindowModality
+
+ \keyword modal
+
+ This enum specifies the behavior of a modal window. A modal window
+ is one that blocks input to other windows. Note that windows that
+ are children of a modal window are not blocked.
+
+ The values are:
+ \value NonModal The window is not modal and does not block input to other windows.
+ \value WindowModal The window is modal to a single window hierarchy and blocks input to its parent window, all grandparent windows, and all siblings of its parent and grandparent windows.
+ \value ApplicationModal The window is modal to the application and blocks input to all windows.
+
+ \sa QWidget::windowModality, QDialog
+*/
+
+/*!
+ \enum Qt::TextInteractionFlag
+
+ This enum specifies how a text displaying widget reacts to user input.
+
+ \value NoTextInteraction No interaction with the text is possible.
+ \value TextSelectableByMouse Text can be selected with the mouse and copied to the clipboard using
+ a context menu or standard keyboard shortcuts.
+ \value TextSelectableByKeyboard Text can be selected with the cursor keys on the keyboard. A text cursor is shown.
+ \value LinksAccessibleByMouse Links can be highlighted and activated with the mouse.
+ \value LinksAccessibleByKeyboard Links can be focused using tab and activated with enter.
+ \value TextEditable The text is fully editable.
+
+ \value TextEditorInteraction The default for a text editor.
+ \value TextBrowserInteraction The default for QTextBrowser.
+*/
+
+/*!
+ \enum Qt::MaskMode
+
+ This enum specifies the behavior of the
+ QPixmap::createMaskFromColor() and QImage::createMaskFromColor()
+ functions.
+
+ \value MaskInColor Creates a mask where all pixels matching the given color are opaque.
+ \value MaskOutColor Creates a mask where all pixels matching the given color are transparent.
+*/
+
+/*!
+ \enum Qt::DockWidgetAreaSizes
+ \internal
+*/
+
+/*!
+ \enum Qt::ToolBarAreaSizes
+ \internal
+*/
+
+/*!
+ \enum Qt::EventPriority
+
+ This enum can be used to specify event priorities.
+
+ \value HighEventPriority Events with this priority are sent before
+ events with NormalEventPriority or LowEventPriority.
+
+ \value NormalEventPriority Events with this priority are sent
+ after events with HighEventPriority, but before events with
+ LowEventPriority.
+
+ \value LowEventPriority Events with this priority are sent after
+ events with HighEventPriority or NormalEventPriority.
+
+ Note that these values are provided purely for convenience, since
+ event priorities can be any value between \c INT_MAX and \c
+ INT_MIN, inclusive. For example, you can define custom priorities
+ as being relative to each other:
+
+ \snippet doc/src/snippets/code/doc_src_qnamespace.qdoc 1
+
+ \sa QCoreApplication::postEvent()
+*/
+/*!
+ \enum Qt::SizeHint
+ \since 4.4
+
+ This enum is used by QGraphicsLayoutItem::sizeHint()
+
+ \value MinimumSize is used to specify the minimum size of a graphics layout item.
+ \value PreferredSize is used to specify the preferred size of a graphics layout item.
+ \value MaximumSize is used to specify the maximum size of a graphics layout item.
+ \value MinimumDescent is used to specify the minimum descent of a text string in a graphics layout item.
+ \omitvalue NSizeHints
+
+ \sa QGraphicsLayoutItem::sizeHint()
+*/
+
+/*!
+ \enum Qt::SizeMode
+ \since 4.4
+
+ This enum is used by QPainter::drawRoundedRect() and QPainterPath::addRoundedRect()
+ functions to specify the radii of rectangle corners with respect to the dimensions
+ of the bounding rectangles specified.
+
+ \value AbsoluteSize Specifies the size using absolute measurements.
+ \value RelativeSize Specifies the size relative to the bounding rectangle,
+ typically using percentage measurements.
+*/
+
+/*!
+ \enum Qt::WindowFrameSection
+ \since 4.4
+
+ This enum is used to describe parts of a window frame. It is returned by
+ QGraphicsWidget::windowFrameSectionAt() to describe what section of the window
+ frame is under the mouse.
+
+ \value NoSection
+ \value LeftSection
+ \value TopLeftSection
+ \value TopSection
+ \value TopRightSection
+ \value RightSection
+ \value BottomRightSection
+ \value BottomSection
+ \value BottomLeftSection
+ \value TitleBarArea
+
+ \sa QGraphicsWidget::windowFrameEvent()
+ \sa QGraphicsWidget::paintWindowFrame()
+ \sa QGraphicsWidget::windowFrameSectionAt()
+
+*/
+
+/*!
+ \enum Qt::TileRule
+ \since 4.6
+
+ This enum describes how to repeat or stretch the parts of an image
+ when drawing.
+
+ \value Stretch Scale the image to fit to the available area.
+
+ \value Repeat Tile the image until there is no more space. May crop
+ the last image.
+
+ \value Round Like Repeat, but scales the images down to ensure that
+ the last image is not cropped.
+*/
+
+/*!
+ \enum Qt::Initialization
+ \internal
+*/
+
+/*!
+ \enum Qt::GestureState
+ \since 4.6
+
+ This enum type describes the state of a gesture.
+
+ \value NoGesture Initial state
+ \value GestureStarted A continuous gesture has started.
+ \value GestureUpdated A gesture continues.
+ \value GestureFinished A gesture has finished.
+
+ \sa QGesture
+*/