TextInput QML Type

Affiche une ligne de texte modifiable. En savoir 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 sert à accepter la saisie d’une ligne de texte. Des contraintes de saisie peuvent être appliquées à un élément TextInput (par exemple, via un signal « validator » ou « inputMask »), et le fait de définir la propriété « echoMode » sur une valeur appropriée permet d’utiliser TextInput comme champ de saisie de mot de passe.

Pour réagir lorsque l’utilisateur valide le texte à l’aide des touches Retour ou Entrée, gérez le signal accepted(). Lorsque les touches Retour ou Entrée sont enfoncées et que le champ de saisie perd le focus, le signal editingFinished() est émis. Lorsque l’utilisateur modifie le texte de quelque manière que ce soit, le signal textEdited() est émis. Dans la plupart des cas, ces signaux sont préférables à textChanged().

Sous macOS, les raccourcis clavier Haut/Bas pour les touches Début/Fin sont explicitement désactivés. Si vous souhaitez utiliser ces raccourcis (sur n’importe quelle plateforme), vous devrez les définir dans 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 accepté par le validateur ou le masque de saisie en tant que chaîne finale (et non en tant que chaîne intermédiaire).

activeFocusOnPress : bool

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

autoScroll : bool

Détermine si l'TextInput doit défiler lorsque le texte dépasse la largeur de l' . Par défaut, cette option est activée (true).

Voir aussi ensureVisible().

Ces propriétés définissent l'espacement 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 d’être définies explicitement. Par exemple, si « padding » est défini sur « 4 » et « leftPadding » sur « 8 », « 8 » sera utilisé comme remplissage à gauche.

canPaste : bool [read-only]

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

canRedo : bool [read-only]

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

canUndo : bool [read-only]

Renvoie « true » si l'TextInput n est accessible en écriture et s'il existe des opérations précédentes pouvant être annulées.

color : color

La couleur du texte.

contentHeight : real [read-only]

Renvoie la hauteur du texte, y compris la partie qui dépasse la hauteur définie si le texte ne tient pas dans l'espace prévu.

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

Si vous définissez un `cursorDelegate` pour un ` TextInput`, 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 l'TextInput lorsque le curseur sera nécessaire, et la propriété `x` de l'instance du délégué sera définie 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 de ` QQuickItem `.

cursorPosition : int

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

displayText La situation est différente si ` echoMode ` est défini sur ` TextInput.Password` : dans ce cas, chaque ` passwordCharacter ` est un caractère « étroit » (la position du curseur se déplace toujours d’un), même si le texte de la ` TextInput ` ne l’est pas.

cursorRectangle : rectangle [read-only]

Rectangle dans lequel s'affiche le curseur de texte standard au sein du champ de saisie. En lecture seule.

La position et la hauteur d’un « cursorDelegate » personnalisé sont mises à jour automatiquement pour suivre le « cursorRectangle » lorsque celui-ci change. La largeur du « » n’est pas affectée par les modifications apportées au rectangle du curseur.

cursorVisible : bool

À définir sur « true » lorsque l'TextInput affiche un curseur.

Cette propriété est activée et désactivée lorsque l'TextInput reçoit le focus actif, ce qui permet de lier d'autres propriétés à l'affichage ou non du curseur. Comme elle est activée et désactivée automatiquement, lorsque vous définissez vous-même sa valeur, vous devez garder à l'esprit que celle-ci risque d'être écrasée.

