Qt Namespace

Type Documentation

enum Qt::AlignmentFlag
flags Qt::Alignment

This enum type is used to describe alignment. It contains horizontal and vertical flags that can be combined to produce the required effect.

The TextElideMode enum can also be used in many situations to fine-tune the appearance of aligned text.

The horizontal flags are:

The vertical flags are:

You can use only one of the horizontal flags at a time. There is one two-dimensional flag:

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:

Masks:

Conflicting combinations of flags have undefined meanings.

The Alignment type is a typedef for QFlags<AlignmentFlag>. It stores an OR combination of AlignmentFlag values.

enum Qt::AnchorPoint

Specifies a side of a layout item that can be anchored. This is used by QGraphicsAnchorLayout.

See also QGraphicsAnchorLayout.

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

When this attribute is true Qt will not do the remapping, and pressing the Command modifier will result in Qt::MetaModifier, while pressing the Control modifier will result in Qt::ControlModifier.

Note that the QKeySequence::StandardKey sequences will always be based on the same modifier (i.e., QKeySequence::Copy will be Command+C regardless of the value set), but what is output for QKeySequence::toString() will be different.

enum Qt::ApplicationState
flags Qt::ApplicationStates

This enum type is used to specify the current state of the application.

The states are

The ApplicationStates type is a typedef for QFlags<ApplicationState>. It stores an OR combination of ApplicationState values.

enum Qt::ArrowType

enum Qt::AspectRatioMode

This enum type defines what happens to the aspect ratio when scaling an rectangle.

See also QSize::scale() and QImage::scaled().

enum Qt::Axis

This enum type defines three values to represent the three axes in the cartesian coordinate system.

See also QTransform::rotate() and QTransform::rotateRadians().

enum Qt::BGMode

Background mode:

enum Qt::BrushStyle

This enum type defines the brush styles supported by Qt, i.e. the fill pattern of shapes drawn using QPainter.

See also QBrush.

enum Qt::CaseSensitivity

enum Qt::CheckState

This enum describes the state of checkable items, controls, and widgets.

See also QCheckBox, Qt::ItemFlags, and Qt::ItemDataRole.

enum Qt::ChecksumType

This enum describes the possible standards used by qChecksum().

enum Qt::ClipOperation

enum class Qt::ColorScheme

Represents the appearance of an application's theme, defined by QGuiApplication::palette().

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.

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:

 QObject::connect: Cannot queue arguments of type 'MyType'

Call qRegisterMetaType() to register the data type before you establish the connection.

When using signals and slots with multiple threads, see Signals and Slots Across Threads.

See also Thread Support in Qt, QObject::connect(), qRegisterMetaType(), and Q_DECLARE_METATYPE().

enum Qt::ContextMenuPolicy

This enum type defines the various policies a widget can have with respect to showing a context menu.

enum Qt::CoordinateSystem

This enum specifies the coordinate system.

enum Qt::Corner

This enum type specifies a corner in a rectangle:

enum Qt::CursorMoveStyle

This enum describes the movement style available to text cursors. The options are:

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.

enum Qt::DateFormat

See also QDate::toString(), QTime::toString(), QDateTime::toString(), QDate::fromString(), QTime::fromString(), and QDateTime::fromString().

enum Qt::DayOfWeek

enum Qt::DockWidgetArea
flags Qt::DockWidgetAreas

Represents the areas a QDockWidget can be plugged to.

The DockWidgetAreas type is a typedef for QFlags<DockWidgetArea>. It stores an OR combination of DockWidgetArea values.

See also QDockWidget::setAllowedAreas and QDockWidget::isAreaAllowed.

enum Qt::DropAction
flags Qt::DropActions

The DropActions type is a typedef for QFlags<DropAction>. It stores an OR combination of DropAction values.

enum Qt::Edge
flags Qt::Edges

This enum type specifies an edge in a rectangle:

The Edges type is a typedef for QFlags<Edge>. It stores an OR combination of Edge values.

enum Qt::EnterKeyType

This can be used to alter the appearance of the Return key on an on-screen keyboard.

enum Qt::EventPriority

This enum can be used to specify event priorities.

