TextInput QML Type

Affiche une ligne de texte modifiable. Plus...

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

Propriétés

• acceptableInput : bool
• activeFocusOnPress : bool
• autoScroll : bool
• bottomPadding : real
• canPaste : bool
• canRedo : bool
• canUndo : bool
• color : color
• contentHeight : real
• contentWidth : real
• cursorDelegate : Component
• cursorPosition : int
• cursorRectangle : rectangle
• cursorVisible : bool
• displayText : string
• echoMode : enumeration
• 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
• inputMask : string
• inputMethodComposing : bool
• inputMethodHints : enumeration
• leftPadding : real
• length : int
• maximumLength : int
• mouseSelectionMode : enumeration
• overwriteMode : bool
• padding : real
• passwordCharacter : string
• passwordMaskDelay : int
• persistentSelection : bool
• preeditText : string
• readOnly : bool
• renderType : enumeration
• rightPadding : real
• selectByMouse : bool
• selectedText : string
• selectedTextColor : color
• selectionColor : color
• selectionEnd : int
• selectionStart : int
• text : string
• topPadding : real
• validator : Validator
• verticalAlignment : enumeration
• wrapMode : enumeration

Signaux

• accepted()
• editingFinished()
• textEdited()

Méthodes

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

Description détaillée

Le type TextInput affiche une seule ligne de texte brut modifiable.

