Espace de noms Qt

L'espace de nom de Qt contient divers identifiants utilisés à de multiples endroits du framework Qt. Plus d'informations...

Description détaillée

L'espace de nom de Qt contient divers identifiants utilisés à de multiples endroits du framework Qt.

Types

enum Qt::AlignmentFlag

flags Qt::Alignment

Cette énumération est utilisée pour décrire l'alignement. Elle contient des drapeaux horizontaux et verticaux pouvant être combinés pour produire l'effet requis.

L'énumération TextElideMode peut aussi être utilisée dans bien des situations pour affiner l'apparence d'un texte aligné.

Les drapeaux horizontaux sont :

Les drapeaux verticaux sont :

Vous ne pouvez utiliser qu'un drapeau horizontal à la fois. Il existe un drapeau à deux dimensions :

Vous ne pouvez utiliser qu'un drapeau horizontal et un drapeau vertical à la fois. Qt::AlignCenter compte en tant que drapeau horizontal et vertical.

Trois valeurs d'énumérations sont très utiles dans des applications pouvant être exécutées dans le mode droite à gauche :

Masques :

Des combinaisons contradictoires de drapeaux ont des significations indéfinies.

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

enum Qt::AnchorAttribute

Une ancre possède un attribut ou plus de cette liste :

enum Qt::AnchorPoint

Spécifie un côté d'un élément de layout pouvant être ancré. Cela est utilisé par QGraphicsAnchorLayout.

Voir aussi QGraphicsAnchorLayout.

enum Qt::ApplicationAttribute

Cette énumération décrit des attributs qui changent le comportement des caractéristiques à l'échelle de l'application. Celles-ci sont activées et désactivées par QCoreApplication::setAttribute() et peuvent être testées avec QCoreApplication::testAttribute().

enum Qt::ArrowType

enum Qt::AspectRatioMode

Cette énumération définit ce qu'il arrive à l'aspect ratio lors d'une réduction aux dimensions d'un rectangle.

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

enum Qt::Axis

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

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

enum Qt::BGMode

Modalité d'arrière-plan :

enum Qt::BrushStyle

Cette énumération définit les styles de pinceaux supportés par Qt, c'est-à-dire le modèle de remplissage des formes dessinées par l'utilisation de QPainter.

Voir aussi QBrush.

enum Qt::CaseSensitivity

enum Qt::CheckState

Cette énumération décrit l'état d'éléments, contrôles et widgets pouvant être cochés.

Voir aussi QCheckBox, Qt::ItemFlags et Qt::ItemDataRole.

enum Qt::ClipOperation

enum Qt::ConnectionType

Cette énumération décrit les types de connexions qui peuvent être utilisés entre les signaux et les slots. Plus précisément, il détermine si un signal particulier est transmis à un slot immédiatement ou mis à la file d'attente pour être envoyé plus tard.

Avec des connexions à la chaîne, les paramètres doivent être de types connus du système de méta-objet de Qt, car Qt a besoin de copier les arguments pour les stocker dans un événement dans les coulisses. Si vous tentez d'utiliser une connexion à la chaîne et si vous obtenez l'erreur suivante :

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

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

Pour l'utilisation des signaux et des slots avec de multiples threads, vous pouvez consulter les signaux et les slots à travers les threads.

Voir aussi threads, QObject::connect() et qRegisterMetaType().

enum Qt::ContextMenuPolicy

Cette énumération définit les politiques variées que peut avoir un widget avec le respect de l'affichage d'un menu contextuel.

enum Qt::CoordinateSystem

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

Cette énumération a été introduite ou modifiée dans Qt 4.6.

enum Qt::Corner

Cette énumération spécifie un coin d'un rectangle.

enum Qt::CursorShape

Cette énumération définit les curseurs variés pouvant être utilisés.

Le curseur standard en forme de flèche est le curseur par défaut de tous les widgets à l'état normal.

