Qt Namespace

Der Qt-Namensraum enthält verschiedene Bezeichner, die in der Qt-Bibliothek verwendet werden. Mehr...

Kopfzeile:	`#include <Qt>`
CMake:	`find_package(Qt6 REQUIRED COMPONENTS Core)` `target_link_libraries(mytarget PRIVATE Qt6::Core)`
qmake:	`QT += core`

Veraltete Mitglieder

Namespaces

namespace Literals

Klassen

`(since 6.7)` class	partial_ordering
`(since 6.7)` class	strong_ordering
`(since 6.8)` class	totally_ordered_wrapper
`(since 6.7)` class	weak_ordering

Typen

flags	Alignment
enum	AlignmentFlag { AlignLeft, AlignRight, AlignHCenter, AlignJustify, AlignTop, …, AlignVertical_Mask }
enum	AnchorPoint { AnchorLeft, AnchorHorizontalCenter, AnchorRight, AnchorTop, AnchorVerticalCenter, AnchorBottom }
enum	ApplicationAttribute { AA_QtQuickUseDefaultSizePolicy, AA_DontShowIconsInMenus, AA_DontShowShortcutsInContextMenus, AA_NativeWindows, AA_DontCreateNativeWidgetSiblings, …, AA_DontUseNativeMenuWindows }
enum	ApplicationState { ApplicationSuspended, ApplicationHidden, ApplicationInactive, ApplicationActive }
flags	ApplicationStates
enum	ArrowType { NoArrow, UpArrow, DownArrow, LeftArrow, RightArrow }
enum	AspectRatioMode { IgnoreAspectRatio, KeepAspectRatio, KeepAspectRatioByExpanding }
enum	Axis { XAxis, YAxis, ZAxis }
enum	BGMode { TransparentMode, OpaqueMode }
enum	BrushStyle { NoBrush, SolidPattern, Dense1Pattern, Dense2Pattern, Dense3Pattern, …, TexturePattern }
enum	CaseSensitivity { CaseInsensitive, CaseSensitive }
enum	CheckState { Unchecked, PartiallyChecked, Checked }
enum	ChecksumType { ChecksumIso3309, ChecksumItuV41 }
enum	ClipOperation { NoClip, ReplaceClip, IntersectClip }
enum class	ColorScheme { Unknown, Light, Dark }
enum	ConnectionType { AutoConnection, DirectConnection, QueuedConnection, BlockingQueuedConnection, UniqueConnection, SingleShotConnection }
enum	ContextMenuPolicy { NoContextMenu, PreventContextMenu, DefaultContextMenu, ActionsContextMenu, CustomContextMenu }
`(since 6.8)` enum class	ContextMenuTrigger { Press, Release }
enum	CoordinateSystem { DeviceCoordinates, LogicalCoordinates }
enum	Corner { TopLeftCorner, TopRightCorner, BottomLeftCorner, BottomRightCorner }
enum	CursorMoveStyle { LogicalMoveStyle, VisualMoveStyle }
enum	CursorShape { ArrowCursor, UpArrowCursor, CrossCursor, WaitCursor, IBeamCursor, …, BitmapCursor }
enum	DateFormat { TextDate, ISODateWithMs, ISODate, RFC2822Date }
enum	DayOfWeek { Monday, Tuesday, Wednesday, Thursday, Friday, …, Sunday }
enum	DockWidgetArea { LeftDockWidgetArea, RightDockWidgetArea, TopDockWidgetArea, BottomDockWidgetArea, AllDockWidgetAreas, NoDockWidgetArea }
flags	DockWidgetAreas
enum	DropAction { CopyAction, MoveAction, LinkAction, ActionMask, IgnoreAction, TargetMoveAction }
flags	DropActions
enum	Edge { TopEdge, LeftEdge, RightEdge, BottomEdge }
flags	Edges
enum	EnterKeyType { EnterKeyDefault, EnterKeyReturn, EnterKeyDone, EnterKeyGo, EnterKeySend, …, EnterKeyPrevious }
enum	EventPriority { HighEventPriority, NormalEventPriority, LowEventPriority }
enum	FillRule { OddEvenFill, WindingFill }
enum	FindChildOption { FindDirectChildrenOnly, FindChildrenRecursively }
flags	FindChildOptions
enum	FocusPolicy { TabFocus, ClickFocus, StrongFocus, WheelFocus, NoFocus }
enum	FocusReason { MouseFocusReason, TabFocusReason, BacktabFocusReason, ActiveWindowFocusReason, PopupFocusReason, …, OtherFocusReason }
enum	GestureFlag { DontStartGestureOnChildren, ReceivePartialGestures, IgnoredGesturesPropagateToParent }
flags	GestureFlags
enum	GestureState { NoGesture, GestureStarted, GestureUpdated, GestureFinished, GestureCanceled }
enum	GestureType { TapGesture, TapAndHoldGesture, PanGesture, PinchGesture, SwipeGesture, CustomGesture }
enum	GlobalColor { white, black, red, darkRed, green, …, color1 }
	HANDLE
enum class	HighDpiScaleFactorRoundingPolicy { Round, Ceil, Floor, RoundPreferFloor, PassThrough }
enum	HitTestAccuracy { ExactHit, FuzzyHit }
enum	ImageConversionFlag { AutoColor, ColorOnly, MonoOnly, DiffuseDither, OrderedDither, …, NoFormatConversion }
flags	ImageConversionFlags
enum	InputMethodHint { ImhNone, ImhHiddenText, ImhSensitiveData, ImhNoAutoUppercase, ImhPreferNumbers, …, ImhExclusiveInputMask }
flags	InputMethodHints
flags	InputMethodQueries
enum	InputMethodQuery { ImEnabled, ImCursorRectangle, ImFont, ImCursorPosition, ImSurroundingText, …, ImQueryAll }
enum	ItemDataRole { DisplayRole, DecorationRole, EditRole, ToolTipRole, StatusTipRole, …, UserRole }
enum	ItemFlag { NoItemFlags, ItemIsSelectable, ItemIsEditable, ItemIsDragEnabled, ItemIsDropEnabled, …, ItemIsUserTristate }
flags	ItemFlags
enum	ItemSelectionMode { ContainsItemShape, IntersectsItemShape, ContainsItemBoundingRect, IntersectsItemBoundingRect }
enum	ItemSelectionOperation { ReplaceSelection, AddToSelection }
enum	Key { Key_Escape, Key_Tab, Key_Backtab, Key_Backspace, Key_Return, …, Key_Cancel }
enum	KeyboardModifier { NoModifier, ShiftModifier, ControlModifier, AltModifier, MetaModifier, …, GroupSwitchModifier }
flags	KeyboardModifiers
enum	LayoutDirection { LeftToRight, RightToLeft, LayoutDirectionAuto }
enum	MaskMode { MaskInColor, MaskOutColor }
enum	MatchFlag { MatchExactly, MatchFixedString, MatchContains, MatchStartsWith, MatchEndsWith, …, MatchRecursive }
flags	MatchFlags
enum	Modifier { SHIFT, META, CTRL, ALT }
flags	Modifiers
enum	MouseButton { NoButton, AllButtons, LeftButton, RightButton, MiddleButton, …, ExtraButton24 }
flags	MouseButtons
enum	MouseEventFlag { MouseEventCreatedDoubleClick }
flags	MouseEventFlags
enum	MouseEventSource { MouseEventNotSynthesized, MouseEventSynthesizedBySystem, MouseEventSynthesizedByQt, MouseEventSynthesizedByApplication }
enum	NativeGestureType { BeginNativeGesture, EndNativeGesture, PanNativeGesture, ZoomNativeGesture, SmartZoomNativeGesture, …, SwipeNativeGesture }
enum	NavigationMode { NavigationModeNone, NavigationModeKeypadTabOrder, NavigationModeKeypadDirectional, NavigationModeCursorAuto, NavigationModeCursorForceVisible }
enum	Orientation { Horizontal, Vertical }
flags	Orientations
enum	PenCapStyle { FlatCap, SquareCap, RoundCap }
enum	PenJoinStyle { MiterJoin, BevelJoin, RoundJoin, SvgMiterJoin }
enum	PenStyle { NoPen, SolidLine, DashLine, DotLine, DashDotLine, …, CustomDashLine }
`(since 6.5)` enum class	PermissionStatus { Undetermined, Granted, Denied }
enum	ReturnByValueConstant { }
enum	ScreenOrientation { PrimaryOrientation, LandscapeOrientation, PortraitOrientation, InvertedLandscapeOrientation, InvertedPortraitOrientation }
flags	ScreenOrientations
enum	ScrollBarPolicy { ScrollBarAsNeeded, ScrollBarAlwaysOff, ScrollBarAlwaysOn }
enum	ScrollPhase { NoScrollPhase, ScrollBegin, ScrollUpdate, ScrollEnd, ScrollMomentum }
enum	ShortcutContext { WidgetShortcut, WidgetWithChildrenShortcut, WindowShortcut, ApplicationShortcut }
enum	SizeHint { MinimumSize, PreferredSize, MaximumSize, MinimumDescent }
enum	SizeMode { AbsoluteSize, RelativeSize }
enum	SortOrder { AscendingOrder, DescendingOrder }
flags	SplitBehavior
enum	SplitBehaviorFlags { KeepEmptyParts, SkipEmptyParts }
enum	TabFocusBehavior { NoTabFocus, TabFocusTextControls, TabFocusListControls, TabFocusAllControls }
enum	TextElideMode { ElideLeft, ElideRight, ElideMiddle, ElideNone }
enum	TextFlag { TextSingleLine, TextDontClip, TextExpandTabs, TextShowMnemonic, TextWordWrap, …, TextJustificationForced }
enum	TextFormat { PlainText, RichText, AutoText, MarkdownText }
enum	TextInteractionFlag { NoTextInteraction, TextSelectableByMouse, TextSelectableByKeyboard, LinksAccessibleByMouse, LinksAccessibleByKeyboard, …, TextBrowserInteraction }
flags	TextInteractionFlags
enum	TileRule { StretchTile, RepeatTile, RoundTile }
enum	TimeSpec { LocalTime, UTC, OffsetFromUTC, TimeZone }
`(since 6.8)` enum class	TimerId { Invalid }
enum	TimerType { PreciseTimer, CoarseTimer, VeryCoarseTimer }
enum	ToolBarArea { LeftToolBarArea, RightToolBarArea, TopToolBarArea, BottomToolBarArea, AllToolBarAreas, NoToolBarArea }
flags	ToolBarAreas
enum	ToolButtonStyle { ToolButtonIconOnly, ToolButtonTextOnly, ToolButtonTextBesideIcon, ToolButtonTextUnderIcon, ToolButtonFollowStyle }
enum	TouchPointState { TouchPointUnknownState, TouchPointPressed, TouchPointMoved, TouchPointStationary, TouchPointReleased }
flags	TouchPointStates
enum	TransformationMode { FastTransformation, SmoothTransformation }
enum	UIEffect { UI_AnimateMenu, UI_FadeMenu, UI_AnimateCombo, UI_AnimateTooltip, UI_FadeTooltip, UI_AnimateToolBox }
enum	WhiteSpaceMode { WhiteSpaceNormal, WhiteSpacePre, WhiteSpaceNoWrap }
enum	WidgetAttribute { WA_AcceptDrops, WA_AlwaysShowToolTips, WA_CustomWhatsThis, WA_DeleteOnClose, WA_Disabled, …, WA_ContentsMarginsRespectsSafeArea }
flags	WindowFlags
enum	WindowFrameSection { NoSection, LeftSection, TopLeftSection, TopSection, TopRightSection, …, TitleBarArea }
enum	WindowModality { NonModal, WindowModal, ApplicationModal }
enum	WindowState { WindowNoState, WindowMinimized, WindowMaximized, WindowFullScreen, WindowActive }
flags	WindowStates
enum	WindowType { Widget, Window, Dialog, Sheet, Drawer, …, WindowType_Mask }

Funktionen



`(since 6.2)` void	beginPropertyUpdateGroup()
QTextStream &	bin(QTextStream &stream)
QTextStream &	bom(QTextStream &stream)
QTextStream &	center(QTextStream &stream)
`(since 6.7)` Qt::strong_ordering	compareThreeWay(Enum lhs, Enum rhs)
`(since 6.7)` auto	compareThreeWay(FloatType lhs, IntType rhs)
`(since 6.7)` auto	compareThreeWay(IntType lhs, FloatType rhs)
`(since 6.7)` auto	compareThreeWay(LeftFloat lhs, RightFloat rhs)
`(since 6.7)` auto	compareThreeWay(LeftInt lhs, RightInt rhs)
`(since 6.8)` Qt::strong_ordering	compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, Qt::totally_ordered_wrapper<U > rhs)
`(since 6.8)` Qt::strong_ordering	compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, U rhs)
`(since 6.8)` Qt::strong_ordering	compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, std::nullptr_t rhs*)
`(since 6.8)` Qt::strong_ordering	compareThreeWay(U lhs, Qt::total_ordered_wrapper<T > rhs)
`(since 6.8)` Qt::strong_ordering	compareThreeWay(std::nullptr_t lhs, Qt::total_ordered_wrapper<T > rhs*)
QString	convertFromPlainText(const QString &plain, Qt::WhiteSpaceMode mode)
QTextStream &	dec(QTextStream &stream)
`(since 6.2)` void	endPropertyUpdateGroup()
QTextStream & (QTextStream &stream)	endl(QTextStream &stream)
QTextStream &	fixed(QTextStream &stream)
QTextStream &	flush(QTextStream &stream)
QTextStream &	forcepoint(QTextStream &stream)
QTextStream &	forcesign(QTextStream &stream)
QTextStream &	hex(QTextStream &stream)
QTextStream &	left(QTextStream &stream)
QTextStream &	lowercasebase(QTextStream &stream)
QTextStream &	lowercasedigits(QTextStream &stream)
bool	mightBeRichText(QAnyStringView text)
QTextStream &	noforcepoint(QTextStream &stream)
QTextStream &	noforcesign(QTextStream &stream)
QTextStream & (QTextStream &stream)	noshowbase(QTextStream &stream)
QTextStream &	oct(QTextStream &stream)
QTextStream &	reset(QTextStream &stream)
QTextStream &	right(QTextStream &stream)
QTextStream &	scientific(QTextStream &stream)
QTextStream &	showbase(QTextStream &stream)
QTextStream &	uppercasebase(QTextStream &stream)
QTextStream &	uppercasedigits(QTextStream &stream)
QTextStream &	ws(QTextStream &stream)
QKeyCombination	operator\|(Qt::Key Taste, Qt::KeyboardModifier Modifikator)
QKeyCombination	operator\|(Qt::Taste key, Qt::KeyboardModifier modifier)
QKeyCombination	operator\|(Qt::Taste Taste, Qt::Modifikator modifier)
QKeyCombination	operator\|(Qt::Taste Taste, Qt::Modifikatoren modifier)
QTastenkombination	operator\|(Qt::KeyboardModifier modifier, Qt::Taste key)
QTastenkombination	operator\|(Qt::KeyboardModifiers modifiers, Qt::Key key)
QKeyCombination	operator\|(Qt::Modifikator modifier, Qt::Taste key)
QKeyCombination	operator\|(Qt::Modifikatoren modifier, Qt::Taste key)

Detaillierte Beschreibung

Namespaces

namespace Qt::Literals

Klassen

Klasse partial_ordering

Qt::partial_ordering stellt das Ergebnis eines Vergleichs dar, der ungeordnete Ergebnisse zulässt. Mehr...

Klasse strong_ordering

Qt::strong_ordering stellt einen Vergleich dar, bei dem äquivalente Werte ununterscheidbar sind. Mehr...

Klasse totally_ordered_wrapper

Qt::totally_ordered_wrapper ist ein Wrapper-Typ, der eine strenge Gesamtordnung für die gewrappten Typen bietet. Mehr...

Klasse weak_ordering

Qt::weak_ordering stellt einen Vergleich dar, bei dem gleichwertige Werte noch unterscheidbar sind. Mehr...

Typ-Dokumentation

enum Qt::AlignmentFlag
flags Qt::Alignment

Dieser enum-Typ wird verwendet, um die Ausrichtung zu beschreiben. Er enthält horizontale und vertikale Flags, die kombiniert werden können, um den gewünschten Effekt zu erzielen.

Die Aufzählung TextElideMode kann auch in vielen Situationen verwendet werden, um das Erscheinungsbild von ausgerichtetem Text zu verfeinern.

Die horizontalen Flags sind:

Konstante	Wert	Beschreibung
`Qt::AlignLeft`	`0x0001`	Richtet sich am linken Rand aus.
`Qt::AlignRight`	`0x0002`	Richtet sich am rechten Rand aus.
`Qt::AlignHCenter`	`0x0004`	Zentriert den Text horizontal im verfügbaren Platz.
`Qt::AlignJustify`	`0x0008`	Richtet den Text im verfügbaren Platz aus.

Die vertikalen Flaggen sind:

Konstante	Wert	Beschreibung
`Qt::AlignTop`	`0x0020`	Richtet sich nach oben aus.
`Qt::AlignBottom`	`0x0040`	Richtet sich an der Unterseite aus.
`Qt::AlignVCenter`	`0x0080`	Zentriert vertikal im verfügbaren Raum.
`Qt::AlignBaseline`	`0x0100`	Richtet sich an der Grundlinie aus.

Sie können jeweils nur eine der horizontalen Flaggen verwenden. Es gibt nur eine zweidimensionale Flagge:

Konstante	Wert	Beschreibung
`Qt::AlignCenter`	`AlignVCenter \| AlignHCenter`	Zentriert in beiden Dimensionen.

Sie können maximal ein horizontales und ein vertikales Flag zur gleichen Zeit verwenden. Qt::AlignCenter zählt sowohl als horizontal als auch vertikal.

Drei Enum-Werte sind nützlich in Anwendungen, die im Rechts-nach-Links-Modus ausgeführt werden können:

Konstante	Wert	Beschreibung
`Qt::AlignAbsolute`	`0x0010`	Wenn die Layoutrichtung des Widgets Qt::RightToLeft ist (statt Qt::LeftToRight, dem Standardwert), bezieht sich Qt::AlignLeft auf den rechten Rand und Qt::AlignRight auf den linken Rand. Dies ist normalerweise das gewünschte Verhalten. Wenn Sie wollen, dass Qt::AlignLeft immer "links" und Qt::AlignRight immer "rechts" bedeutet, kombinieren Sie das Flag mit Qt::AlignAbsolute.
`Qt::AlignLeading`	`AlignLeft`	Synonym für Qt::AlignLeft.
`Qt::AlignTrailing`	`AlignRight`	Synonym für Qt::AlignRight.

Masken:

Konstante	Wert
`Qt::AlignHorizontal_Mask`	`AlignLeft \| AlignRight \| AlignHCenter \| AlignJustify \| AlignAbsolute`
`Qt::AlignVertical_Mask`	`AlignTop \| AlignBottom \| AlignVCenter \| AlignBaseline`

Widersprüchliche Kombinationen von Flags haben undefinierte Bedeutungen.

Der Typ Alignment ist ein Typedef für QFlags<AlignmentFlag>. Er speichert eine ODER-Kombination von AlignmentFlag-Werten.

enum Qt::AnchorPoint

Gibt eine Seite eines Layoutelements an, die verankert werden kann. Dies wird von QGraphicsAnchorLayout verwendet.

Konstante	Wert	Beschreibung
`Qt::AnchorLeft`	`0`	Die linke Seite eines Layoutelements.
`Qt::AnchorHorizontalCenter`	`1`	Eine "virtuelle" Seite, die zwischen der linken und der rechten Seite eines Layoutelements zentriert ist.
`Qt::AnchorRight`	`2`	Die rechte Seite eines Layoutelements.
`Qt::AnchorTop`	`3`	Die obere Seite eines Layoutelements.
`Qt::AnchorVerticalCenter`	`4`	Eine "virtuelle" Seite, die zwischen der oberen und der unteren Seite eines Layoutelements zentriert ist.
`Qt::AnchorBottom`	`5`	Die untere Seite eines Layoutelements.

Siehe auch QGraphicsAnchorLayout.

enum Qt::ApplicationAttribute

Diese Aufzählung beschreibt Attribute, die das Verhalten von anwendungsweiten Funktionen ändern. Diese werden mit QCoreApplication::setAttribute() aktiviert und deaktiviert und können mit QCoreApplication::testAttribute() getestet werden.

Konstante	Wert	Beschreibung
`Qt::AA_QtQuickUseDefaultSizePolicy (since Qt 6.7)`	`1`	Qt Quick Layouts verwenden die eingebaute Größenrichtlinie von Item. Wenn diese Einstellung gesetzt ist, füllt Button beispielsweise die verfügbare Breite aus, hat aber eine feste Höhe. Wenn dieser Wert nicht gesetzt ist, wird das Standard-Größenverhalten des Layouts, in dem es sich befindet, verwendet, d. h. die implizite Größe wird als bevorzugte Größe verwendet. Dies wird im Detail unter Festlegen der bevorzugten Größe und Größenbeschränkungen erläutert. Wenn dies eingestellt ist, kann die Standardgrößenrichtlinie des Elements mit dem Layout durch explizite Einstellung von Layout.fillWidth oder Layout.fillHeight außer Kraft gesetzt werden.
`Qt::AA_DontShowIconsInMenus`	`2`	Aktionen mit der Eigenschaft "Icon" werden in keinem Menü angezeigt, es sei denn, sie werden ausdrücklich durch die Eigenschaft QAction::iconVisibleInMenu festgelegt. Der Standardwert dieses Attributs hängt von der Plattform ab. Um das Standardverhalten außer Kraft zu setzen, setzen Sie das Attribut, nachdem QGuiApplication instanziiert worden ist. Menüs, die gerade geöffnet sind oder Menüs, die bereits in der nativen macOS-Menüleiste erstellt wurden , können eine Änderung in diesem Attribut nicht übernehmen. Änderungen an der Eigenschaft QAction::iconVisibleInMenu werden immer übernommen.
`Qt::AA_DontShowShortcutsInContextMenus`	`28`	Aktionen mit der Shortcut-Eigenschaft werden nicht in Shortcut-Menüs angezeigt, es sei denn, sie werden speziell durch die QAction::shortcutVisibleInContextMenu -Eigenschaft festgelegt. Dieser Wert wurde in Qt 5.10 hinzugefügt und basiert standardmäßig auf dem Wert, der von QStyleHints::showShortcutsInContextMenus() gemeldet wird. Um das Standardverhalten außer Kraft zu setzen, setzen Sie den Style-Hinweis bevor QCoreApplication instanziiert wurde, oder setzen Sie dieses Attribut nachdem QCoreApplication instanziiert wurde.
`Qt::AA_NativeWindows`	`3`	Stellt sicher, dass Widgets native Fenster haben.
`Qt::AA_DontCreateNativeWidgetSiblings`	`4`	Stellt sicher, dass Geschwister von nativen Widgets nicht nativ bleiben, es sei denn, sie werden durch das Qt::WA_NativeWindow Attribut spezifisch gesetzt.
`Qt::AA_PluginApplication`	`5`	Zeigt an, dass Qt verwendet wird, um ein Plugin zu erstellen. Abhängig vom Betriebssystem unterdrückt es bestimmte Initialisierungen, die im Fall eines Plugins nicht unbedingt sinnvoll sind. Unter macOS wird zum Beispiel das Laden unserer Nib für das Hauptmenü vermieden und die native Menüleiste nicht übernommen. Wenn dieses Attribut auf true gesetzt wird, wird auch das Attribut AA_DontUseNativeMenuBar auf true gesetzt. Es deaktiviert auch die nativen Ereignisfilter. Dieses Attribut muss gesetzt werden, bevor QGuiApplication erstellt wird. Dieser Wert wurde in Qt 5.7 hinzugefügt.
`Qt::AA_DontUseNativeMenuBar`	`6`	Alle Menüleisten, die erstellt werden, während dieses Attribut auf true gesetzt ist, werden nicht als native Menüleiste verwendet (z.B. die Menüleiste am oberen Rand des Hauptbildschirms unter macOS).
`Qt::AA_MacDontSwapCtrlAndMeta`	`7`	Tastaturkürzel auf Apple-Plattformen basieren in der Regel auf dem Befehl (oder Cmd) Tastaturmodifikator, der durch das ⌘-Symbol dargestellt wird. Zum Beispiel ist die Aktion "Kopieren" Befehl+C (⌘+C). Um die plattformübergreifende Entwicklung zu erleichtern, ordnet Qt standardmäßig die Befehlstaste dem Qt::ControlModifier zu, um sich an andere Plattformen anzupassen. Dies ermöglicht das Erstellen von Tastenkombinationen wie "Strg+J", die dann unter macOS auf Befehl+J abgebildet werden, wie von macOS-Benutzern erwartet. Der eigentliche Control (oder Ctrl) Modifier auf Apple-Plattformen, dargestellt durch ⌃, wird auf Qt::MetaModifier abgebildet.

Wenn dieses Attribut wahr ist, nimmt Qt die Zuordnung nicht vor, und das Drücken des Befehlsmodifizierers führt zu Qt::MetaModifier, während das Drücken des Steuerungsmodifizierers zu Qt::ControlModifier führt.

Beachten Sie, dass die Sequenzen von QKeySequence::StandardKey immer auf demselben Modifikator basieren (d.h. QKeySequence::Copy ist Befehl+C, unabhängig vom eingestellten Wert), aber die Ausgabe für QKeySequence::toString() ist unterschiedlich.

