Text QML Type

Indique comment ajouter du texte mis en forme à une scène. En savoir plus…

• 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 brut et du texte formaté. Par exemple, vous pouvez définir du texte en rouge avec une police et une taille spécifiques comme ceci :

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

Utilisez le balisage de type 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, Text tentera de déterminer l'espace nécessaire et l'ajustera en conséquence. À moins que la propriété « wrapMode » ne soit définie, il privilégiera toujours la largeur par rapport à la hauteur (tout le texte sera placé sur une seule ligne).

Pour adapter une seule ligne de texte brut à une largeur définie, vous pouvez utiliser la propriété « elide ».

La propriété `Text` fournit du texte en lecture seule. Pour du texte modifiable, voir ` TextEdit`.

Voir également l’exemple «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 d'un élément de texte et l'origine de la ligne de base du premier caractère d'un élément de texte qui suit immédiatement celui-ci dans le flux de texte.

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

antialiasing : bool

Permet de déterminer si le texte doit bénéficier d'un lissage ou non. Seuls les textes dont la propriété « renderType » est définie sur « Text.NativeRendering » peuvent désactiver le lissage.

La valeur par défaut est « true ».

baseUrl : url

Cette propriété définit une URL de base utilisée pour résoudre les URL relatives présentes 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 d'accès située après le dernier « / » sera ignorée.

La valeur par défaut est l'URL du fichier QML qui instancie l'élément Text.

Ces propriétés définissent le remplissage autour du contenu. Cet espace est réservé en plus de l'contentWidth et de l'contentHeight.

clip : bool

Cette propriété s'applique même si le texte est tronqué.

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

Si vous souhaitez afficher un texte potentiellement long dans un espace limité, vous devriez plutôt utiliser la propriété « 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 partie qui dépasse la hauteur définie, lorsque la quantité de texte est supérieure à la hauteur définie.

contentWidth : real [read-only]

Renvoie la largeur du texte, y compris la partie dépassant la largeur couverte en raison d'un retour à la ligne insuffisant si le paramètre WrapMode est défini.

Définit l'alignement horizontal et vertical du texte dans les limites de la largeur et de la hauteur des éléments « Text ». Par défaut, le texte est aligné verticalement en haut. L'alignement horizontal suit l'alignement naturel du texte ; par exemple, un texte qui se lit de gauche à droite sera aligné à gauche.

Les valeurs valides pour ` horizontalAlignment ` sont ` Text.AlignLeft`, ` Text.AlignRight`, ` Text.AlignHCenter ` et ` Text.AlignJustify`. Les valeurs valides 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 occupée par celui-ci. Dans ce cas de figure courant, tous les alignements sont équivalents. Si vous souhaitez, par exemple, que le texte soit centré dans son élément parent, vous devrez soit modifier la propriété « Item::anchors », soit définir la propriété « horizontalAlignment » sur « Text.AlignHCenter » et lier la largeur à celle de l’élément parent.

Lorsque vous utilisez la propriété associée ` LayoutMirroring::enabled ` pour refléter les mises en page de l’application, l’alignement horizontal du texte sera également reflété. Cependant, la propriété ` horizontalAlignment ` restera inchangée. Pour connaître l’alignement horizontal effectif de `Text`, utilisez la propriété en lecture seule ` effectiveHorizontalAlignment`.

elide : enumeration

Définissez cette propriété pour tronquer certaines parties du texte afin de l'adapter à la largeur de l'élément « Texte ». Le texte ne sera tronqué que si une largeur a été explicitement définie.

Cette propriété fonctionne avec les formats Text.PlainText et Text.StyledText, mais ne peut pas être utilisée avec les formats Text.RichText ou Text.MarkdownText.

L'élision peut être :

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

Si le texte est une chaîne à longueurs variables et que le mode n’est pas « Text.ElideNone », la première chaîne qui tient sera utilisée ; sinon, la dernière sera tronquée.

Les chaînes de longueurs variables sont classées de la plus longue à la plus courte, séparées par le caractère Unicode « terminateur de chaîne » U009C (à écrire en QML sous la forme "\u009C" ou "\x9C").

font.bold : bool

Détermine si la police est en gras.

font.capitalization : enumeration

Définit la casse 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 caractère donné, Qt choisit automatiquement une police de remplacement d’aspect similaire qui contient ce caractère. Par défaut, cette opération s’effectue caractère par caractère.

