Техническое руководство

Обзор

В данном документе представлен технический обзор плагина Qt Virtual Keyboard.

Основные концепции

Проект Qt Virtual Keyboard представляет собой плагин контекста ввода Qt, который реализует интерфейсы QPlatformInputContextPlugin и QPlatformInputContext. Эти интерфейсы позволяют использовать плагин в качестве плагина контекста платформенного ввода в приложениях Qt.

Сам плагин предоставляет фреймворк ввода, поддерживающий несколько методов ввода, а также пользовательский интерфейс на QML для виртуальной клавиатуры. Фреймворк ввода расширяется через интерфейс плагинов, что позволяет загружать методы ввода и раскладки клавиатуры сторонних производителей во время выполнения.

Фреймворк ввода предоставляет следующие основные интерфейсы:

• QVirtualKeyboardInputContext: предоставляет контекстную информацию для виртуальной клавиатуры и других компонентов ввода. Выступает в качестве интерфейса к базовому компоненту ввода текста.
• QVirtualKeyboardInputEngine: предоставляет API для интеграции событий ввода пользователя (нажатия клавиш и т. д.) и выступает в роли хоста для методов ввода.
• QVirtualKeyboardAbstractInputMethod: базовый тип для методов ввода на C++. Метод ввода обычно обрабатывает события нажатия клавиш, но также может обрабатывать события мыши и сенсорного ввода.
• InputMethod: базовый тип для методов ввода на QML. Метод ввода обычно обрабатывает события нажатия клавиш, но также может обрабатывать события мыши и сенсорного ввода.
• QVirtualKeyboardExtensionPlugin: интерфейс плагина для расширений виртуальной клавиатуры, предоставляющих дополнительные функции.

Контекст ввода

Контекст ввода используется клавиатурой, а также конкретными методами ввода. InputContext — это экземпляр синглтона, размещённый в QML. Приложение не должно напрямую взаимодействовать с контекстом ввода.

Контекстная информация

Контекст ввода предоставляет доступ к контекстной информации, полученной из приложения. Эта информация включает, но не ограничивается:

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

Локализация

Список поддерживаемых локалей определяется наличием каталога раскладки, специфичной для локали, в "layouts/*". Каждый каталог раскладки может содержать одну или несколько раскладок, например fi_FI/main.qml или symbols.qml. Если раскладка, специфичная для локали, не отличается от локали по умолчанию, то для раскладки можно добавить файл-заполнитель <layout типа>.fallback. Это укажет, что виртуальная клавиатура может использовать раскладку по умолчанию.

По меньшей мере, каталог раскладки должен содержать следующие файлы:

• dialpad.fallback
• digits.fallback
• main.fallback
• numbers.fallback
• symbols.fallback

Приложение может указать начальную раскладку, изменив локаль по умолчанию. Однако это необходимо сделать до инициализации приложения и загрузки плагина метода ввода. Если изменения в локали по умолчанию не внесены, используется текущая системная локализация.

Сопоставление локали клавиатуры выполняется в следующем порядке:

• layouts/<язык>_<<страна>
• layouts/<язык>_*
• layouts/en_GB

Сначала выполняется сопоставление по полному имени локали. Если точного совпадения нет, то сравнивается только язык локали. Если частичное совпадение не найдено, используется локализация "en_GB" в качестве резервного варианта.

После выбора локали клавиатура обновляет локаль ввода и направление ввода, чтобы соответствовать текущей раскладке. Приложение может получить эту информацию через интерфейс QInputMethod.

Внутренне текущая локализация ввода также обновляется в QVirtualKeyboardInputEngine и текущих экземплярах методов ввода.

Двигатель ввода

Объект двигателя ввода принадлежит InputContext. Как и InputContext, существует только один экземпляр QVirtualKeyboardInputEngine. Двигатель ввода содержит функции API, которые клавиатура использует для сопоставления пользовательских взаимодействий, таких как события нажатия и отпускания клавиш, с методом ввода.

