Text QML Type

Spécifie comment ajouter du texte formaté à une scène. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités
• Membres obsolètes

Propriétés

• advance : size
• antialiasing : bool
• baseUrl : url
• bottomPadding : real
• clip : bool
• color : color
• contentHeight : real
• contentWidth : real
• effectiveHorizontalAlignment : enumeration
• elide : enumeration
• font.bold : bool
• font.capitalization : enumeration
• font.contextFontMerging : bool (since 6.8)
• font.family : string
• font.features : object (since 6.6)
• font.hintingPreference : enumeration
• font.italic : bool
• font.kerning : bool
• font.letterSpacing : real
• font.pixelSize : int
• font.pointSize : real
• font.preferShaping : bool
• font.preferTypoLineMetrics : bool (since 6.8)
• font.strikeout : bool
• font.styleName : string
• font.underline : bool
• font.variableAxes : object (since 6.7)
• font.weight : int
• font.wordSpacing : real
• fontInfo.bold : bool
• fontInfo.family : string
• fontInfo.italic : bool
• fontInfo.pixelSize : int
• fontInfo.pointSize : real
• fontInfo.styleName : string
• fontInfo.weight : int
• fontSizeMode : enumeration
• horizontalAlignment : enumeration
• hoveredLink : string
• leftPadding : real
• lineCount : int
• lineHeight : real
• lineHeightMode : enumeration
• linkColor : color
• maximumLineCount : int
• minimumPixelSize : int
• minimumPointSize : int
• padding : real
• renderType : enumeration
• renderTypeQuality : int (since 6.0)
• rightPadding : real
• style : enumeration
• styleColor : color
• text : string
• textFormat : enumeration
• topPadding : real
• truncated : bool
• verticalAlignment : enumeration
• wrapMode : enumeration

Signaux

• lineLaidOut(object line)
• linkActivated(string link)
• linkHovered(string link)

Méthodes

• void forceLayout()
• string linkAt(real x, real y)

Description détaillée

Les éléments de texte peuvent afficher à la fois du texte simple et du texte enrichi. Par exemple, vous pouvez définir un texte rouge avec une police et une taille spécifiques :

Text {
    text: "Hello World!"
    font.family: "Helvetica"
    font.pointSize: 24
    color: "red"
}

Utilisez des balises de style HTML ou Markdown pour définir du texte enrichi :

Text {
    text: "<b>Hello</b> <i>World!</i>"
}

Text {
    text: "**Hello** *World!*"
}

Si la hauteur et la largeur ne sont pas explicitement définies, le texte essaiera de déterminer l'espace nécessaire et le définira en conséquence. À moins que wrapMode ne soit défini, il préférera toujours la largeur à la hauteur (tout le texte sera placé sur une seule ligne).

Pour adapter une ligne de texte simple à une largeur donnée, vous pouvez utiliser la propriété elide.

Le texte est en lecture seule. Pour un texte modifiable, voir TextEdit.

Voir aussi l 'exemple des polices.

Documentation sur les propriétés

advance : size [read-only]

Distance, en pixels, entre l'origine de la ligne de base du premier caractère de l'élément de texte et l'origine de la ligne de base du premier caractère d'un élément de texte apparaissant directement après celui-ci dans un flux de texte.

Notez que l'avance peut être négative si le texte s'écoule de droite à gauche.

antialiasing : bool

Permet de décider si le texte doit utiliser l'anticrénelage ou non. Seuls les textes avec renderType de Text.NativeRendering peuvent désactiver l'anticrénelage.

La valeur par défaut est true.

baseUrl : url

Cette propriété spécifie une URL de base qui est utilisée pour résoudre les URL relatives dans le texte.

Les URL sont résolues de manière à se trouver dans le même répertoire que la cible de l'URL de base, ce qui signifie que toute partie du chemin après le dernier "/" sera ignorée.

La valeur par défaut est l'url du fichier QML instanciant l'élément Texte.

Ces propriétés contiennent l'espace autour du contenu. Cet espace est réservé en plus des propriétés contentWidth et contentHeight.

clip : bool

Cette propriété indique si le texte est coupé.