Konstante	Wert	Beschreibung
`Qt::AA_Use96Dpi`	`8`	Geht davon aus, dass der Bildschirm eine Auflösung von 96 DPI hat, anstatt die vom Betriebssystem bereitgestellte Auflösung zu verwenden. Dies führt dazu, dass die Schriftdarstellung auf allen Geräten einheitlich in Pixel pro Punkt erfolgt, anstatt 1 Punkt als 1/72 Zoll zu definieren.
`Qt::AA_SynthesizeTouchForUnhandledMouseEvents`	`11`	Alle Mausereignisse, die von der Anwendung nicht akzeptiert werden, werden stattdessen in Berührungsereignisse übersetzt.
`Qt::AA_SynthesizeMouseForUnhandledTouchEvents`	`12`	Alle Berührungsereignisse, die von der Anwendung nicht akzeptiert werden, werden stattdessen in Mausereignisse der linken Taste umgewandelt. Dieses Attribut ist standardmäßig aktiviert.
`Qt::AA_ForceRasterWidgets`	`14`	Sorgt dafür, dass Widgets der obersten Ebene reine Rasteroberflächen verwenden und unterstützt keine nicht-nativen GL-basierten Child-Widgets.
`Qt::AA_UseDesktopOpenGL`	`15`	Erzwingt die Verwendung von Desktop-OpenGL (z.B. opengl32.dll oder libGL.so) auf Plattformen, die das dynamische Laden der OpenGL-Implementierung verwenden. Dieses Attribut muss gesetzt werden, bevor QGuiApplication erstellt wird. Dieser Wert wurde in Qt 5.3 hinzugefügt.
`Qt::AA_UseOpenGLES`	`16`	Erzwingt die Verwendung von OpenGL ES 2.0 oder höher auf Plattformen, die das dynamische Laden der OpenGL-Implementierung verwenden. Dieses Attribut muss gesetzt werden, bevor QGuiApplication konstruiert wird. Dieser Wert wurde in Qt 5.3 hinzugefügt.
`Qt::AA_UseSoftwareOpenGL`	`17`	Erzwingt die Verwendung einer softwarebasierten OpenGL-Implementierung auf Plattformen, die dynamisches Laden der OpenGL-Implementierung verwenden. Dies wird normalerweise ein gepatchter Build von Mesa llvmpipe sein, der OpenGL 2.1 bereitstellt. Der Wert hat keine Auswirkung, wenn keine solche OpenGL-Implementierung verfügbar ist. Der Standardname dieser Bibliothek ist `opengl32sw.dll` und kann durch Setzen der Umgebungsvariablen QT_OPENGL_DLL überschrieben werden. Siehe die plattformspezifischen Seiten, zum Beispiel Qt für Windows, für weitere Informationen. Dieses Attribut muss gesetzt werden, bevor QGuiApplication erstellt wird. Dieser Wert wurde in Qt 5.4 hinzugefügt.
`Qt::AA_ShareOpenGLContexts`	`18`	Ermöglicht die gemeinsame Nutzung von Ressourcen zwischen den OpenGL-Kontexten, die von Klassen wie QOpenGLWidget und QQuickWidget verwendet werden. Dies ermöglicht die gemeinsame Nutzung von OpenGL-Ressourcen, wie Texturen, zwischen QOpenGLWidget Instanzen, die zu verschiedenen Top-Level-Fenstern gehören. Dieses Attribut muss gesetzt werden, bevor QGuiApplication erstellt wird. Dieser Wert wurde in Qt 5.4 hinzugefügt.
`Qt::AA_SetPalette`	`19`	Zeigt an, ob eine Palette explizit auf QGuiApplication gesetzt wurde. Dieser Wert wurde in Qt 5.5 hinzugefügt.
`Qt::AA_UseStyleSheetPropagationInWidgetStyles`	`22`	Standardmäßig deaktivieren Qt Style Sheets die reguläre Weitergabe von Paletten und Schriften auf QWidget. Wenn dieses Flag aktiviert ist, werden Schriftart- und Palettenänderungen, die von einem Style Sheet vorgenommen werden, nur einmal übertragen, wenn das Style Sheet gesetzt wird. Siehe Die Stylesheet-Syntax - Vererbung für weitere Details. Dieser Wert wurde in Qt 5.7 hinzugefügt.
`Qt::AA_DontUseNativeDialogs`	`23`	Alle Dialoge, die erstellt werden, während dieses Attribut auf true gesetzt ist, verwenden nicht die von der Plattform bereitgestellten nativen Dialoge. Dieser Wert wurde in Qt 5.7 hinzugefügt.
`Qt::AA_SynthesizeMouseForUnhandledTabletEvents`	`24`	Alle Tablett-Ereignisse, die nicht von der Anwendung akzeptiert werden, werden stattdessen in Maus-Ereignisse übersetzt. Dieses Attribut ist standardmäßig aktiviert. Dieser Wert wurde in Qt 5.7 hinzugefügt.
`Qt::AA_CompressHighFrequencyEvents`	`25`	Ermöglicht die Komprimierung von bestimmten häufigen Ereignissen. Auf dem X11-Fenstersystem ist der Standardwert true, was bedeutet, dass QEvent::MouseMove, QEvent::TouchUpdate und Änderungen der Fenstergröße und -position immer dann zusammengefasst werden, wenn sie häufiger auftreten, als die Anwendung sie verarbeitet, so dass sie sich nicht anhäufen und die Anwendung später überfordern. Unter Windows 8 und höher ist der Standardwert ebenfalls wahr, aber er gilt nur für Berührungsereignisse. Maus- und Fensterereignisse bleiben von diesem Flag unbeeinflusst. Auf anderen Plattformen ist der Standardwert false. (In Zukunft kann die Komprimierungsfunktion plattformübergreifend implementiert werden.) Sie können das Attribut testen, um festzustellen, ob die Komprimierung aktiviert ist. Wenn Ihre Anwendung alle Ereignisse ohne Komprimierung verarbeiten muss, können Sie dieses Attribut deaktivieren. Beachten Sie, dass Eingabeereignisse von Tablet-Geräten nicht komprimiert werden. Siehe AA_CompressTabletEvents, wenn diese ebenfalls komprimiert werden sollen. Dieser Wert wurde in Qt 5.7 hinzugefügt.
`Qt::AA_CompressTabletEvents`	`29`	Aktiviert die Komprimierung von Eingabeereignissen von Tablet-Geräten. Beachten Sie, dass AA_CompressHighFrequencyEvents wahr sein muss, damit die Komprimierung von Ereignissen aktiviert werden kann, und dass dieses Flag erstere auf Tablet-Ereignisse ausweitet. Derzeit unterstützt auf dem X11-Fenstersystem, Windows 8 und höher. Der Standardwert ist false. Dieser Wert wurde in Qt 5.10 hinzugefügt.
`Qt::AA_DontCheckOpenGLContextThreadAffinity`	`26`	Wenn ein Kontext mit QOpenGLContext aktuell gemacht wird, wird nicht überprüft, ob QObject thread affinity des QOpenGLContext Objekts derselbe Thread ist, der makeCurrent() aufruft. Dieser Wert wurde in Qt 5.8 hinzugefügt.
`Qt::AA_DisableShaderDiskCache`	`27`	Deaktiviert das Zwischenspeichern von Shader-Programm-Binärdateien auf der Festplatte. Standardmäßig verwenden Qt Quick, QPainter's OpenGL Backend, und jede Anwendung, die QOpenGLShaderProgram mit einer seiner addCacheableShaderFromSource Überladungen verwendet, einen plattenbasierten Programm-Binär-Cache entweder im gemeinsamen oder prozessspezifischen Cache-Speicherort, auf Systemen, die glProgramBinary() unterstützen. Für den unwahrscheinlichen Fall, dass dies problematisch sein sollte, setzen Sie dieses Attribut, um alle plattenbasierten Caches von Shadern zu deaktivieren.
`Qt::AA_DisableSessionManager`	`31`	Deaktiviert die QSessionManager. Standardmäßig verbindet sich Qt mit einem laufenden Session Manager für eine GUI-Anwendung auf unterstützten Plattformen, die Verwendung eines Session Managers kann für Systemdienste redundant sein. Dieses Attribut muss gesetzt werden, bevor QGuiApplication erstellt wird. Dieser Wert wurde in 5.14 hinzugefügt
`Qt::AA_DisableNativeVirtualKeyboard`	`9`	Wenn dieses Attribut gesetzt ist, wird die native virtuelle Bildschirmtastatur nicht automatisch angezeigt, wenn ein Texteingabe-Widget auf einem System ohne physische Tastatur den Fokus erhält. Derzeit nur auf der Windows-Plattform unterstützt. Dieser Wert wurde in 5.15 hinzugefügt.
`Qt::AA_DontUseNativeMenuWindows`	`10`	Menü-Popup-Fenster (z.B. Kontextmenüs, Combobox-Menüs und nicht-native Menübalken-Menüs), die erstellt werden, während dieses Attribut auf true gesetzt ist, werden nicht als native Fenster der obersten Ebene dargestellt, es sei denn, die Implementierung erfordert dies. Dieser Wert wurde in Qt 6.8 hinzugefügt.

enum Qt::ApplicationState
flags Qt::ApplicationStates

Dieser Enum-Typ wird verwendet, um den aktuellen Zustand der Anwendung zu spezifizieren.

Die Zustände sind

Konstante	Wert	Beschreibung
`Qt::ApplicationSuspended`	`0x00000000`	Die Anwendung wird gerade angehalten. Beim Eintritt in diesen Zustand sollte die Anwendung ihren Zustand speichern, alle Aktivitäten einstellen und darauf vorbereitet sein, dass die Code-Ausführung gestoppt wird. Während des Suspendierens kann die Anwendung jederzeit ohne weitere Warnungen beendet werden (z. B. wenn das Betriebssystem aufgrund von Speichermangel gezwungen ist, suspendierte Anwendungen zu löschen).
`Qt::ApplicationHidden`	`0x00000001`	Die Anwendung ist versteckt und läuft im Hintergrund. Dies ist der normale Zustand für Anwendungen, die im Hintergrund arbeiten müssen, z. B. Musik abspielen, während der Benutzer mit anderen Anwendungen interagiert. Die Anwendung sollte alle grafischen Ressourcen freigeben, wenn sie diesen Zustand erreicht.
`Qt::ApplicationInactive`	`0x00000002`	Die Anwendung ist sichtbar, aber nicht für den Vordergrund ausgewählt. Auf Desktop-Plattformen bedeutet dies in der Regel, dass der Benutzer eine andere Anwendung aktiviert hat. Auf mobilen Plattformen tritt dieser Zustand häufiger auf, wenn das Betriebssystem den Benutzer z. B. durch eingehende Anrufe oder SMS-Nachrichten unterbricht. In diesem Zustand sollten Sie CPU-intensive Aufgaben reduzieren.
`Qt::ApplicationActive`	`0x00000004`	Die Anwendung ist sichtbar und für den Vordergrund ausgewählt.

Der Typ ApplicationStates ist ein Typedef für QFlags<ApplicationState>. Er speichert eine ODER-Kombination von ApplicationState-Werten.

enum Qt::ArrowType

Konstante	Wert
`Qt::NoArrow`	`0`
`Qt::UpArrow`	`1`
`Qt::DownArrow`	`2`
`Qt::LeftArrow`	`3`
`Qt::RightArrow`	`4`

enum Qt::AspectRatioMode

Dieser Enum-Typ legt fest, was mit dem Seitenverhältnis passiert, wenn ein Rechteck skaliert wird.

Konstante	Wert	Beschreibung
`Qt::IgnoreAspectRatio`	`0`	Die Größe wird frei skaliert. Das Seitenverhältnis wird nicht beibehalten.
`Qt::KeepAspectRatio`	`1`	Die Größe wird auf ein Rechteck skaliert, das so groß wie möglich innerhalb eines gegebenen Rechtecks ist, wobei das Seitenverhältnis erhalten bleibt.
`Qt::KeepAspectRatioByExpanding`	`2`	Die Größe wird auf ein Rechteck skaliert, das so klein wie möglich außerhalb eines gegebenen Rechtecks ist, wobei das Seitenverhältnis beibehalten wird.

Siehe auch QSize::scale() und QImage::scaled().

enum Qt::Axis

Dieser Enum-Typ definiert drei Werte zur Darstellung der drei Achsen im kartesischen Koordinatensystem.

Konstante	Wert	Beschreibung
`Qt::XAxis`	`0`	Die X-Achse.
`Qt::YAxis`	`1`	Die Y-Achse.
`Qt::ZAxis`	`2`	Die Z-Achse.

Siehe auch QTransform::rotate() und QTransform::rotateRadians().

enum Qt::BGMode

Hintergrundmodus:

Konstant	Wert
`Qt::TransparentMode`	`0`
`Qt::OpaqueMode`	`1`

enum Qt::BrushStyle

Dieser Enum-Typ definiert die von Qt unterstützten Pinselstile, d.h. das Füllmuster von Formen, die mit QPainter gezeichnet werden.

Brush Styles

Konstante	Wert	Beschreibung
`Qt::NoBrush`	`0`	Kein Pinselmuster.
`Qt::SolidPattern`	`1`	Gleichmäßige Farbe.
`Qt::Dense1Pattern`	`2`	Extrem dichtes Pinselmuster.
`Qt::Dense2Pattern`	`3`	Sehr dichtes Pinselmuster.
`Qt::Dense3Pattern`	`4`	Einigermaßen dichtes Pinselmuster.
`Qt::Dense4Pattern`	`5`	Halb dichtes Pinselmuster.
`Qt::Dense5Pattern`	`6`	Etwas spärliches Pinselmuster.
`Qt::Dense6Pattern`	`7`	Sehr spärliches Pinselmuster.
`Qt::Dense7Pattern`	`8`	Äußerst spärliches Pinselmuster.
`Qt::HorPattern`	`9`	Horizontale Linien.
`Qt::VerPattern`	`10`	Vertikale Linien.
`Qt::CrossPattern`	`11`	Sich kreuzende horizontale und vertikale Linien.
`Qt::BDiagPattern`	`12`	Diagonale Linien nach hinten.
`Qt::FDiagPattern`	`13`	Vorwärts gerichtete diagonale Linien.
`Qt::DiagCrossPattern`	`14`	Sich kreuzende diagonale Linien.
`Qt::LinearGradientPattern`	`15`	Lineare Steigung (wird mit einem speziellen QBrush Konstruktor festgelegt).
`Qt::ConicalGradientPattern`	`17`	Konischer Gradient (wird mit einem speziellen QBrush Konstruktor eingestellt).
`Qt::RadialGradientPattern`	`16`	Radialer Verlauf (wird mit einem speziellen QBrush Konstruktor festgelegt).
`Qt::TexturePattern`	`24`	Benutzerdefiniertes Muster (siehe QBrush::setTexture()).

Siehe auch QBrush.

enum Qt::CaseSensitivity

Konstante	Wert
`Qt::CaseInsensitive`	`0`
`Qt::CaseSensitive`	`1`

enum Qt::CheckState

Diese Aufzählung beschreibt den Zustand von überprüfbaren Elementen, Steuerelementen und Widgets.

Konstante	Wert	Beschreibung
`Qt::Unchecked`	`0`	Das Element ist nicht angekreuzt.
`Qt::PartiallyChecked`	`1`	Das Element ist teilweise geprüft. Elemente in hierarchischen Modellen können teilweise geprüft sein, wenn einige, aber nicht alle ihrer Kinder geprüft sind.
`Qt::Checked`	`2`	Das Element ist angekreuzt.

Siehe auch QCheckBox, Qt::ItemFlags, und Qt::ItemDataRole.

enum Qt::ChecksumType

Diese Aufzählung beschreibt die möglichen Standards, die von qChecksum() verwendet werden.

Konstante	Wert	Beschreibung
`Qt::ChecksumIso3309`	`0`	Prüfsummenberechnung auf der Grundlage von ISO 3309.
`Qt::ChecksumItuV41`	`1`	Prüfsummenberechnung auf der Grundlage von ITU-V.41.

enum Qt::ClipOperation

Konstante	Wert	Beschreibung
`Qt::NoClip`	`0`	Diese Operation schaltet das Clipping aus.
`Qt::ReplaceClip`	`1`	Ersetzt den aktuellen Clip-Pfad/Recht/Bereich durch den im Funktionsaufruf angegebenen.
`Qt::IntersectClip`	`2`	Schneidet den aktuellen Clip-Pfad/Recht/Region mit dem im Funktionsaufruf angegebenen Pfad/Recht/Region.

enum class Qt::ColorScheme

Stellt das Aussehen des Themas einer Anwendung dar, definiert durch QGuiApplication::palette().

Konstante	Wert	Beschreibung
`Qt::ColorScheme::Unknown`	`0`	Das Erscheinungsbild ist unbekannt.
`Qt::ColorScheme::Light`	`1`	Die Hintergrundfarben sind heller als die Textfarbe, d. h. das Thema ist hell.
`Qt::ColorScheme::Dark`	`2`	Die Hintergrundfarben sind dunkler als die Textfarbe, d. h. das Thema ist dunkel.

enum Qt::ConnectionType

Diese Aufzählung beschreibt die Arten von Verbindungen, die zwischen Signalen und Slots verwendet werden können. Sie legt insbesondere fest, ob ein bestimmtes Signal sofort an einen Slot geliefert oder für eine spätere Lieferung in eine Warteschlange gestellt wird.

Konstante	Wert	Beschreibung
`Qt::AutoConnection`	`0`	(Standard) Wenn der Empfänger lives in der Thread ist, der das Signal sendet, wird Qt::DirectConnection verwendet. Andernfalls wird Qt::QueuedConnection verwendet. Der Verbindungstyp wird bestimmt, wenn das Signal ausgesendet wird.
`Qt::DirectConnection`	`1`	Der Slot wird sofort aufgerufen, wenn das Signal ausgesendet wird. Der Slot wird in dem signalgebenden Thread ausgeführt.
`Qt::QueuedConnection`	`2`	Der Slot wird aufgerufen, wenn die Kontrolle zur Ereignisschleife des Threads des Empfängers zurückkehrt. Der Slot wird im Thread des Empfängers ausgeführt.
`Qt::BlockingQueuedConnection`	`3`	Wie Qt::QueuedConnection, mit dem Unterschied, dass der signalisierende Thread blockiert, bis der Slot zurückkehrt. Diese Verbindung darf nicht verwendet werden, wenn sich der Empfänger im Signalisierungs-Thread befindet, da sonst die Anwendung blockiert wird.
`Qt::UniqueConnection`	`0x80`	Dies ist ein Flag, das mit jedem der oben genannten Verbindungstypen kombiniert werden kann, indem ein bitweises ODER verwendet wird. Wenn Qt::UniqueConnection gesetzt ist, wird QObject::connect() fehlschlagen, wenn die Verbindung bereits existiert (d.h. wenn das gleiche Signal bereits mit dem gleichen Slot für das gleiche Objektpaar verbunden ist).
`Qt::SingleShotConnection`	`0x100`	Dies ist ein Flag, das mit jedem der oben genannten Verbindungstypen kombiniert werden kann, indem ein bitweises ODER verwendet wird. Wenn Qt::SingleShotConnection gesetzt ist, wird der Slot nur einmal aufgerufen; die Verbindung wird automatisch unterbrochen, wenn das Signal ausgesendet wird. Dieses Flag wurde in Qt 6.0 eingeführt.

Bei Warteschlangenverbindungen müssen die Parameter von Typen sein, die dem Meta-Objektsystem von Qt bekannt sind, da Qt die Argumente kopieren muss, um sie in einem Event hinter den Kulissen zu speichern. Wenn Sie versuchen, eine Warteschlangenverbindung zu verwenden und die Fehlermeldung erhalten:

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

Rufen Sie qRegisterMetaType() auf, um den Datentyp zu registrieren, bevor Sie die Verbindung herstellen.

Bei der Verwendung von Signalen und Slots mit mehreren Threads, siehe Signale und Slots über mehrere Threads hinweg.

Siehe auch Thread-Unterstützung in Qt, QObject::connect(), qRegisterMetaType(), und Q_DECLARE_METATYPE().

enum Qt::ContextMenuPolicy

Dieser Enum-Typ definiert die verschiedenen Richtlinien, die ein Widget in Bezug auf die Anzeige eines Kontextmenüs haben kann.

Konstante	Wert	Beschreibung
`Qt::NoContextMenu`	`0`	das Widget verfügt über kein Kontextmenü, die Handhabung des Kontextmenüs wird auf das übergeordnete Widget verschoben.
`Qt::PreventContextMenu`	`4`	das Widget hat kein Kontextmenü, und im Gegensatz zu `NoContextMenu` wird die Handhabung nicht auf den Elternteil des Widgets verschoben. Das bedeutet, dass alle Ereignisse der rechten Maustaste über QWidget::mousePressEvent() und QWidget::mouseReleaseEvent() garantiert an das Widget selbst weitergeleitet werden.
`Qt::DefaultContextMenu`	`1`	der QWidget::contextMenuEvent() Handler des Widgets wird aufgerufen.
`Qt::ActionsContextMenu`	`2`	das Widget zeigt sein QWidget::actions() als Kontextmenü an.
`Qt::CustomContextMenu`	`3`	Das Widget sendet das Signal QWidget::customContextMenuRequested().

`[since 6.8]` enum class Qt::ContextMenuTrigger

Dieser Enum-Typ definiert das Mausereignis, das zum Auslösen eines Kontextmenüereignisses verwendet wird.

Konstante	Wert	Beschreibung
`Qt::ContextMenuTrigger::Press`	`0`	Kontextmenü beim Drücken der Maus, Standard auf UNIX-Systemen.
`Qt::ContextMenuTrigger::Release`	`1`	Kontextmenü beim Loslassen der Maus, Standardwert unter Windows.

Dieses Enum wurde in Qt 6.8 eingeführt.

Siehe auch QStyleHints::contextMenuTrigger.

enum Qt::CoordinateSystem

Diese Aufzählung gibt das Koordinatensystem an.

Konstante	Wert	Beschreibung
`Qt::DeviceCoordinates`	`0`	Die Koordinaten beziehen sich auf die linke obere Ecke des Malgeräts des Objekts.
`Qt::LogicalCoordinates`	`1`	Die Koordinaten beziehen sich auf die linke obere Ecke des Objekts.

enum Qt::Corner

Dieser Enum-Typ gibt eine Ecke in einem Rechteck an:

Konstante	Wert	Beschreibung
`Qt::TopLeftCorner`	`0x00000`	Die linke obere Ecke des Rechtecks.
`Qt::TopRightCorner`	`0x00001`	Die obere rechte Ecke des Rechtecks.
`Qt::BottomLeftCorner`	`0x00002`	Die untere linke Ecke des Rechtecks.
`Qt::BottomRightCorner`	`0x00003`	Die rechte untere Ecke des Rechtecks.

enum Qt::CursorMoveStyle

Diese Aufzählung beschreibt den für Textcursor verfügbaren Bewegungsstil. Die Optionen sind:

Konstante	Wert	Beschreibung
`Qt::LogicalMoveStyle`	`0`	Innerhalb eines Links-nach-Rechts-Textblocks wird die Cursorposition beim Drücken der linken Pfeiltaste verringert und beim Drücken der rechten Pfeiltaste erhöht. Bei einem Textblock von rechts nach links ist das Verhalten umgekehrt.
`Qt::VisualMoveStyle`	`1`	Wenn Sie die linke Pfeiltaste drücken, bewegt sich der Cursor immer nach links, unabhängig von der Schreibrichtung des Textes. Wenn Sie die rechte Pfeiltaste drücken, bewegt sich der Cursor immer nach rechts.

enum Qt::CursorShape

Dieser Enum-Typ definiert die verschiedenen Cursors, die verwendet werden können.

Der Standard-Pfeilcursor ist der Standard für Widgets im normalen Zustand.

Konstante	Wert	Beschreibung
`Qt::ArrowCursor`	`0`	Der Standard-Pfeilcursor.
`Qt::UpArrowCursor`	`1`	Ein Pfeil, der nach oben zum oberen Rand des Bildschirms zeigt.
`Qt::CrossCursor`	`2`	Ein Fadenkreuz-Cursor, der normalerweise verwendet wird, um dem Benutzer zu helfen, einen Punkt auf dem Bildschirm genau auszuwählen.
`Qt::WaitCursor`	`3`	Eine Sanduhr oder ein Uhr-Cursor, der normalerweise bei Vorgängen angezeigt wird, die den Benutzer daran hindern, mit der Anwendung zu interagieren.
`Qt::IBeamCursor`	`4`	Ein Caret- oder Ibeam-Cursor, der anzeigt, dass ein Widget Texteingaben akzeptieren und anzeigen kann.
`Qt::SizeVerCursor`	`5`	Ein Cursor, der für Elemente verwendet wird, die zur vertikalen Größenänderung von Fenstern der obersten Ebene verwendet werden.
`Qt::SizeHorCursor`	`6`	Ein Cursor, der für Elemente verwendet wird, die zur horizontalen Größenänderung von Fenstern der obersten Ebene verwendet werden.
`Qt::SizeBDiagCursor`	`7`	Ein Cursor, der für Elemente verwendet wird, die für die diagonale Größenänderung von Fenstern der obersten Ebene an ihren oberen rechten und unteren linken Ecken verwendet werden.
`Qt::SizeFDiagCursor`	`8`	Ein Cursor, der für Elemente verwendet wird, die für die diagonale Größenänderung von Fenstern der obersten Ebene an ihren oberen linken und unteren rechten Ecken verwendet werden.
`Qt::SizeAllCursor`	`9`	Ein Cursor, der für Elemente verwendet wird, mit denen die Größe von Fenstern der obersten Ebene in beliebiger Richtung geändert werden kann.
`Qt::BlankCursor`	`10`	Ein leerer/unsichtbarer Cursor, der normalerweise verwendet wird, wenn die Cursorform verborgen werden soll.
`Qt::SplitVCursor`	`11`	Ein Cursor, der für vertikale Splitter verwendet wird und anzeigt, dass ein Griff horizontal gezogen werden kann, um die Nutzung des verfügbaren Platzes anzupassen.
`Qt::SplitHCursor`	`12`	Ein Cursor für horizontale Splitter, der anzeigt, dass ein Griff vertikal gezogen werden kann, um die Nutzung des verfügbaren Platzes anzupassen.
`Qt::PointingHandCursor`	`13`	Ein Cursor mit einer zeigenden Hand, der normalerweise für anklickbare Elemente wie Hyperlinks verwendet wird.
`Qt::ForbiddenCursor`	`14`	Ein gestrichelter Kreiscursor, der normalerweise bei Drag-and-Drop-Vorgängen verwendet wird, um anzuzeigen, dass gezogener Inhalt nicht auf bestimmten Widgets oder in bestimmten Bereichen abgelegt werden kann.
`Qt::OpenHandCursor`	`17`	Ein Cursor, der eine offene Hand darstellt, wird normalerweise verwendet, um anzuzeigen, dass der Bereich unter dem Cursor der sichtbare Teil eines Canvas ist, auf den der Benutzer klicken und ziehen kann, um einen Bildlauf durchzuführen.
`Qt::ClosedHandCursor`	`18`	Ein Cursor, der eine geschlossene Hand darstellt, wird in der Regel verwendet, um anzuzeigen, dass ein Ziehvorgang im Gange ist, der einen Bildlauf beinhaltet.
`Qt::WhatsThisCursor`	`15`	Ein Pfeil mit einem Fragezeichen, der in der Regel verwendet wird, um das Vorhandensein der Hilfe für ein Widget "Was ist das?
`Qt::BusyCursor`	`16`	Eine Sanduhr oder ein Uhr-Cursor, der normalerweise während Operationen angezeigt wird, die es dem Benutzer ermöglichen, mit der Anwendung zu interagieren, während sie im Hintergrund ausgeführt werden.
`Qt::DragMoveCursor`	`20`	Ein Cursor, der normalerweise beim Ziehen eines Elements verwendet wird.
`Qt::DragCopyCursor`	`19`	Ein Cursor, der in der Regel verwendet wird, wenn ein Element zum Kopieren gezogen wird.
`Qt::DragLinkCursor`	`21`	Ein Cursor, der normalerweise verwendet wird, wenn ein Element gezogen wird, um eine Verknüpfung zu ihm herzustellen.
`Qt::BitmapCursor`	`24`

enum Qt::DateFormat

Konstante	Wert	Beschreibung
`Qt::TextDate`	`0`	Das Standardformat von Qt, das den Tages- und Monatsnamen, die Tagesnummer im Monat und das vollständige Jahr enthält. Die Tages- und Monatsnamen sind Kurznamen in Englisch (C-Locale). Dies verwendet für ein Datum das Format `ddd MMM d yyyy`, für eine Zeit `HH:mm:ss` und kombiniert diese als `ddd MMM d HH:mm:ss yyyy` für eine Datums-Zeit, mit einem optionalen Zonen-Offset-Suffix, wo relevant. Beim Lesen aus einer Zeichenkette wird auch ein Bruchteil der Sekunden eines Zeitteils erkannt, wie `HH:mm:ss.zzz`, und einige kleinere Varianten des Formats können erkannt werden, um die Kompatibilität mit früheren Versionen von Qt und mit den für die Zukunft geplanten Änderungen des Formats zu gewährleisten. Insbesondere das Zonen-Offset-Suffix verwendet derzeit `GMT[±tzoff]` mit einem `tzoff` im `HH[[:]mm]` Format (zweistellige Stunden und optionale zweistellige Minuten, mit optionalem Doppelpunkt-Trennzeichen); dies soll sich ändern, um `UTC` anstelle von `GMT` in einer zukünftigen Version von Qt zu verwenden, so dass das geplante `UTC` Format erkannt wird.
`Qt::ISODateWithMs`	`9`	ErweitertesISO 8601-Format: verwendet `yyyy-MM-dd` für Datumsangaben, `HH:mm:ss.zzz` für Zeitangaben oder `yyyy-MM-ddTHH:mm:ss.zzz` (z.B. 2017-07-24T15:46:29.739) für kombinierte Datums- und Zeitangaben, optional mit einem Zeitzonensuffix (Z für UTC, ansonsten ein Offset als ±HH:mm), wo dies angemessen ist. Beim Parsen kann ein einzelnes Leerzeichen, `' '`, anstelle des Trennzeichens `'T'` zwischen Datum und Uhrzeit verwendet werden; andere Trennzeichen sind nicht zulässig. Dieses Format akzeptiert auch die Formate `HH:mm` und `HH` für den Zeitteil, die beide einen gebrochenen Teil, `HH:mm.zzz` oder `HH.zzz`, enthalten können, der auf das letzte vorhandene Feld (Stunde oder Minute) angewendet wird.
`Qt::ISODate`	`1`	Erweitertes FormatISO 8601, wie bei `ISODateWithMs`, jedoch ohne den Millisekundenanteil (`.zzz`) bei der Konvertierung in eine Zeichenkette. Beim Lesen aus einer Zeichenkette gibt es keinen Unterschied: Wenn das letzte Zeitfeld eine Nachkommastelle enthält, wird diese von beiden Formaten akzeptiert.
`Qt::RFC2822Date`	`8`	RFC 2822-, RFC 850- und RFC 1036-Format: Bei der Konvertierung von Datumsangaben in eine Zeichenkette wird das Format `dd MMM yyyy` verwendet, bei Zeitangaben das Format `HH:mm:ss`. Für kombinierte Datums- und Zeitangaben werden diese als `dd MMM yyyy HH:mm:ss ±tzoff` kombiniert (wobei der optionale führende Wochentag des ersten erkannten Formats weggelassen wird). Beim Lesen aus einer Zeichenkette wird entweder `[ddd,] dd MMM yyyy [HH:mm[:ss]][ ±tzoff]` oder `ddd MMM dd[ HH:mm:ss] yyyy[ ±tzoff]` für kombinierte Datums- und Zeitangaben erkannt, wobei `tzoff` ein Zeitzonen-Offset im Format `HHmm` ist. Vor oder nach dem Text können beliebige Abstände erscheinen, und jeder nicht leere Abstand kann die Leerzeichen in diesem Format ersetzen. Für Datums- und Zeitangaben werden dieselben Formate abgeglichen und die unerwünschten Teile ignoriert. Beachten Sie insbesondere, dass eine Uhrzeit nicht ohne ein zugehöriges Datum erkannt wird.

