TextEdit QML Type

Affiche plusieurs lignes de texte formaté modifiable. En savoir plus…

• 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 (technology preview)
• 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 formaté et modifiable.

Il peut afficher aussi bien du texte brut que 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
}

En définissant focus sur true, l’élément TextEdit peut 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 interface graphique. Par exemple, pour ajouter un défilement par effleurement 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 interface graphique particulière peut utiliser un défilement fluide (par exemple, à l’aide de ` SmoothedAnimation`), disposer d’une barre de défilement visible ou d’une barre de défilement qui s’affiche progressivement pour indiquer la position, etc.

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

Vous pouvez convertir les positions du curseur (caractères à partir du début du document) en coordonnées de pixels, et inversement, à l'aide des méthodes positionAt() et positionToRectangle().

Voir également Text, TextInput, TextArea et Qt Quick Controls - Éditeur de texte.

Documentation sur les propriétés

activeFocusOnPress : bool

Détermine si l'TextEdit e doit devenir active lors d'un clic de souris. Par défaut, cette option est activée.

baseUrl : url

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

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

Ces propriétés définissent le remplissage autour du contenu. Cet espace est réservé en plus des propriétés « contentWidth » et « contentHeight ».

canPaste : bool [read-only]

Renvoie « true » si l'TextEdit est accessible en écriture et si le contenu du presse-papiers peut être collé dans l'TextEdit.

canRedo : bool [read-only]

Renvoie « true » si l'TextEdit est accessible en écriture et s'il existe des opérations d'undone s pouvant être rétablies.

canUndo : bool [read-only]

Renvoie « true » si l'TextEdit t est accessible en écriture et s'il existe des opérations précédentes pouvant ê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 partie dépassant la hauteur définie si le texte ne tient pas dans l'espace alloué.

contentWidth : real [read-only]

Renvoie la largeur du texte, y compris la partie dépassant la largeur prévue en raison d'un retour à la ligne insuffisant si l'option « wrapMode » est activée.

cursorDelegate : Component

Le délégué chargé du curseur dans l'TextEdit.

Si vous définissez un `cursorDelegate` pour un ` TextEdit`, ce délégué sera utilisé pour dessiner le curseur à la place du curseur standard. Une instance du délégué sera créée et gérée par le champ de saisie de texte lorsqu’un curseur est 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é de ` QQuickItem ` ou ` QQuickItem `.

cursorPosition : int

La position du curseur dans l'TextEdit. Le curseur est positionné entre deux caractères.

cursorRectangle : rectangle [read-only]

Le rectangle dans lequel le curseur de texte standard s'affiche dans la zone d'édition de texte. En lecture seule.

La position et la hauteur d'une « cursorDelegate » personnalisée sont mises à jour automatiquement pour suivre le rectangle du curseur (cursorRectangle) lorsqu'il change. La largeur de la « » n'est pas affectée par les modifications apportées au rectangle du curseur.

cursorSelection : QtQuick::TextSelection [read-only, technology preview]

Cette propriété est en phase de prévisualisation technique et est susceptible d'ê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 également selectedText, selectionStart et selectionEnd.

cursorVisible : bool

Si cette propriété est définie sur « true », le champ de saisie affiche un curseur.

Cette propriété est activée et désactivée lorsque le champ de saisie reçoit le focus, mais elle peut également être définie directement (ce qui est utile, par exemple, si un KeyProxy doit lui transmettre des touches).

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

Les valeurs valides pour ` horizontalAlignment ` sont les suivantes :

Les valeurs valides pour ` verticalAlignment ` sont :

Lorsque vous utilisez la propriété associée LayoutMirroring::enabled pour inverser la disposition de l'application, l'alignement horizontal du texte est également inversé. Cependant, la propriété horizontalAlignment reste inchangée. Pour connaître l'alignement horizontal effectif de TextEdit, utilisez la propriété en lecture seule effectiveHorizontalAlignment.

font.bold : bool

Détermine si la police est en gras.

font.capitalization : enumeration

Définit la casse 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 caractère donné, Qt choisit automatiquement une police de secours 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 rares, 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 secours qui correspond au plus grand sous-ensemble de la chaîne 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'un éditeur, 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. Dans la plupart des cas, cette valeur entière transmise avec la balise correspond à une valeur booléenne : une valeur nulle signifie que la fonctionnalité est désactivée, tandis qu’une valeur non nulle indique 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 » convertit 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 un seul caractère (tel que ½).

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 la propriété 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 d'optimisation, dont 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 ` TextEdit::font.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 ensembles concurrents de mesures de ligne verticale qui fournissent les valeurs « ascent », « descent » et « leading » de la police. On les appelle souvent les mesures « win » (Windows) et les mesures « 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 » pour 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, « preferTypoLineMetrics » est défini sur « 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 de style n'est pas sensible à la casse. S'il est défini, la police sera sélectionnée en fonction du nom de 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 créateur de la 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 » (gras), « wdth » (largeur), « ital » (italique) et « opsz » (taille optique). Chacun d’entre eux dispose d’une plage de valeurs propre, 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’une 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 également ` 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 :

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.