Constante	Valeur	Description
Qt::ArrowCursor	0	Le curseur standard en forme de flèche.
Qt::UpArrowCursor	1	Une flèche vers le haut, en direction du haut de l'écran.
Qt::CrossCursor	2	Un curseur réticulé, typiquement utilisé pour aider l'utilisateur à sélectionner un point de l'écran avec précision.
Qt::WaitCursor	3	Un curseur en forme de sablier ou de montre, couramment affiché durant des opérations qui empêchent l'utilisateur d'interagir avec l'application.
Qt::IBeamCursor	4	Un curseur I-beam, indiquant qu'un widget peut accepter et afficher une entrée de texte.
Qt::SizeVerCursor	5	Un curseur employé pour les éléments qui sont utilisés pour redimensionner verticalement des fenêtres de haut niveau.
Qt::SizeHorCursor	6	Un curseur employé pour les éléments qui sont utilisés pour redimensionner horizontalement des fenêtres de haut niveau.
Qt::SizeBDiagCursor	7	Un curseur employé pour les éléments qui sont utilisés pour redimensionner par diagonales les fenêtres de haut niveau, à leur coins en haut à droite et en bas à gauche.
Qt::SizeFDiagCursor	8	Un curseur employé pour les éléments qui sont utilisés pour redimensionner par diagonales les fenêtres de haut niveau, à leur coins en haut à gauche et en bas à droite.
Qt::SizeAllCursor	9	Un curseur employé pour les éléments qui sont utilisés pour redimensionner les fenêtres de haut niveau dans n'importe quelle direction.
Qt::BlankCursor	10	Un curseur vide/invisible, typiquement utilisé quand la forme du curseur doit être cachée.
Qt::SplitVCursor	11	Un curseur employé pour les diviseurs verticaux, indiquant qu'un traitement peut être effectué horizontalement pour ajuster l'espace disponible.
Qt::SplitHCursor	12	Un curseur employé pour les diviseurs horizontaux, indiquant qu'un traitement peut être effectué verticalement pour ajuster l'espace disponible.
Qt::PointingHandCursor	13	Un curseur en forme de main qui pointe, typiquement utilisé pour les éléments cliquables, tels que les liens hypertexte.
Qt::ForbiddenCursor	14	Un curseur en forme de cercle barré, typiquement utilisé pendant les opérations de glissement-déposition pour indiquer que le 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, typiquement utilisé pour indiquer que la zone sous le curseur est la partie visible d'une toile sur laquelle l'utilisateur peut cliquer et faire glisser dans le but d'effectuer un défilement.
Qt::ClosedHandCursor	18	Un curseur représentant une main fermée, typiquement utilisé lorsqu'une opération de glissement est en cours, impliquant un défilement.
Qt::WhatsThisCursor	15	Une flèche avec un point d'interrogation, typiquement utilisée pour indiquer la présence de l'aide « What's this? » d'un widget.
Qt::BusyCursor	16	Un curseur en forme de sablier ou de montre, couramment affiché pendant les opérations permettant à l'utilisateur d'interagir avec l'application durant qu'elles sont effectuées en arrière-plan.
Qt::DragMoveCursor	20	Un curseur qui est généralement utilisé lors du glissement d'un élément.
Qt::DragCopyCursor	19	Un curseur qui est généralement utilisé lors du glissement d'un élément dans le but de le copier.
Qt::DragLinkCursor	21	Un curseur qui est généralement utilisé lors du glissement d'un élément dans le but de créer un lien vers celui-ci.
Qt::BitmapCursor	24

enum Qt::DateFormat

Note : pour les formats ISODate, chaque Y, M et D représente un simple chiffre de l'année, du mois et du jour utilisé pour spécifier la date. Chaque H, M et S représente un simple chiffre d'heure, de minute et de seconde utilisé pour spécifier l'heure. La présence d'un caractère littéral T est utilisée pour séparer la date et le temps lorsque les deux sont spécifiés.

enum Qt::DayOfWeek

enum Qt::DockWidgetArea

flags Qt::DockWidgetAreas 

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

