diff options
Diffstat (limited to 'src/imports/virtualkeyboard/platforminputcontext')
7 files changed, 816 insertions, 0 deletions
diff --git a/src/imports/virtualkeyboard/platforminputcontext/declarativeinputcontext.cpp b/src/imports/virtualkeyboard/platforminputcontext/declarativeinputcontext.cpp new file mode 100644 index 0000000..bf55f9b --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/declarativeinputcontext.cpp @@ -0,0 +1,309 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "platforminputcontext.h" +#include "declarativeinputcontext.h" + +#include <QEvent> +#include <QDebug> +#include <QQuickItem> +#include <QTextFormat> +#include <QGuiApplication> +#include <QLocale> + +DeclarativeInputContext::DeclarativeInputContext(PlatformInputContext *parent) : + QObject(parent), m_inputContext(parent), m_inputMethodVisible(false), m_focus(false), + m_shift(false), m_capsLock(false), m_cursorPosition(0), m_inputMethodHints(0) +{ + if (m_inputContext) + m_inputContext->setDeclarativeContext(this); +} + +DeclarativeInputContext::~DeclarativeInputContext() +{ + if (m_inputContext) + m_inputContext->setDeclarativeContext(0); + m_characterKeys.clear(); +} + +bool DeclarativeInputContext::inputMethodVisible() const +{ + return m_inputMethodVisible; +} + +void DeclarativeInputContext::setInputMethodVisibleProperty(bool visible) +{ + if (m_inputMethodVisible != visible) { + m_inputMethodVisible = visible; + emit inputMethodVisibleChanged(); + } +} + +bool DeclarativeInputContext::focus() const +{ + return m_focus; +} + +void DeclarativeInputContext::setFocus(bool enable) +{ + if (m_focus != enable) { + m_focus = enable; + emit focusChanged(); + } + emit focusEditorChanged(); +} + +bool DeclarativeInputContext::shift() const +{ + return m_shift; +} + +void DeclarativeInputContext::setShift(bool enable) +{ + if (m_shift != enable) { + m_shift = enable; + emit shiftChanged(); + } +} + +bool DeclarativeInputContext::capsLock() const +{ + return m_capsLock; +} + +void DeclarativeInputContext::setCapsLock(bool enable) +{ + if (m_capsLock != enable) { + m_capsLock = enable; + emit capsLockChanged(); + } +} + +int DeclarativeInputContext::cursorPosition() const +{ + return m_cursorPosition; +} + +Qt::InputMethodHints DeclarativeInputContext::inputMethodHints() const +{ + return m_inputMethodHints; +} + +QString DeclarativeInputContext::preeditText() const +{ + return m_preeditText; +} + +void DeclarativeInputContext::setPreeditText(const QString &text) +{ + if (text != m_preeditText) + sendPreedit(text); +} + +QString DeclarativeInputContext::surroundingText() const +{ + return m_surroundingText; +} + +QString DeclarativeInputContext::selectedText() const +{ + return m_selectedText; +} + +QRectF DeclarativeInputContext::cursorRectangle() const +{ + return m_cursorRectangle; +} + +void DeclarativeInputContext::sendKeyClick(int key, const QString &text, int modifiers) +{ + if (m_focus && m_inputContext) { + QKeyEvent pressEvent(QEvent::KeyPress, key, Qt::KeyboardModifiers(modifiers), text); + QKeyEvent releaseEvent(QEvent::KeyRelease, key, Qt::KeyboardModifiers(modifiers), text); + + m_inputContext->sendKeyEvent(&pressEvent); + m_inputContext->sendKeyEvent(&releaseEvent); + } +} + +void DeclarativeInputContext::sendPreedit(const QString &text, int cursor) +{ + const QString preedit = m_preeditText; + m_preeditText = text; + + if (m_inputContext) { + QList<QInputMethodEvent::Attribute> attributes; + + if (cursor >= 0 && cursor <= text.length()) { + attributes.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, cursor, text.length(), QVariant())); + } else { + cursor = text.length(); + } + + QTextCharFormat textFormat; + textFormat.setUnderlineStyle(QTextCharFormat::SingleUnderline); + attributes.append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, text.length(), textFormat)); + + QInputMethodEvent event(text, attributes); + m_inputContext->sendEvent(&event); + } + + if (m_preeditText != preedit) + emit preeditTextChanged(); +} + +void DeclarativeInputContext::commit() +{ + commit(m_preeditText); +} + +void DeclarativeInputContext::commit(const QString &text, int replacementStart, int replacementLength) +{ + bool preeditChanged = !m_preeditText.isEmpty(); + m_preeditText.clear(); + + if (m_inputContext) { + QInputMethodEvent inputEvent; + inputEvent.setCommitString(text, replacementStart, replacementLength); + m_inputContext->sendEvent(&inputEvent); + } + + if (preeditChanged) + emit preeditTextChanged(); +} + +void DeclarativeInputContext::clear() +{ + bool preeditChanged = !m_preeditText.isEmpty(); + m_preeditText.clear(); + + QInputMethodEvent event; + m_inputContext->sendEvent(&event); + + if (preeditChanged) + emit preeditTextChanged(); +} + +void DeclarativeInputContext::setAnimating(bool animating) +{ + if (m_inputContext && m_inputContext->m_animating != animating) { + m_inputContext->m_animating = animating; + m_inputContext->emitAnimatingChanged(); + } +} + +void DeclarativeInputContext::setKeyboardRectangle(QRectF rectangle) +{ + if (m_inputContext && m_inputContext->m_keyboardRect != rectangle) { + m_inputContext->m_keyboardRect = rectangle; + m_inputContext->emitKeyboardRectChanged(); + } +} + +QRectF DeclarativeInputContext::keyboardRectangle() const +{ + return m_inputContext->m_keyboardRect; +} + +void DeclarativeInputContext::setLocale(QString name) +{ + if (m_inputContext && m_inputContext->m_locale.name() != name) { + m_inputContext->m_locale = QLocale(name); + m_inputContext->emitLocaleChanged(); + if (m_inputContext->m_inputDirection != m_inputContext->m_locale.textDirection()) { + m_inputContext->m_inputDirection = m_inputContext->m_locale.textDirection(); + m_inputContext->emitInputDirectionChanged(m_inputContext->m_inputDirection); + } + } +} + +void DeclarativeInputContext::update(Qt::InputMethodQueries queries) +{ + Q_UNUSED(queries); + + // fetch + Qt::InputMethodHints inputMethodHints = Qt::InputMethodHints(m_inputContext->inputMethodQuery(Qt::ImHints).toInt()); + int cursorPosition = m_inputContext->inputMethodQuery(Qt::ImCursorPosition).toInt(); + QRectF cursorRectangle = qApp->inputMethod()->cursorRectangle(); + QString surroundingText = m_inputContext->inputMethodQuery(Qt::ImSurroundingText).toString(); + QString selectedText = m_inputContext->inputMethodQuery(Qt::ImCurrentSelection).toString(); + + // check against changes + bool newInputMethodHints = inputMethodHints != m_inputMethodHints; + bool newSurroundingText = surroundingText != m_surroundingText; + bool newSelectedTextChange = selectedText != m_selectedText; + bool newCursorPosition = cursorPosition != m_cursorPosition; + bool newCursorRectangle = cursorRectangle != m_cursorRectangle; + + // update + m_inputMethodHints = inputMethodHints; + m_surroundingText = surroundingText; + m_selectedText = selectedText; + m_cursorPosition = cursorPosition; + m_cursorRectangle = cursorRectangle; + + // notify + if (newInputMethodHints) + emit inputMethodHintsChanged(); + if (newSurroundingText) + emit surroundingTextChanged(); + if (newSelectedTextChange) + emit selectedTextChanged(); + if (newCursorPosition) + emit cursorPositionChanged(); + if (newCursorRectangle) + emit cursorRectangleChanged(); +} + +void DeclarativeInputContext::registerCharacterKey(QQuickItem *key) +{ + m_characterKeys.append(key); +} + +void DeclarativeInputContext::unregisterCharacterKey(QQuickItem *key) +{ + m_characterKeys.removeOne(key); +} + +void DeclarativeInputContext::handleUppercasing(bool uppercased) +{ + foreach(QQuickItem* key, m_characterKeys) + key->setProperty("uppercased", uppercased); +} diff --git a/src/imports/virtualkeyboard/platforminputcontext/declarativeinputcontext.h b/src/imports/virtualkeyboard/platforminputcontext/declarativeinputcontext.h new file mode 100644 index 0000000..cb695ab --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/declarativeinputcontext.h @@ -0,0 +1,149 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef DECLARATIVEINPUTCONTEXT_H +#define DECLARATIVEINPUTCONTEXT_H + +#include <QObject> +#include <QRectF> +#include <QFont> +#include <QtQml/qqml.h> + +class PlatformInputContext; +class QQuickItem; + +class DeclarativeInputContext : public QObject +{ + Q_OBJECT + Q_PROPERTY(bool inputMethodVisible READ inputMethodVisible NOTIFY inputMethodVisibleChanged) + Q_PROPERTY(bool focus READ focus NOTIFY focusChanged) + Q_PROPERTY(bool shift READ shift WRITE setShift NOTIFY shiftChanged) + Q_PROPERTY(bool capsLock READ capsLock WRITE setCapsLock NOTIFY capsLockChanged) + Q_PROPERTY(int cursorPosition READ cursorPosition NOTIFY cursorPositionChanged) + Q_PROPERTY(Qt::InputMethodHints inputMethodHints READ inputMethodHints NOTIFY inputMethodHintsChanged) + Q_PROPERTY(QString preeditText READ preeditText WRITE setPreeditText NOTIFY preeditTextChanged) + Q_PROPERTY(QString surroundingText READ surroundingText NOTIFY surroundingTextChanged) + Q_PROPERTY(QString selectedText READ selectedText NOTIFY selectedTextChanged) + Q_PROPERTY(QRectF cursorRectangle READ cursorRectangle NOTIFY cursorRectangleChanged) + Q_PROPERTY(QRectF keyboardRectangle READ keyboardRectangle WRITE setKeyboardRectangle NOTIFY keyboardRectangleChanged) + +public: + explicit DeclarativeInputContext(PlatformInputContext *parent = 0); + ~DeclarativeInputContext(); + + bool inputMethodVisible() const; + void setInputMethodVisibleProperty(bool visible); + + bool focus() const; + void setFocus(bool enable); + + bool shift() const; + void setShift(bool enable); + + bool capsLock() const; + void setCapsLock(bool enable); + + int cursorPosition() const; + + Qt::InputMethodHints inputMethodHints() const; + + QString preeditText() const; + void setPreeditText(const QString &text); + + QString surroundingText() const; + + QString selectedText() const; + + QRectF cursorRectangle() const; + + QRectF keyboardRectangle() const; + Q_INVOKABLE void setKeyboardRectangle(QRectF rectangle); + + Q_INVOKABLE void sendKeyClick(int key, const QString &text, int modifiers = 0); + Q_INVOKABLE void sendPreedit(const QString &text, int cursor = -1); + + Q_INVOKABLE void commit(); + Q_INVOKABLE void commit(const QString &text, int replacementStart = 0, int replacementEnd = 0); + + Q_INVOKABLE void clear(); + + Q_INVOKABLE void setAnimating(bool animating); + Q_INVOKABLE void setLocale(QString name); + + void update(Qt::InputMethodQueries queries); + + Q_INVOKABLE void registerCharacterKey(QQuickItem * key); + Q_INVOKABLE void unregisterCharacterKey(QQuickItem * key); + Q_INVOKABLE void handleUppercasing(bool uppercased); + +signals: + void inputMethodVisibleChanged(); + void focusChanged(); + void preeditTextChanged(); + void surroundingTextChanged(); + void selectedTextChanged(); + void cursorPositionChanged(); + void inputMethodHintsChanged(); + void focusEditorChanged(); + void shiftChanged(); + void capsLockChanged(); + void cursorRectangleChanged(); + void keyboardRectangleChanged(); + +private: + void updateInputMethodValues(); + + PlatformInputContext *m_inputContext; + bool m_inputMethodVisible; + bool m_focus; + bool m_shift; + bool m_capsLock; + int m_cursorPosition; + Qt::InputMethodHints m_inputMethodHints; + QString m_preeditText; + QString m_surroundingText; + QString m_selectedText; + QRectF m_cursorRectangle; + QList<QQuickItem *> m_characterKeys; +}; + +QML_DECLARE_TYPE(DeclarativeInputContext) + +#endif diff --git a/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.cpp b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.cpp new file mode 100644 index 0000000..a73a15a --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.cpp @@ -0,0 +1,162 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include "platforminputcontext.h" +#include "declarativeinputcontext.h" + +#include <QWindow> +#include <QInputMethod> +#include <QGuiApplication> +#include <qdebug.h> + +PlatformInputContext::PlatformInputContext() : + m_declarativeContext(0), m_animating(false), m_visible(false), + m_focusObject(0), m_locale("en_GB"), m_inputDirection(Qt::LeftToRight) +{ +} + +PlatformInputContext::~PlatformInputContext() +{ +} + +bool PlatformInputContext::isValid() const +{ + return true; +} + +bool PlatformInputContext::isAnimating() const +{ + return m_animating; +} + +bool PlatformInputContext::isInputPanelVisible() const +{ + return m_visible; +} + +QRectF PlatformInputContext::keyboardRect() const +{ + return m_keyboardRect; +} + +QLocale PlatformInputContext::locale() const +{ + return m_locale; +} + +Qt::LayoutDirection PlatformInputContext::inputDirection() const +{ + return m_inputDirection; +} + +void PlatformInputContext::reset() +{ + if (m_declarativeContext) + m_declarativeContext->commit(); +} + +void PlatformInputContext::update(Qt::InputMethodQueries queries) +{ + if (m_declarativeContext) + m_declarativeContext->update(queries); +} + +void PlatformInputContext::showInputPanel() { + if (!m_visible) { + m_visible = true; + if (m_declarativeContext) { + m_declarativeContext->setInputMethodVisibleProperty(true); + } + emitInputPanelVisibleChanged(); + } +} + +void PlatformInputContext::hideInputPanel() { + if (m_visible) { + m_visible = false; + if (m_declarativeContext) { + m_declarativeContext->setInputMethodVisibleProperty(false); + } + emitInputPanelVisibleChanged(); + } +} + +void PlatformInputContext::setFocusObject(QObject *object) +{ + m_focusObject = object; + bool enabled = false; + if (m_focusObject) { + QInputMethodQueryEvent event(Qt::ImEnabled); + sendEvent(&event); + enabled = event.value(Qt::ImEnabled).toBool(); + } + if (m_declarativeContext) { + bool focus = (object != 0 && enabled); + m_declarativeContext->setFocus(focus); + if (focus) + m_declarativeContext->update(Qt::ImQueryAll); + else + hideInputPanel(); + } +} + +void PlatformInputContext::sendEvent(QEvent *event) +{ + if (m_focusObject) + QGuiApplication::sendEvent(m_focusObject, event); +} + +void PlatformInputContext::sendKeyEvent(QKeyEvent *event) +{ + if (qApp && qApp->focusWindow()) + QGuiApplication::sendEvent(qApp->focusWindow(), event); +} + +QVariant PlatformInputContext::inputMethodQuery(Qt::InputMethodQuery query) +{ + QInputMethodQueryEvent event(query); + sendEvent(&event); + return event.value(query); +} + +void PlatformInputContext::setDeclarativeContext(DeclarativeInputContext *context) +{ + m_declarativeContext = context; +} diff --git a/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.h b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.h new file mode 100644 index 0000000..bcfae44 --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.h @@ -0,0 +1,89 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#ifndef PLATFORMINPUTCONTEXT_H +#define PLATFORMINPUTCONTEXT_H + +#include <qevent.h> +#include <qpa/qplatforminputcontext.h> +#include <QPointer> +#include <QLocale> + +class DeclarativeInputContext; +class PlatformInputContext : public QPlatformInputContext +{ + Q_OBJECT +public: + explicit PlatformInputContext(); + ~PlatformInputContext(); + + // from QPlatformInputContext + virtual bool isValid() const; + virtual bool isAnimating() const; + virtual bool isInputPanelVisible() const; + virtual QRectF keyboardRect() const; + virtual QLocale locale() const; + virtual Qt::LayoutDirection inputDirection() const; + + void reset(); + void update(Qt::InputMethodQueries queries); + virtual void showInputPanel(); + virtual void hideInputPanel(); + virtual void setFocusObject(QObject *object); + +protected: + void sendEvent(QEvent *event); + void sendKeyEvent(QKeyEvent *event); + QVariant inputMethodQuery(Qt::InputMethodQuery query); + void setDeclarativeContext(DeclarativeInputContext *context); + +protected: + friend class DeclarativeInputContext; + + DeclarativeInputContext *m_declarativeContext; + bool m_animating; + bool m_visible; + QRectF m_keyboardRect; + QPointer<QObject> m_focusObject; + QLocale m_locale; + Qt::LayoutDirection m_inputDirection; +}; + +#endif diff --git a/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.json b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.json new file mode 100644 index 0000000..266da3c --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.json @@ -0,0 +1,3 @@ +{ + "Keys": [ "b2qtinputcontext" ] +} diff --git a/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.pro b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.pro new file mode 100644 index 0000000..e2288fe --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/platforminputcontext.pro @@ -0,0 +1,21 @@ +TEMPLATE = lib +TARGET = b2qtinputcontextplugin +TARGETPATH = $$[QT_INSTALL_PLUGINS]/platforminputcontexts + +target.path = $$TARGETPATH + +QT += quick gui gui-private + +CONFIG += plugin + +SOURCES += platforminputcontext.cpp \ + declarativeinputcontext.cpp \ + plugin.cpp + +HEADERS += platforminputcontext.h \ + declarativeinputcontext.h + +OTHER_FILES = $$$PWD/platforminputcontext.json + +INSTALLS += target +OTHER += platforminputcontext.json diff --git a/src/imports/virtualkeyboard/platforminputcontext/plugin.cpp b/src/imports/virtualkeyboard/platforminputcontext/plugin.cpp new file mode 100644 index 0000000..f63205f --- /dev/null +++ b/src/imports/virtualkeyboard/platforminputcontext/plugin.cpp @@ -0,0 +1,83 @@ +/**************************************************************************** +** +** Copyright (C) 2012 Nokia Corporation and/or its subsidiary(-ies). +** Contact: http://www.qt-project.org/ +** +** This file is part of the examples of the Qt Toolkit. +** +** $QT_BEGIN_LICENSE:BSD$ +** You may use this file under the terms of the BSD license as follows: +** +** "Redistribution and use in source and binary forms, with or without +** modification, are permitted provided that the following conditions are +** met: +** * Redistributions of source code must retain the above copyright +** notice, this list of conditions and the following disclaimer. +** * Redistributions in binary form must reproduce the above copyright +** notice, this list of conditions and the following disclaimer in +** the documentation and/or other materials provided with the +** distribution. +** * Neither the name of Nokia Corporation and its Subsidiary(-ies) nor +** the names of its contributors may be used to endorse or promote +** products derived from this software without specific prior written +** permission. +** +** THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +** "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +** LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR +** A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT +** OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, +** SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT +** LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, +** DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY +** THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +** (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE +** OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE." +** +** $QT_END_LICENSE$ +** +****************************************************************************/ + +#include <QDebug> +#include <QStringList> +#include <qpa/qplatforminputcontextplugin_p.h> + +#include "platforminputcontext.h" +#include "declarativeinputcontext.h" + +static PlatformInputContext *platformInputContext = 0; + +static QObject *createInputContextModule(QQmlEngine *engine, QJSEngine *scriptEngine) +{ + Q_UNUSED(engine); + Q_UNUSED(scriptEngine); + return new DeclarativeInputContext(platformInputContext); +} + +class PlatformInputContextPlugin : public QPlatformInputContextPlugin +{ + Q_OBJECT + Q_PLUGIN_METADATA(IID "org.qt-project.Qt.QPlatformInputContextFactoryInterface" FILE "platforminputcontext.json") + +public: + QStringList keys() const; + QPlatformInputContext *create(const QString&, const QStringList&); +}; + +QStringList PlatformInputContextPlugin::keys() const +{ + return QStringList(QStringLiteral("b2qtinputcontext")); +} + +QPlatformInputContext *PlatformInputContextPlugin::create(const QString& system, const QStringList& paramList) +{ + Q_UNUSED(paramList); + + qmlRegisterSingletonType<DeclarativeInputContext>("Boot2Qt.InputContext", 1, 0, "InputContext", createInputContextModule); + + if (system.compare(system, QStringLiteral("b2qtinputcontext"), Qt::CaseInsensitive) == 0) + platformInputContext = new PlatformInputContext; + return platformInputContext; +} + +#include "plugin.moc" |