Revision control
++ // Copyright (C) 2016 The Qt Company Ltd.
++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
++ // Qt-Security score:significant reason:default
++
++ #include "qquickvirtualkeyboardsettings_p.h"
++ #include <QtVirtualKeyboard/private/settings_p.h>
++ #include <QtVirtualKeyboard/private/virtualkeyboarddebug_p.h>
++ #include <QQmlEngine>
++ #include <QQmlContext>
++ #include <QFileInfo>
++ #include <QDir>
++ #include <QRegularExpression>
++ #include <QtCore/private/qobject_p.h>
++
++ QT_BEGIN_NAMESPACE
++ namespace QtVirtualKeyboard {
++
++ class QQuickVirtualKeyboardSettingsPrivate : public QObjectPrivate
++ {
++ Q_DECLARE_PUBLIC(QQuickVirtualKeyboardSettings)
++ public:
++ QQuickVirtualKeyboardSettingsPrivate(QQuickVirtualKeyboardSettings *q_ptr, QQmlEngine *engine) :
++ QObjectPrivate(),
++ q_ptr(q_ptr),
++ engine(engine)
++ {}
++
++ QString buildStylePath(const QString &path, const QString &name) const
++ {
++ QString importPath(path + name + QLatin1String("/style.qml"));
++ if (!importPath.startsWith(QLatin1String("qrc:"))) {
++ QUrl url = QUrl::fromLocalFile(importPath);
++ importPath = url.toString();
++ }
++ return importPath;
++ }
++
++ QString buildStyleFilePath(const QString &path, const QString &name) const
++ {
++ QString filePath(path);
++ if (filePath.startsWith(QLatin1String("qrc:")))
++ filePath.remove(0, 3);
++ return filePath + name + QLatin1String("/style.qml");
++ }
++
++ QStringList qmlImportPathList() const
++ {
++ return engine ? engine->importPathList() : QStringList();
++ }
++
++ QString stylePath(const QString &name) const
++ {
++ if (name.isEmpty())
++ return QString();
++
++ QStringList stylePathList;
++ stylePathList << QLatin1String("qrc:/qt-project.org/imports/QtQuick/VirtualKeyboard/Styles/Builtin/");
++ const QStringList importPathList = qmlImportPathList();
++ // Add QML import path (Note: the QML base dir is usually the last entry in the list)
++ for (int i = importPathList.size() - 1; i >= 0; --i) {
++ const QString stylesPath = importPathList.at(i)
++ + QLatin1String("/QtQuick/VirtualKeyboard/Styles/");
++ stylePathList += stylesPath;
++ }
++
++ // Path for backwards compatibility
++ stylePathList << QLatin1String("qrc:/QtQuick/VirtualKeyboard/content/styles/");
++
++ for (const QString &stylePath : std::as_const(stylePathList)) {
++ QString filePath = buildStyleFilePath(stylePath, name);
++ bool pathExist = false;
++ pathExist = QFileInfo::exists(filePath);
++ if (pathExist)
++ return buildStylePath(stylePath, name);
++ }
++ return QString();
++ }
++
++ QQuickVirtualKeyboardSettings *q_ptr;
++ QQmlEngine *engine;
++ QQuickWordCandidateListSettings wordCandidateListSettings;
++ };
++
++ /*!
++ \qmlmodule QtQuick.VirtualKeyboard.Settings
++ \title Qt Quick Virtual Keyboard Settings QML Types
++ \ingroup qmlmodules
++
++ \brief Provides settings for Qt Virtual Keyboard.
++
++ The QML types can be imported into your application using the following
++ import statements in your .qml file:
++
++ \qml
++ import QtQuick.VirtualKeyboard.Settings
++ \endqml
++ */
++
++ /*!
++ \qmltype VirtualKeyboardSettings
++ \inqmlmodule QtQuick.VirtualKeyboard.Settings
++ \ingroup qtvirtualkeyboard-settings-qml
++ \ingroup qmlclass
++ \since QtQuick.VirtualKeyboard 1.2
++ \brief Provides settings for virtual keyboard.
++
++ This type provides a VirtualKeyboardSettings singleton instance,
++ which can be used to configure the virtual keyboard settings.
++
++ Please note that the settings have only effect in the current
++ application's lifetime, that is, configuration changes are not
++ permanent.
++
++ For example, to change the keyboard style in application:
++
++ \code
++ Component.onCompleted: VirtualKeyboardSettings.styleName = "retro"
++ \endcode
++ */
++
++ /*!
++ \class QtVirtualKeyboard::VirtualKeyboardSettings
++ \internal
++ */
++
++ /*!
++ \internal
++ */
++ QQuickVirtualKeyboardSettings::QQuickVirtualKeyboardSettings(QQmlEngine *engine, QObject *parent) :
++ QObject(*new QQuickVirtualKeyboardSettingsPrivate(this, engine), parent)
++ {
++ Q_D(QQuickVirtualKeyboardSettings);
++ Settings *settings = Settings::instance();
++ if (settings->styleName().isEmpty())
++ resetStyle();
++ connect(settings, SIGNAL(styleChanged()), SIGNAL(styleChanged()));
++ connect(settings, SIGNAL(requestResetStyle()), SLOT(resetStyle()));
++ connect(settings, SIGNAL(styleNameChanged()), SIGNAL(styleNameChanged()));
++ connect(settings, SIGNAL(localeChanged()), SIGNAL(localeChanged()));
++ connect(settings, SIGNAL(availableLocalesChanged()), SIGNAL(availableLocalesChanged()));
++ connect(settings, SIGNAL(activeLocalesChanged()), SIGNAL(activeLocalesChanged()));
++ connect(settings, SIGNAL(layoutPathChanged()), SIGNAL(layoutPathChanged()));
++ connect(settings, SIGNAL(wclAutoHideDelayChanged()), &d->wordCandidateListSettings, SIGNAL(autoHideDelayChanged()));
++ connect(settings, SIGNAL(wclAlwaysVisibleChanged()), &d->wordCandidateListSettings, SIGNAL(alwaysVisibleChanged()));
++ connect(settings, SIGNAL(wclAutoCommitWordChanged()), &d->wordCandidateListSettings, SIGNAL(autoCommitWordChanged()));
++ connect(settings, SIGNAL(fullScreenModeChanged()), SIGNAL(fullScreenModeChanged()));
++ connect(settings, SIGNAL(userDataPathChanged()), SIGNAL(userDataPathChanged()));
++ settings->connect(this, SIGNAL(userDataReset()), SIGNAL(userDataReset()));
++ connect(settings, SIGNAL(hwrTimeoutForAlphabeticChanged()), SIGNAL(hwrTimeoutForAlphabeticChanged()));
++ connect(settings, SIGNAL(hwrTimeoutForCjkChanged()), SIGNAL(hwrTimeoutForCjkChanged()));
++ connect(settings, SIGNAL(inputMethodHintsChanged()), SIGNAL(inputMethodHintsChanged()));
++ connect(settings, SIGNAL(handwritingModeDisabledChanged()), SIGNAL(handwritingModeDisabledChanged()));
++ connect(settings, SIGNAL(defaultInputMethodDisabledChanged()), SIGNAL(defaultInputMethodDisabledChanged()));
++ connect(settings, SIGNAL(defaultDictionaryDisabledChanged()), SIGNAL(defaultDictionaryDisabledChanged()));
++ connect(settings, SIGNAL(visibleFunctionKeysChanged()), SIGNAL(visibleFunctionKeysChanged()));
++ connect(settings, &Settings::keySoundVolumeChanged, this, &QQuickVirtualKeyboardSettings::keySoundVolumeChanged);
++ connect(settings, &Settings::arrowKeyNavigationEnabledChanged, this, &QQuickVirtualKeyboardSettings::arrowKeyNavigationEnabledChanged);
++ connect(settings, &Settings::screenNameChanged, this, &QQuickVirtualKeyboardSettings::screenNameChanged);
++ }
++
++ /*!
++ \internal
++ */
++ QQuickVirtualKeyboardSettings *QQuickVirtualKeyboardSettings::create(QQmlEngine *qmlEngine, QJSEngine *)
++ {
++ return new QQuickVirtualKeyboardSettings(qmlEngine);
++ }
++
++ /*!
++ \internal
++ */
++ QUrl QQuickVirtualKeyboardSettings::style() const
++ {
++ return QUrl{Settings::instance()->style()};
++ }
++
++ /*!
++ \internal
++ */
++ QString QQuickVirtualKeyboardSettings::styleName() const
++ {
++ return Settings::instance()->styleName();
++ }
++
++ /*!
++ \internal
++ */
++ void QQuickVirtualKeyboardSettings::setStyleName(const QString &styleName)
++ {
++ Q_D(QQuickVirtualKeyboardSettings);
++ Settings *settings = Settings::instance();
++ QString style = d->stylePath(styleName);
++ if (style.isEmpty()) {
++ qWarning() << "WARNING: Cannot find style" << styleName << "- fallback:" << settings->styleName();
++ return;
++ }
++ settings->setStyleName(styleName);
++ settings->setStyle(style);
++ }
++
++ /*!
++ \internal
++ */
++ QUrl QQuickVirtualKeyboardSettings::layoutPath() const
++ {
++ return Settings::instance()->layoutPath();
++ }
++
++ /*!
++ \internal
++ */
++ void QQuickVirtualKeyboardSettings::setLayoutPath(const QUrl &layoutPath)
++ {
++ Settings *settings = Settings::instance();
++ QDir layoutDirectory(layoutPath.toLocalFile());
++ if (!layoutDirectory.exists()) {
++ qWarning() << "WARNING: Cannot find layout path" << layoutPath;
++ return;
++ }
++ settings->setLayoutPath(layoutPath);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetLayoutPath()
++ {
++ Settings::instance()->resetLayoutPath();
++ }
++
++ QString QQuickVirtualKeyboardSettings::locale() const
++ {
++ return Settings::instance()->locale();
++ }
++
++ void QQuickVirtualKeyboardSettings::setLocale(const QString &locale)
++ {
++ Settings::instance()->setLocale(locale);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetLocale()
++ {
++ Settings::instance()->resetLocale();
++ }
++
++ QStringList QQuickVirtualKeyboardSettings::availableLocales() const
++ {
++ return Settings::instance()->availableLocales();
++ }
++
++ void QQuickVirtualKeyboardSettings::setActiveLocales(const QStringList &activeLocales)
++ {
++ Settings::instance()->setActiveLocales(activeLocales);
++ }
++
++ QStringList QQuickVirtualKeyboardSettings::activeLocales() const
++ {
++ return Settings::instance()->activeLocales();
++ }
++
++ void QQuickVirtualKeyboardSettings::resetActiveLocales()
++ {
++ return Settings::instance()->resetActiveLocales();
++ }
++
++ QQuickWordCandidateListSettings *QQuickVirtualKeyboardSettings::wordCandidateList() const
++ {
++ Q_D(const QQuickVirtualKeyboardSettings);
++ return const_cast<QQuickWordCandidateListSettings *>(&d->wordCandidateListSettings);
++ }
++
++ bool QQuickVirtualKeyboardSettings::fullScreenMode() const
++ {
++ return Settings::instance()->fullScreenMode();
++ }
++
++ void QQuickVirtualKeyboardSettings::setFullScreenMode(bool fullScreenMode)
++ {
++ return Settings::instance()->setFullScreenMode(fullScreenMode);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetFullScreenMode()
++ {
++ return Settings::instance()->resetFullScreenMode();
++ }
++
++ QString QQuickVirtualKeyboardSettings::userDataPath() const
++ {
++ return Settings::instance()->userDataPath();
++ }
++
++ void QQuickVirtualKeyboardSettings::setUserDataPath(const QString &userDataPath)
++ {
++ return Settings::instance()->setUserDataPath(userDataPath);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetUserDataPath()
++ {
++ return Settings::instance()->resetUserDataPath();
++ }
++
++ int QQuickVirtualKeyboardSettings::hwrTimeoutForAlphabetic() const
++ {
++ return Settings::instance()->hwrTimeoutForAlphabetic();
++ }
++
++ void QQuickVirtualKeyboardSettings::setHwrTimeoutForAlphabetic(int hwrTimeoutForAlphabetic)
++ {
++ return Settings::instance()->setHwrTimeoutForAlphabetic(hwrTimeoutForAlphabetic);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetHwrTimeoutForAlphabetic()
++ {
++ return Settings::instance()->resetHwrTimeoutForAlphabetic();
++ }
++
++ int QQuickVirtualKeyboardSettings::hwrTimeoutForCjk() const
++ {
++ return Settings::instance()->hwrTimeoutForCjk();
++ }
++
++ void QQuickVirtualKeyboardSettings::setHwrTimeoutForCjk(int hwrTimeoutForCjk)
++ {
++ return Settings::instance()->setHwrTimeoutForCjk(hwrTimeoutForCjk);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetHwrTimeoutForCjk()
++ {
++ return Settings::instance()->resetHwrTimeoutForCjk();
++ }
++
++ Qt::InputMethodHints QQuickVirtualKeyboardSettings::inputMethodHints() const
++ {
++ return Settings::instance()->inputMethodHints();
++ }
++
++ void QQuickVirtualKeyboardSettings::setInputMethodHints(const Qt::InputMethodHints &inputMethodHints)
++ {
++ Settings::instance()->setInputMethodHints(inputMethodHints);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetInputMethodHints()
++ {
++ Settings::instance()->resetInputMethodHints();
++ }
++
++ bool QQuickVirtualKeyboardSettings::isHandwritingModeDisabled() const
++ {
++ return Settings::instance()->isHandwritingModeDisabled();
++ }
++
++ void QQuickVirtualKeyboardSettings::setHandwritingModeDisabled(bool handwritingModeDisabled)
++ {
++ Settings::instance()->setHandwritingModeDisabled(handwritingModeDisabled);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetHandwritingModeDisabled()
++ {
++ Settings::instance()->resetHandwritingModeDisabled();
++ }
++
++ bool QQuickVirtualKeyboardSettings::isDefaultInputMethodDisabled() const
++ {
++ return Settings::instance()->isDefaultInputMethodDisabled();
++ }
++
++ void QQuickVirtualKeyboardSettings::setDefaultInputMethodDisabled(bool defaultInputMethodDisabled)
++ {
++ return Settings::instance()->setDefaultInputMethodDisabled(defaultInputMethodDisabled);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetDefaultInputMethodDisabled()
++ {
++ return Settings::instance()->resetDefaultInputMethodDisabled();
++ }
++
++ bool QQuickVirtualKeyboardSettings::isDefaultDictionaryDisabled() const
++ {
++ return Settings::instance()->isDefaultDictionaryDisabled();
++ }
++
++ void QQuickVirtualKeyboardSettings::setDefaultDictionaryDisabled(bool defaultDictionaryDisabled)
++ {
++ return Settings::instance()->setDefaultDictionaryDisabled(defaultDictionaryDisabled);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetDefaultDictionaryDisabled()
++ {
++ return Settings::instance()->resetDefaultDictionaryDisabled();
++ }
++
++ QtVirtualKeyboard::KeyboardFunctionKeys QQuickVirtualKeyboardSettings::visibleFunctionKeys() const
++ {
++ return Settings::instance()->visibleFunctionKeys();
++ }
++
++ void QQuickVirtualKeyboardSettings::setVisibleFunctionKeys(QtVirtualKeyboard::KeyboardFunctionKeys newVisibleFunctionKeys)
++ {
++ Settings::instance()->setVisibleFunctionKeys(newVisibleFunctionKeys);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetVisibleFunctionKeys()
++ {
++ return Settings::instance()->resetVisibleFunctionKeys();
++ }
++
++ bool QQuickVirtualKeyboardSettings::closeOnReturn() const
++ {
++ return Settings::instance()->closeOnReturn();
++ }
++
++ void QQuickVirtualKeyboardSettings::setCloseOnReturn(bool closeOnReturn)
++ {
++ Settings::instance()->setCloseOnReturn(closeOnReturn);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetCloseOnReturn()
++ {
++ Settings::instance()->resetCloseOnReturn();
++ }
++
++ qreal QQuickVirtualKeyboardSettings::keySoundVolume() const
++ {
++ return Settings::instance()->keySoundVolume();
++ }
++
++ void QQuickVirtualKeyboardSettings::setKeySoundVolume(qreal volume)
++ {
++ Settings::instance()->setKeySoundVolume(volume);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetKeySoundVolume()
++ {
++ Settings::instance()->resetKeySoundVolume();
++ }
++
++ bool QQuickVirtualKeyboardSettings::arrowKeyNavigationEnabled() const
++ {
++ return Settings::instance()->arrowKeyNavigationEnabled();
++ }
++
++ void QQuickVirtualKeyboardSettings::setArrowKeyNavigationEnabled(bool arrowKeyNavigationEnabled)
++ {
++ Settings::instance()->setArrowKeyNavigationEnabled(arrowKeyNavigationEnabled);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetArrowKeyNavigationEnabled()
++ {
++ Settings::instance()->resetArrowKeyNavigationEnabled();
++ }
++
++ QString QQuickVirtualKeyboardSettings::screenName() const
++ {
++ return Settings::instance()->screenName();
++ }
++
++ void QQuickVirtualKeyboardSettings::setScreenName(const QString &screenName)
++ {
++ Settings::instance()->setScreenName(screenName);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetScreenName()
++ {
++ Settings::instance()->resetScreenName();
++ }
++
++ /*!
++ \internal
++ */
++ qreal QQuickVirtualKeyboardSettings::convertVolume(qreal volume) const
++ {
++ // Equivalent to QAudio::convertVolume(volume / 100, QtAudio::LogarithmicVolumeScale, QtAudio::LinearVolumeScale)
++ constexpr qreal LOG100 = 4.60517018599;
++ return 1 - std::exp(-(volume / 100) * LOG100);
++ }
++
++ void QQuickVirtualKeyboardSettings::resetStyle()
++ {
++ Q_D(QQuickVirtualKeyboardSettings);
++ Settings *settings = Settings::instance();
++ QString styleName = QLatin1String(QT_VIRTUALKEYBOARD_DEFAULT_STYLE);
++ QString style = d->stylePath(styleName);
++ QString customStyleName = QString::fromLatin1(qgetenv("QT_VIRTUALKEYBOARD_STYLE"));
++ if (!customStyleName.isEmpty()) {
++ bool found = false;
++ static const QRegularExpression styleNameValidator(QLatin1String("\\A(?:\\w+)\\z"));
++ QRegularExpressionMatch match = styleNameValidator.match(customStyleName);
++ if (match.hasMatch()) {
++ QString customStyle = d->stylePath(customStyleName);
++ if (!customStyle.isEmpty()) {
++ styleName = customStyleName;
++ style = customStyle;
++ found = true;
++ }
++ }
++ if (!found) {
++ qWarning() << "WARNING: Cannot find style" << customStyleName << "- fallback:" << styleName;
++ }
++ }
++ if (!style.isEmpty()) {
++ settings->setStyleName(styleName);
++ settings->setStyle(style);
++ }
++ }
++
++ /*!
++ \qmlproperty string VirtualKeyboardSettings::style
++ \internal
++ */
++
++ /*!
++ \qmlproperty string VirtualKeyboardSettings::styleName
++
++ This property provides the current style. Application can change
++ the keyboard style by setting the styleName to different value.
++
++ The system wide keyboard style can be affected by setting
++ the QT_VIRTUALKEYBOARD_STYLE environment variable.
++ */
++
++ /*!
++ \qmlproperty string VirtualKeyboardSettings::locale
++ \since QtQuick.VirtualKeyboard.Settings 2.0
++
++ This property provides the default locale for the keyboard.
++
++ When the locale is not specified, the default system locale is used instead.
++
++ If the keyboard locale is different from the new default locale, keyboard
++ language is changed immediately to reflect the new locale. If the locale setting
++ is incorrect, or it is not in the list of supported locales, it is ignored and
++ the default setting is used instead.
++
++ A locale is supported if it is included in the list of availableLocales.
++ */
++
++ /*!
++ \qmlproperty list<string> VirtualKeyboardSettings::availableLocales
++ \since QtQuick.VirtualKeyboard.Settings 2.0
++ \readonly
++
++ This property contains a list of languages supported by the virtual keyboard.
++
++ This list is read-only and depends on the build-time configuration of the
++ virtual keyboard.
++ */
++
++ /*!
++ \qmlproperty list<string> VirtualKeyboardSettings::activeLocales
++ \since QtQuick.VirtualKeyboard.Settings 2.0
++
++ This property contains a list of activated languages of the virtual keyboard.
++
++ The list of active languages is a subset of the available languages, and can be
++ used to limit the list of available languages in the application lifetime.
++
++ The list of languages will be shown based on the specified ordering.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::fullScreenMode
++ \since QtQuick.VirtualKeyboard.Settings 2.2
++
++ This property enables the fullscreen mode for the virtual keyboard.
++
++ In fullscreen mode, the virtual keyboard replicates the contents of the
++ focused input field to the fullscreen input field located at the top of the
++ keyboard.
++
++ \image shadow-input.png {Keyboard in fullscreen mode with the focused
++ field contents replicated in a bar above the keys}
++
++ For example, to activate the fullscreen mode when the screen aspect ratio
++ is greater than 16:9:
++
++ \code
++ Binding {
++ target: VirtualKeyboardSettings
++ property: "fullScreenMode"
++ value: (Screen.width / Screen.height) > (16.0 / 9.0)
++ }
++ \endcode
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::userDataPath
++ \since 6.1
++
++ This property sets the user data path for the virtual keyboard and its plugins.
++
++ By default, the user data path is set to \l {QStandardPaths::GenericConfigLocation}{GenericConfigLocation} + "/qtvirtualkeyboard".
++ */
++
++ /*!
++ \qmlsignal VirtualKeyboardSettings::userDataReset()
++
++ The application triggers this signal prior to the user's data being reset to
++ indicate to the virtual keyboard that all files must be closed
++ in the user data directory.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::hwrTimeoutForAlphabetic
++ \since 6.1
++
++ This property sets the handwriting recognition timeout for alphabetical languages.
++
++ By default, the timeout is 500 millliseconds.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::hwrTimeoutForCjk
++ \since 6.1
++
++ This property sets the handwriting recognition timeout for Chinese / Japanese / Korean languages.
++
++ By default, the timeout is 500 millliseconds.
++ */
++
++ /*!
++ \qmlproperty int VirtualKeyboardSettings::inputMethodHints
++ \since 6.1
++
++ This property allows to set persistent input method hints.
++
++ The value of this property is combined with the input method
++ hints from the input control. For example, to disable predictive
++ text input, this property can be set to \c Qt::ImhNoPredictiveText.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::handwritingModeDisabled
++ \since 6.1
++
++ This property allows to disable handwriting input mode, if it is
++ otherwise available in the system.
++
++ When this property is set to \c true, the handwriting button is hidden
++ from the keyboard layout and the user cannot switch to handwriting
++ input mode.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::defaultInputMethodDisabled
++ \since 6.1
++
++ This property disables the default input method. The purpose of this setting is to be able to
++ override the default input method with the plain input method, disabling its functionality.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::defaultDictionaryDisabled
++ \since 6.1
++
++ This property disables the default dictionary. The purpose of this setting is to be able to
++ use a custom dictionary only instead of the standard dictionary.
++ */
++
++ /*!
++ \qmlproperty enumeration VirtualKeyboardSettings::visibleFunctionKeys
++ \since 6.6
++
++ This setting adjusts the visibility of specific function keys in the keyboard layout, allowing
++ them to be either displayed or hidden. When a function key is not visible, its functionality
++ remains accessible through the gear menu.
++
++ The value can be combination of the following flags:
++
++ \list
++ \li \c QtVirtualKeyboard.KeyboardFunctionKeys.None All function keys are hidden
++ \li \c QtVirtualKeyboard.KeyboardFunctionKeys.Hide Hide function key is visible
++ \li \c QtVirtualKeyboard.KeyboardFunctionKeys.Language Language function key is visible
++ \li \c QtVirtualKeyboard.KeyboardFunctionKeys.All All function keys are visible
++ \endlist
++
++ The default is \c QtVirtualKeyboard.KeyboardFunctionKeys.All.
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::closeOnReturn
++ \since 6.8
++
++ This property enables hiding of virtual keyboard.
++
++ When this property is set to \c true, the virtual keyboard is hidden when \l Qt::Key_Enter
++ or \l Qt::Key_Return key released. The default is \c false.
++ */
++
++ /*!
++ \qmlproperty real VirtualKeyboardSettings::keySoundVolume
++ \since 6.9
++
++ This property holds the keysound's volume level. The level is in the range [0,1]
++ */
++
++ /*!
++ \qmlproperty bool VirtualKeyboardSettings::arrowKeyNavigationEnabled
++ \since 6.11
++
++ Use this property to enable or disable arrow key navigation.
++ */
++
++ /*!
++ \qmlproperty string VirtualKeyboardSettings::screenName
++ \since 6.13
++
++ This property allows overriding the screen on which the desktop virtual
++ keyboard is shown, in setups with multiple screens. The value must match
++ the \l {QScreen::}{name} of one of \l {QGuiApplication::}{screens}.
++
++ The format of the name is platform specific. Use \c Qt.application.screens
++ to discover the names available on the current system. The names are not
++ guaranteed to be unique; if several screens share the same name, the first
++ matching screen is used.
++
++ When empty (the default), the keyboard is shown on the screen of the
++ window that has focus.
++
++ If the given screen name does not match any connected screen, this
++ setting is ignored and the keyboard falls back to the default behavior.
++
++ This property has no effect outside of the desktop input panel.
++ */
++
++ /*!
++ \since QtQuick.VirtualKeyboard.Settings 2.2
++ \qmlproperty int VirtualKeyboardSettings::wordCandidateList.autoHideDelay
++ \qmlproperty bool VirtualKeyboardSettings::wordCandidateList.alwaysVisible
++
++ \table
++ \header
++ \li Name
++ \li Description
++ \row
++ \li autoHideDelay
++ \li This property defines the delay, in milliseconds, after which the
++ word candidate list is hidden if empty.
++
++ If the value is \c 0, the list is immediately hidden when cleared.
++
++ If the value is \c -1, the list is visible until input focus
++ changes, or the input panel is hidden.
++
++ The default value is \c 5000 milliseconds.
++ \row
++ \li alwaysVisible
++ \li This property defines whether the word candidate list should always
++ remain visible.
++
++ The default value is \c false.
++ \row
++ \li autoCommitWord
++ \li This property enables the automatic commit feature that is activated
++ when the word candidate list is narrowed down to a single candidate.
++
++ The automatic commit feature takes effect when the word candidate
++ list initially contains multiple words and is reduced to single word
++ after additional input. This word will be selected and committed
++ automatically without user interaction.
++
++ This property is set to \c false by default.
++ \endtable
++ */
++
++ QQuickWordCandidateListSettings::QQuickWordCandidateListSettings(QObject *parent) :
++ QObject(parent)
++ {
++ }
++
++ int QQuickWordCandidateListSettings::autoHideDelay() const
++ {
++ return Settings::instance()->wclAutoHideDelay();
++ }
++
++ void QQuickWordCandidateListSettings::setAutoHideDelay(int autoHideDelay)
++ {
++ Settings::instance()->setWclAutoHideDelay(autoHideDelay);
++ }
++
++ void QQuickWordCandidateListSettings::resetAutoHideDelay()
++ {
++ Settings::instance()->resetWclAutoHideDelay();
++ }
++
++ bool QQuickWordCandidateListSettings::alwaysVisible() const
++ {
++ return Settings::instance()->wclAlwaysVisible();
++ }
++
++ void QQuickWordCandidateListSettings::setAlwaysVisible(bool alwaysVisible)
++ {
++ Settings::instance()->setWclAlwaysVisible(alwaysVisible);
++ }
++
++ void QQuickWordCandidateListSettings::resetAlwaysVisible()
++ {
++ Settings::instance()->resetWclAlwaysVisible();
++ }
++
++ bool QQuickWordCandidateListSettings::autoCommitWord() const
++ {
++ return Settings::instance()->wclAutoCommitWord();
++ }
++
++ void QQuickWordCandidateListSettings::setAutoCommitWord(bool autoCommitWord)
++ {
++ Settings::instance()->setWclAutoCommitWord(autoCommitWord);
++ }
++
++ void QQuickWordCandidateListSettings::resetAutoCommitWord()
++ {
++ Settings::instance()->resetWclAutoCommitWord();
++ }
++
++ } // namespace QtVirtualKeyboard
++ QT_END_NAMESPACE