Qt Virtual Keyboard Übersicht

Funktionen

Zu den wichtigsten Funktionen der „ Qt Virtual Keyboard “ gehören:

• Anpassbare Tastaturlayouts und -stile mit dynamischer Umschaltung.
• Vorausschauende Texteingabe mit Wortauswahl.
• Zeichenvorschau und Anzeige alternativer Zeichen.
• Automatische Großschreibung und Einfügen von Leerzeichen.
• Skalierbarkeit auf verschiedene Auflösungen.
• Unterstützung verschiedener Zeichensätze (Latein, vereinfachtes/traditionelles Chinesisch, Hindi, Japanisch, Arabisch, Hebräisch, Koreanisch und andere).
• Unterstützung der gängigsten Eingabesprachen mit der Möglichkeit, die Sprachunterstützung problemlos zu erweitern.
• Eingabe von links nach rechts und von rechts nach links.
• Unterstützung von Hardwaretasten für die 2-Wege- und 5-Wege-Navigation.
• Unterstützung für Handschrift mit Gesten für die Eingabe im Vollbildmodus.
• Akustisches Feedback.
• Plattformübergreifende Funktionalität.
• Unterstützt sowohl „Qt Quick “- als auch „ Qt Widgets “-Anwendungen.

Unterstützte Sprachen

Die virtuelle Tastatur unterstützt die folgenden Sprachen:

Informationen zum Hinzufügen einer weiteren Sprache finden Sie unter „Neue Tastaturlayouts hinzufügen“.

Plugins von Drittanbietern

Der „ Qt Virtual Keyboard “ unterstützt Plugins von Drittanbietern der folgenden Hersteller:

• Cerence XT9 Advanced Input.
• Cerence Handwriting – Texteingabe per Handschrift.
• MyScript Text – Handschrifterkennung

Im Dokument„Building Qt Virtual Keyboard “ wird beschrieben, wie diese Plugins in den „ Qt Virtual Keyboard “ integriert werden können.

Grundlegende Konzepte

Das Projekt „ Qt Virtual Keyboard “ ist ein Qt-Eingabekontext-Plugin, das die Schnittstellen „QPlatformInputContextPlugin“ und „QPlatformInputContext“ implementiert. Diese Schnittstellen ermöglichen es, das Plugin als Plattform-Eingabekontext-Plugin in Qt-Anwendungen zu verwenden.

Das Plugin selbst stellt ein Eingabe-Framework bereit, das mehrere Eingabemethoden unterstützt, sowie eine QML-Benutzeroberfläche für die virtuelle Tastatur. Das Eingabe-Framework ist über eine Plugin-Schnittstelle erweiterbar, wodurch Eingabemethoden und Tastaturlayouts von Drittanbietern zur Laufzeit geladen werden können.

Das Eingabe-Framework stellt die folgenden Hauptschnittstellen bereit:

• QVirtualKeyboardInputContext: Stellt Kontextinformationen für die virtuelle Tastatur und andere Eingabekomponenten bereit. Dient als Schnittstelle zur zugrunde liegenden Texteingabekomponente.
• QVirtualKeyboardInputEngine: Stellt eine API zur Integration von Benutzereingabeereignissen (Tastendrücke usw.) bereit und fungiert als Host für Eingabemethoden.
• QVirtualKeyboardAbstractInputMethod: Ein Basistyp für C++-basierte Eingabemethoden. Die Eingabemethode verarbeitet in der Regel Tastenereignisse, kann aber auch Maus- und Touch-Eingabeereignisse verarbeiten.
• InputMethod: Ein Basistyp für QML-basierte Eingabemethoden. Die Eingabemethode verarbeitet in der Regel Tastenereignisse, kann aber auch Maus- und Touch-Eingabeereignisse verarbeiten.

Eingabekontext

Der Eingabekontext wird sowohl von der Tastatur als auch von konkreten Eingabemethoden verwendet. ` InputContext ` ist eine von QML gehostete Singleton-Instanz. Eine Anwendung sollte nicht direkt mit dem Eingabekontext interagieren.

Kontextinformationen