Notez que si le texte ne tient pas dans le rectangle de délimitation, il sera brusquement coupé.

Si vous souhaitez afficher un texte potentiellement long dans un espace limité, il est préférable d'utiliser elide.

color : color

La couleur du texte.

Exemple de texte vert défini à l'aide de la notation hexadécimale :

Text {
    color: "#00FF00"
    text: "green text"
}

Exemple de texte bleu acier défini à l'aide d'un nom de couleur SVG :

Text {
    color: "steelblue"
    text: "blue text"
}

contentHeight : real [read-only]

Renvoie la hauteur du texte, y compris la hauteur au-delà de laquelle le texte est couvert parce qu'il est plus long que la hauteur définie.

contentWidth : real [read-only]

Renvoie la largeur du texte, y compris la largeur au-delà de la largeur couverte en raison d'un habillage insuffisant si WrapMode est activé.

Définit l'alignement horizontal et vertical du texte dans la largeur et la hauteur des éléments de texte. Par défaut, le texte est aligné verticalement en haut. L'alignement horizontal suit l'alignement naturel du texte, par exemple un texte lu de gauche à droite sera aligné à gauche.

Les valeurs valables pour horizontalAlignment sont Text.AlignLeft, Text.AlignRight, Text.AlignHCenter et Text.AlignJustify. Les valeurs valables pour verticalAlignment sont Text.AlignTop, Text.AlignBottom et Text.AlignVCenter.

Notez que pour une seule ligne de texte, la taille du texte correspond à la surface du texte. Dans ce cas courant, tous les alignements sont équivalents. Si vous souhaitez que le texte soit, par exemple, centré dans son parent, vous devrez soit modifier la propriété Item::anchors, soit attribuer à horizontalAlignment la valeur Text.AlignHCenter et lier la largeur à celle du parent.

Lorsque vous utilisez la propriété jointe LayoutMirroring::enabled pour reproduire les dispositions de l'application, l'alignement horizontal du texte sera également reproduit. Cependant, la propriété horizontalAlignment restera inchangée. Pour demander l'alignement horizontal effectif du texte, utilisez la propriété en lecture seule effectiveHorizontalAlignment.

elide : enumeration

Cette propriété permet d'élider les parties du texte correspondant à la largeur de l'élément de texte. Le texte ne sera élidé que si une largeur explicite a été définie.

Cette propriété ne peut pas être utilisée avec du texte enrichi.

L'élidage peut être :

Si cette propriété est définie sur Text.ElideRight, elle peut être utilisée avec le texte wrapped. Le texte ne sera élidé que si maximumLineCount ou height a été défini. Si maximumLineCount et height sont tous deux définis, maximumLineCount s'appliquera à moins que les lignes ne tiennent pas dans la hauteur autorisée.

Si le texte est une chaîne de plusieurs longueurs et que le mode n'est pas Text.ElideNone, la première chaîne qui convient sera utilisée, sinon la dernière sera élidée.

Les chaînes de plusieurs longueurs sont classées de la plus longue à la plus courte, séparées par le caractère Unicode "String Terminator" U009C (écrire ceci en QML avec "\u009C" ou "\x9C").

font.bold : bool

Définit si la police est en gras.

font.capitalization : enumeration

Définit la capitalisation du texte.

Text { text: "Hello"; font.capitalization: Font.AllLowercase }

font.contextFontMerging : bool [since 6.8]

Si la police sélectionnée ne contient pas un certain caractère, Qt choisit automatiquement une police de remplacement similaire qui contient le caractère. Par défaut, ce choix s'effectue caractère par caractère.

Cela signifie que dans certains cas peu courants, plusieurs polices différentes peuvent être utilisées pour représenter une chaîne de texte, même s'il s'agit du même script. En fixant contextFontMerging à true, on essaiera de trouver la police de remplacement qui correspond au plus grand sous-ensemble de la chaîne d'entrée. Cela sera plus coûteux pour les chaînes où des glyphes manquent, mais peut donner des résultats plus cohérents. Par défaut, contextFontMerging est false.

Cette propriété a été introduite dans Qt 6.8.

Voir aussi QFont::StyleStrategy.