Note that these values are provided purely for convenience, since event priorities can be any value between INT_MAX and INT_MIN, inclusive. For example, you can define custom priorities as being relative to each other:

 enum CustomEventPriority
 {
     // An important event
     ImportantEventPriority = Qt::HighEventPriority,

     // A more important event
     MoreImportantEventPriority = ImportantEventPriority + 1,

     // A critical event
     CriticalEventPriority = 100 * MoreImportantEventPriority,

     // Not that important
     StatusEventPriority = Qt::LowEventPriority,

     // These are less important than Status events
     IdleProcessingDoneEventPriority = StatusEventPriority - 1
 };

See also QCoreApplication::postEvent().

enum Qt::FillRule

Specifies which method should be used to fill the paths and polygons.

enum Qt::FindChildOption
flags Qt::FindChildOptions

The FindChildOptions type is a typedef for QFlags<FindChildOption>. It stores an OR combination of FindChildOption values.

enum Qt::FocusPolicy

This enum type defines the various policies a widget can have with respect to acquiring keyboard focus.

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.

See also Keyboard Focus in Widgets.

enum Qt::GestureFlag
flags Qt::GestureFlags

This enum type describes additional flags that can be used when subscribing to a gesture.

The GestureFlags type is a typedef for QFlags<GestureFlag>. It stores an OR combination of GestureFlag values.

See also QWidget::grabGesture() and QGraphicsObject::grabGesture().

enum Qt::GestureState

This enum type describes the state of a gesture.

See also QGesture.

enum Qt::GestureType

This enum type describes the standard gestures.

User-defined gestures are registered with the QGestureRecognizer::registerRecognizer() function which generates a custom gesture ID with the Qt::CustomGesture flag set.

See also QGesture, QWidget::grabGesture(), and QGraphicsObject::grabGesture().

enum Qt::GlobalColor

Qt's predefined QColor objects:

See also QColor.

Qt::HANDLE

A handle type for system objects, defined as void * on all platforms.

enum class Qt::HighDpiScaleFactorRoundingPolicy

This enum describes the possible High-DPI scale factor rounding policies, which decide how non-integer scale factors (such as Windows 150%) are handled.

The active policy is set by calling QGuiApplication::setHighDdpiScaleFactorRoundingPolicy() before the application object is created.

See also QGuiApplication::setHighDpiScaleFactorRoundingPolicy().

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.

enum Qt::ImageConversionFlag
flags Qt::ImageConversionFlags

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):

Dithering mode preference:

Dithering mode preference for 1-bit alpha masks:

Color matching versus dithering preference:

The ImageConversionFlags type is a typedef for QFlags<ImageConversionFlag>. It stores an OR combination of ImageConversionFlag values.

enum Qt::InputMethodHint
flags Qt::InputMethodHints

Flags that alter the behavior:

Flags that restrict input (exclusive flags):

Masks:

The InputMethodHints type is a typedef for QFlags<InputMethodHint>. It stores an OR combination of InputMethodHint values.

See also QGraphicsItem::inputMethodHints().

enum Qt::InputMethodQuery
flags Qt::InputMethodQueries

Masks:

The InputMethodQueries type is a typedef for QFlags<InputMethodQuery>. It stores an OR combination of InputMethodQuery values.

See also QInputMethodQueryEvent.

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:

Roles describing appearance and meta data (with associated types):

Accessibility roles (with associated types):

User roles:

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
flags Qt::ItemFlags

This enum describes the properties of an item:

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.

Note that it is undefined behavior to reimplement QAbstractItemModel::hasChildren to return true for an index if that index has the Qt::ItemNeverHasChildren flag set.

The ItemFlags type is a typedef for QFlags<ItemFlag>. It stores an OR combination of ItemFlag values.

See also QAbstractItemModel.

enum Qt::ItemSelectionMode

This enum is used in QGraphicsItem, QGraphicsScene and QGraphicsView to specify how items are selected, or how to determine if shapes and items collide.

See also QGraphicsScene::items(), QGraphicsScene::collidingItems(), QGraphicsView::items(), QGraphicsItem::collidesWithItem(), and QGraphicsItem::collidesWithPath().

enum Qt::ItemSelectionOperation

This enum is used in QGraphicsScene to specify what to do with currently selected items when setting a selection area.

See also QGraphicsScene::setSelectionArea().

enum Qt::Key

The key names used by Qt.

See also QKeyEvent::key().

enum Qt::KeyboardModifier
flags Qt::KeyboardModifiers

This enum describes the modifier keys.

The KeyboardModifiers type is a typedef for QFlags<KeyboardModifier>. It stores an OR combination of KeyboardModifier values.