Der Eingabekontext bietet Zugriff auf Kontextinformationen, die aus der Anwendung stammen. Zu diesen Informationen gehören unter anderem:

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

Ländereinstellung

Die Virtual Keyboard Engine generiert die Liste der unterstützten Locales aus den localespezifischen Layout-Verzeichnissen in „ layouts/ “. Jedes Layout-Verzeichnis muss eine Definition oder einen Fallback für die folgenden Layout-Typen enthalten: Wählfeld, Ziffern, Handschrift, Hauptlayout, Zahlen und Symbole. Definitionen werden in „ .qml “-Dateien implementiert, Fallbacks werden durch eine Platzhalterdatei mit der Dateiendung „ .fallback “ definiert. Das Verzeichnis „ layouts/ “ muss ein Unterverzeichnis „ fallback/ “ enthalten, das Definitionen für jeden Layouttyp enthält.

Jedes Layout-Verzeichnis kann die Definition eines oder mehrerer Layouttypen enthalten. Wenn das sprachspezifische Layout mit dem der Fallback-Sprache übereinstimmt, kannst du eine Platzhalterdatei für das Layout namens „ <layout type>.fallback “ hinzufügen. Dadurch wird die virtuelle Tastatur angewiesen, stattdessen das Fallback-Layout zu verwenden.

Beispiel: Sie können ein lokalisierungsspezifisches Layout für Finnisch hinzufügen, das den Hauptlayouttyp in „ main.qml “ definiert. Für die anderen Layouttypen entscheiden Sie sich für den Fallback-Mechanismus. Ihr Verzeichnisbaum „ layouts/ “ sieht dann wie folgt aus:

.
├── 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

Es ist unbedingt erforderlich, dass das Verzeichnis „ layouts/fallback “ stets einen Satz vollständiger Implementierungsdateien enthält.

Die Anwendung kann das Anfangslayout festlegen, indem sie die Standard-Locale ändert. Dies muss jedoch geschehen, bevor die Anwendung das Eingabemethoden-Plugin initialisiert und lädt. Wenn keine Änderungen an der Standard-Locale vorgenommen werden, wird die aktuelle System-Locale verwendet.

Die Zuordnung der Tastatur-Locale erfolgt in folgender Reihenfolge:

• layouts/<language>_<country>
• layouts/<language>_*
• layouts/fallback – Das Standardlayout ist hier „en_GB“.

Zunächst wird die Locale mit dem vollständigen Locale-Namen abgeglichen. Wenn keine vollständige Übereinstimmung vorliegt, wird nur die Sprache der Locale abgeglichen. Schließlich wird der Inhalt von „ layouts/fallback “ als Fallback verwendet, wenn auch keine teilweise Übereinstimmung vorliegt.

Nachdem die Locale-Auswahl abgeschlossen ist, aktualisiert die Tastatur die Eingabe-Locale und die Eingaberichtung entsprechend dem aktuellen Layout. Die Anwendung kann diese Informationen über die Schnittstelle ` QInputMethod ` abrufen.

Intern wird die aktuelle Eingabe-Locale ebenfalls in „ QVirtualKeyboardInputEngine “ und den aktuellen Instanzen der Eingabemethoden aktualisiert.

Eingabe-Engine

Das Objekt „input engine“ gehört zu „ InputContext “. Wie bei „ InputContext “ gibt es nur eine Instanz von „ QVirtualKeyboardInputEngine “. Die Eingabe-Engine enthält API-Funktionen, mit denen die Tastatur Benutzerinteraktionen – wie Tastenanschlag- und -loslassereignisse – der Eingabemethode zuordnet.

Beispielsweise werden Tastenereignisse der virtuellen Tastatur über die folgenden Methoden zugeordnet:

• QVirtualKeyboardInputEngine::virtualKeyPress
• QVirtualKeyboardInputEngine::virtualKeyRelease

Die oben genannten Methoden sind für die Integration der virtuellen Tastatur vorgesehen, daher auch das Wort „virtual“ in den Methodennamen. Das bedeutet auch, dass die Methoden nicht für die Zuordnung physischer Tastenanschläge geeignet sind. Dies ergibt sich daraus, dass die eigentliche Aktion erst beim Loslassen der Taste ausgeführt wird.