hoveredLink : string [read-only]

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

Voir également linkHovered et linkAt().

inputMethodComposing : bool [read-only]

Cette propriété indique si l'TextEdit contient une saisie de texte partielle provenant d'une méthode de saisie.

Lors de la composition, une méthode de saisie peut s’appuyer sur des événements de souris ou de clavier provenant de l’ 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 de saisie concernant le contenu attendu du champ de saisie et son mode de fonctionnement.

La valeur est une combinaison binaire d'indicateurs ou Qt.ImhNone si aucune indication n'est définie.

Les indicateurs qui modifient le comportement sont les suivants :

Les indicateurs qui restreignent la saisie (indicateurs exclusifs) sont les suivants :

Masques :

length : int [read-only]

Renvoie le nombre total de caractères en texte brut contenus dans l’élément « TextEdit ».

Comme ce nombre n'inclut pas les balises de mise en forme, il peut ne pas correspondre à la longueur de la chaîne renvoyée par la propriété « text ».

Cette propriété peut s'avérer plus rapide que l'interrogation de la longueur via la propriété ` text `, car elle ne nécessite aucune copie ni conversion des données de chaîne internes de l'objet ` TextEdit`.

lineCount : int [read-only]

Renvoie le nombre total de lignes contenues dans l'élément « TextEdit ».

mouseSelectionMode : enumeration

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

Cette propriété ne s’applique que lorsque la propriété « selectByMouse » est définie sur « true ».

overwriteMode : bool

Indique si le texte saisi par l'utilisateur remplacera le texte existant.

Comme c'est le cas avec de nombreux éditeurs de texte, le widget d'éditeur de texte peut être configuré pour insérer ou écraser le texte existant avec le nouveau texte saisi par l'utilisateur.

Si cette propriété est définie sur « true », le texte existant est écrasé, caractère par caractère, par le nouveau texte ; sinon, le texte est inséré à la position du curseur, en remplaçant le texte existant.

Par défaut, cette propriété est définie sur « false » (le nouveau texte ne remplace pas le texte existant).

persistentSelection : bool

Détermine si l'TextEdit e doit conserver la sélection visible lorsqu'il perd le focus au profit d'un autre élément de la scène. Par défaut, cette option est définie sur « false ».

preeditText : string [read-only]

Cette propriété contient une saisie de texte partielle provenant d'une méthode de saisie.

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

Voir également inputMethodHints.

readOnly : bool

Indique si l'utilisateur peut interagir avec l'élément « TextEdit ». Si cette propriété est définie sur « true », le texte ne peut pas être modifié par l'utilisateur.

Par défaut, cette propriété est définie sur « false ».

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 « TextEdit.NativeRendering » si vous préférez que le texte s'affiche de manière native sur la plateforme cible et que 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.

TextEdit.QtRendering et TextEdit.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ée comme 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()`.

selectByKeyboard : bool

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

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

Voir également readOnly.

selectByMouse : bool

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

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

selectedText : string [read-only]

Cette propriété en lecture seule renvoie le texte actuellement sélectionné dans la zone d'édition.

Elle équivaut au bout de code suivant, mais 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 surlignage du texte, utilisée pour mettre en évidence les sélections.

selectionEnd : int [read-only]

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]

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 l'appareil, entre les taquets de tabulation.

Voir également ` 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 s'effectue à l'aide de la fonction Qt::mightBeRichText(). Cependant, la détection du Markdown n'est pas automatique.

La propriété text est particulièrement adaptée à la définition du contenu initial et à la gestion des modifications apportées à des contenus textuels relativement courts. Les méthodes append(), insert() et remove() offrent un contrôle plus précis et des performances nettement supérieures pour la modification de contenus en texte enrichi particulièrement volumineux.

Notez que certains claviers utilisent une fonction de prédiction. Dans ce cas, le texte en cours de rédaction 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é à partir de cette propriété. Dans ce cas, vous pouvez ensuite modifier ` textFormat ` pour effectuer des conversions de format qui modifieront la valeur de la propriété ` text `. Par exemple, si ` textFormat ` est défini sur ` RichText ` ou ` AutoText ` et que vous chargez un fichier HTML, puis que vous définissez ` textFormat ` sur ` MarkdownText ` par la suite, la propriété ` text ` contiendra le résultat de la conversion du HTML vers le Markdown.