Cela signifie que, dans certains cas peu courants, de nombreuses polices différentes peuvent être utilisées pour représenter une même chaîne de texte, même si celle-ci appartient au même alphabet. En définissant ` contextFontMerging ` sur `true`, le système tentera plutôt de trouver la police de remplacement qui correspond au plus grand sous-ensemble de la chaîne de caractères d'entrée. Cette opération sera plus gourmande en ressources pour les chaînes comportant des glyphes manquants, mais pourra donner des résultats plus cohérents. Par défaut, la valeur de ` contextFontMerging ` est ` false`.

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

Voir également QFont::StyleStrategy.

font.family : string

Définit le nom de la famille de polices.

Le nom de la famille est insensible à la casse et peut éventuellement inclure le nom d’une fonderie, par exemple « Helvetica [Cronyx] ». Si la famille est disponible auprès de plusieurs fonderies et qu'aucune n'est spécifiée, une fonderie est choisie au hasard. Si la famille n'est pas disponible, une famille sera définie à l'aide de l'algorithme de correspondance des polices.

font.features : object [since 6.6]

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

Les fonctionnalités de police sont représentées par une correspondance entre des balises de 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, tandis qu’une valeur non nulle signifie qu’elle est activée. Pour certaines fonctionnalités de police, cependant, elle peut avoir d’autres interprétations. Par exemple, lorsqu’elle est appliquée à la fonctionnalité « salt », la valeur est un index qui spécifie l’alternative stylistique à utiliser.

Par exemple, la fonctionnalité de police « frac » convertira les fractions diagonales séparées par une barre oblique (telles que 1/2) en une représentation différente. Généralement, cela implique de regrouper la fraction complète dans la largeur d’un seul caractère (comme ½).

Si une police prend en charge la fonctionnalité « frac », celle-ci peut être activée dans le shaper comme dans le code suivant :

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

Plusieurs fonctionnalités peuvent se voir attribuer des valeurs 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 regrouper 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 }
    }
}

dlig, hlig) seront désactivées si une valeur est définie pour font.letterSpacing, mais uniquement pour les systèmes d’écriture où l’utilisation des ligatures est purement esthétique. Pour les systèmes d’écriture où les ligatures sont obligatoires, ces fonctionnalités conserveront leur état par défaut. Les valeurs définies à l’aide de ` font.features ` remplaceront le comportement par défaut. Si, par exemple, ` "kern" ` est défini sur 1, le crénage sera toujours activé, que la propriété ` font::kerning ` soit définie sur `false` ou non. De même,

si elle est définie sur 0, il sera toujours désactivé.

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

Voir également QFont::setFeature().

font.hintingPreference : enumeration

Définit le niveau de « hinting » souhaité pour le texte.

Il s'agit d'une indication donnée au système de rendu de texte sous-jacent afin qu'il utilise un certain niveau de hinting ; la prise en charge varie selon les plateformes. Consultez le tableau figurant dans la documentation relative à QFont::HintingPreference pour plus de détails.

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

font.italic : bool

Détermine si la police dispose d'un style italique.

font.kerning : bool

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

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

font.letterSpacing : real

Définit l'espacement entre les lettres de la police.

L'espacement des lettres modifie l'espacement par défaut entre les lettres de la police. Une valeur positive augmente l'espacement des lettres du nombre de pixels correspondant ; une valeur négative le réduit.

font.pixelSize : int

Définit la taille de la police en pixels.

L'utilisation de cette fonction rend la police dépendante du périphérique. Utilisez ` pointSize ` pour définir la taille de la police de manière indépendante du périphérique.

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

Il arrive parfois qu’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 l’écriture latine, par exemple, il s’agit simplement d’une fonctionnalité esthétique. Définir la propriété preferShaping sur false désactivera toutes ces fonctionnalités lorsqu’elles ne sont pas nécessaires, ce qui améliorera 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]

des jeux concurrents de métriques de lignes verticales qui fournissent les valeurs « ascent », « descent » et « leading » de la police. On les appelle souvent les métriques « win » (Windows) et les métriques « typo » (typographiques). Bien que la spécification recommande d’utiliser les métriques « typo » pour l’espacement des lignes, de nombreuses applications préfèrent les métriques « win », sauf si l’indicateur « USE_TYPO_METRICS » est activé dans le champ fsSelection de la police. Pour des raisons de compatibilité ascendante, c’est également le cas pour les applications Qt. Cela ne pose pas de problème pour les polices qui activent l’indicateur « USE_TYPO_METRICS » afin d’indiquer que les métriques « typo » sont valides, ni pour celles où les métriques « win » et « typo » correspondent. Cependant, pour certaines polices, les métriques « win » peuvent être supérieures à l’espacement de ligne souhaité et l’indicateur « USE_TYPO_METRICS » peut être désactivé par erreur. Pour ces polices, l’activation de « font.preferTypoLineMetrics » peut donner de meilleurs résultats.

