TextEdit QML Type

Affiche plusieurs lignes de texte formaté modifiable. Plus d'informations...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• activeFocusOnPress : bool
• baseUrl : url
• bottomPadding : real
• canPaste : bool
• canRedo : bool
• canUndo : bool
• color : color
• contentHeight : real
• contentWidth : real
• cursorDelegate : Component
• cursorPosition : int
• cursorRectangle : rectangle
• cursorSelection : QtQuick::TextSelection (preliminary)
• cursorVisible : bool
• effectiveHorizontalAlignment : 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
• horizontalAlignment : enumeration
• hoveredLink : string
• inputMethodComposing : bool
• inputMethodHints : enumeration
• leftPadding : real
• length : int
• lineCount : int
• mouseSelectionMode : enumeration
• overwriteMode : bool
• padding : real
• persistentSelection : bool
• preeditText : string
• readOnly : bool
• renderType : enumeration
• rightPadding : real
• selectByKeyboard : bool
• selectByMouse : bool
• selectedText : string
• selectedTextColor : color
• selectionColor : color
• selectionEnd : int
• selectionStart : int
• tabStopDistance : real
• text : string
• textDocument : TextDocument
• textFormat : enumeration
• textMargin : real
• topPadding : real
• verticalAlignment : enumeration
• wrapMode : enumeration

Signaux

• editingFinished()
• linkActivated(string link)
• linkHovered(string link)
• textEdited() (since 6.9)

Méthodes

• void append(string text)
• void clear()
• void copy()
• void cut()
• void deselect()
• string getFormattedText(int start, int end)
• string getText(int start, int end)
• void insert(int position, string text)
• bool isRightToLeft(int start, int end)
• string linkAt(real x, real y)
• void moveCursorSelection(int position, SelectionMode mode)
• void paste()
• int positionAt(int x, int y)
• rectangle positionToRectangle(position)
• void redo()
• string remove(int start, int end)
• void select(int start, int end)
• void selectAll()
• void selectWord()
• void undo()

Description détaillée

L'élément TextEdit affiche un bloc de texte éditable et formaté.

Il peut afficher à la fois du texte simple et du texte enrichi. Par exemple :

TextEdit {
    width: 240
    text: "<b>Hello</b> <i>World!</i>"
    font.family: "Helvetica"
    font.pointSize: 20
    color: "blue"
    focus: true
}

Le fait de définir focus sur true permet à l'élément TextEdit de recevoir le focus clavier.

Notez que l'élément TextEdit n'implémente pas le défilement, le suivi du curseur ou d'autres comportements spécifiques à une apparence. Par exemple, il est possible d'ajouter un défilement variable qui suit le curseur :

Flickable {
     id: flick

     width: 300; height: 200;
     contentWidth: edit.contentWidth
     contentHeight: edit.contentHeight
     clip: true

     function ensureVisible(r)
     {
         if (contentX >= r.x)
             contentX = r.x;
         else if (contentX+width <= r.x+r.width)
             contentX = r.x+r.width-width;
         if (contentY >= r.y)
             contentY = r.y;
         else if (contentY+height <= r.y+r.height)
             contentY = r.y+r.height-height;
     }

     TextEdit {
         id: edit
         width: flick.width
         focus: true
         wrapMode: TextEdit.Wrap
         onCursorRectangleChanged: flick.ensureVisible(cursorRectangle)
     }
 }

Une présentation particulière peut utiliser un défilement fluide (par exemple, en utilisant SmoothedAnimation), avoir une barre de défilement visible ou une barre de défilement qui s'estompe pour indiquer l'emplacement, etc.

La prise en charge du presse-papiers est assurée par les fonctions cut(), copy() et paste(). Le texte peut être sélectionné à l'aide de la souris de la manière habituelle, sauf si selectByMouse est défini sur false; et au clavier avec les combinaisons de touches Shift+arrow, sauf si selectByKeyboard est défini sur false. Pour sélectionner du texte par programme, vous pouvez définir les propriétés selectionStart et selectionEnd, ou utiliser selectAll() ou selectWord().

Vous pouvez effectuer la conversion entre les positions du curseur (caractères à partir du début du document) et les points de pixels en utilisant positionAt() et positionToRectangle().

