Qt Virtual Keyboard Vue d'ensemble

Caractéristiques

Les principales caractéristiques du site Qt Virtual Keyboard sont les suivantes

• Dispositions et styles de clavier personnalisables avec commutation dynamique.
• Saisie prédictive de texte avec sélection de mots.
• Prévisualisation des caractères et affichage alternatif des caractères.
• Insertion automatique de majuscules et d'espaces.
• Possibilité d'adaptation à différentes résolutions.
• Prise en charge de différents jeux de caractères (latin, chinois simplifié/traditionnel, hindi, japonais, arabe, hébreu, coréen et autres).
• Prise en charge des langues d'entrée les plus courantes, avec possibilité d'étendre facilement la prise en charge des langues.
• Saisie de gauche à droite et de droite à gauche.
• Prise en charge des touches matérielles pour la navigation à 2 et 5 voies.
• Prise en charge de l'écriture manuscrite, avec des gestes pour la saisie en plein écran.
• Retour audio.
• Fonctionnalité multiplateforme.
• Prise en charge des applicationsQt Quick et Qt Widgets .

Langues prises en charge

Le clavier virtuel prend en charge les langues suivantes :

Pour ajouter la prise en charge d'une langue supplémentaire, voir Ajouter de nouvelles dispositions de clavier.

Plugins tiers

Le site Qt Virtual Keyboard prend en charge les plugins tiers des fournisseurs suivants :

• CerenceXT9 advanced input.
• CerenceHandwriting text input.
• Reconnaissance de l'écriture manuscriteMyScript Text

Laconstruction de Qt Virtual Keyboard décrit comment intégrer ces plugins dans Qt Virtual Keyboard.

Concepts de base

Le projet Qt Virtual Keyboard est un plugin de contexte d'entrée Qt qui met en œuvre les interfaces QPlatformInputContextPlugin et QPlatformInputContext. Ces interfaces permettent au plugin d'être utilisé comme un plugin de contexte d'entrée de plateforme dans les applications Qt.

Le plugin lui-même fournit un cadre d'entrée prenant en charge plusieurs méthodes d'entrée ainsi qu'une interface utilisateur QML pour le clavier virtuel. Le cadre d'entrée est extensible grâce à une interface de plugin, qui permet de charger des méthodes d'entrée et des dispositions de clavier de tiers au moment de l'exécution.

Le cadre de saisie fournit les interfaces principales suivantes :

• QVirtualKeyboardInputContextLe cadre de saisie : fournit des informations contextuelles pour le clavier virtuel et d'autres composants de saisie. Joue le rôle d'interface avec le composant de saisie de texte sous-jacent.
• QVirtualKeyboardInputEngineIl expose une API pour intégrer les événements de saisie de l'utilisateur (pressions sur les touches, etc.) et sert d'hôte pour les méthodes de saisie.
• QVirtualKeyboardAbstractInputMethodLa méthode input : un type de base pour les méthodes input basées sur le C++. La méthode d'entrée gère généralement les événements liés aux touches, mais peut également gérer les événements liés à la souris et à la saisie tactile.
• InputMethodType de base pour les méthodes d'entrée basées sur QML. La méthode d'entrée gère généralement les événements liés aux touches, mais peut également gérer les événements liés à la souris et au toucher.

Contexte de saisie

Le contexte d'entrée est utilisé par le clavier ainsi que par les méthodes d'entrée concrètes. InputContext est une instance singleton hébergée par QML. Une application ne doit pas interagir directement avec le contexte d'entrée.

Informations contextuelles

Le contexte de saisie permet d'accéder à des informations contextuelles provenant de l'application. Ces informations comprennent, entre autres, les éléments suivants

• InputContext::cursorPosition
• InputContext::cursorRectangle
• InputContext::inputMethodHints
• InputContext::preeditText
• InputContext::selectedText
• InputContext::surroundingText

Locale

