Qt Namespace

Documentation sur les types

enum Qt::AlignmentFlag
flags Qt::Alignment

Ce type d'énumération sert à décrire l'alignement. Il contient des indicateurs horizontaux et verticaux qui peuvent être combinés pour obtenir l'effet souhaité.

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 :

Les indicateurs verticaux sont les suivants :

Vous ne pouvez utiliser qu'un seul indicateur horizontal à la fois. Il existe un indicateur bidimensionnel :

Vous pouvez utiliser au maximum un indicateur horizontal et un indicateur vertical à la fois. Qt::AlignCenter compte à la fois comme indicateur horizontal et vertical.

Trois valeurs d'énumération sont utiles dans les applications pouvant fonctionner en mode de lecture de droite à gauche :

Masques :

Les combinaisons de drapeaux incompatibles ont une signification indéfinie.

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

enum Qt::AnchorPoint

Spécifie un côté d'un élément de mise en page pouvant être ancré. Cette propriété est utilisée par la méthode QGraphicsAnchorLayout.

Voir aussi QGraphicsAnchorLayout.

enum Qt::ApplicationAttribute

Cette énumération décrit les attributs qui modifient le comportement des fonctionnalités à l'échelle de l'application. Ceux-ci sont activés et désactivés à l'aide de la fonction ` QCoreApplication::setAttribute()`, et leur état peut être vérifié à l'aide de la fonction ` QCoreApplication::testAttribute()`.

Lorsque cet attribut est défini sur true, Qt n’effectuera pas cette remappage ; ainsi, appuyer sur la touche de modification « Command » donnera lieu à la séquence « Qt::MetaModifier », tandis qu’appuyer sur la touche de modification « Control » donnera lieu à la séquence « Qt::ControlModifier ».

