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