Qt Namespace

L'espace de noms Qt contient divers identifiants utilisés dans la bibliothèque Qt. Plus d'informations...

En-tête :	`#include <Qt>`
CMake :	`find_package(Qt6 REQUIRED COMPONENTS Core)` `target_link_libraries(mytarget PRIVATE Qt6::Core)`
qmake :	`QT += core`

Membres obsolètes

Espaces de noms

namespace Literals

Classes

`(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

Types

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 }
`(since 6.10)` enum class	ContrastPreference { NoPreference, HighContrast }
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 }

Fonctions

`(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::totally_ordered_wrapper<T > rhs)
`(since 6.8)` Qt::strong_ordering	compareThreeWay(std::nullptr_t lhs, Qt::totally_ordered_wrapper<T > rhs*)
QString	convertFromPlainText(const QString &plain, Qt::WhiteSpaceMode mode = WhiteSpacePre)
QTextStream &	dec(QTextStream &stream)
`(since 6.2)` void	endPropertyUpdateGroup()
QTextStream &	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 texte)
QTextStream &	noforcepoint(QTextStream &stream)
QTextStream &	noforcesign(QTextStream &stream)
QTextStream &	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 key, Qt::KeyboardModifier modifier)
QKeyCombination	operator\|(Qt::Key key, Qt::KeyboardModifiers modifiers)
QKeyCombination	operator\|(Qt::Key key, Qt::Modifier modifier)
QKeyCombination	operator\|(Qt::Key key, Qt::Modifiers modifiers)
QKeyCombination	operator\|(Qt::KeyboardModifier modifier, Qt::Key key)
QKeyCombination	operator\|(Qt::KeyboardModifiers modifiers, Qt::Key key)
QKeyCombination	operator\|(Qt::Modifier modificateur, Qt::Key clé)

QKeyCombination	operator\|(Qt::Modifiers modificateurs, Qt::Key key)

Description détaillée

Espaces de noms

namespace Qt::Literals

Classes

classe partial_ordering

Qt::partial_ordering représente le résultat d'une comparaison qui permet d'obtenir des résultats non ordonnés. Plus d'informations...

classe strong_ordering

Qt::strong_ordering représente une comparaison où les valeurs équivalentes sont indiscernables. En savoir plus...

classe totally_ordered_wrapper

Qt::totally_ordered_wrapper est un type enveloppant qui fournit un ordre total strict pour les types enveloppés. En savoir plus...

classe weak_ordering

Qt::weak_ordering représente une comparaison où des valeurs équivalentes peuvent encore être distinguées. En savoir plus...

Documentation des types

enum Qt::AlignmentFlag
flags Qt::Alignment

Ce type enum est utilisé pour décrire l'alignement. Il contient des drapeaux horizontaux et verticaux qui peuvent être combinés pour produire l'effet désiré.

L'énumération TextElideMode peut également être utilisée dans de nombreuses situations pour affiner l'apparence du texte aligné.

Les indicateurs horizontaux sont les suivants

Constante	Valeur	Description
`Qt::AlignLeft`	`0x0001`	Aligne sur le bord gauche.
`Qt::AlignRight`	`0x0002`	S'aligne sur le bord droit.
`Qt::AlignHCenter`	`0x0004`	Centre horizontalement le texte dans l'espace disponible.
`Qt::AlignJustify`	`0x0008`	Justifie le texte dans l'espace disponible.

Les drapeaux verticaux sont :

Constante	Valeur	Description
`Qt::AlignTop`	`0x0020`	S'aligne sur le haut.
`Qt::AlignBottom`	`0x0040`	S'aligne sur le bas.
`Qt::AlignVCenter`	`0x0080`	Se centre verticalement dans l'espace disponible.
`Qt::AlignBaseline`	`0x0100`	S'aligne sur la ligne de base.

Vous ne pouvez utiliser qu'un seul des drapeaux horizontaux à la fois. Il n'existe qu'un seul drapeau bidimensionnel :

Constante	Valeur	Description
`Qt::AlignCenter`	`AlignVCenter \| AlignHCenter`	Centre dans les deux dimensions.

Vous pouvez utiliser au maximum un indicateur horizontal et un indicateur vertical à la fois. Qt::AlignCenter est considéré comme horizontal et vertical.

Trois valeurs enum sont utiles dans les applications qui peuvent être exécutées en mode droite-gauche :

Constante	Valeur	Description
`Qt::AlignAbsolute`	`0x0010`	Si la direction de disposition du widget est Qt::RightToLeft (au lieu de Qt::LeftToRight, la valeur par défaut), Qt::AlignLeft se réfère au bord droit et Qt::AlignRight au bord gauche. C'est normalement le comportement souhaité. Si vous voulez que Qt::AlignLeft signifie toujours "gauche" et Qt::AlignRight toujours "droite", combinez le drapeau avec Qt::AlignAbsolute.
`Qt::AlignLeading`	`AlignLeft`	Synonyme de Qt::AlignLeft.
`Qt::AlignTrailing`	`AlignRight`	Synonyme de Qt::AlignRight.

Masques :

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

Les combinaisons conflictuelles de drapeaux ont des significations indéfinies.

Le type Alignment est un typedef pour QFlags<AlignmentFlag>. Il stocke une combinaison OU de valeurs AlignmentFlag.

enum Qt::AnchorPoint

Spécifie le côté d'un élément de mise en page qui peut être ancré. Elle est utilisée par QGraphicsAnchorLayout.

Constante	Valeur	Description
`Qt::AnchorLeft`	`0`	Côté gauche d'un élément de mise en page.
`Qt::AnchorHorizontalCenter`	`1`	Côté "virtuel" centré entre le côté gauche et le côté droit d'un élément de mise en page.
`Qt::AnchorRight`	`2`	Le côté droit d'un élément de mise en page.
`Qt::AnchorTop`	`3`	Le côté supérieur d'un élément de mise en page.
`Qt::AnchorVerticalCenter`	`4`	Un côté "virtuel" centré entre le haut et le bas d'un élément de la mise en page.
`Qt::AnchorBottom`	`5`	Le côté inférieur d'un élément de mise en page.

Voir également QGraphicsAnchorLayout.

enum Qt::ApplicationAttribute

Cette liste décrit les attributs qui modifient le comportement des fonctionnalités de l'application. Ils sont activés et désactivés à l'aide de QCoreApplication::setAttribute() et peuvent être testés à l'aide de QCoreApplication::testAttribute().