Le moteur de clavier virtuel génère la liste des paramètres locaux pris en charge à partir des répertoires de mise en page spécifiques aux paramètres locaux dans layouts/. Chaque répertoire de disposition doit contenir une définition ou une solution de repli pour les types de disposition suivants : clavier numérique, chiffres, écriture manuscrite, principal, nombres et symboles. Les définitions sont implémentées dans les fichiers .qml, les replis sont définis par un fichier de remplacement portant l'extension .fallback. Le répertoire layouts/ doit contenir un sous-répertoire fallback/ qui contient les définitions de chaque type de présentation.

Chaque répertoire de mise en page peut contenir la définition d'un ou de plusieurs types de mise en page. Si la disposition locale spécifique est la même que celle de la locale de repli, vous pouvez ajouter un fichier de remplacement pour la disposition appelé <layout type>.fallback. Cela indique au clavier virtuel d'utiliser la disposition de repli à la place.

Par exemple : vous pouvez ajouter une disposition locale spécifique pour le finnois, qui définit le type de disposition principal dans main.qml. Pour les autres types de disposition, vous optez pour le mécanisme de repli. Votre arborescence layouts/ ressemblera à ceci :

.
├── fallback
│   ├── dialpad.qml
│   ├── digits.qml
│   ├── handwriting.qml
│   ├── main.qml
│   ├── numbers.qml
│   └── symbols.qml
└── fi_FI
    ├── dialpad.fallback
    ├── digits.fallback
    ├── handwriting.fallback
    ├── main.qml
    ├── numbers.fallback
    └── symbols.fallback

Il est impératif que le répertoire layouts/fallback contienne toujours un ensemble de fichiers d'implémentation complets.

L'application peut spécifier la présentation initiale en modifiant la locale par défaut. Cependant, cela doit être fait avant que l'application ne s'initialise et ne charge le plugin de la méthode d'entrée. Si la locale par défaut n'est pas modifiée, c'est la locale actuelle du système qui est utilisée.

La correspondance avec les paramètres régionaux du clavier se fait dans l'ordre suivant :

• layouts/<language>_<country>
• layouts/<language>_*
• layouts/fallback - la disposition par défaut est en_GB.

Tout d'abord, la locale est comparée au nom complet de la locale. S'il n'y a pas de correspondance complète, seule la langue de la locale est recherchée. Enfin, le contenu de layouts/fallback est utilisé comme solution de repli lorsqu'il n'y a pas non plus de correspondance partielle.

Une fois la sélection des paramètres linguistiques effectuée, le clavier met à jour les paramètres linguistiques et la direction de la saisie afin de les faire correspondre à la disposition actuelle. L'application peut recevoir ces informations via l'interface QInputMethod.

En interne, la locale d'entrée actuelle est également mise à jour sur QVirtualKeyboardInputEngine et les instances de la méthode d'entrée actuelle.

Moteur d'entrée

L'objet moteur d'entrée appartient à InputContext. Comme pour InputContext, il n'existe qu'une seule instance de QVirtualKeyboardInputEngine. Le moteur d'entrée contient des fonctions API que le clavier utilise pour mettre en correspondance les interactions de l'utilisateur, telles que les événements de pression et de relâchement des touches, avec la méthode d'entrée.

Par exemple, les événements liés aux touches du clavier virtuel sont mappés par les méthodes suivantes :

• QVirtualKeyboardInputEngine::virtualKeyPress
• QVirtualKeyboardInputEngine::virtualKeyRelease

Les méthodes susmentionnées sont destinées à l'intégration du clavier virtuel, d'où le mot "virtuel" dans leur nom. Cela signifie également que ces méthodes ne sont pas adaptées à la cartographie des frappes physiques. C'est une conséquence du fait que l'action réelle n'est exécutée que lorsque la touche est relâchée.

Si la pression sur la touche est interrompue avant l'événement de relâchement de la touche, le clavier invoque la méthode QVirtualKeyboardInputEngine::virtualKeyCancel.

Méthode d'entrée