Wird der Tastendruck vor dem Tastenloslass-Ereignis unterbrochen, ruft die Tastatur die Methode ` QVirtualKeyboardInputEngine::virtualKeyCancel ` auf.

Eingabemethode

Die Eingabemethode ist eine konkrete Implementierung des Tastendruck-Handlers. Ihre Hauptaufgabe besteht darin, Tastendruckereignisse zu verarbeiten und Zustandsinformationen für die Benutzereingabe zu verwalten. Sie interagiert mit dem Texteditor über „ QVirtualKeyboardInputContext “ mittels Vorbearbeitungstext- oder Tastenereignissen.

Die Instanz der Eingabemethode kann je nach Anwendungsfall auf verschiedene Weise erstellt werden:

• KeyboardLayout::inputMethod: Das Tastaturlayout kann eine Eingabemethoden-Instanz ausschließlich für dieses Tastaturlayout erstellen. Es ist zu beachten, dass diese Instanz zerstört wird, wenn sich das Tastaturlayout ändert. Daher ist diese Methode in der Regel auf sehr enge Anwendungsfälle beschränkt.
• KeyboardLayout::createInputMethod(): Das Tastaturlayout kann dynamisch eine Eingabemethode erstellen, die sowohl mit diesem Layout als auch mit dem „ shared layouts “ (z. B. Symbol-Layout) verwendet werden kann. Dies ist die bevorzugte Methode zum Erstellen spezialisierter Eingabemethoden, wie sie beispielsweise bei komplexen Sprachen oder bei der Handschrifterkennung zum Einsatz kommen.
• DefaultInputMethod: Die virtuelle Tastatur versucht beim Start, diese Art von Eingabemethode zu erstellen. Diese Instanz wird als Standard-Eingabemethode für alle Tastaturlayouts verwendet, es sei denn, das Tastaturlayout nutzt eine benutzerdefinierte Eingabemethode. Diese Instanz bleibt auch bei Änderungen des Tastaturlayouts über verschiedene Sprachen hinweg bestehen und ist die bevorzugte Methode zum Erstellen und Überschreiben der Standard-Eingabemethode.

Plugins für die virtuelle Tastatur

Das Verzeichnis „src/plugins“ der virtuellen Tastatur enthält die vorhandenen Plugins für die virtuelle Tastatur. Bei diesen Plugins handelt es sich um Standard-QML-Module, die implizit vom QML-Modul „ QtQuick.VirtualKeyboard.Plugins“ geladen werden.

Ein Plugin kann Tastaturlayouts und Eingabemethoden bereitstellen (in der Regel beides). Die vom virtuellen Tastaturmodul verwendete Eingabemethode hängt davon ab, welches Tastaturlayout gerade verwendet wird. Das Tastaturlayout kann über die Funktion ` KeyboardLayout.createInputMethod()` eine Instanz einer benutzerdefinierten Eingabemethode bereitstellen. Andernfalls wird die vom virtuellen Tastaturmodul erstellte Standard-Eingabemethode (`DefaultInputMethod`) verwendet.

Hinzufügen von Tastaturlayouts

Das Plugin kann Tastaturlayouts für die virtuelle Tastatur hinzufügen, indem es die Layout-Dateien in die Qt-Ressourcen der Plugin-Binärdatei einbindet.

Die virtuelle Tastatur sucht nach den Tastaturlayouts (pro Sprache) unter einem bestimmten Pfad /qt-project.org/imports/QtQuick/VirtualKeyboard/Layouts/<LANGUAGE_COUNTRY>; daher ist es unerlässlich, genau diesen Pfad auch im Plugin zu verwenden. Qt-Ressourcenpfade können sich überschneiden, was bedeutet, dass das Plugin vorhandene Layouts auf dem Qt Virtual Keyboard überschreiben kann.

Es ist zudem möglich, die integrierten Tastaturlayouts zu überschreiben, indem man sie mithilfe der Umgebungsvariable ` QT_VIRTUALKEYBOARD_LAYOUT_PATH ` direkt aus dem Dateisystem laden lässt.

Hinzufügen einer Eingabemethode