Voir aussi Text, TextInput, TextArea, et Qt Quick Contrôles - Éditeur de texte.

Documentation sur les propriétés

activeFocusOnPress : bool

Indique si l'adresse TextEdit doit être activée lorsque l'on appuie sur la souris. Par défaut, cette valeur est fixée à true (vrai).

baseUrl : url

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

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

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

canPaste : bool [read-only]

Retourne true si le site TextEdit est accessible en écriture et si le contenu du presse-papier peut être collé dans le site TextEdit.

canRedo : bool [read-only]

Retourne true si le site TextEdit est accessible en écriture et s'il existe des opérations undone qui peuvent être refaites.

canUndo : bool [read-only]

Retourne true si le site TextEdit est accessible en écriture et si des opérations précédentes peuvent être annulées.

color : color

La couleur du texte.

// green text using hexadecimal notation
TextEdit { color: "#00FF00" }

// steelblue text using SVG color name
TextEdit { color: "steelblue" }

contentHeight : real [read-only]

Renvoie la hauteur du texte, y compris la hauteur au-delà de la hauteur qui est couverte si le texte ne tient pas dans la hauteur définie.

contentWidth : real [read-only]

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

cursorDelegate : Component

Le délégué du curseur dans le site TextEdit.

Si vous définissez un cursorDelegate pour un TextEdit, ce délégué sera utilisé pour dessiner le curseur au lieu du curseur standard. Une instance du délégué sera créée et gérée par l'éditeur de texte lorsqu'un curseur sera nécessaire, et les propriétés x et y de l'instance du délégué seront définies de manière à se situer un pixel avant le coin supérieur gauche du caractère actuel.

Notez que l'élément racine du composant délégué doit être un élément dérivé QQuickItem ou QQuickItem.

cursorPosition : int

La position du curseur dans le fichier TextEdit. Le curseur est positionné entre les caractères.

cursorRectangle : rectangle [read-only]

Le rectangle dans lequel le curseur de texte standard est affiché dans l'édition de texte. En lecture seule.

La position et la hauteur d'une page cursorDelegate personnalisée sont mises à jour automatiquement en fonction du rectangle du curseur lorsque celui-ci est modifié. La largeur du délégué n'est pas affectée par les modifications du rectangle du curseur.

cursorSelection : QtQuick::TextSelection [read-only, preliminary]

Cette propriété est en cours de développement et peut être modifiée.

Cette propriété est un objet qui fournit les propriétés du texte actuellement sélectionné, le cas échéant, à côté du curseur de texte.

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

Voir aussi selectedText, selectionStart, et selectionEnd.

cursorVisible : bool

Si true, l'éditeur de texte affiche un curseur.

Cette propriété est activée et désactivée lorsque l'éditeur de texte obtient le focus actif, mais elle peut également être définie directement (utile, par exemple, si un KeyProxy peut lui transmettre des touches).

Définit l'alignement horizontal et vertical du texte dans la largeur et la hauteur de l'élément TextEdit. Par défaut, l'alignement du texte suit l'alignement naturel du texte, par exemple un texte qui se lit de gauche à droite sera aligné à gauche.

Les valeurs valables pour horizontalAlignment sont les suivantes

Les valeurs valides pour verticalAlignment sont :

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

font.bold : bool

Définit si la police est en gras.

font.capitalization : enumeration

Définit la capitalisation du texte.