See also MouseButton and Modifier.

enum Qt::LayoutDirection

Specifies the direction of Qt's layouts and text handling.

Right-to-left layouts are necessary for certain languages, notably Arabic and Hebrew.

LayoutDirectionAuto serves two purposes. When used in conjunction with widgets and layouts, it will imply to use the layout direction set on the parent widget or QApplication. This has the same effect as QWidget::unsetLayoutDirection().

When LayoutDirectionAuto is used in conjunction with text layouting, it will imply that the text directionality is determined from the content of the string to be layouted.

See also QGuiApplication::setLayoutDirection(), QWidget::setLayoutDirection(), QTextOption::setTextDirection(), and QString::isRightToLeft().

enum Qt::MaskMode

This enum specifies the behavior of the QPixmap::createMaskFromColor() and QImage::createMaskFromColor() functions.

enum Qt::MatchFlag
flags Qt::MatchFlags

This enum describes the type of matches that can be used when searching for items in a model.

The MatchFlags type is a typedef for QFlags<MatchFlag>. It stores an OR combination of MatchFlag values.

See also QString::compare() and QRegularExpression.

enum Qt::Modifier
flags Qt::Modifiers

This enum provides shorter names for the keyboard modifier keys supported by Qt.

The Modifiers type is a typedef for QFlags<Modifier>. It stores an OR combination of Modifier values.

See also KeyboardModifier and MouseButton.

enum Qt::MouseButton
flags Qt::MouseButtons

This enum type describes the different mouse buttons.

The MouseButtons type is a typedef for QFlags<MouseButton>. It stores an OR combination of MouseButton values.

See also KeyboardModifier and Modifier.

enum Qt::MouseEventFlag
flags Qt::MouseEventFlags

This enum provides additional information concerning a QMouseEvent.

The MouseEventFlags type is a typedef for QFlags<MouseEventFlag>. It stores an OR combination of MouseEventFlag values.

enum Qt::MouseEventSource

This enum describes the source of a mouse event and can be useful to determine if the event is an artificial mouse event originating from another device such as a touchscreen.

See also Qt::AA_SynthesizeMouseForUnhandledTouchEvents.

enum Qt::NativeGestureType

This enum returns the gesture type.

enum Qt::NavigationMode

This enum type describes the mode for moving focus.

See also QApplication::setNavigationMode() and QApplication::navigationMode().

enum Qt::Orientation
flags Qt::Orientations

This type is used to signify an object's orientation.

Orientation is used with QScrollBar for example.

The Orientations type is a typedef for QFlags<Orientation>. It stores an OR combination of Orientation values.

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.

See also 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.

See also QPen.

enum Qt::PenStyle

This enum type defines the pen styles that can be drawn using QPainter. The styles are:

See also QPen.

[since 6.5] enum class Qt::PermissionStatus

This enum describes the possible statuses of a permissions.

This enum was introduced in Qt 6.5.

See also QCoreApplication::requestPermission(), QCoreApplication::checkPermission(), and Application Permissions.

enum Qt::ReturnByValueConstant

This is a dummy type, designed to help users transition from certain deprecated APIs to their replacement APIs.

See also QCursor::bitmap(), QCursor::mask(), QLabel::picture(), and QLabel::pixmap().

enum Qt::ScreenOrientation
flags Qt::ScreenOrientations

This enum type specifies the various orientations a screen might have.

The ScreenOrientations type is a typedef for QFlags<ScreenOrientation>. It stores an OR combination of ScreenOrientation values.

enum Qt::ScrollBarPolicy

This enum type describes the various modes of QAbstractScrollArea's scroll bars.

(The modes for the horizontal and vertical scroll bars are independent.)

enum Qt::ScrollPhase

This enum describes the phase of scrolling.

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:

enum Qt::SizeHint

This enum is used by QGraphicsLayoutItem::sizeHint()

See also QGraphicsLayoutItem::sizeHint().

enum Qt::SizeMode

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.

enum Qt::SortOrder

This enum describes how the items in a widget are sorted.

enum Qt::SplitBehaviorFlags
flags Qt::SplitBehavior

This enum specifies how the split() functions should behave with respect to empty strings.

The SplitBehavior type is a typedef for QFlags<SplitBehaviorFlags>. It stores an OR combination of SplitBehaviorFlags values.

See also QString::split().

enum Qt::TabFocusBehavior