Hinweis: Bei den Formaten ISODate steht jedes y, M und d für eine einzelne Ziffer des Jahres, des Monats und des Tages, die zur Angabe des Datums verwendet werden. Jedes H, m und s steht für eine einzelne Ziffer der Stunde (bis zu 24), Minute und Sekunde, die zur Angabe der Uhrzeit verwendet werden. Eine Stunde von 24, mit Null für alle anderen Zeitfelder, wird als der Beginn des nächsten Tages verstanden. Ein .zzz steht für ein Suffix eines Bruchteils des vorangehenden Feldes, das entweder durch ein Komma ',' oder den Punkt '.' von diesem Feld getrennt werden kann. Genauigkeiten über Millisekunden hinaus werden akzeptiert, aber verworfen, wobei auf die nächste darstellbare Millisekunde aufgerundet wird. Das Vorhandensein eines literalen T Zeichens wird verwendet, um das Datum und die Uhrzeit zu trennen, wenn beide angegeben sind. Bei den Formaten TextDate und RFC2822Date steht ddd für die ersten drei Buchstaben des Wochentags und MMM für die ersten drei Buchstaben des Monatsnamens. Die Namen der Tage und Monate sind immer in Englisch (Gebietsschema C), unabhängig von den Benutzerpräferenzen oder Systemeinstellungen. Die anderen Formatzeichen haben die gleiche Bedeutung wie beim ISODate-Format, mit der Ausnahme, dass 24 nicht als Stunde akzeptiert wird. Teile eines Formats, die in eckige Klammern [...] eingeschlossen sind, sind optional; die eckigen Klammern sind nicht Teil des Formats. Das Plus- oder Minuszeichen '±' steht hier für ein Vorzeichen, '-' für Minus oder '+' für Plus.

Hinweis: Zonenverschiebungen werden östlich von Greenwich positiv und westlich negativ gemessen, wie es für UTC-basierte Verschiebungsnotationen üblich ist (im Widerspruch zu einigen GMT-basierten Zonennamen, wie Etc/GMT+3, die die entgegengesetzte Konvention verwenden).

Siehe auch QDate::toString(), QTime::toString(), QDateTime::toString(), QDate::fromString(), QTime::fromString(), und QDateTime::fromString().

enum Qt::DayOfWeek

Konstante	Wert
`Qt::Monday`	`1`
`Qt::Tuesday`	`2`
`Qt::Wednesday`	`3`
`Qt::Thursday`	`4`
`Qt::Friday`	`5`
`Qt::Saturday`	`6`
`Qt::Sunday`	`7`

enum Qt::DockWidgetArea
flags Qt::DockWidgetAreas

Stellt die Bereiche dar, an die ein QDockWidget angedockt werden kann.

Hinweis: Ein schwebendes Dock Widget mit Tabs kann überall angedockt werden.

Konstante	Wert	Beschreibung
`Qt::LeftDockWidgetArea`	`0x1`	Der linke Andockbereich eines QMainWindow.
`Qt::RightDockWidgetArea`	`0x2`	Der rechte Dockbereich eines QMainWindow.
`Qt::TopDockWidgetArea`	`0x4`	Der obere Dockbereich eines QMainWindow.
`Qt::BottomDockWidgetArea`	`0x8`	Der untere Dockbereich eines QMainWindow.
`Qt::AllDockWidgetAreas`	`DockWidgetArea_Mask`	Alle Dock-Widgetbereiche (Standard).
`Qt::NoDockWidgetArea`	`0`	Keine Dock-Widget-Bereiche.

Der Typ DockWidgetAreas ist ein Typedef für QFlags<DockWidgetArea>. Er speichert eine OR-Kombination von DockWidgetArea-Werten.

Siehe auch QDockWidget::setAllowedAreas und QDockWidget::isAreaAllowed.

enum Qt::DropAction
flags Qt::DropActions

Konstante	Wert	Beschreibung
`Qt::CopyAction`	`0x1`	Kopiert die Daten in das Ziel.
`Qt::MoveAction`	`0x2`	Verschiebt die Daten von der Quelle zum Ziel.
`Qt::LinkAction`	`0x4`	Erstellt eine Verknüpfung von der Quelle zum Ziel.
`Qt::ActionMask`	`0xff`
`Qt::IgnoreAction`	`0x0`	Die Aktion ignorieren (nichts mit den Daten machen).
`Qt::TargetMoveAction`	`0x8002`	Unter Windows wird dieser Wert verwendet, wenn der Besitz der D&D-Daten von der Zielanwendung übernommen werden soll, d.h. die Quellanwendung soll die Daten nicht löschen. Unter X11 wird dieser Wert verwendet, um eine Verschiebung durchzuführen. Auf dem Mac wird TargetMoveAction nicht verwendet.

Der Typ DropActions ist ein Typedef für QFlags<DropAction>. Er speichert eine ODER-Kombination von DropAction-Werten.

enum Qt::Edge
flags Qt::Edges

Dieser Enum-Typ spezifiziert eine Kante in einem Rechteck:

Konstante	Wert	Beschreibung
`Qt::TopEdge`	`0x00001`	Die obere Kante des Rechtecks.
`Qt::LeftEdge`	`0x00002`	Die linke Kante des Rechtecks.
`Qt::RightEdge`	`0x00004`	Die rechte Kante des Rechtecks.
`Qt::BottomEdge`	`0x00008`	Die untere Kante des Rechtecks.

Der Typ Edges ist ein Typedef für QFlags<Edge>. Er speichert eine ODER-Kombination von Kantenwerten.

enum Qt::EnterKeyType

Damit können Sie das Aussehen der Return-Taste auf einer Bildschirmtastatur ändern.

Hinweis: Nicht alle dieser Werte werden auf allen Plattformen unterstützt. Für nicht unterstützte Werte wird stattdessen die Standardtaste verwendet.

Konstante	Wert	Beschreibung
`Qt::EnterKeyDefault`	`0`	Die Standard-Eingabetaste. Dies kann entweder eine Taste sein, die die Tastatur schließt, oder eine Return-Taste, die bei einem mehrzeiligen Eingabefeld eine neue Zeile einfügt.
`Qt::EnterKeyReturn`	`1`	Eine Return-Taste anzeigen, die eine neue Zeile einfügt. Die Tastatur wird nicht geschlossen, wenn diese Taste gedrückt wird.
`Qt::EnterKeyDone`	`2`	Eine Schaltfläche "Fertig" anzeigen. Die Tastatur wird geschlossen, wenn diese Taste gedrückt wird.
`Qt::EnterKeyGo`	`3`	Eine "Go"-Schaltfläche anzeigen. Wird in der Regel in einer Adressleiste verwendet, wenn eine URL eingegeben wird; die Tastatur wird geschlossen, wenn diese Schaltfläche gedrückt wird.
`Qt::EnterKeySend`	`4`	Eine "Senden"-Schaltfläche anzeigen. Die Tastatur wird geschlossen, wenn diese Schaltfläche gedrückt wird.
`Qt::EnterKeySearch`	`5`	Eine Schaltfläche "Suchen" anzeigen. Die Tastatur wird geschlossen, wenn diese Schaltfläche gedrückt wird.
`Qt::EnterKeyNext`	`6`	Eine "Weiter"-Schaltfläche anzeigen. Wird normalerweise in einem Formular verwendet, um die Navigation zum nächsten Eingabefeld zu ermöglichen; die Tastatur wird nicht geschlossen, wenn diese Schaltfläche gedrückt wird.
`Qt::EnterKeyPrevious`	`7`	Eine Schaltfläche "Zurück" anzeigen. Die Tastatur wird nicht geschlossen, wenn diese Schaltfläche gedrückt wird.

enum Qt::EventPriority

Diese Aufzählung kann verwendet werden, um Ereignisprioritäten festzulegen.

Konstante	Wert	Beschreibung
`Qt::HighEventPriority`	`1`	Ereignisse mit dieser Priorität werden vor Ereignissen mit NormalEventPriority oder LowEventPriority gesendet.
`Qt::NormalEventPriority`	`0`	Ereignisse mit dieser Priorität werden nach Ereignissen mit HighEventPriority, aber vor Ereignissen mit LowEventPriority gesendet.
`Qt::LowEventPriority`	`-1`	Ereignisse mit dieser Priorität werden nach Ereignissen mit HighEventPriority oder NormalEventPriority gesendet.

Beachten Sie, dass diese Werte nur der Einfachheit halber angegeben werden, da Ereignisprioritäten jeden Wert zwischen INT_MAX und INT_MIN annehmen können. Sie können beispielsweise benutzerdefinierte Prioritäten als relativ zueinander definieren:

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
};

Siehe auch QCoreApplication::postEvent().

enum Qt::FillRule

Gibt an, welche Methode zum Füllen der Pfade und Polygone verwendet werden soll.

Konstante	Wert	Beschreibung
`Qt::OddEvenFill`	`0`	Legt fest, dass die Region nach der ungeraden, geraden Füllregel gefüllt wird. Mit dieser Regel wird bestimmt, ob ein Punkt innerhalb der Form liegt, indem die folgende Methode verwendet wird. Ziehen Sie eine horizontale Linie von dem Punkt zu einer Stelle außerhalb der Form und zählen Sie die Anzahl der Schnittpunkte. Wenn die Anzahl der Schnittpunkte eine ungerade Zahl ist, liegt der Punkt innerhalb der Form. Dieser Modus ist die Standardeinstellung.
`Qt::WindingFill`	`1`	Legt fest, dass der Bereich unter Verwendung der Nicht-Null-Wicklungsregel gefüllt wird. Mit dieser Regel wird bestimmt, ob ein Punkt innerhalb der Form liegt, indem die folgende Methode verwendet wird. Ziehen Sie eine horizontale Linie von dem Punkt zu einer Stelle außerhalb der Form. Bestimmen Sie, ob die Richtung der Linie an jedem Schnittpunkt nach oben oder unten zeigt. Die Windungszahl wird durch Summieren der Richtungen der einzelnen Schnittpunkte ermittelt. Ist die Zahl ungleich Null, befindet sich der Punkt innerhalb der Form. Dieser Füllmodus kann in den meisten Fällen auch als Schnittpunkt geschlossener Formen betrachtet werden.

enum Qt::FindChildOption
flags Qt::FindChildOptions

Konstante	Wert	Beschreibung
`Qt::FindDirectChildrenOnly`	`0x0`	Betrachtet nur die direkten Kinder des Objekts.
`Qt::FindChildrenRecursively`	`0x1`	Betrachtet alle Kinder des Objekts (rekursive Suche).

Der Typ FindChildOptions ist ein Typedef für QFlags<FindChildOption>. Er speichert eine ODER-Kombination von FindChildOption-Werten.

enum Qt::FocusPolicy

Dieser Enum-Typ definiert die verschiedenen Richtlinien, die ein Widget in Bezug auf den Erwerb des Tastaturfokus haben kann.

Konstante	Wert	Beschreibung
`Qt::TabFocus`	`0x1`	Das Widget akzeptiert den Fokus durch Tabulieren.
`Qt::ClickFocus`	`0x2`	das Widget akzeptiert den Fokus durch Klicken.
`Qt::StrongFocus`	`TabFocus \| ClickFocus \| 0x8`	das Widget akzeptiert den Fokus sowohl durch Tabulieren als auch durch Klicken. Unter macOS zeigt dies auch an, dass das Widget den Tabulator-Fokus akzeptiert, wenn es sich im 'Text/Listen-Fokus-Modus' befindet.
`Qt::WheelFocus`	`StrongFocus \| 0x4`	wie Qt::StrongFocus plus das Widget akzeptiert den Fokus durch die Verwendung des Mausrads.
`Qt::NoFocus`	`0`	das Widget akzeptiert keinen Fokus.

enum Qt::FocusReason

Diese Aufzählung gibt an, warum sich der Fokus geändert hat. Es wird über QWidget::setFocus weitergegeben und kann in der QFocusEvent abgerufen werden, die bei einer Fokusänderung an das Widget gesendet wird.

Konstante	Wert	Beschreibung
`Qt::MouseFocusReason`	`0`	Eine Mausaktion ist aufgetreten.
`Qt::TabFocusReason`	`1`	Die Tabulator-Taste wurde gedrückt.
`Qt::BacktabFocusReason`	`2`	Ein Backtab ist aufgetreten. Die Eingabe hierfür kann die Umschalt- oder Steuerungstaste umfassen, z. B. Umschalt+Tab.
`Qt::ActiveWindowFocusReason`	`3`	Das Fenstersystem hat dieses Fenster entweder aktiv oder inaktiv gemacht.
`Qt::PopupFocusReason`	`4`	Die Anwendung öffnete/schloss ein Popup-Fenster, das den Tastaturfokus aufnahm/freigab.
`Qt::ShortcutFocusReason`	`5`	Der Benutzer tippt das Tastaturkürzel eines Etiketts ein.
`Qt::MenuBarFocusReason`	`6`	Die Menüleiste erhielt den Fokus.
`Qt::OtherFocusReason`	`7`	Ein anderer Grund, normalerweise anwendungsspezifisch.

Siehe auch Tastaturfokus in Widgets.

enum Qt::GestureFlag
flags Qt::GestureFlags

Dieser Enum-Typ beschreibt zusätzliche Flags, die verwendet werden können, wenn eine Geste abonniert wird.

Konstante	Wert	Beschreibung
`Qt::DontStartGestureOnChildren`	`0x01`	Standardmäßig können Gesten auf dem Widget oder über einem seiner Kinder beginnen. Verwenden Sie dieses Flag, um dies zu deaktivieren und eine Geste nur auf dem Widget starten zu lassen.
`Qt::ReceivePartialGestures`	`0x02`	Erlaubt, dass alle ignorierten Gestenereignisse an übergeordnete Widgets weitergegeben werden, die diesen Hinweis angegeben haben. Standardmäßig werden nur Gesten weitergegeben, die sich im Zustand Qt::GestureStarted befinden, und das Widget erhält immer die gesamte Gestensequenz, beginnend mit einer Geste im Zustand Qt::GestureStarted und endend mit einer Geste im Zustand Qt::GestureFinished oder Qt::GestureCanceled.
`Qt::IgnoredGesturesPropagateToParent (since Qt 4.7)`	`0x04`	Ermöglicht eine Feinabstimmung der Gesten-Ereignisausbreitung. Wenn das Flag bei grabbing gesetzt wird, werden alle ignorierten Teilgesten an ihre übergeordneten Elemente weitergegeben.

Der Typ GestureFlags ist ein Typedef für QFlags<GestureFlag>. Er speichert eine ODER-Kombination von GestureFlag-Werten.

Siehe auch QWidget::grabGesture() und QGraphicsObject::grabGesture().

enum Qt::GestureState

Dieser Enum-Typ beschreibt den Zustand einer Geste.

Konstante	Wert	Beschreibung
`Qt::NoGesture`	`0`	Es wurde keine Geste erkannt.
`Qt::GestureStarted`	`1`	Eine kontinuierliche Geste hat begonnen.
`Qt::GestureUpdated`	`2`	Eine Geste wird fortgesetzt.
`Qt::GestureFinished`	`3`	Eine Geste wurde beendet.
`Qt::GestureCanceled`	`4`	Eine Geste wurde abgebrochen.

Siehe auch QGesture.

enum Qt::GestureType

Dieser Enum-Typ beschreibt die Standardgesten.

Konstante	Wert	Beschreibung
`Qt::TapGesture`	`1`	Eine Tap-Geste.
`Qt::TapAndHoldGesture`	`2`	Eine Tippen-und-Halten-Geste (Langes Tippen).
`Qt::PanGesture`	`3`	Eine Schwenkgeste.
`Qt::PinchGesture`	`4`	Eine Kneif-Geste.
`Qt::SwipeGesture`	`5`	Eine Wischgeste.
`Qt::CustomGesture`	`0x0100`	Ein Flag, mit dem getestet werden kann, ob die Geste eine benutzerdefinierte Gesten-ID ist.

Benutzerdefinierte Gesten werden mit der Funktion QGestureRecognizer::registerRecognizer() registriert, die eine benutzerdefinierte Gesten-ID mit gesetztem Qt::CustomGesture-Flag erzeugt.

Siehe auch QGesture, QWidget::grabGesture(), und QGraphicsObject::grabGesture().

enum Qt::GlobalColor

Die vordefinierten QColor Objekte von Qt:

Konstante	Wert	Beschreibung
`Qt::white`	`3`	Weiß (#ffffff)
`Qt::black`	`2`	Schwarz (#000000)
`Qt::red`	`7`	Rot (#ff0000)
`Qt::darkRed`	`13`	Dunkelrot (#800000)
`Qt::green`	`8`	Grün (#00ff00)
`Qt::darkGreen`	`14`	Dunkelgrün (#008000)
`Qt::blue`	`9`	Blau (#0000ff)
`Qt::darkBlue`	`15`	Dunkelblau (#000080)
`Qt::cyan`	`10`	Zyan (#00ffff)
`Qt::darkCyan`	`16`	Dunkles Cyan (#008080)
`Qt::magenta`	`11`	Magenta (#ff00ff)
`Qt::darkMagenta`	`17`	Dunkles Magenta (#800080)
`Qt::yellow`	`12`	Gelb (#ffff00)
`Qt::darkYellow`	`18`	Dunkelgelb (#808000)
`Qt::gray`	`5`	Grau (#a0a0a4)
`Qt::darkGray`	`4`	Dunkelgrau (#808080)
`Qt::lightGray`	`6`	Hellgrau (#c0c0c0)
`Qt::transparent`	`19`	ein transparenter schwarzer Wert (d. h. QColor(0, 0, 0, 0))
`Qt::color0`	`0`	0 Pixelwert (für Bitmaps)
`Qt::color1`	`1`	1 Pixelwert (für Bitmaps)

Siehe auch QColor.

Qt::HANDLE

Ein Handle-Typ für Systemobjekte, definiert als void * auf allen Plattformen.

enum class Qt::HighDpiScaleFactorRoundingPolicy

Diese Aufzählung beschreibt die möglichen High-DPI-Skalierungsfaktor-Rundungsrichtlinien, die entscheiden, wie nicht-ganzzahlige Skalierungsfaktoren (z.B. Windows 150%) behandelt werden.

Die aktive Richtlinie wird durch den Aufruf von QGuiApplication::setHighDdpiScaleFactorRoundingPolicy() gesetzt, bevor das Anwendungsobjekt erstellt wird.

Konstante	Wert	Beschreibung
`Qt::HighDpiScaleFactorRoundingPolicy::Round`	`1`	Aufrunden für .5 und höher.
`Qt::HighDpiScaleFactorRoundingPolicy::Ceil`	`2`	Immer aufrunden.
`Qt::HighDpiScaleFactorRoundingPolicy::Floor`	`3`	Immer abrunden.
`Qt::HighDpiScaleFactorRoundingPolicy::RoundPreferFloor`	`4`	Bei 0,75 und mehr aufrunden.
`Qt::HighDpiScaleFactorRoundingPolicy::PassThrough`	`5`	Nicht aufrunden.

Siehe auch QGuiApplication::setHighDpiScaleFactorRoundingPolicy().

enum Qt::HitTestAccuracy

Diese Aufzählung enthält die Genauigkeitstypen, die von der Klasse QTextDocument beim Testen von Mausklicks auf Textdokumente verwendet werden können.

Konstante	Wert	Beschreibung
`Qt::ExactHit`	`0`	Der Punkt, an dem die Eingabe erfolgte, muss genau mit eingabeempfindlichen Teilen des Dokuments übereinstimmen.
`Qt::FuzzyHit`	`1`	Der Punkt, an dem die Eingabe erfolgte, kann in der Nähe von eingabeempfindlichen Teilen des Dokuments liegen.

enum Qt::ImageConversionFlag
flags Qt::ImageConversionFlags

Die mit "(default)" gekennzeichneten Optionen werden gesetzt, wenn keine anderen Werte aus der Liste enthalten sind (da die Standardwerte Null sind):

Farb-/Mono-Präferenz (ignoriert für QBitmap):

Konstante	Wert	Beschreibung
`Qt::AutoColor`	`0x00000000`	(Standard) - Wenn das Bild den Wert depth 1 hat und nur schwarze und weiße Pixel enthält, wird die Pixmap monochrom.
`Qt::ColorOnly`	`0x00000003`	Die Pixmap wird gedithert/konvertiert in die native display depth.
`Qt::MonoOnly`	`0x00000002`	Die Pixmap wird monochrom. Falls erforderlich, wird sie mit dem gewählten Dithering-Algorithmus gedithert.

Bevorzugter Dithering-Modus:

Konstant	Wert	Beschreibung
`Qt::DiffuseDither`	`0x00000000`	(Standard) - Ein qualitativ hochwertiges Dithering mit Fehlerdiffusion.
`Qt::OrderedDither`	`0x00000010`	Ein schnelleres, geordnetes Dithering.
`Qt::ThresholdDither`	`0x00000020`	Kein Dithering; die nächstliegende Farbe wird verwendet.

Bevorzugter Dithering-Modus für 1-Bit-Alpha-Masken:

Konstant	Wert	Beschreibung
`Qt::ThresholdAlphaDither`	`0x00000000`	(Voreinstellung) - Kein Dithering.
`Qt::OrderedAlphaDither`	`0x00000004`	Ein schnelleres, geordnetes Dithering.
`Qt::DiffuseAlphaDither`	`0x00000008`	Ein hochwertiges Dithering mit Fehlerdiffusion.

Bevorzugung von Farbanpassung gegenüber Dithering:

Konstant	Wert	Beschreibung
`Qt::PreferDither`	`0x00000040`	Bilder bei der Konvertierung in kleinere Farbräume immer dithern.
`Qt::AvoidDither`	`0x00000080`	Dithern Sie nur bei indizierten Formaten, wenn das Quellbild mehr verschiedene Farben enthält als die Größe der Farbtabelle des Zielformats.
`Qt::AutoDither`	`0x00000000`	(Standard) - Dithern Sie nur bei der Abwärtskonvertierung in indizierte 1- oder 8-Bit-Formate.
`Qt::NoOpaqueDetection`	`0x00000100`	Nicht prüfen, ob das Bild nicht-opake Pixel enthält. Verwenden Sie diese Option, wenn Sie wissen, dass das Bild halbtransparent ist und Sie den Overhead vermeiden wollen, der durch die Überprüfung der Pixel im Bild entsteht, bis ein nicht-opakes Pixel gefunden wird, oder wenn die Pixmap aus einem anderen Grund einen Alphakanal behalten soll. Wenn das Bild keinen Alphakanal hat, hat dieses Flag keine Wirkung.
`Qt::NoFormatConversion`	`0x00000200`	Führt keine Formatkonvertierung des Bildes durch. Dies kann z. B. bei der Konvertierung eines QImage in ein QPixmap für einen einmaligen Rendering-Vorgang nützlich sein. Beachten Sie, dass ein QPixmap, das nicht das bevorzugte Format hat, als Malgerät viel langsamer ist.

Der Typ ImageConversionFlags ist ein Typedef für QFlags<ImageConversionFlag>. Er speichert eine ODER-Kombination von ImageConversionFlag-Werten.

enum Qt::InputMethodHint
flags Qt::InputMethodHints

Konstante	Wert	Beschreibung
`Qt::ImhNone`	`0x0`	Keine Hinweise.

Flags, die das Verhalten verändern:

Konstante	Wert	Beschreibung
`Qt::ImhHiddenText`	`0x1`	Die Eingabemethode soll die Zeichen während des Tippens nicht anzeigen. Dies wird automatisch eingestellt, wenn QLineEdit::echoMode auf `Password` gesetzt wird. Beachten Sie, dass die Einstellung `ImhHiddenText` den Echo-Modus nicht ändert.
`Qt::ImhSensitiveData`	`0x2`	Getippter Text sollte von der aktiven Eingabemethode nicht in einem dauerhaften Speicher wie dem prädiktiven Benutzerwörterbuch gespeichert werden.
`Qt::ImhNoAutoUppercase`	`0x4`	Die Eingabemethode sollte nicht versuchen, automatisch zu Großbuchstaben zu wechseln, wenn ein Satz endet.
`Qt::ImhPreferNumbers`	`0x8`	Ziffern werden bevorzugt (sind aber nicht erforderlich).
`Qt::ImhPreferUppercase`	`0x10`	Großbuchstaben werden bevorzugt (sind aber nicht erforderlich).
`Qt::ImhPreferLowercase`	`0x20`	Kleinbuchstaben werden bevorzugt (sind aber nicht erforderlich).
`Qt::ImhNoPredictiveText`	`0x40`	Verwenden Sie bei der Eingabe keine Textvorhersage (d.h. Wörterbuchsuche).
`Qt::ImhDate`	`0x80`	Der Texteditor funktioniert wie ein Datumsfeld.
`Qt::ImhTime`	`0x100`	Der Texteditor funktioniert wie ein Zeitfeld.
`Qt::ImhPreferLatin`	`0x200`	Lateinische Zeichen werden bevorzugt (sind aber nicht erforderlich).
`Qt::ImhMultiLine`	`0x400`	Es können mehrere Zeilen in das Textfeld eingegeben werden.
`Qt::ImhNoEditMenu`	`0x800`	Das eingebaute Editiermenü wird nicht verwendet. Dieses Flag wurde in Qt 5.11 eingeführt.
`Qt::ImhNoTextHandles`	`0x1000`	Den eingebauten Textcursor und die Auswahlgriffe nicht verwenden. Dieses Flag wurde in Qt 5.11 eingeführt.

Flags, die die Eingabe beschränken (exklusive Flags):

Konstante	Wert	Beschreibung
`Qt::ImhDigitsOnly`	`0x10000`	Nur Ziffern sind erlaubt.
`Qt::ImhFormattedNumbersOnly`	`0x20000`	Nur die Eingabe von Zahlen ist erlaubt. Dies schließt Dezimalpunkt und Minuszeichen ein.
`Qt::ImhUppercaseOnly`	`0x40000`	Es ist nur die Eingabe von Großbuchstaben erlaubt.
`Qt::ImhLowercaseOnly`	`0x80000`	Nur die Eingabe von Kleinbuchstaben ist erlaubt.
`Qt::ImhDialableCharactersOnly`	`0x100000`	Es sind nur Zeichen erlaubt, die für die Telefonwahl geeignet sind.
`Qt::ImhEmailCharactersOnly`	`0x200000`	Es sind nur Zeichen erlaubt, die für E-Mail-Adressen geeignet sind.
`Qt::ImhUrlCharactersOnly`	`0x400000`	Nur Zeichen, die für URLs geeignet sind, sind erlaubt.
`Qt::ImhLatinOnly`	`0x800000`	Nur Eingaben in lateinischer Schrift sind erlaubt.

Masken:

Konstante	Wert	Beschreibung
`Qt::ImhExclusiveInputMask`	`0xffff0000`	Diese Maske ergibt einen Wert ungleich Null, wenn eines der Exklusiv-Flags verwendet wird.

Hinweis: Wenn mehrere Exklusiv-Flags miteinander ODER-verknüpft werden, besteht der resultierende Zeichensatz aus der Vereinigung der angegebenen Sätze. Die Angabe von ImhNumbersOnly und ImhUppercaseOnly würde zum Beispiel einen Satz ergeben, der aus Zahlen und Großbuchstaben besteht.

Der Typ InputMethodHints ist ein Typedef für QFlags<InputMethodHint>. Er speichert eine OR-Kombination von InputMethodHint-Werten.

Siehe auch QGraphicsItem::inputMethodHints().

enum Qt::InputMethodQuery
flags Qt::InputMethodQueries

Konstante	Wert	Beschreibung
`Qt::ImEnabled`	`0x1`	Das Widget akzeptiert die Eingabe von Eingabemethoden.
`Qt::ImCursorRectangle`	`0x2`	Das Rechteck, das den Bereich des Eingabecursors in Widgetkoordinaten abdeckt.
`Qt::ImFont`	`0x4`	Die aktuell verwendete Schriftart für die Texteingabe.
`Qt::ImCursorPosition`	`0x8`	Die logische Position des Cursors innerhalb des Textes, der den Eingabebereich umgibt (siehe `ImSurroundingText`). Die Position beinhaltet nicht den Versatz des Cursors innerhalb des Preedit-Bereichs, wie er von QInputMethodEvent::Cursor gesteuert wird.
`Qt::ImSurroundingText`	`0x10`	Der reine Text um den Eingabebereich herum, z. B. der aktuelle Absatz.
`Qt::ImCurrentSelection`	`0x20`	Der aktuell ausgewählte Text.
`Qt::ImMaximumTextLength`	`0x40`	Die maximale Anzahl von Zeichen, die das Widget aufnehmen kann. Wenn es keine Begrenzung gibt, wird QVariant::QVariant() zurückgegeben.
`Qt::ImAnchorPosition`	`0x80`	Die Position des Auswahlankers. Diese kann kleiner oder größer als `ImCursorPosition` sein, je nachdem, auf welcher Seite der Auswahl sich der Cursor befindet. Wenn es keine Auswahl gibt, wird dasselbe zurückgegeben wie `ImCursorPosition`.
`Qt::ImHints`	`0x100`	Die Hinweise zur Eingabemethode bei erwarteter Eingabe. (Siehe Qt::InputMethodHints)
`Qt::ImPreferredLanguage`	`0x200`	Die bevorzugte Eingabesprache.
`Qt::ImPlatformData`	`0x80000000`	Plattformspezifische Daten für die Eingabemethode.
`Qt::ImAbsolutePosition`	`0x400`	Die logische Position des Cursors innerhalb des gesamten Dokuments. Die Position beinhaltet nicht den Versatz des Cursors innerhalb des Preedit-Bereichs, wie er von QInputMethodEvent::Cursor gesteuert wird.
`Qt::ImTextBeforeCursor`	`0x800`	Der reine Text vor dem Cursor. Das Widget kann entscheiden, wie viel Text zurückgegeben werden soll, darf aber keine leere Zeichenkette zurückgeben, es sei denn, der Cursor befindet sich am Anfang des Dokuments.
`Qt::ImTextAfterCursor`	`0x1000`	Der Klartext nach der Schreibmarke. Das Widget kann entscheiden, wie viel Text zurückgegeben werden soll, darf aber keine leere Zeichenkette zurückgeben, es sei denn, der Cursor befindet sich am Ende des Dokuments.
`Qt::ImEnterKeyType`	`0x2000`	Der Typ der Eingabetaste.
`Qt::ImAnchorRectangle`	`0x4000`	Das Begrenzungsrechteck des Auswahlankers. Dieser Wert wurde in Qt 5.7 hinzugefügt.
`Qt::ImInputItemClipRectangle`	`0x8000`	Das tatsächlich sichtbare Rechteck des Eingabeelements. Teile des Eingabeelements können abgeschnitten sein. Dieser Wert berücksichtigt die Beschneidung und gibt das tatsächliche gemalte Rechteck des Elements zurück. Das Rechteck ist in den Koordinaten des Widgets angegeben.
`Qt::ImReadOnly`	`0x10000`	Das Widget ist nur lesbar. Dieser Wert wurde in Qt 6.2 hinzugefügt.

Masken:

Konstante	Wert	Beschreibung
`Qt::ImQueryInput`	`ImCursorRectangle \| ImCursorPosition \| ImSurroundingText \| ImCurrentSelection \| ImAnchorRectangle \| ImAnchorPosition`	Häufig geänderte Eigenschaften der Eingabe.
`Qt::ImQueryAll`	`0xffffffff`	Abfrage für alle Eigenschaften von Eingabemethoden.

Der Typ InputMethodQueries ist ein Typedef für QFlags<InputMethodQuery>. Er speichert eine OR-Kombination von InputMethodQuery-Werten.

Siehe auch QInputMethodQueryEvent.

enum Qt::ItemDataRole

Jedem Element des Modells ist ein Satz von Datenelementen zugeordnet, die jeweils eine eigene Rolle haben. Die Rollen werden von der Ansicht verwendet, um dem Modell mitzuteilen, welche Art von Daten es benötigt. Benutzerdefinierte Modelle sollten Daten in diesen Typen zurückgeben.

Die Rollen für allgemeine Zwecke (und die zugehörigen Typen) sind:

Konstante	Wert	Beschreibung
`Qt::DisplayRole`	`0`	Die Schlüsseldaten, die in Form von Text wiedergegeben werden sollen. (QString)
`Qt::DecorationRole`	`1`	Die Daten, die als Dekoration in Form eines Symbols wiedergegeben werden sollen. (QColor, QIcon oder QPixmap)
`Qt::EditRole`	`2`	Die Daten in einer für die Bearbeitung in einem Editor geeigneten Form. (QString)
`Qt::ToolTipRole`	`3`	Die Daten, die im Tooltip des Elements angezeigt werden. (QString)
`Qt::StatusTipRole`	`4`	Die Daten, die in der Statusleiste angezeigt werden. (QString)
`Qt::WhatsThisRole`	`5`	Die Daten, die im "Was ist das?"-Modus für das Element angezeigt werden. (QString)
`Qt::SizeHintRole`	`13`	Der Größenhinweis für das Element, der den Ansichten zur Verfügung gestellt wird. (QSize)

Rollen, die das Erscheinungsbild und die Metadaten (mit zugehörigen Typen) beschreiben:

Konstante	Wert	Beschreibung
`Qt::FontRole`	`6`	Die Schriftart, die für Elemente verwendet wird, die mit dem Standarddelegat dargestellt werden. (QFont)
`Qt::TextAlignmentRole`	`7`	Die Ausrichtung des Textes für Elemente, die mit dem Standarddelegaten wiedergegeben werden. (Qt::Alignment)
`Qt::BackgroundRole`	`8`	Der Hintergrundpinsel, der für Elemente verwendet wird, die mit dem Standarddelegaten gerendert werden. (QBrush)
`Qt::ForegroundRole`	`9`	Der Vordergrundpinsel (in der Regel die Textfarbe), der für Elemente verwendet wird, die mit dem Standarddelegaten gerendert werden. (QBrush)
`Qt::CheckStateRole`	`10`	Diese Rolle wird verwendet, um den Prüfstatus eines Objekts zu erhalten. (Qt::CheckState)
`Qt::InitialSortOrderRole`	`14`	Diese Rolle wird verwendet, um die anfängliche Sortierreihenfolge eines Kopfzeilenabschnitts zu erhalten. (Qt::SortOrder).

Zugänglichkeitsrollen (mit zugehörigen Typen):

Konstante	Wert	Beschreibung
`Qt::AccessibleTextRole`	`11`	Der Text, der von Zugänglichkeitserweiterungen und Plugins, wie z. B. Screenreadern, verwendet werden soll. (QString)
`Qt::AccessibleDescriptionRole`	`12`	Eine Beschreibung des Elements für die Barrierefreiheit. (QString)

Benutzerrollen:

Konstante	Wert	Beschreibung
`Qt::UserRole`	`0x0100`	Die erste Rolle, die für anwendungsspezifische Zwecke verwendet werden kann.

Für Benutzerrollen muss der Entwickler entscheiden, welche Typen verwendet werden sollen und sicherstellen, dass die Komponenten beim Zugriff auf und beim Setzen von Daten die richtigen Typen verwenden.

enum Qt::ItemFlag
flags Qt::ItemFlags

Dieses Enum beschreibt die Eigenschaften eines Items:

Konstante	Wert	Beschreibung
`Qt::NoItemFlags`	`0`	Es sind keine Eigenschaften eingestellt.
`Qt::ItemIsSelectable`	`1`	Es kann ausgewählt werden.
`Qt::ItemIsEditable`	`2`	Er kann bearbeitet werden.
`Qt::ItemIsDragEnabled`	`4`	Es kann gezogen werden.
`Qt::ItemIsDropEnabled`	`8`	Es kann als Ablageziel verwendet werden.
`Qt::ItemIsUserCheckable`	`16`	Es kann vom Benutzer markiert oder abgewählt werden.
`Qt::ItemIsEnabled`	`32`	Der Benutzer kann mit dem Element interagieren.
`Qt::ItemIsAutoTristate`	`64`	Der Status des Objekts hängt vom Status seiner Kinder ab. Dies ermöglicht die automatische Verwaltung des Zustands übergeordneter Elemente in QTreeWidget (markiert, wenn alle Kinder markiert sind, nicht markiert, wenn alle Kinder nicht markiert sind, oder teilweise markiert, wenn nur einige Kinder markiert sind).
`Qt::ItemNeverHasChildren`	`128`	Das Element hat niemals untergeordnete Elemente. Dies dient nur zu Optimierungszwecken.
`Qt::ItemIsUserTristate`	`256`	Der Benutzer kann drei verschiedene Zustände durchlaufen. Dieser Wert wurde in Qt 5.5 hinzugefügt.

Beachten Sie, dass überprüfbare Elemente sowohl mit einem geeigneten Satz von Flags als auch mit einem Anfangszustand versehen werden müssen, der angibt, ob das Element geprüft ist oder nicht. Dies wird automatisch für Model/View Komponenten gehandhabt, muss aber explizit für Instanzen von QListWidgetItem, QTableWidgetItem und QTreeWidgetItem gesetzt werden.

Beachten Sie, dass es ein undefiniertes Verhalten ist, QAbstractItemModel::hasChildren so zu reimplementieren, dass es für einen Index true zurückgibt, wenn dieser Index das Qt::ItemNeverHasChildren Flag gesetzt hat.

Der ItemFlags Typ ist ein Typedef für QFlags<ItemFlag>. Er speichert eine OR-Kombination von ItemFlag-Werten.

Siehe auch QAbstractItemModel.

enum Qt::ItemSelectionMode

Diese Aufzählung wird in QGraphicsItem, QGraphicsScene und QGraphicsView verwendet, um anzugeben, wie Elemente ausgewählt werden oder wie bestimmt wird, ob Formen und Elemente kollidieren.

Konstante	Wert	Beschreibung
`Qt::ContainsItemShape`	`0x0`	Die Ausgabeliste enthält nur Elemente, deren shape vollständig innerhalb des Auswahlbereichs enthalten ist. Elemente, die sich mit dem Umriss des Bereichs überschneiden, werden nicht berücksichtigt.
`Qt::IntersectsItemShape`	`0x1`	Die Ausgabeliste enthält sowohl Elemente, deren shape vollständig im Auswahlbereich enthalten ist, als auch Elemente, die sich mit dem Umriss des Bereichs überschneiden. Dies ist ein üblicher Modus für die Gummibandauswahl.
`Qt::ContainsItemBoundingRect`	`0x2`	Die Ausgabeliste enthält nur Elemente, deren bounding rectangle vollständig innerhalb des Auswahlbereichs liegt. Elemente, die sich mit dem Umriss des Bereichs schneiden, werden nicht berücksichtigt.
`Qt::IntersectsItemBoundingRect`	`0x3`	Die Ausgabeliste enthält sowohl Elemente, deren bounding rectangle vollständig im Auswahlbereich enthalten ist, als auch Elemente, die sich mit dem Umriss des Bereichs überschneiden. Diese Methode wird üblicherweise verwendet, um Bereiche zu ermitteln, die neu gezeichnet werden müssen.

Siehe auch QGraphicsScene::items(), QGraphicsScene::collidingItems(), QGraphicsView::items(), QGraphicsItem::collidesWithItem(), und QGraphicsItem::collidesWithPath().

enum Qt::ItemSelectionOperation

Diese Aufzählung wird in QGraphicsScene verwendet, um anzugeben, was mit den aktuell ausgewählten Elementen geschehen soll, wenn ein Auswahlbereich festgelegt wird.

Konstante	Wert	Beschreibung
`Qt::ReplaceSelection`	`0`	Die aktuell ausgewählten Elemente werden durch Elemente im Auswahlbereich ersetzt.
`Qt::AddToSelection`	`1`	Die Einträge im Auswahlbereich werden zu den aktuell ausgewählten Einträgen hinzugefügt.

Siehe auch QGraphicsScene::setSelectionArea().

enum Qt::Key

Die Schlüsselnamen, die von Qt.

Konstante	Wert	Beschreibung
`Qt::Key_Escape`	`0x01000000`
`Qt::Key_Tab`	`0x01000001`
`Qt::Key_Backtab`	`0x01000002`
`Qt::Key_Backspace`	`0x01000003`
`Qt::Key_Return`	`0x01000004`
`Qt::Key_Enter`	`0x01000005`	Befindet sich normalerweise auf dem Tastenfeld.
`Qt::Key_Insert`	`0x01000006`
`Qt::Key_Delete`	`0x01000007`
`Qt::Key_Pause`	`0x01000008`	Die Pause/Break-Taste(Hinweis: Hat nichts mit dem Anhalten von Medien zu tun)
`Qt::Key_Print`	`0x01000009`
`Qt::Key_SysReq`	`0x0100000a`
`Qt::Key_Clear`	`0x0100000b`	Entspricht der Löschtaste auf ausgewählten Apple-Tastaturmodellen. Auf anderen Systemen wird sie üblicherweise der Taste 5 des Ziffernblocks zugeordnet, wenn Num Lock auf `off` steht.
`Qt::Key_Home`	`0x01000010`
`Qt::Key_End`	`0x01000011`
`Qt::Key_Left`	`0x01000012`
`Qt::Key_Up`	`0x01000013`
`Qt::Key_Right`	`0x01000014`
`Qt::Key_Down`	`0x01000015`
`Qt::Key_PageUp`	`0x01000016`
`Qt::Key_PageDown`	`0x01000017`
`Qt::Key_Shift`	`0x01000020`
`Qt::Key_Control`	`0x01000021`	Unter macOS entspricht dies den Befehlstasten.
`Qt::Key_Meta`	`0x01000022`	Unter macOS entspricht dies den Steuerungstasten. Auf Windows-Tastaturen wird diese Taste der Windows-Taste zugeordnet.
`Qt::Key_Alt`	`0x01000023`
`Qt::Key_AltGr`	`0x01001103`	Wenn unter Windows das KeyDown-Ereignis für diese Taste gesendet wird, werden auch die Strg+Alt-Modifikatoren gesetzt.
`Qt::Key_CapsLock`	`0x01000024`
`Qt::Key_NumLock`	`0x01000025`
`Qt::Key_ScrollLock`	`0x01000026`
`Qt::Key_F1`	`0x01000030`
`Qt::Key_F2`	`0x01000031`
`Qt::Key_F3`	`0x01000032`
`Qt::Key_F4`	`0x01000033`
`Qt::Key_F5`	`0x01000034`
`Qt::Key_F6`	`0x01000035`
`Qt::Key_F7`	`0x01000036`
`Qt::Key_F8`	`0x01000037`
`Qt::Key_F9`	`0x01000038`
`Qt::Key_F10`	`0x01000039`
`Qt::Key_F11`	`0x0100003a`
`Qt::Key_F12`	`0x0100003b`
`Qt::Key_F13`	`0x0100003c`
`Qt::Key_F14`	`0x0100003d`
`Qt::Key_F15`	`0x0100003e`
`Qt::Key_F16`	`0x0100003f`
`Qt::Key_F17`	`0x01000040`
`Qt::Key_F18`	`0x01000041`
`Qt::Key_F19`	`0x01000042`
`Qt::Key_F20`	`0x01000043`
`Qt::Key_F21`	`0x01000044`
`Qt::Key_F22`	`0x01000045`
`Qt::Key_F23`	`0x01000046`
`Qt::Key_F24`	`0x01000047`
`Qt::Key_F25`	`0x01000048`
`Qt::Key_F26`	`0x01000049`
`Qt::Key_F27`	`0x0100004a`
`Qt::Key_F28`	`0x0100004b`
`Qt::Key_F29`	`0x0100004c`
`Qt::Key_F30`	`0x0100004d`
`Qt::Key_F31`	`0x0100004e`
`Qt::Key_F32`	`0x0100004f`
`Qt::Key_F33`	`0x01000050`
`Qt::Key_F34`	`0x01000051`
`Qt::Key_F35`	`0x01000052`
`Qt::Key_Super_L`	`0x01000053`
`Qt::Key_Super_R`	`0x01000054`
`Qt::Key_Menu`	`0x01000055`
`Qt::Key_Hyper_L`	`0x01000056`
`Qt::Key_Hyper_R`	`0x01000057`
`Qt::Key_Help`	`0x01000058`
`Qt::Key_Direction_L`	`0x01000059`
`Qt::Key_Direction_R`	`0x01000060`
`Qt::Key_Space`	`0x20`
`Qt::Key_Any`	`Key_Space`
`Qt::Key_Exclam`	`0x21`
`Qt::Key_QuoteDbl`	`0x22`
`Qt::Key_NumberSign`	`0x23`
`Qt::Key_Dollar`	`0x24`
`Qt::Key_Percent`	`0x25`
`Qt::Key_Ampersand`	`0x26`
`Qt::Key_Apostrophe`	`0x27`
`Qt::Key_ParenLeft`	`0x28`
`Qt::Key_ParenRight`	`0x29`
`Qt::Key_Asterisk`	`0x2a`
`Qt::Key_Plus`	`0x2b`
`Qt::Key_Comma`	`0x2c`
`Qt::Key_Minus`	`0x2d`
`Qt::Key_Period`	`0x2e`
`Qt::Key_Slash`	`0x2f`
`Qt::Key_0`	`0x30`
`Qt::Key_1`	`0x31`
`Qt::Key_2`	`0x32`
`Qt::Key_3`	`0x33`
`Qt::Key_4`	`0x34`
`Qt::Key_5`	`0x35`
`Qt::Key_6`	`0x36`
`Qt::Key_7`	`0x37`
`Qt::Key_8`	`0x38`
`Qt::Key_9`	`0x39`
`Qt::Key_Colon`	`0x3a`
`Qt::Key_Semicolon`	`0x3b`
`Qt::Key_Less`	`0x3c`
`Qt::Key_Equal`	`0x3d`
`Qt::Key_Greater`	`0x3e`
`Qt::Key_Question`	`0x3f`
`Qt::Key_At`	`0x40`
`Qt::Key_A`	`0x41`
`Qt::Key_B`	`0x42`
`Qt::Key_C`	`0x43`
`Qt::Key_D`	`0x44`
`Qt::Key_E`	`0x45`
`Qt::Key_F`	`0x46`
`Qt::Key_G`	`0x47`
`Qt::Key_H`	`0x48`
`Qt::Key_I`	`0x49`
`Qt::Key_J`	`0x4a`
`Qt::Key_K`	`0x4b`
`Qt::Key_L`	`0x4c`
`Qt::Key_M`	`0x4d`
`Qt::Key_N`	`0x4e`
`Qt::Key_O`	`0x4f`
`Qt::Key_P`	`0x50`
`Qt::Key_Q`	`0x51`
`Qt::Key_R`	`0x52`
`Qt::Key_S`	`0x53`
`Qt::Key_T`	`0x54`
`Qt::Key_U`	`0x55`
`Qt::Key_V`	`0x56`
`Qt::Key_W`	`0x57`
`Qt::Key_X`	`0x58`
`Qt::Key_Y`	`0x59`
`Qt::Key_Z`	`0x5a`
`Qt::Key_BracketLeft`	`0x5b`
`Qt::Key_Backslash`	`0x5c`
`Qt::Key_BracketRight`	`0x5d`
`Qt::Key_AsciiCircum`	`0x5e`
`Qt::Key_Underscore`	`0x5f`
`Qt::Key_QuoteLeft`	`0x60`
`Qt::Key_BraceLeft`	`0x7b`
`Qt::Key_Bar`	`0x7c`
`Qt::Key_BraceRight`	`0x7d`
`Qt::Key_AsciiTilde`	`0x7e`
`Qt::Key_nobreakspace`	`0x0a0`
`Qt::Key_exclamdown`	`0x0a1`
`Qt::Key_cent`	`0x0a2`
`Qt::Key_sterling`	`0x0a3`
`Qt::Key_currency`	`0x0a4`
`Qt::Key_yen`	`0x0a5`
`Qt::Key_brokenbar`	`0x0a6`
`Qt::Key_section`	`0x0a7`
`Qt::Key_diaeresis`	`0x0a8`
`Qt::Key_copyright`	`0x0a9`
`Qt::Key_ordfeminine`	`0x0aa`
`Qt::Key_guillemotleft`	`0x0ab`
`Qt::Key_notsign`	`0x0ac`
`Qt::Key_hyphen`	`0x0ad`
`Qt::Key_registered`	`0x0ae`
`Qt::Key_macron`	`0x0af`
`Qt::Key_degree`	`0x0b0`
`Qt::Key_plusminus`	`0x0b1`
`Qt::Key_twosuperior`	`0x0b2`
`Qt::Key_threesuperior`	`0x0b3`
`Qt::Key_acute`	`0x0b4`
`Qt::Key_micro (since Qt 6.7)`	`0x0b5`
`Qt::Key_mu`	`Key_micro`	Veralteter Alias für Key_micro
`Qt::Key_paragraph`	`0x0b6`
`Qt::Key_periodcentered`	`0x0b7`
`Qt::Key_cedilla`	`0x0b8`
`Qt::Key_onesuperior`	`0x0b9`
`Qt::Key_masculine`	`0x0ba`
`Qt::Key_guillemotright`	`0x0bb`
`Qt::Key_onequarter`	`0x0bc`
`Qt::Key_onehalf`	`0x0bd`
`Qt::Key_threequarters`	`0x0be`
`Qt::Key_questiondown`	`0x0bf`
`Qt::Key_Agrave`	`0x0c0`
`Qt::Key_Aacute`	`0x0c1`
`Qt::Key_Acircumflex`	`0x0c2`
`Qt::Key_Atilde`	`0x0c3`
`Qt::Key_Adiaeresis`	`0x0c4`
`Qt::Key_Aring`	`0x0c5`
`Qt::Key_AE`	`0x0c6`
`Qt::Key_Ccedilla`	`0x0c7`
`Qt::Key_Egrave`	`0x0c8`
`Qt::Key_Eacute`	`0x0c9`
`Qt::Key_Ecircumflex`	`0x0ca`
`Qt::Key_Ediaeresis`	`0x0cb`
`Qt::Key_Igrave`	`0x0cc`
`Qt::Key_Iacute`	`0x0cd`
`Qt::Key_Icircumflex`	`0x0ce`
`Qt::Key_Idiaeresis`	`0x0cf`
`Qt::Key_ETH`	`0x0d0`
`Qt::Key_Ntilde`	`0x0d1`
`Qt::Key_Ograve`	`0x0d2`
`Qt::Key_Oacute`	`0x0d3`
`Qt::Key_Ocircumflex`	`0x0d4`
`Qt::Key_Otilde`	`0x0d5`
`Qt::Key_Odiaeresis`	`0x0d6`
`Qt::Key_multiply`	`0x0d7`
`Qt::Key_Ooblique`	`0x0d8`
`Qt::Key_Ugrave`	`0x0d9`
`Qt::Key_Uacute`	`0x0da`
`Qt::Key_Ucircumflex`	`0x0db`
`Qt::Key_Udiaeresis`	`0x0dc`
`Qt::Key_Yacute`	`0x0dd`
`Qt::Key_THORN`	`0x0de`
`Qt::Key_ssharp`	`0x0df`
`Qt::Key_division`	`0x0f7`
`Qt::Key_ydiaeresis`	`0x0ff`
`Qt::Key_Multi_key`	`0x01001120`
`Qt::Key_Codeinput`	`0x01001137`
`Qt::Key_SingleCandidate`	`0x0100113c`
`Qt::Key_MultipleCandidate`	`0x0100113d`
`Qt::Key_PreviousCandidate`	`0x0100113e`
`Qt::Key_Mode_switch`	`0x0100117e`
`Qt::Key_Kanji`	`0x01001121`
`Qt::Key_Muhenkan`	`0x01001122`
`Qt::Key_Henkan`	`0x01001123`
`Qt::Key_Romaji`	`0x01001124`
`Qt::Key_Hiragana`	`0x01001125`
`Qt::Key_Katakana`	`0x01001126`
`Qt::Key_Hiragana_Katakana`	`0x01001127`
`Qt::Key_Zenkaku`	`0x01001128`
`Qt::Key_Hankaku`	`0x01001129`
`Qt::Key_Zenkaku_Hankaku`	`0x0100112a`
`Qt::Key_Touroku`	`0x0100112b`
`Qt::Key_Massyo`	`0x0100112c`
`Qt::Key_Kana_Lock`	`0x0100112d`
`Qt::Key_Kana_Shift`	`0x0100112e`
`Qt::Key_Eisu_Shift`	`0x0100112f`
`Qt::Key_Eisu_toggle`	`0x01001130`
`Qt::Key_Hangul`	`0x01001131`
`Qt::Key_Hangul_Start`	`0x01001132`
`Qt::Key_Hangul_End`	`0x01001133`
`Qt::Key_Hangul_Hanja`	`0x01001134`
`Qt::Key_Hangul_Jamo`	`0x01001135`
`Qt::Key_Hangul_Romaja`	`0x01001136`
`Qt::Key_Hangul_Jeonja`	`0x01001138`
`Qt::Key_Hangul_Banja`	`0x01001139`
`Qt::Key_Hangul_PreHanja`	`0x0100113a`
`Qt::Key_Hangul_PostHanja`	`0x0100113b`
`Qt::Key_Hangul_Special`	`0x0100113f`
`Qt::Key_Dead_Grave`	`0x01001250`
`Qt::Key_Dead_Acute`	`0x01001251`
`Qt::Key_Dead_Circumflex`	`0x01001252`
`Qt::Key_Dead_Tilde`	`0x01001253`
`Qt::Key_Dead_Macron`	`0x01001254`
`Qt::Key_Dead_Breve`	`0x01001255`
`Qt::Key_Dead_Abovedot`	`0x01001256`
`Qt::Key_Dead_Diaeresis`	`0x01001257`
`Qt::Key_Dead_Abovering`	`0x01001258`
`Qt::Key_Dead_Doubleacute`	`0x01001259`
`Qt::Key_Dead_Caron`	`0x0100125a`
`Qt::Key_Dead_Cedilla`	`0x0100125b`
`Qt::Key_Dead_Ogonek`	`0x0100125c`
`Qt::Key_Dead_Iota`	`0x0100125d`
`Qt::Key_Dead_Voiced_Sound`	`0x0100125e`
`Qt::Key_Dead_Semivoiced_Sound`	`0x0100125f`
`Qt::Key_Dead_Belowdot`	`0x01001260`
`Qt::Key_Dead_Hook`	`0x01001261`
`Qt::Key_Dead_Horn`	`0x01001262`
`Qt::Key_Dead_Stroke`	`0x01001263`
`Qt::Key_Dead_Abovecomma`	`0x01001264`
`Qt::Key_Dead_Abovereversedcomma`	`0x01001265`
`Qt::Key_Dead_Doublegrave`	`0x01001266`
`Qt::Key_Dead_Belowring`	`0x01001267`
`Qt::Key_Dead_Belowmacron`	`0x01001268`
`Qt::Key_Dead_Belowcircumflex`	`0x01001269`
`Qt::Key_Dead_Belowtilde`	`0x0100126a`
`Qt::Key_Dead_Belowbreve`	`0x0100126b`
`Qt::Key_Dead_Belowdiaeresis`	`0x0100126c`
`Qt::Key_Dead_Invertedbreve`	`0x0100126d`
`Qt::Key_Dead_Belowcomma`	`0x0100126e`
`Qt::Key_Dead_Currency`	`0x0100126f`
`Qt::Key_Dead_a`	`0x01001280`
`Qt::Key_Dead_A`	`0x01001281`
`Qt::Key_Dead_e`	`0x01001282`
`Qt::Key_Dead_E`	`0x01001283`
`Qt::Key_Dead_i`	`0x01001284`
`Qt::Key_Dead_I`	`0x01001285`
`Qt::Key_Dead_o`	`0x01001286`
`Qt::Key_Dead_O`	`0x01001287`
`Qt::Key_Dead_u`	`0x01001288`
`Qt::Key_Dead_U`	`0x01001289`
`Qt::Key_Dead_Small_Schwa`	`0x0100128a`
`Qt::Key_Dead_Capital_Schwa`	`0x0100128b`
`Qt::Key_Dead_Greek`	`0x0100128c`
`Qt::Key_Dead_Lowline`	`0x01001290`
`Qt::Key_Dead_Aboveverticalline`	`0x01001291`
`Qt::Key_Dead_Belowverticalline`	`0x01001292`
`Qt::Key_Dead_Longsolidusoverlay`	`0x01001293`
`Qt::Key_Back`	`0x01000061`
`Qt::Key_Forward`	`0x01000062`
`Qt::Key_Stop`	`0x01000063`
`Qt::Key_Refresh`	`0x01000064`
`Qt::Key_VolumeDown`	`0x01000070`
`Qt::Key_VolumeMute`	`0x01000071`
`Qt::Key_VolumeUp`	`0x01000072`
`Qt::Key_BassBoost`	`0x01000073`
`Qt::Key_BassUp`	`0x01000074`
`Qt::Key_BassDown`	`0x01000075`
`Qt::Key_TrebleUp`	`0x01000076`
`Qt::Key_TrebleDown`	`0x01000077`
`Qt::Key_MediaPlay`	`0x01000080`	Eine Taste, die den Status des Media Players auf Wiedergabe setzt
`Qt::Key_MediaStop`	`0x01000081`	Eine Taste, die den Status des Mediaplayers auf Stopp setzt
`Qt::Key_MediaPrevious`	`0x01000082`
`Qt::Key_MediaNext`	`0x01000083`
`Qt::Key_MediaRecord`	`0x01000084`
`Qt::Key_MediaPause`	`0x01000085`	Eine Taste, die den Status des Media-Players auf Pause setzt(Hinweis: nicht die Pause/Pause-Taste)
`Qt::Key_MediaTogglePlayPause`	`0x01000086`	Eine Taste zum Umschalten des Abspiel-/Pausezustands im Media Player (anstatt einen absoluten Zustand zu setzen)
`Qt::Key_HomePage`	`0x01000090`
`Qt::Key_Favorites`	`0x01000091`
`Qt::Key_Search`	`0x01000092`
`Qt::Key_Standby`	`0x01000093`
`Qt::Key_OpenUrl`	`0x01000094`
`Qt::Key_LaunchMail`	`0x010000a0`
`Qt::Key_LaunchMedia`	`0x010000a1`
`Qt::Key_Launch0`	`0x010000a2`
`Qt::Key_Launch1`	`0x010000a3`
`Qt::Key_Launch2`	`0x010000a4`
`Qt::Key_Launch3`	`0x010000a5`
`Qt::Key_Launch4`	`0x010000a6`
`Qt::Key_Launch5`	`0x010000a7`
`Qt::Key_Launch6`	`0x010000a8`
`Qt::Key_Launch7`	`0x010000a9`
`Qt::Key_Launch8`	`0x010000aa`
`Qt::Key_Launch9`	`0x010000ab`
`Qt::Key_LaunchA`	`0x010000ac`
`Qt::Key_LaunchB`	`0x010000ad`
`Qt::Key_LaunchC`	`0x010000ae`
`Qt::Key_LaunchD`	`0x010000af`
`Qt::Key_LaunchE`	`0x010000b0`
`Qt::Key_LaunchF`	`0x010000b1`
`Qt::Key_LaunchG`	`0x0100010e`
`Qt::Key_LaunchH`	`0x0100010f`
`Qt::Key_MonBrightnessUp`	`0x010000b2`
`Qt::Key_MonBrightnessDown`	`0x010000b3`
`Qt::Key_KeyboardLightOnOff`	`0x010000b4`
`Qt::Key_KeyboardBrightnessUp`	`0x010000b5`
`Qt::Key_KeyboardBrightnessDown`	`0x010000b6`
`Qt::Key_PowerOff`	`0x010000b7`
`Qt::Key_WakeUp`	`0x010000b8`
`Qt::Key_Eject`	`0x010000b9`
`Qt::Key_ScreenSaver`	`0x010000ba`
`Qt::Key_WWW`	`0x010000bb`
`Qt::Key_Memo`	`0x010000bc`
`Qt::Key_LightBulb`	`0x010000bd`
`Qt::Key_Shop`	`0x010000be`
`Qt::Key_History`	`0x010000bf`
`Qt::Key_AddFavorite`	`0x010000c0`
`Qt::Key_HotLinks`	`0x010000c1`
`Qt::Key_BrightnessAdjust`	`0x010000c2`
`Qt::Key_Finance`	`0x010000c3`
`Qt::Key_Community`	`0x010000c4`
`Qt::Key_AudioRewind`	`0x010000c5`
`Qt::Key_BackForward`	`0x010000c6`
`Qt::Key_ApplicationLeft`	`0x010000c7`
`Qt::Key_ApplicationRight`	`0x010000c8`
`Qt::Key_Book`	`0x010000c9`
`Qt::Key_CD`	`0x010000ca`
`Qt::Key_Calculator`	`0x010000cb`
`Qt::Key_ToDoList`	`0x010000cc`
`Qt::Key_ClearGrab`	`0x010000cd`
`Qt::Key_Close`	`0x010000ce`
`Qt::Key_Copy`	`0x010000cf`
`Qt::Key_Cut`	`0x010000d0`
`Qt::Key_Display`	`0x010000d1`
`Qt::Key_DOS`	`0x010000d2`
`Qt::Key_Documents`	`0x010000d3`
`Qt::Key_Excel`	`0x010000d4`
`Qt::Key_Explorer`	`0x010000d5`
`Qt::Key_Game`	`0x010000d6`
`Qt::Key_Go`	`0x010000d7`
`Qt::Key_iTouch`	`0x010000d8`
`Qt::Key_LogOff`	`0x010000d9`
`Qt::Key_Market`	`0x010000da`
`Qt::Key_Meeting`	`0x010000db`
`Qt::Key_MenuKB`	`0x010000dc`
`Qt::Key_MenuPB`	`0x010000dd`
`Qt::Key_MySites`	`0x010000de`
`Qt::Key_News`	`0x010000df`
`Qt::Key_OfficeHome`	`0x010000e0`
`Qt::Key_Option`	`0x010000e1`
`Qt::Key_Paste`	`0x010000e2`
`Qt::Key_Phone`	`0x010000e3`
`Qt::Key_Calendar`	`0x010000e4`
`Qt::Key_Reply`	`0x010000e5`
`Qt::Key_Reload`	`0x010000e6`
`Qt::Key_RotateWindows`	`0x010000e7`
`Qt::Key_RotationPB`	`0x010000e8`
`Qt::Key_RotationKB`	`0x010000e9`
`Qt::Key_Save`	`0x010000ea`
`Qt::Key_Send`	`0x010000eb`
`Qt::Key_Spell`	`0x010000ec`
`Qt::Key_SplitScreen`	`0x010000ed`
`Qt::Key_Support`	`0x010000ee`
`Qt::Key_TaskPane`	`0x010000ef`
`Qt::Key_Terminal`	`0x010000f0`
`Qt::Key_Tools`	`0x010000f1`
`Qt::Key_Travel`	`0x010000f2`
`Qt::Key_Video`	`0x010000f3`
`Qt::Key_Word`	`0x010000f4`
`Qt::Key_Xfer`	`0x010000f5`
`Qt::Key_ZoomIn`	`0x010000f6`
`Qt::Key_ZoomOut`	`0x010000f7`
`Qt::Key_Away`	`0x010000f8`
`Qt::Key_Messenger`	`0x010000f9`
`Qt::Key_WebCam`	`0x010000fa`
`Qt::Key_MailForward`	`0x010000fb`
`Qt::Key_Pictures`	`0x010000fc`
`Qt::Key_Music`	`0x010000fd`
`Qt::Key_Battery`	`0x010000fe`
`Qt::Key_Bluetooth`	`0x010000ff`
`Qt::Key_WLAN`	`0x01000100`
`Qt::Key_UWB`	`0x01000101`
`Qt::Key_AudioForward`	`0x01000102`
`Qt::Key_AudioRepeat`	`0x01000103`
`Qt::Key_AudioRandomPlay`	`0x01000104`
`Qt::Key_Subtitle`	`0x01000105`
`Qt::Key_AudioCycleTrack`	`0x01000106`
`Qt::Key_Time`	`0x01000107`
`Qt::Key_Hibernate`	`0x01000108`
`Qt::Key_View`	`0x01000109`
`Qt::Key_TopMenu`	`0x0100010a`
`Qt::Key_PowerDown`	`0x0100010b`
`Qt::Key_Suspend`	`0x0100010c`
`Qt::Key_ContrastAdjust`	`0x0100010d`
`Qt::Key_TouchpadToggle`	`0x01000110`
`Qt::Key_TouchpadOn`	`0x01000111`
`Qt::Key_TouchpadOff`	`0x01000112`
`Qt::Key_MicMute`	`0x01000113`
`Qt::Key_Red`	`0x01000114`
`Qt::Key_Green`	`0x01000115`
`Qt::Key_Yellow`	`0x01000116`
`Qt::Key_Blue`	`0x01000117`
`Qt::Key_ChannelUp`	`0x01000118`
`Qt::Key_ChannelDown`	`0x01000119`
`Qt::Key_Guide`	`0x0100011a`
`Qt::Key_Info`	`0x0100011b`
`Qt::Key_Settings`	`0x0100011c`
`Qt::Key_MicVolumeUp`	`0x0100011d`
`Qt::Key_MicVolumeDown`	`0x0100011e`
`Qt::Key_New`	`0x01000120`
`Qt::Key_Open`	`0x01000121`
`Qt::Key_Find`	`0x01000122`
`Qt::Key_Undo`	`0x01000123`
`Qt::Key_Redo`	`0x01000124`
`Qt::Key_MediaLast`	`0x0100ffff`
`Qt::Key_unknown`	`0x01ffffff`
`Qt::Key_Call`	`0x01100004`	Eine Taste zum Annehmen oder Einleiten eines Anrufs (siehe Qt::Key_ToggleCallHangup für eine Taste zum Umschalten des aktuellen Anrufstatus)
`Qt::Key_Camera`	`0x01100020`	Eine Taste zum Aktivieren des Kameraverschlusses. Unter Windows Runtime muss die Umgebungsvariable QT_QPA_ENABLE_CAMERA_KEYS gesetzt sein, um das Ereignis zu empfangen.
`Qt::Key_CameraFocus`	`0x01100021`	Eine Taste zum Fokussieren der Kamera. Unter Windows Runtime muss die Umgebungsvariable QT_QPA_ENABLE_CAMERA_KEYS gesetzt sein, um das Ereignis zu empfangen.
`Qt::Key_Context1`	`0x01100000`
`Qt::Key_Context2`	`0x01100001`
`Qt::Key_Context3`	`0x01100002`
`Qt::Key_Context4`	`0x01100003`
`Qt::Key_Flip`	`0x01100006`
`Qt::Key_Hangup`	`0x01100005`	Eine Taste zum Beenden eines laufenden Anrufs (siehe Qt::Key_ToggleCallHangup für eine Taste zum Umschalten des aktuellen Anrufstatus)
`Qt::Key_No`	`0x01010002`
`Qt::Key_Select`	`0x01010000`
`Qt::Key_Yes`	`0x01010001`
`Qt::Key_ToggleCallHangup`	`0x01100007`	Eine Taste zum Umschalten des aktuellen Gesprächszustands (d.h. entweder Annehmen oder Auflegen) in Abhängigkeit vom aktuellen Gesprächszustand
`Qt::Key_VoiceDial`	`0x01100008`
`Qt::Key_LastNumberRedial`	`0x01100009`
`Qt::Key_Execute`	`0x01020003`
`Qt::Key_Printer`	`0x01020002`
`Qt::Key_Play`	`0x01020005`
`Qt::Key_Sleep`	`0x01020004`
`Qt::Key_Zoom`	`0x01020006`
`Qt::Key_Exit`	`0x0102000a`
`Qt::Key_Cancel`	`0x01020001`

Siehe auch QKeyEvent::key().

enum Qt::KeyboardModifier
flags Qt::KeyboardModifiers

Diese Aufzählung beschreibt die Modifier-Tasten.

Konstante	Wert	Beschreibung
`Qt::NoModifier`	`0x00000000`	Keine Modifier-Taste ist gedrückt.
`Qt::ShiftModifier`	`0x02000000`	Eine Umschalttaste auf der Tastatur ist gedrückt.
`Qt::ControlModifier`	`0x04000000`	Eine Strg-Taste auf der Tastatur ist gedrückt.
`Qt::AltModifier`	`0x08000000`	Eine Alt-Taste auf der Tastatur ist gedrückt.
`Qt::MetaModifier`	`0x10000000`	Eine Meta-Taste auf der Tastatur wird gedrückt.
`Qt::KeypadModifier`	`0x20000000`	Eine Taste des Tastenfelds wird gedrückt.
`Qt::GroupSwitchModifier`	`0x40000000`	Nur X11 (sofern nicht unter Windows durch ein Befehlszeilenargument aktiviert). Eine Mode_switch-Taste auf der Tastatur wird gedrückt.

Hinweis: Unter macOS entspricht der Wert ControlModifier den Befehlstasten auf der Tastatur und der Wert MetaModifier den Steuerungstasten. Der Wert KeypadModifier wird auch gesetzt, wenn eine Pfeiltaste gedrückt wird, da die Pfeiltasten als Teil des Tastenfelds betrachtet werden.

Hinweis: Auf Windows-Tastaturen werden Qt::MetaModifier und Qt::Key_Meta auf die Windows-Taste abgebildet.

Der Typ KeyboardModifiers ist ein Typedef für QFlags<KeyboardModifier>. Er speichert eine ODER-Kombination von KeyboardModifier-Werten.

Siehe auch MouseButton und Modifier.

enum Qt::LayoutDirection

Legt die Richtung des Layouts und der Textverarbeitung von Qt fest.

Konstante	Wert	Beschreibung
`Qt::LeftToRight`	`0`	Links-nach-Rechts-Layout.
`Qt::RightToLeft`	`1`	Rechts-nach-links-Layout.
`Qt::LayoutDirectionAuto`	`2`	Automatisches Layout.

Rechts-nach-links-Layouts sind für bestimmte Sprachen erforderlich, insbesondere Arabisch und Hebräisch.

LayoutDirectionAuto dient zwei Zwecken. Wenn es in Verbindung mit Widgets und Layouts verwendet wird, bedeutet es, dass die im übergeordneten Widget oder QApplication eingestellte Layoutrichtung verwendet wird. Dies hat die gleiche Wirkung wie QWidget::unsetLayoutDirection().

Wenn LayoutDirectionAuto in Verbindung mit Text-Layouting verwendet wird, bedeutet dies, dass die Textrichtung anhand des Inhalts der zu layoutenden Zeichenkette bestimmt wird.

Siehe auch QGuiApplication::setLayoutDirection(), QWidget::setLayoutDirection(), QTextOption::setTextDirection(), und QString::isRightToLeft().

enum Qt::MaskMode

Diese Aufzählung legt das Verhalten der Funktionen QPixmap::createMaskFromColor() und QImage::createMaskFromColor() fest.

Konstante	Wert	Beschreibung
`Qt::MaskInColor`	`0`	Erzeugt eine Maske, bei der alle Pixel, die der angegebenen Farbe entsprechen, undurchsichtig sind.
`Qt::MaskOutColor`	`1`	Erzeugt eine Maske, bei der alle Pixel, die mit der angegebenen Farbe übereinstimmen, transparent sind.

enum Qt::MatchFlag
flags Qt::MatchFlags

Diese Aufzählung beschreibt die Art der Übereinstimmungen, die bei der Suche nach Elementen in einem Modell verwendet werden können.

Konstante	Wert	Beschreibung
`Qt::MatchExactly`	`0`	Führt einen QVariant-basierten Abgleich durch.
`Qt::MatchFixedString`	`8`	Führt einen zeichenkettenbasierten Abgleich durch. Bei zeichenkettenbasierten Vergleichen wird die Groß-/Kleinschreibung nicht berücksichtigt, es sei denn, das Flag `MatchCaseSensitive` ist ebenfalls angegeben.
`Qt::MatchContains`	`1`	Der Suchbegriff ist in dem Eintrag enthalten.
`Qt::MatchStartsWith`	`2`	Der Suchbegriff stimmt mit dem Anfang des Eintrags überein.
`Qt::MatchEndsWith`	`3`	Der Suchbegriff stimmt mit dem Ende des Eintrags überein.
`Qt::MatchCaseSensitive`	`16`	Bei der Suche wird zwischen Groß- und Kleinschreibung unterschieden.
`Qt::MatchRegularExpression`	`4`	Führt einen String-basierten Abgleich mit einem regulären Ausdruck als Suchbegriff durch. Verwendet QRegularExpression. Bei Verwendung dieses Flags kann ein QRegularExpression Objekt als Parameter übergeben werden, das direkt zur Durchführung der Suche verwendet wird. Das Flag zur Unterscheidung von Groß- und Kleinschreibung wird ignoriert, da erwartet wird, dass das QRegularExpression Objekt vollständig konfiguriert ist. Dieser Enum-Wert wurde in Qt 5.15 hinzugefügt.
`Qt::MatchWildcard`	`5`	Führt einen String-basierten Abgleich durch, wobei ein String mit Wildcards als Suchbegriff verwendet wird.
`Qt::MatchWrap`	`32`	Führt eine umlaufende Suche durch, d.h. wenn die Suche das letzte Element im Modell erreicht, beginnt sie wieder beim ersten Element und wird fortgesetzt, bis alle Elemente untersucht wurden.
`Qt::MatchRecursive`	`64`	Durchsucht die gesamte Hierarchie.

Hinweis: Qt::MatchExactly, Qt::MatchContains, Qt::MatchStartsWith, Qt::MatchEndsWith, Qt::MatchRegularExpression, Qt::MatchWildcard, und Qt::MatchFixedString schließen sich gegenseitig aus. Das Verhalten, das erreicht wird, wenn mehrere von ihnen in einem Qt::MatchFlags-Argument gesetzt werden, ist undefiniert.

Der Typ MatchFlags ist ein Typedef für QFlags<MatchFlag>. Er speichert eine OR-Kombination von MatchFlag-Werten.

Siehe auch QString::compare() und QRegularExpression.

enum Qt::Modifier
flags Qt::Modifiers

Diese Aufzählung bietet kürzere Namen für die von Qt unterstützten Modifier-Tasten der Tastatur.

Hinweis: Unter macOS entspricht der Wert CTRL den Befehlstasten auf der Tastatur, und der Wert META den Steuerungstasten.

Konstante	Wert	Beschreibung
`Qt::SHIFT`	`Qt::ShiftModifier`	Die Umschalttasten, die auf allen Standardtastaturen vorhanden sind.
`Qt::META`	`Qt::MetaModifier`	Die Meta-Tasten.
`Qt::CTRL`	`Qt::ControlModifier`	Die Strg-Tasten.
`Qt::ALT`	`Qt::AltModifier`	Die normalen Alt-Tasten, aber nicht Tasten wie AltGr.

Der Typ Modifiers ist ein Typedef für QFlags<Modifier>. Er speichert eine ODER-Kombination von Modifier-Werten.

Siehe auch KeyboardModifier und MouseButton.

enum Qt::MouseButton
flags Qt::MouseButtons

Dieser enum-Typ beschreibt die verschiedenen Maustasten.

Konstante	Wert	Beschreibung
`Qt::NoButton`	`0x00000000`	Der Zustand der Taste bezieht sich auf keine Taste (siehe QMouseEvent::button()).
`Qt::AllButtons`	`0x07ffffff`	Dieser Wert entspricht einer Maske für alle möglichen Maustasten. Wird verwendet, um die 'acceptedButtons'-Eigenschaft von MouseArea so einzustellen, dass ALLE Maustasten akzeptiert werden.
`Qt::LeftButton`	`0x00000001`	Die linke Taste wird gedrückt, oder ein Ereignis bezieht sich auf die linke Taste. (Die linke Taste kann bei linkshändigen Mäusen die rechte Taste sein).
`Qt::RightButton`	`0x00000002`	Die rechte Taste.
`Qt::MiddleButton`	`0x00000004`	Die mittlere Taste.
`Qt::BackButton`	`0x00000008`	Die "Zurück"-Taste. (Sie befindet sich normalerweise auf der Daumenseite einer Maus mit zusätzlichen Tasten. Dies ist NICHT das Kipprad.)
`Qt::XButton1`	`BackButton`	Die "Zurück"-Taste.
`Qt::ExtraButton1`	`XButton1`	Die 'Zurück'-Taste.
`Qt::ForwardButton`	`0x00000010`	Die Taste "Vorwärts". (Befindet sich in der Regel neben der Zurück-Taste und wird ebenfalls mit dem Daumen gedrückt).
`Qt::XButton2`	`ForwardButton`	Die Vorwärtstaste.
`Qt::ExtraButton2`	`ForwardButton`	Die Taste "Vorwärts".
`Qt::TaskButton`	`0x00000020`	Die Taste "Aufgabe".
`Qt::ExtraButton3`	`TaskButton`	Die 'Task'-Taste.
`Qt::ExtraButton4`	`0x00000040`	Die 7. Nicht-Rad-Maustaste.
`Qt::ExtraButton5`	`0x00000080`	Die 8. Nicht-Rad-Maustaste.
`Qt::ExtraButton6`	`0x00000100`	Die 9. Nicht-Rad-Maustaste.
`Qt::ExtraButton7`	`0x00000200`	Die 10. Nicht-Rad-Maustaste.
`Qt::ExtraButton8`	`0x00000400`	Die 11. nicht radgebundene Maustaste.
`Qt::ExtraButton9`	`0x00000800`	Die 12. Nicht-Rad-Maustaste.
`Qt::ExtraButton10`	`0x00001000`	Die 13. Nicht-Rad-Maustaste.
`Qt::ExtraButton11`	`0x00002000`	Die 14. nicht radgebundene Maustaste.
`Qt::ExtraButton12`	`0x00004000`	Die 15. Nicht-Rad-Maustaste.
`Qt::ExtraButton13`	`0x00008000`	Die 16. Nicht-Rad-Maustaste.
`Qt::ExtraButton14`	`0x00010000`	Die 17. Nicht-Rad-Maustaste.
`Qt::ExtraButton15`	`0x00020000`	Die 18. Nicht-Rad-Maustaste.
`Qt::ExtraButton16`	`0x00040000`	Die 19. Nicht-Rad-Maustaste.
`Qt::ExtraButton17`	`0x00080000`	Die 20. Nicht-Rad-Maustaste.
`Qt::ExtraButton18`	`0x00100000`	Die 21. nicht radgebundene Maustaste.
`Qt::ExtraButton19`	`0x00200000`	Die 22. nicht radgebundene Maustaste.
`Qt::ExtraButton20`	`0x00400000`	Die 23. nicht radgebundene Maustaste.
`Qt::ExtraButton21`	`0x00800000`	Die 24. nicht radgebundene Maustaste.
`Qt::ExtraButton22`	`0x01000000`	Die 25. nicht radgebundene Maustaste.
`Qt::ExtraButton23`	`0x02000000`	Die 26. nicht radgebundene Maustaste.
`Qt::ExtraButton24`	`0x04000000`	Die 27. Nicht-Rad-Maustaste.

Hinweis: Einige Modelle von Mehrtastenmäusen sind mit hoch nummerierten Tasten vorkonfiguriert, die Tastatursequenzen emulieren, um in bestimmten Spielen verwendet zu werden. Damit diese Tasten als tatsächliche "Maustasten" angezeigt werden, muss das Gerät neu konfiguriert werden (mit dem Konfigurationsprogramm des Herstellers).

Der Typ MouseButtons ist ein Typedef für QFlags<MouseButton>. Er speichert eine ODER-Kombination von MouseButton-Werten.

Siehe auch KeyboardModifier und Modifier.

enum Qt::MouseEventFlag
flags Qt::MouseEventFlags

Diese Aufzählung liefert zusätzliche Informationen zu einem QMouseEvent.

Konstante	Wert	Beschreibung
`Qt::MouseEventCreatedDoubleClick`	`0x01`	Zeigt an, dass Qt aus diesem Ereignis ein MouseButtonDblClick Ereignis erzeugt hat. Das Flag wird im verursachenden MouseButtonPress gesetzt, und nicht im resultierenden MouseButtonDblClick.

Der Typ MouseEventFlags ist ein Typedef für QFlags<MouseEventFlag>. Er speichert eine ODER-Kombination von MouseEventFlag-Werten.

enum Qt::MouseEventSource

Dieses Enum beschreibt die Quelle eines Mausereignisses und kann nützlich sein, um festzustellen, ob es sich um ein künstliches Mausereignis handelt, das von einem anderen Gerät wie einem Touchscreen stammt.

Konstante	Wert	Beschreibung
`Qt::MouseEventNotSynthesized`	`0`	Der gebräuchlichste Wert. Auf Plattformen, auf denen solche Informationen verfügbar sind, zeigt dieser Wert an, dass das Ereignis als Reaktion auf ein echtes Mausereignis im System erzeugt wurde.
`Qt::MouseEventSynthesizedBySystem`	`1`	Zeigt an, dass das Mausereignis von der Plattform aus einem Berührungsereignis synthetisiert wurde.
`Qt::MouseEventSynthesizedByQt`	`2`	Zeigt an, dass das Mausereignis aus einem nicht behandelten Touch-Ereignis von Qt synthetisiert wurde.
`Qt::MouseEventSynthesizedByApplication`	`3`	Zeigt an, dass das Mausereignis von der Anwendung synthetisiert wurde. Dies ermöglicht die Unterscheidung von Mausereignissen, die von der Anwendung erzeugt wurden, von denen, die vom System kommen oder von Qt synthetisiert wurden. Dieser Wert wurde in Qt 5.6 eingeführt.

Siehe auch Qt::AA_SynthesizeMouseForUnhandledTouchEvents.

enum Qt::NativeGestureType

Diese Aufzählung gibt den Gesten-Typ zurück.

Konstante	Wert	Beschreibung
`Qt::BeginNativeGesture`	`0`	Wird vor dem Gesten-Ereignisstrom gesendet.
`Qt::EndNativeGesture`	`1`	Wird nach dem Gesten-Ereignisstrom gesendet.
`Qt::PanNativeGesture`	`2`	Gibt das Verschiebungsdelta in Pixeln an.
`Qt::ZoomNativeGesture`	`3`	Legt das Vergrößerungsdelta in Prozent fest.
`Qt::SmartZoomNativeGesture`	`4`	Boolescher Vergrößerungsstatus.
`Qt::RotateNativeGesture`	`5`	Gibt das Rotationsdelta in Grad an.
`Qt::SwipeNativeGesture`	`6`	Wird nach einer Wischbewegung gesendet.

enum Qt::NavigationMode

Dieser Enum-Typ beschreibt den Modus für den beweglichen Fokus.

Konstante	Wert	Beschreibung
`Qt::NavigationModeNone`	`0`	Es wird nur der Touchscreen verwendet.
`Qt::NavigationModeKeypadTabOrder`	`1`	Qt::Key_Up und Qt::Key_Down werden verwendet, um den Fokus zu ändern.
`Qt::NavigationModeKeypadDirectional`	`2`	Qt::Key_Up Qt::Key_Down, und werden verwendet, um den Fokus zu ändern. Qt::Key_Left Qt::Key_Right
`Qt::NavigationModeCursorAuto`	`3`	Der Mauszeiger wird verwendet, um den Fokus zu ändern; er wird nur auf Geräten ohne Touchscreen angezeigt. Die Tastatur wird zur Implementierung eines virtuellen Cursors verwendet, es sei denn, das Gerät verfügt über ein analoges Maus-Eingabegerät (z. B. ein Touchpad). Dies ist die empfohlene Einstellung für eine Anwendung wie z. B. einen Webbrowser, der die Zeigersteuerung sowohl auf Geräten mit als auch ohne Touchscreen benötigt.
`Qt::NavigationModeCursorForceVisible`	`4`	Der Mauszeiger wird verwendet, um den Fokus zu ändern; er wird unabhängig vom Gerätetyp angezeigt. Die Tastatur wird zur Implementierung eines virtuellen Cursors verwendet, es sei denn, das Gerät verfügt über ein analoges Maus-Eingabegerät (z. B. ein Touchpad).

Hinweis: Die Cursor-Navigation ist derzeit auf keiner Plattform implementiert und verhält sich wie NavigationModeNone.

Siehe auch QApplication::setNavigationMode() und QApplication::navigationMode().

enum Qt::Orientation
Flaggen Qt::Orientations

Dieser Typ wird verwendet, um die Ausrichtung eines Objekts zu kennzeichnen.

Konstante	Wert
`Qt::Horizontal`	`0x1`
`Qt::Vertical`	`0x2`

Orientation wird zum Beispiel mit QScrollBar verwendet.

Der Typ Orientations ist ein Typedef für QFlags<Orientation>. Er speichert eine ODER-Kombination von Orientierungswerten.

enum Qt::PenCapStyle

Dieser Enum-Typ definiert die von Qt unterstützten Stiftkappenstile, d.h. die Linienendkappen, die mit QPainter gezeichnet werden können.


Qt::SquareCap	Qt::FlatCap	Qt::RoundCap

Konstante	Wert	Beschreibung
`Qt::FlatCap`	`0x00`	ein quadratisches Linienende, das den Endpunkt der Linie nicht überdeckt.
`Qt::SquareCap`	`0x10`	ein quadratisches Linienende, das den Endpunkt überdeckt und um die Hälfte der Linienbreite darüber hinausgeht.
`Qt::RoundCap`	`0x20`	ein abgerundetes Linienende.

Siehe auch QPen.

enum Qt::PenJoinStyle

Dieser Enum-Typ definiert die von Qt unterstützten Stiftverbindungsstile, d.h. welche Verbindungen zwischen zwei verbundenen Linien mit QPainter gezeichnet werden können.


Qt::BevelJoin	Qt::MiterJoin	Qt::RoundJoin

Konstante	Wert	Beschreibung
`Qt::MiterJoin`	`0x00`	Die Außenkanten der Linien werden so verlängert, dass sie sich in einem Winkel treffen, und dieser Bereich wird gefüllt.
`Qt::BevelJoin`	`0x40`	Die dreieckige Kerbe zwischen den beiden Linien wird ausgefüllt.
`Qt::RoundJoin`	`0x80`	Ein Kreisbogen zwischen den beiden Linien wird ausgefüllt.
`Qt::SvgMiterJoin`	`0x100`	Eine Gehrungsverbindung, die der Definition einer Gehrungsverbindung in der SVG 1.2 Tiny-Spezifikation entspricht.

Siehe auch QPen.

enum Qt::PenStyle

Dieser Enum-Typ definiert die Stiftstile, die mit QPainter gezeichnet werden können. Die Stile sind:


Qt::SolidLine	Qt::DashLine	Qt::DotLine

Qt::DashDotLine	Qt::DashDotDotLine	Qt::CustomDashLine

Konstante	Wert	Beschreibung
`Qt::NoPen`	`0`	überhaupt keine Linie. Zum Beispiel: QPainter::drawRect() füllt, aber zeichnet keine Begrenzungslinie.
`Qt::SolidLine`	`1`	Eine einfache Linie.
`Qt::DashLine`	`2`	Striche, die durch ein paar Pixel getrennt sind.
`Qt::DotLine`	`3`	Punkte, die durch ein paar Pixel getrennt sind.
`Qt::DashDotLine`	`4`	Abwechselnd Punkte und Striche.
`Qt::DashDotDotLine`	`5`	Ein Gedankenstrich, zwei Punkte, ein Gedankenstrich, zwei Punkte.
`Qt::CustomDashLine`	`6`	Ein benutzerdefiniertes Muster, das mit QPainterPathStroker::setDashPattern() definiert wurde.

Siehe auch QPen.

`[since 6.5]` enum class Qt::PermissionStatus

Diese Aufzählung beschreibt die möglichen Zustände einer Erlaubnis.

Konstante	Wert	Beschreibung
`Qt::PermissionStatus::Undetermined`	`0`	Der Status der Berechtigung ist noch nicht bekannt. Die Berechtigung sollte über QCoreApplication::requestPermission() angefordert werden, um den aktuellen Status zu ermitteln. Dieser Status wird niemals das Ergebnis einer Berechtigungsanforderung sein.
`Qt::PermissionStatus::Granted`	`1`	Der Benutzer hat der Anwendung die Berechtigung explizit erteilt, oder es ist bekannt, dass die Berechtigung auf der gegebenen Plattform keine Benutzerautorisierung erfordert.
`Qt::PermissionStatus::Denied`	`2`	Der Benutzer hat der Anwendung die angeforderte Berechtigung explizit verweigert oder es ist bekannt, dass die Berechtigung für Anwendungen auf der gegebenen Plattform nicht zugänglich oder anwendbar ist.

Hinweis: Unter Android gibt es keinen Undetermined Status durch die APIs der Plattform. Wenn also eine Berechtigung für eine Anwendung verweigert wird, gibt QCoreApplication::checkPermission() standardmäßig Undetermined zurück, bis QCoreApplication::requestPermission() aufgerufen wird. Danach meldet QCoreApplication::checkPermission() einen nicht Undetermined Status.

Diese Aufzählung wurde in Qt 6.5 eingeführt.

Siehe auch QCoreApplication::requestPermission(), QCoreApplication::checkPermission(), und Anwendungsberechtigungen.

enum Qt::ReturnByValueConstant

Dies ist ein Dummy-Typ, der den Benutzern den Übergang von bestimmten veralteten APIs zu ihren Ersatz-APIs erleichtern soll.

Siehe auch QCursor::bitmap(), QCursor::mask(), QLabel::picture(), und QLabel::pixmap().

enum Qt::ScreenOrientation
flags Qt::ScreenOrientations

Dieser Enum-Typ spezifiziert die verschiedenen Ausrichtungen, die ein Bildschirm haben kann.

Konstante	Wert	Beschreibung
`Qt::PrimaryOrientation`	`0x00000000`	Die primäre Ausrichtung des Bildschirms.
`Qt::LandscapeOrientation`	`0x00000002`	Querformat, die Anzeigebreite ist größer als die Anzeigehöhe.
`Qt::PortraitOrientation`	`0x00000001`	Hochformat, die Anzeigehöhe ist größer als die Anzeigebreite, um 90 Grad im Uhrzeigersinn gegenüber dem Querformat gedreht.
`Qt::InvertedLandscapeOrientation`	`0x00000008`	Umgekehrte Querformatausrichtung, um 180 Grad relativ zum Querformat gedreht.
`Qt::InvertedPortraitOrientation`	`0x00000004`	Umgekehrte Hochformatausrichtung, um 180 Grad relativ zum Hochformat gedreht.

Der Typ ScreenOrientations ist ein Typedef für QFlags<ScreenOrientation>. Er speichert eine ODER-Kombination von ScreenOrientation-Werten.

enum Qt::ScrollBarPolicy

Dieser Enum-Typ beschreibt die verschiedenen Modi der Bildlaufleisten von QAbstractScrollArea.

Konstante	Wert	Beschreibung
`Qt::ScrollBarAsNeeded`	`0`	QAbstractScrollArea zeigt eine Bildlaufleiste an, wenn der Inhalt zu groß ist, um hineinzupassen, ansonsten nicht. Dies ist die Standardeinstellung.
`Qt::ScrollBarAlwaysOff`	`1`	QAbstractScrollArea zeigt nie eine Bildlaufleiste an.
`Qt::ScrollBarAlwaysOn`	`2`	QAbstractScrollArea zeigt immer eine Bildlaufleiste an. Diese Eigenschaft wird auf Systemen mit transienten Bildlaufleisten (z. B. auf Mac ab Version 10.7) ignoriert.

(Die Modi für die horizontalen und vertikalen Bildlaufleisten sind unabhängig voneinander).

enum Qt::ScrollPhase

Diese Aufzählung beschreibt die Phase des Bildlaufs.

Konstante	Wert	Beschreibung
`Qt::NoScrollPhase`	`0`	Das Eingabegerät unterstützt die Scrollphase nicht. Dieser Wert wurde in Qt 5.7 eingeführt.
`Qt::ScrollBegin`	`1`	Der Bildlauf beginnt gerade, aber der Bildlaufabstand hat sich noch nicht geändert.
`Qt::ScrollUpdate`	`2`	Der Bildlaufabstand hat sich geändert (Standard).
`Qt::ScrollEnd`	`3`	Der Bildlauf ist beendet, und der Bildlaufabstand hat sich nicht mehr geändert.
`Qt::ScrollMomentum`	`4`	Der Benutzer berührt das Eingabegerät nicht mehr, aber der Bildlauf wird aufgrund des Bildlaufimpulses fortgesetzt. Dieser Wert wurde in Qt 5.12 eingeführt.

enum Qt::ShortcutContext

Damit ein QEvent::Shortcut -Ereignis eintritt, muss die Tastenfolge des Tastaturkürzels vom Benutzer in einem Kontext eingegeben werden, in dem das Tastaturkürzel aktiv ist. Die folgenden Kontexte sind möglich:

Konstante	Wert	Beschreibung
`Qt::WidgetShortcut`	`0`	Das Tastaturkürzel ist aktiv, wenn das übergeordnete Widget den Fokus hat.
`Qt::WidgetWithChildrenShortcut`	`3`	Die Verknüpfung ist aktiv, wenn ihr übergeordnetes Widget oder eines ihrer untergeordneten Widgets den Fokus hat. Kinder, die Widgets der obersten Ebene sind, mit Ausnahme von Pop-ups, sind von diesem Verknüpfungskontext nicht betroffen.
`Qt::WindowShortcut`	`1`	Die Verknüpfung ist aktiv, wenn das übergeordnete Widget ein logisches Subwidget des aktiven Top-Level-Fensters ist.
`Qt::ApplicationShortcut`	`2`	Die Verknüpfung ist aktiv, wenn eines der Anwendungsfenster aktiv ist.

enum Qt::SizeHint

Diese Aufzählung wird von QGraphicsLayoutItem::sizeHint() verwendet.

Konstante	Wert	Beschreibung
`Qt::MinimumSize`	`0`	wird verwendet, um die Mindestgröße eines Grafiklayoutelements anzugeben.
`Qt::PreferredSize`	`1`	wird verwendet, um die bevorzugte Größe eines Grafiklayoutelements anzugeben.
`Qt::MaximumSize`	`2`	wird verwendet, um die maximale Größe eines Grafiklayoutelements anzugeben.
`Qt::MinimumDescent`	`3`	wird verwendet, um den Mindestabstieg einer Textzeichenfolge in einem Grafiklayoutelement anzugeben.

Siehe auch QGraphicsLayoutItem::sizeHint().

enum Qt::SizeMode

Diese Aufzählung wird von den Funktionen QPainter::drawRoundedRect() und QPainterPath::addRoundedRect() verwendet, um die Radien der Rechteck-Ecken in Bezug auf die Abmessungen der angegebenen Begrenzungsrechtecke anzugeben.

Konstante	Wert	Beschreibung
`Qt::AbsoluteSize`	`0`	Gibt die Größe mit absoluten Maßen an.
`Qt::RelativeSize`	`1`	Gibt die Größe relativ zum begrenzenden Rechteck an, typischerweise unter Verwendung prozentualer Maße.

enum Qt::SortOrder

Diese Aufzählung beschreibt, wie die Elemente in einem Widget sortiert werden.

Konstante	Wert	Beschreibung
`Qt::AscendingOrder`	`0`	Die Elemente werden aufsteigend sortiert, z.B. beginnt mit 'AAA' endet mit 'ZZZ' in Latin-1-Sprachräumen
`Qt::DescendingOrder`	`1`	Die Elemente werden absteigend sortiert, z.B. beginnt mit 'ZZZ' und endet mit 'AAA' in Latin-1-Sprachumgebungen

enum Qt::SplitBehaviorFlags
flags Qt::SplitBehavior

Diese Aufzählung gibt an, wie sich die split()-Funktionen in Bezug auf leere Zeichenketten verhalten sollen.

Konstante	Wert	Beschreibung
`Qt::KeepEmptyParts`	`0`	Wenn ein Feld leer ist, behalte es im Ergebnis.
`Qt::SkipEmptyParts`	`0x1`	Wenn ein Feld leer ist, wird es nicht in das Ergebnis aufgenommen.

Der Typ SplitBehavior ist ein Typedef für QFlags<SplitBehaviorFlags>. Er speichert eine OR-Kombination von SplitBehaviorFlags-Werten.

Siehe auch QString::split().

enum Qt::TabFocusBehavior

Dieser Enum-Typ bietet verschiedene Fokus-Verhaltensweisen für die Registerkarten-Navigation.

Konstante	Wert	Beschreibung
`Qt::NoTabFocus`	`0x00`	iteriert nichts.
`Qt::TabFocusTextControls`	`0x01`	iteriert Text-Steuerelemente und Widgets.
`Qt::TabFocusListControls`	`0x02`	iteriert Listensteuerelemente und Widgets.
`Qt::TabFocusAllControls`	`0xff`	Iteriert alle Steuerelemente und Widgets.

enum Qt::TextElideMode

Diese Aufzählung gibt an, wo die Ellipse erscheinen soll, wenn Texte angezeigt werden, die nicht in den Text passen:

Konstante	Wert	Beschreibung
`Qt::ElideLeft`	`0`	Die Ellipse soll am Anfang des Textes erscheinen.
`Qt::ElideRight`	`1`	Die Ellipse soll am Ende des Textes erscheinen.
`Qt::ElideMiddle`	`2`	Die Ellipse sollte in der Mitte des Textes erscheinen.
`Qt::ElideNone`	`3`	Ellipsen sollten NICHT im Text erscheinen. Bei der Übergabe an Funktionen wie QFontMetrics::elidedText() wird die vollständige Zeichenkette zurückgegeben, es sei denn, der Text enthält Varianten mit mehreren Längen. In diesem Fall muss die Eliminierung durch Beschneidung auf die Komponentenbreite erfolgen.

Qt::ElideMiddle ist normalerweise die beste Wahl für URLs (z.B."http://bugreports.qt.../QTWEBSITE-13/"), während Qt::ElideRight für andere Strings geeignet ist (z.B."Deploying Applications on Ma...").

Siehe auch QAbstractItemView::textElideMode, QFontMetrics::elidedText(), AlignmentFlag, und QTabBar::elideMode.

enum Qt::TextFlag

Dieser Enum-Typ wird verwendet, um einige Modifier-Flags zu definieren. Einige dieser Flags sind nur im Zusammenhang mit dem Drucken sinnvoll:

Konstante	Wert	Beschreibung
`Qt::TextSingleLine`	`0x0100`	Behandelt alle Leerzeichen als Leerzeichen und druckt nur eine Zeile.
`Qt::TextDontClip`	`0x0200`	Wenn es unmöglich ist, innerhalb der angegebenen Grenzen zu bleiben, wird außerhalb gedruckt.
`Qt::TextExpandTabs`	`0x0400`	Lässt das Zeichen U+0009 (ASCII-Tabulator) zum nächsten Tabulatorstop springen.
`Qt::TextShowMnemonic`	`0x0800`	Zeigt die Zeichenfolge "&P" als P an. Für ein kaufmännisches Und-Zeichen verwenden Sie "&&".
`Qt::TextWordWrap`	`0x1000`	Bricht Zeilen an geeigneten Stellen um, z. B. an Wortgrenzen.
`Qt::TextWrapAnywhere`	`0x2000`	Bricht Zeilen überall um, auch innerhalb von Wörtern.
`Qt::TextHideMnemonic`	`0x8000`	Entspricht Qt::TextShowMnemonic, zeichnet aber keine Unterstreichungen.
`Qt::TextDontPrint`	`0x4000`	Behandelt diesen Text als "versteckt" und druckt ihn nicht.
`Qt::TextIncludeTrailingSpaces`	`0x08000000`	Wenn diese Option gesetzt ist, geben QTextLine::naturalTextWidth() und QTextLine::naturalTextRect() einen Wert zurück, der die Breite der nachgestellten Leerzeichen im Text einschließt; andernfalls wird diese Breite nicht berücksichtigt.
`Qt::TextJustificationForced`	`0x10000`	Stellt sicher, dass Textzeilen im Blocksatz gedruckt werden.

Sie können so viele Modifier-Flags verwenden, wie Sie wollen, außer dass Qt::TextSingleLine und Qt::TextWordWrap nicht kombiniert werden können.

Flags, die für eine bestimmte Verwendung unpassend sind, werden im Allgemeinen ignoriert.

enum Qt::TextFormat

Dieses Enum wird in Widgets verwendet, die sowohl reinen Text als auch Rich-Text anzeigen können, zum Beispiel QLabel. Es wird verwendet, um zu entscheiden, ob ein Textstring als das eine oder das andere interpretiert werden soll. Dies geschieht normalerweise durch die Übergabe eines der Enum-Werte an eine QTextEdit::setTextFormat() Funktion.

Konstante	Wert	Beschreibung
`Qt::PlainText`	`0`	Der Textstring wird als einfacher Textstring interpretiert.
`Qt::RichText`	`1`	Der Textstring wird als Rich-Text-String interpretiert. Siehe Supported HTML Subset für die Definition von Rich Text.
`Qt::AutoText`	`2`	Der Textstring wird als Qt::RichText interpretiert, wenn Qt::mightBeRichText() `true` zurückgibt, ansonsten als Qt::PlainText.
`Qt::MarkdownText`	`3`	Der Textstring wird als Markdown-formatierter Text interpretiert. Dieser enum-Wert wurde in Qt 5.14 hinzugefügt.

enum Qt::TextInteractionFlag
flags Qt::TextInteractionFlags

Diese Aufzählung legt fest, wie ein textanzeigendes Widget auf Benutzereingaben reagiert.

Konstante	Wert	Beschreibung
`Qt::NoTextInteraction`	`0`	Es ist keine Interaktion mit dem Text möglich.
`Qt::TextSelectableByMouse`	`1`	Text kann mit der Maus ausgewählt und über ein Kontextmenü oder Standard-Tastaturkürzel in die Zwischenablage kopiert werden.
`Qt::TextSelectableByKeyboard`	`2`	Der Text kann mit den Cursortasten auf der Tastatur ausgewählt werden. Es wird ein Textcursor angezeigt.
`Qt::LinksAccessibleByMouse`	`4`	Links können mit der Maus hervorgehoben und aktiviert werden.
`Qt::LinksAccessibleByKeyboard`	`8`	Links können mit der Tabulatortaste fokussiert und mit der Eingabetaste aktiviert werden.
`Qt::TextEditable`	`16`	Der Text ist vollständig editierbar.
`Qt::TextEditorInteraction`	`TextSelectableByMouse \| TextSelectableByKeyboard \| TextEditable`	Die Voreinstellung für einen Texteditor.
`Qt::TextBrowserInteraction`	`TextSelectableByMouse \| LinksAccessibleByMouse \| LinksAccessibleByKeyboard`	Die Voreinstellung für QTextBrowser.

Der Typ TextInteractionFlags ist ein Typedef für QFlags<TextInteractionFlag>. Er speichert eine ODER-Kombination von TextInteractionFlag-Werten.

enum Qt::TileRule

Diese Aufzählung beschreibt, wie die Teile eines Bildes beim Zeichnen wiederholt oder gestreckt werden können.

Konstante	Wert	Beschreibung
`Qt::StretchTile`	`0`	Skaliert das Bild so, dass es in den verfügbaren Bereich passt.
`Qt::RepeatTile`	`1`	Wiederholt das Bild, bis kein Platz mehr vorhanden ist. Kann das letzte Bild beschneiden.
`Qt::RoundTile`	`2`	Ähnlich wie Wiederholen, jedoch wird das Bild verkleinert, um sicherzustellen, dass die letzte Kachel nicht abgeschnitten wird.

enum Qt::TimeSpec

Konstante	Wert	Beschreibung
`Qt::LocalTime`	`0`	Ortszeit, gesteuert durch eine Systemzeitzoneneinstellung.
`Qt::UTC`	`1`	Koordinierte Weltzeit.
`Qt::OffsetFromUTC`	`2`	Ein Offset in Sekunden zur koordinierten Weltzeit.
`Qt::TimeZone`	`3`	Eine benannte Zeitzone.

Sowohl LocalTime als auch TimeZone kümmern sich um Übergänge, wie den Beginn und das Ende der Sommerzeit. UTC ist die Standardzeit, auf die sich die Zeitzonen normalerweise beziehen: Die Greenwich Mean Time weicht nicht von ihr ab. Weder UTC noch OffsetFromUTC haben irgendwelche Übergänge.

Bei der Angabe einer Datumszeit mit OffsetFromUTC muss auch der Offset von UTC angegeben werden (er wird in Sekunden gemessen). Um einen Zeitpunkt mit TimeZone anzugeben, muss eine QTimeZone angegeben werden. Ab Qt 6.5 kann ein QTimeZone nun einen Timespec mit einem Offset als leichtgewichtige Zeitbeschreibung verpacken, so dass die Übergabe eines QTimeZone nun einen einheitlichen Weg zur Verwendung von Datetime-APIs bietet und die Notwendigkeit erspart, sie für verschiedene Timespecs unterschiedlich aufzurufen.

Hinweis: Nach einer Änderung der Systemzeitzoneneinstellung ist das Verhalten von LocalTime-basierten QDateTime Objekten, die vor der Änderung erstellt wurden, undefiniert: QDateTime kann Daten im Cache haben, die durch die Änderung ungültig werden. (Dies wird nicht durch Änderungen der Systemzeitzone ausgelöst.) In lang laufenden Prozessen können Aktualisierungen der Zeitzonendaten des Systems (z. B. wenn Politiker die Regeln für eine Zone ändern) ebenfalls zu Konflikten zwischen den aktualisierten Zeitzoneninformationen und Daten führen, die von QDateTime Objekten zwischengespeichert wurden, die vor der Aktualisierung erstellt wurden und entweder LocalTime oder TimeZone verwenden.

Siehe auch QTimeZone und QDateTime.

`[since 6.8]` enum class TimerId

Dies wird verwendet, um Zeitgeber-IDs darzustellen (z. B. QTimer und QChronoTimer). Der zugrunde liegende Typ ist int. Sie können qToUnderlying() verwenden, um Qt::TimerId in int zu konvertieren.

Konstante	Wert	Beschreibung
`QObject::TimerId::Invalid`	`0`	Stellt eine No-Op-Timer-ID dar; ihre Verwendung hängt vom Kontext ab, z.B. ist dies der Wert, der von QObject::startTimer() zurückgegeben wird, um anzuzeigen, dass es fehlgeschlagen ist, einen Timer zu starten; während QChronoTimer::id() diesen Wert zurückgibt, wenn der Timer inaktiv ist, d.h. `timer.isActive()` gibt `false` zurück.

Dieses Enum wurde in Qt 6.8 eingeführt.

Siehe auch QTimer::id(), QChronoTimer::id(), und QObject::startTimer().

enum Qt::TimerType

Der Timer-Typ gibt an, wie genau ein Timer sein kann.

Konstante	Wert	Beschreibung
`Qt::PreciseTimer`	`0`	Präzise Zeitgeber versuchen, die Genauigkeit im Millisekundenbereich zu halten
`Qt::CoarseTimer`	`1`	Grobe Zeitgeber versuchen, die Genauigkeit innerhalb von 5% des gewünschten Intervalls zu halten
`Qt::VeryCoarseTimer`	`2`	Sehr grobe Timer halten nur die Genauigkeit einer vollen Sekunde ein

Unter UNIX (einschließlich Linux, macOS und iOS) hält Qt die Millisekundengenauigkeit für Qt::PreciseTimer ein. Für Qt::CoarseTimer wird das Intervall um bis zu 5% angepasst, um den Timer mit anderen Timern abzugleichen, von denen erwartet wird, dass sie zur gleichen Zeit oder ungefähr zur gleichen Zeit ablaufen. Das Ziel ist es, die meisten Timer zur gleichen Zeit aufzuwecken und so die CPU-Weckzeiten und den Stromverbrauch zu reduzieren.

Unter Windows verwendet Qt die Multimedia-Timer-Funktion von Windows (falls verfügbar) für Qt::PreciseTimer und normale Windows-Timer für Qt::CoarseTimer und Qt::VeryCoarseTimer.

Auf allen Plattformen wird das Intervall für Qt::VeryCoarseTimer auf die nächste volle Sekunde gerundet (z.B. wird ein Intervall von 23500ms auf 24000ms gerundet, und 20300ms auf 20000ms).

enum Qt::ToolBarArea
Flaggen Qt::ToolBarAreas

Konstante	Wert
`Qt::LeftToolBarArea`	`0x1`
`Qt::RightToolBarArea`	`0x2`
`Qt::TopToolBarArea`	`0x4`
`Qt::BottomToolBarArea`	`0x8`
`Qt::AllToolBarAreas`	`ToolBarArea_Mask`
`Qt::NoToolBarArea`	`0`

Der Typ ToolBarAreas ist ein Typedef für QFlags<ToolBarArea>. Er speichert eine ODER-Kombination von ToolBarArea-Werten.

enum Qt::ToolButtonStyle

Der Stil der Werkzeugschaltfläche, der beschreibt, wie der Text und das Symbol der Schaltfläche angezeigt werden sollen.

Konstante	Wert	Beschreibung
`Qt::ToolButtonIconOnly`	`0`	Nur das Symbol anzeigen.
`Qt::ToolButtonTextOnly`	`1`	Nur den Text anzeigen.
`Qt::ToolButtonTextBesideIcon`	`2`	Der Text wird neben dem Symbol angezeigt.
`Qt::ToolButtonTextUnderIcon`	`3`	Der Text wird unter dem Symbol angezeigt.
`Qt::ToolButtonFollowStyle`	`4`	Befolgen Sie die style.

enum Qt::TouchPointState
flags Qt::TouchPointStates

Diese Aufzählung stellt den Zustand eines Touchpoints zum Zeitpunkt des Auftretens von QTouchEvent dar.

Konstante	Wert	Beschreibung
`Qt::TouchPointUnknownState`	`0x00`	Der Zustand des Berührungspunktes ist nicht bekannt.
`Qt::TouchPointPressed`	`0x01`	Der Berührungspunkt ist jetzt gedrückt.
`Qt::TouchPointMoved`	`0x02`	Der Berührungspunkt wurde bewegt.
`Qt::TouchPointStationary`	`0x04`	Der Berührungspunkt hat sich nicht bewegt.
`Qt::TouchPointReleased`	`0x08`	Der Berührungspunkt wurde losgelassen.

Der Typ TouchPointStates ist ein Typedef für QFlags<TouchPointState>. Er speichert eine ODER-Kombination von TouchPointState-Werten.

enum Qt::TransformationMode

Dieser Enum-Typ legt fest, ob Bildtransformationen (z. B. Skalierung) weich sein sollen oder nicht.

Konstante	Wert	Beschreibung
`Qt::FastTransformation`	`0`	Die Transformation wird schnell und ohne Glättung durchgeführt.
`Qt::SmoothTransformation`	`1`	Das resultierende Bild wird durch bilineare Filterung transformiert.

Siehe auch QImage::scaled().

enum Qt::UIEffect

Diese Aufzählung beschreibt die verfügbaren UI-Effekte.

Standardmäßig wird Qt versuchen, die plattformspezifischen Desktop-Einstellungen für jeden Effekt zu verwenden. Verwenden Sie die Funktion QApplication::setDesktopSettingsAware() (mit false als Argument), um dies zu verhindern, und die Funktion QApplication::setEffectEnabled(), um einen bestimmten Effekt zu aktivieren oder zu deaktivieren.

Beachten Sie, dass alle Effekte auf Bildschirmen mit einer Farbtiefe von weniger als 16 Bit deaktiviert sind.

Konstante	Wert	Beschreibung
`Qt::UI_AnimateMenu`	`1`	Animierte Menüs anzeigen.
`Qt::UI_FadeMenu`	`2`	Zeigt eingeblendete Menüs.
`Qt::UI_AnimateCombo`	`3`	Animierte Comboboxen anzeigen.
`Qt::UI_AnimateTooltip`	`4`	Tooltip-Animationen anzeigen.
`Qt::UI_FadeTooltip`	`5`	Tooltip-Einblendeffekte anzeigen.
`Qt::UI_AnimateToolBox`	`6`	Reserviert

Siehe auch QApplication::setEffectEnabled() und QGuiApplication::setDesktopSettingsAware().

enum Qt::WhiteSpaceMode

Diese Aufzählung beschreibt die Arten des Leerraummodus, die von der Klasse QTextDocument verwendet werden, um die Anforderungen verschiedener Arten von Textinformationen zu erfüllen.

Konstante	Wert	Beschreibung
`Qt::WhiteSpaceNormal`	`0`	Der Leerraummodus, der für die Anzeige von normalem Text in Absätzen mit Zeilenumbruch verwendet wird.
`Qt::WhiteSpacePre`	`1`	Ein vorformatierter Textmodus, in dem der Leerraum exakt wiedergegeben wird.
`Qt::WhiteSpaceNoWrap`	`2`

enum Qt::WidgetAttribute

Dieser Enum-Typ wird zur Angabe verschiedener Widget-Attribute verwendet. Attribute werden mit QWidget::setAttribute() gesetzt und gelöscht, und mit QWidget::testAttribute() abgefragt, obwohl einige spezielle Komfortfunktionen haben, die unten erwähnt werden.

Konstante	Wert	Beschreibung
`Qt::WA_AcceptDrops`	`78`	Erlaubt das Ablegen von Daten aus Drag&Drop-Operationen auf dem Widget (siehe QWidget::setAcceptDrops()).
`Qt::WA_AlwaysShowToolTips`	`84`	Ermöglicht Tooltips für inaktive Fenster.
`Qt::WA_CustomWhatsThis`	`47`	Zeigt an, dass das Widget weiterhin normal im "Was ist das?"-Modus arbeiten möchte. Dies wird vom Autor des Widgets festgelegt.
`Qt::WA_DeleteOnClose`	`55`	Bringt Qt dazu, dieses Widget zu löschen, wenn das Widget das Schließereignis akzeptiert hat (siehe QWidget::closeEvent()).
`Qt::WA_Disabled`	`0`	Zeigt an, dass das Widget deaktiviert ist, d.h. es empfängt keine Maus- oder Tastaturereignisse. Es gibt auch eine Getter-Funktion QWidget::isEnabled(). Diese wird vom Qt-Kernel gesetzt/gelöscht.
`Qt::WA_DontShowOnScreen`	`103`	Zeigt an, dass das Widget versteckt ist oder kein Teil des sichtbaren Desktops ist.
`Qt::WA_ForceDisabled`	`32`	Zeigt an, dass das Widget explizit deaktiviert ist, d.h. es bleibt deaktiviert, auch wenn alle seine Vorgänger in den aktivierten Zustand versetzt werden. Dies impliziert WA_Disabled. Dies wird durch QWidget::setEnabled() und QWidget::setDisabled() gesetzt/gelöscht.
`Qt::WA_ForceUpdatesDisabled`	`59`	Zeigt an, dass Aktualisierungen für das Widget explizit deaktiviert sind, d. h. es bleibt auch dann deaktiviert, wenn alle seine Vorfahren in den Status "Aktualisierungen aktiviert" gesetzt werden. Dies impliziert WA_UpdatesDisabled. Dies wird durch QWidget::setUpdatesEnabled() gesetzt/gelöscht.
`Qt::WA_Hover`	`74`	Erzwingt, dass Qt Paint-Events erzeugt, wenn die Maus das Widget betritt oder verlässt. Diese Funktion wird typischerweise verwendet, wenn benutzerdefinierte Stile implementiert werden.
`Qt::WA_InputMethodEnabled`	`14`	Aktiviert Eingabemethoden für asiatische Sprachen. Muss gesetzt werden, wenn benutzerdefinierte Textbearbeitungs-Widgets erstellt werden.
`Qt::WA_KeyboardFocusChange`	`77`	Wird in einem Toplevel-Fenster gesetzt, wenn der Benutzer den Fokus mit der Tastatur ändert (Tab, Backtab oder Shortcut).
`Qt::WA_KeyCompression`	`33`	Aktiviert die Komprimierung von Tastenereignissen, wenn sie gesetzt ist, und deaktiviert sie, wenn sie nicht gesetzt ist. Standardmäßig ist die Tastenkomprimierung ausgeschaltet, so dass Widgets für jeden Tastendruck ein Tastendruck-Ereignis erhalten (oder mehr, da Autorepeat normalerweise eingeschaltet ist). Wenn Sie es einschalten und Ihr Programm nicht mit der Tasteneingabe Schritt hält, kann Qt versuchen, Tastenereignisse zu komprimieren, so dass mehr als ein Zeichen in jedem Ereignis verarbeitet werden kann. Zum Beispiel könnte ein Textverarbeitungs-Widget 2, 3 oder mehr Zeichen in jedem QKeyEvent::text() empfangen, wenn die Neuberechnung des Layouts zu lange für die CPU dauert. Wenn ein Widget Mehrzeichen-Unicode-Eingaben unterstützt, ist es immer sicher, die Kompression einzuschalten. Qt führt die Komprimierung von Tastenereignissen nur für druckbare Zeichen durch. Qt::Modifier Tasten, Cursor-Bewegungstasten, Funktionstasten und verschiedene Aktionstasten (z.B. Escape, Enter, Backspace, PrintScreen) stoppen die Komprimierung von Tastenereignissen, selbst wenn weitere komprimierbare Tastenereignisse verfügbar sind. Andere Plattformen als Mac und X11 unterstützen diese Komprimierung nicht, in diesem Fall hat das Einschalten der Komprimierung keine Auswirkungen. Dies wird durch den Autor des Widgets gesetzt/freigegeben.
`Qt::WA_LayoutOnEntireRect`	`48`	Zeigt an, dass das Widget möchte, dass QLayout auf die gesamte QWidget::rect() wirkt, nicht nur auf QWidget::contentsRect(). Dies wird durch den Autor des Widgets festgelegt.
`Qt::WA_LayoutUsesWidgetRect`	`92`	Ignorieren Sie das Layoutelement rect aus dem Stil, wenn Sie dieses Widget mit QLayout auslegen.
`Qt::WA_MacOpaqueSizeGrip`	`85`	Zeigt an, dass der Griff der nativen Größe undurchsichtig statt transparent (Standard) sein soll. Dieses Attribut ist nur auf macOS anwendbar und wird vom Autor des Widgets gesetzt.
`Qt::WA_MacShowFocusRect`	`88`	Zeigt an, dass dieses Widget eine QFocusFrame um sich herum haben soll. Einige Widgets zeichnen ihren eigenen Fokus-Halo unabhängig von diesem Attribut. Nicht, dass QWidget::focusPolicy die Hauptrolle dabei spielt, ob etwas den Fokus bekommt oder nicht, dies steuert nur, ob es den Fokusrahmen bekommt oder nicht. Dieses Attribut ist nur auf macOS anwendbar.
`Qt::WA_MacNormalSize`	`89`	Gibt an, dass das Widget die normale Größe für Widgets unter macOS haben soll. Dieses Attribut ist nur auf macOS anwendbar.
`Qt::WA_MacSmallSize`	`90`	Zeigt an, dass das Widget die kleine Größe für Widgets unter macOS haben sollte. Dieses Attribut ist nur auf macOS anwendbar.
`Qt::WA_MacMiniSize`	`91`	Zeigt an, dass das Widget die Minigröße für Widgets unter macOS haben sollte. Dieses Attribut ist nur auf macOS anwendbar.
`Qt::WA_Mapped`	`11`	Zeigt an, dass das Widget auf dem Bildschirm abgebildet wird. Dies wird durch den Qt-Kernel gesetzt/geklärt.
`Qt::WA_MouseNoMask`	`71`	Sorgt dafür, dass das Widget Mausereignisse für das gesamte Widget empfängt, unabhängig von der aktuell eingestellten Maske, und setzt QWidget::setMask() außer Kraft. Dies ist nicht anwendbar für Top-Level-Fenster.
`Qt::WA_MouseTracking`	`2`	Zeigt an, dass das Widget die Mausverfolgung aktiviert hat. Siehe QWidget::mouseTracking.
`Qt::WA_Moved`	`43`	Zeigt an, dass das Widget eine explizite Position hat. Diese wird durch QWidget::move() und durch QWidget::setGeometry() gesetzt/gelöscht.
`Qt::WA_NoChildEventsForParent`	`58`	Zeigt an, dass das Widget nicht möchte, dass ChildAdded- oder ChildRemoved-Ereignisse an seine Eltern gesendet werden. Dies ist selten notwendig, kann aber helfen, automatisch einfügende Widgets wie Splitter und Layouts zu vermeiden. Dies wird vom Autor des Widgets festgelegt.
`Qt::WA_NoChildEventsFromChildren`	`39`	Zeigt an, dass das Widget keine ChildAdded- oder ChildRemoved-Ereignisse empfangen möchte, die von seinen Kindern gesendet werden. Dies wird vom Autor des Widgets festgelegt.
`Qt::WA_NoMouseReplay`	`54`	Wird für Pop-up-Widgets verwendet. Zeigt an, dass das letzte Mausklick-Ereignis nicht wiedergegeben werden soll, wenn das Popup-Widget geschlossen wird. Das Flag wird vom Autor des Widgets gesetzt und vom Qt-Kernel jedes Mal gelöscht, wenn das Widget ein neues Mausereignis erhält.
`Qt::WA_NoMousePropagation`	`73`	Verhindert, dass Mausereignisse an den Elternteil des Widgets weitergegeben werden. Dieses Attribut ist standardmäßig deaktiviert.
`Qt::WA_TransparentForMouseEvents`	`51`	Wenn es aktiviert ist, deaktiviert dieses Attribut die Übertragung von Mausereignissen an das Widget und seine Kinder. Mausereignisse werden an andere Widgets weitergegeben, als ob das Widget und seine Kinder nicht in der Widget-Hierarchie vorhanden wären; Mausklicks und andere Ereignisse gehen effektiv "durch" sie hindurch. Dieses Attribut ist standardmäßig deaktiviert.
`Qt::WA_NoSystemBackground`	`9`	Gibt an, dass das Widget keinen Hintergrund hat, d.h. wenn das Widget Malereignisse empfängt, wird der Hintergrund nicht automatisch neu gezeichnet. Hinweis: Im Gegensatz zu WA_OpaquePaintEvent werden neu freigelegte Bereiche nie mit dem Hintergrund gefüllt (z. B. kann der Benutzer nach dem ersten Anzeigen eines Fensters "durch" dieses hindurchsehen, bis die Anwendung die Malereignisse verarbeitet). Dieses Flag wird vom Autor des Widgets gesetzt oder gelöscht.
`Qt::WA_OpaquePaintEvent`	`4`	Gibt an, dass das Widget alle seine Pixel malt, wenn es ein Malereignis empfängt. Daher ist es für Operationen wie Aktualisierung, Größenänderung, Scrollen und Fokuswechsel nicht erforderlich, das Widget zu löschen, bevor Malereignisse erzeugt werden. Die Verwendung von WA_OpaquePaintEvent stellt eine kleine Optimierung dar, indem sie dazu beiträgt, Flackern auf Systemen zu reduzieren, die keine doppelte Pufferung unterstützen, und indem sie Rechenzyklen vermeidet, die notwendig sind, um den Hintergrund vor dem Malen zu löschen. Hinweis: Im Gegensatz zu WA_NoSystemBackground ist WA_OpaquePaintEvent bestrebt, transparente Fensterhintergründe zu vermeiden. Dieses Flag wird vom Autor des Widgets gesetzt oder gelöscht.
`Qt::WA_OutsideWSRange`	`49`	Zeigt an, dass das Widget außerhalb des gültigen Bereichs des Koordinatensystems des Fenstersystems liegt. Ein Widget außerhalb des gültigen Bereichs kann nicht auf dem Bildschirm abgebildet werden. Dies wird durch den Qt-Kernel gesetzt/gelöscht.
`Qt::WA_PaintOnScreen`	`8`	Zeigt an, dass das Widget direkt auf den Bildschirm gezeichnet werden soll. Widgets mit diesem Attribut nehmen nicht an der Kompositionsverwaltung teil, d.h. sie können nicht halbtransparent sein oder durch halbtransparente, überlappende Widgets hindurch scheinen. Hinweis: Dieses Flag wird nur unter X11 unterstützt und deaktiviert die doppelte Pufferung. Unter Qt for Embedded Linux funktioniert das Flag nur, wenn es auf einem Top-Level-Widget gesetzt ist und es hängt von der Unterstützung durch den aktiven Bildschirmtreiber ab. Dieses Flag wird vom Autor des Widgets gesetzt oder gelöscht. Um außerhalb des Qt-Paint-Systems zu rendern, z.B. wenn Sie native Mal-Primitive benötigen, müssen Sie QWidget::paintEngine() neu implementieren, um 0 zurückzugeben und dieses Flag zu setzen.
`Qt::WA_PaintUnclipped`	`52`	Macht alle Maler, die auf diesem Widget arbeiten, unclipped. Kinder dieses Widgets oder andere Widgets vor diesem Widget beschneiden nicht den Bereich, auf dem der Maler malen kann. Dieses Flag wird nur für Widgets unterstützt, bei denen das WA_PaintOnScreen-Flag gesetzt ist. Der bevorzugte Weg, dies plattformübergreifend zu tun, ist die Erstellung eines transparenten Widgets, das vor den anderen Widgets liegt.
`Qt::WA_PendingMoveEvent`	`34`	Zeigt an, dass ein Verschiebungsereignis ansteht, z.B. wenn ein verstecktes Widget verschoben wurde. Dieses Flag wird vom Qt-Kernel gesetzt oder gelöscht.
`Qt::WA_PendingResizeEvent`	`35`	Zeigt an, dass ein Größenänderungsereignis ansteht, z.B. wenn ein verstecktes Widget in der Größe verändert wurde. Dieses Flag wird vom Qt-Kernel gesetzt oder gelöscht.
`Qt::WA_QuitOnClose`	`76`	Zeigt an, dass das Widget berücksichtigt werden soll, wenn entschieden wird, ob die Anwendung beendet werden soll, wenn das letzte Fenster geschlossen wird. Dieses Verhalten kann mit der Eigenschaft QGuiApplication::quitOnLastWindowClosed geändert werden. Standardmäßig ist dieses Attribut für alle Widgets des Typs Qt::Window gesetzt.
`Qt::WA_Resized`	`42`	Zeigt an, dass das Widget eine explizite Größe hat. Dieses Flag wird durch QWidget::resize() und QWidget::setGeometry() gesetzt oder gelöscht.
`Qt::WA_RightToLeft`	`56`	Zeigt an, dass die Layout-Richtung für das Widget von rechts nach links ist.
`Qt::WA_SetCursor`	`38`	Zeigt an, dass das Widget einen eigenen Cursor hat. Dieses Flag wird durch QWidget::setCursor() und QWidget::unsetCursor() gesetzt oder gelöscht.
`Qt::WA_SetFont`	`37`	Zeigt an, dass das Widget eine eigene Schriftart hat. Dieses Flag wird durch QWidget::setFont() gesetzt oder gelöscht.
`Qt::WA_SetPalette`	`36`	Zeigt an, dass das Widget über eine eigene Palette verfügt. Dieses Flag wird durch QWidget::setPalette() gesetzt oder gelöscht.
`Qt::WA_SetStyle`	`86`	Zeigt an, dass das Widget einen eigenen Stil hat. Dieses Flag wird durch QWidget::setStyle() gesetzt oder gelöscht.
`Qt::WA_ShowModal`	`70`	Dieses Attribut ist veraltet. Verwenden Sie stattdessen QWidget::windowModality.
`Qt::WA_StaticContents`	`5`	Zeigt an, dass der Inhalt des Widgets nordwestlich ausgerichtet und statisch ist. Bei einer Größenänderung empfängt ein solches Widget Malereignisse nur für die Teile von sich selbst, die neu sichtbar werden. Dieses Flag wird vom Autor des Widgets gesetzt oder gelöscht.
`Qt::WA_StyleSheet`	`97`	Zeigt an, dass das Widget mit einer Stilvorlage gestaltet ist. WA_StyleSheet wird immer dann gesetzt, wenn ein Widget einer Stilvorlage unterliegt, auch wenn die Stilvorlage das Aussehen des Widgets nicht beeinflusst hat.
`Qt::WA_StyleSheetTarget`	`131`	Zeigt an, dass das Aussehen des Widgets durch eine Stilvorlage verändert wurde. WA_StyleSheet wird ebenfalls gesetzt. Dieser Wert wurde in Qt 5.12 eingeführt.
`Qt::WA_TabletTracking`	`129`	Zeigt an, dass das Widget Tablet-Tracking aktiviert hat. Siehe QWidget::tabletTracking.
`Qt::WA_TranslucentBackground`	`120`	Zeigt an, dass das Widget einen durchscheinenden Hintergrund haben soll, d.h. alle nicht-opaken Bereiche des Widgets werden durchscheinend, da das Widget einen Alphakanal hat. Das Setzen dieses Flags bewirkt, dass WA_NoSystemBackground gesetzt wird. Unter Windows muss für das Widget auch das Qt::FramelessWindowHint window flag gesetzt werden. Dieses Flag wird vom Autor des Widgets gesetzt oder gelöscht. Seit Qt 5.0 wird das Umschalten dieses Attributs, nachdem das Widget angezeigt wurde, nicht mehr einheitlich auf allen Plattformen unterstützt. Wenn ein durchscheinender Hintergrund gewünscht ist, sollte das Attribut bereits bei der Erstellung des Widgets gesetzt werden und nicht nachträglich geändert werden.
`Qt::WA_UnderMouse`	`1`	Zeigt an, dass sich das Widget unter dem Mauszeiger befindet. Der Wert wird bei Drag&Drop-Operationen nicht korrekt aktualisiert. Es gibt auch eine Getter-Funktion, QWidget::underMouse(). Dieses Flag wird vom Qt-Kernel gesetzt oder gelöscht.
`Qt::WA_UpdatesDisabled`	`10`	Zeigt an, dass Aktualisierungen blockiert sind (einschließlich des Systemhintergrunds). Dieses Flag wird durch den Qt-Kernel gesetzt oder gelöscht. Warnung: Dieses Flag darf niemals vom Autor des Widgets gesetzt oder gelöscht werden.
`Qt::WA_WindowModified`	`41`	Zeigt an, dass das Fenster als verändert markiert ist. Auf einigen Plattformen wird dieses Flag nichts bewirken, auf anderen (einschließlich macOS und Windows) wird das Fenster ein modifiziertes Aussehen annehmen. Dieses Flag wird durch QWidget::setWindowModified() gesetzt oder gelöscht.
`Qt::WA_WindowPropagation`	`80`	Veranlasst, dass ein Toplevel-Fenster Schriftart, Palette und Gebietsschema von seinem Elternteil erbt.
`Qt::WA_MacAlwaysShowToolWindow`	`96`	Unter macOS wird das Werkzeugfenster angezeigt, auch wenn die Anwendung nicht aktiv ist. Standardmäßig sind alle Werkzeugfenster ausgeblendet, wenn die Anwendung nicht aktiv ist.
`Qt::WA_SetLocale`	`87`	Gibt an, dass das Gebietsschema im Widget berücksichtigt werden soll.
`Qt::WA_StyledBackground`	`93`	Zeigt an, dass das Widget mit einem gestylten Hintergrund gezeichnet werden soll.
`Qt::WA_ShowWithoutActivating`	`98`	Zeigt das Widget an, ohne es aktiv zu machen.
`Qt::WA_NativeWindow`	`100`	Zeigt an, dass ein eigenes Fenster für das Widget erstellt wird. Das Aktivieren dieses Flags erzwingt auch ein natives Fenster für die Vorfahren des Widgets, es sei denn, Qt::WA_DontCreateNativeAncestors ist gesetzt.
`Qt::WA_DontCreateNativeAncestors`	`101`	Zeigt an, dass die Vorfahren des Widgets nicht nativ gehalten werden, obwohl das Widget selbst nativ ist.
`Qt::WA_X11NetWmWindowTypeDesktop`	`104`	Fügt _NET_WM_WINDOW_TYPE_DESKTOP zu der X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11-Plattformen.
`Qt::WA_X11NetWmWindowTypeDock`	`105`	Fügt _NET_WM_WINDOW_TYPE_DOCK zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11-Plattformen.
`Qt::WA_X11NetWmWindowTypeToolBar`	`106`	Fügt _NET_WM_WINDOW_TYPE_TOOLBAR zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für QToolBar.
`Qt::WA_X11NetWmWindowTypeMenu`	`107`	Fügt _NET_WM_WINDOW_TYPE_MENU zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für QMenu, wenn es abgerissen wird.
`Qt::WA_X11NetWmWindowTypeUtility`	`108`	Fügt _NET_WM_WINDOW_TYPE_UTILITY zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für den Fenstertyp Qt::Tool.
`Qt::WA_X11NetWmWindowTypeSplash`	`109`	Fügt _NET_WM_WINDOW_TYPE_SPLASH zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für den Fenstertyp Qt::SplashScreen.
`Qt::WA_X11NetWmWindowTypeDialog`	`110`	Fügt _NET_WM_WINDOW_TYPE_DIALOG zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für die Fenstertypen Qt::Dialog und Qt::Sheet.
`Qt::WA_X11NetWmWindowTypeDropDownMenu`	`111`	Fügt _NET_WM_WINDOW_TYPE_DROPDOWN_MENU zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11-Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für QMenu Objekte, die zu einem QMenuBar hinzugefügt werden.
`Qt::WA_X11NetWmWindowTypePopupMenu`	`112`	Fügt _NET_WM_WINDOW_TYPE_POPUP_MENU zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für QMenu.
`Qt::WA_X11NetWmWindowTypeToolTip`	`113`	Fügt _NET_WM_WINDOW_TYPE_TOOLTIP zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für den Fenstertyp Qt::ToolTip.
`Qt::WA_X11NetWmWindowTypeNotification`	`114`	Fügt _NET_WM_WINDOW_TYPE_NOTIFICATION zur Eigenschaft _NET_WM_WINDOW_TYPE X11 window des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11-Plattformen.
`Qt::WA_X11NetWmWindowTypeCombo`	`115`	Fügt _NET_WM_WINDOW_TYPE_COMBO zur X11-Fenstereigenschaft _NET_WM_WINDOW_TYPE des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11-Plattformen. Hinweis: Qt setzt dieses Attribut automatisch für das QComboBox Pop-up.
`Qt::WA_X11NetWmWindowTypeDND`	`116`	Fügt _NET_WM_WINDOW_TYPE_DND zur Eigenschaft _NET_WM_WINDOW_TYPE X11 window des Fensters hinzu. Siehe http://standards.freedesktop.org/wm-spec/ für weitere Details. Dieses Attribut hat keinen Effekt auf nicht-X11 Plattformen. Hinweis: Qt setzt dieses Attribut automatisch auf das Feedback-Widget, das während des Ziehens verwendet wird.
`Qt::WA_AcceptTouchEvents`	`121`	Ermöglicht das Senden von Berührungsereignissen (siehe QTouchEvent) an das Widget. Muss für alle Widgets gesetzt werden, die Berührungsereignisse verarbeiten können. Wenn dieses Attribut nicht gesetzt ist, werden Ereignisse von einem Touch-Gerät als Mausereignisse gesendet.
`Qt::WA_TouchPadAcceptSingleTouchEvents`	`123`	Erlaubt, dass einzelne Touchpad-Ereignisse an das Widget gesendet werden.
`Qt::WA_X11DoNotAcceptFocus`	`126`	Fordert den Fenstermanager auf, diesem Fenster der obersten Ebene keinen Fokus zu geben. Dieses Attribut hat keinen Effekt auf Nicht-X11-Plattformen.
`Qt::WA_AlwaysStackOnTop (since Qt 5.4)`	`128`	Erzwingt, dass QOpenGLWidget und QQuickWidget als letztes gezeichnet werden, über den anderen Widgets. Wird für andere Widgets ignoriert. Das Setzen dieses Attributs bricht die Stapelreihenfolge auf, erlaubt es aber, ein halbtransparentes OpenGL-Widget zu haben, unter dem andere Widgets sichtbar sind. Es wird dringend empfohlen, update() auf dem Top-Level-Fenster des Widgets aufzurufen, nachdem dieses Attribut aktiviert oder deaktiviert wurde.
`Qt::WA_ContentsMarginsRespectsSafeArea`	`130`	Ein QWidget respektiert die Ränder des sicheren Bereichs eines Fensters, indem es die Ränder standardmäßig in die Ränder seines Inhalts einbezieht. Das bedeutet, dass QLayout den Inhaltsbereich eines Widgets für sein Layout verwendet, es sei denn, das Attribut Qt::WA_LayoutOnEntireRect ist gesetzt. Dies kann zusammen mit einem Inhaltsrand von 0 für das eigentliche Layout verwendet werden, um z.B. ein Hintergrundbild als Unterlage für die Statusleiste und andere Systembereiche auf einem iOS-Gerät zu verwenden und gleichzeitig zu ermöglichen, dass untergeordnete Widgets dieses Hintergrunds auf der Grundlage des sicheren Bereichs eingefügt werden.

enum Qt::WindowFrameSection

Diese Aufzählung wird verwendet, um Teile eines Fensterrahmens zu beschreiben. Sie wird von QGraphicsWidget::windowFrameSectionAt() zurückgegeben, um zu beschreiben, welcher Teil des Fensterrahmens sich unter der Maus befindet.

Konstante	Wert
`Qt::NoSection`	`0`
`Qt::LeftSection`	`1`
`Qt::TopLeftSection`	`2`
`Qt::TopSection`	`3`
`Qt::TopRightSection`	`4`
`Qt::RightSection`	`5`
`Qt::BottomRightSection`	`6`
`Qt::BottomSection`	`7`
`Qt::BottomLeftSection`	`8`
`Qt::TitleBarArea`	`9`

Siehe auch QGraphicsWidget::windowFrameEvent(), QGraphicsWidget::paintWindowFrame(), und QGraphicsWidget::windowFrameSectionAt().

enum Qt::WindowModality

Diese Aufzählung spezifiziert das Verhalten eines modalen Fensters. Ein modales Fenster ist eines, das die Eingabe in andere Fenster blockiert. Beachten Sie, dass Fenster, die Kinder eines modalen Fensters sind, nicht blockiert werden.

Die Werte sind:

Konstante	Wert	Beschreibung
`Qt::NonModal`	`0`	Das Fenster ist nicht modal und blockiert keine Eingaben an andere Fenster.
`Qt::WindowModal`	`1`	Das Fenster ist modal für eine einzelne Fensterhierarchie und blockiert Eingaben für sein Elternfenster, alle Großelternfenster und alle Geschwister seiner Eltern- und Großelternfenster.
`Qt::ApplicationModal`	`2`	Das Fenster ist modal für die Anwendung und blockiert Eingaben für alle Fenster.

Siehe auch QWidget::windowModality und QDialog.

enum Qt::WindowState
flags Qt::WindowStates

Dieser Enum-Typ wird verwendet, um den aktuellen Zustand eines Fensters der obersten Ebene anzugeben.

Die Zustände sind

Konstante	Wert	Beschreibung
`Qt::WindowNoState`	`0x00000000`	Das Fenster hat keinen Status (im Normalzustand).
`Qt::WindowMinimized`	`0x00000001`	Das Fenster ist minimiert (d.h. mit Symbolen versehen).
`Qt::WindowMaximized`	`0x00000002`	Das Fenster ist maximiert und von einem Rahmen umgeben.
`Qt::WindowFullScreen`	`0x00000004`	Das Fenster füllt den gesamten Bildschirm aus, ohne dass es von einem Rahmen umgeben ist.
`Qt::WindowActive`	`0x00000008`	Das Fenster ist das aktive Fenster, d.h. es hat den Tastaturfokus.

Der Typ WindowStates ist ein Typedef für QFlags<WindowState>. Er speichert eine ODER-Kombination von WindowState-Werten.

enum Qt::WindowType
flags Qt::WindowFlags

Dieser Enum-Typ wird verwendet, um verschiedene Window-System-Eigenschaften für das Widget festzulegen. Sie sind ziemlich ungewöhnlich, aber in einigen wenigen Fällen notwendig. Einige dieser Flags hängen davon ab, ob der zugrunde liegende Fenstermanager sie unterstützt.

Die wichtigsten Typen sind

Konstante	Wert	Beschreibung
`Qt::Widget`	`0x00000000`	Dies ist der Standardtyp für QWidget. Widgets dieses Typs sind Kind-Widgets, wenn sie ein Elternteil haben, und unabhängige Fenster, wenn sie kein Elternteil haben. Siehe auch Qt::Window und Qt::SubWindow.
`Qt::Window`	`0x00000001`	Zeigt an, dass das Widget ein Fenster ist, normalerweise mit einem Fenstersystemrahmen und einer Titelleiste, unabhängig davon, ob das Widget ein Elternteil hat oder nicht. Beachten Sie, dass es nicht möglich ist, dieses Flag zu deaktivieren, wenn das Widget kein Elternteil hat.
`Qt::Dialog`	`0x00000002 \| Window`	Zeigt an, dass das Widget ein Fenster ist, das als Dialog dekoriert werden sollte (d.h. typischerweise keine Maximieren- oder Minimieren-Schaltflächen in der Titelleiste). Dies ist der Standardtyp für QDialog. Wenn Sie es als modales Dialogfeld verwenden möchten, sollte es von einem anderen Fenster aus gestartet werden oder ein übergeordnetes Fenster haben und mit der Eigenschaft QWidget::windowModality verwendet werden. Wenn Sie es modal machen, verhindert das Dialogfeld, dass andere Fenster der obersten Ebene in der Anwendung Eingaben erhalten. Wir bezeichnen ein übergeordnetes Fenster, das ein Elternteil hat, als sekundäres Fenster.
`Qt::Sheet`	`0x00000004 \| Window`	Zeigt an, dass das Fenster unter macOS ein Blatt ist. Da die Verwendung eines Blattes eine Fenstermodalität impliziert, wird empfohlen, stattdessen QWidget::setWindowModality() oder QDialog::open() zu verwenden.
`Qt::Drawer`	`Sheet \| Dialog`	Zeigt an, dass das Widget unter macOS eine Schublade ist. Diese Funktion ist veraltet. Das Setzen des Flags hat keine Auswirkung.
`Qt::Popup`	`0x00000008 \| Window`	Zeigt an, dass das Widget ein Pop-up-Fenster der obersten Ebene ist, d. h. dass es modal ist, aber einen Fenstersystemrahmen hat, der für Pop-up-Menüs geeignet ist.
`Qt::Tool`	`Popup \| Dialog`	Zeigt an, dass das Widget ein Werkzeugfenster ist. Ein Werkzeugfenster ist oft ein kleines Fenster mit einer kleineren als der üblichen Titelleiste und Dekoration, das normalerweise für Sammlungen von Werkzeugschaltflächen verwendet wird. Wenn es ein übergeordnetes Fenster gibt, wird das Werkzeugfenster immer über diesem gehalten. Wenn es kein übergeordnetes Fenster gibt, können Sie auch Qt::WindowStaysOnTopHint verwenden. Wenn das Fenstersystem es unterstützt, kann ein Werkzeugfenster mit einem etwas leichteren Rahmen dekoriert werden. Es kann auch mit Qt::FramelessWindowHint kombiniert werden. Unter macOS entsprechen Werkzeugfenster der NSPanel-Klasse von Fenstern. Das bedeutet, dass das Fenster auf einer Ebene über den normalen Fenstern lebt, was es unmöglich macht, ein normales Fenster darüber zu legen. Standardmäßig werden Werkzeugfenster ausgeblendet, wenn die Anwendung inaktiv ist. Dies kann durch das Attribut Qt::WA_MacAlwaysShowToolWindow gesteuert werden.
`Qt::ToolTip`	`Popup \| Sheet`	Zeigt an, dass das Widget ein Tooltip ist. Dies wird intern verwendet, um tooltips zu implementieren.
`Qt::SplashScreen`	`ToolTip \| Dialog`	Zeigt an, dass es sich bei dem Fenster um einen Splash-Screen handelt. Dies ist der Standardtyp für QSplashScreen.
`Qt::SubWindow`	`0x00000012`	Zeigt an, dass es sich bei diesem Widget um ein Unterfenster handelt, wie z. B. ein QMdiSubWindow Widget.
`Qt::ForeignWindow`	`0x00000020 \| Window`	Zeigt an, dass dieses Fensterobjekt ein Handle ist, das ein natives Plattformfenster darstellt, das von einem anderen Prozess oder manuell mit nativem Code erstellt wurde.
`Qt::CoverWindow`	`0x00000040 \| Window`	Zeigt an, dass das Fenster ein Cover-Fenster darstellt, das angezeigt wird, wenn die Anwendung auf einigen Plattformen minimiert wird.

Es gibt auch eine Reihe von Flags, die Sie verwenden können, um das Aussehen von Fenstern der obersten Ebene anzupassen. Diese haben keine Auswirkung auf andere Fenster:

Konstante	Wert	Beschreibung
`Qt::MSWindowsFixedSizeDialogHint`	`0x00000100`	Verleiht dem Fenster einen dünnen Dialograhmen in Windows. Dieser Stil wird traditionell für Dialoge mit fester Größe verwendet.

Hinweis: Die Verwendung dieses Flags wird in Umgebungen mit mehreren Monitoren nicht empfohlen. Dies liegt daran, dass das System erzwingt, dass das Fenster seine ursprüngliche Größe beibehält, wenn es über mehrere Bildschirme hinweg bewegt wird. Dies ist insbesondere bei der Verwendung von Monitoren mit unterschiedlichen Auflösungen unerwünscht.

Konstante	Wert	Beschreibung
`Qt::MSWindowsOwnDC`	`0x00000200`	Gibt dem Fenster seinen eigenen Anzeigekontext unter Windows.
`Qt::BypassWindowManagerHint`	`0x00000400`	Dieses Flag kann verwendet werden, um dem Plattform-Plugin anzuzeigen, dass "alle" Fenstermanager-Protokolle deaktiviert werden sollen. Dieses Flag verhält sich unterschiedlich, je nachdem, auf welchem Betriebssystem die Anwendung läuft und welcher Fenstermanager ausgeführt wird. Das Flag kann verwendet werden, um ein natives Fenster ohne Konfigurationseinstellungen zu erhalten.
`Qt::X11BypassWindowManagerHint`	`BypassWindowManagerHint`	Den Fenstermanager komplett umgehen. Dies resultiert in einem randlosen Fenster, das überhaupt nicht verwaltet wird (d.h. keine Tastatureingabe, es sei denn, Sie rufen QWidget::activateWindow() manuell auf).
`Qt::FramelessWindowHint`	`0x00000800`	Erzeugt ein randloses Fenster.

Unter X11 hängt das Ergebnis des Flags vom Fenstermanager und seiner Fähigkeit ab, Motif- und/oder NETWM-Hinweise zu verstehen. Die meisten modernen Fenstermanager können damit umgehen.

Hinweis: Wenn sich der Fenstermanager auf den Rahmen verlässt, um das Fenster interaktiv zu manipulieren, kann der Benutzer das Fenster nicht mehr über das Fenstersystem verschieben oder in der Größe verändern, aber auf diesen Nebeneffekt sollte man sich nicht verlassen. Um ein Fenster mit fester Größe zu erzeugen, das nicht in der Größe verändert werden kann, setzen Sie bitte QWindow::setMinimumSize() und QWindow::setMaximumSize() auf dieselbe Größe.

Konstante	Wert	Beschreibung
`Qt::NoDropShadowWindowHint`	`0x40000000`	Deaktiviert den Schlagschatten des Fensters auf unterstützenden Plattformen.

Das Flag CustomizeWindowHint wird verwendet, um die Anpassung der Fenstersteuerung zu ermöglichen. Dieses Flag muss gesetzt sein, damit die Flags WindowTitleHint, WindowSystemMenuHint, WindowMinimizeButtonHint, WindowMaximizeButtonHint und WindowCloseButtonHint geändert werden können.

Konstante	Wert	Beschreibung
`Qt::CustomizeWindowHint`	`0x02000000`	Schaltet die standardmäßigen Fenstertitel-Hinweise aus.
`Qt::WindowTitleHint`	`0x00001000`	Verleiht dem Fenster eine Titelleiste.
`Qt::WindowSystemMenuHint`	`0x00002000`	Fügt ein Fenstersystemmenü und möglicherweise eine Schließtaste (z. B. auf dem Mac) hinzu. Wenn Sie eine Schließen-Schaltfläche ein- oder ausblenden müssen, ist es praktischer, `WindowCloseButtonHint` zu verwenden.
`Qt::WindowMinimizeButtonHint`	`0x00004000`	Fügt einen Minimieren-Button hinzu. Auf einigen Plattformen erfordert dies Qt::WindowSystemMenuHint, damit es funktioniert.
`Qt::WindowMaximizeButtonHint`	`0x00008000`	Fügt einen Maximieren-Button hinzu. Auf einigen Plattformen erfordert dies Qt::WindowSystemMenuHint, damit es funktioniert.
`Qt::WindowMinMaxButtonsHint`	`WindowMinimizeButtonHint \| WindowMaximizeButtonHint`	Fügt einen Minimieren- und Maximieren-Button hinzu. Auf einigen Plattformen erfordert dies Qt::WindowSystemMenuHint, damit es funktioniert.
`Qt::WindowCloseButtonHint`	`0x08000000`	Fügt eine Schließen-Schaltfläche hinzu. Auf einigen Plattformen erfordert dies Qt::WindowSystemMenuHint, damit es funktioniert.
`Qt::WindowContextHelpButtonHint`	`0x00010000`	Fügt eine Kontexthilfe-Schaltfläche zu Dialogen hinzu. Auf einigen Plattformen setzt dies Qt::WindowSystemMenuHint voraus, damit es funktioniert.
`Qt::MacWindowToolBarButtonHint`	`0x10000000`	Unter macOS wird eine Schaltfläche für die Symbolleiste hinzugefügt (d.h. die längliche Schaltfläche oben rechts in Fenstern, die Symbolleisten haben).
`Qt::WindowFullscreenButtonHint`	`0x80000000`	Unter macOS wird eine Schaltfläche für den Vollbildmodus hinzugefügt.
`Qt::BypassGraphicsProxyWidget`	`0x20000000`	Verhindert, dass sich das Fenster und seine Kinder automatisch in ein QGraphicsProxyWidget einbetten, wenn das übergeordnete Widget bereits eingebettet ist. Sie können dieses Flag setzen, wenn Sie möchten, dass Ihr Widget immer ein Toplevel-Widget auf dem Desktop ist, unabhängig davon, ob das übergeordnete Widget in eine Szene eingebettet ist oder nicht.
`Qt::WindowShadeButtonHint`	`0x00020000`	Fügt eine Schatten-Schaltfläche anstelle der Minimieren-Schaltfläche hinzu, wenn der zugrunde liegende Fenstermanager dies unterstützt.
`Qt::WindowStaysOnTopHint`	`0x00040000`	Informiert das Fenstersystem, dass das Fenster über allen anderen Fenstern bleiben soll. Beachten Sie, dass Sie bei einigen Fenstermanagern unter X11 auch Qt::X11BypassWindowManagerHint übergeben müssen, damit dieses Flag korrekt funktioniert.
`Qt::WindowStaysOnBottomHint`	`0x04000000`	Informiert das Fenstersystem, dass das Fenster am unteren Rand aller anderen Fenster bleiben soll.

Hinweis: Unter X11 funktioniert dieser Hint nur in Fenstermanagern, die das Atom _NET_WM_STATE_BELOW unterstützen. Wenn ein Fenster, das sich immer am unteren Rand befindet, einen Elternteil hat, wird der Elternteil auch am unteren Rand belassen. Dieser Fenster-Hinweis ist derzeit nicht für macOS implementiert.

Hinweis: Unter Windows funktioniert dies nur für rahmenlose oder bildschirmfüllende Fenster.

Konstante	Wert	Beschreibung
`Qt::WindowTransparentForInput`	`0x00080000`	Informiert das Fenstersystem, dass dieses Fenster nur zur Ausgabe (Anzeige) verwendet wird und keine Eingaben entgegennimmt. Daher sollten Eingabeereignisse durchlaufen werden, als ob es nicht vorhanden wäre.
`Qt::WindowOverridesSystemGestures`	`0x00100000`	Informiert das Fenstersystem, dass dieses Fenster einen eigenen Satz von Gesten implementiert und dass Gesten auf Systemebene, wie z. B. das Umschalten des Desktops mit drei Fingern, deaktiviert werden sollten.
`Qt::WindowDoesNotAcceptFocus`	`0x00200000`	Informiert das Fenstersystem, dass dieses Fenster nicht den Eingabefokus erhalten soll.
`Qt::MaximizeUsingFullscreenGeometryHint`	`0x00400000`	Informiert das Fenstersystem, dass es bei der Maximierung des Fensters so viel wie möglich von der verfügbaren Bildschirmgeometrie nutzen soll, einschließlich der Bereiche, die von der System-UI verdeckt werden, wie z. B. Statusleisten oder Anwendungsstartfenster. Dies kann dazu führen, dass das Fenster unter diesen System-Benutzeroberflächen platziert wird, garantiert dies aber nicht, je nachdem, ob die Plattform dies unterstützt oder nicht. Wenn das Flag aktiviert ist, ist der Benutzer dafür verantwortlich, QScreen::availableGeometry() zu berücksichtigen, so dass alle UI-Elemente in der Anwendung, die eine Benutzerinteraktion erfordern, nicht von der System-UI verdeckt werden.
`Qt::WindowType_Mask`	`0x000000ff`	Eine Maske zum Extrahieren des Fenstertypteils der WindowFlags.

Der Typ WindowFlags ist ein Typedef für QFlags<WindowType>. Er speichert eine ODER-Kombination von WindowType-Werten.

Siehe auch QWidget::windowFlags und WindowFlags Beispiel.

Funktion Dokumentation

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::KeyboardModifier modifier)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::Modifier modifier)

`[constexpr noexcept]` QKeyCombination operator|(Qt::KeyboardModifier modifier, Qt::Key key)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Modifier modifier, Qt::Key key)

Gibt ein QKeyCombination Objekt zurück, das die Kombination von key mit dem Modifikator modifier darstellt.

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::KeyboardModifiers modifiers)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::Modifiers modifiers)

`[constexpr noexcept]` QKeyCombination operator|(Qt::KeyboardModifiers modifiers, Qt::Key key)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Modifiers modifiers, Qt::Key key)

Gibt ein QKeyCombination Objekt zurück, das die Kombination von key mit den Modifikatoren modifiers darstellt.

`[since 6.2]` void beginPropertyUpdateGroup()

Markiert den Beginn einer Eigenschaftsaktualisierungsgruppe. Innerhalb dieser Gruppe führt die Änderung einer Eigenschaft weder zu einer sofortigen Aktualisierung der abhängigen Eigenschaften noch zu einer Änderungsbenachrichtigung. Diese werden stattdessen aufgeschoben, bis die Gruppe durch einen Aufruf von endPropertyUpdateGroup beendet wird.

Gruppen können verschachtelt werden. In diesem Fall endet der Aufschub erst nach Beendigung der äußersten Gruppe.

Hinweis: Änderungsbenachrichtigungen werden erst gesendet, nachdem alle von der Gruppe betroffenen Eigenschaftswerte auf ihre neuen Werte aktualisiert worden sind. Dies ermöglicht die Wiederherstellung einer Klasseninvariante, wenn mehrere Eigenschaften aktualisiert werden müssen, und verhindert, dass ein externer Beobachter einen inkonsistenten Zustand feststellt.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch Qt::endPropertyUpdateGroup und QScopedPropertyUpdateGroup.

QTextStream &Qt::bin(QTextStream &stream)

Ruft QTextStream::setIntegerBase(2) auf stream auf und gibt stream zurück.

Siehe auch oct(), dec(), hex(), und QTextStream manipulators.

QTextStream &Qt::bom(QTextStream &stream)

Schaltet das Einfügen der Byte Order Mark auf stream um, wenn QTextStream mit einer UTF-Kodierung verwendet wird.

Siehe auch QTextStream::setGenerateByteOrderMark() und QTextStream manipulators.

QTextStream &Qt::center(QTextStream &stream)

Ruft QTextStream::setFieldAlignment(QTextStream::AlignCenter) auf stream auf und gibt stream zurück.

Siehe auch left(), right(), und QTextStream manipulators.

`[constexpr noexcept, since 6.7]` template <typename Enum, Qt::if_enum<Enum> = true> Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von Enum-Typen.

Hinweis: Diese Funktion nimmt nur an der Überladungsauflösung teil, wenn Enum ein Aufzählungstyp ist.

Diese Funktion konvertiert Enum in seinen zugrundeliegenden Typ und ruft die Überladung für ganzzahlige Typen auf.

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.7 eingeführt.

`[constexpr noexcept, since 6.7]` template <typename FloatType, typename IntType, Qt::if_floating_point<FloatType> = true, Qt::if_integral<IntType> = true> auto compareThreeWay(FloatType lhs, IntType rhs)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von Fließkomma- und Integral-Typen.

Hinweis: Diese Funktion nimmt nur an der Überladungsauflösung teil, wenn FloatType ein eingebauter Fließkommatyp und IntType ein eingebauter Integraltyp ist.

Diese Funktion konvertiert rhs in FloatType und ruft die Überladung für Fließkommatypen auf.

Gibt eine Instanz von Qt::partial_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt. Wenn lhs keine Zahl (NaN) ist, wird Qt::partial_ordering::unordered zurückgegeben.

Diese Funktion wurde in Qt 6.7 eingeführt.

`[constexpr noexcept, since 6.7]` template <typename IntType, typename FloatType, Qt::if_integral<IntType> = true, Qt::if_floating_point<FloatType> = true> auto compareThreeWay(IntType lhs, FloatType rhs)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von Integral- und Fließkommatypen.

Hinweis: Diese Funktion nimmt nur dann an der Überladungsauflösung teil, wenn IntType ein eingebauter Integral-Typ und FloatType ein eingebauter Fließkomma-Typ ist.

Diese Funktion konvertiert lhs in FloatType und ruft die Überladung für Fließkommatypen auf.

Gibt eine Instanz von Qt::partial_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt. Wenn rhs keine Zahl (NaN) ist, wird Qt::partial_ordering::unordered zurückgegeben.

Diese Funktion wurde in Qt 6.7 eingeführt.

`[constexpr noexcept, since 6.7]` template <typename LeftFloat, typename RightFloat, Qt::if_floating_point<LeftFloat> = true, Qt::if_floating_point<RightFloat> = true> auto compareThreeWay(LeftFloat lhs, RightFloat rhs)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von Fließkommatypen.

Hinweis: Diese Funktion nimmt nur an der Überladungsauflösung teil, wenn sowohl LeftFloat als auch RightFloat eingebaute Fließkommatypen sind.

Gibt lhs <=> rhs zurück, sofern LeftFloat und RightFloat eingebaute Fließkommatypen sind. Im Gegensatz zu operator<=>() ist diese Funktionsvorlage auch in C++17 verfügbar. Siehe cppreference für weitere Details.

Diese Funktion kann auch in benutzerdefinierten compareThreeWay() Funktionen verwendet werden, wenn die Mitglieder einer benutzerdefinierten Klasse durch eingebaute Typen repräsentiert werden:

class MyClass {
public:
    ...
private:
    double value;
    ...
    friend Qt::partial_ordering
    compareThreeWay(const MyClass &lhs, const MyClass &rhs) noexcept
    { return Qt::compareThreeWay(lhs.value, rhs.value); }
    Q_DECLARE_PARTIALLY_ORDERED(MyClass)
};

Gibt eine Instanz von Qt::partial_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt. Wenn lhs oder rhs keine Zahl (NaN) ist, wird Qt::partial_ordering::unordered zurückgegeben.

Diese Funktion wurde in Qt 6.7 eingeführt.

`[constexpr noexcept, since 6.7]` template <typename LeftInt, typename RightInt, Qt::if_integral<LeftInt> = true, Qt::if_integral<RightInt> = true> auto compareThreeWay(LeftInt lhs, RightInt rhs)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von Integraltypen.

Hinweis: Diese Funktion nimmt nur an der Überladungsauflösung teil, wenn sowohl LeftInt als auch RightInt eingebaute Integraltypen sind.

Gibt lhs <=> rhs zurück, sofern LeftInt und RightInt eingebaute Integraltypen sind. Im Gegensatz zu operator<=>() ist diese Funktionsvorlage auch in C++17 verfügbar. Siehe cppreference für weitere Details.

Diese Funktion kann auch in benutzerdefinierten compareThreeWay() Funktionen verwendet werden, wenn die Mitglieder einer benutzerdefinierten Klasse durch eingebaute Typen repräsentiert werden:

class MyClass {
public:
    ...
private:
    int value;
    ...
    friend Qt::strong_ordering
    compareThreeWay(const MyClass &lhs, const MyClass &rhs) noexcept
    { return Qt::compareThreeWay(lhs.value, rhs.value); }
    Q_DECLARE_STRONGLY_ORDERED(MyClass)
};

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.7 eingeführt.

`[constexpr noexcept, since 6.8]` template <typename T, typename U, Qt::if_compatible_pointers<T, U> = true> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, Qt::totally_ordered_wrapper<U > rhs)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von Zeigern, die in Qt::totally_ordered_wrapper verpackt sind. Verwendet beim Vergleich eine strikte Gesamtreihenfolge über Zeiger.

Hinweis: Diese Funktion nimmt an der Überladungsauflösung teil, wenn T und U derselbe Typ sind, oder Basis- und abgeleitete Typen.

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

`[constexpr noexcept, since 6.8]` template <typename T, typename U, Qt::if_compatible_pointers<T, U> = true> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T > lhs*, U **rhs*)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich eines in Qt::totally_ordered_wrapper verpackten Zeigers mit einem normalen Zeiger. Verwendet beim Vergleich eine strenge Gesamtreihenfolge über Zeiger.

Hinweis: Diese Funktion nimmt an der Überladungsauflösung teil, wenn T und U derselbe Typ sind, oder Basis- und abgeleitete Typen.

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

`[constexpr noexcept, since 6.8]` template <typename T> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, std::nullptr_t rhs*)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich eines in Qt::totally_ordered_wrapper verpackten Zeigers mit std::nullptr_t.

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

`[constexpr noexcept, since 6.8]` template <typename T, typename U, Qt::if_compatible_pointers<T, U> = true> Qt::strong_ordering compareThreeWay(U **lhs, Qt::totally_ordered_wrapper<T > rhs)

Dies ist eine überladene Funktion.

Implementiert einen Drei-Wege-Vergleich zwischen einem normalen Zeiger und einem Zeiger, der in Qt::totally_ordered_wrapper verpackt ist. Verwendet beim Vergleich eine strenge Gesamtreihenfolge über Zeiger.

Hinweis: Diese Funktion nimmt an der Überladungsauflösung teil, wenn T und U derselbe Typ sind, oder Basis- und abgeleitete Typen.

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

`[constexpr noexcept, since 6.8]` template <typename T> Qt::strong_ordering compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T > rhs*)

Dies ist eine überladene Funktion.

Implementiert den Drei-Wege-Vergleich von std::nullptr_t mit einem in Qt::totally_ordered_wrapper verpackten Zeiger.

Gibt eine Instanz von Qt::strong_ordering zurück, die die Beziehung zwischen lhs und rhs darstellt.

Diese Funktion wurde in Qt 6.8 eingeführt.

QTextStream &Qt::dec(QTextStream &stream)

Ruft QTextStream::setIntegerBase(10) auf stream auf und gibt stream zurück.

Siehe auch bin(), oct(), hex(), und QTextStream manipulators.

`[since 6.2]` void endPropertyUpdateGroup()

Beendet eine Eigenschaftsaktualisierungsgruppe. Wenn die äußerste Gruppe beendet wurde, und die aufgeschobenen Datenflussauswertungen und Benachrichtigungen jetzt erfolgen.

Warnung: Der Aufruf von endPropertyUpdateGroup ohne einen vorhergehenden Aufruf von beginPropertyUpdateGroup führt zu undefiniertem Verhalten.

Diese Funktion wurde in Qt 6.2 eingeführt.

Siehe auch Qt::beginPropertyUpdateGroup und QScopedPropertyUpdateGroup.

QTextStream &Qt::endl(QTextStream &stream)

Schreibt '\n' in die stream und spült den Stream.

Äquivalent zu

stream << '\n' << Qt::flush;

Hinweis: Unter Windows werden alle '\n'-Zeichen als '\r\n' geschrieben, wenn das Gerät oder der String von QTextStream mit dem Flag QIODeviceBase::Text geöffnet wird.

Siehe auch flush(), reset(), und QTextStream manipulators.

QTextStream &Qt::fixed(QTextStream &stream)

Ruft QTextStream::setRealNumberNotation(QTextStream::FixedNotation) auf stream auf und gibt stream zurück.

Siehe auch scientific() und QTextStream manipulators.

QTextStream &Qt::flush(QTextStream &stream)

Ruft QTextStream::flush() auf stream auf und gibt stream zurück.

Siehe auch endl(), reset(), und QTextStream manipulators.

QTextStream &Qt::forcepoint(QTextStream &stream)

Ruft QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ForcePoint) auf stream auf und gibt stream zurück.

Siehe auch noforcepoint(), forcesign(), showbase(), und QTextStream manipulators.

QTextStream &Qt::forcesign(QTextStream &stream)

Ruft QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ForceSign) auf stream auf und gibt stream zurück.

Siehe auch noforcesign(), forcepoint(), showbase(), und QTextStream manipulators.

QTextStream &Qt::hex(QTextStream &stream)

Ruft QTextStream::setIntegerBase(16) auf stream auf und gibt stream zurück.

Hinweis: Der Hex-Modifikator kann nur für das Schreiben in Streams verwendet werden.

Siehe auch bin(), oct(), dec(), und QTextStream manipulators.

QTextStream &Qt::oct(QTextStream &stream)

Ruft QTextStream::setIntegerBase(8) auf stream auf und gibt stream zurück.

Siehe auch bin(), dec(), hex(), und QTextStream manipulators.

QTextStream &Qt::reset(QTextStream &stream)

Ruft QTextStream::reset() auf stream auf und gibt stream zurück.

Siehe auch flush() und QTextStream manipulators.

QTextStream &Qt::right(QTextStream &stream)

Ruft QTextStream::setFieldAlignment(QTextStream::AlignRight) auf stream auf und gibt stream zurück.

Siehe auch left(), center(), und QTextStream manipulators.

QTextStream &Qt::scientific(QTextStream &stream)

Ruft QTextStream::setRealNumberNotation(QTextStream::ScientificNotation) auf stream auf und gibt stream zurück.

Siehe auch fixed() und QTextStream manipulators.

QTextStream &Qt::showbase(QTextStream &stream)

Ruft QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ShowBase) auf stream auf und gibt stream zurück.

Siehe auch noshowbase(), forcesign(), forcepoint(), und QTextStream manipulators.

QTextStream &Qt::uppercasebase(QTextStream &stream)

Ruft QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::UppercaseBase) auf stream auf und gibt stream zurück.

Siehe auch lowercasebase(), uppercasedigits(), und QTextStream manipulators.

QTextStream &Qt::uppercasedigits(QTextStream &stream)

Ruft QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::UppercaseDigits) auf stream auf und gibt stream zurück.

Siehe auch lowercasedigits(), uppercasebase(), und QTextStream manipulators.

QTextStream &Qt::ws(QTextStream &stream)

Ruft skipWhiteSpace() auf stream auf und gibt stream zurück.

Siehe auch QTextStream manipulators.

© 2025 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.

Qt Namespace

Namespaces

Klassen

Typen

Funktionen

Detaillierte Beschreibung

Namespaces

namespace Qt::Literals

Klassen

Klasse partial_ordering

Klasse strong_ordering

Klasse totally_ordered_wrapper

Klasse weak_ordering

Typ-Dokumentation

enum Qt::AlignmentFlagflags Qt::Alignment

enum Qt::AnchorPoint

enum Qt::ApplicationAttribute

enum Qt::ApplicationStateflags Qt::ApplicationStates

enum Qt::ArrowType

enum Qt::AspectRatioMode

enum Qt::Axis

enum Qt::BGMode

enum Qt::BrushStyle

enum Qt::CaseSensitivity

enum Qt::CheckState

enum Qt::ChecksumType

enum Qt::ClipOperation

enum class Qt::ColorScheme

enum Qt::ConnectionType

enum Qt::ContextMenuPolicy

[since 6.8] enum class Qt::ContextMenuTrigger

enum Qt::CoordinateSystem

enum Qt::Corner

enum Qt::CursorMoveStyle

enum Qt::CursorShape

enum Qt::DateFormat

enum Qt::DayOfWeek

enum Qt::DockWidgetAreaflags Qt::DockWidgetAreas

enum Qt::DropActionflags Qt::DropActions

enum Qt::Edgeflags Qt::Edges

enum Qt::EnterKeyType

enum Qt::EventPriority

enum Qt::FillRule

enum Qt::FindChildOptionflags Qt::FindChildOptions

enum Qt::FocusPolicy

enum Qt::FocusReason

enum Qt::GestureFlagflags Qt::GestureFlags

enum Qt::GestureState

enum Qt::GestureType

enum Qt::GlobalColor

Qt::HANDLE

enum class Qt::HighDpiScaleFactorRoundingPolicy

enum Qt::HitTestAccuracy

enum Qt::ImageConversionFlagflags Qt::ImageConversionFlags

enum Qt::InputMethodHintflags Qt::InputMethodHints

enum Qt::InputMethodQueryflags Qt::InputMethodQueries

enum Qt::ItemDataRole

enum Qt::ItemFlagflags Qt::ItemFlags

enum Qt::ItemSelectionMode

enum Qt::ItemSelectionOperation

enum Qt::Key

enum Qt::KeyboardModifierflags Qt::KeyboardModifiers

enum Qt::LayoutDirection

enum Qt::MaskMode

enum Qt::MatchFlagflags Qt::MatchFlags

enum Qt::Modifierflags Qt::Modifiers

enum Qt::MouseButtonflags Qt::MouseButtons

enum Qt::MouseEventFlagflags Qt::MouseEventFlags

enum Qt::MouseEventSource

enum Qt::NativeGestureType

enum Qt::NavigationMode

enum Qt::OrientationFlaggen Qt::Orientations

enum Qt::PenCapStyle

enum Qt::PenJoinStyle

enum Qt::PenStyle

[since 6.5] enum class Qt::PermissionStatus

enum Qt::ReturnByValueConstant

enum Qt::ScreenOrientationflags Qt::ScreenOrientations

enum Qt::ScrollBarPolicy

enum Qt::ScrollPhase

enum Qt::AlignmentFlag
flags Qt::Alignment

enum Qt::ApplicationState
flags Qt::ApplicationStates

`[since 6.8]` enum class Qt::ContextMenuTrigger

enum Qt::DockWidgetArea
flags Qt::DockWidgetAreas

enum Qt::DropAction
flags Qt::DropActions

enum Qt::Edge
flags Qt::Edges

enum Qt::FindChildOption
flags Qt::FindChildOptions

enum Qt::GestureFlag
flags Qt::GestureFlags

enum Qt::ImageConversionFlag
flags Qt::ImageConversionFlags

enum Qt::InputMethodHint
flags Qt::InputMethodHints

enum Qt::InputMethodQuery
flags Qt::InputMethodQueries

enum Qt::ItemFlag
flags Qt::ItemFlags

enum Qt::KeyboardModifier
flags Qt::KeyboardModifiers

enum Qt::MatchFlag
flags Qt::MatchFlags

enum Qt::Modifier
flags Qt::Modifiers

enum Qt::MouseButton
flags Qt::MouseButtons

enum Qt::MouseEventFlag
flags Qt::MouseEventFlags

enum Qt::Orientation
Flaggen Qt::Orientations

`[since 6.5]` enum class Qt::PermissionStatus

enum Qt::ScreenOrientation
flags Qt::ScreenOrientations

enum Qt::SplitBehaviorFlags
flags Qt::SplitBehavior

enum Qt::TextInteractionFlag
flags Qt::TextInteractionFlags

`[since 6.8]` enum class TimerId

enum Qt::ToolBarArea
Flaggen Qt::ToolBarAreas

enum Qt::TouchPointState
flags Qt::TouchPointStates

enum Qt::WindowState
flags Qt::WindowStates

enum Qt::WindowType
flags Qt::WindowFlags

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::KeyboardModifier modifier)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::Modifier modifier)