La méthode input est une implémentation concrète du gestionnaire de pression de touche. Sa fonction principale est de gérer les événements de pression de touche et de maintenir les informations d'état pour la saisie de l'utilisateur. Elle interagit avec l'éditeur de texte par l'intermédiaire de QVirtualKeyboardInputContext via le texte de pré-édition ou les événements de touche.

L'instance de la méthode d'entrée peut être créée de différentes manières, en fonction du cas d'utilisation :

• KeyboardLayout::inputMethodLe clavier peut créer une instance de méthode d'entrée uniquement pour cette disposition de clavier. Il convient de noter que cette instance sera détruite lorsque la disposition de clavier sera modifiée. Par conséquent, cette méthode est généralement limitée à des cas d'utilisation très restreints.
• KeyboardLayout::createInputMethod()la disposition de clavier peut créer dynamiquement une méthode d'entrée qui peut être utilisée avec cette disposition ainsi qu'avec le site shared layouts (par exemple, la disposition des symboles). C'est la méthode préférée pour créer des méthodes d'entrée spécialisées, telles que celles impliquant des langues complexes ou l'écriture manuscrite.
• DefaultInputMethodLe clavier virtuel tente de créer ce type de méthode d'entrée au démarrage. Cette instance sera utilisée comme méthode de saisie par défaut dans toutes les dispositions de clavier, à moins que la disposition de clavier n'utilise une méthode de saisie personnalisée. Cette instance survit aux changements de disposition du clavier dans les différentes langues et constitue la méthode préférée pour créer et remplacer la méthode de saisie par défaut.

Plugins de clavier virtuel

Le répertoire src/plugins du clavier virtuel contient les plugins existants pour le clavier virtuel. Ces plugins sont des modules QML standard chargés implicitement par le module QML QtQuick.VirtualKeyboard.Plugins.

Un plugin peut fournir des dispositions de clavier et des méthodes d'entrée (généralement les deux). La méthode de saisie utilisée par le clavier virtuel dépend de la disposition de clavier utilisée. La disposition du clavier peut fournir une instance d'une méthode d'entrée personnalisée au moyen de la fonction KeyboardLayout.createInputMethod(). Sinon, la méthode de saisie par défaut (DefaultInputMethod) créée par le clavier virtuel est utilisée.

Ajout de dispositions de clavier

Le plugin peut ajouter des dispositions de clavier pour le clavier virtuel en incluant les fichiers de disposition dans les ressources Qt du binaire du plugin.

Le clavier virtuel recherche les dispositions de clavier (par langue) à partir d'un chemin spécifique /qt-project.org/imports/QtQuick/VirtualKeyboard/Layouts/<language_COUNTRY>, il est donc essentiel d'utiliser ce chemin exact également dans le plugin. Les chemins de ressources Qt peuvent se chevaucher, ce qui signifie que le plugin peut remplacer des dispositions existantes sur le clavier virtuel.

Il est également possible de remplacer les dispositions du clavier intégré en les chargeant directement depuis le système de fichiers à l'aide de la variable d'environnement QT_VIRTUALKEYBOARD_LAYOUT_PATH.

Ajout d'une méthode d'entrée

Le plugin peut enregistrer une méthode d'entrée que d'autres dispositions de clavier peuvent utiliser par défaut (comme DefaultInputMethod) ou une méthode d'entrée qui est utilisée en privé dans le plugin (en fournissant également une disposition de clavier personnalisée, qui crée la méthode d'entrée).

La méthode d'entrée doit implémenter une interface QVirtualKeyboardAbstractInputMethod (C++) ou InputMethod (QML) et doit être enregistrée en tant que type QML (QML_NAMED_ELEMENT) par le plugin.

Mise en œuvre d'une méthode d'entrée personnalisée

L'implémentation des méthodes d'entrée commence par le choix de l'interface utilisée, QML ou C++. Dans cet exemple, c'est l'interface QML qui est utilisée. La même logique et les mêmes interfaces s'appliquent à l'interface C++ QVirtualKeyboardAbstractInputMethod. Dans ce cas, le plugin doit être lié au module VirtualKeyboard.