Par défaut, la valeur de ` preferTypoLineMetrics ` est ` false`.

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

Voir également QFont::StyleStrategy.

font.strikeout : bool

Détermine si la police dispose d'un style barré.

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 sélectionnée en fonction du nom du style plutôt qu'en fonction des propriétés de police suivantes : font.weight, font.bold et font.italic.

font.underline : bool

Détermine 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 variantes (avec des graisses, des largeurs ou des styles différents) dans un même fichier de police. Les variantes sont définies sous forme de valeurs à virgule flottante pour un ensemble prédéfini de paramètres, appelés « axes variables ». Les instances spécifiques sont généralement nommées par le concepteur de police et, dans Qt, elles peuvent être sélectionnées à l'aide de la fonction 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 comporte une sous-famille Regular et une sous-famille Bold, vous pouvez souhaiter obtenir une épaisseur intermédiaire entre les deux. Vous pouvez alors en faire la demande 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 à l’épaisseur 550,0 sera fournie.

Il existe quelques axes standard proposés par de nombreuses polices, tels que « wght » (épaisseur), « wdth » (largeur), « ital » (italique) et « opsz » (taille optique). Chacun d’entre eux dispose d’une plage de valeurs définie dans la police elle-même. Par exemple, « wght » peut aller de 100 à 900 (QFont::Thin à QFont::Black), tandis que « ital » peut aller de 0 à 1 (de non italique à entièrement italique).