`[constexpr noexcept]` QKeyCombination operator|(Qt::KeyboardModifier modifier, Qt::Key key)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Modifier modifier, Qt::Key key)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::KeyboardModifiers modifiers)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Key key, Qt::Modifiers modifiers)

`[constexpr noexcept]` QKeyCombination operator|(Qt::KeyboardModifiers modifiers, Qt::Key key)

`[constexpr noexcept]` QKeyCombination operator|(Qt::Modifiers modifiers, Qt::Key key)

`[since 6.2]` void beginPropertyUpdateGroup()

`[constexpr noexcept, since 6.7]` template <typename Enum, Qt::if_enum<Enum> = true> Qt::strong_ordering compareThreeWay(Enum lhs, Enum rhs)

`[constexpr noexcept, since 6.7]` template <typename FloatType, typename IntType, Qt::if_floating_point<FloatType> = true, Qt::if_integral<IntType> = true> auto compareThreeWay(FloatType lhs, IntType rhs)

`[constexpr noexcept, since 6.7]` template <typename IntType, typename FloatType, Qt::if_integral<IntType> = true, Qt::if_floating_point<FloatType> = true> auto compareThreeWay(IntType lhs, FloatType rhs)

`[constexpr noexcept, since 6.7]` template <typename LeftFloat, typename RightFloat, Qt::if_floating_point<LeftFloat> = true, Qt::if_floating_point<RightFloat> = true> auto compareThreeWay(LeftFloat lhs, RightFloat rhs)

`[constexpr noexcept, since 6.7]` template <typename LeftInt, typename RightInt, Qt::if_integral<LeftInt> = true, Qt::if_integral<RightInt> = true> auto compareThreeWay(LeftInt lhs, RightInt rhs)

`[constexpr noexcept, since 6.8]` template <typename T, typename U, Qt::if_compatible_pointers<T, U> = true> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, Qt::totally_ordered_wrapper<U > rhs)

`[constexpr noexcept, since 6.8]` template <typename T, typename U, Qt::if_compatible_pointers<T, U> = true> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T > lhs*, U **rhs*)

`[constexpr noexcept, since 6.8]` template <typename T> Qt::strong_ordering compareThreeWay(Qt::totally_ordered_wrapper<T > lhs, std::nullptr_t rhs*)

`[constexpr noexcept, since 6.8]` template <typename T, typename U, Qt::if_compatible_pointers<T, U> = true> Qt::strong_ordering compareThreeWay(U **lhs, Qt::totally_ordered_wrapper<T > rhs)

`[constexpr noexcept, since 6.8]` template <typename T> Qt::strong_ordering compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T > rhs*)

`[since 6.2]` void endPropertyUpdateGroup()