L'exemple suivant montre la fonctionnalité minimale requise d'une méthode d'entrée :

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR BSD-3-Clause

import QtQuick
import QtQuick.VirtualKeyboard as VKB

// file: CustomInputMethod.qml

VKB.InputMethod {
    function inputModes(locale) {
        return [VKB.InputEngine.InputMode.Latin];
    }

    function setInputMode(locale, inputMode) {
        return true
    }

    function setTextCase(textCase) {
        return true
    }

    function reset() {
        // TODO: reset the input method without modifying input context
    }

    function update() {
        // TODO: commit current state and update the input method
    }

    function keyEvent(key, text, modifiers) {
        var accept = false
        // TODO: Handle key and set accept or fallback to default processing
        return accept;
    }
}

La méthode InputMethod::inputModes() est appelée par le moteur de saisie avant qu'un mode de saisie ne soit défini. La méthode renvoie une liste des modes d'entrée disponibles dans la locale donnée.

Une méthode d'entrée est initialisée dans la méthode InputMethod::setInputMode() avec une locale et un mode d'entrée. Après avoir défini la locale et le mode d'entrée, la méthode d'entrée doit être prête à l'emploi.

InputMethod::resetLa méthode () est appelée lorsqu'une méthode d'entrée doit être réinitialisée. La réinitialisation ne doit porter que sur l'état interne de la méthode de saisie, et non sur le texte de l'utilisateur.

InputMethod::update() est appelé lorsque le contexte de saisie est mis à jour et que l'état de la saisie peut être désynchronisé. La méthode de saisie doit valider le texte actuel.

Les événements de frappe sont gérés dans InputMethod::keyEvent(). Cette méthode traite un seul événement de frappe et renvoie true si l'événement a été traité. Dans le cas contraire, la frappe est traitée par la méthode de saisie par défaut.

Listes de sélection

Les listes de sélection sont une fonctionnalité optionnelle qui peut être intégrée à la méthode de saisie. Le cadre de saisie prend en charge différents types de listes, tels que la liste des mots candidats. Les responsabilités dans la mise en œuvre des listes sont gérées de telle sorte que la méthode de saisie est responsable du contenu et des activités, telles que le comportement de clic. Le cadre de saisie est responsable de la gestion du modèle de liste et de sa transmission à l'interface utilisateur.

Attribution des listes de sélection

Les listes de sélection sont allouées lorsque la méthode de saisie est activée. La méthode InputMethod::selectionLists() renvoie une liste des types de listes de sélection requis :

function selectionLists() {
    return [SelectionListModel.Type.WordCandidateList];
}

Dans l'exemple ci-dessus, la méthode de saisie attribue la liste de candidats au mot pour son utilisation.

Mise à jour des listes de sélection

Lorsque la méthode de saisie demande à l'interface utilisateur de mettre à jour le contenu d'une liste de sélection, elle émet le signal InputMethod::selectionListChanged. De même, si la méthode de saisie demande à l'interface utilisateur de mettre en évidence un élément de la liste, elle émet le signal InputMethod::selectionListActiveItemChanged.

selectionListChanged(SelectionListModel.Type.WordCandidateList)
selectionListActiveItemChanged(SelectionListModel.Type.WordCandidateList, wordIndex)

Remplissage des éléments des listes de sélection

Les éléments sont remplis à l'aide de méthodes de rappel qui fournissent le nombre d'éléments d'une liste ainsi que les données relatives à chaque élément.

La méthode de rappel InputMethod::selectionListItemCount demande le nombre d'éléments dans la liste identifiée par le type donné.

function selectionListItemCount(type) {
    if (type == SelectionListModel.Type.WordCandidateList) {
        return wordList.length
    }
    return 0
}

La méthode de rappel InputMethod::selectionListData demande les données relatives aux éléments.