TextEdit { 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.

TextEdit { text: "Hello"; renderType: TextEdit.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.

TextEdit { text: "OATS FLAVOUR WAY"; kerning: font.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 TextEdit::font.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, toutes ces caractéristiques seront désactivées 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.

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

font.preferTypoLineMetrics : bool [since 6.8]

les ensembles 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 :

TextEdit { 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.

hoveredLink : string [read-only]

Cette propriété contient la chaîne de 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 de lien permet d'accéder au lien en question.

Voir également linkHovered et linkAt().

inputMethodComposing : bool [read-only]

Cette propriété indique si le site TextEdit a reçu un texte partiel provenant d'une méthode de saisie.

Pendant qu'elle compose, une méthode de saisie peut s'appuyer sur des événements souris ou clavier provenant de TextEdit pour modifier ou valider le texte partiel. Cette propriété peut être utilisée pour déterminer quand désactiver les gestionnaires d'événements susceptibles d'interférer avec le bon fonctionnement d'une méthode de saisie.

inputMethodHints : enumeration

Fournit des indications à la méthode d'entrée sur le contenu attendu de l'édition de texte et sur la manière dont elle doit fonctionner.

La valeur est une combinaison bit à bit de drapeaux ou Qt.ImhNone si aucun indice n'est défini.

Les drapeaux qui modifient le comportement sont

Les drapeaux qui limitent la saisie (drapeaux exclusifs) sont les suivants :

Masques :

length : int [read-only]

Renvoie le nombre total de caractères de texte brut dans l'élément TextEdit.

Comme ce nombre n'inclut aucune marque de formatage, il peut être différent de la longueur de la chaîne renvoyée par la propriété text.

Cette propriété peut être plus rapide que l'interrogation de la longueur de la propriété text car elle ne nécessite aucune copie ou conversion des données de chaîne internes de TextEdit.

lineCount : int [read-only]

Renvoie le nombre total de lignes dans l'article TextEdit.

mouseSelectionMode : enumeration

Spécifie comment le texte doit être sélectionné à l'aide de la souris.

Cette propriété ne s'applique que si selectByMouse est vrai.

overwriteMode : bool

Si le texte saisi par l'utilisateur écrase le texte existant.

Comme de nombreux éditeurs de texte, le widget de l'éditeur de texte peut être configuré pour insérer ou remplacer le texte existant par le nouveau texte saisi par l'utilisateur.

Si cette propriété vaut true, le texte existant est remplacé, caractère par caractère, par le nouveau texte ; sinon, le texte est inséré à la position du curseur, en déplaçant le texte existant.

Par défaut, cette propriété vaut false (le nouveau texte n'écrase pas le texte existant).

persistentSelection : bool

Indique si le site TextEdit doit maintenir la sélection visible lorsqu'elle perd le focus actif au profit d'un autre élément de la scène. Par défaut, cette valeur est fixée à false.

preeditText : string [read-only]

Cette propriété contient du texte partiel provenant d'une méthode d'entrée.

Pour désactiver le texte partiel résultant des prédictions, activez l'indicateur Qt.ImhNoPredictiveText dans inputMethodHints.

Voir aussi inputMethodHints.

readOnly : bool

Indique si l'utilisateur peut interagir avec l'élément TextEdit. Si la valeur de cette propriété est "true", le texte ne peut pas être modifié par l'interaction de l'utilisateur.

Par défaut, cette propriété est fixée à false.

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 TextEdit.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.

TextEdit.QtRendering et TextEdit.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().

selectByKeyboard : bool

La valeur par défaut est true lorsque l'éditeur est modifiable, et false lorsqu'il est en lecture seule.

Si true, l'utilisateur peut utiliser le clavier pour sélectionner du texte même si l'éditeur est en lecture seule. Si false, l'utilisateur ne peut pas utiliser le clavier pour sélectionner du texte même si l'éditeur est modifiable.

Voir aussi readOnly.

selectByMouse : bool

La valeur par défaut est true depuis Qt 6.4.

Si true, l'utilisateur peut utiliser la souris pour sélectionner le texte de la manière habituelle.

selectedText : string [read-only]

Cette propriété en lecture seule fournit le texte actuellement sélectionné dans l'édition de texte.

Elle est équivalente à l'extrait suivant, mais elle est plus rapide et plus facile à utiliser.

//myTextEdit is the id of the TextEdit
myTextEdit.text.toString().substring(myTextEdit.selectionStart,
        myTextEdit.selectionEnd);

selectedTextColor : color

La couleur du texte sélectionné, utilisée dans les sélections.

selectionColor : color

La couleur de mise en évidence du texte, utilisée derrière les sélections.

selectionEnd : int [read-only]

La position du curseur après le dernier caractère de la sélection actuelle.

Cette propriété est en lecture seule. Pour modifier la sélection, utilisez select(start,end), selectAll() ou selectWord().

Voir également selectionStart, cursorPosition, et selectedText.

selectionStart : int [read-only]

La position du curseur avant le premier caractère de la sélection actuelle.

Cette propriété est en lecture seule. Pour modifier la sélection, utilisez select(start,end), selectAll() ou selectWord().

Voir également selectionEnd, cursorPosition, et selectedText.

tabStopDistance : real

Distance par défaut, en unités de mesure, entre les taquets de tabulation.

Voir aussi QTextOption::setTabStopDistance().

text : string

Le texte à afficher. Si le format de texte est AutoText, l'éditeur de texte déterminera automatiquement si le texte doit être traité comme du texte enrichi. Cette détermination se fait à l'aide de Qt::mightBeRichText(). Cependant, la détection de Markdown n'est pas automatique.

La propriété text est surtout adaptée à la définition du contenu initial et à la gestion des modifications apportées à des textes relativement peu volumineux. Les méthodes append(), insert() et remove() offrent un contrôle plus fin et des performances remarquablement meilleures pour la modification d'un contenu textuel riche et particulièrement volumineux.

Notez que certains claviers utilisent une fonction prédictive. Dans ce cas, le texte composé par la méthode de saisie ne fait pas partie de cette propriété. La partie du texte liée aux prédictions est soulignée et stockée dans la propriété preeditText.

Si vous avez utilisé TextDocument::source pour charger du texte, vous pouvez récupérer le texte chargé dans cette propriété. Dans ce cas, vous pouvez modifier textFormat pour effectuer des conversions de format qui modifieront la valeur de la propriété text. Par exemple, si textFormat est RichText ou AutoText et que vous chargez un fichier HTML, puis que vous définissez textFormat à MarkdownText, la propriété text contiendra la conversion de HTML en Markdown.

Voir aussi clear(), preeditText, et textFormat.

textDocument : TextDocument [read-only]

Renvoie l'adresse QQuickTextDocument de cette TextEdit. Depuis Qt 6.7, il dispose de fonctions de chargement et d'enregistrement de fichiers. Il peut également être utilisé en C++ comme moyen d'accéder à l'instance QTextDocument sous-jacente, par exemple pour installer un QSyntaxHighlighter.

Voir également QQuickTextDocument.

textFormat : enumeration

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

Les formats de texte pris en charge sont les suivants :

La valeur par défaut est TextEdit.PlainText. Si le format de texte est défini sur TextEdit.AutoText, l'éditeur de texte déterminera automatiquement si le texte doit être traité comme du texte enrichi. Si la propriété text est définie, cette détermination est effectuée à 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 texte Markdown du texte simple. Si la propriété TextDocument::source est définie, cette détermination est faite à partir de la page mime type of the file.

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

Avec TextEdit.MarkdownText, les cases à cocher résultant de l'utilisation de l'extension GitHub checkbox sont vérifiables de manière interactive.

Si la propriété TextDocument::source est définie, la modification de la propriété textFormat après le chargement a pour effet de convertir le format détecté au format demandé. Par exemple, vous pouvez convertir entre HTML et Markdown. Cependant, si l'un de ces formats "riches" est chargé et que vous définissez ensuite textFormat en PlainText, TextEdit affichera le balisage brut. Ainsi, des liaisons appropriées (par exemple à un contrôle vérifiable) peuvent permettre à l'utilisateur d'alterner entre l'édition "brute" et l'édition WYSIWYG.

• les blocs de code utilisent l'adresse default monospace font mais ne sont pas entourés d'une zone de surbrillance
• les blocs de guillemets sont indentés, mais il n'y a pas de ligne verticale à côté de la citation

textMargin : real

La marge, en pixels, autour du texte dans le site TextEdit.

wrapMode : enumeration

Cette propriété permet d'adapter le texte à la largeur de l'élément TextEdit. Le texte ne sera enveloppé que si une largeur explicite a été définie.

La valeur par défaut est TextEdit.NoWrap. Si vous définissez une largeur, envisagez d'utiliser TextEdit.Wrap.

Documentation sur les signaux

editingFinished()

Ce signal est émis lorsque l'édition de texte perd le focus.

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.

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().

[since 6.9] textEdited()

Ce signal est émis lorsque le texte est modifié. Contrairement à textChanged(), ce signal n'est pas émis lorsque le texte est modifié par programme, par exemple en changeant la valeur de la propriété text ou en appelant clear().

Ce signal a été introduit dans Qt 6.9.

Documentation de la méthode

void append(string text)

Ajoute un nouveau paragraphe avec text à la fin de TextEdit.

Pour ajouter un paragraphe sans en insérer un nouveau, appelez plutôt myTextEdit.insert(myTextEdit.length, text).

void clear()

Efface le contenu de l'édition de texte et réinitialise les entrées de texte partielles provenant d'une méthode d'entrée.

Utilisez cette méthode au lieu de donner à la propriété text la valeur d'une chaîne vide.

Voir aussi QInputMethod::reset().

void copy()

Copie le texte sélectionné dans le presse-papiers du système.

void cut()

Déplace le texte sélectionné dans le presse-papiers du système.

void deselect()

Supprime la sélection de texte active.

string getFormattedText(int start, int end)

Renvoie la section de texte qui se trouve entre les positions start et end.

Le texte retourné sera formaté selon la propriété textFormat.

string getText(int start, int end)

Renvoie la section de texte située entre les positions start et end.

Le texte renvoyé n'inclut pas de formatage de texte riche.

void insert(int position, string text)

Insère text dans le site TextEdit à l'adresse position.

bool isRightToLeft(int start, int end)

Renvoie true si le sens de lecture naturel du texte de l'éditeur trouvé entre les positions start et end est de droite à gauche.

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.

void moveCursorSelection(int position, SelectionMode mode)

Déplace le curseur sur position et met à jour la sélection en fonction du paramètre facultatif mode. (Pour ne déplacer que le curseur, définissez la propriété cursorPosition.)

Lorsque cette méthode est appelée, elle place également selectionStart ou selectionEnd (selon la position précédente du curseur) à la position spécifiée. Cela vous permet d'étendre ou de réduire facilement la plage de texte sélectionnée.

Le mode de sélection indique si la sélection est mise à jour par caractère ou par mot. S'il n'est pas spécifié, le mode de sélection sera par défaut TextEdit.SelectCharacters.

Prenons par exemple cette séquence d'appels :

cursorPosition = 5
moveCursorSelection(9, TextEdit.SelectCharacters)
moveCursorSelection(7, TextEdit.SelectCharacters)

Ceci déplace le curseur à la position 5, étend l'extrémité de la sélection de 5 à 9, puis rétracte l'extrémité de la sélection de 9 à 7, en laissant le texte des positions 5 à 7 sélectionné (les 6e et 7e caractères).

La même séquence avec TextEdit.SelectWords étendra le début de la sélection à une limite de mot avant ou sur la position 5 et étendra la fin de la sélection à une limite de mot sur ou après la position 9.

void paste()

Remplace le texte sélectionné par le contenu du presse-papiers du système.

int positionAt(int x, int y)

Renvoie la position du texte la plus proche de la position du pixel (x, y).

La position 0 est avant le premier caractère, la position 1 est après le premier caractère mais avant le deuxième, et ainsi de suite jusqu'à la position text.length, qui est après tous les caractères.

rectangle positionToRectangle(position)

Renvoie le rectangle situé à l'adresse position dans le texte. Les propriétés x, y et height correspondent au curseur qui décrirait cette position.

void redo()

Refait la dernière opération si redo est available.

string remove(int start, int end)

Supprime la section de texte qui se trouve entre les positions start et end du site TextEdit.

void select(int start, int end)

Sélectionne le texte compris entre start et end.

Si le début ou la fin est en dehors de la plage, la sélection n'est pas modifiée.

Après cet appel, selectionStart devient le plus petit et selectionEnd le plus grand (quel que soit l'ordre transmis à cette méthode).

Voir également selectionStart et selectionEnd.

void selectAll()

Permet de sélectionner tout le texte.

void selectWord()

Sélectionne le mot le plus proche de la position actuelle du curseur.

void undo()

Annule la dernière opération si l'option d'annulation se trouve à l'adresse available. Désélectionne toute sélection en cours et met à jour le début de la sélection à la position actuelle du curseur.