enum Qt::DropAction

flags Qt::DropActions 

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

enum Qt::EventPriority

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

Notez que ces valeurs sont fournies par entière commodité, depuis que les priorités d'événements peuvent être des valeurs entre INT_MAX et INT_MIN inclus. Par exemple, vous pouvez définir des priorités en tant que priorités relatives à chaque autre :

 enum CustomEventPriority
 {
     // Un événement important
     ImportantEventPriority = Qt::HighEventPriority,
 
     // Un événement plus important
     MoreImportantEventPriority = ImportantEventPriority + 1,
 
     // Un événement critique
     CriticalEventPriority = 100 * MoreImportantEventPriority,
 
     // Pas si important
     StatusEventPriority = Qt::LowEventPriority,
 
     // Ceux-là sont moins importants que les événements de Status
     IdleProcessingDoneEventPriority = StatusEventPriority - 1
 };

Voir aussi QCoreApplication::postEvent().

enum Qt::FillRule

Spécifie quelle méthode doit être utilisée pour remplir les trajectoires et les polygones.

enum Qt::FocusPolicy

enum Qt::FocusReason

Cette énumération spécifie la raison pour laquelle le focus a changé. Elle sera passée à travers QWidget::setFocus et pourra être reçue dans le QFocusEvent envoyé au widget au changement de focus.

Voir aussi Le focus de clavier.

enum Qt::GestureFlag

flags Qt::GestureFlags

Cette énumération décrit les drapeaux additionnels pouvant être utilisés lors d'un abonnement à un geste.

Cette énumération a été introduite ou modifiée dans Qt 4.6.

Le type GestureFlags est un typedef de QFlags<GestureFlag>. Il stocke des combinaisons OU des valeurs de GestureFlag.

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

enum Qt::GestureState

Cette énumération décrit l'état d'un geste.

Cette énumération a été introduite ou modifiée dans Qt 4.6.

Voir aussi QGesture.

enum Qt::GestureType

Cette énumération décrit les gestes standards.

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 le drapeau Qt::CustomGesture défini.

Cette énumération a été introduite ou modifiée dans Qt 4.6.

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

enum Qt::GlobalColor

Les objets de QColor prédéfinis de Qt :

Voir aussi QColor.

typedef Qt::HANDLE

Le type de gestion spécifique à la plateforme des objets système. C'est l'équivalent de void * sous Mac OS X et Linux embarqué et à unsigned long sous X11. Sous Windows, c'est le DWORD retourné par la fonction Win32 getCurrentThreadId().

Attention : utiliser ce type n'est pas portable.

enum Qt::HitTestAccuracy

Cette énumération contient les types de précisions pouvant être utilisés avec la classe lors de tests concernant des clics de souris sur les documents textuels.

Cette énumération est définie dans le fichier d'en-tête <QTextDocument>.

enum Qt::ImageConversionFlag

flags Qt::ImageConversionFlags

Les options marquées « (par défaut) » sont définies si aucune autre valeur de la liste n'est incluse (comme les valeurs par défaut sont zéro).

Préférences de couleur/mono (ignorée pour QBitmap) :

Préférences de modes de tramage de canaux RGB :

Préférences de modes de tramage de canal alpha :

Harmonisation colorimétrique contre préférence de tramage :

Le type de drapeau ImageConversionFlags est un typedef de QFlags<ImageConversionFlag>. Il stocke des combinaisons OU des valeurs de ImageConversionFlag.

enum Qt::InputMethodHint

flags Qt::InputMethodHints 

Drapeaux qui altèrent le comportement :

Drapeaux restreignant l'entrée (drapeaux exclusifs) :

Masques :

Note : si de multiples drapeaux exclusifs sont mis en composition OU, le caractère défini résultant consistera en l'union des drapeaux spécifiés définis. Par exemple, la spécification de ImhNumbersOnly et de ImhUppercaseOnly produira un ensemble composé de nombres et de lettres majuscules.