Elle peut être définie directement dans un script, par exemple si un KeyProxy lui transmet des touches et que vous souhaitez qu’elle paraisse active lorsque cela se produit (sans pour autant lui attribuer 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 écrasée et perdue lors des changements de focus.

TextInput {
    text: "Text"
    cursorVisible: false
}

Dans l’extrait de code ci-dessus, le curseur restera visible lorsque l’ TextInput e obtiendra le focus actif.

displayText : string [read-only]

Il s'agit du texte affiché dans l'TextInput.

Si la propriété « echoMode » est définie sur « TextInput::Normal », cette propriété contient la même valeur que la propriété « TextInput::text ». Dans le cas contraire, 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

Définit la manière dont le texte doit s'afficher dans l'TextInput.

effectiveHorizontalAlignment : enumeration [read-only]

Lorsque vous utilisez la propriété associée LayoutMirroring::enabled pour inverser la disposition d'une application, l'alignement horizontal du texte est également inversé. En revanche, la propriété horizontalAlignment reste inchangée. Pour connaître l'alignement horizontal effectif de TextInput, 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.

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

font.contextFontMerging : bool [since 6.8]

Si la police sélectionnée ne contient pas un caractère donné, Qt choisit automatiquement une police de 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 peu courants, de nombreuses polices différentes peuvent être utilisées pour représenter une même chaîne de texte, même si celle-ci appartient au même alphabet. En définissant ` contextFontMerging ` sur `true`, le système tentera plutôt de trouver la police de secours qui correspond au plus grand sous-ensemble de la chaîne de caractères d'entrée. Cette approche 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 famille n'est pas sensible à la casse et peut éventuellement inclure le nom d'une fonderie, par exemple « Helvetica [Cronyx] ». Si la famille est disponible auprès de plusieurs fonderies et qu’aucune n’est spécifiée, une fonderie est choisie au hasard. Si la famille n’est pas disponible, une famille sera définie à l’aide de l’algorithme de correspondance des polices.

font.features : object [since 6.6]

Applique des valeurs entières à certaines fonctionnalités OpenType 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 s’applique à 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. En général, cela implique de regrouper la fraction complète en une seule largeur de caractère (comme ½).

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

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

Plusieurs fonctionnalités peuvent se voir attribuer des valeurs dans le même mappage. Par exemple, si vous souhaitez également désactiver le crénage pour la police, vous pouvez le désactiver explicitement comme suit :

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

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

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

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

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

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

Voir également QFont::setFeature().

font.hintingPreference : enumeration

Définit le « hinting » préféré pour le texte.

Il s'agit d'une indication donnée au système de rendu de texte sous-jacent afin qu'il utilise un certain niveau de hinting ; sa prise en charge varie d'une plateforme à l'autre. 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'une variante en italique.

font.kerning : bool

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

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

font.letterSpacing : real

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

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

font.pixelSize : int

Définit la taille de la police en pixels.

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

font.pointSize : real

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

font.preferShaping : bool

Il arrive parfois qu’une police applique des règles complexes à un ensemble de caractères afin de les afficher correctement. Dans certains systèmes d’écriture, tels que les écritures brahmiques, cela est nécessaire pour que le texte soit lisible, mais dans l’écriture latine, par exemple, il s’agit simplement d’une fonctionnalité esthétique. Définir la propriété preferShaping sur « false » désactivera toutes ces fonctionnalités lorsqu’elles ne sont pas nécessaires, ce qui améliorera les performances dans la plupart des cas.

La valeur par défaut est « true ».

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

font.preferTypoLineMetrics : bool [since 6.8]

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

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

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

Voir également QFont::StyleStrategy.

font.strikeout : bool

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

font.styleName : string

Définit le nom du style de la police.

Le nom 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 différentes épaisseurs, largeurs ou styles) 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 » (épaisseur), « wdth » (largeur), « ital » (italique) et « opsz » (taille optique). Chacun d’entre eux dispose d’une plage de valeurs définie dans la police elle-même. Par exemple, « wght » peut s’étendre de 100 à 900 (QFont::Thin à QFont::Black), tandis que « ital » peut s’étendre de 0 à 1 (de non italique à entièrement italique).

Une police peut également choisir de définir des axes personnalisés ; la seule contrainte est que le nom doit respecter les exigences d’un QFont::Tag (séquence de quatre caractères Latin-1).

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

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

Voir aussi ` QFont::setVariableAxis()`.

font.weight : int

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

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 de pixels correspondant, tandis qu'une valeur négative le réduit d'autant.

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

TextInput Il n’y a pas d’alignement vertical, car la hauteur naturelle correspond exactement à la hauteur d’une seule ligne de texte. Si vous définissez manuellement une hauteur supérieure, « TextInput » sera toujours aligné en haut verticalement. Vous pouvez utiliser des ancres pour l’aligner comme vous le souhaitez au sein d’un autre élément.

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

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

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 TextInput, utilisez la propriété en lecture seule effectiveHorizontalAlignment.

inputMask : string

Vous permet de définir un masque de saisie sur TextInput, afin de restreindre les entrées de texte autorisées. Consultez QLineEdit::inputMask pour plus de détails, car les chaînes de masque utilisées sont exactement les mêmes que celles de TextInput.

Voir également acceptableInput et validator.

inputMethodComposing : bool [read-only]

Cette propriété indique si l'TextInput 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'TextInput pour modifier ou valider le texte partiel. Cette propriété permet de déterminer à quel moment 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 de la saisie de texte et la manière dont elle doit fonctionner.

La valeur est une combinaison binaire d'indicateurs, ou Qt.ImhNone si aucun indice n'est défini.

Les indicateurs qui modifient le comportement sont les suivants :

Notez que les IME Android n'autorisent délibérément que la saisie de caractères latins/ASCII dans les champs de mot de passe.

Notez que le framework Qt traite cela comme un mot de passe visible et que, dans ce cas, les IME Android n'autorisent délibérément que la saisie de caractères latins/ASCII.

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

Masques :

length : int [read-only]

Renvoie le nombre total de caractères de l'élément « TextInput ».

Si l'élément « TextInput » comporte un « inputMask », la longueur inclura les caractères de masque et pourra différer de 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 la ` TextInput`.

maximumLength : int

La longueur maximale autorisée du texte dans la balise TextInput.

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

Par défaut, cette propriété a pour valeur 32767.

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 écrasera le texte existant.

Comme dans 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 ; dans le cas contraire, 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).

passwordCharacter : string

