An error occurred while loading the file. Please try again.
-
John Koleszar authored
A large number of functions were defined with external linkage, even though they were only used from within one file. This patch changes their linkage to static and removes the vp8_ prefix from their names, which should make it more obvious to the reader that the function is contained within the current translation unit. Functions that were not referenced were removed. These symbols were identified by: $ nm -A libvpx.a | sort -k3 | uniq -c -f2 | grep ' [A-Z] ' \ | sort | grep '^ *1 ' Change-Id: I59609f58ab65312012c047036ae1e0634f795779429dc676
/******************************************************************************** Copyright (C) 2016 The Qt Company Ltd.** Contact: https://www.qt.io/licensing/**** This file is part of the Qt Virtual Keyboard module of the Qt Toolkit.**** $QT_BEGIN_LICENSE:GPL$** Commercial License Usage** Licensees holding valid commercial Qt licenses may use this file in** accordance with the commercial license agreement provided with the** Software or, alternatively, in accordance with the terms contained in** a written agreement between you and The Qt Company. For licensing terms** and conditions see https://www.qt.io/terms-conditions. For further** information use the contact form at https://www.qt.io/contact-us.**** GNU General Public License Usage** Alternatively, this file may be used under the terms of the GNU** General Public License version 3 or (at your option) any later version** approved by the KDE Free Qt Foundation. The licenses are as published by** the Free Software Foundation and appearing in the file LICENSE.GPL3** included in the packaging of this file. Please review the following** information to ensure the GNU General Public License requirements will** be met: https://www.gnu.org/licenses/gpl-3.0.html.**** $QT_END_LICENSE$******************************************************************************/#include "lipiinputmethod.h"#include "lipisharedrecognizer.h"#include "inputengine.h"#include "inputcontext.h"#include "shifthandler.h"#include "virtualkeyboarddebug.h"#include "trace.h"#include "handwritinggesturerecognizer.h"#ifdef HAVE_HUNSPELL#include "hunspellinputmethod_p.h"#endif#include "LTKCaptureDevice.h"#include "LTKScreenContext.h"#include "LTKTraceGroup.h"#include "LTKChannel.h"#include "LTKTraceFormat.h"#include "LTKTrace.h"#include "LTKShapeRecoResult.h"#include <QCryptographicHash>#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT#include "unipentrace.h"#include <QStandardPaths>#endif#ifdef HAVE_HUNSPELL#define LipiInputMethodPrivateBase HunspellInputMethodPrivate#else#define LipiInputMethodPrivateBase AbstractInputMethodPrivate#endifnamespace QtVirtualKeyboard {class LipiInputMethodPrivate : public LipiInputMethodPrivateBase{ Q_DECLARE_PUBLIC(LipiInputMethod)public: LipiInputMethodPrivate(LipiInputMethod *q_ptr) :7172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140
#ifdef HAVE_HUNSPELL
LipiInputMethodPrivateBase(static_cast<HunspellInputMethod *>(q_ptr)),
#else
LipiInputMethodPrivateBase(),
#endif
q_ptr(q_ptr),
recognizeTimer(0),
textCase(InputEngine::Lower)
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
, unipenTrace(0)
#endif
{
}
~LipiInputMethodPrivate()
{
cancelRecognition();
}
QByteArray getContext(InputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo,
const QVariantMap &traceScreenInfo) const
{
QCryptographicHash hash(QCryptographicHash::Md5);
hash.addData((const char *)&patternRecognitionMode, sizeof(patternRecognitionMode));
QByteArray mapData;
QDataStream ds(&mapData, QIODevice::WriteOnly);
ds << traceCaptureDeviceInfo;
ds << traceScreenInfo;
hash.addData(mapData);
return hash.result();
}
void setContext(InputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo,
const QVariantMap &traceScreenInfo)
{
QByteArray context = getContext(patternRecognitionMode, traceCaptureDeviceInfo, traceScreenInfo);
if (context == currentContext)
return;
VIRTUALKEYBOARD_DEBUG() << "LipiInputMethodPrivate::setContext():" << QString(context.toHex());
clearTraces();
deviceInfo.reset(new LTKCaptureDevice());
deviceInfo->setSamplingRate(traceCaptureDeviceInfo.value("sampleRate", 60).toInt());
deviceInfo->setXDPI(traceCaptureDeviceInfo.value("dpi", 96).toInt());
deviceInfo->setYDPI(deviceInfo->getXDPI());
deviceInfo->setLatency(traceCaptureDeviceInfo.value("latency", 0.0).toFloat());
deviceInfo->setUniformSampling(traceCaptureDeviceInfo.value("uniform", false).toBool());
screenContext.reset(new LTKScreenContext());
QRectF boundingBox(traceScreenInfo.value("boundingBox").toRectF());
if (!boundingBox.isEmpty()) {
screenContext->setBboxLeft(boundingBox.left());
screenContext->setBboxTop(boundingBox.top());
screenContext->setBboxRight(boundingBox.right());
screenContext->setBboxBottom(boundingBox.bottom());
}
QVariantList horizontalRulers(traceScreenInfo.value("horizontalRulers", QVariantList()).toList());
if (!horizontalRulers.isEmpty()) {
for (QVariantList::ConstIterator i = horizontalRulers.constBegin();
i != horizontalRulers.constEnd(); i++) {
screenContext->addHLine(i->toFloat());
}
141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210
}
QVariantList verticalRulers(traceScreenInfo.value("verticalRulers", QVariantList()).toList());
if (!horizontalRulers.isEmpty()) {
for (QVariantList::ConstIterator i = verticalRulers.constBegin();
i != verticalRulers.constEnd(); i++) {
screenContext->addVLine(i->toFloat());
}
}
gestureRecognizer.setDpi(deviceInfo->getXDPI());
currentContext = context;
}
Trace *traceBegin(int traceId, InputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo, const QVariantMap &traceScreenInfo)
{
Q_UNUSED(traceId)
stopRecognizeTimer();
setContext(patternRecognitionMode, traceCaptureDeviceInfo, traceScreenInfo);
if (recognitionTask) {
recognizer.cancelRecognitionTask(recognitionTask);
recognitionTask.reset();
delayedResult.clear();
}
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
if (!unipenTrace) {
Q_Q(LipiInputMethod);
unipenTrace = new UnipenTrace(traceCaptureDeviceInfo, traceScreenInfo, q);
}
#endif
Trace *trace = new Trace();
trace->setChannels(QStringList("t"));
traceList.append(trace);
return trace;
}
void traceEnd(Trace *trace)
{
if (trace->isCanceled()) {
VIRTUALKEYBOARD_DEBUG() << "LipiInputMethodPrivate::traceEnd(): discarded" << trace;
traceList.removeOne(trace);
delete trace;
} else {
addPointsToTraceGroup(trace);
}
handleGesture();
if (!traceList.isEmpty() && countActiveTraces() == 0)
restartRecognition();
}
int countActiveTraces() const
{
int count = 0;
for (Trace *trace : qAsConst(traceList)) {
if (!trace->isFinal())
count++;
}
return count;
}
void handleGesture()
{
211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280
if (countActiveTraces() > 0)
return;
QVariantMap gesture = gestureRecognizer.recognize(traceList);
if (gesture.isEmpty())
return;
VIRTUALKEYBOARD_DEBUG() << "LipiInputMethodPrivate::handleGesture():" << gesture;
if (gesture[QLatin1String("type")].toString() == QLatin1String("swipe")) {
static const int SWIPE_MIN_LENGTH = 25; // mm
static const int SWIPE_ANGLE_THRESHOLD = 15; // degrees +-
qreal swipeLength = gesture[QLatin1String("length_mm")].toReal();
if (swipeLength >= SWIPE_MIN_LENGTH) {
Q_Q(LipiInputMethod);
InputContext *ic = q->inputContext();
if (!ic)
return;
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
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
dumpTraces();
saveTraces(Qt::Key_Backspace, 100);
#endif
cancelRecognition();
ic->inputEngine()->virtualKeyClick(Qt::Key_Backspace, QString(), Qt::NoModifier);
} else if (swipeTouchCount == 2) {
// Double swipe: reset word, or backspace
cancelRecognition();
if (!ic->preeditText().isEmpty()) {
q->reset();
ic->setPreeditText(QString());
} else {
ic->inputEngine()->virtualKeyClick(Qt::Key_Backspace, QString(), Qt::NoModifier);
}
}
return;
}
// Swipe right
if (swipeAngle <= SWIPE_ANGLE_THRESHOLD || swipeAngle >= 360 - SWIPE_ANGLE_THRESHOLD) {
if (swipeTouchCount == 1) {
// Single swipe: space
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
dumpTraces();
saveTraces(Qt::Key_Space, 100);
#endif
cancelRecognition();
ic->inputEngine()->virtualKeyClick(Qt::Key_Space, QString(" "), Qt::NoModifier);
} else if (swipeTouchCount == 2) {
// Double swipe: commit word, or insert space
cancelRecognition();
#ifdef HAVE_HUNSPELL
if (activeWordIndex != -1) {
q->selectionListItemSelected(SelectionListModel::WordCandidateList, activeWordIndex);
return;
}
#endif
ic->inputEngine()->virtualKeyClick(Qt::Key_Space, QString(" "), Qt::NoModifier);
}
return;
281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350
}
// Swipe up
if (swipeAngle <= 270 + SWIPE_ANGLE_THRESHOLD && swipeAngle >= 270 - SWIPE_ANGLE_THRESHOLD) {
if (swipeTouchCount == 1) {
// Single swipe: toggle input mode
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
dumpTraces();
saveTraces(Qt::Key_Mode_switch, 100);
#endif
cancelRecognition();
if (!(ic->inputMethodHints() & (Qt::ImhDialableCharactersOnly | Qt::ImhFormattedNumbersOnly | Qt::ImhDigitsOnly))) {
InputEngine::InputMode inputMode = ic->inputEngine()->inputMode();
inputMode = inputMode == InputEngine::Latin ?
InputEngine::Numeric : InputEngine::Latin;
ic->inputEngine()->setInputMode(inputMode);
}
} else if (swipeTouchCount == 2) {
// Double swipe: toggle text case
cancelRecognition();
ic->shiftHandler()->toggleShift();
}
return;
}
}
}
}
void clearTraces()
{
qDeleteAll(traceList);
traceList.clear();
traceGroup.emptyAllTraces();
}
void addPointsToTraceGroup(Trace *trace)
{
vector<LTKChannel> channels;
channels.push_back(LTKChannel("X", DT_INT, true));
channels.push_back(LTKChannel("Y", DT_INT, true));
bool hasTime = trace->channels().contains("t");
if (hasTime)
channels.push_back(LTKChannel("T", DT_FLOAT, true));
LTKTraceFormat traceFormat(channels);
LTKTrace ltktrace(traceFormat);
const QVariantList points = trace->points();
const QVariantList timeData = hasTime ? trace->channelData("t") : QVariantList();
QVariantList::ConstIterator t = timeData.constBegin();
for (const QVariant &p : points) {
const QPointF pt(p.toPointF());
vector<float> point;
point.push_back(pt.x());
point.push_back(pt.y());
if (hasTime) {
point.push_back(t->toFloat());
t++;
}
ltktrace.addPoint(point);
}
traceGroup.addTrace(ltktrace);
}
void finishRecognition()
{
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
dumpTraces();
#endif
stopRecognizeTimer();
clearTraces();
351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420
if (recognitionTask && !delayedResult.isEmpty() && recognitionTask->resultId() == delayedResult["resultId"].toInt())
processResult(delayedResult);
delayedResult.clear();
recognitionTask.reset();
}
void restartRecognition()
{
recognitionTask = recognizer.newRecognition(*deviceInfo, *screenContext, subsetOfClasses, 0.0f, 4);
if (recognitionTask) {
Q_Q(LipiInputMethod);
recognitionTask->traceGroup = traceGroup;
QSharedPointer<LipiRecognitionResultsTask> resultsTask = recognizer.startRecognition(recognitionTask);
q->connect(resultsTask.data(), SIGNAL(resultsAvailable(const QVariantList &)), SLOT(resultsAvailable(const QVariantList &)));
resetRecognizeTimer();
} else {
stopRecognizeTimer();
}
}
bool cancelRecognition()
{
stopRecognizeTimer();
clearTraces();
delayedResult.clear();
bool result = !recognitionTask.isNull();
recognitionTask.reset();
return recognizer.cancelRecognition() || result;
}
void resetRecognizeTimer()
{
Q_Q(LipiInputMethod);
stopRecognizeTimer();
recognizeTimer = q->startTimer(300);
}
void stopRecognizeTimer()
{
if (recognizeTimer) {
Q_Q(LipiInputMethod);
q->killTimer(recognizeTimer);
recognizeTimer = 0;
}
}
void resultsAvailable(const QVariantList &resultList)
{
if (!resultList.isEmpty()) {
const QVariantMap result = resultList.at(0).toMap();
if (recognitionTask && recognitionTask->resultId() == result["resultId"].toInt())
delayedResult = result;
else
processResult(result);
}
}
void processResult(const QVariantMap &result)
{
const QChar ch = result["unicode"].toChar();
const QChar chUpper = ch.toUpper();
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
// In recording mode, the text case must match with the current text case
if (unipenTrace) {
if (!ch.isLetter() || (ch.isUpper() == (textCase == InputEngine::Upper)))
saveTraces(ch.unicode(), qRound(result["confidence"].toDouble() * 100));
delete unipenTrace;
421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490
unipenTrace = 0;
}
#endif
Q_Q(LipiInputMethod);
q->inputContext()->inputEngine()->virtualKeyClick((Qt::Key)chUpper.unicode(),
textCase == InputEngine::Lower ? QString(ch.toLower()) : QString(chUpper),
Qt::NoModifier);
}
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
void dumpTraces()
{
if (unipenTrace)
unipenTrace->record(traceList);
}
void saveTraces(uint unicode, uint confidence)
{
if (!unipenTrace)
return;
QStringList homeLocations = QStandardPaths::standardLocations(QStandardPaths::HomeLocation);
if (!homeLocations.isEmpty()) {
QString filePath = QStringLiteral("%1/%2").arg(homeLocations.at(0)).arg("VIRTUAL_KEYBOARD_TRACES");
unipenTrace->setDirectory(filePath);
unipenTrace->save(unicode, confidence);
}
}
#endif
LipiInputMethod *q_ptr;
LipiSharedRecognizer recognizer;
QByteArray currentContext;
QScopedPointer<LTKCaptureDevice> deviceInfo;
QScopedPointer<LTKScreenContext> screenContext;
QSharedPointer<LipiRecognitionTask> recognitionTask;
LTKTraceGroup traceGroup;
QList<Trace *> traceList;
int recognizeTimer;
InputEngine::TextCase textCase;
vector<int> subsetOfClasses;
QVariantMap delayedResult;
HandwritingGestureRecognizer gestureRecognizer;
#ifdef QT_VIRTUALKEYBOARD_RECORD_TRACE_INPUT
UnipenTrace *unipenTrace;
#endif
};
/*!
\class QtVirtualKeyboard::LipiInputMethod
\internal
*/
LipiInputMethod::LipiInputMethod(QObject *parent) :
LipiInputMethodBase(*new LipiInputMethodPrivate(this), parent)
{
}
LipiInputMethod::~LipiInputMethod()
{
}
QList<InputEngine::InputMode> LipiInputMethod::inputModes(const QString &locale)
{
Q_UNUSED(locale)
QList<InputEngine::InputMode> availableInputModes;
const Qt::InputMethodHints inputMethodHints(inputContext()->inputMethodHints());
if (inputMethodHints.testFlag(Qt::ImhDialableCharactersOnly) || inputMethodHints.testFlag(Qt::ImhDigitsOnly)) {
availableInputModes.append(InputEngine::Dialable);
491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560
} else if (inputMethodHints.testFlag(Qt::ImhFormattedNumbersOnly)) {
availableInputModes.append(InputEngine::Numeric);
} else {
availableInputModes.append(InputEngine::Latin);
availableInputModes.append(InputEngine::Numeric);
}
return availableInputModes;
}
bool LipiInputMethod::setInputMode(const QString &locale, InputEngine::InputMode inputMode)
{
Q_UNUSED(locale)
Q_D(LipiInputMethod);
#ifdef HAVE_HUNSPELL
HunspellInputMethod::setInputMode(locale, inputMode);
#endif
bool result = d->recognizer.setModel(QStringLiteral("SHAPEREC_ALPHANUM"));
if (!result)
return false;
d->subsetOfClasses.clear();
switch (inputMode) {
case InputEngine::Latin:
d->recognizer.subsetOfClasses(QStringLiteral("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz?,.@"), d->subsetOfClasses);
break;
case InputEngine::Numeric:
case InputEngine::Dialable:
d->recognizer.subsetOfClasses(QStringLiteral("1234567890,.+"), d->subsetOfClasses);
break;
default:
break;
}
return true;
}
bool LipiInputMethod::setTextCase(InputEngine::TextCase textCase)
{
Q_D(LipiInputMethod);
d->textCase = textCase;
#ifdef HAVE_HUNSPELL
HunspellInputMethod::setTextCase(textCase);
#endif
return true;
}
bool LipiInputMethod::keyEvent(Qt::Key key, const QString &text, Qt::KeyboardModifiers modifiers)
{
#ifdef HAVE_HUNSPELL
Q_D(LipiInputMethod);
switch (key) {
case Qt::Key_Enter:
case Qt::Key_Return:
d->cancelRecognition();
break;
case Qt::Key_Backspace:
if (d->cancelRecognition())
return true;
break;
default:
break;
}
return HunspellInputMethod::keyEvent(key, text, modifiers);
#else
Q_UNUSED(key)
Q_UNUSED(text)
Q_UNUSED(modifiers)
return false;
#endif
}
561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624
void LipiInputMethod::reset()
{
LipiInputMethodBase::reset();
Q_D(LipiInputMethod);
d->cancelRecognition();
}
void LipiInputMethod::update()
{
LipiInputMethodBase::update();
}
void LipiInputMethod::selectionListItemSelected(SelectionListModel::Type type, int index)
{
LipiInputMethodBase::selectionListItemSelected(type, index);
Q_D(LipiInputMethod);
d->cancelRecognition();
}
QList<InputEngine::PatternRecognitionMode> LipiInputMethod::patternRecognitionModes() const
{
return QList<InputEngine::PatternRecognitionMode>()
<< InputEngine::HandwritingRecoginition;
}
Trace *LipiInputMethod::traceBegin(int traceId, InputEngine::PatternRecognitionMode patternRecognitionMode,
const QVariantMap &traceCaptureDeviceInfo, const QVariantMap &traceScreenInfo)
{
Q_D(LipiInputMethod);
return d->traceBegin(traceId, patternRecognitionMode, traceCaptureDeviceInfo, traceScreenInfo);
}
bool LipiInputMethod::traceEnd(Trace *trace)
{
Q_D(LipiInputMethod);
d->traceEnd(trace);
return true;
}
void LipiInputMethod::timerEvent(QTimerEvent *timerEvent)
{
Q_D(LipiInputMethod);
if (timerEvent->timerId() == d->recognizeTimer) {
d->finishRecognition();
}
}
void LipiInputMethod::resultsAvailable(const QVariantList &resultList)
{
#ifdef QT_VIRTUALKEYBOARD_DEBUG
{
VIRTUALKEYBOARD_DEBUG() << "LipiInputMethod::resultsAvailable():";
for (int i = 0; i < resultList.size(); i++) {
QVariantMap result = resultList.at(i).toMap();
VIRTUALKEYBOARD_DEBUG() << QString("%1: %2 (%3)").arg(i + 1).arg(result["unicode"].toChar()).arg(result["confidence"].toFloat()).toUtf8().constData();
}
}
#endif
Q_D(LipiInputMethod);
d->resultsAvailable(resultList);
}
} // namespace QtVirtualKeyboard