font.family : string

Définit le nom de famille de la police.

Le nom de famille est insensible à la casse et peut optionnellement inclure un nom de fonderie, par exemple "Helvetica [Cronyx]". Si la famille est disponible dans plus d'une fonderie et que la fonderie n'est pas spécifiée, une fonderie arbitraire est choisie. Si la famille n'est pas disponible, une famille sera définie en utilisant l'algorithme de correspondance des polices.

font.features : object [since 6.6]

Applique des valeurs entières à des caractéristiques OpenType spécifiques lors de la mise en forme du texte en fonction du contenu de features. Cela permet un accès avancé au processus de mise en forme des polices et peut être utilisé pour prendre en charge des caractéristiques de polices qui ne sont pas couvertes par l'API.

Les caractéristiques des polices sont représentées par une correspondance entre des balises à quatre lettres et des valeurs entières. Cette valeur entière transmise avec la balise représente dans la plupart des cas une valeur booléenne : Une valeur nulle signifie que la fonctionnalité est désactivée, et une valeur non nulle signifie qu'elle est activée. Pour certaines fonctions de police, cependant, elle peut avoir d'autres interprétations. Par exemple, lorsqu'elle est appliquée à la fonction salt, la valeur est un index qui spécifie l'alternative stylistique à utiliser.

Par exemple, la fonction de police frac convertira les fractions diagonales séparées par une barre oblique (comme 1/2) en une représentation différente. Typiquement, cela implique de faire passer la fraction complète dans une largeur de caractère unique (comme ½).

Si une police supporte la fonctionnalité frac, elle peut être activée dans la mise en forme comme dans le code suivant :

Text {
    text: "One divided by two is 1/2"
    font.family: "MyFractionFont"
    font.features: { "frac": 1 }
}

Il est possible d'attribuer des valeurs à plusieurs caractéristiques dans le même mappage. Par exemple, si vous souhaitez également désactiver le crénage pour la police, vous pouvez le désactiver explicitement comme suit :

Text {
    text: "One divided by two is 1/2"
    font.family: "MyFractionFont"
    font.features: { "frac": 1, "kern": 0 }
}

Vous pouvez également rassembler les propriétés de la police dans un objet :

Text {
    text: "One divided by two is 1/2"
    font: {
        family: "MyFractionFont"
        features: { "frac": 1, "kern": 0 }
    }
}

Cette propriété a été introduite dans Qt 6.6.

Voir aussi QFont::setFeature().

font.hintingPreference : enumeration

Définit le niveau d'indication préféré pour le texte. Il s'agit d'une indication au système de rendu de texte sous-jacent d'utiliser un certain niveau d'indication, et la prise en charge varie d'une plate-forme à l'autre. Voir le tableau dans la documentation de QFont::HintingPreference pour plus de détails.

Text { text: "Hello"; renderType: Text.NativeRendering; font.hintingPreference: Font.PreferVerticalHinting }

font.italic : bool

Définit si la police a un style italique.

font.kerning : bool

Active ou désactive la fonction OpenType de crénage lors de la mise en forme du texte. La désactivation de cette fonction peut améliorer les performances lors de la création ou de la modification du texte, au détriment de certaines caractéristiques esthétiques. La valeur par défaut est true.

Text { text: "OATS FLAVOUR WAY"; font.kerning: false }

font.letterSpacing : real

Définit l'espacement des lettres pour la police.

L'espacement des lettres modifie l'espacement par défaut entre les lettres individuelles dans la police. Une valeur positive augmente l'espacement des lettres des pixels correspondants ; une valeur négative diminue l'espacement.

font.pixelSize : int

Définit la taille de la police en pixels.

L'utilisation de cette fonction rend la police dépendante de l'appareil. Utilisez pointSize pour définir la taille de la police indépendamment de l'appareil.

font.pointSize : real

Définit la taille de la police en points. La taille en points doit être supérieure à zéro.

font.preferShaping : bool