Il s'agit du caractère affiché lorsque la propriété « echoMode » est définie 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 de caractères comportant plus d'un caractère, seul 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, en millisecondes, avant que le caractère visible ne soit masqué par un caractère de mot de passe.

La méthode reset sera appelée en lui attribuant la valeur « undefined ».

persistentSelection : bool

Détermine si l'TextInput e doit conserver sa sélection 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 displayText et inputMethodHints.

readOnly : bool

Détermine si les saisies de l'utilisateur peuvent modifier le contenu de la balise TextInput.

Si readOnly est défini sur true, les saisies de l'utilisateur n'auront aucun effet sur la propriété text. Les liaisons ou les tentatives de définition de la propriété text fonctionneront néanmoins.

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

TextInput.QtRendering et TextInput.CurveRendering sont toutes deux des techniques accélérées par le matériel. Le rendu « QtRendering » est le plus rapide des deux, mais il utilise davantage de mémoire et peut présenter des artefacts de rendu sur les grandes tailles. Le rendu « CurveRendering » doit être envisagé comme une alternative lorsque le rendu « 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().

selectByMouse : bool

La valeur par défaut est « true ».

Si cette propriété est définie sur « 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 le champ de saisie.

Elle équivaut au snippet suivant, mais est plus rapide et plus facile à utiliser.

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

selectedTextColor : color

La couleur du texte mis en surbrillance, utilisée pour 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.

text : string

Le texte figurant dans la propriété « TextInput ».

Notez que certains claviers utilisent une fonction de prédiction. Dans ce cas, le texte en cours de saisie 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 également clear(), displayText, preeditText, accepted(), editingFinished() et textEdited().

validator : Validator

Permet de définir un validateur sur l'élément TextInput. Lorsqu'un validateur est défini, l'élément TextInput n'acceptera que les saisies qui laissent la propriété « text » dans un état acceptable ou intermédiaire. Le signal « accepted » ne sera envoyé que si le texte se trouve dans un état acceptable au moment où la touche Entrée est enfoncée.

Les validateurs actuellement pris en charge sont IntValidator, DoubleValidator et RegularExpressionValidator. Vous trouverez ci-dessous un exemple d’utilisation des validateurs, qui permet de saisir des nombres entiers compris entre 11 et 31 dans le champ de saisie de texte :

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

Voir également acceptableInput et inputMask.

wrapMode : enumeration

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

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

Documentation de Signal

accepted()

Ce signal est émis lorsque l'on appuie sur la touche Retour ou Entrée. Notez que si une valeur « validator » ou « inputMask » est définie pour le champ de saisie de texte, le signal ne sera émis que si la saisie se trouve dans un état acceptable.

Voir également editingFinished() et textEdited().

editingFinished()

Ce signal est émis lorsque la touche Retour ou Entrée est enfoncée, ou lorsque le champ de saisie perd le focus. Notez que si un validateur ou un « inputMask » est défini sur le champ de saisie et que la touche Entrée ou Retour est enfoncée, ce signal ne sera émis que si la saisie respecte l’ inputMask et que le validateur renvoie un état acceptable.

Voir également ` accepted()` et ` textEdited()`.

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

Voir également accepted() et editingFinished().

Documentation de la méthode

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.

void ensureVisible(int position)

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

Voir également autoScroll.

string getText(int start, int end)

Renvoie la partie de texte située entre les positions « start » et « end ».

Si la position TextInput comporte un caractère inputMask, la longueur inclura les caractères de masque.

void insert(int position, string text)

Ajoute l'text ion à la liste « TextInput » 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.

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 la sélection « selectionStart », soit la sélection « selectionEnd » (selon celle 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 prendra par défaut la valeur « TextInput.SelectCharacters ».

Prenons par exemple cette séquence d’appels :

cursorPosition = 5
moveCursorSelection(9, TextInput.SelectCharacters)
moveCursorSelection(7, TextInput.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 ` TextInput.SelectWords` étendra le début de la sélection jusqu’à une limite de mot située avant ou à la position 5 et étendra la fin de la sélection jusqu’à une limite de mot située à 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(real x, real y, CursorPosition position)

Cette fonction renvoie la position du caractère situé à x et y pixels à partir du coin supérieur gauche du champ textInput. 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.

Cela signifie que pour toutes les valeurs x situées avant le premier caractère, cette fonction renvoie 0, et pour toutes les valeurs x situées après le dernier caractère, elle renvoie text.length. Si la valeur y est supérieure à la hauteur du texte, la position correspondra à celle du caractère le plus proche sur la première ligne ; si elle est inférieure à la hauteur du texte, la position du caractère le plus proche sur la dernière ligne sera renvoyée.

Le paramètre « position » du curseur spécifie comment la position du curseur doit être déterminée :

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.

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

void redo()

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

void remove(int start, int end)

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

void select(int start, int end)

Sélectionne le texte compris entre start et end.

Si le point de départ ou le point d’arrivée est hors de la plage autorisée, la sélection n’est pas modifiée.

Après l'appel de cette méthode, selectionStart deviendra la partie la plus petite et selectionEnd la partie la plus grande (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.