Le type InputMethodHints est un typedef de QFlags<InputMethodHint>. Il stocke des combinaisons OU des valeurs de InputMethodHint.

Voir aussi QGraphicsItem::inputMethodHints().

enum Qt::InputMethodQuery

enum Qt::ItemDataRole

Chaque item du modèle a un ensemble d'éléments de données associées, chacune avec son propre rôle. Les rôles sont utilisés par la vue pour indiquer au modèle le type de données requises. Des modèles personnalisés devraient retourner des données de ces types.

Les rôles généraux et leurs types associés sont :

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

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

Rôles utilisateur :

Pour les rôles utilisateur, le développeur doit décider quels types utiliser et s'assurer que les composants utilisent les bons types lors de l'accès aux données et de leur écriture.

enum Qt::ItemFlag

flags Qt::ItemFlags

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

Notez que les items cochables doivent recevoir un set de drapeaux correct et un état initial indiquant si l'item est coché ou non. Ceci est géré automatiquement pour les composants modèle-vue mais nécessite d'être explicitement mis pour les instances de QListWidgetItem, QTableWidgetItem et QTreeWidgetItem.

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

Voir aussi QAbstractItemModel.

enum Qt::ItemSelectionMode

Cette énumération est utilisée dans QGraphicsItem, QGraphicsScene et QGraphicsView pour spécifier la manière dont les items sont sélectionnés ou comme déterminer si un forme et un item sont en collision.

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

enum Qt::Key

Les noms des touches utilisés par Qt.

Voir aussi QKeyEvent::key().

enum Qt::KeyboardModifier

flags Qt::KeyboardModifiers

Cette énumération décrit les touches modificatrices.

Note : sous Mac OS X, la valeur ControlModifier correspond à la touche de commande sur les claviers Macintosh et la valeur MetaModifier correspond à la touche de contrôle. La valeur KeypadModifier sera également définie quand une touche directionnelle est appuyée, puisque les touches directionnelles sont considérées comme faisant partie du pavé numérique.

Note : sur les claviers Windows, Qt::MetaModifier et Qt::Key_Meta sont associées aux touches de Windows.

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

Voir aussi MouseButton et Modifier.

enum Qt::LayoutDirection

Spécifie la direction des layouts de Qt et des traitements de textes :

Les layouts avec une disposition de droite à gauche sont nécessaires pour certaines langues, notamment l'arabe et l'hébreu.

LayoutDirectionAuto sert à deux objectifs. Lorsqu'il est utilisé en conjonction avec des widgets et des layouts, cela implique d'utiliser la direction du layout définit sur le widget parent ou QApplication. Cela a le même effet que QWidget::unsetLayoutDirection().

Lorsque LayoutDirectoinAuto est utilisé en conjonction avec un texte mis en page, cela implique que la directionnalité du texte est déterminée à partir du contenu de la chaîne de caractères qui doit être mise en page.

Voir aussi QApplication::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().

enum Qt::MatchFlag

flags Qt::MatchFlags

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

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

Voir aussi QString::compare() et QRegExp.

enum Qt::Modifier

Cette énumération fournit des raccourcis pour les touches-modifieurs supportées par Qt.

Note : sur Mac OS X, la valeur CTRL correspond à la touche Commande sur le clavier Macintosh ; META à la touche Contrôle.

Voir aussi KeyboardModifier et MouseButton.

enum Qt::MouseButton

flags Qt::MouseButtons

Cette énumération décrit les différents boutons de la souris.

Le type MouseButtons est un typedef de QFlags<MouseButton>. Il stocke des combinaisons OU des valeurs de MouseButton.

Voir aussi KeyboardModifier et Modifier.

enum Qt::NavigationMode

Cette énumération décrit le mode de changement de focus.

Note : dans Qt 4.6, la navigation au curseur n'est implémentée que pour Symbian. Sur les autres plateformes, elle se comporte comme NavigationModeNone.

Cette énumération a été introduite ou modifiée dans Qt 4.6.

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

enum Qt::Orientation