Voir également clear(), preeditText et textFormat.

textDocument : TextDocument [read-only]

Renvoie l'QQuickTextDocument de cet TextEdit. Depuis Qt 6.7, il dispose de fonctionnalités permettant de charger et d'enregistrer des fichiers. Il peut également être utilisé en C++ pour accéder à l'instance sous-jacente de QTextDocument, par exemple pour installer un QSyntaxHighlighter.

Voir également QQuickTextDocument.

textFormat : enumeration

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

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 s’effectue à 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. Si la propriété ` TextDocument::source ` est définie, cette détermination s'effectue à partir de ` 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 » peuvent être cochées 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é vers le format demandé. Par exemple, vous pouvez effectuer une conversion entre HTML et Markdown. Toutefois, si l’un de ces formats « enrichis » est chargé et que vous définissez ensuite textFormat sur PlainText, l’ TextEdit affichera le balisage brut. Ainsi, des liaisons appropriées (par exemple vers un contrôle cochable) peuvent permettre à l’utilisateur de basculer entre l’édition « brute » et l’édition WYSIWYG.

• 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 ne les accompagne

textMargin : real

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

wrapMode : enumeration

Définissez cette propriété pour que le texte s'adapte à la largeur de l'élément « TextEdit ». Le texte ne s'adaptera que si une largeur a été explicitement définie.

La valeur par défaut est « TextEdit.NoWrap ». Si vous définissez une largeur, pensez à utiliser « TextEdit.Wrap ».

Documentation Signal

editingFinished()

Ce signal est émis lorsque la zone d'é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 RTF ou HTML, et la chaîne « link » permet d'accéder à ce lien spécifique.

linkHovered(string link)

Ce signal est émis lorsque l'utilisateur passe la souris sur un lien intégré au 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().

[since 6.9] textEdited()

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

Ce signal a été introduit dans Qt 6.9.

Documentation des méthodes

void append(string text)

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

Pour ajouter du contenu sans insérer de nouveau paragraphe, utilisez plutôt la fonction myTextEdit.insert(myTextEdit.length, text).

void clear()

Efface le contenu du champ de saisie de texte et réinitialise la saisie partielle provenant d'une méthode de saisie.

Utilisez cette méthode plutôt que de définir la propriété ` text ` sur une chaîne vide.

Voir également QInputMethod::reset().

void copy()

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

void cut()

Copie le texte actuellement 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 partie du texte située entre les positions « start » et « end ».

Le texte renvoyé sera formaté conformément à la propriété textFormat.

string getText(int start, int end)

Renvoie la partie du texte située entre les positions start et end.

Le texte renvoyé ne contient aucune mise en forme de texte enrichi.

void insert(int position, string text)

Ajoute l'text à la liste « TextEdit » disponible à l'adresse position.

bool isRightToLeft(int start, int end)

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

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.

void moveCursorSelection(int position, SelectionMode mode)

Déplace le curseur vers 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 définit en outre soit selectionStart, soit selectionEnd (selon la valeur qui se trouvait à la position précédente du curseur) à la position spécifiée. Cela vous permet d'étendre et de réduire facilement la plage de texte sélectionnée.

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

Prenons par exemple cette séquence d’appels :

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

Cela déplace le curseur à la position 5, étend la fin de la sélection de 5 à 9, puis la rétracte de 9 à 7, laissant sélectionné le texte compris entre les positions 5 et 7 (les 6e et 7e caractères).

La même séquence avec ` TextEdit.SelectWords` étendra le début de la sélection jusqu’à une limite de mot avant ou à la position 5 et étendra la fin de la sélection jusqu’à une limite de mot à la position 9 ou au-delà.

void paste()

Remplace le texte actuellement 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 en pixels (x, y).

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

rectangle positionToRectangle(position)

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

void redo()

Répète la dernière opération si la valeur de « redo » est « available ».

string remove(int start, int end)

Supprime la partie du texte située entre les positions « start » et « end » dans le fichier « TextEdit ».

void select(int start, int end)

Sélectionne le texte compris entre start et end.

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

Après l'appel de cette méthode, selectionStart deviendra la partie inférieure et selectionEnd la partie supérieure (quel que soit l'ordre dans lequel les paramètres ont été transmis à cette méthode).

Voir également selectionStart et selectionEnd.

void selectAll()

Sélectionne 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 la fonction « undo » est définie sur « available ». Désélectionne toute sélection en cours et met à jour le point de départ de la sélection à la position actuelle du curseur.