Long live Qt 4.5!

1 files changed, 2660 insertions, 0 deletions

diff --git a/doc/src/qnamespace.qdoc b/doc/src/qnamespace.qdoc
new file mode 100644
index 0000000..6220795
--- /dev/null
+++ b/doc/src/qnamespace.qdoc
@@ -0,0 +1,2660 @@
+/****************************************************************************
+**
+** Copyright (C) 2009 Nokia Corporation and/or its subsidiary(-ies).
+** Contact: Qt Software Information (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 qt-sales@nokia.com.
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+/*!
+    \namespace Qt
+
+    \brief The Qt namespace contains miscellaneous identifiers
+    used throughout the Qt library.
+
+    \ingroup misc
+*/
+
+/*!
+    \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 Is a Windows specific
+           attribute, that will make the Direct3D paint engine the
+           default Qt widget paint engine.  Note that you can toggle
+           usage of the Direct3D engine on individual QWidgets by
+           setting/clearing the \c WA_MSWindowsUseDirect3D attribute
+           on a specific widget. \bold {This functionality is
+           experimental}.
+
+    \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 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 a 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.
+
+    \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
+
+    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.
+
+    \omitvalue AutoCompatConnection
+    \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 dead locks 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.
+
+    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 Makes drawing to a widget
+    with this attribute set use the Direct3D paint engine, if the
+    Direct3D paint engine is available. \bold {This functionality
+    is experimental.}
+
+    \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.
+
+    \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
+*/
+
+/*! \typedef Qt::HANDLE
+
+    Platform-specific handle type for system objects. This is
+    equivalent to \c{void *} on Windows and Mac OS X, and embedded
+    Linux, and to \c{unsigned long} on X11.
+
+    \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.
+*/
+
+/*!
+    \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 widget is a Macintosh sheet.
+
+    \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.
+
+                            On X11 this value is used to do a move.
+
+                            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::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.
+
+    The general purpose roles are:
+
+    \value DisplayRole    The key data to be rendered in the form of text.
+    \value DecorationRole The data to be rendered as a decoration in the form
+                          of an icon.
+    \value EditRole       The data in a form suitable for editing in an
+                          editor.
+    \value ToolTipRole    The data displayed in the item's tooltip.
+    \value StatusTipRole  The data displayed in the status bar.
+    \value WhatsThisRole  The data displayed for the item in "What's This?"
+                          mode.
+    \value SizeHintRole   The size hint for the item that will be supplied
+                          to views.
+
+    Roles describing appearance and meta data:
+
+    \value FontRole            The font used for items rendered with the default
+                               delegate.
+    \value TextAlignmentRole   The alignment of the text for items rendered with the
+                               default delegate.
+    \value BackgroundRole      The background brush used for items rendered with
+                               the default delegate.
+    \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.
+    \value TextColorRole       This role is obsolete. Use ForegroundRole instead.
+    \value CheckStateRole      This role is used to obtain the checked state of
+                               an item (see \l Qt::CheckState).
+
+    Accessibility roles:
+
+    \value AccessibleTextRole        The text to be used by accessibility
+                                     extensions and plugins, such as screen
+                                     readers.
+    \value AccessibleDescriptionRole A description of the item for accessibility
+                                     purposes.
+
+    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
+*/
+
+/*!
+    \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://www.qtsoftware.com/careers/movingto/beijing/}{http://www.qtsof...ovingto/beijing/}"),
+    whereas Qt::ElideRight is appropriate
+    for other strings (e.g.,
+    "\l{http://doc.trolltech.com/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()
+
+*/