Например, события нажатия клавиш виртуальной клавиатуры сопоставляются с помощью следующих методов:

• QVirtualKeyboardInputEngine::virtualKeyPress
• QVirtualKeyboardInputEngine::virtualKeyRelease

Упомянутые выше методы предназначены для интеграции виртуальной клавиатуры, поэтому в их именах присутствует слово «виртуальный». Это также означает, что эти методы не подходят для сопоставления физических нажатий клавиш. Это следствие того, что фактическое действие выполняется только при отпускании клавиши.

Если нажатие клавиши прерывается до события отпускания клавиши, клавиатура вызывает метод QVirtualKeyboardInputEngine::virtualKeyCancel.

Метод ввода

Метод ввода — это конкретная реализация обработчика нажатия клавиш. Его основная функция заключается в обработке событий нажатия клавиш и сохранении информации о состоянии пользовательского ввода. Он взаимодействует с редактором текста через QVirtualKeyboardInputContext посредством предварительного текста или событий нажатия клавиш.

Экземпляр метода ввода может быть создан различными способами, в зависимости от использования:

• KeyboardLayout::inputMethod: раскладка клавиатуры может создать экземпляр метода ввода только для этой раскладки. Следует отметить, что этот экземпляр будет уничтожен при изменении раскладки клавиатуры. Поэтому этот метод обычно ограничен узкими сценариями использования.
• KeyboardLayout::createInputMethod(): раскладка клавиатуры может динамически создать метод ввода, который может использоваться с этой раскладкой, а также с совместно используемыми раскладками (например, раскладкой символов). Это предпочтительный способ создания специализированных методов ввода, таких как методы для сложных языков или рукописного ввода.
• DefaultInputMethod: виртуальная клавиатура пытается создать этот тип метода ввода при запуске. Этот экземпляр будет использоваться в качестве метода ввода по умолчанию для всех раскладок клавиатуры, если раскладка клавиатуры не использует пользовательский метод ввода. Этот экземпляр сохраняется при изменениях раскладок клавиатуры между языками и является предпочтительным способом создания и переопределения метода ввода по умолчанию.

Плагин расширения виртуальной клавиатуры

Плагин расширения позволяет сторонним поставщикам расширять функциональность виртуальной клавиатуры без её перекомпиляции. В настоящее время плагин расширения может предоставлять раскладки клавиатуры и пользовательские методы ввода.

Создание плагина для Qt Virtual Keyboard аналогично стандартному способу создания плагина Qt:

• Связь с библиотекой virtualkeyboard

  Модуль virtualkeyboard должен быть связан с плагином:

  QT += virtualkeyboard

  Это позволяет плагину получить доступ к QVirtualKeyboardInputContext и другим интерфейсам.

• Реализация подкласса QVirtualKeyboardExtensionPlugin.

  Плагин предоставляет виртуальной клавиатуре необходимую метаданные, что позволяет ей сортировать и загружать плагины.

Добавление раскладок клавиатуры

Плагин может добавлять раскладки клавиатуры для виртуальной клавиатуры, включая файлы раскладки в ресурсы Qt двоичного файла плагина.

Виртуальная клавиатура ищет раскладки клавиатуры (по языку) из определённого пути /QtQuick/VirtualKeyboard/content/layouts/<language_COUNTRY>, поэтому важно использовать именно этот путь и в плагине. Пути ресурсов Qt могут перекрываться, однако плагин не может переопределять существующие раскладки в плагине виртуальной клавиатуры.

Если плагин расширения должен переопределять встроенную раскладку клавиатуры, виртуальная клавиатура должна быть перекомпилирована только с определёнными языками (например, CONFIG+=lang-en) или без раскладок клавиатуры (например, CONFIG+=disable-layouts). В качестве альтернативы, если перекомпиляция невозможна, можно переопределить встроенные раскладки клавиатуры и загрузить их непосредственно из файловой системы, используя переменную среды QT_VIRTUALKEYBOARD_LAYOUT_PATH.

Добавление метода ввода

