Revision control
Copy as Markdown
// Copyright (C) 2021 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
#include "t9writeinputmethod_p.h"
#include <QtVirtualKeyboard/qvirtualkeyboardinputengine.h>
#include <QtVirtualKeyboard/qvirtualkeyboardinputcontext.h>
#include <QtVirtualKeyboard/qvirtualkeyboardtrace.h>
#include "t9writeworker_p.h"
#include <QLoggingCategory>
#include <QDirIterator>
#include <QCryptographicHash>
#include <QTime>
#include <QMetaEnum>
#include <QtCore/QLibraryInfo>
#include <QtVirtualKeyboard/private/settings_p.h>
#include <QtVirtualKeyboard/private/handwritinggesturerecognizer_p.h>
#include <QtVirtualKeyboard/private/qvirtualkeyboardabstractinputmethod_p.h>
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
#include <QtVirtualKeyboard/private/unipentrace_p.h>
#include <QStandardPaths>
#endif
#include <QtVirtualKeyboard/qvirtualkeyboarddictionary.h>
#include <QtVirtualKeyboard/qvirtualkeyboarddictionarymanager.h>
#include "decumaStatus.h"
#include "decumaSymbolCategories.h"
#include "decumaLanguages.h"
#include "xxchOem.h"
#include "xt9ldbmanager.h"
#include "t9writewordcandidate_p.h"
#ifdef HAVE_XT9
#include <xt9awime.h>
#include <xt9cpime.h>
#include <xt9jime.h>
#include <xt9kime.h>
#include <xt9callbacks.h>
#include <xt9languagemap.h>
#endif
/* Set to 1 to enable T9 Write log.
The log is routed to qDebug() and it can be enabled for troubleshooting
and when reporting issues. The log must not to be enabled in production
build.
*/
#define QT_VIRTUALKEYBOARD_CERENCE_HWR_LOG 0
#define CERENCE_HWR_DLM_MAX_WORDS 10000
QT_BEGIN_NAMESPACE
namespace QtVirtualKeyboard {
Q_LOGGING_CATEGORY(lcT9Write, "qt.virtualkeyboard.cerence-hwr")
class T9WriteCaseFormatter
{
public:
T9WriteCaseFormatter() :
preferLowercase(false)
{
}
void clear()
{
textCaseList.clear();
}
void ensureLength(int length, QVirtualKeyboardInputEngine::TextCase textCase)
{
if (length <= 0) {
textCaseList.clear();
return;
}
while (length < textCaseList.size())
textCaseList.removeLast();
while (length > textCaseList.size())
textCaseList.append(textCase);
}
QString formatString(const QString &str) const
{
QString result;
QVirtualKeyboardInputEngine::TextCase textCase = QVirtualKeyboardInputEngine::TextCase::Lower;
for (int i = 0; i < str.length(); ++i) {
if (i < textCaseList.size())
textCase = textCaseList.at(i);
result.append(textCase == QVirtualKeyboardInputEngine::TextCase::Upper ? str.at(i).toUpper() : (preferLowercase ? str.at(i).toLower() : str.at(i)));
}
return result;
}
bool preferLowercase;
private:
QList<QVirtualKeyboardInputEngine::TextCase> textCaseList;
};
class T9WriteInputMethodPrivate : public QVirtualKeyboardAbstractInputMethodPrivate
#ifdef HAVE_XT9
, public Xt9RequestCallback
#endif
{
public:
Q_DECLARE_PUBLIC(T9WriteInputMethod)
T9WriteInputMethodPrivate(T9WriteInputMethod *q_ptr) :
QVirtualKeyboardAbstractInputMethodPrivate(),
q_ptr(q_ptr),
cjk(false),
engineMode(T9WriteInputMethod::EngineMode::Uninitialized),
traceListHardLimit(32),
attachedDictionary(nullptr),
ldbManager(new Xt9LdbManager()),
resultId(0),
lastResultId(0),
resultTimer(0),
decumaSession(nullptr),
activeWordIndex(-1),
arcAdditionStarted(false),
ignoreUpdate(false),
textCase(QVirtualKeyboardInputEngine::TextCase::Lower)
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
, unipenTrace()
#endif
{
#ifdef HAVE_CERENCE_HWR_RESOURCE
Q_INIT_RESOURCE(qmake_cerencecommondata_db);
Q_INIT_RESOURCE(qmake_cerencehwrdata_db);
#endif
const QString pathListSep(
#if defined(Q_OS_WIN32)
QStringLiteral(";")
#else
QStringLiteral(":")
#endif
);
const QString userHwrDbPath(qEnvironmentVariable("QT_VIRTUALKEYBOARD_CERENCE_HWR_DB_PATH"));
defaultHwrDbPaths = userHwrDbPath.split(pathListSep, Qt::SkipEmptyParts)
<< QDir(QStringLiteral("%1/qtvirtualkeyboard/cerence/handwriting/").arg(QLibraryInfo::path(QLibraryInfo::DataPath))).absolutePath()
<< QStringLiteral(":/qt-project.org/imports/QtQuick/VirtualKeyboard/Cerence/Handwriting/");
ldbManager->setPhdEnabled(true);
for (const QString &searchPath : defaultHwrDbPaths) {
ldbManager->addSearchPath(searchPath);
}
}
static void *decumaMalloc(size_t size, void *pPrivate)
{
Q_UNUSED(pPrivate);
return malloc(size);
}
static void *decumaCalloc(size_t elements, size_t size, void *pPrivate)
{
Q_UNUSED(pPrivate);
return calloc(elements, size);
}
static void decumaFree(void *ptr, void *pPrivate)
{
Q_UNUSED(pPrivate);
free(ptr);
}
#if QT_VIRTUALKEYBOARD_CERENCE_HWR_LOG
static void decumaLogString(void *pUserData, const char *pLogString, DECUMA_UINT32 nLogStringLength)
{
static QMutex s_logMutex;
static QByteArray s_logString;
Q_UNUSED(pUserData);
QMutexLocker guard(&s_logMutex);
s_logString.append(pLogString, nLogStringLength);
if (s_logString.endsWith('\n')) {
while (s_logString.endsWith('\n'))
s_logString.chop(1);
qDebug() << (const char *)s_logString.constData();
s_logString.clear();
}
}
#endif
static const char *engineModeToString(T9WriteInputMethod::EngineMode mode)
{
return QMetaEnum::fromType<T9WriteInputMethod::EngineMode>().key(static_cast<int>(mode));
}
bool initEngine(T9WriteInputMethod::EngineMode newEngineMode)
{
if (engineMode == newEngineMode)
return engineMode != T9WriteInputMethod::EngineMode::Uninitialized;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::initEngine()" << engineModeToString(newEngineMode);
if (decumaSession)
exitEngine();
if (newEngineMode == T9WriteInputMethod::EngineMode::Uninitialized)
return false;
switch (newEngineMode) {
case T9WriteInputMethod::EngineMode::Alphabetic:
case T9WriteInputMethod::EngineMode::Arabic:
case T9WriteInputMethod::EngineMode::Hebrew:
case T9WriteInputMethod::EngineMode::Thai:
cjk = false;
break;
case T9WriteInputMethod::EngineMode::SimplifiedChinese:
case T9WriteInputMethod::EngineMode::TraditionalChinese:
case T9WriteInputMethod::EngineMode::HongKongChinese:
case T9WriteInputMethod::EngineMode::Japanese:
case T9WriteInputMethod::EngineMode::Korean:
cjk = true;
break;
default:
Q_ASSERT(0 && "Invalid T9WriteInputMethod::EngineMode!");
return false;
}
engineMode = newEngineMode;
memset(&sessionSettings, 0, sizeof(sessionSettings));
QString hwrDb = findHwrDb(engineMode);
hwrDbFile.setFileName(hwrDb);
if (!hwrDbFile.open(QIODevice::ReadOnly)) {
qCCritical(lcT9Write) << "Could not open HWR database" << hwrDb;
exitEngine();
return false;
}
sessionSettings.pStaticDB = reinterpret_cast<DECUMA_STATIC_DB_PTR>(hwrDbFile.map(0, hwrDbFile.size(), QFile::NoOptions));
if (!sessionSettings.pStaticDB) {
qCCritical(lcT9Write) << "Could not read HWR database" << hwrDb;
exitEngine();
return false;
}
symbolCategories.append(DECUMA_CATEGORY_ANSI);
languageCategories.append(DECUMA_LANG_EN);
sessionSettings.recognitionMode = mcrMode;
sessionSettings.writingDirection = unknownWriting;
sessionSettings.charSet.pSymbolCategories = symbolCategories.data();
sessionSettings.charSet.nSymbolCategories = static_cast<DECUMA_UINT8>(symbolCategories.size());
sessionSettings.charSet.pLanguages = languageCategories.data();
sessionSettings.charSet.nLanguages = static_cast<DECUMA_UINT8>(languageCategories.size());
session = QByteArray(static_cast<int>(DECUMA_API(GetSessionSize)()), 0);
decumaSession = reinterpret_cast<DECUMA_SESSION *>(!session.isEmpty() ? session.data() : nullptr);
DECUMA_STATUS status = DECUMA_API(BeginSession)(decumaSession, &sessionSettings, &memFuncs);
Q_ASSERT(status == decumaNoError);
if (status != decumaNoError) {
qCCritical(lcT9Write) << "Could not initialize engine" << status;
exitEngine();
return false;
}
#if QT_VIRTUALKEYBOARD_CERENCE_HWR_LOG
DECUMA_API(StartLogging)(decumaSession, 0, decumaLogString);
#endif
worker.reset(new T9WriteWorker(decumaSession, cjk));
worker->start();
Q_Q(T9WriteInputMethod);
resultListChangedConnection = QObjectPrivate::connect(
q, &T9WriteInputMethod::resultListChanged,
this, &T9WriteInputMethodPrivate::processResultCheckTimer,
Qt::QueuedConnection);
availableDictionariesChangedConnection = QObjectPrivate::connect(QVirtualKeyboardDictionaryManager::instance(),
&QVirtualKeyboardDictionaryManager::availableDictionariesChanged,
this, &T9WriteInputMethodPrivate::onAvailableDynamicDictionariesChanged);
activeDictionariesChangedConnection = QObjectPrivate::connect(QVirtualKeyboardDictionaryManager::instance(),
&QVirtualKeyboardDictionaryManager::activeDictionariesChanged,
this, &T9WriteInputMethodPrivate::onActiveDynamicDictionariesChanged);
#ifdef HAVE_XT9
bindSettings();
#endif
return true;
}
void exitEngine()
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::exitEngine()";
#ifdef HAVE_XT9
unbindSettings();
#endif
QObject::disconnect(resultListChangedConnection);
QObject::disconnect(availableDictionariesChangedConnection);
QObject::disconnect(activeDictionariesChangedConnection);
worker.reset();
#ifdef HAVE_XT9
xt9Exit();
#endif
if (sessionSettings.pStaticDB) {
hwrDbFile.unmap(const_cast<uchar *>(reinterpret_cast<const uchar *>(sessionSettings.pStaticDB)));
hwrDbFile.close();
}
dlmDeactivate();
if (attachedDictionary) {
detachDictionary(attachedDictionary);
attachedDictionary.reset();
}
loadedDictionary.reset();
for (auto &dynamicDictionary : attachedDynamicDictionaries) {
detachDictionary(dynamicDictionary);
}
attachedDynamicDictionaries.clear();
dynamicDictionaries.clear();
if (decumaSession) {
#if QT_VIRTUALKEYBOARD_CERENCE_HWR_LOG
DECUMA_API(StopLogging)(decumaSession);
#endif
DECUMA_API(EndSession)(decumaSession);
decumaSession = nullptr;
session.clear();
}
memset(&sessionSettings, 0, sizeof(sessionSettings));
symbolCategories.clear();
languageCategories.clear();
ldbManager->closeAll();
engineMode = T9WriteInputMethod::EngineMode::Uninitialized;
cjk = false;
}
#ifdef HAVE_XT9
void xt9Init(const QLocale &locale, QVirtualKeyboardInputEngine::InputMode inputMode, T9WriteInputMethod::EngineMode newEngineMode)
{
ET9U32 dwFirstLdbNum = Xt9LanguageMap::languageId(locale);
ET9U32 eInputMode = ET9AWInputMode_Default;
xt9DetachAllDynamicDictionaries();
switch (newEngineMode) {
case T9WriteInputMethod::EngineMode::SimplifiedChinese:
case T9WriteInputMethod::EngineMode::TraditionalChinese:
case T9WriteInputMethod::EngineMode::HongKongChinese:
if (inputMode == QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting) {
xt9Ime.reset(new Xt9CpIme(this));
switch (locale.script()) {
case QLocale::SimplifiedHanScript:
if (static_cast<Xt9CpIme *>(xt9Ime.data())) {
eInputMode = ET9CPMODE_PINYIN;
}
break;
default:
break;
}
} else {
if (xt9IsAlphabeticCoreDisabled()) {
xt9Exit();
return;
}
xt9Ime.reset(new Xt9AwIme(this));
dwFirstLdbNum = ET9LIDEnglish_UK;
}
break;
case T9WriteInputMethod::EngineMode::Japanese:
xt9Ime.reset(new Xt9JIme(this));
eInputMode = ET9AWInputMode_RomajiConversion;
break;
case T9WriteInputMethod::EngineMode::Korean:
xt9Ime.reset(new Xt9KIme(this));
break;
default:
if (xt9IsAlphabeticCoreDisabled()) {
xt9Exit();
return;
}
xt9Ime.reset(new Xt9AwIme(this));
break;
}
xt9Ime->ldbManager = ldbManager;
xt9Ime->sysInit();
xt9Ime->setWorkingDirectory(Settings::instance()->userDataPath());
if (xt9DynamicDictionaries.isEmpty())
xt9Ime->removeAllIndexes();
// PHD must be disabled during XT9 init to prevent finding
// T9 Write specific dictionary files.
ldbManager->setPhdEnabled(false);
xt9Ime->ldbInit(dwFirstLdbNum, ET9PLIDNone, eInputMode);
ldbManager->setPhdEnabled(true);
onDefaultDictionaryDisabledChanged();
onAvailableDynamicDictionariesChanged();
onActiveDynamicDictionariesChanged();
}
void xt9Exit()
{
if (xt9Ime)
xt9Ime->removeAllIndexes();
Q_Q(T9WriteInputMethod);
QVirtualKeyboardDictionaryManager *dictionaryManager = QVirtualKeyboardDictionaryManager::instance();
const QStringList availableDictionaries = dictionaryManager->availableDictionaries();
for (const QString &dictionaryName : availableDictionaries) {
QVirtualKeyboardDictionary *dictionary = dictionaryManager->dictionary(dictionaryName);
dictionary->disconnect(q); // lambdas
}
xt9AttachedDynamicDictionaries.clear();
xt9DynamicDictionaries.clear();
xt9DynamicDictionaryNextId = 0;
xt9Ime.reset();
}
void bindSettings()
{
if (!defaultInputMethodDisabledChangedConnection)
defaultInputMethodDisabledChangedConnection = QObjectPrivate::connect(
Settings::instance(), &Settings::defaultInputMethodDisabledChanged,
this, &T9WriteInputMethodPrivate::onXt9AlphabeticCoreDisabledChanged);
if (!defaultDictionaryDisabledChangedConnection)
defaultDictionaryDisabledChangedConnection = QObjectPrivate::connect(
Settings::instance(), &Settings::defaultDictionaryDisabledChanged,
this, &T9WriteInputMethodPrivate::onDefaultDictionaryDisabledChanged);
if (!userDataResetConnection)
userDataResetConnection = QObjectPrivate::connect(
Settings::instance(), &Settings::userDataReset,
this, &T9WriteInputMethodPrivate::onUserDataReset);
}
void unbindSettings()
{
QObject::disconnect(defaultInputMethodDisabledChangedConnection);
QObject::disconnect(defaultDictionaryDisabledChangedConnection);
QObject::disconnect(userDataResetConnection);
}
void onXt9AlphabeticCoreDisabledChanged()
{
if (xt9IsAlphabeticCoreDisabled()) {
xt9Exit();
} else if (!xt9Ime) {
Q_Q(T9WriteInputMethod);
const QVirtualKeyboardInputEngine::InputMode inputMode = q->inputEngine()->inputMode();
const QLocale locale = QLocale(q->inputContext()->locale());
const DECUMA_UINT32 language = mapToDecumaLanguage(locale, inputMode);
const T9WriteInputMethod::EngineMode newEngineMode = mapLocaleToEngineMode(locale, language);
xt9Init(locale, inputMode, newEngineMode);
}
}
static bool xt9IsAlphabeticCoreDisabled()
{
Settings *settings = Settings::instance();
return settings->isDefaultInputMethodDisabled();
}
void onDefaultDictionaryDisabledChanged()
{
if (Xt9AwIme *xt9AwIme = dynamic_cast<Xt9AwIme *>(xt9Ime.data()))
xt9AwIme->setLdbEnabled(!Settings::instance()->isDefaultDictionaryDisabled());
}
void onUserDataReset()
{
dlmDeactivate();
#ifdef HAVE_XT9
xt9Exit();
#endif
}
ET9STATUS request(ET9_Request *const pRequest) override
{
Q_Q(T9WriteInputMethod);
switch (pRequest->eType) {
case ET9_REQ_BufferContext:
{
QVirtualKeyboardInputContext *ic = q->inputContext();
if (!ic)
break;
const ET9U32 dwContextLen = static_cast<ET9U32>(ic->cursorPosition());
const ET9U32 dwStartIndex =
dwContextLen <= pRequest->data.sBufferContextInfo.dwMaxBufLen ?
0 : dwContextLen - pRequest->data.sBufferContextInfo.dwMaxBufLen;
pRequest->data.sBufferContextInfo.dwBufLen = dwContextLen - dwStartIndex;
const QString surroundingText = ic->surroundingText();
memcpy(pRequest->data.sBufferContextInfo.psBuf, surroundingText.utf16() + dwStartIndex,
pRequest->data.sBufferContextInfo.dwBufLen * sizeof(ET9SYMB));
break;
}
default:
break;
}
return ET9STATUS_NONE;
}
bool xt9AllSymbsArePinyin(const QString &symbs) const
{
bool allSymbsArePinyin = false;
for (const QChar &symb : symbs) {
const ushort ucs = symb.unicode();
allSymbsArePinyin = ET9CPIsPinyinSymbol(ucs);
if (!allSymbsArePinyin)
break;
}
return allSymbsArePinyin;
}
bool xt9AttachDictionary(const QString &dictionaryName)
{
if (!xt9DynamicDictionaries.contains(dictionaryName))
return false;
const quint16 id = xt9DynamicDictionaries.value(dictionaryName);
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::xt9AttachDictionary():" << dictionaryName << id;
xt9Ime->mountIndex(id);
xt9AttachedDynamicDictionaries[dictionaryName] = id;
return true;
}
void xt9DetachDictionary(const QString &dictionaryName)
{
if (!xt9AttachedDynamicDictionaries.contains(dictionaryName))
return;
const quint16 id = xt9AttachedDynamicDictionaries[dictionaryName];
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::xt9DetachDictionary():" << dictionaryName << id;
xt9Ime->unmountIndex(id);
xt9AttachedDynamicDictionaries.remove(dictionaryName);
}
#endif
#ifdef HAVE_XT9
void xt9DetachAllDynamicDictionaries()
{
if (xt9Ime) {
const QStringList dictionaryNames = xt9AttachedDynamicDictionaries.keys();
for (const QString &dictionaryName : dictionaryNames) {
xt9DetachDictionary(dictionaryName);
}
}
xt9AttachedDynamicDictionaries.clear();
}
#endif
QStringList xt9BuildSelectionList(const QString &exactWord, int *defaultListIndex)
{
#ifdef HAVE_XT9
if (!xt9Ime)
return QStringList();
xt9Ime->cursorMoved();
Q_Q(T9WriteInputMethod);
bool forceLowerCase =
engineMode == T9WriteInputMethod::EngineMode::SimplifiedChinese &&
q->inputEngine()->inputMode() == QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting &&
xt9AllSymbsArePinyin(exactWord);
ET9ClearAllSymbs(&xt9Ime->sWordSymbInfo);
for (const QChar &c : exactWord) {
ET9AddExplicitSymb(&xt9Ime->sWordSymbInfo, c.unicode(), 0, !forceLowerCase && c.isUpper() ? ET9SHIFT : ET9NOSHIFT, ET9_NO_ACTIVE_INDEX);
}
ET9SYMB gestureValue = 0;
return xt9Ime->buildSelectionList(defaultListIndex, &gestureValue);
#else
return QStringList();
#endif
}
void appendWordCandidates(QList<T9WriteWordCandidate> &aWordCandidates, int &activeWordIndex, const QString &exactWord, const QStringList &wordCandidatesToAppend, int defaultListIndex, T9WriteWordCandidate::Origin origin) const
{
for (int index = 0; index < wordCandidatesToAppend.size(); ++index) {
const T9WriteWordCandidate wordCandidate(wordCandidatesToAppend[index], index, origin);
if (!aWordCandidates.contains(wordCandidate)) {
bool isDefaultIndex = defaultListIndex > 0 &&
index == defaultListIndex && !cjk &&
origin == T9WriteWordCandidate::Origin::XT9;
if (isDefaultIndex) {
activeWordIndex = qMin(aWordCandidates.size(), 1);
aWordCandidates.insert(activeWordIndex, wordCandidate);
} else {
aWordCandidates.append(wordCandidate);
}
}
}
if (aWordCandidates.isEmpty()) {
aWordCandidates.append(T9WriteWordCandidate(exactWord));
}
}
QString findHwrDb(T9WriteInputMethod::EngineMode mode) const
{
for (const QString &defaultHwrDbPath : defaultHwrDbPaths) {
const QString result = findHwrDb(mode, defaultHwrDbPath);
if (!result.isEmpty())
return result;
}
qCCritical(lcT9Write) << "Could not find HWR database for" << engineModeToString(mode);
return QString();
}
QString findHwrDb(T9WriteInputMethod::EngineMode mode, const QString &dir) const
{
QString hwrDbPath(QDir::fromNativeSeparators(dir));
if (!hwrDbPath.endsWith(QLatin1Char('/')))
hwrDbPath.append(QLatin1Char('/'));
switch (mode) {
case T9WriteInputMethod::EngineMode::Alphabetic:
hwrDbPath.append(QLatin1String("hwrDB_le.bin"));
break;
case T9WriteInputMethod::EngineMode::Arabic:
hwrDbPath.append(QLatin1String("arabic/hwrDB_le.bin"));
break;
case T9WriteInputMethod::EngineMode::Hebrew:
hwrDbPath.append(QLatin1String("hebrew/hwrDB_le.bin"));
break;
case T9WriteInputMethod::EngineMode::Thai:
hwrDbPath.append(QLatin1String("thai/hwrDB_le.bin"));
break;
case T9WriteInputMethod::EngineMode::SimplifiedChinese:
hwrDbPath.append(QLatin1String("cjk_S_gb18030_le.hdb"));
break;
case T9WriteInputMethod::EngineMode::TraditionalChinese:
case T9WriteInputMethod::EngineMode::HongKongChinese:
hwrDbPath.append(QLatin1String("cjk_HK_std_le.hdb"));
break;
case T9WriteInputMethod::EngineMode::Japanese:
hwrDbPath.append(QLatin1String("cjk_J_std_le.hdb"));
break;
case T9WriteInputMethod::EngineMode::Korean:
hwrDbPath.append(QLatin1String("cjk_K_mkt_le.hdb"));
break;
default:
return QString();
}
if (!QFileInfo::exists(hwrDbPath)) {
return QString();
}
return hwrDbPath;
}
QString findDictionary(const QLocale &locale, DECUMA_SRC_DICTIONARY_TYPE &srcType)
{
srcType = numberOfSrcDictionaryTypes;
QString dictionary = ldbManager->findDictionary(locale);
if (!dictionary.isEmpty()) {
if (dictionary.endsWith(QLatin1String(".ldb"))) {
srcType = decumaPortableHWRDictionary;
} else if (dictionary.endsWith(QLatin1String(".phd"))) {
srcType = decumaPortableHWRDictionary;
} else {
qCCritical(lcT9Write) << "Incompatible dictionary" << dictionary;
dictionary.clear();
}
}
return dictionary;
}
bool attachDictionary(const QSharedPointer<T9WriteAbstractDictionary> &dictionary)
{
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
Q_ASSERT(decumaSession != nullptr);
Q_ASSERT(dictionary != nullptr);
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::attachDictionary():" << dictionary->name();
DECUMA_STATUS status = DECUMA_API(AttachDictionary)(decumaSession, dictionary->data(), static_cast<DECUMA_UINT32>(dictionary->size()));
return status == decumaNoError;
}
void detachDictionary(const QSharedPointer<T9WriteAbstractDictionary> &dictionary)
{
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
if (!dictionary)
return;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::detachDictionary():" << dictionary->name();
Q_ASSERT(decumaSession != nullptr);
DECUMA_STATUS status = DECUMA_API(DetachDictionary)(decumaSession, dictionary->data());
Q_UNUSED(status);
Q_ASSERT(status == decumaNoError);
}
bool setInputMode(const QLocale &locale, QVirtualKeyboardInputEngine::InputMode inputMode)
{
Q_Q(T9WriteInputMethod);
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::setInputMode():" << locale << inputMode;
finishRecognition();
// All tasks must be completed before changing the session settings
if (worker) {
worker->waitForAllTasks();
dictionaryTask.reset();
}
DECUMA_UINT32 language = mapToDecumaLanguage(locale, inputMode);
if (language == DECUMA_LANG_GSMDEFAULT) {
qCCritical(lcT9Write) << "Language is not supported" << locale.name();
return false;
}
T9WriteInputMethod::EngineMode newEngineMode = mapLocaleToEngineMode(locale, language);
#ifdef HAVE_XT9
xt9Init(locale, inputMode, newEngineMode);
#endif
if (!initEngine(newEngineMode)) {
#ifdef HAVE_XT9
xt9Exit();
#endif
return false;
}
onAvailableDynamicDictionariesChanged();
onActiveDynamicDictionariesChanged();
const Qt::InputMethodHints inputMethodHints = q->inputContext()->inputMethodHints();
if (!inputMethodHints.testFlag(Qt::ImhHiddenText) && !inputMethodHints.testFlag(Qt::ImhNoPredictiveText) &&
!inputMethodHints.testFlag(Qt::ImhSensitiveData)) {
dlmActivate();
}
int isLanguageSupported = 0;
DECUMA_API(DatabaseIsLanguageSupported)(sessionSettings.pStaticDB, language, &isLanguageSupported);
if (!isLanguageSupported) {
qCCritical(lcT9Write) << "Language is not supported" << locale.name();
return false;
}
bool languageChanged = languageCategories.isEmpty() || languageCategories.first() != language;
languageCategories.clear();
languageCategories.append(language);
// Add English as secondary language for non-latin languages.
// T9 Write requires it for punctuation and latin symbols if
// included in the symbol categories.
if (locale.script() != QLocale::LatinScript)
languageCategories.append(DECUMA_LANG_EN);
if (!updateSymbolCategories(language, locale, inputMode))
return false;
updateRecognitionMode(language, locale, inputMode);
static const QList<DECUMA_UINT32> rtlLanguages = QList<DECUMA_UINT32>()
<< DECUMA_LANG_AR << DECUMA_LANG_IW << DECUMA_LANG_FA << DECUMA_LANG_UR;
sessionSettings.writingDirection = rtlLanguages.contains(language) ? rightToLeft : leftToRight;
// Enable multi-threaded recognition if available.
#ifdef DECUMA_USE_MULTI_THREAD
// Note: This feature requires T9 Write v8.0.0 or later,
// and feature enabled in the SDK.
#if CERENCEHANDWRITINGAPIMAJORVERNUM > 28
sessionSettings.bUseThreads = 1;
#else
sessionSettings.nMaxThreads = qMax(QThread::idealThreadCount(), 0);
#endif
#endif
qCDebug(lcT9Write) << " -> language categories:" << languageCategories;
qCDebug(lcT9Write) << " -> symbol categories:" << symbolCategories;
qCDebug(lcT9Write) << " -> recognition mode:" << sessionSettings.recognitionMode;
// Change session settings
sessionSettings.charSet.pSymbolCategories = symbolCategories.data();
sessionSettings.charSet.nSymbolCategories = static_cast<DECUMA_UINT8>(symbolCategories.size());
sessionSettings.charSet.pLanguages = languageCategories.data();
sessionSettings.charSet.nLanguages = static_cast<DECUMA_UINT8>(languageCategories.size());
DECUMA_STATUS status = DECUMA_API(ChangeSessionSettings)(decumaSession, &sessionSettings);
if (status == decumaUnsupportedLanguageInUcrMode || status == decumaUnsupportedSymbolCategoryInUcrMode) {
sessionSettings.recognitionMode = mcrMode;
status = DECUMA_API(ChangeSessionSettings)(decumaSession, &sessionSettings);
}
if (status != decumaNoError)
qCWarning(lcT9Write) << "Failed to configure HWR engine" << status;
caseFormatter.preferLowercase = q->inputContext()->inputMethodHints().testFlag(Qt::ImhPreferLowercase);
updateDictionary(language, locale, languageChanged);
return status == decumaNoError;
}
T9WriteInputMethod::EngineMode mapLocaleToEngineMode(const QLocale &locale, DECUMA_UINT32 language = 0)
{
#ifdef HAVE_CERENCE_HWR_CJK
switch (locale.language()) {
case QLocale::Chinese: {
if (locale.script() == QLocale::TraditionalChineseScript)
return locale.territory() == QLocale::HongKong ? T9WriteInputMethod::EngineMode::HongKongChinese : T9WriteInputMethod::EngineMode::TraditionalChinese;
return T9WriteInputMethod::EngineMode::SimplifiedChinese;
}
case QLocale::Japanese:
return T9WriteInputMethod::EngineMode::Japanese;
case QLocale::Korean:
return T9WriteInputMethod::EngineMode::Korean;
default:
break;
}
#else
Q_UNUSED(locale);
Q_UNUSED(language);
#endif
#ifdef HAVE_CERENCE_HWR_ALPHABETIC
switch (locale.script()) {
case QLocale::ArabicScript:
return T9WriteInputMethod::EngineMode::Arabic;
case QLocale::HebrewScript:
return T9WriteInputMethod::EngineMode::Hebrew;
case QLocale::ThaiScript:
return language == DECUMA_LANG_EN ? T9WriteInputMethod::EngineMode::Alphabetic
: T9WriteInputMethod::EngineMode::Thai;
default:
return T9WriteInputMethod::EngineMode::Alphabetic;
}
#else
return T9WriteInputMethod::EngineMode::Uninitialized;
#endif
}
DECUMA_UINT32 mapToDecumaLanguage(const QLocale &locale, QVirtualKeyboardInputEngine::InputMode inputMode)
{
struct LanguageMap {
QLocale::Language localeLanguage;
DECUMA_UINT16 decumaLanguage;
};
static const LanguageMap languageMap[] = {
{ QLocale::Language::Afrikaans, DECUMA_LANG_AF },
{ QLocale::Language::Albanian, DECUMA_LANG_SQ },
{ QLocale::Language::Arabic, DECUMA_LANG_AR },
{ QLocale::Language::Azerbaijani, DECUMA_LANG_AZ },
{ QLocale::Language::Basque, DECUMA_LANG_EU },
{ QLocale::Language::Belarusian, DECUMA_LANG_BE },
{ QLocale::Language::Bengali, DECUMA_LANG_BN },
{ QLocale::Language::Bulgarian, DECUMA_LANG_BG },
{ QLocale::Language::Catalan, DECUMA_LANG_CA },
{ QLocale::Language::Chinese, DECUMA_LANG_PRC },
{ QLocale::Language::Croatian, DECUMA_LANG_HR },
{ QLocale::Language::Czech, DECUMA_LANG_CS },
{ QLocale::Language::Danish, DECUMA_LANG_DA },
{ QLocale::Language::Dutch, DECUMA_LANG_NL },
{ QLocale::Language::English, DECUMA_LANG_EN },
{ QLocale::Language::Estonian, DECUMA_LANG_ET },
{ QLocale::Language::Finnish, DECUMA_LANG_FI },
{ QLocale::Language::French, DECUMA_LANG_FR },
{ QLocale::Language::Galician, DECUMA_LANG_GL },
{ QLocale::Language::German, DECUMA_LANG_DE },
{ QLocale::Language::Greek, DECUMA_LANG_EL },
{ QLocale::Language::Gujarati, DECUMA_LANG_GU },
{ QLocale::Language::Hausa, DECUMA_LANG_HA },
{ QLocale::Language::Hebrew, DECUMA_LANG_IW },
{ QLocale::Language::Hindi, DECUMA_LANG_HI },
{ QLocale::Language::Hungarian, DECUMA_LANG_HU },
{ QLocale::Language::Icelandic, DECUMA_LANG_IS },
{ QLocale::Language::Indonesian, DECUMA_LANG_IN },
{ QLocale::Language::Italian, DECUMA_LANG_IT },
{ QLocale::Language::Japanese, DECUMA_LANG_JP },
{ QLocale::Language::Kannada, DECUMA_LANG_KN },
{ QLocale::Language::Kazakh, DECUMA_LANG_KK },
{ QLocale::Language::Khmer, DECUMA_LANG_KM },
{ QLocale::Language::Kirghiz, DECUMA_LANG_KY },
{ QLocale::Language::Korean, DECUMA_LANG_KO },
{ QLocale::Language::Latvian, DECUMA_LANG_LV },
{ QLocale::Language::Lithuanian, DECUMA_LANG_LT },
{ QLocale::Language::Macedonian, DECUMA_LANG_MK },
{ QLocale::Language::Malay, DECUMA_LANG_MS },
{ QLocale::Language::Malayalam, DECUMA_LANG_ML },
{ QLocale::Language::Marathi, DECUMA_LANG_MR },
{ QLocale::Language::Mongolian, DECUMA_LANG_MN },
{ QLocale::Language::NorwegianBokmal, DECUMA_LANG_NO },
{ QLocale::Language::Persian, DECUMA_LANG_FA },
{ QLocale::Language::Polish, DECUMA_LANG_PL },
{ QLocale::Language::Portuguese, DECUMA_LANG_PT },
{ QLocale::Language::Punjabi, DECUMA_LANG_PA },
{ QLocale::Language::Romanian, DECUMA_LANG_RO },
{ QLocale::Language::Russian, DECUMA_LANG_RU },
{ QLocale::Language::Serbian, DECUMA_LANG_SRCY },
{ QLocale::Language::Sinhala, DECUMA_LANG_SI },
{ QLocale::Language::Slovak, DECUMA_LANG_SK },
{ QLocale::Language::Slovenian, DECUMA_LANG_SL },
{ QLocale::Language::SouthernSotho, DECUMA_LANG_ST },
{ QLocale::Language::Spanish, DECUMA_LANG_ES },
{ QLocale::Language::Swahili, DECUMA_LANG_SW },
{ QLocale::Language::Swedish, DECUMA_LANG_SV },
{ QLocale::Language::Tajik, DECUMA_LANG_TG },
{ QLocale::Language::Tamil, DECUMA_LANG_TA },
{ QLocale::Language::Telugu, DECUMA_LANG_TE },
{ QLocale::Language::Thai, DECUMA_LANG_TH },
{ QLocale::Language::Turkish, DECUMA_LANG_TR },
{ QLocale::Language::Ukrainian, DECUMA_LANG_UK },
{ QLocale::Language::Urdu, DECUMA_LANG_UR },
{ QLocale::Language::Uzbek, DECUMA_LANG_UZ },
{ QLocale::Language::Vietnamese, DECUMA_LANG_VI },
// Last entry
{ QLocale::Language::AnyLanguage, DECUMA_LANG_GSMDEFAULT }
};
const int localeLanguage = locale.language();
const LanguageMap *languageMapIterator = languageMap;
for (; languageMapIterator->localeLanguage != QLocale::Language::AnyLanguage &&
languageMapIterator->localeLanguage != localeLanguage; languageMapIterator++) {}
DECUMA_UINT32 language = languageMapIterator->decumaLanguage;
if (language == DECUMA_LANG_PRC) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting)
language = DECUMA_LANG_EN;
else if (locale.script() == QLocale::TraditionalChineseScript)
language = DECUMA_LANG_HK; // Common language for the traditional script
} else if (language == DECUMA_LANG_JP) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting)
language = DECUMA_LANG_EN;
} else if (language == DECUMA_LANG_KO) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting)
language = DECUMA_LANG_EN;
} else if (language == DECUMA_LANG_SRCY) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::Cyrillic)
language = DECUMA_LANG_SRLA;
} else if (language == DECUMA_LANG_AR || language == DECUMA_LANG_FA) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::Arabic && inputMode != QVirtualKeyboardInputEngine::InputMode::Numeric)
language = DECUMA_LANG_EN;
} else if (language == DECUMA_LANG_IW) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::Hebrew)
language = DECUMA_LANG_EN;
} else if (language == DECUMA_LANG_TH) {
if (inputMode != QVirtualKeyboardInputEngine::InputMode::Thai)
language = DECUMA_LANG_EN;
}
return language;
}
void updateRecognitionMode(DECUMA_UINT32 language, const QLocale &locale,
QVirtualKeyboardInputEngine::InputMode inputMode)
{
Q_Q(T9WriteInputMethod);
Q_UNUSED(language);
Q_UNUSED(locale);
// Select recognition mode
// Note: MCR mode is preferred, as it does not require recognition
// timer and provides better user experience.
sessionSettings.recognitionMode = mcrMode;
// T9 Write Alphabetic v8.0.0 supports UCR mode for specific languages
if (!cjk) {
switch (inputMode) {
case QVirtualKeyboardInputEngine::InputMode::Latin:
sessionSettings.recognitionMode = ucrMode;
break;
case QVirtualKeyboardInputEngine::InputMode::Arabic:
sessionSettings.recognitionMode = ucrMode;
break;
case QVirtualKeyboardInputEngine::InputMode::Cyrillic:
sessionSettings.recognitionMode = ucrMode;
break;
case QVirtualKeyboardInputEngine::InputMode::Hebrew:
case QVirtualKeyboardInputEngine::InputMode::Thai:
sessionSettings.recognitionMode = ucrMode;
break;
default:
break;
}
}
// Use scrMode with hidden text or with no predictive mode
if (inputMode != QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting) {
const Qt::InputMethodHints inputMethodHints = q->inputContext()->inputMethodHints();
if (inputMethodHints.testFlag(Qt::ImhHiddenText) || inputMethodHints.testFlag(Qt::ImhNoPredictiveText))
sessionSettings.recognitionMode = scrMode;
}
}
bool updateSymbolCategories(DECUMA_UINT32 language, const QLocale &locale,
QVirtualKeyboardInputEngine::InputMode inputMode)
{
// Handle CJK in separate method
if (cjk)
return updateSymbolCategoriesCjk(language, locale, inputMode);
symbolCategories.clear();
// Choose the symbol categories by input mode, script and input method hints
bool leftToRightGestures = true;
Q_Q(T9WriteInputMethod);
const Qt::InputMethodHints inputMethodHints = q->inputContext()->inputMethodHints();
switch (inputMode) {
case QVirtualKeyboardInputEngine::InputMode::Latin:
if (inputMethodHints.testFlag(Qt::ImhEmailCharactersOnly)) {
symbolCategories.append(DECUMA_CATEGORY_EMAIL);
} else if (inputMethodHints.testFlag(Qt::ImhUrlCharactersOnly)) {
symbolCategories.append(DECUMA_CATEGORY_URL);
} else {
if (language == DECUMA_LANG_EN || language == DECUMA_LANG_NL ||
language == DECUMA_LANG_MS || language == DECUMA_LANG_IN)
symbolCategories.append(DECUMA_CATEGORY_ANSI);
else
symbolCategories.append(DECUMA_CATEGORY_ISO8859_1);
symbolCategories.append(DECUMA_CATEGORY_DIGIT);
symbolCategories.append(DECUMA_CATEGORY_BASIC_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_CONTRACTION_MARK);
if (language == DECUMA_LANG_ES)
symbolCategories.append(DECUMA_CATEGORY_SPANISH_PUNCTUATIONS);
else if (language == DECUMA_LANG_VI)
symbolCategories.append(DECUMA_CATEGORY_VIETNAMESE_SUPPLEMENTS);
}
break;
case QVirtualKeyboardInputEngine::InputMode::Numeric:
if (language == DECUMA_LANG_AR || language == DECUMA_LANG_FA) {
symbolCategories.append(DECUMA_CATEGORY_ARABIC_NUM_MODE);
symbolCategories.append(DECUMA_CATEGORY_ARABIC_GESTURES);
leftToRightGestures = false;
break;
}
symbolCategories.append(DECUMA_CATEGORY_DIGIT);
if (!inputMethodHints.testFlag(Qt::ImhDigitsOnly))
symbolCategories.append(DECUMA_CATEGORY_NUM_SUP);
break;
case QVirtualKeyboardInputEngine::InputMode::Dialable:
symbolCategories.append(DECUMA_CATEGORY_PHONE_NUMBER);
break;
case QVirtualKeyboardInputEngine::InputMode::Greek:
symbolCategories.append(DECUMA_CATEGORY_GREEK);
symbolCategories.append(DECUMA_CATEGORY_QUEST_EXCL_MARK_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_PERIOD_COMMA_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_COLON_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_CONTRACTION_MARK);
symbolCategories.append(DECUMA_CATEGORY_CONTRACTION_MARK);
break;
case QVirtualKeyboardInputEngine::InputMode::Cyrillic:
symbolCategories.append(DECUMA_CATEGORY_CYRILLIC);
symbolCategories.append(DECUMA_CATEGORY_QUEST_EXCL_MARK_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_PERIOD_COMMA_PUNCTUATIONS);
// Ukrainian needs contraction mark, but not Russian or Bulgarian
if (language == DECUMA_LANG_UK)
symbolCategories.append(DECUMA_CATEGORY_CONTRACTION_MARK);
break;
case QVirtualKeyboardInputEngine::InputMode::Arabic:
symbolCategories.append(DECUMA_CATEGORY_ARABIC_ISOLATED_LETTER_MODE);
symbolCategories.append(DECUMA_CATEGORY_ARABIC_GESTURES);
leftToRightGestures = false;
break;
case QVirtualKeyboardInputEngine::InputMode::Hebrew:
symbolCategories.append(DECUMA_CATEGORY_HEBREW_GL_HEBREW_CURSIVE_MODE);
symbolCategories.append(DECUMA_CATEGORY_HEBREW_GL_HEBREW_LETTERSYMBOLS);
symbolCategories.append(DECUMA_CATEGORY_HEBREW_SHEQEL);
symbolCategories.append(DECUMA_CATEGORY_ARABIC_GESTURES);
leftToRightGestures = false;
break;
case QVirtualKeyboardInputEngine::InputMode::Thai:
symbolCategories.append(DECUMA_CATEGORY_THAI_BASE);
symbolCategories.append(DECUMA_CATEGORY_THAI_NON_BASE);
break;
default:
qCCritical(lcT9Write) << "Invalid input mode" << inputMode;
return false;
}
if (leftToRightGestures) {
symbolCategories.append(DECUMA_CATEGORY_BACKSPACE_STROKE);
symbolCategories.append(DECUMA_CATEGORY_RETURN_STROKE);
symbolCategories.append(DECUMA_CATEGORY_WHITESPACE_STROKE);
}
return true;
}
bool updateSymbolCategoriesCjk(DECUMA_UINT32 language, const QLocale &locale,
QVirtualKeyboardInputEngine::InputMode inputMode)
{
Q_ASSERT(cjk);
symbolCategories.clear();
switch (inputMode) {
case QVirtualKeyboardInputEngine::InputMode::Latin:
symbolCategories.append(DECUMA_CATEGORY_ANSI);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
symbolCategories.append(DECUMA_CATEGORY_PUNCTUATIONS);
break;
case QVirtualKeyboardInputEngine::InputMode::Numeric:
symbolCategories.append(DECUMA_CATEGORY_DIGIT);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
symbolCategories.append(DECUMA_CATEGORY_PUNCTUATIONS);
break;
case QVirtualKeyboardInputEngine::InputMode::Dialable:
symbolCategories.append(DECUMA_CATEGORY_DIGIT);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
break;
case QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting:
switch (locale.script()) {
case QLocale::SimplifiedChineseScript:
symbolCategories.append(DECUMA_CATEGORY_GB2312_A);
symbolCategories.append(DECUMA_CATEGORY_GB2312_B_CHARS_ONLY);
symbolCategories.append(DECUMA_CATEGORY_GBK_3);
symbolCategories.append(DECUMA_CATEGORY_GBK_4);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
symbolCategories.append(DECUMA_CATEGORY_CJK_GENERAL_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_PUNCTUATIONS);
#ifdef HAVE_XT9
if (xt9Ime) {
symbolCategories.append(DECUMA_CATEGORY_ANSI);
}
#endif
break;
case QLocale::TraditionalChineseScript:
symbolCategories.append(DECUMA_CATEGORY_BIGFIVE);
if (language == DECUMA_LANG_HK)
symbolCategories.append(DECUMA_CATEGORY_HKSCS_CHARS_ONLY);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
symbolCategories.append(DECUMA_CATEGORY_CJK_GENERAL_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_PUNCTUATIONS);
break;
default:
qCCritical(lcT9Write) << "Invalid locale" << locale << "for" << engineModeToString(engineMode);
return false;
}
break;
case QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting:
symbolCategories.append(DECUMA_CATEGORY_JIS_LEVEL_1);
symbolCategories.append(DECUMA_CATEGORY_JIS_LEVEL_2);
symbolCategories.append(DECUMA_CATEGORY_HIRAGANA);
symbolCategories.append(DECUMA_CATEGORY_KATAKANA);
symbolCategories.append(DECUMA_CATEGORY_HIRAGANASMALL);
symbolCategories.append(DECUMA_CATEGORY_KATAKANASMALL);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
symbolCategories.append(DECUMA_CATEGORY_CJK_GENERAL_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_PUNCTUATIONS);
#ifdef HAVE_XT9
if (xt9Ime) {
symbolCategories.append(DECUMA_CATEGORY_ANSI);
}
#endif
break;
case QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting:
symbolCategories.append(DECUMA_CATEGORY_HANGUL_1001_A);
symbolCategories.append(DECUMA_CATEGORY_HANGUL_1001_B);
symbolCategories.append(DECUMA_CATEGORY_CJK_SYMBOL);
symbolCategories.append(DECUMA_CATEGORY_CJK_GENERAL_PUNCTUATIONS);
symbolCategories.append(DECUMA_CATEGORY_PUNCTUATIONS);
break;
default:
return false;
}
return true;
}
void updateDictionary(DECUMA_UINT32 language, const QLocale &locale, bool languageChanged)
{
Q_Q(T9WriteInputMethod);
/* The dictionary is loaded in the background thread. Once the loading is
complete the dictionary will be attached to the current session. The
attachment happens in the worker thread context, thus the direct
connection for the signal handler and the mutex protecting the
converted dictionary for concurrent access.
The loading operation is blocking for the main thread only if the
user starts handwriting input before the operation is complete.
*/
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
// Detach previous dictionary if the language is being changed
// or the recognizer mode is single-character mode
const Qt::InputMethodHints inputMethodHints = q->inputContext()->inputMethodHints();
if ((languageChanged || inputMethodHints.testFlag(Qt::ImhNoPredictiveText) || sessionSettings.recognitionMode == scrMode) && attachedDictionary) {
detachDictionary(attachedDictionary);
attachedDictionary.reset();
}
// Check if a dictionary needs to be loaded
if (languageChanged || !loadedDictionary) {
loadedDictionary.reset();
DECUMA_SRC_DICTIONARY_INFO dictionaryInfo;
memset(&dictionaryInfo, 0, sizeof(dictionaryInfo));
QList<QLocale> decumaLocales;
decumaLocales.append(locale);
// CJK: No dictionary for latin input
if (cjk && language == DECUMA_LANG_EN)
decumaLocales.clear();
dictionaryFileName.clear();
QLocale decumaLocale;
for (const QLocale &tryLocale : decumaLocales) {
dictionaryFileName = findDictionary(tryLocale, dictionaryInfo.srcType);
if (!dictionaryFileName.isEmpty()) {
decumaLocale = tryLocale;
break;
}
}
if (!dictionaryFileName.isEmpty()) {
if (dictionaryTask.isNull() || dictionaryTask->dictionaryFileName != dictionaryFileName) {
qCDebug(lcT9Write) << " -> load dictionary:" << dictionaryFileName;
bool convertDictionary = true;
#if defined(HAVE_CERENCE_HWR_CJK)
// Chinese dictionary cannot be converted (PHD)
if (dictionaryInfo.srcType == decumaPortableHWRDictionary && decumaLocale.language() == QLocale::Chinese)
convertDictionary = false;
#endif
QSharedPointer<T9WriteAbstractSource> sourceDictionary(new T9WriteFileSource(dictionaryInfo, dictionaryFileName));
QSharedPointer<T9WriteDictionary> newDictionary(new T9WriteDictionary(sourceDictionary, decumaSession, memFuncs, cjk));
dictionaryTask.reset(new T9WriteDictionaryTask(newDictionary, convertDictionary));
QObjectPrivate::connect(dictionaryTask.data(), &T9WriteDictionaryTask::completed,
this, &T9WriteInputMethodPrivate::dictionaryLoadCompleted, Qt::DirectConnection);
worker->addTask(dictionaryTask);
}
}
}
// Attach existing dictionary, if available
if (sessionSettings.recognitionMode != scrMode && !inputMethodHints.testFlag(Qt::ImhNoPredictiveText) &&
loadedDictionary && !attachedDictionary) {
if (attachDictionary(loadedDictionary))
attachedDictionary = loadedDictionary;
}
}
QByteArray getContext(QVirtualKeyboardInputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo,
const QVariantMap &traceScreenInfo) const
{
QCryptographicHash hash(QCryptographicHash::Md5);
hash.addData(QByteArrayView(reinterpret_cast<const char *>(&patternRecognitionMode), sizeof(patternRecognitionMode)));
QByteArray mapData;
QDataStream ds(&mapData, QIODevice::WriteOnly);
ds << traceCaptureDeviceInfo;
ds << traceScreenInfo;
hash.addData(mapData);
return hash.result();
}
void setContext(QVirtualKeyboardInputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo,
const QVariantMap &traceScreenInfo,
const QByteArray &context)
{
Q_UNUSED(patternRecognitionMode);
Q_UNUSED(traceScreenInfo);
if (context == currentContext)
return;
currentContext = context;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::setContext():" << QLatin1String((context.toHex()));
// Finish recognition, but preserve current input
Q_Q(T9WriteInputMethod);
QString preeditText = q->inputContext()->preeditText();
bool preserveCurrentInput = !preeditText.isEmpty();
T9WriteCaseFormatter oldCaseFormatter(caseFormatter);
finishRecognition(!preserveCurrentInput);
if (preserveCurrentInput) {
caseFormatter = oldCaseFormatter;
stringStart = preeditText;
wordCandidates.append(T9WriteWordCandidate(preeditText));
activeWordIndex = 0;
emit q->selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit q->selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, activeWordIndex);
}
const int dpi = traceCaptureDeviceInfo.value(QLatin1String("dpi"), 96).toInt();
static const int INSTANT_GESTURE_WIDTH_THRESHOLD_MM = 25;
gestureWidthThreshold = static_cast<DECUMA_UINT32>(INSTANT_GESTURE_WIDTH_THRESHOLD_MM / 25.4 * dpi);
gestureRecognizer.setDpi(dpi);
sessionSettings.baseline = 0;
sessionSettings.helpline = 0;
sessionSettings.topline = 0;
sessionSettings.supportLineSet = baselineAndHelpline;
sessionSettings.UIInputGuide = none;
DECUMA_STATUS status = DECUMA_API(ChangeSessionSettings)(decumaSession, &sessionSettings);
Q_ASSERT(status == decumaNoError);
}
QVirtualKeyboardTrace *traceBegin(
int traceId, QVirtualKeyboardInputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo, const QVariantMap &traceScreenInfo)
{
if (!worker)
return nullptr;
// The result id follows the trace id so that the (previous)
// results completed during the handwriting can be rejected.
resultId = traceId;
stopResultTimer();
// Dictionary must be completed before the arc addition can begin
worker->waitForAllTasksOfType<T9WriteDictionaryTask>();
dictionaryTask.reset();
// Cancel the current recognition task
worker->removeAllTasks<T9WriteRecognitionResultsTask>();
worker->removeAllTasks<T9WriteRecognitionTask>();
if (recognitionTask) {
recognitionTask->cancelRecognition();
recognitionTask.reset();
}
// Check for hard limit on the size the trace list
if (traceList.size() >= traceListHardLimit) {
worker->waitForAllTasksOfType<T9WriteAddArcTask>();
while (traceListHardLimit < traceList.size())
delete traceList.takeFirst();
}
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
if (!unipenTrace)
unipenTrace.reset(new UnipenTrace(traceCaptureDeviceInfo, traceScreenInfo));
#endif
QByteArray context = getContext(patternRecognitionMode, traceCaptureDeviceInfo, traceScreenInfo);
if (context != currentContext) {
worker->waitForAllTasks();
setContext(patternRecognitionMode, traceCaptureDeviceInfo, traceScreenInfo, context);
}
DECUMA_STATUS status;
if (!arcAdditionStarted) {
worker->waitForAllTasks();
DECUMA_RECOGNITION_SETTINGS recSettings;
memset(&recSettings, 0, sizeof(recSettings));
// Boost dictionary words by default
recSettings.boostLevel = attachedDictionary || attachedDynamicDictionaries.size() > 0 ? boostDictWords : noBoost;
// Disable dictionary boost in UCR mode for URL and E-mail input
// Otherwise it will completely mess input
Q_Q(T9WriteInputMethod);
const Qt::InputMethodHints inputMethodHints = q->inputContext()->inputMethodHints();
if (sessionSettings.recognitionMode == ucrMode && (inputMethodHints & (Qt::ImhUrlCharactersOnly | Qt::ImhEmailCharactersOnly)))
recSettings.boostLevel = noBoost;
recSettings.stringCompleteness = canBeContinued;
if (!stringStart.isEmpty())
recSettings.pStringStart = const_cast<DECUMA_UNICODE *>(stringStart.utf16());
status = DECUMA_API(BeginArcAddition)(decumaSession, &recSettings);
Q_ASSERT(status == decumaNoError);
arcAdditionStarted = true;
}
Q_Q(T9WriteInputMethod);
QVirtualKeyboardTrace *trace = new QVirtualKeyboardTrace(q);
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
trace->setChannels(QStringList(QLatin1String("t")));
#endif
traceList.append(trace);
return trace;
}
void traceEnd(QVirtualKeyboardTrace *trace)
{
if (trace->isCanceled()) {
traceList.removeOne(trace);
delete trace;
} else {
if (cjk && countActiveTraces() == 0) {
// For some reason gestures don't seem to work in CJK mode
// Using our own gesture recognizer as fallback
if (handleGesture())
return;
}
worker->addTask(QSharedPointer<T9WriteAddArcTask>(new T9WriteAddArcTask(trace)));
}
if (!traceList.isEmpty()) {
Q_ASSERT(arcAdditionStarted);
if (countActiveTraces() == 0)
restartRecognition();
}
}
int countActiveTraces() const
{
int count = 0;
for (QVirtualKeyboardTrace *trace : std::as_const(traceList)) {
if (!trace->isFinal())
count++;
}
return count;
}
void clearTraces()
{
worker->waitForAllTasks();
qDeleteAll(traceList);
traceList.clear();
}
void noteSelected(int index)
{
if (index < 0 || index >= wordCandidates.size())
return;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::noteSelected():" << index;
const T9WriteWordCandidate &wordCandidate = wordCandidates[index];
switch (wordCandidate.origin) {
case T9WriteWordCandidate::Origin::T9Write:
DECUMA_API(NoteSelectedCandidate)(decumaSession, wordCandidate.resultIndex);
break;
#ifdef HAVE_XT9
case T9WriteWordCandidate::Origin::XT9:
{
Xt9AwIme *xt9AwIme = static_cast<Xt9AwIme *>(xt9Ime.data());
if (xt9AwIme) {
xt9AwIme->noteWordDone(wordCandidate.symbs);
xt9AwIme->selectWord(wordCandidate.resultIndex, true);
}
break;
}
#endif
default:
break;
}
}
void restartRecognition()
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::restartRecognition()";
worker->removeAllTasks<T9WriteRecognitionResultsTask>();
if (recognitionTask) {
recognitionTask->cancelRecognition();
recognitionTask.reset();
}
QSharedPointer<T9WriteRecognitionResult> recognitionResult(new T9WriteRecognitionResult(resultId, 9, 64));
recognitionTask.reset(new T9WriteRecognitionTask(recognitionResult));
worker->addTask(recognitionTask);
QSharedPointer<T9WriteRecognitionResultsTask> resultsTask(new T9WriteRecognitionResultsTask(recognitionResult));
QObjectPrivate::connect(resultsTask.data(), &T9WriteRecognitionResultsTask::resultsAvailable, this, &T9WriteInputMethodPrivate::setResultList, Qt::DirectConnection);
worker->addTask(resultsTask);
resetResultTimer(cjk ? Settings::instance()->hwrTimeoutForCjk() : Settings::instance()->hwrTimeoutForAlphabetic());
}
void waitForRecognitionResults()
{
if (!worker)
return;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::waitForRecognitionResults()";
worker->waitForAllTasks();
processResultCheckTimer();
}
bool finishRecognition(bool emitSelectionListChanged = true)
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::finishRecognition()";
if (!worker)
return false;
bool result = !traceList.isEmpty();
Q_ASSERT(decumaSession != nullptr);
stopResultTimer();
worker->removeAllTasks<T9WriteAddArcTask>();
worker->removeAllTasks<T9WriteRecognitionResultsTask>();
if (recognitionTask) {
recognitionTask->cancelRecognition();
recognitionTask.reset();
result = true;
}
worker->waitForAllTasks();
clearTraces();
if (arcAdditionStarted) {
DECUMA_API(EndArcAddition)(decumaSession);
arcAdditionStarted = false;
}
if (!wordCandidates.isEmpty()) {
wordCandidates.clear();
activeWordIndex = -1;
if (emitSelectionListChanged) {
Q_Q(T9WriteInputMethod);
emit q->selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit q->selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, activeWordIndex);
}
result = true;
}
stringStart.clear();
scrResult.clear();
caseFormatter.clear();
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
unipenTrace.reset();
#endif
return result;
}
bool select(int index = -1)
{
if (!worker)
return false;
if (sessionSettings.recognitionMode != scrMode && wordCandidates.isEmpty()) {
finishRecognition();
return false;
}
if (sessionSettings.recognitionMode == scrMode && scrResult.isEmpty()) {
finishRecognition();
return false;
}
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::select():" << index;
Q_Q(T9WriteInputMethod);
if (sessionSettings.recognitionMode != scrMode) {
index = index >= 0 ? index : activeWordIndex;
noteSelected(index);
QString finalWord = wordCandidates.at(index).symbs;
dlmAddWord(finalWord);
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
// Record trace
if (unipenTrace) {
if (finalWord.length() == 1) {
// In recording mode, the text case must match with the current text case
QChar ch(finalWord.at(0));
if (!ch.isLetter() || (ch.isUpper() == (textCase == QVirtualKeyboardInputEngine::TextCase::Upper))) {
QStringList homeLocations = QStandardPaths::standardLocations(QStandardPaths::HomeLocation);
if (!homeLocations.isEmpty()) {
unipenTrace->setDirectory(QStringLiteral("%1/%2").arg(homeLocations.at(0)).arg(QLatin1String("VIRTUAL_KEYBOARD_TRACES")));
unipenTrace->record(traceList);
unipenTrace->save(ch.unicode(), 100);
}
}
}
}
#endif
finishRecognition();
QChar gesture = T9WriteInputMethodPrivate::mapSymbolToGesture(finalWord.right(1).at(0));
if (!gesture.isNull())
finalWord.chop(1);
q->inputContext()->commit(finalWord);
applyGesture(gesture);
} else if (sessionSettings.recognitionMode == scrMode) {
QString finalWord = scrResult;
finishRecognition();
q->inputContext()->inputEngine()->virtualKeyClick(static_cast<Qt::Key>(finalWord.at(0).unicode()), finalWord, Qt::NoModifier);
}
return true;
}
void resetResultTimer(int interval = 500)
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::resetResultTimer():" << interval;
Q_Q(T9WriteInputMethod);
stopResultTimer();
resultTimer = q->startTimer(interval);
}
void stopResultTimer()
{
if (resultTimer) {
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::stopResultTimer()";
Q_Q(T9WriteInputMethod);
q->killTimer(resultTimer);
resultTimer = 0;
}
}
void dictionaryLoadCompleted(QSharedPointer<T9WriteAbstractDictionary> dictionary)
{
// Note: This method is called in worker thread context
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
if (!dictionary)
return;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::dictionaryLoadCompleted():"
<< dictionary->name() << dictionary->data() << dictionary->size();
Q_Q(T9WriteInputMethod);
QVirtualKeyboardInputContext *ic = q->inputContext();
if (ic && dictionary->name() == dictionaryFileName) {
loadedDictionary = dictionary;
if (sessionSettings.recognitionMode != scrMode &&
!ic->inputMethodHints().testFlag(Qt::ImhNoPredictiveText) &&
!attachedDictionary) {
if (attachDictionary(loadedDictionary))
attachedDictionary = loadedDictionary;
}
}
}
void recognitionError(int status)
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::recognitionError():" << status;
Q_Q(T9WriteInputMethod);
q->reset();
}
// Note: Called from T9WriteWorker thread!
void setResultList(const QVariantList &resultList)
{
{
const std::lock_guard<QRecursiveMutex> ListGuard(resultListLock);
this->resultList = resultList;
}
Q_Q(T9WriteInputMethod);
emit q->resultListChanged();
}
void processResultCheckTimer()
{
bool resultTimerWasRunning = resultTimer != 0;
processResult();
// Restart the result timer now if it stopped before the results were completed
if (!resultTimerWasRunning && (!scrResult.isEmpty() || !wordCandidates.isEmpty()))
resetResultTimer(0);
}
void processResult()
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::processResult()";
#ifdef SENSITIVE_DEBUG
if (lcT9Write().isDebugEnabled()) {
const std::lock_guard<QRecursiveMutex> resultListGuard(resultListLock);
for (int i = 0; i < resultList.size(); i++) {
QVariantMap result = resultList.at(i).toMap();
QString resultPrint = QStringLiteral("%1: ").arg(i + 1);
QString resultChars = result.value(QLatin1String("chars")).toString();
if (!resultChars.isEmpty())
resultPrint.append(resultChars);
if (result.contains(QLatin1String("gesture"))) {
if (!resultChars.isEmpty())
resultPrint.append(QLatin1String(", "));
QString gesture = result[QLatin1String("gesture")].toString();
resultPrint.append(QLatin1String("gesture ="));
for (const QChar &chr : gesture) {
resultPrint.append(QString::fromLatin1(" 0x%1").arg(chr.unicode(), 0, 16));
}
}
qCDebug(lcT9Write) << resultPrint.toUtf8().constData();
}
}
#endif
Q_Q(T9WriteInputMethod);
QVirtualKeyboardInputContext *ic = q->inputContext();
if (!ic)
return;
#ifdef HAVE_XT9
int xt9DefaultListIndex = 0;
QStringList xt9Candidates;
#endif
QList<T9WriteWordCandidate> newWordCandidates;
int newActiveWordIndex = -1;
QString resultString;
QString gesture;
QVariantList symbolStrokes;
{
const std::lock_guard<QRecursiveMutex> resultListGuard(resultListLock);
if (resultList.isEmpty())
return;
if (resultList.first().toMap()[QLatin1String("resultId")] != resultId) {
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::processResult(): resultId mismatch" << resultList.first().toMap()[QLatin1String("resultId")] << "(" << resultId << ")";
resultList.clear();
return;
}
lastResultId = resultId;
for (int i = 0; i < resultList.size(); i++) {
QVariantMap result = resultList.at(i).toMap();
QString resultChars = result[QLatin1String("chars")].toString();
if (i == 0) {
if (ic->isShiftActive()) {
caseFormatter.ensureLength(1, textCase);
caseFormatter.ensureLength(resultChars.length(), QVirtualKeyboardInputEngine::TextCase::Lower);
} else {
caseFormatter.ensureLength(resultChars.length(), textCase);
}
}
if (!resultChars.isEmpty()) {
resultChars = caseFormatter.formatString(resultChars);
if (sessionSettings.recognitionMode != scrMode && !newWordCandidates.contains(T9WriteWordCandidate(resultChars))) {
newWordCandidates.append(T9WriteWordCandidate(resultChars, i, T9WriteWordCandidate::Origin::T9Write));
}
}
if (i == 0) {
resultString = resultChars;
if (result.contains(QLatin1String("gesture")))
gesture = result[QLatin1String("gesture")].toString();
if (sessionSettings.recognitionMode != scrMode && result.contains(QLatin1String("symbolStrokes")))
symbolStrokes = result[QLatin1String("symbolStrokes")].toList();
if (sessionSettings.recognitionMode == scrMode)
break;
#ifdef HAVE_XT9
xt9Candidates = xt9BuildSelectionList(resultString, &xt9DefaultListIndex);
#endif
} else {
// Add a gesture symbol to the secondary candidate
if (sessionSettings.recognitionMode != scrMode && result.contains(QLatin1String("gesture"))) {
QString gesture2 = result[QLatin1String("gesture")].toString();
if (gesture2.length() == 1) {
QChar symbol = T9WriteInputMethodPrivate::mapGestureToSymbol(gesture2.at(0).unicode());
if (!symbol.isNull()) {
// Check for duplicates
bool duplicateFound = false;
for (const T9WriteWordCandidate &wordCandidate : newWordCandidates) {
duplicateFound = wordCandidate.symbs.size() == 1 && wordCandidate.symbs.at(0) == symbol;
if (duplicateFound)
break;
}
if (!duplicateFound) {
if (!resultChars.isEmpty()) {
newWordCandidates.last().symbs.append(symbol);
} else {
newWordCandidates.append(T9WriteWordCandidate(symbol, i, T9WriteWordCandidate::Origin::T9Write));
}
}
}
}
}
#ifdef HAVE_XT9
if (i >= 2 && !xt9Candidates.isEmpty())
break;
#endif
}
}
resultList.clear();
if (!newWordCandidates.isEmpty())
newActiveWordIndex = 0;
#ifdef HAVE_XT9
if (!xt9Candidates.isEmpty())
appendWordCandidates(newWordCandidates, newActiveWordIndex, resultString, xt9Candidates, xt9DefaultListIndex, T9WriteWordCandidate::Origin::XT9);
#endif
}
bool wordCandidatesChanged = true;
#ifndef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
// Delete trace history
// Note: We have to be sure there are no background tasks
// running since the QVirtualKeyboardTrace objects consumed there.
if (worker->numberOfPendingTasks() == 0) {
const QVirtualKeyboardInputEngine::InputMode inputMode = q->inputEngine()->inputMode();
if (sessionSettings.recognitionMode != scrMode &&
inputMode != QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting) {
const int hwrTimeout = cjk ?
Settings::instance()->hwrTimeoutForCjk() :
Settings::instance()->hwrTimeoutForAlphabetic();
for (int traceIndex = 0; traceIndex < traceList.size();) {
QVirtualKeyboardTrace *trace = traceList.at(traceIndex);
if (trace->opacity() > 0) {
trace->startHideTimer(hwrTimeout);
++traceIndex;
} else {
traceList.removeAt(traceIndex);
delete trace;
}
}
}
// Enforce hard limit for number of traces
if (traceList.size() >= traceListHardLimit) {
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::processResult(): Clearing traces (hard limit):" << traceList.size();
clearTraces();
}
}
#endif
// Find a gesture at the end of the first result
if (!gesture.isEmpty()) {
DECUMA_UNICODE gestureSymbol = gesture.at(0).unicode();
if (!applyGesture(gestureSymbol)) {
ic->commit(ic->preeditText());
finishRecognition();
}
return;
}
if (sessionSettings.recognitionMode != scrMode) {
ignoreUpdate = true;
ic->setPreeditText(resultString);
ignoreUpdate = false;
} else {
scrResult = resultString;
}
if (wordCandidatesChanged) {
wordCandidates = newWordCandidates;
activeWordIndex = wordCandidates.isEmpty() ? -1 : newActiveWordIndex;
emit q->selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit q->selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, activeWordIndex);
}
if (arcAdditionStarted && traceList.isEmpty() && worker->numberOfPendingTasks() == 0) {
DECUMA_API(EndArcAddition)(decumaSession);
arcAdditionStarted = false;
}
}
static QChar mapGestureToSymbol(const QChar &gesture)
{
switch (gesture.unicode()) {
case '\r':
return QChar(0x23CE);
case ' ':
return QChar(0x2423);
default:
return QChar();
}
}
static QChar mapSymbolToGesture(const QChar &symbol)
{
switch (symbol.unicode()) {
case 0x23CE:
return QLatin1Char('\r');
case 0x2423:
return QLatin1Char(' ');
default:
return QChar();
}
}
bool applyGesture(const QChar &gesture)
{
Q_Q(T9WriteInputMethod);
QVirtualKeyboardInputContext *ic = q->inputContext();
switch (gesture.unicode()) {
case '\b':
return ic->inputEngine()->virtualKeyClick(Qt::Key_Backspace, QString(), Qt::NoModifier);
case '\r':
return ic->inputEngine()->virtualKeyClick(Qt::Key_Return, QLatin1String("\n"), Qt::NoModifier);
case ' ':
return ic->inputEngine()->virtualKeyClick(Qt::Key_Space, QLatin1String(" "), Qt::NoModifier);
default:
return false;
}
}
bool handleGesture()
{
if (countActiveTraces() > 0)
return false;
QVariantMap gesture(gestureRecognizer.recognize(traceList.mid(traceList.size() - 1, 1)));
if (gesture.isEmpty())
return false;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::handleGesture():" << gesture;
if (gesture[QLatin1String("type")].toString() == QLatin1String("swipe")) {
static const int SWIPE_ANGLE_THRESHOLD = 15; // degrees +-
qreal swipeLength = gesture[QLatin1String("length")].toReal();
if (swipeLength >= gestureWidthThreshold) {
Q_Q(T9WriteInputMethod);
QVirtualKeyboardInputContext *ic = q->inputContext();
if (!ic)
return false;
qreal swipeAngle = gesture[QLatin1String("angle_degrees")].toReal();
int swipeTouchCount = gesture[QLatin1String("touch_count")].toInt();
// Swipe left
if (swipeAngle <= 180 + SWIPE_ANGLE_THRESHOLD && swipeAngle >= 180 - SWIPE_ANGLE_THRESHOLD) {
if (swipeTouchCount == 1) {
// Single swipe: backspace
ic->inputEngine()->virtualKeyClick(Qt::Key_Backspace, QString(), Qt::NoModifier);
return true;
}
return false;
}
// Swipe right
const QVirtualKeyboardInputEngine::InputMode inputMode = q->inputEngine()->inputMode();
if (inputMode != QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting) {
if (swipeAngle <= SWIPE_ANGLE_THRESHOLD || swipeAngle >= 360 - SWIPE_ANGLE_THRESHOLD) {
if (swipeTouchCount == 1) {
// Single swipe: space
ic->inputEngine()->virtualKeyClick(Qt::Key_Space, QLatin1String(" "), Qt::NoModifier);
return true;
}
return false;
}
}
// Swipe up
if (swipeAngle <= 270 + SWIPE_ANGLE_THRESHOLD && swipeAngle >= 270 - SWIPE_ANGLE_THRESHOLD) {
if (swipeTouchCount == 1) {
// Single swipe: toggle input mode
select();
if (!(ic->inputMethodHints() & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly))) {
QList<int> inputModes = ic->inputEngine()->inputModes();
// Filter out duplicate numeric mode (in favor of Numeric)
int indexOfNumericInputMode = inputModes.indexOf(static_cast<const int>(QVirtualKeyboardInputEngine::InputMode::Numeric));
int indexOfDialableInputMode = inputModes.indexOf(static_cast<const int>(QVirtualKeyboardInputEngine::InputMode::Dialable));
if (indexOfNumericInputMode != -1 && indexOfDialableInputMode != -1)
inputModes.removeAt(inputMode != QVirtualKeyboardInputEngine::InputMode::Dialable ?
indexOfDialableInputMode :
indexOfNumericInputMode);
if (inputModes.size() > 1) {
int inputModeIndex = inputModes.indexOf(static_cast<const int>(inputMode)) + 1;
if (inputModeIndex >= inputModes.size())
inputModeIndex = 0;
ic->inputEngine()->setInputMode(static_cast<QVirtualKeyboardInputEngine::InputMode>(inputModes.at(inputModeIndex)));
}
}
return true;
}
}
}
}
return false;
}
bool isValidInputChar(const QChar &c) const
{
if (c.isLetterOrNumber())
return true;
if (isJoiner(c))
return true;
return false;
}
bool isJoiner(const QChar &c) const
{
if (c.isPunct() || c.isSymbol()) {
Q_Q(const T9WriteInputMethod);
QVirtualKeyboardInputContext *ic = q->inputContext();
if (ic) {
Qt::InputMethodHints inputMethodHints = ic->inputMethodHints();
if (inputMethodHints.testFlag(Qt::ImhUrlCharactersOnly) || inputMethodHints.testFlag(Qt::ImhEmailCharactersOnly))
return QString(QStringLiteral(":/?#[]@!$&'()*+,;=-_.%")).contains(c);
}
ushort unicode = c.unicode();
if (unicode == Qt::Key_Apostrophe || unicode == Qt::Key_Minus)
return true;
}
return false;
}
void onAvailableDynamicDictionariesChanged()
{
if (!worker)
return;
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
QVirtualKeyboardDictionaryManager *dictionaryManager = QVirtualKeyboardDictionaryManager::instance();
const QStringList availableDictionaries = dictionaryManager->availableDictionaries();
for (const QString &dictionaryName : availableDictionaries) {
if (!dynamicDictionaries.contains(dictionaryName)) {
DECUMA_SRC_DICTIONARY_INFO sourceInfo;
sourceInfo.srcType = decumaTextList;
sourceInfo.bNoFrequencyRanking = 1;
sourceInfo.multiStepWordSeparator = 0;
QSharedPointer<T9WriteAbstractSource> sourceDictionary(
new T9WriteStringSource(
sourceInfo,
dictionaryManager->dictionary(dictionaryName)->contents(),
dictionaryName));
QSharedPointer<T9WriteDictionary> dynamicDictionary(
new T9WriteDictionary(
sourceDictionary,
decumaSession,
memFuncs,
cjk));
dynamicDictionaries[dictionaryName] = dynamicDictionary;
QSharedPointer<T9WriteDictionaryTask> dynamicDictionaryTask(
new T9WriteDictionaryTask(
dynamicDictionary,
true));
Q_Q(T9WriteInputMethod);
q->connect(dynamicDictionaryTask.data(),
&T9WriteDictionaryTask::completed,
[=](QSharedPointer<T9WriteAbstractDictionary> dynamicDictionary) {
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
if (dynamicDictionary->data()) {
if (dictionaryManager->activeDictionaries().contains(dictionaryName) &&
!attachedDynamicDictionaries.contains(dictionaryName) &&
attachDictionary(dynamicDictionary))
attachedDynamicDictionaries[dictionaryName] = dynamicDictionary;
} else {
dynamicDictionaries.remove(dictionaryName);
}
});
worker->addTask(dynamicDictionaryTask);
}
#ifdef HAVE_XT9
if (!xt9DynamicDictionaries.contains(dictionaryName)) {
if (xt9Ime) {
QVirtualKeyboardDictionary *dictionary = dictionaryManager->dictionary(dictionaryName);
const quint16 id = static_cast<quint16>(xt9DynamicDictionaryNextId.fetchAndAddRelaxed(1));
xt9DynamicDictionaries[dictionaryName] = id;
xt9Ime->updateIndex(id, dictionary->contents());
Q_Q(T9WriteInputMethod);
q->connect(dictionary, &QVirtualKeyboardDictionary::contentsChanged, q, [=]() {
xt9Ime->updateIndex(id, dictionary->contents());
if (xt9AttachedDynamicDictionaries.contains(dictionaryName))
xt9Ime->mountIndex(id);
});
}
}
#endif
}
}
void onActiveDynamicDictionariesChanged()
{
if (!worker)
return;
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
QVirtualKeyboardDictionaryManager *dictionaryManager = QVirtualKeyboardDictionaryManager::instance();
// Attach
const QStringList activeDictionaries = dictionaryManager->activeDictionaries();
for (const QString &dictionaryName : activeDictionaries) {
QSharedPointer<T9WriteAbstractDictionary> dynamicDictionary = dynamicDictionaries.value(dictionaryName);
if (dynamicDictionary && dynamicDictionary->data() &&
!attachedDynamicDictionaries.contains(dictionaryName) &&
dynamicDictionary->isCompleted() &&
attachDictionary(dynamicDictionary)) {
attachedDynamicDictionaries[dictionaryName] = dynamicDictionary;
}
#ifdef HAVE_XT9
if (xt9Ime) {
if (!xt9AttachedDynamicDictionaries.contains(dictionaryName)) {
xt9AttachDictionary(dictionaryName);
}
}
#endif
}
// Detach
const QStringList attachedDynamicDictionariesKeys = attachedDynamicDictionaries.keys();
for (const QString &dictionaryName : attachedDynamicDictionariesKeys) {
if (!activeDictionaries.contains(dictionaryName)) {
if (attachedDynamicDictionaries.contains(dictionaryName)) {
detachDictionary(attachedDynamicDictionaries[dictionaryName]);
attachedDynamicDictionaries.remove(dictionaryName);
}
}
}
#ifdef HAVE_XT9
// Detach (XT9)
if (xt9Ime) {
const QStringList xt9AttachedDynamicDictionariesKeys = xt9AttachedDynamicDictionaries.keys();
for (const QString &dictionaryName : xt9AttachedDynamicDictionariesKeys) {
if (!activeDictionaries.contains(dictionaryName)) {
xt9DetachDictionary(dictionaryName);
}
}
}
#endif
}
bool isDlmActive()
{
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
return !loadedDlmDictionary.isNull();
}
QString dlmFileName() const
{
QString suffix;
switch (engineMode) {
case T9WriteInputMethod::EngineMode::Alphabetic:
case T9WriteInputMethod::EngineMode::Arabic:
case T9WriteInputMethod::EngineMode::Hebrew:
case T9WriteInputMethod::EngineMode::Thai:
suffix = QStringLiteral("aw");
break;
case T9WriteInputMethod::EngineMode::SimplifiedChinese:
case T9WriteInputMethod::EngineMode::TraditionalChinese:
case T9WriteInputMethod::EngineMode::HongKongChinese:
suffix = QStringLiteral("cp");
break;
case T9WriteInputMethod::EngineMode::Japanese:
suffix = QStringLiteral("j");
break;
case T9WriteInputMethod::EngineMode::Korean:
suffix = QStringLiteral("k");
break;
default:
break;
}
return QStringLiteral("cerence-hwr%1.dlm").arg(suffix);
}
void dlmActivate()
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::dlmActivate()";
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
if (loadedDlmDictionary)
return;
DECUMA_SRC_DICTIONARY_INFO sourceInfo;
sourceInfo.srcType = decumaPortableHWRDictionary;
sourceInfo.bNoFrequencyRanking = 1;
sourceInfo.multiStepWordSeparator = 0;
QString dictionaryName(QStringLiteral("%1/%2").arg(Settings::instance()->userDataPath(), dlmFileName()));
QSharedPointer<T9WriteAbstractSource> sourceDictionary(
new T9WriteFileSource(
sourceInfo,
dictionaryName));
loadedDlmDictionary.reset(new T9WriteDynamicDictionary(
sourceDictionary,
CERENCE_HWR_DLM_MAX_WORDS,
memFuncs,
cjk));
QSharedPointer<T9WriteDictionaryTask> dynamicDictionaryTask(
new T9WriteDictionaryTask(
loadedDlmDictionary,
false));
Q_Q(T9WriteInputMethod);
q->connect(dynamicDictionaryTask.data(),
&T9WriteDictionaryTask::completed,
[=](QSharedPointer<T9WriteAbstractDictionary> dynamicDictionary) {
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
if (!loadedDlmDictionary || dynamicDictionary != loadedDlmDictionary)
return;
if (dynamicDictionary->data()) {
if (attachedDlmDictionary != dynamicDictionary &&
attachDictionary(dynamicDictionary)) {
attachedDlmDictionary = dynamicDictionary;
}
} else {
dlmDeactivate();
}
});
worker->addTask(dynamicDictionaryTask);
}
void dlmDeactivate()
{
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
if (loadedDlmDictionary) {
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::dlmDeactivate()";
loadedDlmDictionary.reset();
}
if (attachedDlmDictionary) {
detachDictionary(attachedDlmDictionary);
attachedDlmDictionary.reset();
}
}
void dlmAddWord(const QString &word)
{
if (!isDlmActive() || !worker)
return;
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::dlmAddWord()";
QSharedPointer<T9WriteDlmWordTask> learnWordTask(new T9WriteDlmWordTask(loadedDlmDictionary, word, stringStart));
worker->addTask(learnWordTask);
}
bool dlmHasWord(const QString &word)
{
if (!isDlmActive() || !worker)
return false;
worker->waitForAllTasks();
const std::lock_guard<QRecursiveMutex> dictionaryGuard(dictionaryLock);
T9WriteDynamicDictionary *dictionary = static_cast<T9WriteDynamicDictionary *>(loadedDlmDictionary.data());
return dictionary->hasWord(word);
}
void dlmRemoveWord(const QString &word)
{
qCDebug(lcT9Write) << "T9WriteInputMethodPrivate::dlmRemoveWord()";
QSharedPointer<T9WriteDlmRemoveWordTask> removeWordTask(new T9WriteDlmRemoveWordTask(loadedDlmDictionary, word));
worker->addTask(removeWordTask);
}
T9WriteInputMethod *q_ptr;
static const DECUMA_MEM_FUNCTIONS memFuncs;
bool cjk;
T9WriteInputMethod::EngineMode engineMode;
QByteArray currentContext;
DECUMA_SESSION_SETTINGS sessionSettings;
DECUMA_UINT32 gestureWidthThreshold;
QStringList defaultHwrDbPaths;
QFile hwrDbFile;
QList<DECUMA_UINT32> languageCategories;
QList<DECUMA_UINT32> symbolCategories;
QScopedPointer<T9WriteWorker> worker;
QList<QVirtualKeyboardTrace *> traceList;
int traceListHardLimit;
QRecursiveMutex dictionaryLock;
QString dictionaryFileName;
QSharedPointer<T9WriteAbstractDictionary> loadedDictionary;
QSharedPointer<T9WriteAbstractDictionary> attachedDictionary;
QSharedPointer<Xt9LdbManager> ldbManager;
QSharedPointer<T9WriteDictionaryTask> dictionaryTask;
QMap<QString, QSharedPointer<T9WriteAbstractDictionary>> dynamicDictionaries;
QMap<QString, QSharedPointer<T9WriteAbstractDictionary>> attachedDynamicDictionaries;
QSharedPointer<T9WriteAbstractDictionary> loadedDlmDictionary;
QSharedPointer<T9WriteAbstractDictionary> attachedDlmDictionary;
QMetaObject::Connection availableDictionariesChangedConnection;
QMetaObject::Connection activeDictionariesChangedConnection;
QSharedPointer<T9WriteRecognitionTask> recognitionTask;
QRecursiveMutex resultListLock;
QVariantList resultList;
QMetaObject::Connection resultListChangedConnection;
int resultId;
int lastResultId;
int resultTimer;
QByteArray session;
DECUMA_SESSION *decumaSession;
QList<T9WriteWordCandidate> wordCandidates;
QString stringStart;
QString scrResult;
int activeWordIndex;
bool arcAdditionStarted;
bool ignoreUpdate;
QVirtualKeyboardInputEngine::TextCase textCase;
T9WriteCaseFormatter caseFormatter;
HandwritingGestureRecognizer gestureRecognizer;
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
QScopedPointer<UnipenTrace> unipenTrace;
#endif
#ifdef HAVE_XT9
QScopedPointer<Xt9Ime> xt9Ime;
QMap<QString, quint16> xt9DynamicDictionaries;
QMap<QString, quint16> xt9AttachedDynamicDictionaries;
QAtomicInt xt9DynamicDictionaryNextId;
QMetaObject::Connection defaultInputMethodDisabledChangedConnection;
QMetaObject::Connection defaultDictionaryDisabledChangedConnection;
#endif
QMetaObject::Connection userDataResetConnection;
};
const DECUMA_MEM_FUNCTIONS T9WriteInputMethodPrivate::memFuncs = {
T9WriteInputMethodPrivate::decumaMalloc,
T9WriteInputMethodPrivate::decumaCalloc,
T9WriteInputMethodPrivate::decumaFree,
nullptr
};
/*!
\class QtVirtualKeyboard::T9WriteInputMethod
\internal
*/
T9WriteInputMethod::T9WriteInputMethod(QObject *parent) :
QVirtualKeyboardAbstractInputMethod(*new T9WriteInputMethodPrivate(this), parent)
{
}
T9WriteInputMethod::~T9WriteInputMethod()
{
}
void T9WriteInputMethod::clearInputMode()
{
Q_D(T9WriteInputMethod);
d->exitEngine();
}
QList<QVirtualKeyboardInputEngine::InputMode> T9WriteInputMethod::inputModes(const QString &locale)
{
Q_D(T9WriteInputMethod);
QList<QVirtualKeyboardInputEngine::InputMode> availableInputModes;
const Qt::InputMethodHints inputMethodHints(inputContext()->inputMethodHints());
const QLocale loc(locale);
T9WriteInputMethod::EngineMode mode = d->mapLocaleToEngineMode(loc);
// Add primary input mode
switch (mode) {
#ifdef HAVE_CERENCE_HWR_ALPHABETIC
case T9WriteInputMethod::EngineMode::Alphabetic:
if (d->findHwrDb(T9WriteInputMethod::EngineMode::Alphabetic).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly))) {
switch (loc.script()) {
case QLocale::GreekScript:
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Greek);
break;
case QLocale::CyrillicScript:
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Cyrillic);
break;
case QLocale::ThaiScript:
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Thai);
break;
default:
break;
}
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Latin);
}
break;
case T9WriteInputMethod::EngineMode::Arabic:
if (d->findHwrDb(T9WriteInputMethod::EngineMode::Arabic).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly)))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Arabic);
break;
case T9WriteInputMethod::EngineMode::Hebrew:
if (d->findHwrDb(T9WriteInputMethod::EngineMode::Hebrew).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly)))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Hebrew);
break;
case T9WriteInputMethod::EngineMode::Thai:
if (d->findHwrDb(T9WriteInputMethod::EngineMode::Thai).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly)))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Thai);
break;
#endif
#ifdef HAVE_CERENCE_HWR_CJK
case T9WriteInputMethod::EngineMode::SimplifiedChinese:
case T9WriteInputMethod::EngineMode::TraditionalChinese:
case T9WriteInputMethod::EngineMode::HongKongChinese:
if (d->findHwrDb(mode).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly)))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting);
break;
case T9WriteInputMethod::EngineMode::Japanese:
if (d->findHwrDb(T9WriteInputMethod::EngineMode::Japanese).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly)))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting);
break;
case T9WriteInputMethod::EngineMode::Korean:
if (d->findHwrDb(T9WriteInputMethod::EngineMode::Korean).isEmpty())
return availableInputModes;
if (!(inputMethodHints & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly | Qt::ImhLatinOnly)))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting);
break;
#endif
default:
return availableInputModes;
}
// Add exclusive input modes
if (inputMethodHints.testFlag(Qt::ImhDialableCharactersOnly) || inputMethodHints.testFlag(Qt::ImhDigitsOnly)) {
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Dialable);
} else if (inputMethodHints.testFlag(Qt::ImhFormattedNumbersOnly)) {
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Numeric);
} else if (inputMethodHints.testFlag(Qt::ImhLatinOnly)) {
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Latin);
} else {
// Add other input modes
Q_ASSERT(!availableInputModes.isEmpty());
if (!availableInputModes.contains(QVirtualKeyboardInputEngine::InputMode::Latin))
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Latin);
availableInputModes.append(QVirtualKeyboardInputEngine::InputMode::Numeric);
}
return availableInputModes;
}
bool T9WriteInputMethod::setInputMode(const QString &locale, QVirtualKeyboardInputEngine::InputMode inputMode)
{
Q_D(T9WriteInputMethod);
d->select();
return d->setInputMode(QLocale(locale), inputMode);
}
bool T9WriteInputMethod::setTextCase(QVirtualKeyboardInputEngine::TextCase textCase)
{
Q_D(T9WriteInputMethod);
d->textCase = textCase;
return true;
}
bool T9WriteInputMethod::keyEvent(Qt::Key key, const QString &text, Qt::KeyboardModifiers modifiers)
{
Q_UNUSED(modifiers);
Q_D(T9WriteInputMethod);
switch (key) {
case Qt::Key_Enter:
case Qt::Key_Return:
case Qt::Key_Tab:
case Qt::Key_Space:
d->select();
update();
break;
case Qt::Key_Backspace:
{
QVirtualKeyboardInputContext *ic = inputContext();
QString preeditText = ic->preeditText();
if (preeditText.length() > 1) {
preeditText.chop(1);
ic->setPreeditText(preeditText);
d->caseFormatter.ensureLength(preeditText.length(), d->textCase);
T9WriteCaseFormatter caseFormatter(d->caseFormatter);
d->finishRecognition(false);
d->caseFormatter = caseFormatter;
d->stringStart = preeditText;
int xt9DefaultListIndex = 0;
d->activeWordIndex = 0;
d->appendWordCandidates(d->wordCandidates, d->activeWordIndex, d->stringStart, d->xt9BuildSelectionList(d->stringStart, &xt9DefaultListIndex), xt9DefaultListIndex, T9WriteWordCandidate::Origin::XT9);
emit selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, d->activeWordIndex);
return true;
} else {
bool result = !preeditText.isEmpty();
if (result)
ic->clear();
else
result = !d->scrResult.isEmpty();
d->finishRecognition();
return result;
}
}
default:
if (d->sessionSettings.recognitionMode != scrMode && text.length() > 0) {
d->waitForRecognitionResults();
QVirtualKeyboardInputContext *ic = inputContext();
QString preeditText = ic->preeditText();
QChar c = text.at(0);
bool addToWord = d->isValidInputChar(c) && (!preeditText.isEmpty() || !d->isJoiner(c));
if (addToWord) {
preeditText.append(text);
ic->setPreeditText(preeditText);
d->caseFormatter.ensureLength(preeditText.length(), d->textCase);
T9WriteCaseFormatter caseFormatter(d->caseFormatter);
d->finishRecognition(false);
d->caseFormatter = caseFormatter;
d->stringStart = preeditText;
d->wordCandidates.append(preeditText);
d->activeWordIndex = 0;
emit selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, d->activeWordIndex);
return true;
} else {
ic->commit();
d->finishRecognition();
}
break;
} else if (d->sessionSettings.recognitionMode == scrMode) {
d->finishRecognition();
}
}
return false;
}
void T9WriteInputMethod::reset()
{
Q_D(T9WriteInputMethod);
d->finishRecognition();
d->setInputMode(QLocale(inputContext()->locale()), inputEngine()->inputMode());
}
void T9WriteInputMethod::update()
{
Q_D(T9WriteInputMethod);
if (d->ignoreUpdate)
return;
d->select();
}
QList<QVirtualKeyboardSelectionListModel::Type> T9WriteInputMethod::selectionLists()
{
return QList<QVirtualKeyboardSelectionListModel::Type>() << QVirtualKeyboardSelectionListModel::Type::WordCandidateList;
}
int T9WriteInputMethod::selectionListItemCount(QVirtualKeyboardSelectionListModel::Type type)
{
Q_UNUSED(type);
Q_D(T9WriteInputMethod);
return d->wordCandidates.size();
}
QVariant T9WriteInputMethod::selectionListData(QVirtualKeyboardSelectionListModel::Type type, int index, QVirtualKeyboardSelectionListModel::Role role)
{
QVariant result;
Q_D(T9WriteInputMethod);
switch (role) {
case QVirtualKeyboardSelectionListModel::Role::Display:
result = QVariant(d->wordCandidates.at(index).symbs);
break;
case QVirtualKeyboardSelectionListModel::Role::WordCompletionLength:
result.setValue(0);
break;
case QVirtualKeyboardSelectionListModel::Role::Dictionary:
{
QVirtualKeyboardSelectionListModel::DictionaryType dictionaryType =
d->dlmHasWord(d->wordCandidates.at(index).symbs) ?
QVirtualKeyboardSelectionListModel::DictionaryType::User :
QVirtualKeyboardSelectionListModel::DictionaryType::Default;
result = QVariant(static_cast<int>(dictionaryType));
break;
}
case QVirtualKeyboardSelectionListModel::Role::CanRemoveSuggestion:
result = QVariant(d->dlmHasWord(d->wordCandidates.at(index).symbs));
break;
default:
result = QVirtualKeyboardAbstractInputMethod::selectionListData(type, index, role);
break;
}
return result;
}
void T9WriteInputMethod::selectionListItemSelected(QVirtualKeyboardSelectionListModel::Type type, int index)
{
Q_UNUSED(type);
Q_D(T9WriteInputMethod);
#ifdef HAVE_XT9
switch (d->engineMode) {
case T9WriteInputMethod::EngineMode::SimplifiedChinese:
if (inputEngine()->inputMode() != QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting)
break;
[[fallthrough]]; case T9WriteInputMethod::EngineMode::Japanese:
if (d->wordCandidates[index].origin == T9WriteWordCandidate::Origin::T9Write) {
if (d->xt9AllSymbsArePinyin(d->wordCandidates[index].symbs)) {
int indexOfFirstXt9Candidate;
for (indexOfFirstXt9Candidate = 0; indexOfFirstXt9Candidate < d->wordCandidates.size(); ++indexOfFirstXt9Candidate) {
if (d->wordCandidates[indexOfFirstXt9Candidate].origin == T9WriteWordCandidate::Origin::XT9)
break;
}
while (indexOfFirstXt9Candidate < d->wordCandidates.size()) {
d->wordCandidates.removeAt(indexOfFirstXt9Candidate);
}
int xt9DefaultListIndex = 0;
d->appendWordCandidates(d->wordCandidates, d->activeWordIndex, d->wordCandidates[index].symbs, d->xt9BuildSelectionList(d->wordCandidates[index].symbs, &xt9DefaultListIndex), xt9DefaultListIndex, T9WriteWordCandidate::Origin::XT9);
d->activeWordIndex = index;
emit selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, d->activeWordIndex);
return;
}
}
break;
default:
break;
}
#endif
d->select(index);
}
bool T9WriteInputMethod::selectionListRemoveItem(QVirtualKeyboardSelectionListModel::Type type, int index)
{
Q_UNUSED(type)
Q_D(T9WriteInputMethod);
if (index < 0 || index >= d->wordCandidates.size())
return false;
d->dlmRemoveWord(d->wordCandidates.at(index).symbs);
if (d->wordCandidates.size() > 1) {
d->wordCandidates.removeAt(index);
emit selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, d->activeWordIndex);
} else {
inputContext()->clear();
reset();
}
return true;
}
QList<QVirtualKeyboardInputEngine::PatternRecognitionMode> T9WriteInputMethod::patternRecognitionModes() const
{
return QList<QVirtualKeyboardInputEngine::PatternRecognitionMode>()
<< QVirtualKeyboardInputEngine::PatternRecognitionMode::Handwriting;
}
QVirtualKeyboardTrace *T9WriteInputMethod::traceBegin(
int traceId, QVirtualKeyboardInputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo, const QVariantMap &traceScreenInfo)
{
Q_D(T9WriteInputMethod);
return d->traceBegin(traceId, patternRecognitionMode, traceCaptureDeviceInfo, traceScreenInfo);
}
bool T9WriteInputMethod::traceEnd(QVirtualKeyboardTrace *trace)
{
Q_D(T9WriteInputMethod);
d->traceEnd(trace);
return true;
}
bool T9WriteInputMethod::reselect(int cursorPosition, const QVirtualKeyboardInputEngine::ReselectFlags &reselectFlags)
{
Q_D(T9WriteInputMethod);
if (d->sessionSettings.recognitionMode == scrMode)
return false;
QVirtualKeyboardInputContext *ic = inputContext();
if (!ic)
return false;
const QVirtualKeyboardInputEngine::InputMode inputMode = inputEngine()->inputMode();
const int maxLength = (inputMode == QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting ||
inputMode == QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting ||
inputMode == QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting) ? 16 : 32;
const QString surroundingText = ic->surroundingText();
int replaceFrom = 0;
if (cursorPosition > surroundingText.length())
return false;
if (reselectFlags.testFlag(QVirtualKeyboardInputEngine::ReselectFlag::WordBeforeCursor)) {
for (int i = cursorPosition - 1; i >= 0 && d->stringStart.length() < maxLength; --i) {
QChar c = surroundingText.at(i);
if (!d->isValidInputChar(c))
break;
d->stringStart.insert(0, c);
--replaceFrom;
}
while (replaceFrom < 0 && d->isJoiner(d->stringStart.at(0))) {
d->stringStart.remove(0, 1);
++replaceFrom;
}
}
if (reselectFlags.testFlag(QVirtualKeyboardInputEngine::ReselectFlag::WordAtCursor) && replaceFrom == 0) {
d->stringStart.clear();
return false;
}
if (reselectFlags.testFlag(QVirtualKeyboardInputEngine::ReselectFlag::WordAfterCursor)) {
for (int i = cursorPosition; i < surroundingText.length() && d->stringStart.length() < maxLength; ++i) {
QChar c = surroundingText.at(i);
if (!d->isValidInputChar(c))
break;
d->stringStart.append(c);
}
while (replaceFrom > -d->stringStart.length()) {
int lastPos = d->stringStart.length() - 1;
if (!d->isJoiner(d->stringStart.at(lastPos)))
break;
d->stringStart.remove(lastPos, 1);
}
}
if (d->stringStart.isEmpty())
return false;
if (reselectFlags.testFlag(QVirtualKeyboardInputEngine::ReselectFlag::WordAtCursor) && replaceFrom == -d->stringStart.length() && d->stringStart.length() < maxLength) {
d->stringStart.clear();
return false;
}
if (d->isJoiner(d->stringStart.at(0))) {
d->stringStart.clear();
return false;
}
if (d->isJoiner(d->stringStart.at(d->stringStart.length() - 1))) {
d->stringStart.clear();
return false;
}
ic->setPreeditText(d->stringStart, QList<QInputMethodEvent::Attribute>(), replaceFrom, d->stringStart.length());
for (int i = 0; i < d->stringStart.length(); ++i)
d->caseFormatter.ensureLength(i + 1, d->stringStart.at(i).isUpper() ? QVirtualKeyboardInputEngine::TextCase::Upper : QVirtualKeyboardInputEngine::TextCase::Lower);
int xt9DefaultListIndex = 0;
d->activeWordIndex = 0;
d->appendWordCandidates(d->wordCandidates, d->activeWordIndex, d->stringStart, d->xt9BuildSelectionList(d->stringStart, &xt9DefaultListIndex), xt9DefaultListIndex, T9WriteWordCandidate::Origin::XT9);
emit selectionListChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList);
emit selectionListActiveItemChanged(QVirtualKeyboardSelectionListModel::Type::WordCandidateList, d->activeWordIndex);
return true;
}
void T9WriteInputMethod::timerEvent(QTimerEvent *timerEvent)
{
Q_D(T9WriteInputMethod);
int timerId = timerEvent->timerId();
qCDebug(lcT9Write) << "T9WriteInputMethod::timerEvent():" << timerId;
if (timerId == d->resultTimer) {
d->stopResultTimer();
// Ignore if the result is not yet available
if (d->resultId != d->lastResultId) {
qCDebug(lcT9Write) << "T9WriteInputMethod::timerEvent(): Result not yet available";
return;
}
if (d->sessionSettings.recognitionMode != scrMode) {
#ifndef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
// Don't clear traces in UCR mode if dictionary is loaded.
// In UCR mode the whole purpose is to write the word with
// one or few strokes.
if (d->sessionSettings.recognitionMode == ucrMode) {
const std::lock_guard<QRecursiveMutex> dictionaryGuard(d->dictionaryLock);
if (d->attachedDictionary)
return;
}
const QVirtualKeyboardInputEngine::InputMode inputMode = inputEngine()->inputMode();
if (inputMode != QVirtualKeyboardInputEngine::InputMode::ChineseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::JapaneseHandwriting &&
inputMode != QVirtualKeyboardInputEngine::InputMode::KoreanHandwriting) {
d->clearTraces();
}
#endif
} else {
d->select();
}
}
}
} // namespace QtVirtualKeyboard
QT_END_NAMESPACE