Das Plugin kann eine Eingabemethode registrieren, die von anderen Tastaturlayouts standardmäßig verwendet werden kann (z. B. DefaultInputMethod), oder eine Eingabemethode, die intern im Plugin verwendet wird (indem zusätzlich ein benutzerdefiniertes Tastaturlayout bereitgestellt wird, das die Eingabemethode erstellt).

Die Eingabemethode muss eine Schnittstelle „ QVirtualKeyboardAbstractInputMethod “ (C++) oder „ InputMethod “ (QML) implementieren und vom Plugin als QML-Typ („QML_NAMED_ELEMENT “) registriert werden.

Implementierung einer benutzerdefinierten Eingabemethode

Die Implementierung von Eingabemethoden beginnt mit der Entscheidung, welche Schnittstelle verwendet wird: QML oder C++. In diesem Beispiel wird die QML-Schnittstelle verwendet. Die gleiche Logik und die gleichen Schnittstellen gelten auch für die C++-Schnittstelle „ QVirtualKeyboardAbstractInputMethod “. In diesem Fall muss das Plugin mit dem „VirtualKeyboard “-Modul verknüpft werden.

Das folgende Beispiel zeigt die Mindestfunktionalität, die von einer Eingabemethode erwartet wird:

// 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;
    }
}

Die Methode ` InputMethod::inputModes()` wird von der Eingabe-Engine aufgerufen, bevor ein Eingabemodus festgelegt wird. Die Methode gibt eine Liste der in der angegebenen Locale verfügbaren Eingabemodi zurück.

Eine Eingabemethode wird in der Methode ` InputMethod::setInputMode()` mit einer Locale und einem Eingabemodus initialisiert. Nach der Festlegung der Locale und des Eingabemodus sollte die Eingabemethode einsatzbereit sein.

InputMethod::reset() wird aufgerufen, wenn eine Eingabemethode zurückgesetzt werden muss. Das Zurücksetzen darf nur den internen Zustand der Eingabemethode betreffen, nicht den Benutzentext.

InputMethod::update() wird aufgerufen, wenn der Eingabekontext aktualisiert wird und der Eingabezustand möglicherweise nicht mehr synchron ist. Die Eingabemethode sollte den aktuellen Text festschreiben.

Die Tastenanschlag-Ereignisse werden in ` InputMethod::keyEvent()` verarbeitet. Diese Methode verarbeitet ein einzelnes Tastenanschlag-Ereignis und gibt ` true ` zurück, wenn das Ereignis verarbeitet wurde. Andernfalls wird der Tastenanschlag von der Standard-Eingabemethode verarbeitet.

Auswahllisten

Auswahllisten sind eine optionale Funktion, die in die Eingabemethode integriert werden kann. Das Eingabe-Framework unterstützt verschiedene Arten von Listen, wie beispielsweise die Wortkandidatenliste. Die Zuständigkeiten bei der Implementierung der Listen sind so geregelt, dass die Eingabemethode für den Inhalt und die Interaktionen, wie z. B. das Klickverhalten, verantwortlich ist. Das Eingabe-Framework ist für die Pflege des Listenmodells und die Bereitstellung an die Benutzeroberfläche zuständig.

Zuweisung der Auswahllisten

Auswahllisten werden bei der Aktivierung der Eingabemethode zugewiesen. Die Methode ` InputMethod::selectionLists()` gibt eine Liste der erforderlichen Auswahllistentypen zurück:

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

Im obigen Beispiel weist die Eingabemethode die Wortkandidatenliste für ihre Verwendung zu.

Aktualisierung der Auswahllisten

Wenn die Eingabemethode die Benutzeroberfläche auffordert, den Inhalt einer Auswahlliste zu aktualisieren, sendet sie das Signal „ InputMethod::selectionListChanged “ aus. Ebenso sendet die Eingabemethode das Signal „ InputMethod::selectionListActiveItemChanged “ aus, wenn sie die Benutzeroberfläche auffordert, ein Element in der Liste hervorzuheben.

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

Befüllen der Auswahllisten mit Elementen

Die Elemente werden mit Method-Callbacks gefüllt, die sowohl die Anzahl der Elemente in einer Liste als auch die Daten für einzelne Elemente bereitstellen.