Une police peut également choisir de définir des axes personnalisés ; la seule contrainte est que le nom doit respecter les exigences d’un QFont::Tag (séquence de quatre caractères Latin-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

L'épaisseur demandée pour la police. L'épaisseur demandée doit être un nombre entier compris entre 1 et 1 000, ou l'une des valeurs prédéfinies suivantes :

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

font.wordSpacing : real

Définit l'espacement entre les mots pour la police.

L'espacement entre les mots modifie l'espacement par défaut entre les mots. Une valeur positive augmente l'espacement entre les mots d'un nombre correspondant de pixels, tandis qu'une valeur négative le réduit d'autant.

fontInfo.bold : bool [read-only]

Le statut « gras » de l'information relative à la police qui a été résolue pour la police actuelle et fontSizeMode. Cette valeur est vraie si l'épaisseur de la police résolue est « gras » ou supérieure.

fontInfo.family : string [read-only]

Nom de famille de la police qui a été déterminé pour la police actuelle et fontSizeMode.

fontInfo.italic : bool [read-only]

L'état « italique » de la police, tel qu'il a été déterminé pour la police actuelle et fontSizeMode.

fontInfo.pixelSize : int [read-only]

La taille en pixels des informations relatives à la police qui a été déterminée pour la police actuelle et fontSizeMode.

fontInfo.pointSize : real [read-only]

La valeur « pointSize » des informations de police qui a été déterminée pour la police actuelle et fontSizeMode.

fontInfo.styleName : string [read-only]

Nom de style des informations de police qui ont été déterminées pour la police actuelle et fontSizeMode.

fontInfo.weight : int [read-only]

Le poids des informations de police qui ont été déterminées pour la police actuelle et fontSizeMode.

fontSizeMode : enumeration

Cette propriété définit la manière dont la taille de la police du texte affiché est déterminée. Les valeurs possibles sont les suivantes :

La taille de police du texte ajusté est soumise à une limite minimale définie par la propriété minimumPointSize ou minimumPixelSize et à une limite maximale définie 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 tient pas dans les limites de l’élément avec la taille de police minimale, il sera tronqué 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 sur ` Text.StyledText`, la propriété sera alors respectée à condition qu’il n’y ait pas de balises de taille de police à l’intérieur du texte. S’il y a des balises de taille de police, la propriété les respectera tout de même. Cela peut entraîner une non-conformité totale avec le paramètre `fontSizeMode`.

hoveredLink : string [read-only]

Cette propriété contient la chaîne de caractères du lien lorsque l'utilisateur passe la souris sur un lien intégré dans le texte. Le lien doit être au format RTF ou HTML, et la chaîne « hoveredLink » permet d'accéder à ce lien spécifique.

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 aussi maximumLineCount.

lineHeight : real

Définit la hauteur de ligne du texte. La valeur peut être exprimée en pixels ou sous forme de multiplicateur, selon la propriété « 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 ligne est définie. Les valeurs possibles sont les suivantes :

linkColor : color

La couleur des liens dans le texte.

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

maximumLineCount : int

Définissez cette propriété pour limiter le nombre de lignes que l'élément de texte affichera. Si la propriété « elide » est définie sur « Text.ElideRight », le texte sera tronqué de manière appropriée. Par défaut, cette valeur correspond au plus grand 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 de la police du texte mis à l'échelle par la propriété « fontSizeMode ».

Si la propriété « fontSizeMode » est définie sur « Text.FixedSize » ou si la valeur « font.pixelSize » est égale à -1, cette propriété est ignorée.

minimumPointSize : int

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

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

renderType : enumeration

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

Les types de rendu pris en charge sont les suivants :

Sélectionnez « Text.NativeRendering » si vous préférez que le texte s'affiche de manière native sur la plateforme cible et si vous n'avez pas besoin de fonctionnalités avancées telles que la transformation du texte. L'utilisation de ces fonctionnalités en combinaison avec le type de rendu « NativeRendering » donnera des résultats médiocres et parfois pixélisés.

Text.QtRendering et Text.CurveRendering sont toutes deux des techniques accélérées par le matériel. QtRendering est la plus rapide des deux, mais elle utilise davantage de mémoire et présente des artefacts de rendu sur les grandes tailles. CurveRendering doit être envisagé comme une alternative lorsque 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 la fonction QQuickWindow::textRenderType().

renderTypeQuality : int [since 6.0]

Remplace la qualité par défaut du type de rendu 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 défini sur ` Text.QtRendering`.

L’algorithme de rastérisation utilisé par Text.QtRendering peut générer des artefacts lorsque la taille du texte est importante, par exemple des angles vifs qui apparaissent plus arrondis qu’ils ne devraient l’être. Si cela pose problème pour certains éléments de texte, augmentez la valeur de ` renderTypeQuality ` pour améliorer la qualité de rendu, au détriment de la consommation de mémoire.

L’ renderTypeQuality peut être n’importe quel 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éfinissez 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 Elle sert de couleur de contour pour le texte contourné, et de couleur d’ombre pour le texte 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

Texte à afficher. Le texte peut être au format brut ou enrichi.

L'élément tentera de déterminer automatiquement si le texte doit être traité comme du texte formaté. Cette détermination s'effectue à l'aide de la fonction Qt::mightBeRichText(). Cependant, la détection du Markdown n'est pas automatique.

Voir également textFormat.

textFormat : enumeration

Mode d'affichage de la propriété « text ».

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 mis en forme. Cette détermination s’effectue à l’aide de la fonction 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 Il s’agit d’un format optimisé prenant en charge certaines balises de mise en forme de texte de base, à la manière du 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 est strict et exige 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 prend en charge un sous-ensemble plus large de HTML 4, comme décrit sur la page « Sous-ensemble HTML pris en charge ». Il est préférable d’utiliser plutôt Text.PlainText, Text.StyledText ou Text.MarkdownText, car ils offrent de meilleures performances.

• les blocs de code utilisent le format default monospace font, mais sans encadré de mise en évidence
• les citations en bloc sont indentées, mais aucune ligne verticale n’accompagne la citation

truncated : bool [read-only]

Renvoie « true » si le texte a été tronqué en raison d'une erreur de type « maximumLineCount » ou « elide ».

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

Voir également maximumLineCount et elide.

wrapMode : enumeration

Définissez cette propriété pour que le texte s'adapte à la largeur de l'élément « Text ». Le texte ne s'adaptera que si une largeur a été explicitement définie. La propriété « wrapMode » peut prendre l'une des valeurs suivantes :

Documentation Signal

lineLaidOut(object line)

Ce signal est émis pour chaque ligne de texte mise en page au cours du processus de mise en page, en mode texte brut ou texte formaté. Il n'est pas émis en mode texte enrichi. L'objet ` line ` spécifié fournit davantage de détails sur la ligne en cours de mise en page.

Cela permet de positionner et de redimensionner une ligne au fur et à mesure de sa mise en page. Cette fonctionnalité peut par exemple être utilisée pour créer des colonnes ou pour mettre du texte en page autour d’objets.

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

Par exemple, cela 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 vous permettra 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 RTF ou HTML, et la chaîne « link » permet d'accéder à ce lien spécifique.

    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 d'exemple affichera le texte « Consultez le site web du projet Qt. »

En cliquant sur le lien surligné, la chaîne http://qt-project.org link activated s'affichera dans la console.

linkHovered(string link)

Ce signal est émis lorsque l'utilisateur passe la souris sur un lien intégré dans le texte. Le lien doit être au format RTF ou HTML, et la chaîne « link » permet d'accéder à ce lien spécifique.

Voir également hoveredLink et linkAt().

Documentation de la méthode

void forceLayout()

Déclenche un réagencement du texte affiché.

string linkAt(real x, real y)

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

Voir également hoveredLink.