TextInput est utilisé pour accepter une ligne de texte en entrée. Des contraintes de saisie peuvent être imposées à un élément TextInput (par exemple, par l'intermédiaire de validator ou inputMask), et le fait de donner à echoMode une valeur appropriée permet d'utiliser TextInput pour un champ de saisie de mot de passe.

Pour réagir à l'acceptation d'un texte par l'utilisateur via les touches Return ou Enter, il convient de gérer le signal accepted(). Lorsque les touches Return ou Enter sont actionnées et que l'entrée de texte perd le focus, le signal editingFinished() est émis. Lorsque le texte est modifié de quelque manière que ce soit par l'utilisateur, le signal textEdited() est émis. Ces signaux doivent être préférés à textChanged() dans la plupart des cas.

Sous macOS, les raccourcis clavier Up/Down pour Home/End sont explicitement désactivés. Si vous voulez de telles liaisons (sur n'importe quelle plateforme), vous devrez les construire en QML.

Voir également TextEdit et Text.

Documentation sur les propriétés

acceptableInput : bool [read-only]

Cette propriété est toujours vraie, sauf si un validateur ou un masque de saisie a été défini. Si un validateur ou un masque de saisie a été défini, cette propriété ne sera vraie que si le texte actuel est acceptable pour le validateur ou le masque de saisie en tant que chaîne finale (et non en tant que chaîne intermédiaire).

activeFocusOnPress : bool

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

autoScroll : bool

Indique si le site TextInput doit défiler lorsque le texte est plus long que la largeur. Par défaut, cette valeur est fixée à true (vrai).

Voir également ensureVisible().

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

Les propriétés de remplissage individuelles prennent la valeur de la propriété padding à moins qu'elles ne soient définies explicitement. Par exemple, si padding est défini comme 4 et leftPadding comme 8, 8 sera utilisé comme espace de remplissage à gauche.

canPaste : bool [read-only]

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

canRedo : bool [read-only]

Retourne true si le site TextInput 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 TextInput est accessible en écriture et si des opérations précédentes peuvent être annulées.

color : color

La couleur du texte.

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

Si vous définissez un cursorDelegate pour une TextInput, 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 TextInput lorsqu'un curseur sera nécessaire, et la propriété x de l'instance du délégué sera définie de manière à se trouver 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 le fichier TextInput. Le curseur est positionné entre les caractères.

displayText La situation est différente si echoMode est défini comme TextInput.Password: chaque passwordCharacter est alors un caractère "étroit" (la position du curseur est toujours déplacée de 1), même si le texte contenu dans le TextInput ne l'est pas.

cursorRectangle : rectangle [read-only]

Le rectangle où le curseur de texte standard est rendu dans l'entrée de texte. En lecture seule.

La position et la hauteur d'un site personnalisé cursorDelegate 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.

cursorVisible : bool

Prend la valeur true lorsque le TextInput affiche un curseur.

Cette propriété est activée et désactivée lorsque le site TextInput reçoit le focus actif, de sorte que d'autres propriétés peuvent être liées à l'affichage ou non du curseur. Comme elle est définie et désactivée automatiquement, vous devez garder à l'esprit que votre valeur peut être écrasée si vous la définissez vous-même.

Elle peut être définie directement dans un script, par exemple si un KeyProxy peut lui transmettre des touches et que vous souhaitez qu'elle ait l'air active lorsque cela se produit (sans pour autant lui donner le focus actif).

Elle ne doit pas être définie directement sur l'élément, comme dans le code QML ci-dessous, car la valeur spécifiée sera remplacée et perdue en cas de changement de focus.

TextInput {
    text: "Text"
    cursorVisible: false
}

Dans l'extrait ci-dessus, le curseur sera toujours visible lorsque le site TextInput sera activé.

displayText : string [read-only]

Il s'agit du texte affiché dans la propriété TextInput.

Si echoMode est défini sur TextInput::Normal, cette propriété a la même valeur que la propriété TextInput::text. Sinon, cette propriété contient le texte visible par l'utilisateur, tandis que la propriété text contient le texte réellement saisi.

Voir également preeditText.

echoMode : enumeration

Spécifie comment le texte doit être affiché dans le site TextInput.

effectiveHorizontalAlignment : enumeration [read-only]

Lorsque vous utilisez la propriété ci-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 TextInput, 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.

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

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

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

font.letterSpacing : real

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

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

font.pixelSize : int

Définit la taille de la police en pixels.

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

font.pointSize : real

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

font.preferShaping : bool

Parfois, une police applique des règles complexes à un ensemble de caractères afin de les afficher correctement. Dans certains systèmes d'écriture, tels que les écritures brahmiques, cela est nécessaire pour que le texte soit lisible, mais dans les écritures latines, par exemple, il s'agit simplement d'une caractéristique cosmétique. En définissant la propriété preferShaping sur false, 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.

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

font.preferTypoLineMetrics : bool [since 6.8]

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

Par défaut, preferTypoLineMetrics est false.

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

Voir aussi QFont::StyleStrategy.

font.strikeout : bool

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

font.styleName : string

Définit le nom du style de la police.

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

font.underline : bool

Définit si le texte est souligné.

font.variableAxes : object [since 6.7]

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

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

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

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

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

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

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

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

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

Voir aussi QFont::setVariableAxis().

font.weight : int

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

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

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

TextInput n'a pas d'alignement vertical, car la hauteur naturelle est exactement la hauteur de la ligne de texte. Si vous définissez manuellement une hauteur supérieure, TextInput sera toujours aligné verticalement en haut. Vous pouvez utiliser des ancres pour l'aligner comme vous le souhaitez dans un autre élément.

Les valeurs valables pour horizontalAlignment sont TextInput.AlignLeft, TextInput.AlignRight et TextInput.AlignHCenter.

Les valeurs valables pour verticalAlignment sont TextInput.AlignTop (par défaut), TextInput.AlignBottom TextInput.AlignVCenter .

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

inputMask : string

Permet de définir un masque de saisie sur le site TextInput, limitant les entrées de texte autorisées. Voir QLineEdit::inputMask pour plus de détails, car les mêmes chaînes de masques sont utilisées par TextInput.

Voir également acceptableInput et validator.

inputMethodComposing : bool [read-only]

Cette propriété indique si le site TextInput 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 TextInput 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'entrée 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 l'élément TextInput.

Si l'article TextInput a un inputMask, la longueur comprendra les caractères de masque et peut différer 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 pas de copie ou de conversion des données de chaîne internes de TextInput.

maximumLength : int

Longueur maximale autorisée du texte dans le site TextInput.

Si le texte est trop long, il est tronqué à la limite.

Par défaut, cette propriété contient une valeur de 32767.

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

passwordCharacter : string

Il s'agit du caractère affiché lorsque echoMode est défini sur Password ou PasswordEchoOnEdit. Par défaut, il s'agit du caractère de mot de passe utilisé par le thème de la plateforme.

Si cette propriété est définie sur une chaîne comportant plus d'un caractère, le premier caractère est utilisé. Si la chaîne est vide, la valeur est ignorée et la propriété n'est pas définie.

passwordMaskDelay : int

Définit le délai avant que le caractère visible ne soit masqué par le caractère du mot de passe, en millisecondes.

La méthode de réinitialisation sera appelée en assignant undefined.

persistentSelection : bool

Indique si le site TextInput doit conserver sa sélection lorsqu'il 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 également displayText et inputMethodHints.

readOnly : bool

Définit si la saisie de l'utilisateur peut modifier le contenu de TextInput.

Si readOnly a la valeur true, la saisie de l'utilisateur n'affecte pas la propriété text. Les liaisons ou les tentatives de définition de la propriété text fonctionneront toujours.

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

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

selectByMouse : bool

La valeur par défaut est true.

Si la valeur est vraie, 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'entrée de texte.

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

myTextInput.text.toString().substring(myTextInput.selectionStart,
    myTextInput.selectionEnd);

selectedTextColor : color

La couleur du texte en surbrillance, 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.

text : string

Le texte dans le site TextInput.

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. Pour obtenir l'intégralité du texte affiché dans la propriété TextInput, utilisez la propriété displayText.

Voir aussi clear(), displayText, preeditText, accepted(), editingFinished(), et textEdited().

validator : Validator

Permet de définir un validateur sur le site TextInput. Lorsqu'un validateur est défini, le site TextInput n'accepte que les entrées qui laissent la propriété du texte dans un état acceptable ou intermédiaire. Le signal d'acceptation ne sera envoyé que si le texte est dans un état acceptable lorsque l'on appuie sur la touche Entrée.

Les validateurs actuellement pris en charge sont IntValidator, DoubleValidator et RegularExpressionValidator. Un exemple d'utilisation des validateurs est présenté ci-dessous, qui autorise la saisie d'entiers compris entre 11 et 31 dans la saisie de texte :

import QtQuick 2.0
TextInput{
    validator: IntValidator{bottom: 11; top: 31;}
    focus: true
}

Voir également acceptableInput et inputMask.

wrapMode : enumeration

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

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

Documentation sur les signaux

accepted()

Ce signal est émis lorsque la touche Return ou Enter est enfoncée. Notez que si l'entrée de texte est définie par validator ou inputMask, le signal ne sera émis que si l'entrée est dans un état acceptable.

Voir aussi editingFinished() et textEdited().

editingFinished()

Ce signal est émis lorsque la touche Retour ou Entrée est enfoncée ou que l'entrée de texte perd le focus. Notez que si un validateur ou inputMask est défini sur l'entrée de texte et que l'on appuie sur Entrée/Retour, ce signal ne sera émis que si l'entrée suit le inputMask et que le validateur renvoie un état acceptable.

Voir aussi accepted() et textEdited().

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

Voir également accepted() et editingFinished().

Documentation de la méthode

void clear()

Efface le contenu de l'entrée de texte et réinitialise l'entrée de texte partielle 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.

void ensureVisible(int position)

Fait défiler le contenu de l'entrée de texte de manière à ce que le caractère spécifié position soit visible à l'intérieur des limites de l'entrée de texte.

Voir également autoScroll.

string getText(int start, int end)

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

Si le TextInput a un inputMask, la longueur inclura les caractères de masque.

void insert(int position, string text)

Insère text dans le site TextInput à 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.

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 TextInput.SelectCharacters.

Prenons par exemple cette séquence d'appels :

cursorPosition = 5
moveCursorSelection(9, TextInput.SelectCharacters)
moveCursorSelection(7, TextInput.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 TextInput.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(real x, real y, CursorPosition position)

Cette fonction renvoie la position du caractère à x et y pixels du coin supérieur gauche de l'entrée texte. 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.

Cela signifie que pour toutes les valeurs x avant le premier caractère, cette fonction renvoie 0, et pour toutes les valeurs x après le dernier caractère, cette fonction renvoie text.length. Si la valeur y est au-dessus du texte, la position sera celle du caractère le plus proche sur la première ligne et si elle est en dessous du texte, la position du caractère le plus proche sur la dernière ligne sera renvoyée.

Le paramètre curseur position spécifie comment la position du curseur doit être résolue :

rect positionToRectangle(int pos)

Cette fonction prend une position de caractère pos et renvoie le rectangle que le curseur occuperait s'il était placé à cette position de caractère.

Cela revient à définir cursorPosition, puis à demander le rectangle du curseur, mais cursorPosition n'est pas modifié.

void redo()

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

void remove(int start, int end)

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

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.