flags Qt::Orientations

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

Orientation est utilisé, par exemple, avec QScrollBar.

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

enum Qt::PenCapStyle

Cette énumération définit les styles de pinceaux utilisés par Qt, comme la pointe droite qui peut être dessinée avec QPainter.

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

Voir aussi QPen.

enum Qt::PenJoinStyle

Cette énumération définit les styles de jointures entre les levées supportées par Qt, comme la jointure entre deux lignes connectées qui peut être dessinée par QPainter.

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

Voir aussi QPen.

enum Qt::PenStyle

Cette énumération définit les styles de pinceaux qui peuvent être dessinés par QPainter. Ces styles sont :

Qt::SolidLine	Qt::DashLine	Qt::DotLine
Qt::DashDotLine	Qt::DashDotDotLine	Qt::CustomDashLine

Voir aussi QPen.

enum Qt::ScrollBarPolicy

Cette énumération décrit les différents modes des barres de défilement de QAbstractScrollArea.

Les modes pour les barres horizontales et verticales sont indépendants.

enum Qt::ShortcutContext

Pour qu'un QEvent::Shortcut apparaisse, la séquence de touches du raccourci doit être entrée par l'utilisateur dans un contexte où elle est active. Les contextes possibles sont :

enum Qt::SizeHint

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

Cette énumération a été introduite ou modifiée dans Qt 4.4.

Voir aussi 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 en respectant les dimensions des rectangles alentours spécifiés.

Cette énumération a été introduite ou modifiée dans Qt 4.4.

enum Qt::SortOrder

Cette énumération décrit comment les items d'un widget sont triés.

enum Qt::TextElideMode

Cette énumération spécifie où les élision doivent être faites quand du texte trop long doit être affiché :