Parfois, une police applique des règles complexes à un ensemble de caractères afin de les afficher correctement. Dans certains systèmes d'écriture, tels que les écritures brahmiques, cela est nécessaire pour que le texte soit lisible, mais dans les écritures latines, par exemple, il s'agit simplement d'une caractéristique cosmétique. En définissant la propriété preferShaping sur false, vous désactivez toutes ces fonctionnalités lorsqu'elles ne sont pas nécessaires, ce qui améliore les performances dans la plupart des cas.

La valeur par défaut est true.

Text { text: "Some text"; font.preferShaping: false }

font.preferTypoLineMetrics : bool [since 6.8]

les jeux concurrents de métriques de lignes verticales qui fournissent les ascent, descent et leading de la police. Ces métriques sont souvent appelées métriques win (Windows) et métriques typo (typographiques). Bien que la spécification recommande l'utilisation de la métrique typo pour l'espacement des lignes, de nombreuses applications préfèrent la métrique win à moins que le drapeau USE_TYPO_METRICS ne soit défini dans le champ fsSelection de la police. Pour des raisons de compatibilité ascendante, c'est également le cas pour les applications Qt. Ce n'est pas un problème pour les polices qui définissent le drapeau USE_TYPO_METRICS pour indiquer que les métriques typo sont valides, ni pour les polices dont les métriques win et typo correspondent. Cependant, pour certaines polices, la métrique win peut être plus grande que l'interligne préférable et l'indicateur USE_TYPO_METRICS peut être désactivé par erreur. Pour ces polices, le réglage de font.preferTypoLineMetrics peut donner de meilleurs résultats.

Par défaut, preferTypoLineMetrics est false.

Cette propriété a été introduite dans Qt 6.8.

Voir aussi QFont::StyleStrategy.

font.strikeout : bool

Définit si la police a un style de biffure.

font.styleName : string

Définit le nom du style de la police.

Le nom du style n'est pas sensible à la casse. S'il est défini, la police sera comparée au nom de style plutôt qu'aux propriétés de la police font.weight, font.bold et font.italic.

font.underline : bool

Définit si le texte est souligné.

font.variableAxes : object [since 6.7]

Applique des valeurs à virgule flottante aux axes variables dans les polices variables.

Les polices variables permettent de stocker plusieurs variations (avec des poids, des largeurs ou des styles différents) dans le même fichier de police. Les variations sont données sous forme de valeurs à virgule flottante pour un ensemble prédéfini de paramètres, appelés "axes variables". Des instances spécifiques sont généralement nommées par le concepteur de la police et, dans Qt Designer, elles peuvent être sélectionnées à l'aide de setStyleName(), tout comme les sous-familles traditionnelles.

Dans certains cas, il est également utile de fournir des valeurs arbitraires pour les différents axes. Par exemple, si une police possède une sous-famille Regular et une sous-famille Bold, vous pouvez souhaiter un poids intermédiaire entre ces deux sous-familles. Vous pouvez alors le demander manuellement en fournissant une valeur personnalisée pour l'axe "wght" de la police.

Text {
    text: "Foobar"
    font.family: "MyVariableFont"
    font.variableAxes: { "wght": (Font.Normal + Font.Bold) / 2.0 }
}

Si l'axe "wght" est pris en charge par la police et que la valeur fournie se situe dans la plage définie, une police correspondant au poids 550.0 sera fournie.

Il existe quelques axes standard que de nombreuses polices fournissent, tels que "wght" (poids), "wdth" (largeur), "ital" (italique) et "opsz" (taille optique). Chacune d'entre elles a des plages individuelles définies dans la police elle-même. Par exemple, "wght" peut s'étendre de 100 à 900 (QFont::Thin à QFont::Black) tandis que "ital" peut s'étendre de 0 à 1 (de non italique à totalement italique).

Une police peut également choisir de définir des axes personnalisés ; la seule limitation est que le nom doit répondre aux exigences d'un QFont::Tag (séquence de quatre caractères latins-1).

Par défaut, aucun axe variable n'est défini.

Cette propriété a été introduite dans Qt 6.7.

Voir aussi QFont::setVariableAxis().

font.weight : int

Le poids demandé pour la police. Le poids demandé doit être un entier compris entre 1 et 1000, ou l'une des valeurs prédéfinies :

Text { text: "Hello"; font.weight: Font.DemiBold }

