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 | |
14 | QT_BEGIN_NAMESPACE |
15 | namespace QtVirtualKeyboard { |
16 | |
17 | class QQuickVirtualKeyboardSettingsPrivate : public QObjectPrivate |
18 | { |
19 | Q_DECLARE_PUBLIC(QQuickVirtualKeyboardSettings) |
20 | public: |
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 | */ |
127 | QQuickVirtualKeyboardSettings::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 | */ |
160 | QQuickVirtualKeyboardSettings *QQuickVirtualKeyboardSettings::create(QQmlEngine *qmlEngine, QJSEngine *) |
161 | { |
162 | return new QQuickVirtualKeyboardSettings(qmlEngine); |
163 | } |
164 | |
165 | /*! |
166 | \internal |
167 | */ |
168 | QString QQuickVirtualKeyboardSettings::style() const |
169 | { |
170 | return Settings::instance()->style(); |
171 | } |
172 | |
173 | /*! |
174 | \internal |
175 | */ |
176 | QString QQuickVirtualKeyboardSettings::styleName() const |
177 | { |
178 | return Settings::instance()->styleName(); |
179 | } |
180 | |
181 | /*! |
182 | \internal |
183 | */ |
184 | void 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 | */ |
200 | QUrl QQuickVirtualKeyboardSettings::layoutPath() const |
201 | { |
202 | return Settings::instance()->layoutPath(); |
203 | } |
204 | |
205 | /*! |
206 | \internal |
207 | */ |
208 | void 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 | |
219 | void 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 | |
244 | QString QQuickVirtualKeyboardSettings::locale() const |
245 | { |
246 | return Settings::instance()->locale(); |
247 | } |
248 | |
249 | void QQuickVirtualKeyboardSettings::setLocale(const QString &locale) |
250 | { |
251 | Settings::instance()->setLocale(locale); |
252 | } |
253 | |
254 | QStringList QQuickVirtualKeyboardSettings::availableLocales() const |
255 | { |
256 | return Settings::instance()->availableLocales(); |
257 | } |
258 | |
259 | void QQuickVirtualKeyboardSettings::setActiveLocales(const QStringList &activeLocales) |
260 | { |
261 | Settings::instance()->setActiveLocales(activeLocales); |
262 | } |
263 | |
264 | QStringList QQuickVirtualKeyboardSettings::activeLocales() const |
265 | { |
266 | return Settings::instance()->activeLocales(); |
267 | } |
268 | |
269 | QQuickWordCandidateListSettings *QQuickVirtualKeyboardSettings::wordCandidateList() const |
270 | { |
271 | Q_D(const QQuickVirtualKeyboardSettings); |
272 | return const_cast<QQuickWordCandidateListSettings *>(&d->wordCandidateListSettings); |
273 | } |
274 | |
275 | bool QQuickVirtualKeyboardSettings::fullScreenMode() const |
276 | { |
277 | return Settings::instance()->fullScreenMode(); |
278 | } |
279 | |
280 | void QQuickVirtualKeyboardSettings::setFullScreenMode(bool fullScreenMode) |
281 | { |
282 | return Settings::instance()->setFullScreenMode(fullScreenMode); |
283 | } |
284 | |
285 | QString QQuickVirtualKeyboardSettings::userDataPath() const |
286 | { |
287 | return Settings::instance()->userDataPath(); |
288 | } |
289 | |
290 | void QQuickVirtualKeyboardSettings::setUserDataPath(const QString &userDataPath) |
291 | { |
292 | return Settings::instance()->setUserDataPath(userDataPath); |
293 | } |
294 | |
295 | int QQuickVirtualKeyboardSettings::hwrTimeoutForAlphabetic() const |
296 | { |
297 | return Settings::instance()->hwrTimeoutForAlphabetic(); |
298 | } |
299 | |
300 | void QQuickVirtualKeyboardSettings::setHwrTimeoutForAlphabetic(int hwrTimeoutForAlphabetic) |
301 | { |
302 | return Settings::instance()->setHwrTimeoutForAlphabetic(hwrTimeoutForAlphabetic); |
303 | } |
304 | |
305 | int QQuickVirtualKeyboardSettings::hwrTimeoutForCjk() const |
306 | { |
307 | return Settings::instance()->hwrTimeoutForCjk(); |
308 | } |
309 | |
310 | void QQuickVirtualKeyboardSettings::setHwrTimeoutForCjk(int hwrTimeoutForCjk) |
311 | { |
312 | return Settings::instance()->setHwrTimeoutForCjk(hwrTimeoutForCjk); |
313 | } |
314 | |
315 | Qt::InputMethodHints QQuickVirtualKeyboardSettings::inputMethodHints() const |
316 | { |
317 | return Settings::instance()->inputMethodHints(); |
318 | } |
319 | |
320 | void QQuickVirtualKeyboardSettings::setInputMethodHints(const Qt::InputMethodHints &inputMethodHints) |
321 | { |
322 | Settings::instance()->setInputMethodHints(inputMethodHints); |
323 | } |
324 | |
325 | bool QQuickVirtualKeyboardSettings::isHandwritingModeDisabled() const |
326 | { |
327 | return Settings::instance()->isHandwritingModeDisabled(); |
328 | } |
329 | |
330 | void QQuickVirtualKeyboardSettings::setHandwritingModeDisabled(bool handwritingModeDisabled) |
331 | { |
332 | Settings::instance()->setHandwritingModeDisabled(handwritingModeDisabled); |
333 | } |
334 | |
335 | bool QQuickVirtualKeyboardSettings::isDefaultInputMethodDisabled() const |
336 | { |
337 | return Settings::instance()->isDefaultInputMethodDisabled(); |
338 | } |
339 | |
340 | void QQuickVirtualKeyboardSettings::setDefaultInputMethodDisabled(bool defaultInputMethodDisabled) |
341 | { |
342 | return Settings::instance()->setDefaultInputMethodDisabled(defaultInputMethodDisabled); |
343 | } |
344 | |
345 | bool QQuickVirtualKeyboardSettings::isDefaultDictionaryDisabled() const |
346 | { |
347 | return Settings::instance()->isDefaultDictionaryDisabled(); |
348 | } |
349 | |
350 | void QQuickVirtualKeyboardSettings::setDefaultDictionaryDisabled(bool defaultDictionaryDisabled) |
351 | { |
352 | return Settings::instance()->setDefaultDictionaryDisabled(defaultDictionaryDisabled); |
353 | } |
354 | |
355 | QtVirtualKeyboard::KeyboardFunctionKeys QQuickVirtualKeyboardSettings::visibleFunctionKeys() const |
356 | { |
357 | return Settings::instance()->visibleFunctionKeys(); |
358 | } |
359 | |
360 | void QQuickVirtualKeyboardSettings::setVisibleFunctionKeys(QtVirtualKeyboard::KeyboardFunctionKeys newVisibleFunctionKeys) |
361 | { |
362 | Settings::instance()->setVisibleFunctionKeys(newVisibleFunctionKeys); |
363 | } |
364 | |
365 | bool QQuickVirtualKeyboardSettings::closeOnReturn() const |
366 | { |
367 | return Settings::instance()->closeOnReturn(); |
368 | } |
369 | |
370 | void QQuickVirtualKeyboardSettings::setCloseOnReturn(bool closeOnReturn) |
371 | { |
372 | Settings::instance()->setCloseOnReturn(closeOnReturn); |
373 | } |
374 | |
375 | void 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 | |
624 | QQuickWordCandidateListSettings::QQuickWordCandidateListSettings(QObject *parent) : |
625 | QObject(parent) |
626 | { |
627 | } |
628 | |
629 | int QQuickWordCandidateListSettings::autoHideDelay() const |
630 | { |
631 | return Settings::instance()->wclAutoHideDelay(); |
632 | } |
633 | |
634 | void QQuickWordCandidateListSettings::setAutoHideDelay(int autoHideDelay) |
635 | { |
636 | Settings::instance()->setWclAutoHideDelay(autoHideDelay); |
637 | } |
638 | |
639 | bool QQuickWordCandidateListSettings::alwaysVisible() const |
640 | { |
641 | return Settings::instance()->wclAlwaysVisible(); |
642 | } |
643 | |
644 | void QQuickWordCandidateListSettings::setAlwaysVisible(bool alwaysVisible) |
645 | { |
646 | Settings::instance()->setWclAlwaysVisible(alwaysVisible); |
647 | } |
648 | |
649 | bool QQuickWordCandidateListSettings::autoCommitWord() const |
650 | { |
651 | return Settings::instance()->wclAutoCommitWord(); |
652 | } |
653 | |
654 | void QQuickWordCandidateListSettings::setAutoCommitWord(bool autoCommitWord) |
655 | { |
656 | Settings::instance()->setWclAutoCommitWord(autoCommitWord); |
657 | } |
658 | |
659 | } // namespace QtVirtualKeyboard |
660 | QT_END_NAMESPACE |
661 |
Definitions
- QQuickVirtualKeyboardSettingsPrivate
- QQuickVirtualKeyboardSettingsPrivate
- buildStylePath
- buildStyleFilePath
- qmlImportPathList
- stylePath
- QQuickVirtualKeyboardSettings
- create
- style
- styleName
- setStyleName
- layoutPath
- setLayoutPath
- resetLayoutPath
- locale
- setLocale
- availableLocales
- setActiveLocales
- activeLocales
- wordCandidateList
- fullScreenMode
- setFullScreenMode
- userDataPath
- setUserDataPath
- hwrTimeoutForAlphabetic
- setHwrTimeoutForAlphabetic
- hwrTimeoutForCjk
- setHwrTimeoutForCjk
- inputMethodHints
- setInputMethodHints
- isHandwritingModeDisabled
- setHandwritingModeDisabled
- isDefaultInputMethodDisabled
- setDefaultInputMethodDisabled
- isDefaultDictionaryDisabled
- setDefaultDictionaryDisabled
- visibleFunctionKeys
- setVisibleFunctionKeys
- closeOnReturn
- setCloseOnReturn
- resetStyle
- QQuickWordCandidateListSettings
- autoHideDelay
- setAutoHideDelay
- alwaysVisible
- setAlwaysVisible
- autoCommitWord
Start learning QML with our Intro Training
Find out more