function selectionListData(type, index, role) {
    var result = null
    if (type == SelectionListModel.Type.WordCandidateList) {
        switch (role) {
        case SelectionListModel.Role.Display:
            result = wordList[index]
            break
        default:
            break
        }
    }
    return result
}

Le paramètre role identifie les données demandées pour un élément. Par exemple, la fonction SelectionListModel.Role.Display demande les données du texte d'affichage.

Réponse aux actions de l'utilisateur

Lorsque l'utilisateur sélectionne un élément de la liste, la méthode de saisie répond à l'événement dans le rappel de la méthode InputMethod::selectionListItemSelected.

function selectionListItemSelected(type, index) {
    if (type == SelectionListModel.Type.WordCandidateList) {
        inputContext.commit(wordlist[index])
        update()
    }
}

Intégration de la reconnaissance de l'écriture manuscrite

Une méthode de saisie peut également utiliser des données provenant de l'écran tactile ou d'autres périphériques de saisie.

Lorsque la saisie commence, le clavier virtuel appelle la fonction de la méthode de saisie traceBegin , qui renvoie un nouvel objet Trace dans lequel la saisie est collectée pour le compte de la méthode de saisie. De même, lorsque le doigt ou le stylet est levé, l'événement se termine par l'appel de traceEnd . La méthode de saisie traite les données collectées et produit du texte à l'aide de l'interface InputContext.

Il existe des dispositions de clavier prédéfinies pour l'écriture manuscrite. Cependant, elles ne sont pas incluses par défaut, et le plugin d'écriture manuscrite doit les inclure dans ses propres ressources. Pour des exemples sur la manière de procéder, voir les plugins existants pour l'écriture manuscrite de MyScript ou Cerence.

Modèle de données pour l'écriture manuscrite