font.wordSpacing : real

Définit l'espacement des mots pour la police.

L'espacement entre les mots modifie l'espacement par défaut entre les mots individuels. Une valeur positive augmente l'espacement entre les mots d'un nombre correspondant de pixels, tandis qu'une valeur négative diminue l'espacement entre les mots en conséquence.

fontInfo.bold : bool [read-only]

L'état gras des informations de police qui ont été résolues pour la police actuelle et fontSizeMode. Ceci est vrai si le poids de la police résolue est gras ou supérieur.

fontInfo.family : string [read-only]

Le nom de famille de la police qui a été résolu pour la police actuelle et fontSizeMode.

fontInfo.italic : bool [read-only]

L'état italique de l'information sur la police qui a été résolue pour la police actuelle et fontSizeMode.

fontInfo.pixelSize : int [read-only]

La taille en pixels de l'information de police qui a été résolue pour la police actuelle et fontSizeMode.

fontInfo.pointSize : real [read-only]

Le pointSize de l'information de police qui a été résolu pour la police actuelle et fontSizeMode.

fontInfo.styleName : string [read-only]

Le nom du style de l'information de police qui a été résolu pour la police actuelle et fontSizeMode.

fontInfo.weight : int [read-only]

Le poids de l'information de police qui a été résolu pour la police actuelle et fontSizeMode.

fontSizeMode : enumeration

Cette propriété indique comment est déterminée la taille de la police du texte affiché. Les valeurs possibles sont les suivantes

La taille de police du texte ajusté a une limite minimale spécifiée par la propriété minimumPointSize ou minimumPixelSize et une limite maximale spécifiée par les propriétés font.pointSize ou font.pixelSize.

Text { text: "Hello"; fontSizeMode: Text.Fit; minimumPixelSize: 10; font.pixelSize: 72 }

Si le texte ne rentre pas dans les limites de l'élément avec la taille de police minimale, il sera élidé conformément à la propriété elide.

Si la propriété textFormat est définie sur Text.RichText, cela n'aura aucun effet car la propriété sera complètement ignorée. Si textFormat est défini à Text.StyledText, la propriété sera respectée à condition qu'il n'y ait pas de balises de taille de police dans le texte. S'il y a des balises de taille de police, la propriété les respectera quand même. Il se peut donc que la propriété ne soit pas entièrement conforme au paramètre fontSizeMode.

hoveredLink : string [read-only]

Cette propriété contient la chaîne du lien lorsque l'utilisateur survole un lien intégré dans le texte. Le lien doit être au format texte riche ou HTML et la chaîne hoveredLink permet d'accéder au lien en question.

Voir également linkHovered et linkAt().

lineCount : int [read-only]

Renvoie le nombre de lignes visibles dans l'élément de texte.

Cette propriété n'est pas prise en charge pour le texte enrichi.

Voir également maximumLineCount.

lineHeight : real

Définit la hauteur de ligne du texte. La valeur peut être exprimée en pixels ou en multiplicateur, selon lineHeightMode.

La valeur par défaut est un multiplicateur de 1,0. La hauteur de ligne doit être une valeur positive.

lineHeightMode : enumeration

Cette propriété détermine la manière dont la hauteur de la ligne est spécifiée. Les valeurs possibles sont les suivantes :

linkColor : color

La couleur des liens dans le texte.

Cette propriété fonctionne avec StyledText textFormat, mais pas avec RichText. La couleur des liens dans le RichText peut être spécifiée en incluant des balises de style CSS dans le texte.

maximumLineCount : int

Cette propriété permet de limiter le nombre de lignes affichées par l'élément de texte. Si elide est défini sur Text.ElideRight, le texte sera élidé de manière appropriée. Par défaut, il s'agit de la valeur du plus grand nombre entier possible.

Cette propriété n'est pas prise en charge pour le texte enrichi.

Voir également lineCount et elide.

minimumPixelSize : int

Cette propriété spécifie la taille minimale en pixels du texte mis à l'échelle par la propriété fontSizeMode.

Si la propriété fontSizeMode est Text.FixedSize ou si la propriété font.pixelSize est -1, cette propriété est ignorée.