Der Callback „ InputMethod::selectionListItemCount “ fordert die Anzahl der Elemente in der Liste an, die durch den angegebenen Typ identifiziert wird.

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

Der Callback „ InputMethod::selectionListData “ fordert die Daten für Elemente an.

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
}

Der Parameter „ role “ gibt an, welche Daten für ein Element angefordert werden. Beispielsweise fordert „ SelectionListModel.Role.Display“ die Anzeigetextdaten an.

Reagieren auf Benutzeraktionen

Wenn der Benutzer ein Element in der Liste auswählt, reagiert die Eingabemethode auf das Ereignis im Callback der Methode „ InputMethod::selectionListItemSelected “.

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

Integration der Handschrifterkennung

Eine Eingabemethode kann auch Eingabedaten vom Touchscreen oder anderen Eingabegeräten verwenden.

Zu Beginn der Eingabe ruft die virtuelle Tastatur die Funktion „ traceBegin “ der Eingabemethode auf, die ein neues „ Trace “-Objekt zurückgibt, in dem die Eingabe im Auftrag der Eingabemethode gesammelt wird. Analog dazu wird das Ereignis durch den Aufruf „ traceEnd “ beendet, sobald der Finger oder Stift abgehoben wird. Die Eingabemethode verarbeitet die gesammelten Daten und erzeugt Text mithilfe der Schnittstelle „ InputContext “.

Es gibt vordefinierte Tastaturlayouts für die Handschrifteingabe. Diese sind jedoch standardmäßig nicht enthalten, und das Handschrift-Plugin sollte sie in seine eigenen Ressourcen aufnehmen. Beispiele hierfür finden Sie in den vorhandenen Handschrift-Plugins von MyScript oder Cerence.

Datenmodell für die Handschrifteingabe

Die virtuelle Tastatur sammelt die Handschriftdaten in einem speziellen Datenmodell „ QVirtualKeyboardTrace “. Jede „Trace“ stellt eine Sammlung von Daten dar, die bei einer Berührung (z. B. einem Wisch über den Bildschirm) erfasst wurden. Es gibt so viele Instanzen von „ QVirtualKeyboardTrace “, wie Berührungen im Handschrifteingabebereich stattfinden.

Per Definition ist ein „Trace“ eine Reihe von Daten, die bei einer Berührung erfasst wurden. Zusätzlich zu den grundlegenden Punktdaten kann er auch andere Datentypen enthalten, wie beispielsweise den Zeitpunkt jedes Punktes. Die Eingabemethode kann die gewünschten Eingabekanäle zu Beginn eines „Trace“-Ereignisses definieren.

Die Eingabemethode ist nicht an der eigentlichen Erfassung von Trace-Daten beteiligt. Sie hat jedoch die volle Kontrolle über die Eingabe, da sie ein „ QVirtualKeyboardTrace “ entweder akzeptieren oder ablehnen kann (z. B. wenn zu viele Instanzen zur Verarbeitung anstehen). Dies ermöglicht auch eine präzise Steuerung darüber, wie viele Finger gleichzeitig verwendet werden können.

Die Eingabemethode kann so viele Trace-Datensätze erfassen, wie sie für angemessen hält, und bei Bedarf mit deren Verarbeitung beginnen. Die Verarbeitung kann sogar parallel zur Erfassung der Daten erfolgen, was jedoch aufgrund möglicher Leistungseinbußen nicht empfohlen wird. Es wird empfohlen, die Verarbeitung in einem Hintergrund-Thread nach einer angemessenen Verzögerung seit der letzten Eingabe zu starten, damit die Verarbeitung die Benutzeroberfläche nicht beeinträchtigt.

Trace-API für Eingabemethoden

Die Trace-API besteht aus den folgenden virtuellen Methoden, die die Eingabemethode implementieren muss, um Trace-Eingabedaten zu empfangen und zu verarbeiten.

• patternRecognitionModes
• traceBegin
• traceEnd

Durch die Implementierung dieser Methoden kann die Eingabemethode Daten aus einer Vielzahl von Eingabequellen (z. B. Tastaturlayout oder Vollbildmodus) empfangen und verarbeiten.

