1// Copyright (C) 2016 The Qt Company Ltd.
2// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
3
4#include "qquickvirtualkeyboardsettings_p.h"
5#include <QtVirtualKeyboard/private/settings_p.h>
6#include <QtVirtualKeyboard/private/virtualkeyboarddebug_p.h>
7#include <QQmlEngine>
8#include <QQmlContext>
9#include <QFileInfo>
10#include <QDir>
11#include <QRegularExpression>
12#include <QtCore/private/qobject_p.h>
13
14QT_BEGIN_NAMESPACE
15namespace QtVirtualKeyboard {
16
17class QQuickVirtualKeyboardSettingsPrivate : public QObjectPrivate
18{
19 Q_DECLARE_PUBLIC(QQuickVirtualKeyboardSettings)
20public:
21 QQuickVirtualKeyboardSettingsPrivate(QQuickVirtualKeyboardSettings *q_ptr, QQmlEngine *engine) :
22 QObjectPrivate(),
23 q_ptr(q_ptr),
24 engine(engine)
25 {}
26
27 QString buildStylePath(const QString &path, const QString &name) const
28 {
29 QString importPath(path + name + QLatin1String("/style.qml"));
30 if (!importPath.startsWith(s: QLatin1String("qrc:"))) {
31 QUrl url = QUrl::fromLocalFile(localfile: importPath);
32 importPath = url.toString();
33 }
34 return importPath;
35 }
36
37 QString buildStyleFilePath(const QString &path, const QString &name) const
38 {
39 QString filePath(path);
40 if (filePath.startsWith(s: QLatin1String("qrc:")))
41 filePath.remove(i: 0, len: 3);
42 return filePath + name + QLatin1String("/style.qml");
43 }
44
45 QStringList qmlImportPathList() const
46 {
47 return engine ? engine->importPathList() : QStringList();
48 }
49
50 QString stylePath(const QString &name) const
51 {
52 if (name.isEmpty())
53 return QString();
54
55 QStringList stylePathList;
56 stylePathList << QLatin1String("qrc:/qt-project.org/imports/QtQuick/VirtualKeyboard/Styles/Builtin/");
57 const QStringList importPathList = qmlImportPathList();
58 // Add QML import path (Note: the QML base dir is usually the last entry in the list)
59 for (int i = importPathList.size() - 1; i >= 0; --i) {
60 const QString stylesPath = importPathList.at(i)
61 + QLatin1String("/QtQuick/VirtualKeyboard/Styles/");
62 stylePathList += stylesPath;
63 }
64
65 // Path for backwards compatibility
66 stylePathList << QLatin1String("qrc:/QtQuick/VirtualKeyboard/content/styles/");
67
68 for (const QString &stylePath : std::as_const(t&: stylePathList)) {
69 QString filePath = buildStyleFilePath(path: stylePath, name);
70 bool pathExist = false;
71 pathExist = QFileInfo::exists(file: filePath);
72 if (pathExist)
73 return buildStylePath(path: stylePath, name);
74 }
75 return QString();
76 }
77
78 QQuickVirtualKeyboardSettings *q_ptr;
79 QQmlEngine *engine;
80 QQuickWordCandidateListSettings wordCandidateListSettings;
81};
82
83/*!
84 \qmlmodule QtQuick.VirtualKeyboard.Settings
85 \title Qt Quick Virtual Keyboard Settings QML Types
86 \ingroup qmlmodules
87
88 \brief Provides settings for Qt Virtual Keyboard.
89
90 The QML types can be imported into your application using the following
91 import statements in your .qml file:
92
93 \qml
94 import QtQuick.VirtualKeyboard.Settings
95 \endqml
96*/
97
98/*!
99 \qmltype VirtualKeyboardSettings
100 \inqmlmodule QtQuick.VirtualKeyboard.Settings
101 \ingroup qtvirtualkeyboard-settings-qml
102 \since QtQuick.VirtualKeyboard 1.2
103 \brief Provides settings for virtual keyboard.
104
105 This type provides a VirtualKeyboardSettings singleton instance,
106 which can be used to configure the virtual keyboard settings.
107
108 Please note that the settings have only effect in the current
109 application's lifetime, that is, configuration changes are not
110 permanent.
111
112 For example, to change the keyboard style in application:
113
114 \code
115 Component.onCompleted: VirtualKeyboardSettings.styleName = "retro"
116 \endcode
117*/
118
119/*!
120 \class QtVirtualKeyboard::VirtualKeyboardSettings
121 \internal
122*/
123
124/*!
125 \internal
126*/
127QQuickVirtualKeyboardSettings::QQuickVirtualKeyboardSettings(QQmlEngine *engine, QObject *parent) :
128 QObject(*new QQuickVirtualKeyboardSettingsPrivate(this, engine), parent)
129{
130 Q_D(QQuickVirtualKeyboardSettings);
131 Settings *settings = Settings::instance();
132 if (settings->styleName().isEmpty())
133 resetStyle();
134 if (settings->layoutPath().isEmpty())
135 resetLayoutPath();
136 connect(asender: settings, SIGNAL(styleChanged()), SIGNAL(styleChanged()));
137 connect(asender: settings, SIGNAL(styleNameChanged()), SIGNAL(styleNameChanged()));
138 connect(asender: settings, SIGNAL(localeChanged()), SIGNAL(localeChanged()));
139 connect(asender: settings, SIGNAL(availableLocalesChanged()), SIGNAL(availableLocalesChanged()));
140 connect(asender: settings, SIGNAL(activeLocalesChanged()), SIGNAL(activeLocalesChanged()));
141 connect(asender: settings, SIGNAL(layoutPathChanged()), SIGNAL(layoutPathChanged()));
142 connect(sender: settings, SIGNAL(wclAutoHideDelayChanged()), receiver: &d->wordCandidateListSettings, SIGNAL(autoHideDelayChanged()));
143 connect(sender: settings, SIGNAL(wclAlwaysVisibleChanged()), receiver: &d->wordCandidateListSettings, SIGNAL(alwaysVisibleChanged()));
144 connect(sender: settings, SIGNAL(wclAutoCommitWordChanged()), receiver: &d->wordCandidateListSettings, SIGNAL(autoCommitWordChanged()));
145 connect(asender: settings, SIGNAL(fullScreenModeChanged()), SIGNAL(fullScreenModeChanged()));
146 connect(asender: settings, SIGNAL(userDataPathChanged()), SIGNAL(userDataPathChanged()));
147 settings->connect(asender: this, SIGNAL(userDataReset()), SIGNAL(userDataReset()));
148 connect(asender: settings, SIGNAL(hwrTimeoutForAlphabeticChanged()), SIGNAL(hwrTimeoutForAlphabeticChanged()));
149 connect(asender: settings, SIGNAL(hwrTimeoutForCjkChanged()), SIGNAL(hwrTimeoutForCjkChanged()));
150 connect(asender: settings, SIGNAL(inputMethodHintsChanged()), SIGNAL(inputMethodHintsChanged()));
151 connect(asender: settings, SIGNAL(handwritingModeDisabledChanged()), SIGNAL(handwritingModeDisabledChanged()));
152 connect(asender: settings, SIGNAL(defaultInputMethodDisabledChanged()), SIGNAL(defaultInputMethodDisabledChanged()));
153 connect(asender: settings, SIGNAL(defaultDictionaryDisabledChanged()), SIGNAL(defaultDictionaryDisabledChanged()));
154 connect(asender: settings, SIGNAL(visibleFunctionKeysChanged()), SIGNAL(visibleFunctionKeysChanged()));
155}
156
157/*!
158 \internal
159 */
160QQuickVirtualKeyboardSettings *QQuickVirtualKeyboardSettings::create(QQmlEngine *qmlEngine, QJSEngine *)
161{
162 return new QQuickVirtualKeyboardSettings(qmlEngine);
163}
164
165/*!
166 \internal
167*/
168QString QQuickVirtualKeyboardSettings::style() const
169{
170 return Settings::instance()->style();
171}
172
173/*!
174 \internal
175*/
176QString QQuickVirtualKeyboardSettings::styleName() const
177{
178 return Settings::instance()->styleName();
179}
180
181/*!
182 \internal
183*/
184void QQuickVirtualKeyboardSettings::setStyleName(const QString &styleName)
185{
186 Q_D(QQuickVirtualKeyboardSettings);
187 Settings *settings = Settings::instance();
188 QString style = d->stylePath(name: styleName);
189 if (style.isEmpty()) {
190 qWarning() << "WARNING: Cannot find style" << styleName << "- fallback:" << settings->styleName();
191 return;
192 }
193 settings->setStyleName(styleName);
194 settings->setStyle(style);
195}
196
197/*!
198 \internal
199*/
200QUrl QQuickVirtualKeyboardSettings::layoutPath() const
201{
202 return Settings::instance()->layoutPath();
203}
204
205/*!
206 \internal
207*/
208void QQuickVirtualKeyboardSettings::setLayoutPath(const QUrl &layoutPath)
209{
210 Settings *settings = Settings::instance();
211 QDir layoutDirectory(layoutPath.toLocalFile());
212 if (!layoutDirectory.exists()) {
213 qWarning() << "WARNING: Cannot find layout path" << layoutPath;
214 return;
215 }
216 settings->setLayoutPath(layoutPath);
217}
218
219void QQuickVirtualKeyboardSettings::resetLayoutPath()
220{
221 Settings *settings = Settings::instance();
222 QUrl layoutPath(QLatin1String(QT_VIRTUALKEYBOARD_DEFAULT_LAYOUTS_DIR));
223 const QString customLayoutPath(QDir::fromNativeSeparators(pathName: qEnvironmentVariable(varName: "QT_VIRTUALKEYBOARD_LAYOUT_PATH")));
224 if (!customLayoutPath.isEmpty()) {
225 bool found = false;
226 QDir customLayoutDirectory(customLayoutPath);
227 if (customLayoutDirectory.exists()) {
228 found = true;
229 layoutPath = QUrl::fromLocalFile(localfile: customLayoutPath);
230 } else {
231 customLayoutDirectory = QDir(QUrl(customLayoutPath).toLocalFile());
232 if (customLayoutDirectory.exists()) {
233 found = true;
234 layoutPath = QUrl(customLayoutPath);
235 }
236 }
237 if (!found) {
238 qWarning() << "WARNING: Cannot assign custom layout path" << customLayoutPath << "- fallback:" << layoutPath;
239 }
240 }
241 settings->setLayoutPath(layoutPath);
242}
243
244QString QQuickVirtualKeyboardSettings::locale() const
245{
246 return Settings::instance()->locale();
247}
248
249void QQuickVirtualKeyboardSettings::setLocale(const QString &locale)
250{
251 Settings::instance()->setLocale(locale);
252}
253
254QStringList QQuickVirtualKeyboardSettings::availableLocales() const
255{
256 return Settings::instance()->availableLocales();
257}
258
259void QQuickVirtualKeyboardSettings::setActiveLocales(const QStringList &activeLocales)
260{
261 Settings::instance()->setActiveLocales(activeLocales);
262}
263
264QStringList QQuickVirtualKeyboardSettings::activeLocales() const
265{
266 return Settings::instance()->activeLocales();
267}
268
269QQuickWordCandidateListSettings *QQuickVirtualKeyboardSettings::wordCandidateList() const
270{
271 Q_D(const QQuickVirtualKeyboardSettings);
272 return const_cast<QQuickWordCandidateListSettings *>(&d->wordCandidateListSettings);
273}
274
275bool QQuickVirtualKeyboardSettings::fullScreenMode() const
276{
277 return Settings::instance()->fullScreenMode();
278}
279
280void QQuickVirtualKeyboardSettings::setFullScreenMode(bool fullScreenMode)
281{
282 return Settings::instance()->setFullScreenMode(fullScreenMode);
283}
284
285QString QQuickVirtualKeyboardSettings::userDataPath() const
286{
287 return Settings::instance()->userDataPath();
288}
289
290void QQuickVirtualKeyboardSettings::setUserDataPath(const QString &userDataPath)
291{
292 return Settings::instance()->setUserDataPath(userDataPath);
293}
294
295int QQuickVirtualKeyboardSettings::hwrTimeoutForAlphabetic() const
296{
297 return Settings::instance()->hwrTimeoutForAlphabetic();
298}
299
300void QQuickVirtualKeyboardSettings::setHwrTimeoutForAlphabetic(int hwrTimeoutForAlphabetic)
301{
302 return Settings::instance()->setHwrTimeoutForAlphabetic(hwrTimeoutForAlphabetic);
303}
304
305int QQuickVirtualKeyboardSettings::hwrTimeoutForCjk() const
306{
307 return Settings::instance()->hwrTimeoutForCjk();
308}
309
310void QQuickVirtualKeyboardSettings::setHwrTimeoutForCjk(int hwrTimeoutForCjk)
311{
312 return Settings::instance()->setHwrTimeoutForCjk(hwrTimeoutForCjk);
313}
314
315Qt::InputMethodHints QQuickVirtualKeyboardSettings::inputMethodHints() const
316{
317 return Settings::instance()->inputMethodHints();
318}
319
320void QQuickVirtualKeyboardSettings::setInputMethodHints(const Qt::InputMethodHints &inputMethodHints)
321{
322 Settings::instance()->setInputMethodHints(inputMethodHints);
323}
324
325bool QQuickVirtualKeyboardSettings::isHandwritingModeDisabled() const
326{
327 return Settings::instance()->isHandwritingModeDisabled();
328}
329
330void QQuickVirtualKeyboardSettings::setHandwritingModeDisabled(bool handwritingModeDisabled)
331{
332 Settings::instance()->setHandwritingModeDisabled(handwritingModeDisabled);
333}
334
335bool QQuickVirtualKeyboardSettings::isDefaultInputMethodDisabled() const
336{
337 return Settings::instance()->isDefaultInputMethodDisabled();
338}
339
340void QQuickVirtualKeyboardSettings::setDefaultInputMethodDisabled(bool defaultInputMethodDisabled)
341{
342 return Settings::instance()->setDefaultInputMethodDisabled(defaultInputMethodDisabled);
343}
344
345bool QQuickVirtualKeyboardSettings::isDefaultDictionaryDisabled() const
346{
347 return Settings::instance()->isDefaultDictionaryDisabled();
348}
349
350void QQuickVirtualKeyboardSettings::setDefaultDictionaryDisabled(bool defaultDictionaryDisabled)
351{
352 return Settings::instance()->setDefaultDictionaryDisabled(defaultDictionaryDisabled);
353}
354
355QtVirtualKeyboard::KeyboardFunctionKeys QQuickVirtualKeyboardSettings::visibleFunctionKeys() const
356{
357 return Settings::instance()->visibleFunctionKeys();
358}
359
360void QQuickVirtualKeyboardSettings::setVisibleFunctionKeys(QtVirtualKeyboard::KeyboardFunctionKeys newVisibleFunctionKeys)
361{
362 Settings::instance()->setVisibleFunctionKeys(newVisibleFunctionKeys);
363}
364
365bool QQuickVirtualKeyboardSettings::closeOnReturn() const
366{
367 return Settings::instance()->closeOnReturn();
368}
369
370void QQuickVirtualKeyboardSettings::setCloseOnReturn(bool closeOnReturn)
371{
372 Settings::instance()->setCloseOnReturn(closeOnReturn);
373}
374
375void QQuickVirtualKeyboardSettings::resetStyle()
376{
377 Q_D(QQuickVirtualKeyboardSettings);
378 Settings *settings = Settings::instance();
379 QString styleName = QLatin1String(QT_VIRTUALKEYBOARD_DEFAULT_STYLE);
380 QString style = d->stylePath(name: styleName);
381 QString customStyleName = QString::fromLatin1(ba: qgetenv(varName: "QT_VIRTUALKEYBOARD_STYLE"));
382 if (!customStyleName.isEmpty()) {
383 bool found = false;
384 QRegularExpression styleNameValidator(QLatin1String("\\A(?:\\w+)\\z"));
385 QRegularExpressionMatch match = styleNameValidator.match(subject: customStyleName);
386 if (match.hasMatch()) {
387 QString customStyle = d->stylePath(name: customStyleName);
388 if (!customStyle.isEmpty()) {
389 styleName = customStyleName;
390 style = customStyle;
391 found = true;
392 }
393 }
394 if (!found) {
395 qWarning() << "WARNING: Cannot find style" << customStyleName << "- fallback:" << styleName;
396 }
397 }
398 if (!style.isEmpty()) {
399 settings->setStyleName(styleName);
400 settings->setStyle(style);
401 }
402}
403
404/*!
405 \qmlproperty string VirtualKeyboardSettings::style
406 \internal
407*/
408
409/*!
410 \qmlproperty string VirtualKeyboardSettings::styleName
411
412 This property provides the current style. Application can change
413 the keyboard style by setting the styleName to different value.
414
415 The system wide keyboard style can be affected by setting
416 the QT_VIRTUALKEYBOARD_STYLE environment variable.
417*/
418
419/*!
420 \qmlproperty string VirtualKeyboardSettings::locale
421 \since QtQuick.VirtualKeyboard.Settings 2.0
422
423 This property provides the default locale for the keyboard.
424
425 When the locale is not specified, the default system locale is used instead.
426
427 If the keyboard locale is different from the new default locale, keyboard
428 language is changed immediately to reflect the new locale. If the locale setting
429 is incorrect, or it is not in the list of supported locales, it is ignored and
430 the default setting is used instead.
431
432 A locale is supported if it is included in the list of availableLocales.
433*/
434
435/*!
436 \qmlproperty list<string> VirtualKeyboardSettings::availableLocales
437 \since QtQuick.VirtualKeyboard.Settings 2.0
438 \readonly
439
440 This property contains a list of languages supported by the virtual keyboard.
441
442 This list is read-only and depends on the build-time configuration of the
443 virtual keyboard.
444*/
445
446/*!
447 \qmlproperty list<string> VirtualKeyboardSettings::activeLocales
448 \since QtQuick.VirtualKeyboard.Settings 2.0
449
450 This property contains a list of activated languages of the virtual keyboard.
451
452 The list of active languages is a subset of the available languages, and can be
453 used to limit the list of available languages in the application lifetime.
454
455 The list of languages will be shown based on the specified ordering.
456*/
457
458/*!
459 \qmlproperty bool VirtualKeyboardSettings::fullScreenMode
460 \since QtQuick.VirtualKeyboard.Settings 2.2
461
462 This property enables the fullscreen mode for the virtual keyboard.
463
464 In fullscreen mode, the virtual keyboard replicates the contents of the
465 focused input field to the fullscreen input field located at the top of the
466 keyboard.
467
468 For example, to activate the fullscreen mode when the screen aspect ratio
469 is greater than 16:9:
470
471 \code
472 Binding {
473 target: VirtualKeyboardSettings
474 property: "fullScreenMode"
475 value: (Screen.width / Screen.height) > (16.0 / 9.0)
476 }
477 \endcode
478*/
479
480/*!
481 \qmlproperty bool VirtualKeyboardSettings::userDataPath
482 \since QtQuick.VirtualKeyboard.Settings 6.1
483
484 This property sets the user data path for the virtual keyboard and its plugins.
485
486 By default, the user data path is set to \l {QStandardPaths::GenericConfigLocation}{GenericConfigLocation} + "/qtvirtualkeyboard".
487*/
488
489/*!
490 \qmlsignal VirtualKeyboardSettings::userDataReset()
491
492 The application triggers this signal prior to the user's data being reset to
493 indicate to the virtual keyboard that all files must be closed
494 in the user data directory.
495*/
496
497/*!
498 \qmlproperty bool VirtualKeyboardSettings::hwrTimeoutForAlphabetic
499 \since QtQuick.VirtualKeyboard.Settings 6.1
500
501 This property sets the handwriting recognition timeout for alphabetical languages.
502
503 By default, the timeout is 500 millliseconds.
504*/
505
506/*!
507 \qmlproperty bool VirtualKeyboardSettings::hwrTimeoutForCjk
508 \since QtQuick.VirtualKeyboard.Settings 6.1
509
510 This property sets the handwriting recognition timeout for Chinese / Japanese / Korean languages.
511
512 By default, the timeout is 500 millliseconds.
513*/
514
515/*!
516 \qmlproperty int VirtualKeyboardSettings::inputMethodHints
517 \since QtQuick.VirtualKeyboard.Settings 6.1
518
519 This property allows to set persistent input method hints.
520
521 The value of this property is combined with the input method
522 hints from the input control. For example, to disable predictive
523 text input, this property can be set to \c Qt::ImhNoPredictiveText.
524*/
525
526/*!
527 \qmlproperty bool VirtualKeyboardSettings::handwritingModeDisabled
528 \since QtQuick.VirtualKeyboard.Settings 6.1
529
530 This property allows to disable handwriting input mode, if it is
531 otherwise available in the system.
532
533 When this property is set to \c true, the handwriting button is hidden
534 from the keyboard layout and the user cannot switch to handwriting
535 input mode.
536*/
537
538/*!
539 \qmlproperty bool VirtualKeyboardSettings::defaultInputMethodDisabled
540 \since QtQuick.VirtualKeyboard.Settings 6.1
541
542 This property disables the default input method. The purpose of this setting is to be able to
543 override the default input method with the plain input method, disabling its functionality.
544*/
545
546/*!
547 \qmlproperty bool VirtualKeyboardSettings::defaultDictionaryDisabled
548 \since QtQuick.VirtualKeyboard.Settings 6.1
549
550 This property disables the default dictionary. The purpose of this setting is to be able to
551 use a custom dictionary only instead of the standard dictionary.
552*/
553
554/*!
555 \qmlproperty enumeration VirtualKeyboardSettings::visibleFunctionKeys
556 \since QtQuick.VirtualKeyboard.Settings 6.6
557
558 This setting adjusts the visibility of specific function keys in the keyboard layout, allowing
559 them to be either displayed or hidden. When a function key is not visible, its functionality
560 remains accessible through the gear menu.
561
562 The value can be combination of the following flags:
563
564 \list
565 \li \c QtVirtualKeyboard.KeyboardFunctionKeys.None All function keys are hidden
566 \li \c QtVirtualKeyboard.KeyboardFunctionKeys.Hide Hide function key is visible
567 \li \c QtVirtualKeyboard.KeyboardFunctionKeys.Language Language function key is visible
568 \li \c QtVirtualKeyboard.KeyboardFunctionKeys.All All function keys are visible
569 \endlist
570
571 The default is \c QtVirtualKeyboard.KeyboardFunctionKeys.All.
572*/
573
574/*!
575 \qmlproperty bool VirtualKeyboardSettings::closeOnReturn
576 \since QtQuick.VirtualKeyboard.Settings 6.8
577
578 This property enables hiding of virtual keyboard.
579
580 When this property is set to \c true, the virtual keyboard is hidden when \l Qt::Key_Enter
581 or \l Qt::Key_Return key released. The default is \c false.
582*/
583
584/*!
585 \since QtQuick.VirtualKeyboard.Settings 2.2
586 \qmlproperty int VirtualKeyboardSettings::wordCandidateList.autoHideDelay
587 \qmlproperty bool VirtualKeyboardSettings::wordCandidateList.alwaysVisible
588
589 \table
590 \header
591 \li Name
592 \li Description
593 \row
594 \li autoHideDelay
595 \li This property defines the delay, in milliseconds, after which the
596 word candidate list is hidden if empty.
597
598 If the value is \c 0, the list is immediately hidden when cleared.
599
600 If the value is \c -1, the list is visible until input focus
601 changes, or the input panel is hidden.
602
603 The default value is \c 5000 milliseconds.
604 \row
605 \li alwaysVisible
606 \li This property defines whether the word candidate list should always
607 remain visible.
608
609 The default value is \c false.
610 \row
611 \li autoCommitWord
612 \li This property enables the automatic commit feature that is activated
613 when the word candidate list is narrowed down to a single candidate.
614
615 The automatic commit feature takes effect when the word candidate
616 list initially contains multiple words and is reduced to single word
617 after additional input. This word will be selected and committed
618 automatically without user interaction.
619
620 This property is set to \c false by default.
621 \endtable
622*/
623
624QQuickWordCandidateListSettings::QQuickWordCandidateListSettings(QObject *parent) :
625 QObject(parent)
626{
627}
628
629int QQuickWordCandidateListSettings::autoHideDelay() const
630{
631 return Settings::instance()->wclAutoHideDelay();
632}
633
634void QQuickWordCandidateListSettings::setAutoHideDelay(int autoHideDelay)
635{
636 Settings::instance()->setWclAutoHideDelay(autoHideDelay);
637}
638
639bool QQuickWordCandidateListSettings::alwaysVisible() const
640{
641 return Settings::instance()->wclAlwaysVisible();
642}
643
644void QQuickWordCandidateListSettings::setAlwaysVisible(bool alwaysVisible)
645{
646 Settings::instance()->setWclAlwaysVisible(alwaysVisible);
647}
648
649bool QQuickWordCandidateListSettings::autoCommitWord() const
650{
651 return Settings::instance()->wclAutoCommitWord();
652}
653
654void QQuickWordCandidateListSettings::setAutoCommitWord(bool autoCommitWord)
655{
656 Settings::instance()->setWclAutoCommitWord(autoCommitWord);
657}
658
659} // namespace QtVirtualKeyboard
660QT_END_NAMESPACE
661

source code of qtvirtualkeyboard/src/settings/qquickvirtualkeyboardsettings.cpp