Le clavier virtuel recueille les données d'écriture manuscrite dans un modèle de données spécial QVirtualKeyboardTrace. Chaque trace représente une collection de données échantillonnées à partir d'un toucher (par exemple, un glissement sur l'écran). Il y aura autant d'instances de QVirtualKeyboardTrace qu'il y a de touches sur la zone d'entrée de l'écriture manuscrite.

Par définition, une trace est un ensemble de données échantillonnées à partir d'un toucher. Outre les données ponctuelles de base, elle peut également inclure d'autres types de données, telles que l'heure de chaque point. La méthode d'entrée peut définir les canaux d'entrée souhaités au début d'un événement de traçage.

La méthode d'entrée ne participe pas à la collecte proprement dite des données de la trace. Cependant, la méthode d'entrée a un contrôle total sur l'entrée puisqu'elle peut accepter ou rejeter un site QVirtualKeyboardTrace (par exemple, s'il y a trop d'instances à traiter). Cela permet également de contrôler avec précision le nombre de doigts pouvant être utilisés simultanément.

La méthode de saisie peut collecter autant de traces qu'elle le souhaite et commencer à les traiter lorsque c'est nécessaire. Le traitement peut même être effectué en parallèle tout en échantillonnant les données, bien que cela ne soit pas recommandé en raison des problèmes de performance potentiels. Il est recommandé de lancer le traitement dans un thread d'arrière-plan après un délai approprié à partir de la dernière entrée, de manière à ce que le traitement n'ait pas d'incidence négative sur l'interface utilisateur.

API de traçage pour les méthodes d'entrée

L'API de traçage se compose des méthodes virtuelles suivantes, que la méthode d'entrée doit mettre en œuvre afin de recevoir et de traiter les données d'entrée de traçage.

• patternRecognitionModes
• traceBegin
• traceEnd

En implémentant ces méthodes, la méthode d'entrée peut recevoir et traiter des données provenant de diverses sources d'entrée (par exemple, la disposition du clavier ou le plein écran).

La méthode patternRecognitionModes renvoie une liste des modes de reconnaissance des formes pris en charge par la méthode de saisie. Un mode de reconnaissance des formes, tel que Handwriting , définit la méthode par laquelle la méthode de saisie traite les données.

L'interaction de traçage est lancée lorsqu'une source d'entrée détecte un nouveau point de contact et appelle la méthode traceBegin pour un nouvel objet de traçage. Si la méthode d'entrée accepte l'interaction, elle crée un nouvel objet trace et le renvoie à l'appelant. À partir de ce moment, les données de traçage sont collectées jusqu'à l'appel de la méthode traceEnd.

Lorsque la méthode traceEnd est appelée, la méthode d'entrée peut commencer à traiter les données contenues dans l'objet trace. Après avoir traité les données, la méthode d'entrée doit détruire l'objet. Cette opération supprime également la trace affichée à l'écran.

Dispositions du clavier

Les dispositions de clavier sont situées dans le répertoire src/layouts/builtin. Chaque sous-répertoire du répertoire layout représente une locale. Le répertoire locale est une chaîne de la forme "language_country", où language est un code de langue ISO 639 à deux lettres minuscules, et country est un code de pays ISO 3166 à deux ou trois lettres majuscules.

Types de disposition

Différents types de disposition de clavier sont utilisés dans différents modes de saisie. La disposition par défaut, utilisée pour la saisie de texte normal, est appelée disposition "principale". Le type de disposition est déterminé par le nom du fichier de disposition. Par conséquent, le fichier de disposition "principal" est appelé "main.qml".

Liste des types de mise en page pris en charge :

• main La mise en page principale pour la saisie de texte normal
• symbols La disposition des symboles pour les caractères spéciaux, etc. (activée à partir de la disposition principale)
• numbers La disposition numérique pour les nombres formatés (activée par Qt::ImhFormattedNumbersOnly)
• digits Disposition pour les chiffres uniquement (activée par Qt::ImhDigitsOnly)
• dialpad Disposition du clavier pour la saisie des numéros de téléphone (activée par Qt::ImhDialableCharactersOnly)
• handwriting Disposition d'écriture manuscrite pour la reconnaissance de l'écriture manuscrite (activée à partir de la disposition principale)

Ajout de nouvelles dispositions de clavier

L'élément de disposition de clavier doit être basé sur le type QML KeyboardLayout. Ce type définit l'élément racine de la disposition. L'élément racine possède les propriétés facultatives suivantes, qui peuvent être définies si nécessaire :

De nouvelles lignes sont ajoutées à la disposition de clavier à l'aide du type KeyboardRow. Le type KeyboardRow peut également spécifier le poids des touches par défaut pour ses éléments enfants. Sinon, le poids des touches est hérité de l'élément parent.

Les nouvelles touches sont ajoutées à la rangée de clavier à l'aide du type Key ou de l'un des types de touches spécialisés. Vous trouverez ci-dessous la liste de tous les types de touches :

Par exemple, pour ajouter une touche ordinaire qui envoie un événement de touche à la méthode de saisie :

import QtQuick
import QtQuick.VirtualKeyboard
import QtQuick.VirtualKeyboard.Components

// file: en_GB/main.qml

KeyboardLayout {
    keyWeight: 160
    KeyboardRow {
        Key {
            key: Qt.Key_Q
            text: "q"
        }
    }
}

Calcul de la taille des touches

Les dispositions de clavier sont évolutives, ce qui signifie qu'aucune taille fixe ne peut être définie pour les éléments de la disposition. Au lieu de cela, la largeur des touches est calculée à partir du poids des touches les unes par rapport aux autres et de la hauteur en divisant l'espace de manière égale entre les lignes du clavier.

Dans l'exemple ci-dessus, la taille des touches est héritée des éléments parents dans cet ordre :

Touche > KeyboardRow > KeyboardLayout

La valeur effective du poids des touches sera de 160. Pour les besoins de l'exemple, nous ajoutons une autre touche qui spécifie un poids de touche personnalisé :

import QtQuick
import QtQuick.VirtualKeyboard
import QtQuick.VirtualKeyboard.Components

// file: en_GB/main.qml

KeyboardLayout {
    keyWeight: 160
    KeyboardRow {
        Key {
            key: Qt.Key_Q
            text: "q"
        }
        Key {
            key: Qt.Key_W
            text: "w"
            keyWeight: 200
        }
    }
}

Le poids total des touches d'une rangée est maintenant de 160 + 200 = 360. Lorsque la disposition du clavier est activée, la largeur d'une touche individuelle est calculée comme suit :

largeur de la touche en pixels = poids de la touche / SOMME (poids des touches d'une rangée) * largeur de la rangée en pixels

Cela signifie que le clavier peut être mis à l'échelle à n'importe quelle taille, tout en conservant la taille relative des touches.

Touches alternatives

Les touches peuvent spécifier une propriété alternativeKeys, qui donne lieu à une fenêtre contextuelle listant les touches alternatives lorsque l'utilisateur appuie sur la touche et la maintient enfoncée. La propriété alternativeKeys peut spécifier une chaîne ou une liste de chaînes. Si alternativeKeys est une chaîne, l'utilisateur peut choisir parmi les caractères de la chaîne.

Styles et dispositions

Les dispositions de clavier ne peuvent pas spécifier d'éléments visuels. Au lieu de cela, la disposition est visualisée par le style de clavier. D'autre part, le style de clavier ne peut pas affecter la taille de la disposition de clavier.

Dispositions de clavier avec plusieurs pages de touches

Certaines dispositions de clavier, telles que les dispositions de symboles, peuvent contenir plus de touches qu'il n'est possible d'en présenter sur une seule disposition de clavier. Une solution consiste à intégrer plusieurs dispositions de clavier dans le même contexte en utilisant le site KeyboardLayoutLoader.

Lorsque le site KeyboardLayoutLoader est utilisé comme élément racine d'une disposition de clavier, les dispositions de clavier proprement dites sont enveloppées dans des éléments Component. La disposition de clavier est activée en attribuant l'identifiant d'un composant actif à la propriété sourceComponent.

En voici un exemple :

import QtQuick
import QtQuick.VirtualKeyboard
import QtQuick.VirtualKeyboard.Components

// file: en_GB/symbols.qml

KeyboardLayoutLoader {
    property bool secondPage
    onVisibleChanged: if (!visible) secondPage = false
    sourceComponent: secondPage ? page2 : page1
    Component {
        id: page1
        KeyboardLayout {
            KeyboardRow {
                Key {
                    displayText: "1/2"
                    functionKey: true
                    onClicked: secondPage = !secondPage
                }
            }
        }
    }
    Component {
        id: page2
        KeyboardLayout {
            KeyboardRow {
                Key {
                    displayText: "2/2"
                    functionKey: true
                    onClicked: secondPage = !secondPage
                }
            }
        }
    }
}

Disposition de clavier pour l'écriture manuscrite

Chaque langue qui prend en charge la reconnaissance de l'écriture manuscrite doit fournir une disposition de clavier spéciale appelée handwriting.qml.

Ce type de disposition de clavier doit répondre aux exigences suivantes :

• il contient une adresse TraceInputKey dans la disposition de clavier
• fournit une instance de HandwritingInputMethod comme méthode d'entrée.

La disposition d'écriture manuscrite peut également inclure ChangeLanguageKey. Pour ce faire, il est important d'utiliser l'attribut customLayoutsOnly, qui filtrera les langues qui n'utilisent pas l'écriture manuscrite.

La présentation principale et la présentation de l'écriture manuscrite doivent contenir une touche permettant d'activer et de désactiver le mode d'entrée de l'écriture manuscrite. Pour ce faire, il suffit d'ajouter une adresse HandwritingModeKey à la présentation.

Ajout de dispositions personnalisées

Le système de disposition des claviers virtuels prend en charge les dispositions intégrées ainsi que les dispositions personnalisées. Les dispositions intégrées sont intégrées en tant que ressources Qt dans le binaire du plugin. Les dispositions personnalisées sont situées dans le système de fichiers, de sorte qu'elles peuvent être installées sans recompiler le clavier virtuel lui-même, ou elles peuvent être situées dans un fichier de ressources.

La sélection des dispositions au moment de l'exécution est affectée par la variable d'environnement QT_VIRTUALKEYBOARD_LAYOUT_PATH.

Si la variable d'environnement n'est pas définie ou si elle contient un répertoire invalide, le clavier virtuel revient aux dispositions intégrées par défaut.

Pour empêcher l'intégration des dispositions intégrées dans le plugin du clavier virtuel lors de l'utilisation de dispositions personnalisées, ajoutez l'option -no-vkb-layouts au script configure. Pour plus d'informations, voir Options de configuration.

Styles de clavier

Le système de style du clavier virtuel prend en charge les styles intégrés ainsi que les styles personnalisés. Les styles intégrés sont incorporés en tant que Qt Location dans le binaire du plugin et les styles personnalisés sont situés dans le système de fichiers et peuvent être installés sans recompiler le clavier virtuel lui-même.

La sélection du style d'exécution est affectée par une variable d'environnement QT_VIRTUALKEYBOARD_STYLE, qui peut être définie sur le nom du style intégré, par exemple "retro", ou sur n'importe lequel des styles personnalisés installés dans le répertoire Styles :

$$[QT_INSTALL_QML]/QtQuick/VirtualKeyboard/Styles

Si la variable d'environnement n'est pas définie ou si elle contient un nom de style invalide, le clavier virtuel reprend le style intégré par défaut.

Ajouter des styles personnalisés

Le processus de création d'un nouveau style commence par la création d'un nouveau sous-répertoire pour le style dans un chemin d'importation QML sous la structure de répertoire basée sur l'URL QtQuick/VirtualKeyboard/Styles/. Voir Chemin d'importation QML pour plus d'informations sur les chemins d'importation QML. Le nom du répertoire ne peut pas contenir d'espaces ou de caractères spéciaux autres que le trait de soulignement. Le nom du répertoire ne peut pas non plus être identique à l'un des styles intégrés, qui comprennent actuellement "default" et "retro".

Un bon point de départ pour créer un nouveau style est d'utiliser un style intégré existant comme modèle et de le modifier. Vous pouvez trouver les styles intégrés dans le répertoire des sources du clavier virtuel src/styles/builtin. Copiez l'un des répertoires contenant un style intégré dans le répertoire Styles et renommez-le "test". La structure du répertoire devrait maintenant être la suivante :

test/default_style.qrc
test/style.qml
test/images
test/images/backspace.png
test/images/check.png
test/images/enter.png
test/images/globe.png
test/images/hidekeyboard.png
test/images/search.png
test/images/shift.png

Le fichier de configuration QRC, qui n'est pas nécessaire dans ce cas, peut être supprimé sans risque.

Ensuite, ouvrez le fichier style.qml dans votre éditeur préféré et donnez à la propriété resourcePrefix la valeur d'une chaîne vide. Le préfixe de ressource n'est pas nécessaire car les ressources sont contenues dans le même répertoire que le fichier style.qml.

De plus, pour qu'il soit plus évident de voir que le style personnalisé est effectivement chargé et utilisé, donnez une couleur différente à l'arrière-plan du clavier :

keyboardBackground: Rectangle {
    color: "gray"
}

La dernière étape consiste à exécuter l'application d'exemple avec votre style personnalisé :

QT_VIRTUALKEYBOARD_STYLE=test virtualkeyboard

Utilisation de Qt Virtual Keyboard avec QQuickWidget

Lorsque vous utilisez Qt Virtual Keyboard dans un QQuickWidget sur un appareil tactile, il est nécessaire de définir l'attribut Qt::WA_AcceptTouchEvents via QWidget::setAttribute(). Sans cet attribut, les événements provenant d'un périphérique tactile seront convertis en événements souris synthétisés.