minimumPointSize : int

Cette propriété spécifie le nombre minimum de points de police size du texte mis à l'échelle par la propriété fontSizeMode.

Si la propriété fontSizeMode est Text.FixedSize ou si la propriété font.pointSize est -1, cette propriété est ignorée.

renderType : enumeration

Remplacer le type de rendu par défaut pour ce composant.

Les types de rendu pris en charge sont les suivants

Sélectionnez Text.NativeRendering si vous préférez que le texte ait un aspect natif sur la plate-forme cible et si vous n'avez pas besoin de fonctions avancées telles que la transformation du texte. L'utilisation de ces fonctions en combinaison avec le type de rendu NativeRendering donnera des résultats médiocres et parfois pixellisés.

Text.QtRendering et Text.CurveRendering sont des techniques accélérées par le matériel. QtRendering est la plus rapide des deux, mais utilise plus de mémoire et présentera des artefacts de rendu à grande échelle. CurveRendering doit être considéré comme une alternative dans les cas où QtRendering ne donne pas de bons résultats visuels ou lorsque la réduction de la consommation de mémoire graphique est une priorité.

Le type de rendu par défaut est déterminé par QQuickWindow::textRenderType().

renderTypeQuality : int [since 6.0]

Remplacer la qualité du type de rendu par défaut pour ce composant. Il s'agit d'une personnalisation de bas niveau qui peut être ignorée dans la plupart des cas. Elle n'a actuellement d'effet que lorsque renderType est Text.QtRendering.

L'algorithme de tramage utilisé par Text.QtRendering peut produire des artefacts pour les textes de grande taille, tels que les angles aigus qui paraissent plus ronds qu'ils ne devraient l'être. Si cela pose un problème pour certains éléments de texte, augmentez la valeur de renderTypeQuality pour améliorer la qualité du rendu, au détriment de la consommation de mémoire.

La valeur renderTypeQuality peut être un nombre entier supérieur à 0 ou l'une des valeurs prédéfinies suivantes

Cette propriété a été introduite dans Qt 6.0.

style : enumeration

Définir un style de texte supplémentaire.

Les styles de texte pris en charge sont les suivants :

Row {
    Text { font.pointSize: 24; text: "Normal" }
    Text { font.pointSize: 24; text: "Raised"; style: Text.Raised; styleColor: "#AAAAAA" }
    Text { font.pointSize: 24; text: "Outline";style: Text.Outline; styleColor: "red" }
    Text { font.pointSize: 24; text: "Sunken"; style: Text.Sunken; styleColor: "#AAAAAA" }
}

styleColor : color

Définit la couleur secondaire utilisée par les styles de texte.

styleColor est utilisée comme couleur de contour pour les textes délimités et comme couleur d'ombre pour les textes en relief ou en creux. Si aucun style n'a été défini, elle n'est pas utilisée du tout.

Text { font.pointSize: 18; text: "hello"; style: Text.Raised; styleColor: "gray" }

Voir également style.

text : string

Le texte à afficher. Le texte prend en charge à la fois les chaînes de texte simple et les chaînes de texte enrichi.

L'élément tente de déterminer automatiquement si le texte doit être traité comme un texte stylé. Cette détermination se fait à l'aide de Qt::mightBeRichText(). Cependant, la détection de Markdown n'est pas automatique.

Voir également textFormat.

textFormat : enumeration

La manière dont la propriété text doit être affichée.

Les formats de texte pris en charge sont les suivants :

Si le format de texte est Text.AutoText, l'élément Texte déterminera automatiquement si le texte doit être traité comme du texte stylé. Cette détermination est faite à l'aide de Qt::mightBeRichText(), qui peut détecter la présence d'une balise HTML sur la première ligne de texte, mais ne peut pas distinguer le Markdown du texte brut.

Text.StyledText Markdown est un format optimisé prenant en charge certaines balises de style de texte de base, dans le style de HTML 3.2 :