Qt::ElideMiddle est normalement le choix le plus approprié pour les URL (par exemple,  »http://qt.nok...ovingto/brisbane/ »), alors que Qt::ElideRight est plus approprié pour les autres chaînes (par exemple,  »Deploying Applications on Ma... »).

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

enum Qt::TextFlag

Cette énumération est utilisée pour définir des drapeaux modificateurs. Certains drapeaux n'ont du sens que dans le contexte de l'impression :

Utilisez toujours la variante la plus longue lorsque vous calculez la taille d'une chaîne multi-variante.

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

Les drapeaux inappropriés pour un usage donné sont généralement ignorés.

enum Qt::TextFormat

Cette énumération est utilisée dans les widgets pouvant afficher du texte simple et du texte riche, par exemple QLabel. Elle est utilisée pour décider si une chaîne de texte doit être interprétée en tant que l'un ou l'autre. Cela est normalement fait par le passage de valeurs de l'énumération à la fonction setTextFormat().

enum Qt::TextInteractionFlag

flags Qt::TextInteractionFlags

Cette énumération spécifie comment un widget d'affichage de texte réagit à l'entrée utilisateur.

Le type TextInteractionFlags est un typedef de QFlags<TextInteractionFlag>. Il stocke des combinaisons OU des valeurs de TextInteractionFlag.

enum Qt::TileRule

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

Cette énumération a été introduite ou modifiée dans Qt 4.6.

enum Qt::TimeSpec

enum Qt::ToolBarArea

flags Qt::ToolBarAreas 

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

enum Qt::ToolButtonStyle

Le style du bouton outil, décrivant la manière dont le texte du bouton et l'icône devraient être affichés.

enum Qt::TouchPointState

flags Qt::TouchPointStates

Cette énumération représente l'état d'un point au moment où un QTouchEvent apparaît.

Cette énumération a été introduite ou modifiée dans Qt 4.6.

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

enum Qt::TransformationMode

Cette énumération définit si les transformations des images (par exemple, le changement de taille) doit être lisse ou non.

Voir aussi QImage::scaled().

enum Qt::UIEffect

Cette énumération décrit les effets d'UI disponibles.

Par défaut, Qt essayera d'utiliser les paramètres de bureaux spécifiques aux plateformes pour chaque effet. Utilisez la fonction QApplication::setDesktopSettingsAware() (passez false comme argument) pour éviter 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 utilisant des couleurs codées sur moins de 16 bits.

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

typedef Qt::WFlags

Synonyme de Qt::WindowFlags.

enum Qt::WhiteSpaceMode

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

Cette énumération est définie dans le fichier d'en-tête <QTextDocument>.

enum Qt::WidgetAttribute

Cette énumération est utilisée pour spécifier divers attributs de widget. Les attributs sont assignés et enlevés avec QWidget::setAttribute() et interrogés avec QWidget::testAttribute(), bien que certains aient des fonctions de commodité spéciales qui sont mentionnées ci-dessous.

Avertissement : ce drapeau ne doit jamais être défini ou effacé par l'auteur du widget.

enum Qt::WindowFrameSection

Cette énumération est utilisée pour décrire les parties du cadre de la fenêtre. Elle est retournée par QGraphicsWidget::windowFrameSectionAt() pour décrire quelle section du cadre de la fenêtre est sous la souris.

Cette énumération a été introduite ou modifiée dans Qt 4.4.

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 la saisie sur d'autres fenêtres. Notez que les fenêtres qui sont des enfants d'une fenêtre modale ne sont pas bloquées.

Les valeurs sont :

Voir aussi QWidget::windowModality et QDialog.

enum Qt::WindowState

flags Qt::WindowStates

Cette énumération est utilisée pour spécifier l'état actuel d'une fenêtre de haut niveau.

Les états sont :

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

enum Qt::WindowType

flags Qt::WindowFlags

Cette énumération est utilisée pour spécifier diverses propriétés du système de fenêtrage pour le widget. Elles sont assez inhabituelles mais nécessaires dans quelques cas. Certains de ces drapeaux dépendent de la manière dont le gestionnaire de fenêtres les supporte.

Les principaux types sont :

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

Le drapeau CustomizeWindowHint est utilisé pour activer la personnalisation du contrôle de fenêtre. Ce drapeau doit être défini pour autoriser le changement des drapeaux WindowTitleHint, WindowSystemMenuHint, WindowMinimizeButtonHint, WindowMaximizeButtonHint et WindowCloseButtonHint.

Drapeaux obsolètes :

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

Voir aussi QWidget::windowFlags et Window Flags Example.

Fonctions membres

QString Qt::convertFromPlainText ( const QString & plain, WhiteSpaceMode mode = WhiteSpacePre )

Convertit la chaîne de texte brut plain en un paragraphe au format HTML en conservant au mieux son apparence.

mode définit comment les espaces blancs sont gérés.

Cette fonction est définie dans le fichier d'en-tête <QTextDocument>.

Voir aussi escape() et mightBeRichText().

QString Qt::escape ( const QString & plain )

Convertit la chaîne de texte brut plain en une chaîne de caractères HTML dont les méta-caractères HTML <, >, & et  » sont remplacés par leurs entités HTML correspondantes.

Exemple :

QString plain = "#include <QtCore>"
QString html = Qt::escape(plain);
// html == "#include &lt;QtCore&gt;"

Cette fonction est définie dans le fichier d'en-tête <QTextDocument>.

Voir aussi convertFromPlainText() et mightBeRichText().

bool Qt::mightBeRichText ( const QString & text )

Retourne true si la chaîne de caractères text semble être du texte riche, dans le cas contraire retourne false.

Cette fonction utilise une heuristique simple et rapide. Elle vérifie s'il y a quelque chose qui ressemble à un tag avant la fin de la première ligne. Bien que le résultat doive être correct pour les cas ordinaires, il n'y en a aucune garantie.

Cette fonction est définie dans le fichier d'en-tête <QTextDocument>.

Remerciements

Merci à Jonathan Courtois, à Louis du Verdier et à Thibaut Cuvelier pour la traduction, la mise en page et la relecture, à Jacques Thery pour sa relecture approfondie !