Die Methode `patternRecognitionModes` gibt eine Liste der Mustererkennungsmodi zurück, die von der Eingabemethode unterstützt werden. Ein Mustererkennungsmodus, wie beispielsweise „ Handwriting “, definiert die Methode, mit der die Eingabemethode die Daten verarbeitet.

Die Trace-Interaktion wird gestartet, wenn eine Eingabequelle einen neuen Kontaktpunkt erkennt und die Methode `traceBegin` für ein neues Trace-Objekt aufruft. Wenn die Eingabemethode die Interaktion akzeptiert, erstellt sie ein neues Trace-Objekt und gibt es an den Aufrufer zurück. Ab diesem Zeitpunkt werden Trace-Daten gesammelt, bis die Methode `traceEnd` aufgerufen wird.

Wenn die Methode `traceEnd` aufgerufen wird, kann die Eingabemethode mit der Verarbeitung der im Trace-Objekt enthaltenen Daten beginnen. Nach der Verarbeitung der Daten sollte die Eingabemethode das Objekt löschen. Dadurch wird auch die auf dem Bildschirm angezeigte Trace-Darstellung entfernt.

Tastaturlayouts

Die Tastaturlayouts befinden sich im Verzeichnis „src/layouts/builtin “. Jedes Unterverzeichnis des Verzeichnisses „layouts“ steht für eine Locale. Das Locale-Verzeichnis ist eine Zeichenkette der Form „Sprache_Land“, wobei „Sprache“ ein zweistelliger ISO 639-Sprachcode in Kleinbuchstaben und „Land“ ein zwei- oder dreistelliger ISO 3166-Ländercode in Großbuchstaben ist.

Layout-Typen

In verschiedenen Eingabemodi kommen unterschiedliche Tastaturlayout-Typen zum Einsatz. Das Standardlayout, das für die normale Texteingabe verwendet wird, wird als „main“-Layout bezeichnet. Der Layout-Typ wird durch den Namen der Layout-Datei bestimmt. Daher heißt die „main“-Layout-Datei „main.qml“.

Liste der unterstützten Layouttypen:

• main Das Hauptlayout für die normale Texteingabe
• symbols Symbol-Layout für Sonderzeichen usw. (wird über das Hauptlayout aktiviert)
• numbers Zahlenlayout für formatierte Zahlen (aktiviert über Qt::ImhFormattedNumbersOnly)
• digits Layout „Nur Ziffern“ (aktiviert über ` Qt::ImhDigitsOnly`)
• dialpad Wählfeld-Layout für die Eingabe von Telefonnummern (aktiviert über „ Qt::ImhDialableCharactersOnly “)
• handwriting Handschrift-Layout für die Handschrifterkennung (aktivierbar über das Hauptlayout)

Hinzufügen neuer Tastaturlayouts

Das Tastaturlayout-Element muss auf dem QML-Typ „ KeyboardLayout “ basieren. Dieser Typ definiert das Stammelement des Layouts. Das Stammelement verfügt über die folgenden optionalen Eigenschaften, die bei Bedarf festgelegt werden können:

Neue Zeilen werden dem Tastaturlayout mithilfe des Typs „ KeyboardRow “ hinzugefügt. Das Element „ KeyboardRow “ kann auch das Standardtastengewicht für seine untergeordneten Elemente festlegen. Andernfalls wird das Tastengewicht vom übergeordneten Element geerbt.

Neue Tasten werden mithilfe des Typs „Key“ oder eines der spezialisierten Tastentypen zur Tastaturreihe hinzugefügt. Nachfolgend finden Sie eine Liste aller Tastentypen:

Beispiel: So fügen Sie eine normale Taste hinzu, die ein Tastenereignis an die Eingabemethode sendet:

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"
        }
    }
}

Berechnung der Tastengröße

Die Tastaturlayouts sind skalierbar, was bedeutet, dass für keine Elemente im Layout feste Größen festgelegt werden können. Stattdessen werden die Tastenbreiten anhand des relativen Gewichts der Tasten zueinander und der Höhe berechnet, indem der Platz gleichmäßig auf die Tastaturreihen aufgeteilt wird.

