/****************************************************************************

**

** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).

** All rights reserved.

** 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 Technology Preview License Agreement accompanying

** this package.

**

** GNU Lesser General Public License Usage

** Alternatively, this file may be used under the terms of the GNU Lesser

** General Public License version 2.1 as published by the Free Software

** Foundation and appearing in the file LICENSE.LGPL included in the

** packaging of this file.  Please review the following information to

** ensure the GNU Lesser General Public License version 2.1 requirements

** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.

**

** In addition, as a special exception, Nokia gives you certain additional

** rights.  These rights are described in the Nokia Qt LGPL Exception

** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.

**

** If you have questions regarding the use of this file, please contact

** Nokia at qt-info@nokia.com.

**

**

**

**

**

**

**

**

** $QT_END_LICENSE$

**

****************************************************************************/

/*!

    \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).

    \value AA_S60DontConstructApplicationPanes Stops Qt from initializing the S60 status

           pane and softkey pane on Symbian. This is useful to save memory and reduce

           startup time for applications that will run in fullscreen mode during their

           whole lifetime. This attribute must be set before QApplication is

           constructed.

    \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 AutoConnection

    	   (default) Same as DirectConnection, if the emitter and

       	   receiver are in the same thread. Same as QueuedConnection,

       	   if the emitter and receiver are in different threads.