Плагин может регистрировать метод ввода, который другие раскладки клавиатуры могут использовать по умолчанию (например, DefaultInputMethod) или метод ввода, используемый только внутри плагина.

Метод ввода должен реализовывать интерфейс QVirtualKeyboardAbstractInputMethod (C++) или InputMethod (QML), а плагин должен зарегистрировать его как тип QML в методе {QVirtualKeyboardExtensionPlugin::registerTypes}.

Метаданные для плагина расширения

Метаданные позволяют виртуальной клавиатуре проверить плагин перед загрузкой фактической библиотеки. Они также предотвращают загрузку виртуальной клавиатурой конфликтующих плагинов расширения, например, двух плагинов рукописного ввода.

Следующий фрагмент демонстрирует метаданные примера плагина для рукописного ввода:

{
    "Name": "handwriting",
    "Provider": "Qt Handwriting Extension",
    "InputMethod": "HandwritingInputMethod",
    "Version": 100
}

Реализация пользовательского метода ввода

Реализация методов ввода начинается с определения используемого интерфейса; QML или C++. В этом примере используется интерфейс QML.

Следующий пример показывает минимальную функциональность, необходимую от метода ввода:

/****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt Virtual Keyboard module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/

import QtQuick
import QtQuick.VirtualKeyboard

// file: CustomInputMethod.qml

InputMethod {
    function inputModes(locale) {
        return [InputEngine.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;
    }
}

Метод InputMethod::inputModes() вызывается движком ввода перед установкой режима ввода. Метод возвращает список режимов ввода, доступных в данном языке.

Метод ввода инициализируется в методе InputMethod::setInputMode() с языком и режимом ввода. После установки языка и режима ввода метод ввода должен быть готов к использованию.

InputMethod::reset() вызывается при необходимости сброса метода ввода. Сброс должен затрагивать только внутреннее состояние метода ввода, а не текст пользователя.

InputMethod::update() вызывается при обновлении контекста ввода и при возможной несинхронизации состояния ввода. Метод ввода должен подтвердить текущий текст.

Обработка событий нажатия клавиш выполняется в методе InputMethod::keyEvent(). Этот метод обрабатывает одно событие нажатия клавиши и возвращает true если событие было обработано. В противном случае нажатие клавиши обрабатывается методом ввода по умолчанию.

Списки выбора

Списки выбора — это необязательная функция, которая может быть интегрирована в метод ввода. Фреймворк ввода поддерживает различные типы списков, такие как список кандидатов слов. Ответственность за реализацию списков распределяется таким образом, что метод ввода отвечает за содержимое и действия, такие как поведение при нажатии. Фреймворк ввода отвечает за поддержание модели списка и передачу данных в пользовательский интерфейс.

Распределение списков выбора

Списки выбора распределяются при активации метода ввода. Метод InputMethod::selectionLists() возвращает список необходимых типов списков выбора:

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

В приведённом примере метод ввода распределяет список кандидатов слов для использования.

Обновление списков выбора

Когда метод ввода требует обновления содержимого списка выбора в пользовательском интерфейсе, он отправит сигнал InputMethod::selectionListChanged. Аналогично, если метод ввода требует выделения элемента в списке, он отправит сигнал InputMethod::selectionListActiveItemChanged.

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

Заполнение элементов в списках выбора

Элементы заполняются с помощью методов обратного вызова, которые предоставят количество элементов в списке и данные для отдельных элементов.

Метод обратного вызова InputMethod::selectionListItemCount запрашивает количество элементов в списке, идентифицированном по указанному типу.

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

Метод обратного вызова InputMethod::selectionListData запрашивает данные для элементов.

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
}

Параметр role определяет, какие данные запрашиваются для элемента. Например, SelectionListModel.Role.Display запрашивает данные отображаемого текста.

Реакция на действия пользователя

Когда пользователь выбирает элемент в списке, метод ввода реагирует на событие в методе обратного вызова InputMethod::selectionListItemSelected.

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

Интеграция распознавания рукописного ввода

Начиная с версии 2.0 виртуальной клавиатуры, методы ввода могут использовать данные касания от сенсорных экранов или других устройств ввода. Это позволяет интегрировать движок распознавания рукописного ввода в виртуальную клавиатуру без каких-либо изменений в существующих макетах клавиатуры (поскольку виртуальная клавиатура уже предоставляет макеты клавиатуры для рукописного ввода для большинства языков).

Для метода ввода распознавание рукописного ввода работает по тому же принципу, что и обработка обычного ввода с клавиатуры, то есть данные ввода собираются макетом клавиатуры и передаются движком ввода методу ввода для обработки.

Модель данных для ввода рукописного текста

Виртуальная клавиатура собирает данные рукописного ввода в специальной модели данных QVirtualKeyboardTrace. Каждый след представляет собой набор данных, взятых с одного касания (например, скользящего движения по экрану). Будет столько экземпляров QVirtualKeyboardTrace, сколько касаний в области ввода рукописного текста.

По определению, след — это набор данных, взятых с одного касания. Помимо базовых данных о точках, он может также включать другие типы данных, такие как время каждой точки. Метод ввода может определить желаемые каналы ввода в начале события следа.

Метод ввода не участвует в фактическом сборе данных следа. Однако метод ввода имеет полный контроль над вводом, поскольку он может принять или отклонить QVirtualKeyboardTrace (например, если есть слишком много экземпляров для обработки). Это также позволяет точно контролировать, сколько пальцев может быть использовано одновременно.

Метод ввода может собрать столько следов, сколько ему нужно, и начать их обработку при необходимости. Обработка может даже выполняться параллельно во время взятия данных, хотя это не рекомендуется из-за возможных проблем с производительностью. Рекомендуемым способом является запуск обработки в фоновом потоке после подходящей задержки от последнего ввода, чтобы обработка не оказывала негативного влияния на пользовательский интерфейс.

API следов для методов ввода

API следов состоит из следующих виртуальных методов, которые метод ввода должен реализовать для получения и обработки данных следов ввода.

• patternRecognitionModes
• traceBegin
• traceEnd

Реализовав эти методы, метод ввода может получать и обрабатывать данные из различных источников ввода (например, макета клавиатуры или полноэкранного режима).

Взаимодействие с следами начинается, когда источник ввода обнаруживает новую точку контакта и вызывает метод traceBegin для нового объекта следа. Если метод ввода принимает взаимодействие, он создаёт новый объект следа и возвращает его вызывающей стороне. С этого момента данные следов собираются до вызова метода traceEnd.

Когда вызывается метод traceEnd, метод ввода может начать обработку данных, содержащихся в объекте следа. После обработки данных метод ввода должен уничтожить объект. Это также удаляет след, отображаемый на экране.

Макеты клавиатуры

Макеты клавиатуры находятся в каталоге src/virtualkeyboard/content/layouts. Каждый подкаталог каталога макетов представляет собой локаль. Каталог локали представляет собой строку вида "язык_страна", где язык — двухбуквенный код языка ISO 639 в нижнем регистре, а страна — двух- или трёхбуквенный код страны ISO 3166 в верхнем регистре.

Типы макетов

В разных режимах ввода используются различные типы макетов клавиатуры. По умолчанию используется макет "main" для обычного текстового ввода. Тип макета определяется именем файла макета. Таким образом, файл макета "main" называется "main.qml".

Список поддерживаемых типов макетов:

• main Основной макет для обычного текстового ввода
• symbols Макет символов для специальных символов и т. д. (активируется из основного макета)
• numbers Макет чисел для форматированных чисел (активируется с помощью Qt::ImhFormattedNumbersOnly)
• digits Макет только цифр (активируется с помощью Qt::ImhDigitsOnly)
• dialpad Макет кнопок набора номера для ввода номеров телефонов (активируется с помощью Qt::ImhDialableCharactersOnly)
• handwriting Макет рукописного ввода для распознавания рукописного ввода (активируется из основного макета)

Добавление новых макетов клавиатуры

Элемент макета клавиатуры должен быть основан на типе QML KeyboardLayout. Этот тип определяет корневой элемент макета. Корневой элемент имеет следующие необязательные свойства, которые можно установить при необходимости:

Новые строки в макете клавиатуры добавляются с помощью типа KeyboardRow. KeyboardRow также может указать значение по умолчанию для весов клавиш для своих дочерних элементов. В противном случае, вес клавиши наследуется от родительского элемента.

Новые клавиши добавляются в строку клавиатуры с помощью типа Key или одного из специализированных типов клавиш. Ниже приведён список всех типов клавиш:

• Клавиша
• Клавиша Backspace
• Клавиша смены языка
• Клавиша Enter
• Заполнитель
• Клавиша скрытия клавиатуры
• Цифровая клавиша
• Клавиша Shift
• Клавиша пробела
• Клавиша режима символов
• Клавиша Flick
• Клавиша режима рукописного ввода
• Клавиша рукописного ввода

Например, чтобы добавить обычную клавишу, которая отправляет событие клавиши методу ввода:

import QtQuick 2.0
import QtQuick.Layouts 1.0
import QtQuick.VirtualKeyboard 2.1

// file: layouts/en_GB/main.qml

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

Расчёт размера клавиш

Макеты клавиатуры масштабируемы, что означает, что для каких-либо элементов макета нельзя устанавливать фиксированные размеры. Вместо этого, ширина клавиш вычисляется из веса клавиш по отношению друг к другу, а высота — путём равного распределения пространства между строками клавиатуры.

В приведённом примере размер клавиши наследуется от родительских элементов в таком порядке:

Клавиша > KeyboardRow > KeyboardLayout

Эффективное значение веса клавиши будет 160. Для примера, добавим ещё одну клавишу, которая указывает на пользовательский вес клавиши:

import QtQuick 2.0
import QtQuick.Layouts 1.0
import QtQuick.VirtualKeyboard 2.1

// file: layouts/en_GB/main.qml

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

Теперь общий вес клавиш строки равен 160 + 200 = 360. При активации макета клавиатуры ширина отдельной клавиши рассчитывается следующим образом:

ширина клавиши в пикселях = вес клавиши / СУММА(весов клавиш в строке) * ширина строки в пикселях

Это означает, что клавиатура может быть масштабирована до любого размера, а относительные размеры клавиш останутся неизменными.

Альтернативные клавиши

Ключ может указать свойство alternativeKeys, что приводит к появлению всплывающего окна, в котором перечислены альтернативные клавиши, когда пользователь удерживает нажатой клавишу. alternativeKeys может указывать строку или список строк. Если alternativeKeys — это строка, пользователь может выбрать символы в этой строке.

Стили и макеты

Макеты клавиатуры не могут указывать какие-либо визуальные элементы. Вместо этого макет визуализируется стилем клавиатуры. С другой стороны, стиль клавиатуры не может влиять на размер макета клавиатуры.

Макеты клавиатур с несколькими страницами клавиш

Некоторые макеты клавиатур, такие как макеты символов, могут содержать больше клавиш, чем удобно отобразить на одном макете клавиатуры. Решение — встраивание нескольких макетов клавиатур в один контекст с использованием KeyboardLayoutLoader.

Когда KeyboardLayoutLoader используется как корневой элемент макета клавиатуры, фактические макеты клавиатуры обернуты внутри элементов Component. Макет клавиатуры активируется путём присвоения идентификатора активного компонента свойству sourceComponent.

Например:

import QtQuick 2.0
import QtQuick.Layouts 1.0
import QtQuick.VirtualKeyboard 2.1

// file: layouts/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
                }
            }
        }
    }
}

Макет клавиатуры для рукописного ввода

Каждый язык, поддерживающий распознавание рукописного ввода, должен предоставить специальный макет клавиатуры под именем handwriting.qml.

Этот тип макета клавиатуры должен удовлетворять следующим требованиям:

• содержит TraceInputKey в макете клавиатуры
• предоставляет экземпляр HandwritingInputMethod в качестве метода ввода.

Макет для рукописного ввода также может включать клавишу смены языка. Для этой цели важно использовать атрибут customLayoutsOnly, который будет отфильтровывать языки, не использующие рукописный ввод.

Как основной, так и макет для рукописного ввода должны содержать клавишу для активации и деактивации режима рукописного ввода. Это можно сделать, добавив HandwritingModeKey в макет.

Добавление пользовательских макетов

Система макетов виртуальной клавиатуры поддерживает встроенные макеты, а также пользовательские макеты. Встроенные макеты встроены как Qt Ресурсы в двоичный файл плагина. Пользовательские макеты расположены в файловой системе, поэтому их можно установить без перекомпиляции самой виртуальной клавиатуры, или они могут быть расположены в файле ресурсов.

Выбор макетов во время выполнения зависит от переменной среды QT_VIRTUALKEYBOARD_LAYOUT_PATH.

В случае, если переменная среды не установлена или содержит недопустимый каталог, виртуальная клавиатура возвращается к стандартным встроенным макетам.

Чтобы предотвратить включение встроенных макетов в плагин виртуальной клавиатуры при использовании пользовательских макетов, добавьте disable-layouts к переменной CONFIG qmake. Для получения дополнительной информации, обратитесь к дополнительным параметрам конфигурации qmake.

Стили клавиатуры

Система стилей виртуальной клавиатуры поддерживает встроенные стили, а также пользовательские стили. Встроенные стили встроены как Qt Ресурсы в двоичный файл плагина, а пользовательские стили расположены в файловой системе и могут быть установлены без перекомпиляции самой виртуальной клавиатуры.

Выбор стиля во время выполнения зависит от переменной окружения QT_VIRTUALKEYBOARD_STYLE, которая может быть установлена в имя встроенного стиля, например, "retro", или в любое из установленных пользовательских стилей в каталоге Styles:

$$[QT_INSTALL_QML]/QtQuick/VirtualKeyboard/Styles

В случае, если переменная среды не установлена или содержит недопустимое имя стиля, виртуальная клавиатура возвращается к стандартному встроенному стилю.

Добавление пользовательских стилей

Процесс создания нового стиля начинается с создания новой подпапки для стиля в пути импорта QML по URL-структуре QtQuick/VirtualKeyboard/Styles/. Смотрите Путь импорта QML для получения информации о путях импорта QML. Имя каталога не может содержать пробелы или специальные символы, кроме подчеркивания. Также имя каталога не может совпадать с именем одного из встроенных стилей, которые в настоящее время включают "default" и "retro".

Хорошей отправной точкой для создания нового стиля является использование существующего встроенного стиля в качестве шаблона и редактирование его. Вы можете найти встроенные стили в каталоге исходных кодов виртуальной клавиатуры src/virtualkeyboard/content/styles. Скопируйте одну из папок, содержащих встроенный стиль, в каталог Styles и переименуйте её в "test". Структура каталогов должна быть такой:

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

Файл конфигурации QRC, который в данном случае не нужен, можно безопасно удалить.

Далее, откройте style.qml в вашем любимом редакторе и установите свойство resourcePrefix в пустую строку. Префикс ресурсов не нужен, так как ресурсы находятся в той же папке, что и файл style.qml.

Также, чтобы сделать более очевидным, что пользовательский стиль действительно загружается и используется, установите фон клавиатуры в другой цвет:

keyboardBackground: Rectangle {
    color: "gray"
}

Последний шаг — запуск примерного приложения с вашим пользовательским стилем:

QT_VIRTUALKEYBOARD_STYLE=test virtualkeyboard

Использование Qt Virtual Keyboard с QQuickWidget

При использовании Qt Virtual Keyboard в QQuickWidget на сенсорном устройстве необходимо установить атрибут Qt::WA_AcceptTouchEvents с помощью QWidget::setAttribute(). Без этого атрибута события от сенсорного устройства будут преобразованы в синтезированные события мыши.