Im obigen Beispiel wird die Tastengröße in folgender Reihenfolge von übergeordneten Elementen übernommen:

Taste > „ KeyboardRow “ > KeyboardLayout

Der effektive Wert für das Tastengewicht beträgt 160. Zur Veranschaulichung fügen wir eine weitere Taste hinzu, die ein benutzerdefiniertes Tastengewicht angibt:

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
        }
    }
}

Nun beträgt das gesamte Tastengewicht einer Zeile 160 + 200 = 360. Wenn das Tastaturlayout aktiviert ist, wird die Breite einer einzelnen Taste wie folgt berechnet:

Tastenbreite in Pixeln = Tastengewicht / SUM(Tastengewichte in einer Zeile) * Zeilenbreite in Pixeln

Das bedeutet, dass die Tastatur auf jede beliebige Größe skaliert werden kann, während die relativen Tastengrößen gleich bleiben.

Alternative Tasten

Eine Taste kann eine `alternativeKeys`-Eigenschaft angeben, die dazu führt, dass ein Popup-Fenster mit alternativen Tasten angezeigt wird, wenn der Benutzer die Taste gedrückt hält. Die `alternativeKeys` können entweder eine Zeichenkette oder eine Liste von Zeichenketten sein. Ist `alternativeKeys` eine Zeichenkette, kann der Benutzer zwischen den Zeichen in der Zeichenkette wählen.

Stile und Layouts

Die Tastaturlayouts können keine visuellen Elemente festlegen. Stattdessen wird das Layout durch den Tastaturstil visualisiert. Andererseits kann der Tastaturstil die Größe des Tastaturlayouts nicht beeinflussen.

Tastaturlayouts mit mehreren Seiten von Tasten

Einige Tastaturlayouts, wie beispielsweise Symbol-Layouts, können mehr Tasten enthalten, als auf einem einzelnen Tastaturlayout dargestellt werden können. Eine Lösung besteht darin, mehrere Tastaturlayouts mithilfe von ` KeyboardLayoutLoader` in denselben Kontext einzubetten.

Wird die „ KeyboardLayoutLoader “ als Stammelement eines Tastaturlayouts verwendet, werden die eigentlichen Tastaturlayouts in „Component“-Elemente eingeschlossen. Das Tastaturlayout wird aktiviert, indem die ID einer aktiven Komponente der Eigenschaft „sourceComponent“ zugewiesen wird.

Beispiel:

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
                }
            }
        }
    }
}

Tastaturlayout für Handschrift

Jede Sprache, die die Handschrifterkennung unterstützt, muss ein spezielles Tastaturlayout mit dem Namen „handwriting.qml“ bereitstellen.

Diese Art von Tastaturlayout muss die folgenden Anforderungen erfüllen:

• enthält ein „ TraceInputKey “ im Tastaturlayout
• stellt eine Instanz von „HandwritingInputMethod“ als Eingabemethode bereit.

Das Handschriften-Layout kann auch „ ChangeLanguageKey “ enthalten. Zu diesem Zweck ist es wichtig, das Attribut „ customLayoutsOnly “ zu verwenden, das Sprachen herausfiltert, die keine Handschrifterkennung nutzen.

Sowohl das Hauptlayout als auch das Handschrift-Layout sollten eine Taste zum Aktivieren und Deaktivieren des Handschrifteingabemodus enthalten. Dies kann durch Hinzufügen eines „ HandwritingModeKey “ zum Layout erreicht werden.

Hinzufügen benutzerdefinierter Layouts

Das System für virtuelle Tastaturlayouts unterstützt sowohl integrierte als auch benutzerdefinierte Layouts. Die integrierten Layouts sind als Qt-Ressourcen in die Plugin-Binärdatei eingebettet. Benutzerdefinierte Layouts befinden sich im Dateisystem, sodass sie ohne Neukompilierung der virtuellen Tastatur selbst installiert werden können, oder sie können in einer Ressourcendatei gespeichert sein.

Die Auswahl der Layouts zur Laufzeit wird durch die Umgebungsvariable ` QT_VIRTUALKEYBOARD_LAYOUT_PATH ` beeinflusst.