Constante	Valeur	Description de l'attribut
`Qt::AA_QtQuickUseDefaultSizePolicy (since Qt 6.7)`	`1`	Qt Quick Les mises en page utilisent la politique de taille intégrée de Item. Par exemple, lorsque cet attribut est défini, Button remplit la largeur disponible, mais a une hauteur fixe. Si cette valeur n'est pas définie, la page utilisera le comportement de dimensionnement par défaut de la mise en page dans laquelle elle se trouve, c'est-à-dire qu'elle utilisera sa taille implicite comme taille préférée. Ceci est expliqué en détail dans les sections Spécifier la taille préférée et Contraintes de taille. Lorsque cette propriété est définie, la politique de taille par défaut de l'élément avec la mise en page peut être remplacée en définissant explicitement Layout.fillWidth ou Layout.fillHeight.
`Qt::AA_DontShowIconsInMenus`	`2`	Les actions dotées de la propriété Icon ne seront pas affichées dans les menus, à moins qu'elles ne soient spécifiquement définies par la propriété QAction::iconVisibleInMenu. La valeur par défaut de cet attribut dépend de la plateforme. Pour remplacer le comportement par défaut, définissez l'attribut après l'instanciation de QGuiApplication. Les menus actuellement ouverts ou les menus déjà créés dans la barre de menus native de macOS peuvent ne pas tenir compte d'une modification de cet attribut. Les modifications apportées à la propriété QAction::iconVisibleInMenu seront toujours prises en compte.
`Qt::AA_DontShowShortcutsInContextMenus`	`28`	Les actions avec la propriété Shortcut ne seront pas affichées dans les menus de raccourcis à moins qu'elles ne soient spécifiquement définies par la propriété QAction::shortcutVisibleInContextMenu. Cette valeur a été ajoutée dans Qt 5.10, et est par défaut basée sur la valeur rapportée par QStyleHints::showShortcutsInContextMenus(). Pour modifier le comportement par défaut, définissez l'indice de style avant l'instanciation de QCoreApplication ou définissez cet attribut après l'instanciation de QCoreApplication.
`Qt::AA_NativeWindows`	`3`	Garantit que les widgets ont des fenêtres natives.
`Qt::AA_DontCreateNativeWidgetSiblings`	`4`	Garantit que les frères et sœurs des widgets natifs restent non natifs, à moins qu'ils ne soient spécifiquement définis par l'attribut Qt::WA_NativeWindow.
`Qt::AA_PluginApplication`	`5`	Indique que Qt est utilisé pour créer un plugin. Selon le système d'exploitation, il supprime des initialisations spécifiques qui n'ont pas nécessairement de sens dans le cas d'un plugin. Par exemple, sur macOS, il s'agit d'éviter de charger notre nib pour le menu principal et de ne pas prendre possession de la barre de menu native. En définissant cet attribut à true, l'attribut AA_DontUseNativeMenuBar sera également défini à true. Il désactive également les filtres d'événements natifs. Cet attribut doit être défini avant la construction de QGuiApplication. Cette valeur a été ajoutée dans Qt 5.7.
`Qt::AA_DontUseNativeMenuBar`	`6`	Toutes les barres de menus créées lorsque cet attribut est défini à true ne seront pas utilisées comme barre de menus native (par exemple, la barre de menus située en haut de l'écran principal sous macOS).
`Qt::AA_MacDontSwapCtrlAndMeta`	`7`	Les raccourcis clavier sur les plateformes Apple sont généralement basés sur le modificateur de clavier Commande (ou Cmd), représenté par le symbole ⌘. Par exemple, l'action "Copier" est Commande+C (⌘+C). Pour faciliter le développement inter-plateforme, Qt remappera par défaut Commande en Qt::ControlModifier, pour s'aligner sur les autres plateformes. Cela permet de créer des raccourcis clavier tels que "Ctrl+J", qui sur macOS sera alors mappé en Commande+J, comme prévu par les utilisateurs de macOS. Le modificateur Control (ou Ctrl) sur les plateformes Apple, représenté par ⌃, est mappé sur Qt::MetaModifier.

Lorsque cet attribut est vrai, Qt XML n'effectue pas le remappage, et le fait d'appuyer sur le modificateur Commande donnera Qt::MetaModifier, tandis que le fait d'appuyer sur le modificateur Contrôle donnera Qt::ControlModifier.

Notez que les séquences QKeySequence::StandardKey seront toujours basées sur le même modificateur (c'est-à-dire que QKeySequence::Copy sera Command+C quelle que soit la valeur définie), mais ce qui est produit pour QKeySequence::toString() sera différent.

Constante	Valeur	Description
`Qt::AA_Use96Dpi`	`8`	Suppose que l'écran a une résolution de 96 DPI au lieu d'utiliser la résolution fournie par le système d'exploitation. Ainsi, le rendu des polices sera cohérent en pixels par point d'un périphérique à l'autre, plutôt que de définir 1 point comme étant 1/72 pouce.
`Qt::AA_SynthesizeTouchForUnhandledMouseEvents`	`11`	Tous les événements souris qui ne sont pas acceptés par l'application seront traduits en événements tactiles.
`Qt::AA_SynthesizeMouseForUnhandledTouchEvents`	`12`	Tous les événements tactiles qui ne sont pas acceptés par l'application seront traduits en événements du bouton gauche de la souris. Cet attribut est activé par défaut.
`Qt::AA_ForceRasterWidgets`	`14`	Faire en sorte que les widgets de premier niveau utilisent des surfaces matricielles pures et ne pas prendre en charge les widgets enfants non natifs basés sur GL.
`Qt::AA_UseDesktopOpenGL`	`15`	Force l'utilisation de l'OpenGL de bureau (par exemple, opengl32.dll ou libGL.so) sur les plateformes qui utilisent le chargement dynamique de l'implémentation OpenGL. Cet attribut doit être défini avant la construction de QGuiApplication. Cette valeur a été ajoutée dans Qt 5.3.
`Qt::AA_UseOpenGLES`	`16`	Force l'utilisation d'OpenGL ES 2.0 ou plus sur les plateformes qui utilisent le chargement dynamique de l'implémentation OpenGL. Cet attribut doit être défini avant la construction de QGuiApplication. Cette valeur a été ajoutée dans Qt 5.3.
`Qt::AA_UseSoftwareOpenGL`	`17`	Force l'utilisation d'une implémentation OpenGL logicielle sur les plateformes qui utilisent le chargement dynamique de l'implémentation OpenGL. Il s'agit généralement d'une version corrigée de Mesa llvmpipe, fournissant OpenGL 2.1. La valeur peut n'avoir aucun effet si aucune implémentation OpenGL n'est disponible. Le nom par défaut de cette bibliothèque est `opengl32sw.dll` et peut être remplacé par la variable d'environnement QT_OPENGL_DLL. Voir les pages spécifiques à la plate-forme, par exemple Qt pour Windows, pour plus d'informations. Cet attribut doit être défini avant la construction de QGuiApplication. Cette valeur a été ajoutée dans Qt 5.4.
`Qt::AA_ShareOpenGLContexts`	`18`	Permet le partage des ressources entre les contextes OpenGL utilisés par des classes comme QOpenGLWidget et QQuickWidget. Cela permet de partager les ressources OpenGL, comme les textures, entre les instances QOpenGLWidget qui appartiennent à des fenêtres de niveau supérieur différentes. Cette valeur a été ajoutée dans Qt 5.4.
`Qt::AA_SetPalette`	`19`	Indique si une palette a été explicitement définie sur le site QGuiApplication. Cette valeur a été ajoutée dans Qt 5.5.
`Qt::AA_UseStyleSheetPropagationInWidgetStyles`	`22`	Par défaut, les feuilles de style Qt désactivent la propagation régulière des palettes et des polices sur QWidget. Lorsque ce drapeau est activé, les changements de police et de palette effectués à partir d'une feuille de style se propagent une seule fois, lorsque la feuille de style est définie. Voir La syntaxe des feuilles de style - Héritage pour plus de détails. Cette valeur a été ajoutée dans Qt 5.7.
`Qt::AA_DontUseNativeDialogs`	`23`	Toutes les boîtes de dialogue créées alors que cet attribut est défini à true n'utiliseront pas les boîtes de dialogue natives fournies par la plate-forme. Cette valeur a été ajoutée dans Qt 5.7.
`Qt::AA_SynthesizeMouseForUnhandledTabletEvents`	`24`	Tous les événements de la tablette qui ne sont pas acceptés par l'application seront traduits en événements de la souris. Cet attribut est activé par défaut. Cette valeur a été ajoutée dans Qt 5.7.
`Qt::AA_CompressHighFrequencyEvents`	`25`	Permet la compression de certains événements fréquents. Sur le système de fenêtrage X11, la valeur par défaut est true, ce qui signifie que QEvent::MouseMove, QEvent::TouchUpdate, et les changements de taille et de position de la fenêtre seront combinés chaque fois qu'ils se produisent plus fréquemment que l'application ne les gère, de sorte qu'ils ne s'accumulent pas et ne submergent pas l'application plus tard. Sous Windows 8 et les versions ultérieures, la valeur par défaut est également vraie, mais elle ne s'applique qu'aux événements tactiles. Les événements liés à la souris et à la fenêtre ne sont pas affectés par ce drapeau. Sur Wayland, la valeur par défaut est également vraie, mais elle ne s'applique qu'aux événements liés à la souris. Sur les autres plateformes, la valeur par défaut est false. (Vous pouvez tester l'attribut pour savoir si la compression est activée. Si votre application doit traiter tous les événements sans compression, vous pouvez désactiver cet attribut. Notez que les événements de saisie provenant de tablettes ne seront pas compressés. Voir AA_CompressTabletEvents si vous souhaitez qu'ils soient également compressés. Cette valeur a été ajoutée dans Qt 5.7.
`Qt::AA_CompressTabletEvents`	`29`	Active la compression des événements d'entrée provenant des tablettes. Notez que AA_CompressHighFrequencyEvents doit être vrai pour que la compression des événements soit activée, et que ce drapeau étend le premier aux événements des tablettes. Actuellement supporté par le système de fenêtrage X11, Windows 8 et plus. La valeur par défaut est false. Cette valeur a été ajoutée dans Qt 5.10.
`Qt::AA_DontCheckOpenGLContextThreadAffinity`	`26`	Lors de l'actualisation d'un contexte à l'aide de QOpenGLContext, ne vérifiez pas que le QObject thread affinity de l'objet QOpenGLContext est le même thread que celui qui appelle makeCurrent(). Cette valeur a été ajoutée dans Qt 5.8.
`Qt::AA_DisableShaderDiskCache`	`27`	Désactive la mise en cache des binaires des programmes de shaders sur le disque. Par défaut Qt Quick, QPainter's OpenGL backend, et toute application utilisant QOpenGLShaderProgram avec l'une de ses surcharges addCacheableShaderFromSource emploiera un cache binaire de programme sur disque dans l'emplacement de stockage du cache partagé ou par processus, sur les systèmes qui supportent glProgramBinary(). Dans le cas improbable où cela poserait problème, définissez cet attribut pour désactiver toute mise en cache des shaders sur disque.
`Qt::AA_DisableSessionManager`	`31`	Désactive l'application QSessionManager. Par défaut, Qt se connectera à un gestionnaire de session en cours d'exécution pour une application GUI sur les plates-formes prises en charge, l'utilisation d'un gestionnaire de session peut être redondante pour les services système. Cet attribut doit être défini avant la construction de QGuiApplication. Cette valeur a été ajoutée dans la version 5.14
`Qt::AA_DisableNativeVirtualKeyboard`	`9`	Lorsque cet attribut est défini, le clavier virtuel natif à l'écran n'est pas affiché automatiquement lorsqu'un widget de saisie de texte est mis en évidence sur un système dépourvu de clavier physique. Actuellement, cet attribut n'est pris en charge que sur la plate-forme Windows. Cette valeur a été ajoutée dans la version 5.15
`Qt::AA_DontUseNativeMenuWindows`	`10`	Les fenêtres contextuelles de menu (par exemple les menus contextuels, les menus déroulants et les menus non natifs de la barre de menus) créées alors que cet attribut a la valeur true ne seront pas représentées comme des fenêtres de premier niveau natives, sauf si l'implémentation l'exige. Cette valeur a été ajoutée dans Qt 6.8.

enum Qt::ApplicationState
flags Qt::ApplicationStates

Ce type d'enum est utilisé pour spécifier l'état actuel de l'application.

Les états sont les suivants

Constante	Valeur	Description de l'état de l'application
`Qt::ApplicationSuspended`	`0x00000000`	L'application est sur le point d'être suspendue. Lorsqu'elle entre dans cet état, l'application doit sauvegarder son état, cesser toute activité et se préparer à l'arrêt de l'exécution du code. Lorsqu'elle est suspendue, l'application peut être tuée à tout moment sans autre avertissement (par exemple, lorsqu'un manque de mémoire oblige le système d'exploitation à purger les applications suspendues).
`Qt::ApplicationHidden`	`0x00000001`	L'application est cachée et fonctionne en arrière-plan. C'est l'état normal des applications qui doivent effectuer des traitements en arrière-plan, comme jouer de la musique, pendant que l'utilisateur interagit avec d'autres applications. L'application doit libérer toutes les ressources graphiques lorsqu'elle entre dans cet état.
`Qt::ApplicationInactive`	`0x00000002`	L'application est visible, mais n'est pas sélectionnée pour être au premier plan. Sur les plateformes de bureau, cela signifie généralement que l'utilisateur a activé une autre application. Sur les plateformes mobiles, il est plus courant d'entrer dans cet état lorsque le système d'exploitation interrompt l'utilisateur avec, par exemple, des appels entrants ou des messages SMS. Lorsque l'utilisateur se trouve dans cet état, il peut envisager de réduire les tâches gourmandes en ressources processeur.
`Qt::ApplicationActive`	`0x00000004`	L'application est visible et sélectionnée pour être au premier plan.

Le type ApplicationStates est un typedef pour QFlags<ApplicationState>. Il stocke une combinaison OU de valeurs d'état d'application.

enum Qt::ArrowType

Constante	Valeur
`Qt::NoArrow`	`0`
`Qt::UpArrow`	`1`
`Qt::DownArrow`	`2`
`Qt::LeftArrow`	`3`
`Qt::RightArrow`	`4`

enum Qt::AspectRatioMode

Ce type d'énumération définit ce qu'il advient du rapport d'aspect lors de la mise à l'échelle d'un rectangle.

Illustration montrant trois façons différentes de mettre à l'échelle des images avec le mode Rapport d'aspect

Constante	Valeur	Description
`Qt::IgnoreAspectRatio`	`0`	La taille est mise à l'échelle librement. Le rapport hauteur/largeur n'est pas préservé.
`Qt::KeepAspectRatio`	`1`	La taille est réduite à un rectangle aussi grand que possible à l'intérieur d'un rectangle donné, en préservant le rapport hauteur/largeur.
`Qt::KeepAspectRatioByExpanding`	`2`	La taille est réduite à un rectangle aussi petit que possible à l'extérieur d'un rectangle donné, en préservant le rapport hauteur/largeur.

Voir aussi QSize::scale() et QImage::scaled().

enum Qt::Axis

Ce type d'énumération définit trois valeurs pour représenter les trois axes du système de coordonnées cartésiennes.

Constante	Valeur	Description de l'axe X
`Qt::XAxis`	`0`	L'axe X.
`Qt::YAxis`	`1`	L'axe Y.
`Qt::ZAxis`	`2`	L'axe Z.

Voir également QTransform::rotate() et QTransform::rotateRadians().

enum Qt::BGMode

Mode d'arrière-plan :

Constant	Valeur
`Qt::TransparentMode`	`0`
`Qt::OpaqueMode`	`1`

enum Qt::BrushStyle

Ce type d'énumération définit les styles de brosse pris en charge par Qt XML, c'est-à-dire le motif de remplissage des formes dessinées à l'aide de QPainter.

Styles de pinceau

Constante	Valeur	Description
`Qt::NoBrush`	`0`	Pas de motif de brosse.
`Qt::SolidPattern`	`1`	Couleur uniforme.
`Qt::Dense1Pattern`	`2`	Dessin de brosse extrêmement dense.
`Qt::Dense2Pattern`	`3`	Brosse très dense.
`Qt::Dense3Pattern`	`4`	Brosse assez dense.
`Qt::Dense4Pattern`	`5`	Brosse à moitié dense.
`Qt::Dense5Pattern`	`6`	Broussailles assez clairsemées.
`Qt::Dense6Pattern`	`7`	Brosse très clairsemée.
`Qt::Dense7Pattern`	`8`	Motif de brosse extrêmement clairsemé.
`Qt::HorPattern`	`9`	Lignes horizontales.
`Qt::VerPattern`	`10`	Lignes verticales.
`Qt::CrossPattern`	`11`	Lignes horizontales et verticales croisées.
`Qt::BDiagPattern`	`12`	Lignes diagonales vers l'arrière.
`Qt::FDiagPattern`	`13`	Lignes diagonales vers l'avant.
`Qt::DiagCrossPattern`	`14`	Croisement de lignes diagonales.
`Qt::LinearGradientPattern`	`15`	Gradient linéaire (défini à l'aide d'un constructeur dédié QBrush ).
`Qt::ConicalGradientPattern`	`17`	Gradient conique (défini à l'aide d'un constructeur dédié QBrush ).
`Qt::RadialGradientPattern`	`16`	Dégradé radial (défini à l'aide d'un constructeur dédié QBrush ).
`Qt::TexturePattern`	`24`	Motif personnalisé (voir QBrush::setTexture()).

Voir également QBrush.

enum Qt::CaseSensitivity

Constante	Valeur
`Qt::CaseInsensitive`	`0`
`Qt::CaseSensitive`	`1`

enum Qt::CheckState

Cette énumération décrit l'état des éléments vérifiables, des contrôles et des widgets.

Constante	Valeur	Description
`Qt::Unchecked`	`0`	L'élément n'est pas coché.
`Qt::PartiallyChecked`	`1`	L'élément est partiellement contrôlé. Dans les modèles hiérarchiques, les éléments peuvent être partiellement contrôlés si certains de leurs enfants, mais pas tous, sont contrôlés.
`Qt::Checked`	`2`	L'élément est coché.

Voir également QCheckBox, Qt::ItemFlags, et Qt::ItemDataRole.

enum Qt::ChecksumType

Cette énumération décrit les normes possibles utilisées par qChecksum().

Constante	Valeur	Description de la norme
`Qt::ChecksumIso3309`	`0`	Calcul de la somme de contrôle basé sur la norme ISO 3309.
`Qt::ChecksumItuV41`	`1`	Calcul de la somme de contrôle basé sur ITU-V.41.

enum Qt::ClipOperation

Constante	Valeur	Description de l'opération
`Qt::NoClip`	`0`	Cette opération désactive l'écrêtage.
`Qt::ReplaceClip`	`1`	Remplace le chemin/rect/région du clip actuel par celui fourni dans l'appel de fonction.
`Qt::IntersectClip`	`2`	Intersection du chemin/rect/région du clip actuel avec celui fourni dans l'appel de fonction.

enum class Qt::ColorScheme

Représente l'apparence du thème d'une application, défini par QGuiApplication::palette().

Constante	Valeur	Description
`Qt::ColorScheme::Unknown`	`0`	L'apparence est inconnue.
`Qt::ColorScheme::Light`	`1`	Les couleurs d'arrière-plan sont plus claires que la couleur du texte, c'est-à-dire que le thème est clair.
`Qt::ColorScheme::Dark`	`2`	Les couleurs d'arrière-plan sont plus foncées que la couleur du texte, c'est-à-dire que le thème est sombre.

enum Qt::ConnectionType

Cette énumération décrit les types de connexion qui peuvent être utilisés entre les signaux et les créneaux. En particulier, elle détermine si un signal particulier est délivré à un emplacement immédiatement ou s'il est mis en file d'attente pour être délivré ultérieurement.

Constante	Valeur	Description
`Qt::AutoConnection`	`0`	(Par défaut) Si le récepteur lives in le thread qui émet le signal, Qt::DirectConnection est utilisé. Sinon, Qt::QueuedConnection est utilisé. Le type de connexion est déterminé lors de l'émission du signal.
`Qt::DirectConnection`	`1`	Le slot est invoqué immédiatement lorsque le signal est émis. Le slot est exécuté dans le thread de signalisation.
`Qt::QueuedConnection`	`2`	Le slot est invoqué lorsque le contrôle revient à la boucle d'événements du thread du récepteur. Le slot est exécuté dans le thread du récepteur.
`Qt::BlockingQueuedConnection`	`3`	Identique à Qt::QueuedConnection, sauf que le thread de signalisation se bloque jusqu'à ce que le slot revienne. Cette connexion ne doit pas être utilisée si le récepteur vit dans le thread de signalisation, sinon l'application sera bloquée.
`Qt::UniqueConnection`	`0x80`	Il s'agit d'un drapeau qui peut être combiné avec n'importe quel type de connexion ci-dessus, à l'aide d'un OU binaire. Lorsque Qt::UniqueConnection est défini, QObject::connect() échouera si la connexion existe déjà (c'est-à-dire si le même signal est déjà connecté au même slot pour la même paire d'objets).
`Qt::SingleShotConnection`	`0x100`	Il s'agit d'un drapeau qui peut être combiné avec n'importe quel type de connexion ci-dessus, en utilisant un OU bit à bit. Lorsque Qt::SingleShotConnection est activé, le slot ne sera appelé qu'une seule fois ; la connexion sera automatiquement rompue lorsque le signal sera émis. Ce drapeau a été introduit dans Qt 6.0.

Avec les connexions en file d'attente, les paramètres doivent être de types connus du système de méta-objets de Qt, car Qt doit copier les arguments pour les stocker dans un événement en coulisses. Si vous essayez d'utiliser une connexion en file d'attente et que vous obtenez le message d'erreur :

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

Appelez qRegisterMetaType() pour enregistrer le type de données avant d'établir la connexion.

Lors de l'utilisation de signaux et de slots avec plusieurs threads, voir Signaux et slots entre threads.

Voir aussi Multi-threading dans Qt XML, QObject::connect(), qRegisterMetaType(), et Q_DECLARE_METATYPE().

enum Qt::ContextMenuPolicy

Ce type d'énumération définit les différentes politiques qu'un widget peut avoir en ce qui concerne l'affichage d'un menu contextuel.

Constante	Valeur	Description
`Qt::NoContextMenu`	`0`	le widget ne comporte pas de menu contextuel, la gestion du menu contextuel est reportée au parent du widget.
`Qt::PreventContextMenu`	`4`	le widget ne comporte pas de menu contextuel et, contrairement à `NoContextMenu`, la gestion du menu contextuel n' est pas reportée au parent du widget. Cela signifie que tous les événements liés au bouton droit de la souris sont garantis d'être transmis au widget lui-même par l'intermédiaire de QWidget::mousePressEvent() et QWidget::mouseReleaseEvent().
`Qt::DefaultContextMenu`	`1`	Le gestionnaire QWidget::contextMenuEvent() du widget est appelé.
`Qt::ActionsContextMenu`	`2`	le widget affiche son QWidget::actions() en tant que menu contextuel.
`Qt::CustomContextMenu`	`3`	le widget émet le signal QWidget::customContextMenuRequested().

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

Ce type d'énumération définit l'événement de la souris utilisé pour déclencher un événement de menu contextuel.

Constante	Valeur	Description de l'événement
`Qt::ContextMenuTrigger::Press`	`0`	menu contextuel lors de l'appui sur la souris, par défaut sur les systèmes UNIX.
`Qt::ContextMenuTrigger::Release`	`1`	menu contextuel lors du relâchement de la souris, par défaut sous Windows.

Cette liste a été introduite dans Qt 6.8.

Voir aussi QStyleHints::contextMenuTrigger.

`[since 6.10]` enum class Qt::ContrastPreference

Représente le paramètre de contraste préféré de l'utilisateur. Les styles peuvent respecter ce paramètre en augmentant le contraste des couleurs d'avant-plan et d'arrière-plan, ainsi qu'en donnant aux widgets et aux contrôles des bordures plus épaisses.

Constante	Valeur	Description
`Qt::ContrastPreference::NoPreference`	`0`	Pas de préférences spécifiques.
`Qt::ContrastPreference::HighContrast`	`1`	L'utilisateur préfère que l'application soit très contrastée.

Cette énumération a été introduite dans Qt 6.10.

enum Qt::CoordinateSystem

Cette énumération spécifie le système de coordonnées.

Constante	Valeur	Description du système de coordonnées
`Qt::DeviceCoordinates`	`0`	Les coordonnées sont relatives au coin supérieur gauche du dispositif de peinture de l'objet.
`Qt::LogicalCoordinates`	`1`	Les coordonnées sont relatives au coin supérieur gauche de l'objet.

enum Qt::Corner

Ce type d'énumération spécifie un coin dans un rectangle :

Constante	Valeur	Description
`Qt::TopLeftCorner`	`0x00000`	Le coin supérieur gauche du rectangle.
`Qt::TopRightCorner`	`0x00001`	Le coin supérieur droit du rectangle.
`Qt::BottomLeftCorner`	`0x00002`	Le coin inférieur gauche du rectangle.
`Qt::BottomRightCorner`	`0x00003`	Le coin inférieur droit du rectangle.

enum Qt::CursorMoveStyle

Cette énumération décrit le style de mouvement disponible pour les curseurs de texte. Les options sont les suivantes :

Constante	Valeur	Description
`Qt::LogicalMoveStyle`	`0`	Dans un bloc de texte de gauche à droite, diminuer la position du curseur en appuyant sur la touche fléchée gauche, augmenter la position du curseur en appuyant sur la touche fléchée droite. Si le bloc de texte va de droite à gauche, le comportement inverse s'applique.
`Qt::VisualMoveStyle`	`1`	Une pression sur la touche fléchée gauche entraînera toujours le déplacement du curseur vers la gauche, quel que soit le sens d'écriture du texte. Une pression sur la touche de déplacement vers la droite entraînera toujours un déplacement du curseur vers la droite.

enum Qt::CursorShape

Ce type d'énumération définit les différents curseurs qui peuvent être utilisés.

Le curseur flèche standard est le curseur par défaut pour les widgets dans un état normal.

Constante	Valeur	Description du curseur
`Qt::ArrowCursor`	`0`	Le curseur flèche standard.
`Qt::UpArrowCursor`	`1`	Une flèche pointant vers le haut de l'écran.
`Qt::CrossCursor`	`2`	Un curseur en croix, généralement utilisé pour aider l'utilisateur à sélectionner avec précision un point sur l'écran.
`Qt::WaitCursor`	`3`	Un sablier ou un curseur de montre, généralement affiché pendant les opérations qui empêchent l'utilisateur d'interagir avec l'application.
`Qt::IBeamCursor`	`4`	Un curseur de type caret ou ibeam, indiquant qu'un widget peut accepter et afficher du texte.
`Qt::SizeVerCursor`	`5`	Un curseur utilisé pour les éléments qui servent à redimensionner verticalement les fenêtres de premier niveau.
`Qt::SizeHorCursor`	`6`	Un curseur utilisé pour les éléments qui sont utilisés pour redimensionner horizontalement les fenêtres de niveau supérieur.
`Qt::SizeBDiagCursor`	`7`	Un curseur utilisé pour les éléments qui sont utilisés pour redimensionner diagonalement les fenêtres de niveau supérieur dans leurs coins supérieur droit et inférieur gauche.
`Qt::SizeFDiagCursor`	`8`	Un curseur utilisé pour les éléments qui sont utilisés pour redimensionner en diagonale les fenêtres de niveau supérieur dans leurs angles supérieur gauche et inférieur droit.
`Qt::SizeAllCursor`	`9`	Un curseur utilisé pour les éléments qui sont utilisés pour redimensionner les fenêtres de niveau supérieur dans n'importe quelle direction.
`Qt::BlankCursor`	`10`	Un curseur vide/invisible, généralement utilisé lorsque la forme du curseur doit être cachée.
`Qt::SplitVCursor`	`11`	Un curseur utilisé pour les séparateurs verticaux, indiquant qu'une poignée peut être glissée horizontalement pour ajuster l'utilisation de l'espace disponible.
`Qt::SplitHCursor`	`12`	Curseur utilisé pour les séparateurs horizontaux, indiquant qu'une poignée peut être glissée verticalement pour ajuster l'utilisation de l'espace disponible.
`Qt::PointingHandCursor`	`13`	Un curseur en forme de main pointée, généralement utilisé pour les éléments cliquables tels que les liens hypertextes.
`Qt::ForbiddenCursor`	`14`	Un curseur représentant un cercle barré, généralement utilisé lors des opérations de glisser-déposer pour indiquer qu'un contenu glissé ne peut pas être déposé sur des widgets particuliers ou à l'intérieur de certaines régions.
`Qt::OpenHandCursor`	`17`	Un curseur représentant une main ouverte, généralement utilisé pour indiquer que la zone sous le curseur est la partie visible d'un canevas que l'utilisateur peut cliquer et faire glisser pour le faire défiler.
`Qt::ClosedHandCursor`	`18`	Un curseur représentant une main fermée, généralement utilisé pour indiquer qu'une opération de glissement est en cours et qu'elle implique un défilement.
`Qt::WhatsThisCursor`	`15`	Une flèche avec un point d'interrogation, généralement utilisée pour indiquer la présence de l'aide What's This ? pour un widget.
`Qt::BusyCursor`	`16`	Un sablier ou un curseur de montre, généralement affiché lors d'opérations permettant à l'utilisateur d'interagir avec l'application pendant qu'elles sont exécutées en arrière-plan.
`Qt::DragMoveCursor`	`20`	Curseur généralement utilisé pour faire glisser un élément.
`Qt::DragCopyCursor`	`19`	Curseur généralement utilisé lorsqu'on fait glisser un élément pour le copier.
`Qt::DragLinkCursor`	`21`	Curseur généralement utilisé lorsqu'on fait glisser un élément pour établir un lien avec lui.
`Qt::BitmapCursor`	`24`

enum Qt::DateFormat

Constante	Valeur	Description du format par défaut de Qt
`Qt::TextDate`	`0`	Le format Qt par défaut, qui comprend le nom du jour et du mois, le numéro du jour dans le mois et l'année complète. Les noms du jour et du mois seront des noms courts en anglais (locale C). Pour une date, on utilise le format `ddd MMM d yyyy`, pour une heure `HH:mm:ss` et on les combine comme `ddd MMM d HH:mm:ss yyyy` pour une date-heure, avec un suffixe optionnel de décalage de zone, le cas échéant. Lors de la lecture d'une chaîne, une partie fractionnaire est également reconnue sur les secondes d'une partie temporelle, comme `HH:mm:ss.zzz`, et quelques variantes mineures du format peuvent être reconnues, pour des raisons de compatibilité avec les versions antérieures de Qt XML et avec les changements de format prévus pour l'avenir. En particulier, le suffixe de décalage de zone utilise actuellement `GMT[±tzoff]` avec `tzoff` au format `HH[[:]mm]` (heure à deux chiffres et minutes à deux chiffres facultatives, avec séparateur à deux points facultatif) ; il utilisera `UTC` à la place de `GMT` dans une prochaine version de Qt, de sorte que le format `UTC` prévu soit reconnu.
`Qt::ISODateWithMs`	`9`	FormatISO 8601 étendu : utilise `yyyy-MM-dd` pour les dates, `HH:mm:ss.zzz` pour les heures ou `yyyy-MM-ddTHH:mm:ss.zzz` (par exemple 2017-07-24T15:46:29.739) pour les dates et heures combinées, avec éventuellement un suffixe de fuseau horaire (Z pour UTC, sinon un décalage de ±HH:mm) le cas échéant. Lors de l'analyse, un espace unique, `' '`, peut être utilisé à la place du séparateur `'T'` entre la date et l'heure ; aucun autre caractère d'espacement n'est autorisé. Ce format accepte également les formats `HH:mm` et `HH` pour la partie temporelle, l'un ou l'autre pouvant inclure une partie fractionnaire, `HH:mm.zzz` ou `HH.zzz`, appliquée au dernier champ présent (heure ou minute).
`Qt::ISODate`	`1`	Format étenduISO 8601, comme pour `ISODateWithMs`, mais en omettant la partie millisecondes (`.zzz`) lors de la conversion en chaîne de caractères. Il n'y a pas de différence lors de la lecture d'une chaîne : si une partie fractionnaire est présente dans le dernier champ de l'heure, l'un ou l'autre format l'acceptera.
`Qt::RFC2822Date`	`8`	FormatRFC 2822, RFC 850 et RFC 1036: lors de la conversion des dates en chaînes de caractères, le format `dd MMM yyyy` est utilisé, tandis que pour les heures, le format est `HH:mm:ss`. Pour les dates et heures combinées, elles sont combinées sous le format `dd MMM yyyy HH:mm:ss ±tzoff` (en omettant le jour de la semaine facultatif du premier format reconnu). Lors de la lecture d'une chaîne, `[ddd,] dd MMM yyyy [HH:mm[:ss]][ ±tzoff]` ou `ddd MMM dd[ HH:mm:ss] yyyy[ ±tzoff]` sera reconnu pour les dates et heures combinées, où `tzoff` est un décalage de fuseau horaire au format `HHmm`. Un espacement arbitraire peut apparaître avant ou après le texte et tout espace non vide peut remplacer les espaces dans ce format. Pour les dates et les heures séparément, les mêmes formats sont appliqués et les parties non désirées sont ignorées. En particulier, il convient de noter qu'une heure n'est pas reconnue si elle n'est pas accompagnée d'une date.

Note : Pour les formats ISODate, chaque y, M et d représente un seul chiffre de l'année, du mois et du jour utilisés pour spécifier la date. Chaque H, m, et s représente un chiffre de l'heure (jusqu'à 24), de la minute et de la seconde utilisées pour spécifier l'heure. Une heure de 24, avec zéro pour tous les autres champs temporels, est considérée comme le début du jour suivant. Un .zzz représente un suffixe fractionnaire du champ précédent, qui peut être séparé de ce champ soit par une virgule ',', soit par le point '.' indiqué. La précision au-delà de la milliseconde est acceptée mais écartée, l'arrondi se faisant à la milliseconde représentable la plus proche. La présence d'un caractère littéral T est utilisée pour séparer la date et l'heure lorsqu'elles sont toutes deux spécifiées. Pour les formats TextDate et RFC2822Date, ddd représente les trois premières lettres du nom du jour de la semaine et MMM représente les trois premières lettres du nom du mois. Les noms des jours et des mois sont toujours en anglais (paramètres régionaux C), quels que soient les préférences de l'utilisateur ou les paramètres du système. Les autres caractères du format ont la même signification que pour le format ISODate, sauf que 24 n'est pas accepté comme heure. Les parties d'un format placées entre crochets [...] sont facultatives ; les crochets ne font pas partie du format. Le caractère plus ou moins '±' représente ici l'un ou l'autre signe, '-' pour le moins ou '+' pour le plus.

Note : Les décalages de zone sont mesurés en positif à l'est de Greenwich, en négatif à l'ouest, comme il est d'usage pour les notations de décalage basées sur l'UTC (ce qui entre en conflit avec certains noms de zones basés sur l'UTC, tels que Etc/GMT+3, qui utilisent la convention inverse).

Voir aussi QDate::toString(), QTime::toString(), QDateTime::toString(), QDate::fromString(), QTime::fromString(), et QDateTime::fromString().

enum Qt::DayOfWeek

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

enum Qt::DockWidgetArea
drapeaux Qt::DockWidgetAreas

Représente les zones sur lesquelles un QDockWidget peut être branché.

Remarque : un widget d'ancrage flottant avec des onglets peut être ancré n'importe où.

Constante	Valeur	Description
`Qt::LeftDockWidgetArea`	`0x1`	La zone d'ancrage gauche d'un QMainWindow.
`Qt::RightDockWidgetArea`	`0x2`	La zone d'ancrage droite d'une page QMainWindow.
`Qt::TopDockWidgetArea`	`0x4`	La zone d'ancrage supérieure d'un QMainWindow.
`Qt::BottomDockWidgetArea`	`0x8`	La zone d'ancrage inférieure d'une page QMainWindow.
`Qt::AllDockWidgetAreas`	`DockWidgetArea_Mask`	Toutes les zones de widgets de la station d'accueil (par défaut).
`Qt::NoDockWidgetArea`	`0`	Aucune zone de widget de dock.

Le type DockWidgetAreas est un typedef pour QFlags<DockWidgetArea>. Il stocke une combinaison OU de valeurs DockWidgetArea.

Voir également QDockWidget::setAllowedAreas et QDockWidget::isAreaAllowed.

enum Qt::DropAction
flags Qt::DropActions

Constante	Valeur	Description de l'action
`Qt::CopyAction`	`0x1`	Copie les données vers la cible.
`Qt::MoveAction`	`0x2`	Déplace les données de la source vers la cible.
`Qt::LinkAction`	`0x4`	Créer un lien entre la source et la cible.
`Qt::ActionMask`	`0xff`
`Qt::IgnoreAction`	`0x0`	Ignorer l'action (ne rien faire avec les données).
`Qt::TargetMoveAction`	`0x8002`	Sous Windows, cette valeur est utilisée lorsque la propriété des données D&D doit être reprise par l'application cible, c'est-à-dire que l'application source ne doit pas supprimer les données. Sous X11, cette valeur est utilisée pour effectuer un déplacement. TargetMoveAction n'est pas utilisé sur Mac.

Le type DropActions est un typedef pour QFlags<DropAction>. Il stocke une combinaison OR de valeurs DropAction.

enum Qt::Edge
flags Qt::Edges

Ce type enum spécifie une arête dans un rectangle :

Constante	Constante Valeur	Description
`Qt::TopEdge`	`0x00001`	Le bord supérieur du rectangle.
`Qt::LeftEdge`	`0x00002`	Le bord gauche du rectangle.
`Qt::RightEdge`	`0x00004`	Le bord droit du rectangle.
`Qt::BottomEdge`	`0x00008`	Le bord inférieur du rectangle.

Le type Edges est un typedef pour QFlags<Edge>. Il stocke une combinaison OU de valeurs de bord.

enum Qt::EnterKeyType

Cette valeur peut être utilisée pour modifier l'apparence de la touche Retour sur un clavier à l'écran.

Remarque : toutes ces valeurs ne sont pas prises en charge sur toutes les plates-formes. Pour les valeurs non supportées, la touche par défaut sera utilisée à la place.

Constante	Valeur	Description
`Qt::EnterKeyDefault`	`0`	La touche Entrée par défaut. Il peut s'agir soit d'un bouton fermant le clavier, soit d'un bouton Retour provoquant l'insertion d'une nouvelle ligne dans le cas d'un champ de saisie multi-lignes.
`Qt::EnterKeyReturn`	`1`	Affiche un bouton Retour qui insère une nouvelle ligne. Le clavier ne se ferme pas lorsque l'on appuie sur ce bouton.
`Qt::EnterKeyDone`	`2`	Afficher un bouton "Terminé". Le clavier se ferme lorsque l'on appuie sur ce bouton.
`Qt::EnterKeyGo`	`3`	Afficher un bouton "Go". Généralement utilisé dans une barre d'adresse lors de la saisie d'un URL ; le clavier se ferme lorsque l'on appuie sur ce bouton.
`Qt::EnterKeySend`	`4`	Afficher un bouton "Envoyer". Le clavier se ferme lorsque l'on appuie sur ce bouton.
`Qt::EnterKeySearch`	`5`	Afficher un bouton "Rechercher". Le clavier se ferme lorsque l'on appuie sur ce bouton.
`Qt::EnterKeyNext`	`6`	Afficher un bouton "Suivant". Généralement utilisé dans un formulaire pour permettre la navigation vers le champ de saisie suivant ; le clavier ne se fermera pas lorsque ce bouton sera enfoncé.
`Qt::EnterKeyPrevious`	`7`	Afficher un bouton "Précédent". Le clavier ne se ferme pas lorsque l'on appuie sur ce bouton.

enum Qt::EventPriority

Cette énumération peut être utilisée pour spécifier les priorités des événements.

Constante	Valeur	Description
`Qt::HighEventPriority`	`1`	Les événements ayant cette priorité sont envoyés avant les événements ayant la priorité NormalEventPriority ou LowEventPriority.
`Qt::NormalEventPriority`	`0`	Les événements ayant cette priorité sont envoyés après les événements ayant une priorité élevée, mais avant les événements ayant une priorité faible.
`Qt::LowEventPriority`	`-1`	Les événements ayant cette priorité sont envoyés après les événements ayant une priorité élevée ou une priorité normale.

Notez que ces valeurs sont fournies à titre purement pratique, car les priorités des événements peuvent être comprises entre INT_MAX et INT_MIN, inclusivement. Par exemple, vous pouvez définir des priorités personnalisées comme étant relatives les unes par rapport aux autres :

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

Voir aussi QCoreApplication::postEvent().

enum Qt::FillRule

Spécifie la méthode à utiliser pour remplir les chemins et les polygones.

Constante	Valeur	Description
`Qt::OddEvenFill`	`0`	Spécifie que la région est remplie à l'aide de la règle de remplissage pair-impair. Avec cette règle, nous déterminons si un point se trouve à l'intérieur de la forme en utilisant la méthode suivante. Tracez une ligne horizontale entre le point et un endroit situé à l'extérieur de la forme et comptez le nombre d'intersections. Si le nombre d'intersections est impair, le point est à l'intérieur de la forme. Ce mode est le mode par défaut.
`Qt::WindingFill`	`1`	Spécifie que la région est remplie en utilisant la règle d'enroulement non nul. Avec cette règle, nous déterminons si un point est à l'intérieur de la forme en utilisant la méthode suivante. Tracez une ligne horizontale depuis le point jusqu'à un endroit situé à l'extérieur de la forme. Déterminez si la direction de la ligne à chaque point d'intersection est vers le haut ou vers le bas. Le nombre d'enroulements est déterminé en additionnant la direction de chaque intersection. Si ce nombre est différent de zéro, le point se trouve à l'intérieur de la forme. Ce mode de remplissage peut également, dans la plupart des cas, être considéré comme l'intersection de formes fermées.

enum Qt::FindChildOption
flags Qt::FindChildOptions

Constante	Valeur	Description
`Qt::FindDirectChildrenOnly`	`0x0`	Ne regarde que les enfants directs de l'objet.
`Qt::FindChildrenRecursively`	`0x1`	Examine tous les enfants de l'objet (recherche récursive).

Le type FindChildOptions est un typedef pour QFlags<FindChildOption>. Il stocke une combinaison OU de valeurs FindChildOption.

enum Qt::FocusPolicy

Ce type d'énumération définit les différentes politiques qu'un widget peut avoir en ce qui concerne l'acquisition du focus clavier.

Constante	Valeur	Description
`Qt::TabFocus`	`0x1`	le widget accepte le focus par tabulation.
`Qt::ClickFocus`	`0x2`	le widget accepte le focus en cliquant.
`Qt::StrongFocus`	`TabFocus \| ClickFocus \| 0x8`	le widget accepte le focus à la fois par tabulation et par clic. Sur macOS, cette valeur indiquera également que le widget accepte le focus par tabulation lorsqu'il est en mode "focus texte/liste".
`Qt::WheelFocus`	`StrongFocus \| 0x4`	comme Qt::StrongFocus plus le widget accepte le focus en utilisant la molette de la souris.
`Qt::NoFocus`	`0`	le widget n'accepte pas le focus.

enum Qt::FocusReason

Cette énumération spécifie la raison pour laquelle le focus a changé. Elle sera transmise par l'intermédiaire de QWidget::setFocus et pourra être récupérée dans QFocusEvent envoyé au widget lors du changement de focus.

Constante	Valeur	Description
`Qt::MouseFocusReason`	`0`	Une action de la souris s'est produite.
`Qt::TabFocusReason`	`1`	La touche Tab a été enfoncée.
`Qt::BacktabFocusReason`	`2`	Un retour de tabulation s'est produit. L'entrée pour cela peut inclure les touches Shift ou Control ; par exemple Shift+Tab.
`Qt::ActiveWindowFocusReason`	`3`	Le système de fenêtres a rendu cette fenêtre active ou inactive.
`Qt::PopupFocusReason`	`4`	L'application a ouvert/fermé une fenêtre contextuelle qui a pris/retiré le focus du clavier.
`Qt::ShortcutFocusReason`	`5`	L'utilisateur a tapé le raccourci d'un copain de l'étiquette.
`Qt::MenuBarFocusReason`	`6`	La barre de menu a pris le focus.
`Qt::OtherFocusReason`	`7`	Autre raison, généralement propre à l'application.

Voir aussi Focus clavier dans les widgets.

enum Qt::GestureFlag
flags Qt::GestureFlags

Ce type d'enum décrit les drapeaux supplémentaires qui peuvent être utilisés lors de la souscription à un geste.

Constante	Valeur	Description
`Qt::DontStartGestureOnChildren`	`0x01`	Par défaut, les gestes peuvent commencer sur le widget ou sur n'importe lequel de ses enfants. Utilisez ce drapeau pour désactiver cette possibilité et permettre à un geste de démarrer uniquement sur le widget.
`Qt::ReceivePartialGestures`	`0x02`	Permet à tout événement de geste ignoré d'être propagé aux widgets parents qui ont spécifié cet indice. Par défaut, seuls les gestes qui se trouvent dans l'état Qt::GestureStarted sont propagés et le widget reçoit toujours la séquence complète de gestes en commençant par un geste dans l'état Qt::GestureStarted et en terminant par un geste dans l'état Qt::GestureFinished ou Qt::GestureCanceled.
`Qt::IgnoredGesturesPropagateToParent (since Qt 4.7)`	`0x04`	Permet un réglage fin de la propagation des événements gestuels. En activant ce drapeau lors de l'envoi d'un geste à grabbing, tous les gestes partiels ignorés se propageront à leurs éléments parents.

Le type GestureFlags est un typedef pour QFlags<GestureFlag>. Il stocke une combinaison OU de valeurs GestureFlag.

Voir également QWidget::grabGesture() et QGraphicsObject::grabGesture().

enum Qt::GestureState

Ce type d'énumération décrit l'état d'un geste.

Constante	Valeur	Description de l'état
`Qt::NoGesture`	`0`	Aucun geste n'a été détecté.
`Qt::GestureStarted`	`1`	Un geste continu a commencé.
`Qt::GestureUpdated`	`2`	Un geste se poursuit.
`Qt::GestureFinished`	`3`	Un geste est terminé.
`Qt::GestureCanceled`	`4`	Un geste a été annulé.

Voir aussi QGesture.

enum Qt::GestureType

Ce type d'énumération décrit les gestes standard.

Constante	Valeur	Description du geste
`Qt::TapGesture`	`1`	Geste de tapotement.
`Qt::TapAndHoldGesture`	`2`	Geste de tapotement et de maintien (tapotement long).
`Qt::PanGesture`	`3`	Geste de panoramique.
`Qt::PinchGesture`	`4`	Geste de pincement.
`Qt::SwipeGesture`	`5`	Geste de balayage.
`Qt::CustomGesture`	`0x0100`	Un indicateur qui peut être utilisé pour tester si le geste est un ID de geste défini par l'utilisateur.

Les gestes définis par l'utilisateur sont enregistrés avec la fonction QGestureRecognizer::registerRecognizer() qui génère un ID de geste personnalisé avec l'indicateur Qt::CustomGesture.

Voir aussi QGesture, QWidget::grabGesture(), et QGraphicsObject::grabGesture().

enum Qt::GlobalColor

Objets prédéfinis de Qt QColor:

Constante	Valeur	Description de l'objet
`Qt::white`	`3`	Blanc (#ffffff)
`Qt::black`	`2`	Noir (#000000)
`Qt::red`	`7`	Rouge (#ff0000)
`Qt::darkRed`	`13`	Rouge foncé (#800000)
`Qt::green`	`8`	Vert (#00ff00)
`Qt::darkGreen`	`14`	Vert foncé (#008000)
`Qt::blue`	`9`	Bleu (#0000ff)
`Qt::darkBlue`	`15`	Bleu foncé (#000080)
`Qt::cyan`	`10`	Cyan (#00ffff)
`Qt::darkCyan`	`16`	Cyan foncé (#008080)
`Qt::magenta`	`11`	Magenta (#ff00ff)
`Qt::darkMagenta`	`17`	Magenta foncé (#800080)
`Qt::yellow`	`12`	Jaune (#ffff00)
`Qt::darkYellow`	`18`	Jaune foncé (#808000)
`Qt::gray`	`5`	Gris (#a0a0a4)
`Qt::darkGray`	`4`	Gris foncé (#808080)
`Qt::lightGray`	`6`	Gris clair (#c0c0c0)
`Qt::transparent`	`19`	une valeur noire transparente (c'est-à-dire QColor(0, 0, 0, 0))
`Qt::color0`	`0`	Valeur de 0 pixel (pour les images bitmap)
`Qt::color1`	`1`	Valeur de 1 pixel (pour les bitmaps)

Voir aussi QColor.

Qt::HANDLE

Un type de poignée pour les objets du système, défini comme void * sur toutes les plates-formes.

enum class Qt::HighDpiScaleFactorRoundingPolicy

Cette énumération décrit les politiques possibles d'arrondissement du facteur d'échelle High-DPI, qui décident de la manière dont les facteurs d'échelle non entiers (tels que Windows 150%) sont traités.

La politique active est définie en appelant QGuiApplication::setHighDpiScaleFactorRoundingPolicy() avant la création de l'objet d'application.

Constante	Valeur	Description
`Qt::HighDpiScaleFactorRoundingPolicy::Round`	`1`	Arrondir vers le haut à partir de 0,5.
`Qt::HighDpiScaleFactorRoundingPolicy::Ceil`	`2`	Toujours arrondir à l'unité supérieure.
`Qt::HighDpiScaleFactorRoundingPolicy::Floor`	`3`	Toujours arrondir à la valeur inférieure.
`Qt::HighDpiScaleFactorRoundingPolicy::RoundPreferFloor`	`4`	Arrondir vers le haut à partir de 0,75.
`Qt::HighDpiScaleFactorRoundingPolicy::PassThrough`	`5`	Ne pas arrondir.

Voir également QGuiApplication::setHighDpiScaleFactorRoundingPolicy().

enum Qt::HitTestAccuracy

Cette liste contient les types de précision qui peuvent être utilisés par la classe QTextDocument pour tester les clics de souris sur des documents textuels.

Constante	Valeur	Description
`Qt::ExactHit`	`0`	Le point où la saisie a eu lieu doit coïncider exactement avec les parties du document sensibles à la saisie.
`Qt::FuzzyHit`	`1`	Le point de saisie peut se situer à proximité des parties du document sensibles à la saisie.

enum Qt::ImageConversionFlag
flags Qt::ImageConversionFlags

Les options marquées "(default)" sont définies si aucune autre valeur de la liste n'est incluse (puisque les valeurs par défaut sont zéro) :

Préférence Couleur/Mono (ignorée pour QBitmap) :

Constante	Valeur	Description
`Qt::AutoColor`	`0x00000000`	(par défaut) - Si l'image a depth 1 et ne contient que des pixels noirs et blancs, la pixmap devient monochrome.
`Qt::ColorOnly`	`0x00000003`	La pixmap est dithered/convertie en native display depth.
`Qt::MonoOnly`	`0x00000002`	La pixmap devient monochrome. Si nécessaire, elle est lissée à l'aide de l'algorithme de lissage choisi.

Préférence pour le mode de tramage :

Constante	Valeur	Description
`Qt::DiffuseDither`	`0x00000000`	(par défaut) - Un tramage de haute qualité utilisant la diffusion des erreurs.
`Qt::OrderedDither`	`0x00000010`	Un tramage plus rapide et ordonné.
`Qt::ThresholdDither`	`0x00000020`	Pas de tramage ; la couleur la plus proche est utilisée.

Mode de tramage préféré pour les masques alpha 1 bit :

Constante	Valeur	Description
`Qt::ThresholdAlphaDither`	`0x00000000`	(par défaut) - Pas de tramage.
`Qt::OrderedAlphaDither`	`0x00000004`	Un tramage plus rapide et ordonné.
`Qt::DiffuseAlphaDither`	`0x00000008`	Un tramage de haute qualité utilisant la diffusion des erreurs.

Préférence pour la correspondance des couleurs par rapport au tramage :

Constante	Valeur	Description
`Qt::PreferDither`	`0x00000040`	Toujours effectuer un tramage des images lors de la conversion vers des espaces colorimétriques plus petits.
`Qt::AvoidDither`	`0x00000080`	N'effectuer le tramage vers des formats indexés que si l'image source utilise plus de couleurs différentes que la taille de la table des couleurs du format de destination.
`Qt::AutoDither`	`0x00000000`	(par défaut) - N'effectuer le tramage que lors de la conversion vers des formats indexés de 1 ou 8 bits.
`Qt::NoOpaqueDetection`	`0x00000100`	Ne pas vérifier si l'image contient des pixels non opaques. Utilisez cette option si vous savez que l'image est semi-transparente et que vous voulez éviter de vérifier les pixels de l'image jusqu'à ce qu'un pixel non-opaque soit trouvé, ou si vous voulez que la pixmap conserve un canal alpha pour une autre raison. Si l'image n'a pas de canal alpha, ce drapeau n'a aucun effet.
`Qt::NoFormatConversion`	`0x00000200`	N'effectue aucune conversion de format sur l'image. Cela peut être utile pour convertir une image QImage en QPixmap pour une opération de rendu unique, par exemple. Notez qu'une image QPixmap qui n'est pas dans le format préféré sera beaucoup plus lente en tant que périphérique de peinture.

Le type ImageConversionFlags est un typedef pour QFlags<ImageConversionFlag>. Il stocke une combinaison OU de valeurs ImageConversionFlag.

enum Qt::InputMethodHint
flags Qt::InputMethodHints

Constante	Valeur	Description
`Qt::ImhNone`	`0x0`	Aucune indication.

Drapeaux qui modifient le comportement :

Constante	Valeur	Description
`Qt::ImhHiddenText`	`0x1`	La méthode de saisie ne doit pas afficher les caractères pendant la frappe. Ce paramètre est automatiquement défini lorsque QLineEdit::echoMode est remplacé par `Password`. Notez que la définition de `ImhHiddenText` ne modifie pas le mode d'écho.
`Qt::ImhSensitiveData`	`0x2`	Le texte tapé ne doit pas être stocké par la méthode de saisie active dans une mémoire persistante telle que le dictionnaire prédictif de l'utilisateur.
`Qt::ImhNoAutoUppercase`	`0x4`	La méthode de saisie ne doit pas essayer de passer automatiquement en majuscules à la fin d'une phrase.
`Qt::ImhPreferNumbers`	`0x8`	Les chiffres sont préférables (mais pas obligatoires).
`Qt::ImhPreferUppercase`	`0x10`	Les lettres majuscules sont préférées (mais pas obligatoires).
`Qt::ImhPreferLowercase`	`0x20`	Les lettres minuscules sont préférables (mais pas obligatoires).
`Qt::ImhNoPredictiveText`	`0x40`	N'utilisez pas de texte prédictif (c'est-à-dire de recherche dans le dictionnaire) lorsque vous tapez.
`Qt::ImhDate`	`0x80`	L'éditeur de texte fonctionne comme un champ de date.
`Qt::ImhTime`	`0x100`	L'éditeur de texte fonctionne comme un champ d'heure.
`Qt::ImhPreferLatin`	`0x200`	Les caractères latins sont préférés (mais pas obligatoires).
`Qt::ImhMultiLine`	`0x400`	Plusieurs lignes peuvent être saisies dans le champ de texte.
`Qt::ImhNoEditMenu`	`0x800`	Ne pas utiliser le menu d'édition intégré. Ce drapeau a été introduit dans Qt 5.11.
`Qt::ImhNoTextHandles`	`0x1000`	Ne pas utiliser le curseur de texte intégré et les poignées de sélection. Ce drapeau a été introduit dans Qt 5.11.

Drapeaux qui limitent la saisie (drapeaux exclusifs) :

Constante	Valeur	Description de l'indicateur
`Qt::ImhDigitsOnly`	`0x10000`	Seuls les chiffres sont autorisés.
`Qt::ImhFormattedNumbersOnly`	`0x20000`	Seule la saisie de chiffres est autorisée. Cela inclut le point décimal et le signe moins.
`Qt::ImhUppercaseOnly`	`0x40000`	Seules les lettres majuscules sont autorisées.
`Qt::ImhLowercaseOnly`	`0x80000`	Seules les lettres minuscules peuvent être saisies.
`Qt::ImhDialableCharactersOnly`	`0x100000`	Seuls les caractères adaptés à la composition d'un numéro de téléphone sont autorisés.
`Qt::ImhEmailCharactersOnly`	`0x200000`	Seuls les caractères adaptés aux adresses électroniques sont autorisés.
`Qt::ImhUrlCharactersOnly`	`0x400000`	Seuls les caractères adaptés aux URL sont autorisés.
`Qt::ImhLatinOnly`	`0x800000`	Seule la saisie de caractères latins est autorisée.

Masques :

Constante	Valeur	Description du masque
`Qt::ImhExclusiveInputMask`	`0xffff0000`	Ce masque donne une valeur non nulle si l'un des indicateurs d'exclusivité est utilisé.

Remarque : si plusieurs indicateurs d'exclusivité sont combinés par OU, le jeu de caractères résultant sera constitué de l'union des jeux spécifiés. Par exemple, en spécifiant ImhNumbersOnly et ImhUppercaseOnly, on obtient un jeu composé de chiffres et de lettres majuscules.

Le type InputMethodHints est un typedef pour QFlags<InputMethodHint>. Il stocke une combinaison OU de valeurs InputMethodHint.

Voir également QGraphicsItem::inputMethodHints().

enum Qt::InputMethodQuery
flags Qt::InputMethodQueries

Constante	Valeur	Description
`Qt::ImEnabled`	`0x1`	Le widget accepte les méthodes d'entrée.
`Qt::ImCursorRectangle`	`0x2`	Le rectangle couvrant la zone du curseur de saisie en coordonnées du widget.
`Qt::ImFont`	`0x4`	La police actuellement utilisée pour la saisie de texte.
`Qt::ImCursorPosition`	`0x8`	La position logique du curseur dans le texte entourant la zone de saisie (voir `ImSurroundingText`). La position n'intègre pas le décalage du curseur dans la zone de pré-édition, tel qu'il est contrôlé par QInputMethodEvent::Cursor.
`Qt::ImSurroundingText`	`0x10`	Le texte en clair autour de la zone de saisie, par exemple le paragraphe en cours.
`Qt::ImCurrentSelection`	`0x20`	Le texte actuellement sélectionné.
`Qt::ImMaximumTextLength`	`0x40`	Le nombre maximum de caractères que le widget peut contenir. S'il n'y a pas de limite, QVariant::QVariant() est renvoyé.
`Qt::ImAnchorPosition`	`0x80`	La position de l'ancre de sélection. Elle peut être inférieure ou supérieure à `ImCursorPosition`, selon le côté de la sélection où se trouve le curseur. S'il n'y a pas de sélection, elle renvoie la même chose que `ImCursorPosition`.
`Qt::ImHints`	`0x100`	La méthode "hints for input" (conseils pour la saisie) sur la saisie attendue. (Voir Qt::InputMethodHints)
`Qt::ImPreferredLanguage`	`0x200`	La langue d'entrée préférée.
`Qt::ImPlatformData`	`0x80000000`	Données spécifiques à la plate-forme pour la méthode de saisie.
`Qt::ImAbsolutePosition`	`0x400`	La position logique du curseur dans l'ensemble du document. Cette position n'intègre pas le décalage du curseur dans la zone de pré-édition, tel qu'il est contrôlé par QInputMethodEvent::Cursor.
`Qt::ImTextBeforeCursor`	`0x800`	Le texte en clair avant le curseur. Le widget peut décider de la quantité de texte à renvoyer, mais ne doit pas renvoyer une chaîne vide, sauf si le curseur se trouve au début du document.
`Qt::ImTextAfterCursor`	`0x1000`	Le texte en clair après le curseur. Le widget peut décider de la quantité de texte à renvoyer, mais ne doit pas renvoyer de chaîne vide, sauf si le curseur se trouve à la fin du document.
`Qt::ImEnterKeyType`	`0x2000`	Le type de touche Entrée.
`Qt::ImAnchorRectangle`	`0x4000`	Le rectangle de délimitation de l'ancre de sélection. Cette valeur a été ajoutée dans Qt 5.7.
`Qt::ImInputItemClipRectangle`	`0x8000`	Le rectangle de l'élément de saisie exposé. Certaines parties de l'élément de saisie peuvent être coupées. Cette valeur tient compte de la coupure et renvoie le rectangle réel de l'élément peint. Le rectangle est en coordonnées de widget.
`Qt::ImReadOnly`	`0x10000`	Le widget est en lecture seule. Cette valeur a été ajoutée dans Qt 6.2.

Masques :

Constante	Valeur	Description
`Qt::ImQueryInput`	`ImCursorRectangle \| ImCursorPosition \| ImSurroundingText \| ImCurrentSelection \| ImAnchorRectangle \| ImAnchorPosition`	Propriétés couramment modifiées en entrée.
`Qt::ImQueryAll`	`0xffffffff`	Requête portant sur toutes les propriétés des méthodes d'entrée.

Le type InputMethodQueries est un typedef pour QFlags<InputMethodQuery>. Il stocke une combinaison OU de valeurs InputMethodQuery.

Voir également QInputMethodQueryEvent.

enum Qt::ItemDataRole

Chaque élément du modèle est associé à un ensemble d'éléments de données, chacun ayant son propre rôle. Les rôles sont utilisés par la vue pour indiquer au modèle le type de données dont il a besoin. Les modèles personnalisés doivent renvoyer des données de ces types.

Les rôles généraux (et les types associés) sont les suivants :

Constante	Valeur	Description
`Qt::DisplayRole`	`0`	Les données clés à restituer sous forme de texte. (QString)
`Qt::DecorationRole`	`1`	Les données à afficher en tant que décoration sous la forme d'une icône. (QColor, QIcon ou QPixmap)
`Qt::EditRole`	`2`	Les données sous une forme adaptée à l'édition dans un éditeur. (QString)
`Qt::ToolTipRole`	`3`	Les données affichées dans l'infobulle de l'élément. (QString)
`Qt::StatusTipRole`	`4`	Les données affichées dans la barre d'état. (QString)
`Qt::WhatsThisRole`	`5`	Les données affichées pour l'élément en mode "Qu'est-ce que c'est ? (QString)
`Qt::SizeHintRole`	`13`	L'indice de taille de l'élément qui sera fourni aux vues. (QSize)

Rôles décrivant l'apparence et les métadonnées (avec les types associés) :

Constante	Valeur	Description
`Qt::FontRole`	`6`	Police utilisée pour les éléments rendus avec le délégué par défaut. (QFont)
`Qt::TextAlignmentRole`	`7`	L'alignement du texte pour les éléments rendus avec le délégué par défaut. (Qt::Alignment)
`Qt::BackgroundRole`	`8`	La brosse d'arrière-plan utilisée pour les éléments rendus avec le délégué par défaut. (QBrush)
`Qt::ForegroundRole`	`9`	La brosse de premier plan (couleur du texte, typiquement) utilisée pour les éléments rendus avec le délégué par défaut. (QBrush)
`Qt::CheckStateRole`	`10`	Ce rôle est utilisé pour obtenir l'état vérifié d'un élément. (Qt::CheckState)
`Qt::InitialSortOrderRole`	`14`	Ce rôle est utilisé pour obtenir l'ordre de tri initial d'une section de la vue d'en-tête. (Qt::SortOrder).

Rôles d'accessibilité (avec les types associés) :

Constante	Valeur	Description
`Qt::AccessibleTextRole`	`11`	Texte à utiliser par les extensions et plugins d'accessibilité, tels que les lecteurs d'écran. (QString)
`Qt::AccessibleDescriptionRole`	`12`	Description de l'élément à des fins d'accessibilité. (QString)

Rôles des utilisateurs :

Constante	Valeur	Description du rôle
`Qt::UserRole`	`0x0100`	Le premier rôle qui peut être utilisé à des fins spécifiques à l'application.

Pour les rôles d'utilisateur, il appartient au développeur de décider des types à utiliser et de s'assurer que les composants utilisent les types corrects lorsqu'ils accèdent aux données et les définissent.

enum Qt::ItemFlag
flags Qt::ItemFlags

Cette énumération décrit les propriétés d'un élément :

Constante	Valeur	Description de l'élément
`Qt::NoItemFlags`	`0`	Aucune propriété n'est définie.
`Qt::ItemIsSelectable`	`1`	Il peut être sélectionné.
`Qt::ItemIsEditable`	`2`	Il peut être modifié.
`Qt::ItemIsDragEnabled`	`4`	Il peut être déplacé.
`Qt::ItemIsDropEnabled`	`8`	Il peut être utilisé comme cible de dépôt.
`Qt::ItemIsUserCheckable`	`16`	Il peut être coché ou décoché par l'utilisateur.
`Qt::ItemIsEnabled`	`32`	L'utilisateur peut interagir avec l'élément.
`Qt::ItemIsAutoTristate`	`64`	L'état de l'élément dépend de l'état de ses enfants. Cela permet de gérer automatiquement l'état des éléments parents dans QTreeWidget (coché si tous les enfants sont cochés, décoché si tous les enfants sont décochés, ou partiellement coché si seuls certains enfants sont cochés).
`Qt::ItemNeverHasChildren`	`128`	L'élément n'a jamais d'éléments enfants. Ceci n'est utilisé qu'à des fins d'optimisation.
`Qt::ItemIsUserTristate`	`256`	L'utilisateur peut passer par trois états distincts. Cette valeur a été ajoutée dans Qt 5.5.

Notez que les éléments vérifiables doivent recevoir à la fois un ensemble approprié de drapeaux et un état initial, indiquant si l'élément est vérifié ou non. Ceci est géré automatiquement pour les composants modèle/vue, mais doit être explicitement défini pour les instances de QListWidgetItem, QTableWidgetItem, et QTreeWidgetItem.

Notez que c'est un comportement non défini de réimplémenter QAbstractItemModel::hasChildren pour retourner true pour un index si cet index a le drapeau Qt::ItemNeverHasChildren activé.

Le type ItemFlags est un typedef pour QFlags<ItemFlag>. Il stocke une combinaison OU de valeurs ItemFlag.

Voir également QAbstractItemModel.

enum Qt::ItemSelectionMode

Cette énumération est utilisée dans QGraphicsItem, QGraphicsScene et QGraphicsView pour spécifier comment les éléments sont sélectionnés ou comment déterminer si les formes et les éléments entrent en collision.

Constante	Valeur	Description
`Qt::ContainsItemShape`	`0x0`	La liste de sortie ne contient que les éléments dont shape est entièrement contenu dans la zone de sélection. Les éléments qui recoupent le contour de la zone ne sont pas inclus.
`Qt::IntersectsItemShape`	`0x1`	La liste de sortie contient à la fois les éléments dont le site shape est entièrement contenu dans la zone de sélection et les éléments qui recoupent le contour de la zone. Il s'agit d'un mode courant de sélection par élastique.
`Qt::ContainsItemBoundingRect`	`0x2`	La liste de sortie ne contient que les éléments dont le site bounding rectangle est entièrement contenu dans la zone de sélection. Les éléments qui coupent le contour de la zone ne sont pas inclus.
`Qt::IntersectsItemBoundingRect`	`0x3`	La liste de sortie contient à la fois les éléments dont le site bounding rectangle est entièrement contenu dans la zone de sélection, et les éléments qui recoupent le contour de la zone. Cette méthode est couramment utilisée pour déterminer les zones qui doivent être redessinées.

Voir également QGraphicsScene::items(), QGraphicsScene::collidingItems(), QGraphicsView::items(), QGraphicsItem::collidesWithItem() et QGraphicsItem::collidesWithPath().

enum Qt::ItemSelectionOperation

Cette énumération est utilisée dans QGraphicsScene pour spécifier ce qu'il convient de faire avec les éléments actuellement sélectionnés lors de la définition d'une zone de sélection.

Constante	Valeur	Description
`Qt::ReplaceSelection`	`0`	Les éléments actuellement sélectionnés sont remplacés par les éléments de la zone de sélection.
`Qt::AddToSelection`	`1`	Les éléments de la zone de sélection sont ajoutés aux éléments actuellement sélectionnés.

Voir également QGraphicsScene::setSelectionArea().

enum Qt::Key

Les noms de clés utilisés par Qt.

Constante	Valeur	Description
`Qt::Key_Escape`	`0x01000000`
`Qt::Key_Tab`	`0x01000001`
`Qt::Key_Backtab`	`0x01000002`
`Qt::Key_Backspace`	`0x01000003`
`Qt::Key_Return`	`0x01000004`
`Qt::Key_Enter`	`0x01000005`	Généralement située sur le clavier.
`Qt::Key_Insert`	`0x01000006`
`Qt::Key_Delete`	`0x01000007`
`Qt::Key_Pause`	`0x01000008`	La touche Pause/Break(Remarque: n'est pas liée à la mise en pause d'un média)
`Qt::Key_Print`	`0x01000009`
`Qt::Key_SysReq`	`0x0100000a`
`Qt::Key_Clear`	`0x0100000b`	Correspond à la touche Clear sur certains modèles de claviers Apple. Sur d'autres systèmes, elle est généralement associée à la touche 5 du pavé numérique, lorsque la fonction Verrouillage numérique est activée à l'adresse `off`.
`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`	Sous macOS, cette touche correspond aux touches de commande.
`Qt::Key_Meta`	`0x01000022`	Sous macOS, cette touche correspond aux touches de contrôle. Sur les claviers Windows, cette touche est associée à la touche Windows.
`Qt::Key_Alt`	`0x01000023`
`Qt::Key_AltGr`	`0x01001103`	Sous Windows, lorsque l'événement `KeyDown` est envoyé pour cette touche, les modificateurs Ctrl+Alt sont également activés.
`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`	Alias obsolète pour 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`	Une touche qui règle l'état du lecteur multimédia sur la lecture
`Qt::Key_MediaStop`	`0x01000081`	une touche permettant d'arrêter le lecteur multimédia
`Qt::Key_MediaPrevious`	`0x01000082`
`Qt::Key_MediaNext`	`0x01000083`
`Qt::Key_MediaRecord`	`0x01000084`
`Qt::Key_MediaPause`	`0x01000085`	Une touche permettant de mettre le lecteur multimédia en pause(Note: pas la touche pause/break)
`Qt::Key_MediaTogglePlayPause`	`0x01000086`	Une touche permettant de basculer l'état lecture/pause du lecteur multimédia (plutôt que de définir un état absolu).
`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_Keyboard`	`0x0100011f`
`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`	Une touche pour répondre ou lancer un appel (voir Qt::Key_ToggleCallHangup pour une touche permettant de basculer l'état de l'appel en cours).
`Qt::Key_Camera`	`0x01100020`	Une touche pour activer l'obturateur de la caméra. Sous Windows Runtime, la variable d'environnement QT_QPA_ENABLE_CAMERA_KEYS doit être définie pour recevoir l'événement.
`Qt::Key_CameraFocus`	`0x01100021`	Touche permettant d'effectuer la mise au point de la caméra. Sous Windows Runtime, la variable d'environnement QT_QPA_ENABLE_CAMERA_KEYS doit être définie pour recevoir l'événement.
`Qt::Key_Context1`	`0x01100000`
`Qt::Key_Context2`	`0x01100001`
`Qt::Key_Context3`	`0x01100002`
`Qt::Key_Context4`	`0x01100003`
`Qt::Key_Flip`	`0x01100006`
`Qt::Key_Hangup`	`0x01100005`	Une touche pour mettre fin à un appel en cours (voir Qt::Key_ToggleCallHangup pour une touche permettant de basculer l'état de l'appel en cours).
`Qt::Key_No`	`0x01010002`
`Qt::Key_Select`	`0x01010000`
`Qt::Key_Yes`	`0x01010001`
`Qt::Key_ToggleCallHangup`	`0x01100007`	Une touche pour basculer l'état de l'appel en cours (c'est-à-dire soit répondre, soit raccrocher) en fonction de l'état de l'appel en cours.
`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`

Voir aussi QKeyEvent::key().

enum Qt::KeyboardModifier
flags Qt::KeyboardModifiers

Cet enum décrit les touches modificatrices.

Constante	Valeur	Description
`Qt::NoModifier`	`0x00000000`	Aucune touche de modification n'est enfoncée.
`Qt::ShiftModifier`	`0x02000000`	Une touche Shift du clavier est enfoncée.
`Qt::ControlModifier`	`0x04000000`	Une touche Ctrl du clavier est enfoncée.
`Qt::AltModifier`	`0x08000000`	Une touche Alt du clavier est enfoncée.
`Qt::MetaModifier`	`0x10000000`	Une touche Meta du clavier est enfoncée.
`Qt::KeypadModifier`	`0x20000000`	Une touche du clavier est enfoncée.
`Qt::GroupSwitchModifier`	`0x40000000`	X11 uniquement (sauf si activé sous Windows par un argument de ligne de commande). Une touche Mode_switch du clavier est enfoncée.

Remarque : sur macOS, la valeur ControlModifier correspond aux touches de commande du clavier et la valeur MetaModifier correspond aux touches de contrôle. La valeur KeypadModifier sera également définie lorsqu'une touche fléchée est enfoncée, car les touches fléchées sont considérées comme faisant partie du clavier.

Note : Sur les claviers Windows, Qt::MetaModifier et Qt::Key_Meta sont mappés à la touche Windows.

Le type KeyboardModifiers est un typedef pour QFlags<KeyboardModifier>. Il stocke une combinaison OU de valeurs KeyboardModifier.

Voir également MouseButton et Modifier.

enum Qt::LayoutDirection

Spécifie la direction de la mise en page et de la gestion du texte de Qt.

Constante	Valeur	Description
`Qt::LeftToRight`	`0`	Disposition gauche-droite.
`Qt::RightToLeft`	`1`	Disposition de droite à gauche.
`Qt::LayoutDirectionAuto`	`2`	Disposition automatique.

La mise en page de droite à gauche est nécessaire pour certaines langues, notamment l'arabe et l'hébreu.

LayoutDirectionAuto a deux fonctions. Lorsqu'il est utilisé avec des widgets et des présentations, il implique l'utilisation de la direction de présentation définie sur le widget parent ou sur QApplication. Cela a le même effet que QWidget::unsetLayoutDirection().

Lorsque LayoutDirectionAuto est utilisé avec la mise en page de texte, cela signifie que la direction du texte est déterminée à partir du contenu de la chaîne de caractères à mettre en page.

Voir aussi QGuiApplication::setLayoutDirection(), QWidget::setLayoutDirection(), QTextOption::setTextDirection() et QString::isRightToLeft().

enum Qt::MaskMode

Cette énumération spécifie le comportement des fonctions QPixmap::createMaskFromColor() et QImage::createMaskFromColor().

Constante	Valeur	Description
`Qt::MaskInColor`	`0`	Crée un masque dans lequel tous les pixels correspondant à la couleur donnée sont opaques.
`Qt::MaskOutColor`	`1`	Crée un masque dans lequel tous les pixels correspondant à la couleur donnée sont transparents.

enum Qt::MatchFlag
flags Qt::MatchFlags

Cette énumération décrit le type de correspondance qui peut être utilisé lors de la recherche d'éléments dans un modèle.

Constante	Valeur	Description
`Qt::MatchExactly`	`0`	Effectue une correspondance basée sur QVariant.
`Qt::MatchFixedString`	`8`	Effectue des correspondances basées sur des chaînes de caractères. Les comparaisons basées sur les chaînes de caractères sont insensibles à la casse, sauf si l'option `MatchCaseSensitive` est également spécifiée.
`Qt::MatchContains`	`1`	Le terme recherché est contenu dans l'élément.
`Qt::MatchStartsWith`	`2`	Le terme recherché correspond au début de l'élément.
`Qt::MatchEndsWith`	`3`	Le terme recherché correspond à la fin de l'élément.
`Qt::MatchCaseSensitive`	`16`	La recherche est sensible à la casse.
`Qt::MatchRegularExpression`	`4`	Effectue une correspondance basée sur une chaîne en utilisant une expression régulière comme terme de recherche. Utilise QRegularExpression. Lorsque cet indicateur est utilisé, un objet QRegularExpression peut être transmis en tant que paramètre et sera directement utilisé pour effectuer la recherche. L'indicateur de sensibilité à la casse sera ignoré car l'objet QRegularExpression est censé être entièrement configuré. Cette valeur d'énumération a été ajoutée dans Qt 5.15.
`Qt::MatchWildcard`	`5`	Effectue une correspondance basée sur une chaîne en utilisant une chaîne avec des caractères génériques comme terme de recherche.
`Qt::MatchWrap`	`32`	Effectue une recherche enveloppante, de sorte que lorsque la recherche atteint le dernier élément du modèle, elle recommence au premier élément et se poursuit jusqu'à ce que tous les éléments aient été examinés.
`Qt::MatchRecursive`	`64`	Recherche dans toute la hiérarchie.

Remarque : Qt::MatchExactly, Qt::MatchContains, Qt::MatchStartsWith, Qt::MatchEndsWith, Qt::MatchRegularExpression, Qt::MatchWildcard, et Qt::MatchFixedString sont mutuellement exclusifs. Le comportement obtenu en définissant plusieurs d'entre eux dans un argument de Qt::MatchFlags est indéfini.

Le type MatchFlags est un typedef pour QFlags<MatchFlag>. Il stocke une combinaison OU de valeurs MatchFlag.

Voir aussi QString::compare() et QRegularExpression.

enum Qt::Modifier
flags Qt::Modifiers

Cette énumération fournit des noms plus courts pour les touches de modification du clavier prises en charge par Qt.

Note : Sur macOS, la valeur CTRL correspond aux touches de commande du clavier, et la valeur META correspond aux touches de contrôle.

Constante	Valeur	Description
`Qt::SHIFT`	`Qt::ShiftModifier`	Les touches Shift présentes sur tous les claviers standard.
`Qt::META`	`Qt::MetaModifier`	Les touches Meta.
`Qt::CTRL`	`Qt::ControlModifier`	Les touches Ctrl.
`Qt::ALT`	`Qt::AltModifier`	Les touches Alt normales, mais pas les touches comme AltGr.

Le type Modifiers est un typedef pour QFlags<Modifier>. Il stocke une combinaison OU de valeurs de modificateurs.

Voir également KeyboardModifier et MouseButton.

enum Qt::MouseButton
flags Qt::MouseButtons

Ce type d'énumération décrit les différents boutons de la souris.

Constante	Valeur	Description
`Qt::NoButton`	`0x00000000`	L'état du bouton ne fait référence à aucun bouton (voir QMouseEvent::button()).
`Qt::AllButtons`	`0x07ffffff`	Cette valeur correspond à un masque de tous les boutons de souris possibles. À utiliser pour définir la propriété "acceptedButtons" d'un site MouseArea afin qu'elle accepte TOUS les boutons de la souris.
`Qt::LeftButton`	`0x00000001`	Le bouton gauche est enfoncé ou un événement fait référence au bouton gauche. (Le bouton gauche peut être le bouton droit sur les souris pour gauchers).
`Qt::RightButton`	`0x00000002`	Le bouton droit.
`Qt::MiddleButton`	`0x00000004`	Le bouton du milieu.
`Qt::BackButton`	`0x00000008`	Le bouton "Retour". (Généralement présent sur le côté "pouce" d'une souris dotée de boutons supplémentaires. Il ne s'agit PAS de la molette).
`Qt::XButton1`	`BackButton`	Le bouton "Retour".
`Qt::ExtraButton1`	`XButton1`	Le bouton "Retour".
`Qt::ForwardButton`	`0x00000010`	Le bouton "Avancer". (Généralement présent à côté du bouton "Retour", et également pressé par le pouce).
`Qt::XButton2`	`ForwardButton`	Le bouton "avant".
`Qt::ExtraButton2`	`ForwardButton`	Le bouton "Avancer".
`Qt::TaskButton`	`0x00000020`	Le bouton "Tâche".
`Qt::ExtraButton3`	`TaskButton`	Le bouton "Tâche".
`Qt::ExtraButton4`	`0x00000040`	Le 7e bouton de la souris non roulante.
`Qt::ExtraButton5`	`0x00000080`	Le 8e bouton de la souris non roulante.
`Qt::ExtraButton6`	`0x00000100`	Le 9e bouton de la souris non roulante.
`Qt::ExtraButton7`	`0x00000200`	Le 10e bouton de la souris non roulante.
`Qt::ExtraButton8`	`0x00000400`	Le 11e bouton de la souris non roulante.
`Qt::ExtraButton9`	`0x00000800`	Le 12e bouton de la souris sans volant.
`Qt::ExtraButton10`	`0x00001000`	Le 13e bouton de la souris sans volant.
`Qt::ExtraButton11`	`0x00002000`	Le 14e bouton de la souris sans volant.
`Qt::ExtraButton12`	`0x00004000`	Le 15e bouton de la souris sans volant.
`Qt::ExtraButton13`	`0x00008000`	Le 16e bouton de la souris sans volant.
`Qt::ExtraButton14`	`0x00010000`	Le 17e bouton de la souris sans volant.
`Qt::ExtraButton15`	`0x00020000`	Le 18e bouton de la souris sans volant.
`Qt::ExtraButton16`	`0x00040000`	Le 19e bouton de la souris sans volant.
`Qt::ExtraButton17`	`0x00080000`	Le 20e bouton de la souris sans volant.
`Qt::ExtraButton18`	`0x00100000`	Le 21e bouton de la souris sans volant.
`Qt::ExtraButton19`	`0x00200000`	Le 22e bouton de la souris sans volant.
`Qt::ExtraButton20`	`0x00400000`	Le 23e bouton de la souris sans volant.
`Qt::ExtraButton21`	`0x00800000`	Le 24e bouton de la souris sans volant.
`Qt::ExtraButton22`	`0x01000000`	Le 25e bouton de la souris sans volant.
`Qt::ExtraButton23`	`0x02000000`	Le 26e bouton de la souris sans volant.
`Qt::ExtraButton24`	`0x04000000`	Le 27e bouton de la souris sans roulette.

Remarque : certains modèles de souris à boutons multiples sont préconfigurés avec des boutons à numérotation élevée émulant des séquences de clavier, pour une utilisation dans des jeux spécifiques. Pour que ces boutons soient considérés comme de véritables "boutons de souris", le périphérique doit être reconfiguré (à l'aide de l'outil de configuration du fournisseur).

Le type MouseButtons est un typedef pour QFlags<MouseButton>. Il stocke une combinaison OU de valeurs de boutons de souris.

Voir également KeyboardModifier et Modifier.

enum Qt::MouseEventFlag
flags Qt::MouseEventFlags

Cette énumération fournit des informations supplémentaires concernant un événement QMouseEvent.

Constante	Valeur	Description de l'événement
`Qt::MouseEventCreatedDoubleClick`	`0x01`	Indique que Qt a créé un événement MouseButtonDblClick à partir de cet événement. L'indicateur est défini dans l'événement à l'origine de l'événement MouseButtonPress, et non dans l'événement résultant MouseButtonDblClick.

Le type MouseEventFlags est un typedef pour QFlags<MouseEventFlag>. Il stocke une combinaison OU de valeurs MouseEventFlag.

enum Qt::MouseEventSource

Cette énumération décrit la source d'un événement de souris et peut être utile pour déterminer s'il s'agit d'un événement de souris artificiel provenant d'un autre périphérique tel qu'un écran tactile.

Constante	Valeur	Description
`Qt::MouseEventNotSynthesized`	`0`	Valeur la plus courante. Sur les plateformes où cette information est disponible, cette valeur indique que l'événement a été généré en réponse à un véritable événement de souris dans le système.
`Qt::MouseEventSynthesizedBySystem`	`1`	Indique que l'événement souris a été synthétisé par la plate-forme à partir d'un événement tactile.
`Qt::MouseEventSynthesizedByQt`	`2`	Indique que l'événement souris a été synthétisé à partir d'un événement tactile non géré par Qt.
`Qt::MouseEventSynthesizedByApplication`	`3`	Indique que l'événement souris a été synthétisé par l'application. Cela permet de distinguer les événements souris générés par l'application de ceux qui proviennent du système ou qui sont synthétisés par Qt. Cette valeur a été introduite dans Qt 5.6

Voir aussi Qt::AA_SynthesizeMouseForUnhandledTouchEvents.

enum Qt::NativeGestureType

Cette énumération renvoie le type de geste.

Constante	Valeur	Description du geste
`Qt::BeginNativeGesture`	`0`	Envoyé avant le flux d'événements de geste.
`Qt::EndNativeGesture`	`1`	Envoyé après le flux d'événements du geste.
`Qt::PanNativeGesture`	`2`	Spécifie le delta de déplacement en pixels.
`Qt::ZoomNativeGesture`	`3`	Spécifie le delta d'agrandissement en pourcentage.
`Qt::SmartZoomNativeGesture`	`4`	État d'agrandissement booléen.
`Qt::RotateNativeGesture`	`5`	Spécifie le delta de rotation en degrés.
`Qt::SwipeNativeGesture`	`6`	Envoyé après un mouvement de balayage.

enum Qt::NavigationMode

Ce type d'énumération décrit le mode de déplacement de la mise au point.

Constante	Valeur	Description
`Qt::NavigationModeNone`	`0`	Seul l'écran tactile est utilisé.
`Qt::NavigationModeKeypadTabOrder`	`1`	Qt::Key_Up et Qt::Key_Down sont utilisés pour modifier la mise au point.
`Qt::NavigationModeKeypadDirectional`	`2`	Qt::Key_UpLe curseur de la souris, Qt::Key_Down, Qt::Key_Left et Qt::Key_Right sont utilisés pour changer le focus.
`Qt::NavigationModeCursorAuto`	`3`	Le curseur de la souris est utilisé pour changer le focus, il n'est affiché que sur les appareils sans écran tactile. Le clavier est utilisé pour implémenter un curseur virtuel, à moins que l'appareil ne dispose d'un périphérique d'entrée de type souris analogique (par exemple, un pavé tactile). C'est le paramètre recommandé pour une application telle qu'un navigateur web qui nécessite un contrôle du pointeur à la fois sur les dispositifs tactiles et non tactiles.
`Qt::NavigationModeCursorForceVisible`	`4`	Le curseur de la souris est utilisé pour changer le focus, il est affiché quel que soit le type de périphérique. Le clavier est utilisé pour mettre en œuvre un curseur virtuel, à moins que le dispositif ne dispose d'un périphérique d'entrée de type souris analogique (par exemple, un pavé tactile).

Remarque : la navigation par curseur n'est actuellement mise en œuvre sur aucune plate-forme et se comporte comme NavigationModeNone.

Voir aussi QApplication::setNavigationMode() et QApplication::navigationMode().

enum Qt::Orientation
flags Qt::Orientations

Ce type est utilisé pour indiquer l'orientation d'un objet.

Constante	Valeur
`Qt::Horizontal`	`0x1`
`Qt::Vertical`	`0x2`

L'orientation est utilisée avec QScrollBar par exemple.

Le type Orientations est un typedef pour QFlags<Orientation>. Il stocke une combinaison OU de valeurs d'orientation.

enum Qt::PenCapStyle

Ce type d'énumération définit les styles de capuchon de stylo pris en charge par Qt, c'est-à-dire les capuchons de fin de ligne qui peuvent être dessinés à l'aide de QPainter.


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

Constante	Valeur	Description
`Qt::FlatCap`	`0x00`	une extrémité de ligne carrée qui ne couvre pas le point final de la ligne.
`Qt::SquareCap`	`0x10`	une extrémité de ligne carrée qui couvre le point final et le dépasse de la moitié de la largeur de la ligne.
`Qt::RoundCap`	`0x20`	une extrémité de ligne arrondie.

Voir également QPen.

enum Qt::PenJoinStyle

Ce type d'énumération définit les styles de jonction de stylo pris en charge par Qt, c'est-à-dire les jonctions entre deux lignes connectées qui peuvent être dessinées à l'aide de QPainter.


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

Constante	Valeur	Description
`Qt::MiterJoin`	`0x00`	Les bords extérieurs des lignes sont prolongés pour former un angle et cette zone est remplie.
`Qt::BevelJoin`	`0x40`	L'encoche triangulaire entre les deux lignes est remplie.
`Qt::RoundJoin`	`0x80`	Un arc de cercle entre les deux lignes est rempli.
`Qt::SvgMiterJoin`	`0x100`	Une jointure en onglet correspondant à la définition d'une jointure en onglet dans la spécification SVG 1.2 Tiny.

Voir aussi QPen.

enum Qt::PenStyle

Ce type d'énumération définit les styles de stylo qui peuvent être dessinés à l'aide de QPainter. Les styles sont les suivants :


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

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

Constante	Valeur	Description de la constante
`Qt::NoPen`	`0`	pas de ligne du tout. Par exemple, QPainter::drawRect() remplit mais ne dessine pas de ligne de démarcation.
`Qt::SolidLine`	`1`	Une ligne simple.
`Qt::DashLine`	`2`	Tirets séparés de quelques pixels.
`Qt::DotLine`	`3`	Points séparés de quelques pixels.
`Qt::DashDotLine`	`4`	Alternance de points et de tirets.
`Qt::DashDotDotLine`	`5`	Un tiret, deux points, un tiret, deux points.
`Qt::CustomDashLine`	`6`	Un motif personnalisé défini à l'aide de QPainterPathStroker::setDashPattern().

Voir également QPen.

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

Cette énumération décrit les statuts possibles d'une autorisation.

Constante	Valeur	Description de l'état
`Qt::PermissionStatus::Undetermined`	`0`	Le statut de la permission n'est pas encore connu. La permission doit être demandée via QCoreApplication::requestPermission() pour déterminer le statut réel. Ce statut ne sera jamais le résultat d'une demande de permission.
`Qt::PermissionStatus::Granted`	`1`	L'utilisateur a explicitement accordé l'autorisation à l'application, ou l'autorisation est connue pour ne pas nécessiter l'autorisation de l'utilisateur sur la plate-forme donnée.
`Qt::PermissionStatus::Denied`	`2`	L'utilisateur a explicitement refusé à l'application l'autorisation demandée, ou l'on sait que l'autorisation n'est pas accessible ou applicable aux applications sur la plate-forme donnée.

Note : Sur Android, il n'y a pas de statut Undetermined par les API de la plateforme. Par conséquent, si une autorisation est refusée à une application, QCoreApplication::checkPermission() renvoie Undetermined par défaut jusqu'à ce que QCoreApplication::requestPermission() soit appelé. Après cela, QCoreApplication::checkPermission() renvoie un état non Undetermined.

Cette liste a été introduite dans Qt 6.5.

Voir aussi QCoreApplication::requestPermission(), QCoreApplication::checkPermission(), et Permissions d'application.

enum Qt::ReturnByValueConstant

Il s'agit d'un type fictif, conçu pour aider les utilisateurs à passer de certaines API obsolètes à leurs API de remplacement.

Voir aussi QCursor::bitmap(), QCursor::mask(), QLabel::picture() et QLabel::pixmap().

enum Qt::ScreenOrientation
flags Qt::ScreenOrientations

Ce type d'enum spécifie les différentes orientations qu'un écran peut avoir.

Constante	Valeur	Description
`Qt::PrimaryOrientation`	`0x00000000`	Orientation principale de l'écran.
`Qt::LandscapeOrientation`	`0x00000002`	Orientation paysage, la largeur de l'écran est supérieure à sa hauteur.
`Qt::PortraitOrientation`	`0x00000001`	Orientation portrait, la hauteur de l'affichage est supérieure à la largeur de l'affichage, avec une rotation de 90 degrés dans le sens des aiguilles d'une montre par rapport à l'orientation paysage.
`Qt::InvertedLandscapeOrientation`	`0x00000008`	Orientation paysage inversée, rotation de 180 degrés par rapport au paysage.
`Qt::InvertedPortraitOrientation`	`0x00000004`	Orientation portrait inversée, rotation de 180 degrés par rapport au portrait.

Le type ScreenOrientations est un typedef pour QFlags<ScreenOrientation>. Il stocke une combinaison OU de valeurs ScreenOrientation.

enum Qt::ScrollBarPolicy

Ce type d'énumération décrit les différents modes des barres de défilement de QAbstractScrollArea.

Constante	Valeur	Description
`Qt::ScrollBarAsNeeded`	`0`	QAbstractScrollArea affiche une barre de défilement lorsque le contenu est trop grand pour être affiché, mais pas dans les autres cas. Il s'agit de la valeur par défaut.
`Qt::ScrollBarAlwaysOff`	`1`	QAbstractScrollArea n'affiche jamais de barre de défilement.
`Qt::ScrollBarAlwaysOn`	`2`	QAbstractScrollArea affiche toujours une barre de défilement. Cette propriété est ignorée sur les systèmes dotés de barres de défilement transitoires (par exemple, sur Mac à partir de la version 10.7).

(Les modes pour les barres de défilement horizontales et verticales sont indépendants).

enum Qt::ScrollPhase

Cette énumération décrit la phase de défilement.

Constante	Valeur	Description de la phase de défilement
`Qt::NoScrollPhase`	`0`	Le périphérique d'entrée ne prend pas en charge la phase de défilement. Cette valeur a été introduite dans Qt 5.7.
`Qt::ScrollBegin`	`1`	Le défilement est sur le point de commencer, mais la distance de défilement n'a pas encore changé.
`Qt::ScrollUpdate`	`2`	La distance de défilement a changé (par défaut).
`Qt::ScrollEnd`	`3`	Le défilement est terminé et la distance de défilement n'a pas changé.
`Qt::ScrollMomentum`	`4`	L'utilisateur ne touche plus le périphérique d'entrée, mais le défilement se poursuit en raison de l'élan du défilement. Cette valeur a été introduite dans Qt 5.12.

enum Qt::ShortcutContext

Pour qu'un événement QEvent::Shortcut se produise, la séquence de touches du raccourci doit être saisie par l'utilisateur dans un contexte où le raccourci est actif. Les contextes possibles sont les suivants :

Constante	Valeur	Description
`Qt::WidgetShortcut`	`0`	Le raccourci est actif lorsque le widget parent a le focus.
`Qt::WidgetWithChildrenShortcut`	`3`	Le raccourci est actif lorsque le widget parent ou l'un de ses enfants a le focus. Les enfants qui sont des widgets de niveau supérieur, à l'exception des pop-ups, ne sont pas concernés par ce contexte de raccourci.
`Qt::WindowShortcut`	`1`	Le raccourci est actif lorsque son widget parent est un sous-widget logique de la fenêtre de premier niveau active.
`Qt::ApplicationShortcut`	`2`	Le raccourci est actif lorsque l'une des fenêtres d'application est active.

enum Qt::SizeHint

Cette énumération est utilisée par QGraphicsLayoutItem::sizeHint()

Constante	Valeur	Description
`Qt::MinimumSize`	`0`	permet de spécifier la taille minimale d'un élément de la présentation graphique.
`Qt::PreferredSize`	`1`	permet de spécifier la taille préférée d'un élément de la présentation graphique.
`Qt::MaximumSize`	`2`	permet de spécifier la taille maximale d'un élément de présentation graphique.
`Qt::MinimumDescent`	`3`	permet de spécifier la descente minimale d'une chaîne de texte dans un élément de présentation graphique.

Voir également QGraphicsLayoutItem::sizeHint().

enum Qt::SizeMode

Cette énumération est utilisée par les fonctions QPainter::drawRoundedRect() et QPainterPath::addRoundedRect() pour spécifier les rayons des coins des rectangles par rapport aux dimensions des rectangles de délimitation spécifiés.

Constante	Valeur	Description
`Qt::AbsoluteSize`	`0`	Spécifie la taille en utilisant des mesures absolues.
`Qt::RelativeSize`	`1`	Spécifie la taille par rapport au rectangle de délimitation, généralement à l'aide de mesures en pourcentage.

enum Qt::SortOrder

Cette énumération décrit la manière dont les éléments d'un widget sont triés.

Constante	Valeur	Description
`Qt::AscendingOrder`	`0`	Les éléments sont triés de manière ascendante, par exemple : commence par "AAA" et se termine par "ZZZ" dans les langues locales latines-1.
`Qt::DescendingOrder`	`1`	Les éléments sont triés de manière décroissante, par exemple : commence par "ZZZ" et se termine par "AAA" dans les langues locales latines 1.

enum Qt::SplitBehaviorFlags
flags Qt::SplitBehavior

Cette énumération spécifie comment les fonctions QString::split() doivent se comporter avec les chaînes vides.

Constante	Valeur	Description
`Qt::KeepEmptyParts`	`0`	Si un champ est vide, le conserver dans le résultat.
`Qt::SkipEmptyParts`	`0x1`	Si un champ est vide, ne pas l'inclure dans le résultat.

Le type SplitBehavior est un typedef pour QFlags<SplitBehaviorFlags>. Il stocke une combinaison OU de valeurs SplitBehaviorFlags.

Voir également QString::split().

enum Qt::TabFocusBehavior

Ce type d'énumération fournit différents comportements de mise au point pour la navigation dans les onglets.

Constante	Valeur	Description
`Qt::NoTabFocus`	`0x00`	n'itère rien.
`Qt::TabFocusTextControls`	`0x01`	itère les contrôles et widgets de texte.
`Qt::TabFocusListControls`	`0x02`	itère les contrôles et widgets de liste.
`Qt::TabFocusAllControls`	`0xff`	itérer tous les contrôles et widgets.

enum Qt::TextElideMode

Cette énumération spécifie l'emplacement de l'ellipse lors de l'affichage de textes qui ne tiennent pas en place :

Constante	Valeur	Description
`Qt::ElideLeft`	`0`	L'ellipse doit apparaître au début du texte.
`Qt::ElideRight`	`1`	L'ellipse doit apparaître à la fin du texte.
`Qt::ElideMiddle`	`2`	L'ellipse doit apparaître au milieu du texte.
`Qt::ElideNone`	`3`	L'ellipse ne doit pas apparaître dans le texte. Lorsqu'elle est transmise à des fonctions telles que QFontMetrics::elidedText(), la chaîne complète est renvoyée, à moins que le texte ne contienne des variantes de plusieurs longueurs. Dans ce cas, l'élision doit être faite en coupant à la largeur du composant.

Qt::ElideMiddle est normalement le choix le plus approprié pour les URL (par exemple,"http://bugreports.qt.../QTWEBSITE-13/"), tandis que Qt::ElideRight est approprié pour d'autres chaînes (par exemple,"Deploying Applications on Ma...").

Voir aussi QAbstractItemView::textElideMode, QFontMetrics::elidedText(), AlignmentFlag, et QTabBar::elideMode.

enum Qt::TextFlag

Ce type d'énumération est utilisé pour définir certains indicateurs de modification. Certains de ces indicateurs n'ont de sens que dans le contexte de l'impression :

Constante	Valeur	Description
`Qt::TextSingleLine`	`0x0100`	Traite tous les espaces blancs comme des espaces et n'imprime qu'une seule ligne.
`Qt::TextDontClip`	`0x0200`	S'il est impossible de rester dans les limites données, la ligne est imprimée à l'extérieur.
`Qt::TextExpandTabs`	`0x0400`	Fait passer le caractère U+0009 (tabulation ASCII) au prochain taquet de tabulation.
`Qt::TextShowMnemonic`	`0x0800`	Affiche la chaîne "&P" sous la forme P. Pour une esperluette, utilisez "&&".
`Qt::TextWordWrap`	`0x1000`	Interrompt les lignes aux endroits appropriés, par exemple à la limite des mots.
`Qt::TextWrapAnywhere`	`0x2000`	Casse les lignes n'importe où, même à l'intérieur des mots.
`Qt::TextHideMnemonic`	`0x8000`	Identique à Qt::TextShowMnemonic mais ne dessine pas les soulignements.
`Qt::TextDontPrint`	`0x4000`	Traite ce texte comme "caché" et ne l'imprime pas.
`Qt::TextIncludeTrailingSpaces`	`0x08000000`	Lorsque cette option est activée, QTextLine::naturalTextWidth() et QTextLine::naturalTextRect() renvoient une valeur qui inclut la largeur des espaces de fin de texte ; sinon, cette largeur est exclue.
`Qt::TextJustificationForced`	`0x10000`	Assure que les lignes de texte sont justifiées.

Vous pouvez utiliser autant de drapeaux modificateurs que vous le souhaitez, sauf que Qt::TextSingleLine et Qt::TextWordWrap ne peuvent pas être combinés.

Les drapeaux qui ne conviennent pas à une utilisation donnée sont généralement ignorés.

enum Qt::TextFormat

Cette énumération est utilisée dans les widgets qui peuvent afficher à la fois du texte brut et du texte enrichi, par exemple QLabel. Elle permet de décider si une chaîne de texte doit être interprétée comme l'une ou l'autre. Cela se fait normalement en passant l'une des valeurs de l'énumération à une fonction QStaticText::setTextFormat().

Constante	Valeur	Description
`Qt::PlainText`	`0`	La chaîne de texte est interprétée comme une chaîne de texte simple.
`Qt::RichText`	`1`	La chaîne de texte est interprétée comme une chaîne de texte riche. Voir Supported HTML Subset pour la définition du texte enrichi.
`Qt::AutoText`	`2`	La chaîne de texte est interprétée comme pour Qt::RichText si Qt::mightBeRichText() renvoie `true`, sinon comme Qt::PlainText.
`Qt::MarkdownText`	`3`	La chaîne de texte est interprétée comme du texte formaté Markdown. Cette valeur a été ajoutée dans Qt 5.14.

enum Qt::TextInteractionFlag
flags Qt::TextInteractionFlags

Cette enum spécifie comment un widget d'affichage de texte réagit à la saisie de l'utilisateur.

Constante	Valeur	Description
`Qt::NoTextInteraction`	`0`	Aucune interaction avec le texte n'est possible.
`Qt::TextSelectableByMouse`	`1`	Le texte peut être sélectionné à l'aide de la souris et copié dans le presse-papiers à l'aide d'un menu contextuel ou de raccourcis clavier standard.
`Qt::TextSelectableByKeyboard`	`2`	Le texte peut être sélectionné à l'aide des touches du curseur du clavier. Un curseur de texte est affiché.
`Qt::LinksAccessibleByMouse`	`4`	Les liens peuvent être mis en évidence et activés à l'aide de la souris.
`Qt::LinksAccessibleByKeyboard`	`8`	Les liens peuvent être mis en évidence à l'aide de la touche tabulation et activés à l'aide de la touche Entrée.
`Qt::TextEditable`	`16`	Le texte est entièrement modifiable.
`Qt::TextEditorInteraction`	`TextSelectableByMouse \| TextSelectableByKeyboard \| TextEditable`	La valeur par défaut d'un éditeur de texte.
`Qt::TextBrowserInteraction`	`TextSelectableByMouse \| LinksAccessibleByMouse \| LinksAccessibleByKeyboard`	La valeur par défaut pour QTextBrowser.

Le type TextInteractionFlags est un typedef pour QFlags<TextInteractionFlag>. Il stocke une combinaison OU de valeurs TextInteractionFlag.

enum Qt::TileRule

Cette énumération décrit comment répéter ou étirer les parties d'une image lors du dessin.

Constante	Valeur	Description
`Qt::StretchTile`	`0`	Redimensionne l'image pour qu'elle s'adapte à la zone disponible.
`Qt::RepeatTile`	`1`	Répéter l'image jusqu'à ce qu'il n'y ait plus de place. Peut recadrer la dernière image.
`Qt::RoundTile`	`2`	Semblable à Répéter, mais réduit l'image pour s'assurer que la dernière tuile n'est pas rognée.

enum Qt::TimeSpec

Constante	Valeur	Description de l'heure locale
`Qt::LocalTime`	`0`	Heure locale, contrôlée par le réglage du fuseau horaire du système.
`Qt::UTC`	`1`	Temps universel coordonné.
`Qt::OffsetFromUTC`	`2`	Décalage en secondes par rapport au temps universel coordonné.
`Qt::TimeZone`	`3`	Un fuseau horaire nommé.

LocalTime et TimeZone prennent en charge les transitions, telles que le début et la fin de l'heure d'été. UTC est l'heure standard par rapport à laquelle les fuseaux horaires sont généralement spécifiés : Le décalage par rapport à l'heure de Greenwich est nul. Ni UTC ni OffsetFromUTC n'ont de transitions.

Lorsque l'on spécifie une date à l'aide de OffsetFromUTC, le décalage par rapport à UTC doit également être fourni (il est mesuré en secondes). Pour spécifier une date à l'aide de TimeZone, une adresse QTimeZone doit être fournie. À partir de la version 6.5 de Qt XML, une adresse QTimeZone peut maintenant contenir un timespec avec, le cas échéant, un décalage en tant que description temporelle légère, de sorte que le passage d'une adresse QTimeZone fournit maintenant un moyen uniforme d'utiliser les API de datetime, en évitant d'avoir à les appeler différemment pour des timespecs différents.

Remarque : après une modification du fuseau horaire du système, le comportement des objets QDateTime basés sur LocalTime et créés avant la modification n'est pas défini : QDateTime peut avoir mis en cache des données que la modification invalide. (Ce phénomène n'est pas déclenché par les transitions du fuseau horaire du système.) Dans les processus de longue durée, les mises à jour des données relatives au fuseau horaire du système (par exemple, lorsque les responsables politiques modifient les règles d'une zone) peuvent également entraîner des conflits entre les informations relatives au fuseau horaire mises à jour et les données mises en cache par les objets QDateTime créés avant la mise à jour, en utilisant soit LocalTime, soit TimeZone.

Voir également QTimeZone et QDateTime.

`[since 6.8]` enum class TimerId

Il est utilisé pour représenter les identifiants de minuterie (par exemple, QTimer et QChronoTimer). Le type sous-jacent est int. Vous pouvez utiliser qToUnderlying() pour convertir Qt::TimerId en int.

Constante	Valeur	Description
`QObject::TimerId::Invalid`	`0`	Représente l'ID d'une minuterie non active ; son utilisation dépend du contexte, par exemple, c'est la valeur renvoyée par QObject::startTimer() pour indiquer qu'il n'a pas réussi à démarrer une minuterie ; tandis que QChronoTimer::id() renvoie cette valeur lorsque la minuterie est inactive, c'est-à-dire que `timer.isActive()` renvoie `false`.

Cette liste a été introduite dans Qt 6.8.

Voir également QTimer::id(), QChronoTimer::id() et QObject::startTimer().

enum Qt::TimerType

Le type de minuterie indique le degré de précision de la minuterie.

Constante	Valeur	Description du type de minuterie
`Qt::PreciseTimer`	`0`	Les temporisateurs précis tentent de conserver une précision de l'ordre de la milliseconde.
`Qt::CoarseTimer`	`1`	Les minuteries grossières tentent de conserver une précision de 5 % de l'intervalle souhaité.
`Qt::VeryCoarseTimer`	`2`	Les temporisateurs très grossiers ne conservent que la précision de la seconde entière.

Sous UNIX (y compris Linux, macOS et iOS), Qt conservera une précision de l'ordre de la milliseconde pour Qt::PreciseTimer. Pour Qt::CoarseTimer, l'intervalle sera ajusté jusqu'à 5% pour aligner la minuterie avec d'autres minuteries qui sont censées se déclencher au même moment ou à peu près. L'objectif est de faire en sorte que la plupart des minuteries se réveillent en même temps, réduisant ainsi les réveils du processeur et la consommation d'énergie.

Sous Windows, Qt utilisera la fonction de minuterie Multimedia de Windows (si elle est disponible) pour Qt::PreciseTimer et les minuteries Windows normales pour Qt::CoarseTimer et Qt::VeryCoarseTimer.

Sur toutes les plates-formes, l'intervalle de Qt::VeryCoarseTimer est arrondi à la seconde la plus proche (par exemple, un intervalle de 23500ms sera arrondi à 24000ms, et 20300ms à 20000ms).

enum Qt::ToolBarArea
drapeaux Qt::ToolBarAreas

Constante	Valeur
`Qt::LeftToolBarArea`	`0x1`
`Qt::RightToolBarArea`	`0x2`
`Qt::TopToolBarArea`	`0x4`
`Qt::BottomToolBarArea`	`0x8`
`Qt::AllToolBarAreas`	`ToolBarArea_Mask`
`Qt::NoToolBarArea`	`0`

Le type ToolBarAreas est un typedef pour QFlags<ToolBarArea>. Il stocke une combinaison OR de valeurs ToolBarArea.

enum Qt::ToolButtonStyle

Le style du bouton d'outil, décrivant comment le texte et l'icône du bouton doivent être affichés.

Constante	Valeur	Description
`Qt::ToolButtonIconOnly`	`0`	Affiche uniquement l'icône.
`Qt::ToolButtonTextOnly`	`1`	Affiche uniquement le texte.
`Qt::ToolButtonTextBesideIcon`	`2`	Le texte apparaît à côté de l'icône.
`Qt::ToolButtonTextUnderIcon`	`3`	Le texte apparaît sous l'icône.
`Qt::ToolButtonFollowStyle`	`4`	Suivre les indications de style.

enum Qt::TouchPointState
flags Qt::TouchPointStates

Cette énumération représente l'état d'un point de contact au moment où QTouchEvent s'est produit.

Constante	Valeur	Description
`Qt::TouchPointUnknownState`	`0x00`	L'état du point de contact n'est pas connu.
`Qt::TouchPointPressed`	`0x01`	Le point de contact est maintenant enfoncé.
`Qt::TouchPointMoved`	`0x02`	Le point de contact s'est déplacé.
`Qt::TouchPointStationary`	`0x04`	Le point de contact n'a pas bougé.
`Qt::TouchPointReleased`	`0x08`	Le point de contact a été relâché.

Le type TouchPointStates est un typedef pour QFlags<TouchPointState>. Il stocke une combinaison OU de valeurs TouchPointState.

enum Qt::TransformationMode

Ce type d'énumération définit si les transformations de l'image (par exemple, la mise à l'échelle) doivent être lisses ou non.

Constante	Valeur	Description
`Qt::FastTransformation`	`0`	La transformation est effectuée rapidement, sans lissage.
`Qt::SmoothTransformation`	`1`	L'image résultante est transformée à l'aide d'un filtrage bilinéaire.

Voir également QImage::scaled().

enum Qt::UIEffect

Cette énumération décrit les effets d'interface utilisateur disponibles.

Par défaut, Qt essaiera d'utiliser les paramètres de bureau spécifiques à la plate-forme pour chaque effet. Utilisez la fonction QApplication::setDesktopSettingsAware() (en passant false comme argument) pour empêcher cela, et la fonction QApplication::setEffectEnabled() pour activer ou désactiver un effet particulier.

Notez que tous les effets sont désactivés sur les écrans fonctionnant avec une profondeur de couleur inférieure à 16 bits.

Constante	Valeur	Description
`Qt::UI_AnimateMenu`	`1`	Affiche les menus animés.
`Qt::UI_FadeMenu`	`2`	Afficher les menus estompés.
`Qt::UI_AnimateCombo`	`3`	Afficher les comboboxes animés.
`Qt::UI_AnimateTooltip`	`4`	Afficher les animations des info-bulles.
`Qt::UI_FadeTooltip`	`5`	Afficher les effets de fondu de l'infobulle.
`Qt::UI_AnimateToolBox`	`6`	Réservé

Voir aussi QApplication::setEffectEnabled() et QGuiApplication::setDesktopSettingsAware().

enum Qt::WhiteSpaceMode

Cette énumération décrit les types de mode d'espacement utilisés par la classe QTextDocument pour répondre aux exigences des différents types d'informations textuelles.

Constante	Valeur	Description
`Qt::WhiteSpaceNormal`	`0`	Le mode d'espacement utilisé pour afficher du texte normal enveloppé de mots dans des paragraphes.
`Qt::WhiteSpacePre`	`1`	Mode de texte préformaté dans lequel les espaces blancs sont reproduits à l'identique.
`Qt::WhiteSpaceNoWrap`	`2`

enum Qt::WidgetAttribute

Ce type d'énumération est utilisé pour spécifier divers attributs de widget. Les attributs sont définis et effacés à l'aide de QWidget::setAttribute() et interrogés à l'aide de QWidget::testAttribute(), bien que certains d'entre eux aient des fonctions spéciales de commodité qui sont mentionnées ci-dessous.

Constante	Valeur	Description de l'attribut
`Qt::WA_AcceptDrops`	`78`	Permet aux données provenant d'opérations de glisser-déposer d'être déposées sur le widget (voir QWidget::setAcceptDrops()).
`Qt::WA_AlwaysShowToolTips`	`84`	Active les infobulles pour les fenêtres inactives.
`Qt::WA_CustomWhatsThis`	`47`	Indique que le widget veut continuer à fonctionner normalement en mode "Qu'est-ce que c'est ? Ce mode est défini par l'auteur du widget.
`Qt::WA_DeleteOnClose`	`55`	Fait en sorte que Qt Widgets supprime ce widget lorsque celui-ci a accepté l'événement de fermeture (voir QWidget::closeEvent()).
`Qt::WA_Disabled`	`0`	Indique que le widget est désactivé, c'est-à-dire qu'il ne reçoit aucun événement de souris ou de clavier. Il existe également une fonction getter QWidget::isEnabled(). Cette valeur est définie/nettoyée par le noyau Qt.
`Qt::WA_DontShowOnScreen`	`103`	Indique que le widget est caché ou ne fait pas partie du bureau visible.
`Qt::WA_ForceDisabled`	`32`	Indique que le widget est explicitement désactivé, c'est-à-dire qu'il restera désactivé même si tous ses ancêtres sont activés. Cela implique WA_Disabled. Il est activé/désactivé par QWidget::setEnabled() et QWidget::setDisabled().
`Qt::WA_ForceUpdatesDisabled`	`59`	Indique que les mises à jour sont explicitement désactivées pour le widget, c'est-à-dire qu'il restera désactivé même si tous ses ancêtres sont activés pour les mises à jour. Cela implique WA_UpdatesDisabled. Il est activé/désactivé par QWidget::setUpdatesEnabled().
`Qt::WA_Hover`	`74`	Force Qt à générer des événements de peinture lorsque la souris entre ou sort du widget. Cette fonctionnalité est typiquement utilisée lors de l'implémentation de styles personnalisés.
`Qt::WA_InputMethodEnabled`	`14`	Active les méthodes de saisie pour les langues asiatiques. Doit être défini lors de la création de widgets d'édition de texte personnalisés.
`Qt::WA_KeyboardFocusChange`	`77`	Défini sur une fenêtre de niveau supérieur lorsque l'utilisateur change le focus avec le clavier (tabulation, backtab, ou raccourci).
`Qt::WA_KeyCompression`	`33`	Active la compression des événements clavier si elle est activée, et la désactive si elle n'est pas activée. Par défaut, la compression des touches est désactivée, de sorte que les widgets reçoivent un événement de pression de touche pour chaque pression de touche (ou plus, puisque la répétition automatique est généralement activée). Si vous l'activez et que votre programme ne suit pas la saisie des touches, Qt peut essayer de compresser les événements de touche de sorte que plus d'un caractère puisse être traité dans chaque événement. Par exemple, un widget de traitement de texte peut recevoir 2, 3 ou plus de caractères dans chaque QKeyEvent::text(), si le recalcul de la disposition prend trop de temps pour le processeur. Si un widget prend en charge l'entrée de plusieurs caractères unicode, il est toujours prudent d'activer la compression. Qt XML n'effectue la compression des événements de touches que pour les caractères imprimables. Les touches Qt::Modifier, les touches de déplacement du curseur, les touches de fonction et les diverses touches d'action (par exemple, Escape, Enter, Backspace, PrintScreen) arrêteront la compression des événements de touches, même s'il y a des événements de touches plus compressibles disponibles. Les plateformes autres que Mac et X11 ne supportent pas cette compression, auquel cas l'activer n'aura aucun effet. C'est l'auteur du widget qui l'active ou le désactive.
`Qt::WA_LayoutOnEntireRect`	`48`	Indique que le widget veut que QLayout opère sur l'ensemble de QWidget::rect(), et pas seulement sur QWidget::contentsRect(). Ce paramètre est défini par l'auteur du widget.
`Qt::WA_LayoutUsesWidgetRect`	`92`	Ignorer l'élément de mise en page rect du style lors de la mise en page de ce widget avec QLayout.
`Qt::WA_MacOpaqueSizeGrip`	`85`	Indique que la poignée de taille native doit être opaque au lieu d'être transparente (par défaut). Cet attribut ne s'applique qu'à macOS et est défini par l'auteur du widget.
`Qt::WA_MacShowFocusRect`	`88`	Indique que ce widget doit être entouré d'un QFocusFrame. Certains widgets dessinent leur propre halo de mise au point sans tenir compte de cet attribut. Il ne faut pas oublier que l'adresse QWidget::focusPolicy joue également un rôle important dans l'attribution ou non du focus, cet attribut permet uniquement de contrôler si le widget obtient ou non le cadre de focus. Cet attribut ne s'applique qu'à macOS.
`Qt::WA_MacNormalSize`	`89`	Indique que le widget doit avoir la taille normale des widgets sous macOS. Cet attribut ne s'applique qu'à macOS.
`Qt::WA_MacSmallSize`	`90`	Indique que le widget doit avoir la petite taille prévue pour les widgets dans macOS. Cet attribut ne s'applique qu'à macOS.
`Qt::WA_MacMiniSize`	`91`	Indique que le widget doit avoir la taille mini pour les widgets dans macOS. Cet attribut ne s'applique qu'à macOS.
`Qt::WA_Mapped`	`11`	Indique que le widget est mappé à l'écran. Cet attribut est activé/désactivé par le noyau Qt.
`Qt::WA_MouseNoMask`	`71`	Fait en sorte que le widget reçoive des événements de souris pour l'ensemble du widget, indépendamment du masque actuellement défini, en surchargeant QWidget::setMask(). Ceci n'est pas applicable aux fenêtres de premier niveau.
`Qt::WA_MouseTracking`	`2`	Indique que le suivi de la souris est activé dans le widget. Voir QWidget::mouseTracking.
`Qt::WA_Moved`	`43`	Indique que le widget a une position explicite. Cette position est définie/nettoyée par QWidget::move() et par QWidget::setGeometry().
`Qt::WA_NoChildEventsForParent`	`58`	Indique que le widget ne veut pas que les événements ChildAdded ou ChildRemoved soient envoyés à son parent. Cela est rarement nécessaire, mais peut permettre d'éviter l'insertion automatique de widgets tels que les splitters et les layouts. Ce paramètre est défini par l'auteur du widget.
`Qt::WA_NoChildEventsFromChildren`	`39`	Indique que le widget ne veut pas recevoir les événements ChildAdded ou ChildRemoved envoyés par ses enfants. Ce paramètre est défini par l'auteur du widget.
`Qt::WA_NoMouseReplay`	`54`	Utilisé pour les widgets pop-up. Indique que l'événement de pression de la souris le plus récent ne doit pas être rejoué lorsque le widget pop-up se ferme. Ce drapeau est défini par l'auteur du widget et effacé par le noyau Qt chaque fois que le widget reçoit un nouvel événement de souris.
`Qt::WA_NoMousePropagation`	`73`	Interdit la propagation des événements de souris au parent du widget. Cet attribut est désactivé par défaut.
`Qt::WA_TransparentForMouseEvents`	`51`	Lorsqu'il est activé, cet attribut désactive la transmission des événements de souris au widget et à ses enfants. Les événements liés à la souris sont transmis aux autres widgets comme si le widget et ses enfants n'étaient pas présents dans la hiérarchie des widgets ; les clics de souris et autres événements les "traversent" effectivement. Cet attribut est désactivé par défaut.
`Qt::WA_NoSystemBackground`	`9`	Indique que le widget n'a pas d'arrière-plan, c'est-à-dire que lorsque le widget reçoit des événements de peinture, l'arrière-plan n'est pas automatiquement repeint. Remarque: contrairement à WA_OpaquePaintEvent, les zones nouvellement exposées ne sont jamais remplies par l'arrière-plan (par exemple, après avoir affiché une fenêtre pour la première fois, l'utilisateur peut voir "à travers" jusqu'à ce que l'application traite les événements de peinture). Ce drapeau est activé ou désactivé par l'auteur du widget.
`Qt::WA_OpaquePaintEvent`	`4`	Indique que le widget peint tous ses pixels lorsqu'il reçoit un événement de peinture. Il n'est donc pas nécessaire, pour des opérations telles que la mise à jour, le redimensionnement, le défilement et les changements de focus, d'effacer le widget avant de générer des événements de peinture. L'utilisation de WA_OpaquePaintEvent permet une petite optimisation en aidant à réduire le scintillement sur les systèmes qui ne supportent pas le double tampon et en évitant les cycles de calcul nécessaires pour effacer l'arrière-plan avant de peindre. Note: Contrairement à WA_NoSystemBackground, WA_OpaquePaintEvent s'efforce d'éviter les arrière-plans de fenêtre transparents. Ce drapeau est activé ou désactivé par l'auteur du widget.
`Qt::WA_OutsideWSRange`	`49`	Indique que le widget est en dehors de la plage valide du système de coordonnées du système de fenêtres. Un widget en dehors de la plage valide ne peut pas être mappé à l'écran. Ce paramètre est activé/désactivé par le noyau Qt.
`Qt::WA_PaintOnScreen`	`8`	Indique que le widget veut dessiner directement sur l'écran. Les widgets ayant cet attribut ne participent pas à la gestion de la composition, c'est-à-dire qu'ils ne peuvent pas être semi-transparents ou briller à travers des widgets semi-transparents qui se chevauchent. Remarque: cet attribut n'est pris en charge que sur X11 et il désactive la double mise en mémoire tampon. Sur Qt Widgets pour Linux embarqué, l'indicateur ne fonctionne que lorsqu'il est défini sur un widget de niveau supérieur et il dépend de la prise en charge par le pilote d'écran actif. Ce drapeau est activé ou désactivé par l'auteur du widget. Pour effectuer un rendu en dehors du système de peinture de Qt, par exemple si vous avez besoin de primitives de peinture natives, vous devez réimplémenter QWidget::paintEngine() pour qu'il renvoie 0 et active ce drapeau.
`Qt::WA_PaintUnclipped`	`52`	Rend tous les peintres opérant sur ce widget déclipsés. Les enfants de ce widget ou d'autres widgets situés devant lui n'écrêtent pas la zone sur laquelle le peintre peut peindre. Ce drapeau n'est supporté que pour les widgets dont le drapeau WA_PaintOnScreen est activé. La meilleure façon de procéder est de créer un widget transparent qui se trouve devant les autres widgets.
`Qt::WA_PendingMoveEvent`	`34`	Indique qu'un événement de déplacement est en attente, par exemple lorsqu'un widget caché a été déplacé. Ce drapeau est activé ou désactivé par le noyau Qt.
`Qt::WA_PendingResizeEvent`	`35`	Indique qu'un événement de redimensionnement est en attente, par exemple lorsqu'un widget caché a été redimensionné. Ce drapeau est activé ou désactivé par le noyau Qt.
`Qt::WA_QuitOnClose`	`76`	Indique que le widget doit être pris en compte pour décider de quitter l'application lorsque la dernière fenêtre est fermée. Ce comportement peut être modifié à l'aide de la propriété QGuiApplication::quitOnLastWindowClosed. Par défaut, cet attribut est défini pour tous les widgets de type Qt::Window.
`Qt::WA_Resized`	`42`	Indique que le widget a une taille explicite. Cet indicateur est activé ou désactivé par QWidget::resize() et QWidget::setGeometry().
`Qt::WA_RightToLeft`	`56`	Indique que la direction de la mise en page du widget est de droite à gauche.
`Qt::WA_SetCursor`	`38`	Indique que le widget possède son propre curseur. Cet indicateur est activé ou désactivé par QWidget::setCursor() et QWidget::unsetCursor().
`Qt::WA_SetFont`	`37`	Indique que le widget possède sa propre police de caractères. Cet indicateur est activé ou désactivé par QWidget::setFont().
`Qt::WA_SetPalette`	`36`	Indique que le widget possède sa propre palette. Cet indicateur est activé ou désactivé par QWidget::setPalette().
`Qt::WA_SetStyle`	`86`	Indique que le widget a son propre style. Cet indicateur est activé ou désactivé par QWidget::setStyle().
`Qt::WA_ShowModal`	`70`	Cet attribut est obsolète. Utilisez plutôt QWidget::windowModality.
`Qt::WA_StaticContents`	`5`	Indique que le contenu du widget est aligné sur le nord-ouest et statique. Lors d'un redimensionnement, un tel widget ne recevra des événements de peinture que pour les parties de lui-même qui sont nouvellement visibles. Ce drapeau est activé ou désactivé par l'auteur du widget.
`Qt::WA_StyleSheet`	`97`	Indique que le widget est stylé à l'aide d'une feuille de style. WA_StyleSheet est défini chaque fois qu'un widget est soumis à une feuille de style, même si la feuille de style n'a pas affecté l'apparence du widget.
`Qt::WA_StyleSheetTarget`	`131`	Indique que l'apparence du widget a été modifiée par une feuille de style. WA_StyleSheet sera également défini. Cette valeur a été introduite dans Qt 5.12.
`Qt::WA_TabletTracking`	`129`	Indique que le suivi de la tablette est activé dans le widget. Voir QWidget::tabletTracking.
`Qt::WA_TranslucentBackground`	`120`	Indique que le widget doit avoir un arrière-plan translucide, c'est-à-dire que toutes les régions non opaques du widget seront translucides parce que le widget aura un canal alpha. La définition de ce drapeau entraîne la définition de WA_NoSystemBackground. Sous Windows, le widget a également besoin que l'indicateur de fenêtre Qt::FramelessWindowHint soit activé. Ce drapeau est activé ou désactivé par l'auteur du widget. Depuis la version 5.0 de Qt Widgets, le basculement de cet attribut après l'affichage du widget n'est pas pris en charge de manière uniforme sur toutes les plates-formes. Si vous souhaitez un arrière-plan translucide, définissez l'attribut dès la création du widget et évitez de le modifier par la suite.
`Qt::WA_UnderMouse`	`1`	Indique que le widget se trouve sous le curseur de la souris. La valeur n'est pas mise à jour correctement lors des opérations de glisser-déposer. Il existe également une fonction d'obtention, QWidget::underMouse(). Ce drapeau est activé ou désactivé par le noyau Qt.
`Qt::WA_UpdatesDisabled`	`10`	Indique que les mises à jour sont bloquées (y compris l'arrière-plan du système). Cet indicateur est activé ou désactivé par le noyau Qt. Attention: Ce drapeau ne doit jamais être activé ou désactivé par l'auteur du widget.
`Qt::WA_WindowModified`	`41`	Indique que la fenêtre est marquée comme modifiée. Sur certaines plateformes, ce drapeau ne fera rien, sur d'autres (y compris macOS et Windows) la fenêtre prendra une apparence modifiée. Cet indicateur est activé ou désactivé par QWidget::setWindowModified().
`Qt::WA_WindowPropagation`	`80`	Fait en sorte qu'une fenêtre de niveau supérieur hérite de la police, de la palette et de la locale de son parent.
`Qt::WA_MacAlwaysShowToolWindow`	`96`	Sous macOS, affiche la fenêtre d'outils même lorsque l'application n'est pas active. Par défaut, toutes les fenêtres d'outils sont masquées lorsque l'application est inactive.
`Qt::WA_SetLocale`	`87`	Indique que la locale doit être prise en compte dans le widget.
`Qt::WA_StyledBackground`	`93`	Indique que le widget doit être dessiné à l'aide d'un arrière-plan stylisé.
`Qt::WA_ShowWithoutActivating`	`98`	Affiche le widget sans le rendre actif.
`Qt::WA_NativeWindow`	`100`	Indique qu'une fenêtre native est créée pour le widget. L'activation de ce drapeau forcera également la création d'une fenêtre native pour les ancêtres du widget, à moins que Qt::WA_DontCreateNativeAncestors ne soit défini.
`Qt::WA_DontCreateNativeAncestors`	`101`	Indique que les ancêtres du widget sont maintenus non natifs même si le widget lui-même est natif.
`Qt::WA_X11NetWmWindowTypeDesktop`	`104`	Ajoute _NET_WM_WINDOW_TYPE_DESKTOP à la propriété de fenêtre X11 _NET_WM_WINDOW_TYPE. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11.
`Qt::WA_X11NetWmWindowTypeDock`	`105`	Ajoute _NET_WM_WINDOW_TYPE_DOCK à la propriété _NET_WM_WINDOW_TYPE X11 de la fenêtre. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11.
`Qt::WA_X11NetWmWindowTypeToolBar`	`106`	Ajoute _NET_WM_WINDOW_TYPE_TOOLBAR à la propriété _NET_WM_WINDOW_TYPE X11 de la fenêtre. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt définit automatiquement cet attribut pour QToolBar.
`Qt::WA_X11NetWmWindowTypeMenu`	`107`	Ajoute _NET_WM_WINDOW_TYPE_MENU à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt définit automatiquement cet attribut pour QMenu lorsqu'elle est éteinte.
`Qt::WA_X11NetWmWindowTypeUtility`	`108`	Ajoute _NET_WM_WINDOW_TYPE_UTILITY à la propriété de fenêtre X11 _NET_WM_WINDOW_TYPE. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Note: Qt définit automatiquement cet attribut pour le type de fenêtre Qt::Tool.
`Qt::WA_X11NetWmWindowTypeSplash`	`109`	Ajoute _NET_WM_WINDOW_TYPE_SPLASH à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Note: Qt définit automatiquement cet attribut pour le type de fenêtre Qt::SplashScreen.
`Qt::WA_X11NetWmWindowTypeDialog`	`110`	Ajoute _NET_WM_WINDOW_TYPE_DIALOG à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt définit automatiquement cet attribut pour les types de fenêtres Qt::Dialog et Qt::Sheet.
`Qt::WA_X11NetWmWindowTypeDropDownMenu`	`111`	Ajoute _NET_WM_WINDOW_TYPE_DROPDOWN_MENU à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt XML définit automatiquement cet attribut pour les objets QMenu ajoutés à une fenêtre QMenuBar.
`Qt::WA_X11NetWmWindowTypePopupMenu`	`112`	Ajoute _NET_WM_WINDOW_TYPE_POPUP_MENU à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt définit automatiquement cet attribut pour QMenu.
`Qt::WA_X11NetWmWindowTypeToolTip`	`113`	Ajoute _NET_WM_WINDOW_TYPE_TOOLTIP à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Note: Qt définit automatiquement cet attribut pour le type de fenêtre Qt::ToolTip.
`Qt::WA_X11NetWmWindowTypeNotification`	`114`	Ajoute _NET_WM_WINDOW_TYPE_NOTIFICATION à la propriété _NET_WM_WINDOW_TYPE X11 de la fenêtre. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11.
`Qt::WA_X11NetWmWindowTypeCombo`	`115`	Ajoute _NET_WM_WINDOW_TYPE_COMBO à la propriété _NET_WM_WINDOW_TYPE X11 de la fenêtre. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt XML définit automatiquement cet attribut pour la fenêtre contextuelle QComboBox.
`Qt::WA_X11NetWmWindowTypeDND`	`116`	Ajoute _NET_WM_WINDOW_TYPE_DND à la propriété _NET_WM_WINDOW_TYPE de la fenêtre X11. Voir http://standards.freedesktop.org/wm-spec/ pour plus de détails. Cet attribut n'a aucun effet sur les plates-formes non X11. Remarque: Qt Widgets définit automatiquement cet attribut sur le widget de retour d'information utilisé lors d'un glisser.
`Qt::WA_AcceptTouchEvents`	`121`	Permet d'envoyer des événements tactiles (voir QTouchEvent) au widget. Cet attribut doit être défini sur tous les widgets qui peuvent gérer des événements tactiles. Si cet attribut n'est pas défini, les événements provenant d'un périphérique tactile seront envoyés en tant qu'événements de souris.
`Qt::WA_TouchPadAcceptSingleTouchEvents`	`123`	Permet d'envoyer au widget les événements de toucher unique du pavé tactile.
`Qt::WA_X11DoNotAcceptFocus`	`126`	Demande au gestionnaire de fenêtres de ne pas donner le focus à cette fenêtre de premier niveau. Cet attribut n'a aucun effet sur les plates-formes non X11.
`Qt::WA_AlwaysStackOnTop (since Qt 5.4)`	`128`	Oblige QOpenGLWidget et QQuickWidget à être dessinés en dernier, avant les autres widgets. Ignoré pour les autres types de widgets. La définition de cet attribut rompt l'ordre d'empilement, mais permet d'avoir un widget OpenGL semi-transparent avec d'autres widgets visibles en dessous. Il est fortement recommandé d'appeler update() sur la fenêtre de premier niveau du widget après avoir activé ou désactivé cet attribut.
`Qt::WA_ContentsMarginsRespectsSafeArea`	`130`	Un QWidget respecte les marges de sécurité d'une fenêtre en les incorporant par défaut dans les marges de son contenu. Cela signifie qu'un QLayout utilisera la zone de contenu d'un widget pour sa mise en page, à moins que l'attribut Qt::WA_LayoutOnEntireRect ne soit défini. Ceci, ainsi qu'une marge de contenu de 0, peut être utilisé sur la disposition réelle, pour permettre par exemple à une image de fond de recouvrir la barre d'état et d'autres zones du système sur un appareil iOS, tout en permettant aux widgets enfants de ce fond d'être insérés sur la base de la zone de sécurité.

enum Qt::WindowFrameSection

Cette énumération est utilisée pour décrire les parties d'un cadre de fenêtre. Elle est renvoyée par QGraphicsWidget::windowFrameSectionAt() pour décrire la section du cadre de la fenêtre qui se trouve sous la souris.

Constante	Valeur
`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`

Voir aussi QGraphicsWidget::windowFrameEvent(), QGraphicsWidget::paintWindowFrame() et QGraphicsWidget::windowFrameSectionAt().

enum Qt::WindowModality

Cette énumération spécifie le comportement d'une fenêtre modale. Une fenêtre modale est une fenêtre qui bloque l'entrée des autres fenêtres. Les fenêtres qui sont des enfants d'une fenêtre modale ne sont pas bloquées.

Les valeurs sont les suivantes :

Constante	Valeur	Description
`Qt::NonModal`	`0`	La fenêtre n'est pas modale et ne bloque pas la saisie des autres fenêtres.
`Qt::WindowModal`	`1`	La fenêtre est modale par rapport à une hiérarchie de fenêtres unique et bloque la saisie de sa fenêtre parentale, de toutes les fenêtres grand-parentales et de tous les frères et sœurs de sa fenêtre parentale et de ses fenêtres grand-parentales.
`Qt::ApplicationModal`	`2`	La fenêtre est modale par rapport à l'application et bloque l'accès à toutes les fenêtres.

Voir également QWidget::windowModality et QDialog.

enum Qt::WindowState
flags Qt::WindowStates

Ce type d'énumération est utilisé pour spécifier l'état actuel d'une fenêtre de niveau supérieur.

Les états sont les suivants

Constante	Valeur	Description de l'état
`Qt::WindowNoState`	`0x00000000`	La fenêtre n'a pas d'état défini (état normal).
`Qt::WindowMinimized`	`0x00000001`	La fenêtre est réduite (c'est-à-dire iconifiée).
`Qt::WindowMaximized`	`0x00000002`	La fenêtre est maximisée avec un cadre autour d'elle.
`Qt::WindowFullScreen`	`0x00000004`	La fenêtre remplit tout l'écran sans aucun cadre autour d'elle.
`Qt::WindowActive`	`0x00000008`	La fenêtre est la fenêtre active, c'est-à-dire qu'elle a le focus clavier.

Le type WindowStates est un typedef pour QFlags<WindowState>. Il stocke une combinaison OR de valeurs WindowState.

enum Qt::WindowType
flags Qt::WindowFlags

Ce type d'énumération est utilisé pour spécifier diverses propriétés du système de fenêtres pour le widget. Elles sont assez inhabituelles mais nécessaires dans certains cas. Certains de ces drapeaux dépendent de leur prise en charge par le gestionnaire de fenêtres sous-jacent.

Les principaux types sont

Constante	Valeur	Description
`Qt::Widget`	`0x00000000`	Il s'agit du type par défaut pour QWidget. Les widgets de ce type sont des widgets enfants s'ils ont un parent, et des fenêtres indépendantes s'ils n'ont pas de parent. Voir aussi Qt::Window et Qt::SubWindow.
`Qt::Window`	`0x00000001`	Indique que le widget est une fenêtre, généralement avec un cadre de système de fenêtre et une barre de titre, indépendamment du fait que le widget ait un parent ou non. Notez qu'il n'est pas possible de désactiver ce drapeau si le widget n'a pas de parent.
`Qt::Dialog`	`0x00000002 \| Window`	Indique que le widget est une fenêtre qui doit être décorée comme une boîte de dialogue (c'est-à-dire qu'il n'y a généralement pas de boutons d'agrandissement ou de réduction dans la barre de titre). Il s'agit du type par défaut pour QDialog. Si vous souhaitez l'utiliser comme une boîte de dialogue modale, il doit être lancé à partir d'une autre fenêtre ou avoir un parent et être utilisé avec la propriété QWidget::windowModality. Si vous la rendez modale, la boîte de dialogue empêchera les autres fenêtres de premier niveau de l'application de recevoir des données. Nous appelons fenêtre secondaire une fenêtre de premier niveau qui a un parent.
`Qt::Sheet`	`0x00000004 \| Window`	Indique que la fenêtre est une feuille sous macOS. Comme l'utilisation d'une feuille implique la modalité de la fenêtre, il est recommandé d'utiliser QWidget::setWindowModality(), ou QDialog::open(), à la place.
`Qt::Drawer`	`Sheet \| Dialog`	Indique que le widget est un tiroir sous macOS. Cette fonctionnalité est obsolète. La définition de ce drapeau n'a aucun effet.
`Qt::Popup`	`0x00000008 \| Window`	Indique que le widget est une fenêtre pop-up de premier niveau, c'est-à-dire qu'il est modal, mais qu'il possède un cadre de système de fenêtres approprié pour les menus pop-up.
`Qt::Tool`	`Popup \| Dialog`	Indique que le widget est une fenêtre d'outil. Une fenêtre d'outil est souvent une petite fenêtre avec une barre de titre et une décoration plus petites que d'habitude, généralement utilisée pour des collections de boutons d'outils. S'il existe un parent, la fenêtre d'outil sera toujours placée au-dessus de celui-ci. S'il n'y a pas de parent, vous pouvez envisager d'utiliser Qt::WindowStaysOnTopHint. Si le système de fenêtres le permet, une fenêtre d'outil peut être décorée avec un cadre un peu plus léger. Elle peut également être combinée avec Qt::FramelessWindowHint. Sur macOS, les fenêtres d'outils correspondent à la classe de fenêtres NSPanel. Cela signifie que la fenêtre se situe à un niveau supérieur aux fenêtres normales, ce qui rend impossible l'installation d'une fenêtre normale au-dessus d'elle. Par défaut, les fenêtres d'outils disparaissent lorsque l'application est inactive. Ceci peut être contrôlé par l'attribut Qt::WA_MacAlwaysShowToolWindow.
`Qt::ToolTip`	`Popup \| Sheet`	Indique que le widget est une infobulle. Cet attribut est utilisé en interne pour implémenter tooltips.
`Qt::SplashScreen`	`ToolTip \| Dialog`	Indique que la fenêtre est un écran de démarrage. Il s'agit du type par défaut pour QSplashScreen.
`Qt::SubWindow`	`0x00000012`	Indique que ce widget est une sous-fenêtre, telle qu'un widget QMdiSubWindow.
`Qt::ForeignWindow`	`0x00000020 \| Window`	Indique que cet objet fenêtre est une poignée représentant une fenêtre de plate-forme native créée par un autre processus ou manuellement à l'aide d'un code natif.
`Qt::CoverWindow`	`0x00000040 \| Window`	Indique que la fenêtre représente une fenêtre de couverture, qui s'affiche lorsque l'application est réduite sur certaines plates-formes.

Il existe également un certain nombre de drapeaux que vous pouvez utiliser pour personnaliser l'apparence des fenêtres de premier niveau. Ces drapeaux n'ont aucun effet sur les autres fenêtres :

Constante	Valeur	Description
`Qt::MSWindowsFixedSizeDialogHint`	`0x00000100`	Donne à la fenêtre une fine bordure de dialogue sur Windows. Ce style est traditionnellement utilisé pour les boîtes de dialogue de taille fixe.

Remarque : l'utilisation de cet indicateur n'est pas recommandée dans les environnements multi-moniteurs. En effet, le système veille à ce que la fenêtre conserve sa taille d'origine lorsqu'elle est déplacée d'un écran à l'autre. Ceci est particulièrement indésirable lorsque l'on utilise des moniteurs ayant des résolutions différentes.

Constante	Valeur	Description
`Qt::MSWindowsOwnDC`	`0x00000200`	Donne à la fenêtre son propre contexte d'affichage sous Windows.
`Qt::BypassWindowManagerHint`	`0x00000400`	Ce drapeau peut être utilisé pour indiquer au plugin de plateforme que "tous" les protocoles de gestion de fenêtres doivent être désactivés. Cet indicateur se comportera différemment selon le système d'exploitation sur lequel l'application est exécutée et le gestionnaire de fenêtres en cours d'exécution. Il peut être utilisé pour obtenir une fenêtre native sans configuration.
`Qt::X11BypassWindowManagerHint`	`BypassWindowManagerHint`	Contourner complètement le gestionnaire de fenêtres. Il en résulte une fenêtre sans bordures qui n'est pas gérée du tout (c'est-à-dire qu'il n'y a pas de saisie au clavier à moins que vous n'appeliez QWidget::activateWindow() manuellement).
`Qt::FramelessWindowHint`	`0x00000800`	Produit une fenêtre sans bordure.

Sur X11, le résultat de l'indicateur dépend du gestionnaire de fenêtres et de sa capacité à comprendre les indices Motif et/ou NETWM. La plupart des gestionnaires de fenêtres modernes existants peuvent gérer cela.

Remarque : si le gestionnaire de fenêtres s'appuie sur le cadre pour manipuler la fenêtre de manière interactive, l'utilisateur ne peut plus déplacer ou redimensionner la fenêtre via le système de fenêtres, mais il ne faut pas compter sur cet effet secondaire. Pour produire une fenêtre de taille fixe qui ne peut pas être redimensionnée, veuillez définir QWindow::setMinimumSize() et QWindow::setMaximumSize() à la même taille.

Constante	Valeur	Description
`Qt::NoDropShadowWindowHint`	`0x40000000`	Désactive l'ombre portée de la fenêtre sur les plates-formes compatibles.

L'indicateur CustomizeWindowHint est utilisé pour permettre la personnalisation des contrôles de la fenêtre. Cet indicateur doit être défini pour que les indicateurs WindowTitleHint, WindowSystemMenuHint, WindowMinimizeButtonHint, WindowMaximizeButtonHint et WindowCloseButtonHint puissent être modifiés.

Constante	Valeur	Description de la constante
`Qt::CustomizeWindowHint`	`0x02000000`	Désactive les indications de titre par défaut de la fenêtre.
`Qt::WindowTitleHint`	`0x00001000`	Donne une barre de titre à la fenêtre.
`Qt::WindowSystemMenuHint`	`0x00002000`	Ajoute un menu système pour la fenêtre, et éventuellement un bouton de fermeture (par exemple sur Mac). Si vous devez masquer ou afficher un bouton de fermeture, il est plus pratique d'utiliser `WindowCloseButtonHint`.
`Qt::WindowMinimizeButtonHint`	`0x00004000`	Ajoute un bouton de minimisation. Sur certaines plateformes, cela implique Qt::WindowSystemMenuHint pour fonctionner.
`Qt::WindowMaximizeButtonHint`	`0x00008000`	Ajoute un bouton de maximisation. Sur certaines plateformes, cela implique Qt::WindowSystemMenuHint pour fonctionner.
`Qt::WindowMinMaxButtonsHint`	`WindowMinimizeButtonHint \| WindowMaximizeButtonHint`	Ajoute un bouton de minimisation et un bouton de maximisation. Sur certaines plateformes, cela implique Qt::WindowSystemMenuHint pour fonctionner.
`Qt::WindowCloseButtonHint`	`0x08000000`	Ajoute un bouton de fermeture. Sur certaines plateformes, cela implique Qt::WindowSystemMenuHint pour fonctionner.
`Qt::WindowContextHelpButtonHint`	`0x00010000`	Ajoute un bouton d'aide contextuelle aux boîtes de dialogue. Sur certaines plateformes, cela implique Qt::WindowSystemMenuHint pour fonctionner.
`Qt::WindowFullscreenButtonHint`	`0x80000000`	Sur macOS, ajoute un bouton "fullscreen".
`Qt::BypassGraphicsProxyWidget`	`0x20000000`	Empêche la fenêtre et ses enfants de s'intégrer automatiquement dans un QGraphicsProxyWidget si le widget parent est déjà intégré. Vous pouvez activer ce drapeau si vous souhaitez que votre widget soit toujours un widget de premier niveau sur le bureau, que le widget parent soit intégré dans une scène ou non.
`Qt::WindowShadeButtonHint`	`0x00020000`	Ajoute un bouton d'ombrage à la place du bouton de réduction si le gestionnaire de fenêtres sous-jacent le prend en charge.
`Qt::WindowStaysOnTopHint`	`0x00040000`	Informe le système de fenêtres que la fenêtre doit rester au-dessus de toutes les autres fenêtres. Notez que sur certains gestionnaires de fenêtres sous X11, vous devez également passer Qt::X11BypassWindowManagerHint pour que ce drapeau fonctionne correctement.
`Qt::WindowStaysOnBottomHint`	`0x04000000`	Informe le système de fenêtres que la fenêtre doit rester en bas de toutes les autres fenêtres.

Note : Sur X11, cette indication ne fonctionnera que dans les gestionnaires de fenêtres qui supportent l'atome _NET_WM_STATE_BELOW. Si une fenêtre toujours en bas a un parent, ce dernier sera également laissé en bas. Cette astuce de fenêtre n'est actuellement pas implémentée pour macOS.

Remarque : sous Windows, cela ne fonctionnera que pour les fenêtres sans cadre ou plein écran.

Constante	Valeur	Description
`Qt::WindowTransparentForInput`	`0x00080000`	Informe le système de fenêtres que cette fenêtre n'est utilisée que pour la sortie (affichage de quelque chose) et qu'elle ne prend pas d'entrée. Par conséquent, les événements d'entrée doivent passer comme si elle n'était pas là.
`Qt::WindowOverridesSystemGestures`	`0x00100000`	Informe le système de fenêtres que cette fenêtre implémente son propre ensemble de gestes et que les gestes au niveau du système, comme par exemple le changement de bureau à trois doigts, doivent être désactivés.
`Qt::WindowDoesNotAcceptFocus`	`0x00200000`	Informe le système de fenêtres que cette fenêtre ne doit pas recevoir le focus d'entrée.

Remarque : sous Windows, cela empêche la fenêtre d'apparaître dans la barre des tâches.

Constante	Valeur	Description
`Qt::MaximizeUsingFullscreenGeometryHint`	`0x00400000`	Alias obsolète de Qt::ExpandedClientAreaHint
`Qt::ExpandedClientAreaHint (since Qt 6.9)`	`0x00400000`	Demande que la zone client de la fenêtre soit étendue aux zones où elle pourrait être masquée par d'autres éléments d'interface utilisateur ou entrer en conflit avec eux, tels que les contrôles de la barre de titre de la fenêtre ou d'autres interfaces utilisateur du système. Le site safe area margins de la fenêtre reflétera toutes les zones susceptibles de présenter des éléments d'interface utilisateur conflictuels.
`Qt::NoTitleBarBackgroundHint (since Qt 6.9)`	`0x00800000`	Demande que la barre de titre de la fenêtre soit dessinée sans couleur de fond. Ce drapeau est utile en combinaison avec Qt::ExpandedClientAreaHint, pour donner l'impression que la zone client de la fenêtre se confond avec la zone de la barre de titre et les contrôles.
`Qt::WindowType_Mask`	`0x000000ff`	Un masque permettant d'extraire la partie "type de fenêtre" des drapeaux de fenêtre.

Le type WindowFlags est un typedef pour QFlags<WindowType>. Il stocke une combinaison OU de valeurs WindowType.

Voir également QWidget::windowFlags et Exemple de drapeaux de fenêtre.

Documentation des fonctions

`[since 6.2]` void beginPropertyUpdateGroup()

Marque le début d'un groupe de mise à jour des propriétés. Dans ce groupe, la modification d'une propriété ne met pas immédiatement à jour les propriétés dépendantes et ne déclenche pas de notifications de changement. Ces notifications sont reportées jusqu'à ce que le groupe soit terminé par un appel à endPropertyUpdateGroup.

Les groupes peuvent être imbriqués. Dans ce cas, le report ne prend fin que lorsque le groupe le plus éloigné a été fermé.

Remarque : les notifications de changement ne sont envoyées qu'une fois que toutes les valeurs des propriétés affectées par le groupe ont été mises à jour. Cela permet de rétablir un invariant de classe si plusieurs propriétés doivent être mises à jour, empêchant ainsi tout observateur externe de remarquer un état incohérent.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi Qt::endPropertyUpdateGroup et QScopedPropertyUpdateGroup.

QTextStream &Qt::bin(QTextStream &stream)

Appelle QTextStream::setIntegerBase(2) sur stream et renvoie stream.

Voir aussi oct(), dec(), hex() et QTextStream manipulators.

QTextStream &Qt::bom(QTextStream &stream)

Bascule l'insertion de la marque d'ordre des octets sur stream lorsque QTextStream est utilisé avec un encodage UTF.

Voir aussi QTextStream::setGenerateByteOrderMark() et QTextStream manipulators.

QTextStream &Qt::center(QTextStream &stream)

Appelle QTextStream::setFieldAlignment(QTextStream::AlignCenter) sur stream et renvoie stream.

Voir aussi left(), right(), et QTextStream manipulators.

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

Implémente la comparaison à trois voies des types enum.

Cette fonction convertit Enum en son type sous-jacent et appelle la surcharge pour les types intégraux.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution de surcharge que si Enum est un type enum.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.7.

`[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)

Implémente la comparaison à trois voies des types à virgule flottante et intégraux.

Cette fonction convertit rhs en FloatType et appelle la surcharge pour les types à virgule flottante.

Renvoie une instance de Qt::partial_ordering qui représente la relation entre lhs et rhs. Si lhs n'est pas un nombre (NaN), Qt::partial_ordering::unordered est renvoyé.

Contraintes

Ne participe à la résolution de surcharge que si FloatType est un type flottant intégré et IntType un type intégral intégré.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.7.

`[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)

Implémente la comparaison à trois voies des types intégraux et à virgule flottante.

Cette fonction convertit lhs en FloatType et appelle la surcharge pour les types à virgule flottante.

Renvoie une instance de Qt::partial_ordering qui représente la relation entre lhs et rhs. Si rhs n'est pas un nombre (NaN), Qt::partial_ordering::unordered est renvoyé.

Contraintes

Ne participe à la résolution de surcharge que si IntType est un type intégral intégré et FloatType un type flottant intégré.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.7.

`[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)

Implémente la comparaison à trois voies des types à virgule flottante.

Renvoie lhs <=> rhs, à condition que LeftFloat et RightFloat soient des types à virgule flottante intégrés. Contrairement à operator<=>(), ce modèle de fonction est également disponible en C++17. Voir cppreference pour plus de détails.

Cette fonction peut également être utilisée dans les fonctions personnalisées compareThreeWay(), lors de l'ordonnancement des membres d'une classe personnalisée représentée par des types intégrés :

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

Renvoie une instance de Qt::partial_ordering qui représente la relation entre lhs et rhs. Si lhs ou rhs n'est pas un nombre (NaN), Qt::partial_ordering::unordered est renvoyé.

Contraintes

Ne participe à la résolution de surcharge que si LeftFloat et RightFloat sont des types flottants intégrés.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.7.

`[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)

Implémente la comparaison à trois voies des types intégraux.

Renvoie lhs <=> rhs, à condition que LeftInt et RightInt soient des types intégraux intégrés. Contrairement à operator<=>(), ce modèle de fonction est également disponible en C++17. Voir cppreference pour plus de détails.

Cette fonction peut également être utilisée dans les fonctions personnalisées compareThreeWay(), lorsqu'il s'agit d'ordonner les membres d'une classe personnalisée représentée par des types intégrés :

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

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution de surcharge que si LeftInt et RightInt sont des types intégraux intégrés.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.7.

`[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)

Implémente une comparaison à trois voies de pointeurs qui sont enveloppés dans Qt::totally_ordered_wrapper. Utilise l'ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Participe à la résolution de surcharge uniquement si T et U sont du même type, ou des types de base et dérivés.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.8.

`[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*)

Implémente la comparaison à trois voies d'un pointeur enveloppé dans Qt::totally_ordered_wrapper avec un pointeur normal. Utilise l'ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Ne participe à la résolution de surcharge que si T et U sont du même type, ou des types de base et dérivés.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.8.

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

Implémente la comparaison à trois voies d'un pointeur enveloppé dans Qt::totally_ordered_wrapper avec std::nullptr_t.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.8.

`[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)

Implémente la comparaison à trois voies d'un pointeur normal avec un pointeur enveloppé dans Qt::totally_ordered_wrapper. Utilise l'ordre total strict sur les pointeurs lors de la comparaison.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Contraintes

Participe à la résolution de surcharge uniquement si T et U sont du même type, ou des types de base et dérivés.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.8.

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

Implémente la comparaison à trois voies de std::nullptr_t avec un pointeur enveloppé dans Qt::totally_ordered_wrapper.

Renvoie une instance de Qt::strong_ordering qui représente la relation entre lhs et rhs.

Il s'agit d'une fonction surchargée.

Cette fonction a été introduite dans Qt 6.8.

QTextStream &Qt::dec(QTextStream &stream)

Appelle QTextStream::setIntegerBase(10) sur stream et renvoie stream.

Voir aussi bin(), oct(), hex() et QTextStream manipulators.

`[since 6.2]` void endPropertyUpdateGroup()

Met fin à un groupe de mise à jour des propriétés. Si le groupe le plus externe a été terminé, les évaluations et les notifications de liaison différée ont lieu maintenant.

Attention : L'appel à endPropertyUpdateGroup sans un appel précédent à beginPropertyUpdateGroup entraîne un comportement non défini.

Cette fonction a été introduite dans Qt 6.2.

Voir aussi Qt::beginPropertyUpdateGroup et QScopedPropertyUpdateGroup.

QTextStream &Qt::endl(QTextStream &stream)

Écrit '\n' sur le site stream et vide le flux.

Équivalent à

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

Remarque : sous Windows, tous les caractères "\n" sont écrits sous la forme "\r\n " si le périphérique ou la chaîne de caractères de QTextStream est ouvert(e) à l'aide de l'indicateur QIODeviceBase::Text.

Voir également flush(), reset() et QTextStream manipulators.

QTextStream &Qt::fixed(QTextStream &stream)

Appelle QTextStream::setRealNumberNotation(QTextStream::FixedNotation) sur stream et renvoie stream.

Voir aussi scientific() et QTextStream manipulators.

QTextStream &Qt::flush(QTextStream &stream)

Appelle QTextStream::flush() sur stream et renvoie stream.

Voir aussi endl(), reset(), et QTextStream manipulators.

QTextStream &Qt::forcepoint(QTextStream &stream)

Appelle QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ForcePoint) sur stream et renvoie stream.

Voir aussi noforcepoint(), forcesign(), showbase() et QTextStream manipulators.

QTextStream &Qt::forcesign(QTextStream &stream)

Appelle QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ForceSign) sur stream et renvoie stream.

Voir aussi noforcesign(), forcepoint(), showbase() et QTextStream manipulators.

QTextStream &Qt::hex(QTextStream &stream)

Appelle QTextStream::setIntegerBase(16) sur stream et renvoie stream.

Remarque : le modificateur hexagonal ne peut être utilisé que pour écrire dans des flux.

Voir aussi bin(), oct(), dec() et QTextStream manipulators.

QTextStream &Qt::oct(QTextStream &stream)

Appelle QTextStream::setIntegerBase(8) sur stream et renvoie stream.

Voir aussi bin(), dec(), hex() et QTextStream manipulators.

QTextStream &Qt::reset(QTextStream &stream)

Appelle QTextStream::reset() sur stream et renvoie stream.

Voir aussi flush() et QTextStream manipulators.

QTextStream &Qt::right(QTextStream &stream)

Appelle QTextStream::setFieldAlignment(QTextStream::AlignRight) sur stream et renvoie stream.

Voir aussi left(), center(), et QTextStream manipulators.

QTextStream &Qt::scientific(QTextStream &stream)

Appelle QTextStream::setRealNumberNotation(QTextStream::ScientificNotation) sur stream et renvoie stream.

Voir aussi fixed() et QTextStream manipulators.

QTextStream &Qt::showbase(QTextStream &stream)

Appelle QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::ShowBase) sur stream et renvoie stream.

Voir aussi noshowbase(), forcesign(), forcepoint() et QTextStream manipulators.

QTextStream &Qt::uppercasebase(QTextStream &stream)

Appelle QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::UppercaseBase) sur stream et renvoie stream.

Voir aussi lowercasebase(), uppercasedigits(), et QTextStream manipulators.

QTextStream &Qt::uppercasedigits(QTextStream &stream)

Appelle QTextStream::setNumberFlags(QTextStream::numberFlags() | QTextStream::UppercaseDigits) sur stream et renvoie stream.

Voir aussi lowercasedigits(), uppercasebase(), et QTextStream manipulators.

QTextStream &Qt::ws(QTextStream &stream)

Appelle skipWhiteSpace() sur stream et renvoie stream.

Voir aussi QTextStream manipulators.

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

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

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

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

Renvoie un objet QKeyCombination qui représente la combinaison de key avec le modificateur modifier.

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

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

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

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

Renvoie un objet QKeyCombination qui représente la combinaison de key avec les modificateurs modifiers.

© 2026 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

Espaces de noms

Classes

Types

Fonctions

Description détaillée

Espaces de noms

namespace Qt::Literals

Classes

classe partial_ordering

classe strong_ordering

classe totally_ordered_wrapper

classe weak_ordering

Documentation des types

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

[since 6.10] enum class Qt::ContrastPreference

enum Qt::CoordinateSystem

enum Qt::Corner

enum Qt::CursorMoveStyle

enum Qt::CursorShape

enum Qt::DateFormat

enum Qt::DayOfWeek

enum Qt::DockWidgetAreadrapeaux 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::Orientationflags 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::AlignmentFlag
flags Qt::Alignment

enum Qt::ApplicationState
flags Qt::ApplicationStates

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

`[since 6.10]` enum class Qt::ContrastPreference

enum Qt::DockWidgetArea
drapeaux 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
flags 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
drapeaux Qt::ToolBarAreas

enum Qt::TouchPointState
flags Qt::TouchPointStates

enum Qt::WindowState
flags Qt::WindowStates

enum Qt::WindowType
flags Qt::WindowFlags

`[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()