This enum type provides different focus behaviors for tab navigation.

enum Qt::TextElideMode

This enum specifies where the ellipsis should appear when displaying texts that don't fit:

Qt::ElideMiddle is normally the most appropriate choice for URLs (e.g., "http://bugreports.qt.../QTWEBSITE-13/"), whereas Qt::ElideRight is appropriate for other strings (e.g., "Deploying Applications on Ma...").

See also QAbstractItemView::textElideMode, QFontMetrics::elidedText(), AlignmentFlag, and QTabBar::elideMode.

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:

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::TextFormat

This enum is used in widgets that can display both plain text and rich text, for example 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 QTextEdit::setTextFormat() function.

enum Qt::TextInteractionFlag
flags Qt::TextInteractionFlags

This enum specifies how a text displaying widget reacts to user input.

The TextInteractionFlags type is a typedef for QFlags<TextInteractionFlag>. It stores an OR combination of TextInteractionFlag values.

enum Qt::TileRule

This enum describes how to repeat or stretch the parts of an image when drawing.

enum Qt::TimeSpec

Both LocalTime and TimeZone will take care of transitions, such as the start and end of daylight-saving time. UTC is the standard time relative to which time-zones are usually specified: Greenwich Mean Time has zero offset from it. Neither UTC nor OffsetFromUTC has any transitions.

When specifying a datetime using OffsetFromUTC, the offset from UTC must also be supplied (it is measured in seconds). To specify a datetime using TimeZone, a QTimeZone must be supplied. From Qt 6.5, a QTimeZone can now package a timespec with, where needed, an offset as a lightweight time description, so that passing a QTimeZone now provides a uniform way to use datetime APIs, saving the need to call them differently for different timespecs.

See also QTimeZone and QDateTime.

enum Qt::TimerType

The timer type indicates how accurate a timer can be.

On UNIX (including Linux, macOS, and iOS), Qt will keep millisecond accuracy for Qt::PreciseTimer. For Qt::CoarseTimer, the interval will be adjusted up to 5% to align the timer with other timers that are expected to fire at or around the same time. The objective is to make most timers wake up at the same time, thereby reducing CPU wakeups and power consumption.

On Windows, Qt will use Windows's Multimedia timer facility (if available) for Qt::PreciseTimer and normal Windows timers for Qt::CoarseTimer and Qt::VeryCoarseTimer.

On all platforms, the interval for Qt::VeryCoarseTimer is rounded to the nearest full second (e.g. an interval of 23500ms will be rounded to 24000ms, and 20300ms to 20000ms).

enum Qt::ToolBarArea
flags Qt::ToolBarAreas

The ToolBarAreas type is a typedef for QFlags<ToolBarArea>. It stores an OR combination of ToolBarArea values.

enum Qt::ToolButtonStyle

The style of the tool button, describing how the button's text and icon should be displayed.

enum Qt::TouchPointState
flags Qt::TouchPointStates

This enum represents the state of a touch point at the time a QTouchEvent occurred.

The TouchPointStates type is a typedef for QFlags<TouchPointState>. It stores an OR combination of TouchPointState values.

enum Qt::TransformationMode

This enum type defines whether image transformations (e.g., scaling) should be smooth or not.

See also QImage::scaled().

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

See also QApplication::setEffectEnabled() and QGuiApplication::setDesktopSettingsAware().

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.

enum Qt::WidgetAttribute

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.

enum Qt::WindowFrameSection

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.

See also QGraphicsWidget::windowFrameEvent(), QGraphicsWidget::paintWindowFrame(), and QGraphicsWidget::windowFrameSectionAt().

enum Qt::WindowModality

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:

See also QWidget::windowModality and QDialog.

enum Qt::WindowState
flags Qt::WindowStates

This enum type is used to specify the current state of a top-level window.

The states are

The WindowStates type is a typedef for QFlags<WindowState>. It stores an OR combination of WindowState values.

enum Qt::WindowType
flags Qt::WindowFlags

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

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:

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 CustomizeWindowHint flag is used to enable customization of the window controls. This flag must be set to allow the WindowTitleHint, WindowSystemMenuHint, WindowMinimizeButtonHint, WindowMaximizeButtonHint and WindowCloseButtonHint flags to be changed.

The WindowFlags type is a typedef for QFlags<WindowType>. It stores an OR combination of WindowType values.

See also QWidget::windowFlags and Window Flags Example.