Notez que les séquences « QKeySequence::StandardKey » seront toujours basées sur le même modificateur (c'est-à-dire que « QKeySequence::Copy » correspondra toujours à Commande+C, quelle que soit la valeur définie), mais que la sortie de la fonction QKeySequence::toString() sera différente.

enum Qt::ApplicationState
flags Qt::ApplicationStates

Ce type d'énumération sert à indiquer l'état actuel de l'application.

Les états sont les suivants :

Le type `ApplicationStates` est une définition de type pour ` QFlags<ApplicationState>`. Il stocke une combinaison (ou) de valeurs `ApplicationState`.

enum Qt::ArrowType

enum Qt::AspectRatioMode

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

Voir également QSize::scale() et QImage::scaled().

enum Qt::Axis

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

Voir aussi QTransform::rotate() et QTransform::rotateRadians().

enum Qt::BGMode

Mode arrière-plan :

enum Qt::BrushStyle

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

Voir également QBrush.

enum Qt::CaseSensitivity

enum Qt::CheckState

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

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

enum Qt::ChecksumType

Cette énumération décrit les normes pouvant être utilisées par la fonction qChecksum().

enum Qt::ClipOperation

enum class Qt::ColorScheme

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

enum Qt::ConnectionType

Cette énumération décrit les types de connexion pouvant être utilisés entre les signaux et les slots. Elle détermine notamment si un signal donné est transmis immédiatement à un slot ou s'il est mis en file d'attente pour être transmis ultérieurement.

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 arrière-plan. 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.

Lorsque vous utilisez des signaux et des slots avec plusieurs threads, consultez la section Signaux et slots entre threads.

Voir également le multithreading dans Qt, ` 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 adopter concernant l'affichage d'un menu contextuel.

[since 6.8] enum class Qt::ContextMenuTrigger

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

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

Voir aussi QStyleHints::contextMenuTrigger.

[since 6.10] enum class Qt::ContrastPreference

Représente le réglage de contraste préféré de l'utilisateur. Les thèmes peuvent tenir compte de ce réglage en augmentant le contraste entre les couleurs de premier plan et d'arrière-plan, ainsi qu'en épaississant les bordures des widgets et des commandes.

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

enum Qt::CoordinateSystem

Cette énumération définit le système de coordonnées.

enum Qt::Corner

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

enum Qt::CursorMoveStyle

Cette énumération décrit les modes de déplacement disponibles pour les curseurs de texte. Les options sont les suivantes :

enum Qt::CursorShape

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

Le curseur fléché standard est celui utilisé par défaut pour les widgets à l'état normal.

Constante	Valeur	Description
Qt::ArrowCursor	0	Le curseur en forme de flèche standard.
Qt::UpArrowCursor	1	Une flèche pointant vers le haut, en direction du haut de l'écran.
Qt::CrossCursor	2	Un curseur en réticule, généralement utilisé pour aider l'utilisateur à sélectionner avec précision un point à l'écran.
Qt::WaitCursor	3	Un curseur en forme de sablier ou 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 en forme de caret ou de « i-beam », indiquant qu'un widget peut accepter et afficher du texte saisi par l'utilisateur.
Qt::SizeVerCursor	5	Un curseur utilisé pour les éléments permettant de redimensionner verticalement les fenêtres de premier niveau.
Qt::SizeHorCursor	6	Un curseur utilisé pour les éléments permettant de redimensionner horizontalement les fenêtres de premier niveau.
Qt::SizeBDiagCursor	7	Un curseur utilisé pour les éléments permettant de redimensionner en diagonale les fenêtres de premier niveau au niveau de leurs coins supérieur droit et inférieur gauche.
Qt::SizeFDiagCursor	8	Un curseur utilisé pour les éléments permettant de redimensionner en diagonale les fenêtres de premier niveau au niveau de leurs coins supérieur gauche et inférieur droit.
Qt::SizeAllCursor	9	Un curseur utilisé pour les éléments servant à redimensionner les fenêtres de premier niveau dans n’importe quelle direction.
Qt::BlankCursor	10	Un curseur vide/invisible, généralement utilisé lorsque la forme du curseur doit être masquée.
Qt::SplitVCursor	11	Curseur utilisé pour les séparateurs verticaux, indiquant qu’une poignée peut être déplacée horizontalement pour ajuster l’utilisation de l’espace disponible.
Qt::SplitHCursor	12	Un curseur utilisé pour les séparateurs horizontaux, indiquant qu’une poignée peut être déplacée verticalement pour ajuster l’utilisation de l’espace disponible.
Qt::PointingHandCursor	13	Un curseur en forme de main pointant, généralement utilisé pour les éléments cliquables tels que les liens hypertextes.
Qt::ForbiddenCursor	14	Un curseur en forme de cercle barré, généralement utilisé lors d’opérations de glisser-déposer pour indiquer que le contenu déplacé ne peut pas être déposé sur certains widgets ou à l’intérieur de certaines zones.
Qt::OpenHandCursor	17	Un curseur représentant une main ouverte, généralement utilisé pour indiquer que la zone située sous le curseur correspond à la partie visible d’un canevas sur laquelle l’utilisateur peut cliquer et faire glisser pour faire défiler le contenu.
Qt::ClosedHandCursor	18	Un curseur représentant une main fermée, généralement utilisé pour indiquer qu’une opération de glisser-déposer impliquant un défilement est en cours.
Qt::WhatsThisCursor	15	Une flèche accompagnée d’un point d’interrogation, généralement utilisée pour indiquer la présence d’une aide de type « Qu’est-ce que c’est ? » pour un widget.
Qt::BusyCursor	16	Un curseur en forme de sablier ou de montre, généralement affiché pendant les opérations qui permettent à l’utilisateur d’interagir avec l’application pendant qu’elles s’exécutent en arrière-plan.
Qt::DragMoveCursor	20	Un curseur généralement utilisé lors du glissement d’un élément.
Qt::DragCopyCursor	19	Un curseur généralement utilisé lors du glissement d’un élément pour le copier.
Qt::DragLinkCursor	21	Un curseur généralement utilisé lors du glissement d'un élément pour créer un lien vers celui-ci.
Qt::BitmapCursor	24

enum Qt::DateFormat

Pour les formats de type ISODate, chaque y, M et d représente un 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és pour spécifier l’heure. Une heure égale à 24, avec zéro pour tous les autres champs d'heure, est considérée comme le début du jour suivant. Un « .zzz » désigne une fraction ajoutée au champ précédent ; celle-ci peut être séparée de ce champ soit par une virgule ',', soit par le point '.' illustré. Une précision supérieure à la milliseconde est acceptée mais ignorée ; l’arrondi s’effectue à la milliseconde représentable la plus proche. La présence d’un caractère littéral « T » sert à séparer la date et l’heure lorsque les deux sont spécifiées. Pour les formats « TextDate » et « RFC2822Date », « ddd » correspond aux trois premières lettres du nom du jour de la semaine et « MMM » correspond aux trois premières lettres du nom du mois. Les noms des jours et des mois sont toujours en anglais (locale C), quelles que soient les préférences de l’utilisateur ou les paramètres système. Les autres caractères de 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 des signes, '-' pour le moins ou '+' pour le plus.

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

enum Qt::DayOfWeek

enum Qt::DockWidgetArea
flags Qt::DockWidgetAreas

Indique les emplacements auxquels un « QDockWidget » peut être connecté.

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

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

enum Qt::DropAction
flags Qt::DropActions

Le type DropActions est une définition de type (typedef) pour QFlags<DropAction>. Il stocke une combinaison OU de valeurs DropAction.

enum Qt::Edge
flags Qt::Edges

Ce type d'énumération spécifie une arête d'un rectangle :

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

enum Qt::EnterKeyType

Cette option permet de modifier l'apparence de la touche « Retour » sur un clavier à l'écran.

enum Qt::EventPriority

Cette énumération permet de définir les priorités des événements.

Notez que ces valeurs sont fournies uniquement à titre indicatif, car les priorités d’événements peuvent prendre n’importe quelle valeur comprise entre INT_MAX et INT_MIN, inclus. Par exemple, vous pouvez définir des priorités personnalisées 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 également QCoreApplication::postEvent().

enum Qt::FillRule

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

enum Qt::FindChildOption
flags Qt::FindChildOptions

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 adopter en matière d'obtention du focus clavier.

enum Qt::FocusReason

Cette énumération précise la raison du changement de focus. Elle est transmise via ` QWidget::setFocus ` et peut être récupérée dans l'QFocusEvent ` envoyé au widget lors d'un changement de focus.

Voir également «Focus clavier dans les widgets ».

enum Qt::GestureFlag
flags Qt::GestureFlags

Ce type d'énumération décrit des indicateurs supplémentaires pouvant être utilisés lors de l'abonnement à un geste.

Le type `GestureFlags` est un `typedef` pour ` QFlags<GestureFlag>`. Il stocke une combinaison OR 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.

Voir aussi QGesture.

enum Qt::GestureType

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

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

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

enum Qt::GlobalColor

Objets d'QColor prédéfinis de Qt :

Voir aussi QColor.

Qt::HANDLE

Type de descripteur pour les objets système, défini comme « void * » sur toutes les plateformes.

enum class Qt::HighDpiScaleFactorRoundingPolicy

Cette énumération décrit les règles d'arrondi possibles pour les facteurs d'échelle haute résolution (High-DPI), qui déterminent la manière dont les facteurs d'échelle non entiers (tels que 150 % sous Windows) sont gérés.

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

Voir aussi QGuiApplication::setHighDpiScaleFactorRoundingPolicy().

enum Qt::HitTestAccuracy

Cette énumération contient les types de précision pouvant être utilisés par la classe ` QTextDocument ` lors de la détection des clics de souris sur des documents texte.

enum Qt::ImageConversionFlag
flags Qt::ImageConversionFlags

Les options marquées « (par défaut) » sont activées si aucune autre valeur de la liste n'est spécifiée (les valeurs par défaut étant zéro) :

Préférence couleur/monochrome (ignorée pour QBitmap) :

Préférence de mode de tramage :

Préférence de mode de tramage pour les masques alpha 1 bit :

Préférence pour la correspondance des couleurs ou le tramage :

Le type `ImageConversionFlags` est un `typedef` pour ` QFlags<ImageConversionFlag>`. Il stocke une combinaison (ou) de valeurs `ImageConversionFlag`.

enum Qt::InputMethodHint
flags Qt::InputMethodHints

Indicateurs modifiant le comportement :

Notez que les IME Android n'autorisent délibérément que la saisie de caractères latins/ASCII dans les champs de mot de passe.

Notez que le framework Qt traite cela comme un mot de passe visible et que, dans ce cas, les IME Android n'autorisent délibérément que la saisie de caractères latins/ASCII.

Indicateurs restreignant la saisie (indicateurs exclusifs) :

Masques :

Le type `InputMethodHints` est une définition de type (`typedef`) pour ` QFlags<InputMethodHint>`. Il stocke une combinaison (ou) de valeurs `InputMethodHint`.

Voir également QGraphicsItem::inputMethodHints().

enum Qt::InputMethodQuery
flags Qt::InputMethodQueries

Masques :

Le type InputMethodQueries est une définition de type pour QFlags<InputMethodQuery>. Il stocke une combinaison « OU » de valeurs InputMethodQuery.

Voir aussi 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. Ces rôles sont utilisés par la vue pour indiquer au modèle le type de données dont elle 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 :

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

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

Rôles utilisateur :

En ce qui concerne les rôles utilisateur, c’est au développeur de décider quels types utiliser et de s’assurer que les composants utilisent les types appropriés lors de l’accès aux données et de leur définition.

enum Qt::ItemFlag
flags Qt::ItemFlags

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

Notez que les éléments cochables doivent se voir attribuer à la fois un ensemble approprié d’indicateurs et un état initial, indiquant si l’élément est coché ou non. Ceci est géré automatiquement pour les composants modèle/vue, mais doit être défini explicitement pour les instances de ` QListWidgetItem`, ` QTableWidgetItem` et ` QTreeWidgetItem`.

Notez que la réimplémentation de ` QAbstractItemModel::hasChildren ` de manière à renvoyer `true` pour un index alors que cet index a l'indicateur `Qt::ItemNeverHasChildren` activé constitue un comportement indéfini.

Le type ItemFlags est une définition de type (typedef) pour QFlags<ItemFlag>. Il stocke une combinaison OR de valeurs ItemFlag.

Voir également ` QAbstractItemModel`.

enum Qt::ItemSelectionMode

Cette énumération est utilisée dans QGraphicsItem, QGraphicsScene et QGraphicsView pour définir la manière dont les éléments sont sélectionnés, ou pour déterminer si des formes et des éléments entrent en collision.

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 le traitement à appliquer aux éléments actuellement sélectionnés lors de la définition d'une zone de sélection.

Voir aussi QGraphicsScene::setSelectionArea().

enum Qt::Key

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

Voir également QKeyEvent::key().

enum Qt::KeyboardModifier
flags Qt::KeyboardModifiers

Cette énumération décrit les touches de modification.

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

Voir également MouseButton et Modifier.

enum Qt::LayoutDirection

Définit la direction des mises en page et du traitement du texte dans Qt.

Les mises en page de droite à gauche sont nécessaires pour certaines langues, notamment l'arabe et l'hébreu.

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

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

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

enum Qt::MaskMode

Cette énumération définit le comportement des fonctions ` QPixmap::createMaskFromColor()` et ` QImage::createMaskFromColor()`.

enum Qt::MatchFlag
flags Qt::MatchFlags

Cette énumération décrit les types de correspondance pouvant être utilisés lors de la recherche d'éléments dans un modèle.

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

Voir également 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.

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

Voir également KeyboardModifier et MouseButton.

[since 6.12] enum class Qt::MotionPreference

Représente le paramètre préféré de l'utilisateur en matière d'animations et de mouvements. Les contrôles, les styles et les applications peuvent respecter ce paramètre en limitant le nombre d'animations en fonction de la valeur de l'énumération.

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

enum Qt::MouseButton
flags Qt::MouseButtons

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

Le type `MouseButtons` est un `typedef` pour ` QFlags<MouseButton>`. Il stocke une combinaison OR de valeurs `MouseButton`.

Voir également KeyboardModifier et Modifier.

enum Qt::MouseEventFlag
flags Qt::MouseEventFlags

Cette énumération fournit des informations supplémentaires concernant une QMouseEvent.

Le type `MouseEventFlags` est un `typedef` pour ` QFlags<MouseEventFlag>`. Il stocke une combinaison OR 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 si l'événement est un événement de souris artificiel provenant d'un autre périphérique, tel qu'un écran tactile.

Voir également Qt::AA_SynthesizeMouseForUnhandledTouchEvents.

enum Qt::NativeGestureType

Cette énumération renvoie le type de geste.

enum Qt::Orientation
flags Qt::Orientations

Ce type sert à indiquer l'orientation d'un objet.

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

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

enum Qt::PenCapStyle

Ce type d'énumération définit les styles d'embouts de stylo pris en charge par Qt, c'est-à-dire les embouts de fin de ligne pouvant être dessinés à l'aide de la fonction ` QPainter`.

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

Voir aussi QPen.

enum Qt::PenJoinStyle

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

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

Voir également QPen.

enum Qt::PenStyle

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

Qt::SolidLine	Qt::DashLine	Qt::DotLine
Qt::DashDotLine	Qt::DashDotDotLine	Qt::Ligne-pointillée-personnalisée

Voir aussi QPen.

[since 6.5] enum class Qt::PermissionStatus

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

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

Voir également QCoreApplication::requestPermission(), QCoreApplication::checkPermission() et Autorisations de l'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 également QCursor::bitmap(), QCursor::mask(), QLabel::picture() et QLabel::pixmap().

enum Qt::ScreenOrientation
flags Qt::ScreenOrientations

Ce type d'énumération définit les différentes orientations possibles d'un écran.

Le type `ScreenOrientations` est une définition de type 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 l'QAbstractScrollArea.

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

enum Qt::ScrollPhase

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