<b></b> - bold
<del></del> - strike out (removed content)
<s></s> - strike out (no longer accurate or no longer relevant content)
<strong></strong> - bold
<i></i> - italic
<br> - new line
<p> - paragraph
<u> - underlined text
<font color="color_name" size="1-7"></font>
<h1> to <h6> - headers
<a href=""> - anchor
<img src="" align="top,middle,bottom" width="" height=""> - inline images
<ol type="">, <ul type=""> and <li> - ordered and unordered lists
<pre></pre> - preformatted
All entities

Text.StyledText l'analyseur syntaxique est strict, exigeant que les balises soient correctement imbriquées.

Column {
    Text {
        font.pointSize: 24
        text: "<b>Hello</b> <i>World!</i>"
    }
    Text {
        font.pointSize: 24
        textFormat: Text.RichText
        text: "<b>Hello</b> <i>World!</i>"
    }
    Text {
        font.pointSize: 24
        textFormat: Text.PlainText
        text: "<b>Hello</b> <i>World!</i>"
    }
    Text {
        font.pointSize: 24
        textFormat: Text.MarkdownText
        text: "**Hello** *World!*"
    }
}

Text.RichText supporte un sous-ensemble plus large de HTML 4, tel que décrit sur la page Supported HTML Subset. Il est préférable d'utiliser Text.PlainText, Text.StyledText ou Text.MarkdownText, qui offrent de meilleures performances.

• les blocs de code utilisent l'adresse default monospace font, mais sans la zone de surbrillance qui les entoure
• les blocs de guillemets sont indentés, mais il n'y a pas de ligne verticale à côté des guillemets.

truncated : bool [read-only]

Retourne true si le texte a été tronqué à cause de maximumLineCount ou elide.

Cette propriété n'est pas prise en charge pour le texte enrichi.

Voir également maximumLineCount et elide.

wrapMode : enumeration

Cette propriété permet d'adapter le texte à la largeur de l'élément textuel. Le texte ne sera enveloppé que si une largeur explicite a été définie. wrapMode peut être l'un des éléments suivants :

Documentation sur les signaux

lineLaidOut(object line)

Ce signal est émis pour chaque ligne de texte disposée au cours du processus de mise en page en mode texte simple ou texte stylé. Il n'est pas émis en mode texte enrichi. L'objet line spécifié fournit plus de détails sur la ligne en cours de mise en page.

Il permet de positionner et de redimensionner une ligne au fur et à mesure de sa mise en page. Il peut par exemple être utilisé pour créer des colonnes ou disposer du texte autour d'objets.

Les propriétés de l'objet line spécifié sont les suivantes :

Par exemple, ceci déplacera les 5 premières lignes d'un élément Text de 100 pixels vers la droite :

onLineLaidOut: (line)=> {
    if (line.number < 5) {
        line.x = line.x + 100
        line.width = line.width - 100
    }
}

L'exemple suivant permet de positionner un élément à la fin de la dernière ligne :

onLineLaidOut: (line)=> {
    if (line.isLast) {
        lastLineMarker.x = line.x + line.implicitWidth
        lastLineMarker.y = line.y + (line.height - lastLineMarker.height) / 2
    }
}

linkActivated(string link)

Ce signal est émis lorsque l'utilisateur clique sur un lien intégré dans le texte. Le lien doit être au format texte riche ou HTML et la chaîne link permet d'accéder au lien en question.

    Text {
            textFormat: Text.RichText
            text: "See the <a href=\"http://qt-project.org\">Qt Project website</a>."
            onLinkActivated: (link)=> console.log(link + " link activated")
    }

Le code de l'exemple affiche le texte "Voir le site web du projet Qt".

En cliquant sur le lien en surbrillance, la console affichera http://qt-project.org link activated.

linkHovered(string link)

Ce signal est émis lorsque l'utilisateur survole un lien intégré dans le texte. Le lien doit être au format texte riche ou HTML et la chaîne link permet d'accéder au lien en question.

Voir également hoveredLink et linkAt().

Documentation de la méthode

void forceLayout()

Déclenche une nouvelle présentation du texte affiché.

string linkAt(real x, real y)

Renvoie la chaîne du lien au point x, y en coordonnées de contenu, ou une chaîne vide si aucun lien n'existe à ce point.

Voir aussi hoveredLink.