Falls die Umgebungsvariable nicht gesetzt ist oder ein ungültiges Verzeichnis enthält, greift die virtuelle Tastatur auf die standardmäßigen integrierten Layouts zurück.

Um zu verhindern, dass die integrierten Layouts bei Verwendung benutzerdefinierter Layouts in das Plugin der virtuellen Tastatur eingebaut werden, fügen Sie die Option ` -no-vkb-layouts ` zum Skript ` configure ` hinzu. Weitere Informationen finden Sie unter „Konfigurationsoptionen“.

Tastaturstile

Das Stilsystem des Qt Virtual Keyboard unterstützt sowohl integrierte als auch benutzerdefinierte Stile. Die integrierten Stile sind als Qt-Ressourcen in die Plugin-Binärdatei eingebettet, während sich die benutzerdefinierten Stile im Dateisystem befinden und ohne Neukompilierung des Qt Virtual Keyboard selbst installiert werden können.

Die Auswahl des Laufzeilstils wird durch die Umgebungsvariable `QT_VIRTUALKEYBOARD_STYLE` gesteuert, die auf den Namen des integrierten Stils, z. B. „retro“, oder auf einen der im Verzeichnis „Styles“ installierten benutzerdefinierten Stile gesetzt werden kann:

$$[QT_INSTALL_QML]/QtQuick/VirtualKeyboard/Styles

Falls die Umgebungsvariable nicht gesetzt ist oder einen ungültigen Stilnamen enthält, greift die virtuelle Tastatur auf den integrierten Standardstil zurück.

Hinzufügen benutzerdefinierter Stile

Das Erstellen eines neuen Stils beginnt mit der Erstellung eines neuen Unterverzeichnisses für den Stil in einem QML-Importpfad unter der URL-basierten Verzeichnisstruktur QtQuick/VirtualKeyboard/Styles/. Informationen zu QML-Importpfaden finden Sie unter „QML-Importpfad “. Der Verzeichnisname darf keine Leerzeichen oder Sonderzeichen außer Unterstrichen enthalten. Außerdem darf der Verzeichnisname nicht mit dem Namen eines der integrierten Stile übereinstimmen, zu denen derzeit „default“ und „retro“ gehören.

Ein guter Ausgangspunkt für die Erstellung eines neuen Stils ist es, einen vorhandenen integrierten Stil als Vorlage zu verwenden und diesen zu bearbeiten. Sie finden die integrierten Stile im Quellverzeichnis der virtuellen Tastatur unter src/styles/builtin. Kopieren Sie eines der Verzeichnisse, das einen integrierten Stil enthält, in das Verzeichnis „Styles“ und benennen Sie es in „test“ um. Die Verzeichnisstruktur sollte nun wie folgt aussehen:

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

Die QRC-Konfigurationsdatei, die in diesem Fall nicht benötigt wird, kann bedenkenlos entfernt werden.

Öffne anschließend die Datei „style.qml“ in deinem bevorzugten Editor und setze die Eigenschaft „resourcePrefix“ auf eine leere Zeichenkette. Das Ressourcenpräfix wird nicht benötigt, da sich die Ressourcen im selben Verzeichnis wie die Datei „style.qml“ befinden.

Um außerdem deutlicher zu machen, dass der benutzerdefinierte Stil tatsächlich geladen und verwendet wird, legen Sie für den Tastaturhintergrund eine andere Farbe fest:

keyboardBackground: Rectangle {
    color: "gray"
}

Der letzte Schritt besteht darin, die Beispielanwendung mit Ihrem benutzerdefinierten Stil auszuführen:

QT_VIRTUALKEYBOARD_STYLE=test virtualkeyboard

Verwendung von „ Qt Virtual Keyboard “ mit QQuickWidget

Bei der Verwendung von „ Qt Virtual Keyboard “ in einem „ QQuickWidget “ auf einem Touch-Gerät muss das Attribut „ Qt::WA_AcceptTouchEvents “ über „ QWidget::setAttribute()“ gesetzt werden. Ohne dieses Attribut werden Ereignisse von einem Touch-Gerät in synthetische Mausereignisse umgewandelt.