16 files changed, 939 insertions, 968 deletions

diff --git a/src/plugins/platforms/qnx/qnx.pro b/src/plugins/platforms/qnx/qnx.pro
index bc7219de5c..100db54a5c 100644
--- a/src/plugins/platforms/qnx/qnx.pro
+++ b/src/plugins/platforms/qnx/qnx.pro
@@ -62,7 +62,8 @@ HEADERS =   main.h \
             qqnxabstractcover.h \
             qqnxservices.h \
             qqnxcursor.h \
-            qqnxrasterwindow.h
+            qqnxrasterwindow.h \
+            qqnxscreeneventfilter.h
 
 CONFIG(qqnx_screeneventthread) {
     DEFINES += QQNX_SCREENEVENTTHREAD
diff --git a/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.cpp b/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.cpp
index a42f73415e..1d8591cfa1 100644
--- a/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.cpp
+++ b/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -62,23 +62,19 @@ void QQnxAbstractVirtualKeyboard::setKeyboardMode(KeyboardMode mode)
     applyKeyboardMode(mode);
 }
 
-void QQnxAbstractVirtualKeyboard::setInputHintsFromObject(QObject *focusObject)
+void QQnxAbstractVirtualKeyboard::setInputHints(int inputHints)
 {
-    if (focusObject) {
-        const Qt::InputMethodHints hints = static_cast<Qt::InputMethodHints>(
-                    focusObject->property("inputMethodHints").toInt());
-        if (hints & Qt::ImhEmailCharactersOnly) {
-            setKeyboardMode(QQnxAbstractVirtualKeyboard::Email);
-        } else if (hints & Qt::ImhDialableCharactersOnly) {
-            setKeyboardMode(QQnxAbstractVirtualKeyboard::Phone);
-        } else if (hints & Qt::ImhUrlCharactersOnly) {
-            setKeyboardMode(QQnxAbstractVirtualKeyboard::Web);
-        } else if (hints & Qt::ImhFormattedNumbersOnly || hints & Qt::ImhDigitsOnly ||
-                   hints & Qt::ImhDate || hints & Qt::ImhTime) {
-            setKeyboardMode(QQnxAbstractVirtualKeyboard::NumPunc);
-        } else {
-            setKeyboardMode(QQnxAbstractVirtualKeyboard::Default);
-        }
+    if (inputHints & Qt::ImhEmailCharactersOnly) {
+        setKeyboardMode(QQnxAbstractVirtualKeyboard::Email);
+    } else if (inputHints & Qt::ImhDialableCharactersOnly) {
+        setKeyboardMode(QQnxAbstractVirtualKeyboard::Phone);
+    } else if (inputHints & Qt::ImhUrlCharactersOnly) {
+        setKeyboardMode(QQnxAbstractVirtualKeyboard::Web);
+    } else if (inputHints & Qt::ImhFormattedNumbersOnly || inputHints & Qt::ImhDigitsOnly ||
+               inputHints & Qt::ImhDate || inputHints & Qt::ImhTime) {
+        setKeyboardMode(QQnxAbstractVirtualKeyboard::NumPunc);
+    } else if (inputHints & Qt::ImhHiddenText) {
+        setKeyboardMode(QQnxAbstractVirtualKeyboard::Password);
     } else {
         setKeyboardMode(QQnxAbstractVirtualKeyboard::Default);
     }
diff --git a/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.h b/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.h
index 9b911e1dec..033d8ebb74 100644
--- a/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.h
+++ b/src/plugins/platforms/qnx/qqnxabstractvirtualkeyboard.h
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -59,10 +59,11 @@ public:
     // Symbol - All symbols, alternate to NumPunc, currently unused.
     // Phone - Phone enhanced keyboard - currently unused as no alternate keyboard available to access a-zA-Z
     // Pin - Keyboard for entering Pins (Hex values) currently unused.
+    // Password - Keyboard for entering passwords.
     //
     // SPECIAL NOTE: Usage of NumPunc may have to be removed, ABC button is non-functional.
     //
-    enum KeyboardMode { Default, Url, Email, Web, NumPunc, Symbol, Phone, Pin };
+    enum KeyboardMode { Default, Url, Email, Web, NumPunc, Symbol, Phone, Pin, Password };
 
     explicit QQnxAbstractVirtualKeyboard(QObject *parent = 0);
 
@@ -74,7 +75,7 @@ public:
     QLocale locale() const { return m_locale; }
 
     void setKeyboardMode(KeyboardMode mode);
-    void setInputHintsFromObject(QObject *focusObject);
+    void setInputHints(int inputHints);
     KeyboardMode keyboardMode() const { return m_keyboardMode; }
 
 Q_SIGNALS:
diff --git a/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp b/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
index 580553f6e2..619883e843 100644
--- a/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
+++ b/src/plugins/platforms/qnx/qqnxinputcontext_imf.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -40,10 +40,10 @@
 ****************************************************************************/
 
 #include "qqnxinputcontext_imf.h"
-#include "qqnxeventthread.h"
 #include "qqnxabstractvirtualkeyboard.h"
 #include "qqnxintegration.h"
 #include "qqnxscreen.h"
+#include "qqnxscreeneventhandler.h"
 
 #include <QtGui/QGuiApplication>
 #include <QtGui/QInputMethodEvent>
@@ -54,6 +54,8 @@
 #include <QtCore/QVariant>
 #include <QtCore/QVariantHash>
 #include <QtCore/QWaitCondition>
+#include <QtCore/QQueue>
+#include <QtCore/QGlobalStatic>
 
 #include <dlfcn.h>
 #include "imf/imf_client.h"
@@ -62,9 +64,9 @@
 #include <sys/keycodes.h>
 
 #if defined(QQNXINPUTCONTEXT_IMF_EVENT_DEBUG)
-#define qInputContextIMFEventDebug qDebug
+#define qInputContextIMFRequestDebug qDebug
 #else
-#define qInputContextIMFEventDebug QT_NO_QDEBUG_MACRO
+#define qInputContextIMFRequestDebug QT_NO_QDEBUG_MACRO
 #endif
 
 #if defined(QQNXINPUTCONTEXT_DEBUG)
@@ -73,492 +75,426 @@
 #define qInputContextDebug QT_NO_QDEBUG_MACRO
 #endif
 
-/** TODO:
-    Support inputMethodHints to restrict input (needs additional features in IMF).
-*/
+static QQnxInputContext *sInputContextInstance;
+static QColor sSelectedColor(0,0xb8,0,85);
 
-#define STRX(x) #x
-#define STR(x) STRX(x)
-
-// Someone tell me why input_control methods are in this namespace, but the rest is not.
-using namespace InputMethodSystem;
-
-#define qs(x) QString::fromLatin1(x)
-#define iarg(name) event->mArgs[qs(#name)] = QVariant::fromValue(name)
-#define parg(name) event->mArgs[qs(#name)] = QVariant::fromValue((void*)name)
-namespace
-{
-
-spannable_string_t *toSpannableString(const QString &text);
+static const input_session_t *sSpellCheckSession = 0;
 static const input_session_t *sInputSession = 0;
-bool isSessionOkay(input_session_t *ic)
+static bool isSessionOkay(input_session_t *ic)
 {
     return ic !=0 && sInputSession != 0 && ic->component_id == sInputSession->component_id;
 }
 
 enum ImfEventType
 {
-    ImfBeginBatchEdit,
-    ImfClearMetaKeyStates,
     ImfCommitText,
     ImfDeleteSurroundingText,
-    ImfEndBatchEdit,
     ImfFinishComposingText,
-    ImfGetCursorCapsMode,
     ImfGetCursorPosition,
-    ImfGetExtractedText,
-    ImfGetSelectedText,
     ImfGetTextAfterCursor,
     ImfGetTextBeforeCursor,
-    ImfPerformEditorAction,
-    ImfReportFullscreenMode,
     ImfSendEvent,
-    ImfSendAsyncEvent,
     ImfSetComposingRegion,
     ImfSetComposingText,
-    ImfSetSelection
+    ImfIsTextSelected,
+    ImfIsAllTextSelected,
 };
 
-// We use this class as a round about way to support a posting synchronous event into
-// Qt's main thread from the IMF thread.
-class ImfEventResult
-{
-public:
-    ImfEventResult()
-    {
-        m_mutex.lock();
-    }
-
-    ~ImfEventResult()
-    {
-        m_mutex.unlock();
-    }
-
-    void wait()
-    {
-        m_wait.wait(&m_mutex);
-    }
-
-    void signal()
-    {
-        m_wait.wakeAll();
-    }
-
-    void setResult(const QVariant& result)
-    {
-        m_mutex.lock();
-        m_retVal = result;
-        signal();
-        m_mutex.unlock();
-    }
-
-    QVariant result()
-    {
-        return m_retVal;
-    }
-
-private:
-    QVariant m_retVal;
-    QMutex m_mutex;
-    QWaitCondition m_wait;
+struct SpellCheckInfo {
+    SpellCheckInfo(void *_context, void (*_spellCheckDone)(void *, const QString &, const QList<int> &))
+        : context(_context), spellCheckDone(_spellCheckDone) {}
+    void *context;
+    void (*spellCheckDone)(void *, const QString &, const QList<int> &);
 };
+Q_GLOBAL_STATIC(QQueue<SpellCheckInfo>, sSpellCheckQueue)
 
-class ImfEvent : public QEvent
+// IMF requests all arrive on IMF's own thread and have to be posted to the main thread to be processed.
+class QQnxImfRequest
 {
-    public:
-        ImfEvent(input_session_t *session, ImfEventType type, ImfEventResult *result) :
-            QEvent((QEvent::Type)sUserEventType),
-            m_session(session),
-            m_imfType(type),
-            m_result(result)
-        {
-        }
-        ~ImfEvent() { }
-
-    input_session_t *m_session;
-    ImfEventType m_imfType;
-    QVariantHash m_args;
-    ImfEventResult *m_result;
-
-    static int sUserEventType;
+public:
+    QQnxImfRequest(input_session_t *_session, ImfEventType _type)
+        : session(_session), type(_type)
+        { }
+    ~QQnxImfRequest() { }
+
+    input_session_t *session;
+    ImfEventType type;
+    union {
+        struct {
+            int32_t n;
+            int32_t flags;
+            bool before;
+            spannable_string_t *result;
+        } gtac; // ic_get_text_before_cursor/ic_get_text_after_cursor
+        struct {
+            int32_t result;
+        } gcp; // ic_get_cursor_position
+        struct {
+            int32_t start;
+            int32_t end;
+            int32_t result;
+        } scr; // ic_set_composing_region
+        struct {
+            spannable_string_t* text;
+            int32_t new_cursor_position;
+            int32_t result;
+        } sct; // ic_set_composing_text
+        struct {
+            spannable_string_t* text;
+            int32_t new_cursor_position;
+            int32_t result;
+        } ct; // ic_commit_text
+        struct {
+            int32_t result;
+        } fct; // ic_finish_composing_text
+        struct {
+            int32_t left_length;
+            int32_t right_length;
+            int32_t result;
+        } dst; // ic_delete_surrounding_text
+        struct {
+            event_t *event;
+            int32_t result;
+        } sae;  // ic_send_async_event/ic_send_event
+        struct {
+            int32_t *pIsSelected;
+            int32_t result;
+        } its;  // ic_is_text_selected/ic_is_all_text_selected
+    };
 };
-int ImfEvent::sUserEventType = QEvent::registerEventType();
 
-static int32_t imfBeginBatchEdit(input_session_t *ic)
+// Invoke an IMF initiated request synchronously on Qt's main thread.  As describe below all
+// IMF requests are made from another thread but need to be executed on the main thread.
+static void executeIMFRequest(QQnxImfRequest *event)
+{
+    QMetaObject::invokeMethod(sInputContextInstance,
+                              "processImfEvent",
+                              Qt::BlockingQueuedConnection,
+                              Q_ARG(QQnxImfRequest*, event));
+}
+
+// The following functions (ic_*) are callback functions called by the input system to query information
+// about the text object that currently has focus or to make changes to it.  All calls are made from the
+// input system's own thread.  The pattern for each callback function is to copy its parameters into
+// a QQnxImfRequest structure and call executeIMFRequest to have it passed synchronously to Qt's main thread.
+// Any return values should be pre-initialised with suitable default values as in some cases
+// (e.g. a stale session) the call will return without having executed any request specific code.
+//
+// To make the correspondence more obvious, the names of these functions match those defined in the headers.
+// They're in an anonymous namespace to avoid compiler conflicts with external functions defined with the
+// same names.
+namespace
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
 
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfBeginBatchEdit, &result);
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_begin_batch_edit(input_session_t *ic)
+{
+    Q_UNUSED(ic);
 
-    return ret;
+    // Ignore silently.
+    return 0;
 }
 
-static int32_t imfClearMetaKeyStates(input_session_t *ic, int32_t states)
+// End composition, committing the supplied text.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_commit_text(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfClearMetaKeyStates, &result);
-    iarg(states);
-
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
+    QQnxImfRequest event(ic, ImfCommitText);
+    event.ct.text = text;
+    event.ct.new_cursor_position = new_cursor_position;
+    event.ct.result = -1;
+    executeIMFRequest(&event);
 
-    return ret;
+    return event.ct.result;
 }
 
-static int32_t imfCommitText(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position)
+// Delete left_length characters before and right_length characters after the cursor.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_delete_surrounding_text(input_session_t *ic, int32_t left_length, int32_t right_length)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfCommitText, &result);
-    parg(text);
-    iarg(new_cursor_position);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    QQnxImfRequest event(ic, ImfDeleteSurroundingText);
+    event.dst.left_length = left_length;
+    event.dst.right_length = right_length;
+    event.dst.result = -1;
+    executeIMFRequest(&event);
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-
-    return ret;
+    return event.dst.result;
 }
 
-static int32_t imfDeleteSurroundingText(input_session_t *ic, int32_t left_length, int32_t right_length)
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_end_batch_edit(input_session_t *ic)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfDeleteSurroundingText, &result);
-    iarg(left_length);
-    iarg(right_length);
+    Q_UNUSED(ic);
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-
-    return ret;
+    // Ignore silently.
+    return 0;
 }
 
-static int32_t imfEndBatchEdit(input_session_t *ic)
+// End composition, committing what's there.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_finish_composing_text(input_session_t *ic)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfEndBatchEdit, &result);
-
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
+    QQnxImfRequest event(ic, ImfFinishComposingText);
+    event.fct.result = -1;
+    executeIMFRequest(&event);
 
-    return ret;
+    return event.fct.result;
 }
 
-static int32_t imfFinishComposingText(input_session_t *ic)
+// Return the position of the cursor.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_get_cursor_position(input_session_t *ic)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfFinishComposingText, &result);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    QQnxImfRequest event(ic, ImfGetCursorPosition);
+    event.gcp.result = -1;
+    executeIMFRequest(&event);
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-
-    return ret;
+    return event.gcp.result;
 }
 
-static int32_t imfGetCursorCapsMode(input_session_t *ic, int32_t req_modes)
+// Return the n characters after the cursor.
+// See comment at beginning of namespace declaration for general information
+static spannable_string_t *ic_get_text_after_cursor(input_session_t *ic, int32_t n, int32_t flags)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfGetCursorCapsMode, &result);
-    iarg(req_modes);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    QQnxImfRequest event(ic, ImfGetTextAfterCursor);
+    event.gtac.n = n;
+    event.gtac.flags = flags;
+    event.gtac.result = 0;
+    executeIMFRequest(&event);
 
-    int32_t ret = result.result().value<int32_t>();
-    return ret;
+    return event.gtac.result;
 }
 
-static int32_t imfGetCursorPosition(input_session_t *ic)
+// Return the n characters before the cursor.
+// See comment at beginning of namespace declaration for general information
+static spannable_string_t *ic_get_text_before_cursor(input_session_t *ic, int32_t n, int32_t flags)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfGetCursorPosition, &result);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    QQnxImfRequest event(ic, ImfGetTextBeforeCursor);
+    event.gtac.n = n;
+    event.gtac.flags = flags;
+    event.gtac.result = 0;
+    executeIMFRequest(&event);
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-
-    return ret;
+    return event.gtac.result;
 }
 
-static extracted_text_t *imfGetExtractedText(input_session_t *ic, extracted_text_request_t *request, int32_t flags)
+// Process an event from IMF.  Primarily used for reflecting back keyboard events.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_send_event(input_session_t *ic, event_t *event)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic)) {
-        extracted_text_t *et = (extracted_text_t *)calloc(sizeof(extracted_text_t),1);
-        et->text = (spannable_string_t *)calloc(sizeof(spannable_string_t),1);
-        return et;
-    }
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfGetExtractedText, &result);
-    parg(request);
-    iarg(flags);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    QQnxImfRequest imfEvent(ic, ImfSendEvent);
+    imfEvent.sae.event = event;
+    imfEvent.sae.result = -1;
+    executeIMFRequest(&imfEvent);
 
-    result.wait();
-    return result.result().value<extracted_text_t *>();
+    return imfEvent.sae.result;
 }
 
-static spannable_string_t *imfGetSelectedText(input_session_t *ic, int32_t flags)
+// Same as ic_send_event.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_send_async_event(input_session_t *ic, event_t *event)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return toSpannableString("");
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfGetSelectedText, &result);
-    iarg(flags);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    // There's no difference from our point of view between ic_send_event & ic_send_async_event
+    QQnxImfRequest imfEvent(ic, ImfSendEvent);
+    imfEvent.sae.event = event;
+    imfEvent.sae.result = -1;
+    executeIMFRequest(&imfEvent);
 
-    result.wait();
-    return result.result().value<extracted_text_t *>();
+    return imfEvent.sae.result;
 }
 
-static spannable_string_t *imfGetTextAfterCursor(input_session_t *ic, int32_t n, int32_t flags)
+// Set the range of text between start and end as the composition range.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_set_composing_region(input_session_t *ic, int32_t start, int32_t end)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return toSpannableString("");
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfGetTextAfterCursor, &result);
-    iarg(n);
-    iarg(flags);
+    QQnxImfRequest event(ic, ImfSetComposingRegion);
+    event.scr.start = start;
+    event.scr.end = end;
+    event.scr.result = -1;
+    executeIMFRequest(&event);
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    return result.result().value<extracted_text_t *>();
+    return event.scr.result;
 }
 
-static spannable_string_t *imfGetTextBeforeCursor(input_session_t *ic, int32_t n, int32_t flags)
+// Update the composition range with the supplied text.  This can be called when no composition
+// range is in effect in which case one is started at the current cursor position.
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_set_composing_text(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return toSpannableString("");
+    QQnxImfRequest event(ic, ImfSetComposingText);
+    event.sct.text = text;
+    event.sct.new_cursor_position = new_cursor_position;
+    event.sct.result = -1;
+    executeIMFRequest(&event);
 
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfGetTextBeforeCursor, &result);
-    iarg(n);
-    iarg(flags);
-
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    return result.result().value<extracted_text_t *>();
+    return event.sct.result;
 }
 
-static int32_t imfPerformEditorAction(input_session_t *ic, int32_t editor_action)
+// Indicate if any text is selected
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_is_text_selected(input_session_t* ic, int32_t* pIsSelected)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfPerformEditorAction, &result);
-    iarg(editor_action);
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+    QQnxImfRequest event(ic, ImfIsTextSelected);
+    event.its.pIsSelected = pIsSelected;
+    event.its.result = -1;
+    executeIMFRequest(&event);
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-    return ret;
+    return event.its.result;
 }
 
-static int32_t imfReportFullscreenMode(input_session_t *ic, int32_t enabled)
+// Indicate if all text is selected
+// See comment at beginning of namespace declaration for general information
+static int32_t ic_is_all_text_selected(input_session_t* ic, int32_t* pIsSelected)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
+    qInputContextIMFRequestDebug() << Q_FUNC_INFO;
 
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfReportFullscreenMode, &result);
-    iarg(enabled);
+    QQnxImfRequest event(ic, ImfIsAllTextSelected);
+    event.its.pIsSelected = pIsSelected;
+    event.its.result = -1;
+    executeIMFRequest(&event);
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
-
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-    return ret;
+    return event.its.result;
 }
 
-static int32_t imfSendEvent(input_session_t *ic, event_t *event)
-{
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEvent *imfEvent = new ImfEvent(ic, ImfSendEvent, 0);
-    imfEvent->m_args[qs("event")] = QVariant::fromValue(static_cast<void *>(event));
+// LCOV_EXCL_START - exclude from code coverage analysis
+// The following functions are defined in the IMF headers but are not currently called.
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), imfEvent);
+// Not currently used
+static int32_t ic_perform_editor_action(input_session_t *ic, int32_t editor_action)
+{
+    Q_UNUSED(ic);
+    Q_UNUSED(editor_action);
 
+    qCritical() << "ic_perform_editor_action not implemented";
     return 0;
 }
 
-static int32_t imfSendAsyncEvent(input_session_t *ic, event_t *event)
+// Not currently used
+static int32_t ic_report_fullscreen_mode(input_session_t *ic, int32_t enabled)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    ImfEvent *imfEvent = new ImfEvent(ic, ImfSendAsyncEvent, 0);
-    imfEvent->m_args[qs("event")] = QVariant::fromValue(static_cast<void *>(event));
-
-    QCoreApplication::postEvent(QCoreApplication::instance(), imfEvent);
+    Q_UNUSED(ic);
+    Q_UNUSED(enabled);
 
+    qCritical() << "ic_report_fullscreen_mode not implemented";
     return 0;
 }
 
-static int32_t imfSetComposingRegion(input_session_t *ic, int32_t start, int32_t end)
+// Not currently used
+static extracted_text_t *ic_get_extracted_text(input_session_t *ic, extracted_text_request_t *request, int32_t flags)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
+    Q_UNUSED(ic);
+    Q_UNUSED(request);
+    Q_UNUSED(flags);
 
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfSetComposingRegion, &result);
-    iarg(start);
-    iarg(end);
+    qCritical() << "ic_get_extracted_text not implemented";
+    return 0;
+}
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+// Not currently used
+static spannable_string_t *ic_get_selected_text(input_session_t *ic, int32_t flags)
+{
+    Q_UNUSED(ic);
+    Q_UNUSED(flags);
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-    return ret;
+    qCritical() << "ic_get_selected_text not implemented";
+    return 0;
 }
 
-static int32_t imfSetComposingText(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position)
+// Not currently used
+static int32_t ic_get_cursor_caps_mode(input_session_t *ic, int32_t req_modes)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
+    Q_UNUSED(ic);
+    Q_UNUSED(req_modes);
 
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfSetComposingText, &result);
-    parg(text);
-    iarg(new_cursor_position);
+    qCritical() << "ic_get_cursor_caps_mode not implemented";
+    return 0;
+}
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+// Not currently used
+static int32_t ic_clear_meta_key_states(input_session_t *ic, int32_t states)
+{
+    Q_UNUSED(ic);
+    Q_UNUSED(states);
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-    return ret;
+    qCritical() << "ic_clear_meta_key_states not implemented";
+    return 0;
 }
 
-static int32_t imfSetSelection(input_session_t *ic, int32_t start, int32_t end)
+// Not currently used
+static int32_t ic_set_selection(input_session_t *ic, int32_t start, int32_t end)
 {
-    qInputContextIMFEventDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
+    Q_UNUSED(ic);
+    Q_UNUSED(start);
+    Q_UNUSED(end);
 
-    ImfEventResult result;
-    ImfEvent *event = new ImfEvent(ic, ImfSetSelection, &result);
-    iarg(start);
-    iarg(end);
+    qCritical() << "ic_set_selection not implemented";
+    return 0;
+}
 
-    QCoreApplication::postEvent(QCoreApplication::instance(), event);
+// End of un-hittable code
+// LCOV_EXCL_STOP
 
-    result.wait();
-    int32_t ret = result.result().value<int32_t>();
-    return ret;
-}
 
 static connection_interface_t ic_funcs = {
-    imfBeginBatchEdit,
-    imfClearMetaKeyStates,
-    imfCommitText,
-    imfDeleteSurroundingText,
-    imfEndBatchEdit,
-    imfFinishComposingText,
-    imfGetCursorCapsMode,
-    imfGetCursorPosition,
-    imfGetExtractedText,
-    imfGetSelectedText,
-    imfGetTextAfterCursor,
-    imfGetTextBeforeCursor,
-    imfPerformEditorAction,
-    imfReportFullscreenMode,
-    NULL, //ic_send_key_event
-    imfSendEvent,
-    imfSendAsyncEvent,
-    imfSetComposingRegion,
-    imfSetComposingText,
-    imfSetSelection,
-    NULL, //ic_set_candidates,
+    ic_begin_batch_edit,
+    ic_clear_meta_key_states,
+    ic_commit_text,
+    ic_delete_surrounding_text,
+    ic_end_batch_edit,
+    ic_finish_composing_text,
+    ic_get_cursor_caps_mode,
+    ic_get_cursor_position,
+    ic_get_extracted_text,
+    ic_get_selected_text,
+    ic_get_text_after_cursor,
+    ic_get_text_before_cursor,
+    ic_perform_editor_action,
+    ic_report_fullscreen_mode,
+    0, //ic_send_key_event
+    ic_send_event,
+    ic_send_async_event,
+    ic_set_composing_region,
+    ic_set_composing_text,
+    ic_set_selection,
+    0, //ic_set_candidates,
+    0, //ic_get_cursor_offset,
+    0, //ic_get_selection,
+    ic_is_text_selected,
+    ic_is_all_text_selected,
+    0, //ic_get_max_cursor_offset_t
 };
 
+} // namespace
+
 static void
-initEvent(event_t *pEvent, const input_session_t *pSession, EventType eventType, int eventId)
+initEvent(event_t *pEvent, const input_session_t *pSession, EventType eventType, int eventId, int eventSize)
 {
     static int s_transactionId;
 
     // Make sure structure is squeaky clean since it's not clear just what is significant.
-    memset(pEvent, 0, sizeof(event_t));
+    memset(pEvent, 0, eventSize);
     pEvent->event_type = eventType;
     pEvent->event_id = eventId;
     pEvent->pid = getpid();
@@ -566,31 +502,20 @@ initEvent(event_t *pEvent, const input_session_t *pSession, EventType eventType,
     pEvent->transaction_id = ++s_transactionId;
 }
 
-spannable_string_t *toSpannableString(const QString &text)
+static spannable_string_t *toSpannableString(const QString &text)
 {
     qInputContextDebug() << Q_FUNC_INFO << text;
 
-    spannable_string_t *pString = reinterpret_cast<spannable_string_t *>(malloc(sizeof(spannable_string_t)));
-    pString->str = (wchar_t *)malloc(sizeof(wchar_t) * text.length() + 1);
-    pString->length = text.length();
+    spannable_string_t *pString = static_cast<spannable_string_t *>(malloc(sizeof(spannable_string_t)));
+    pString->str =  static_cast<wchar_t *>(malloc(sizeof(wchar_t) * text.length() + 1));
+    pString->length = text.toWCharArray(pString->str);
     pString->spans = 0;
     pString->spans_count = 0;
-
-    const QChar *pData = text.constData();
-    wchar_t *pDst = pString->str;
-
-    while (!pData->isNull())
-    {
-        *pDst = pData->unicode();
-        pDst++;
-        pData++;
-    }
-    *pDst = 0;
+    pString->str[pString->length] = 0;
 
     return pString;
 }
 
-} // namespace
 
 static const input_session_t *(*p_ictrl_open_session)(connection_interface_t *) = 0;
 static void (*p_ictrl_close_session)(input_session_t *) = 0;
@@ -645,27 +570,30 @@ QT_BEGIN_NAMESPACE
 
 QQnxInputContext::QQnxInputContext(QQnxIntegration *integration, QQnxAbstractVirtualKeyboard &keyboard) :
          QPlatformInputContext(),
-         m_lastCaretPos(0),
+         m_caretPosition(0),
          m_isComposing(false),
+         m_isUpdatingText(false),
          m_inputPanelVisible(false),
          m_inputPanelLocale(QLocale::c()),
+         m_focusObject(0),
          m_integration(integration),
-         m_virtualKeyboad(keyboard)
+         m_virtualKeyboard(keyboard)
 {
     qInputContextDebug() << Q_FUNC_INFO;
 
     if (!imfAvailable())
         return;
 
-    if ( p_imf_client_init() != 0 ) {
+    // Save a pointer to ourselves so we can execute calls from IMF through executeIMFRequest
+    // In practice there will only ever be a single instance.
+    Q_ASSERT(sInputContextInstance == 0);
+    sInputContextInstance = this;
+
+    if (p_imf_client_init() != 0) {
         s_imfInitFailed = true;
         qCritical("imf_client_init failed - IMF services will be unavailable");
     }
 
-    QCoreApplication::instance()->installEventFilter(this);
-
-    // p_vkb_init_selection_service();
-
     connect(&keyboard, SIGNAL(visibilityChanged(bool)), this, SLOT(keyboardVisibilityChanged(bool)));
     connect(&keyboard, SIGNAL(localeChanged(QLocale)), this, SLOT(keyboardLocaleChanged(QLocale)));
     keyboardVisibilityChanged(keyboard.isVisible());
@@ -676,168 +604,75 @@ QQnxInputContext::~QQnxInputContext()
 {
     qInputContextDebug() << Q_FUNC_INFO;
 
+    Q_ASSERT(sInputContextInstance == this);
+    sInputContextInstance = 0;
+
     if (!imfAvailable())
         return;
 
-    QCoreApplication::instance()->removeEventFilter(this);
     p_imf_client_disconnect();
 }
 
-#define getarg(type, name) type name = imfEvent->mArgs[qs(#name)].value<type>()
-#define getparg(type, name) type name = (type)(imfEvent->mArgs[qs(#name)].value<void*>())
-
 bool QQnxInputContext::isValid() const
 {
     return imfAvailable();
 }
 
-bool QQnxInputContext::eventFilter(QObject *obj, QEvent *event)
+void QQnxInputContext::processImfEvent(QQnxImfRequest *imfEvent)
 {
-    if (event->type() == ImfEvent::sUserEventType) {
-        // Forward the event to our real handler.
-        ImfEvent *imfEvent = static_cast<ImfEvent *>(event);
-        switch (imfEvent->m_imfType) {
-        case ImfBeginBatchEdit: {
-            int32_t ret = onBeginBatchEdit(imfEvent->m_session);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfClearMetaKeyStates: {
-            getarg(int32_t, states);
-            int32_t ret = onClearMetaKeyStates(imfEvent->m_session, states);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfCommitText: {
-            getparg(spannable_string_t*, text);
-            getarg(int32_t, new_cursor_position);
-            int32_t ret = onCommitText(imfEvent->m_session, text, new_cursor_position);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfDeleteSurroundingText: {
-            getarg(int32_t, left_length);
-            getarg(int32_t, right_length);
-            int32_t ret = onDeleteSurroundingText(imfEvent->m_session, left_length, right_length);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfEndBatchEdit: {
-            int32_t ret = onEndBatchEdit(imfEvent->m_session);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfFinishComposingText: {
-            int32_t ret = onFinishComposingText(imfEvent->m_session);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfGetCursorCapsMode: {
-            getarg(int32_t, req_modes);
-            int32_t ret = onGetCursorCapsMode(imfEvent->m_session, req_modes);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfGetCursorPosition: {
-            int32_t ret = onGetCursorPosition(imfEvent->m_session);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-
-        case ImfGetExtractedText: {
-            getparg(extracted_text_request_t*, request);
-            getarg(int32_t, flags);
-            extracted_text_t *ret = onGetExtractedText(imfEvent->m_session, request, flags);
-            imfEvent->m_result->setResult(QVariant::fromValue(static_cast<void *>(ret)));
-            break;
-        }
+    // If input session is no longer current, just bail, imfEvent should already be set with the appropriate
+    // return value.  The only exception is spell check events since they're not associated with the
+    // object with focus.
+    if (imfEvent->type != ImfSendEvent || imfEvent->sae.event->event_type != EVENT_SPELL_CHECK) {
+        if (!isSessionOkay(imfEvent->session))
+            return;
+    }
 
-        case ImfGetSelectedText: {
-            getarg(int32_t, flags);
-            spannable_string_t *ret = onGetSelectedText(imfEvent->m_session, flags);
-            imfEvent->m_result->setResult(QVariant::fromValue(static_cast<void *>(ret)));
-            break;
-        }
+    switch (imfEvent->type) {
+    case ImfCommitText:
+        imfEvent->ct.result = onCommitText(imfEvent->ct.text, imfEvent->ct.new_cursor_position);
+        break;
 
-        case ImfGetTextAfterCursor: {
-            getarg(int32_t, n);
-            getarg(int32_t, flags);
-            spannable_string_t *ret = onGetTextAfterCursor(imfEvent->m_session, n, flags);
-            imfEvent->m_result->setResult(QVariant::fromValue(static_cast<void *>(ret)));
-            break;
-        }
+    case ImfDeleteSurroundingText:
+        imfEvent->dst.result = onDeleteSurroundingText(imfEvent->dst.left_length, imfEvent->dst.right_length);
+        break;
 
-        case ImfGetTextBeforeCursor: {
-            getarg(int32_t, n);
-            getarg(int32_t, flags);
-            spannable_string_t *ret = onGetTextBeforeCursor(imfEvent->m_session, n, flags);
-            imfEvent->m_result->setResult(QVariant::fromValue((void*)ret));
-            break;
-        }
+    case ImfFinishComposingText:
+        imfEvent->fct.result = onFinishComposingText();
+        break;
 
-        case ImfPerformEditorAction: {
-            getarg(int32_t, editor_action);
-            int32_t ret = onPerformEditorAction(imfEvent->m_session, editor_action);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
+    case ImfGetCursorPosition:
+        imfEvent->gcp.result = onGetCursorPosition();
+        break;
 
-        case ImfReportFullscreenMode: {
-            getarg(int32_t, enabled);
-            int32_t ret = onReportFullscreenMode(imfEvent->m_session, enabled);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
+    case ImfGetTextAfterCursor:
+        imfEvent->gtac.result = onGetTextAfterCursor(imfEvent->gtac.n, imfEvent->gtac.flags);
+        break;
 
-        case ImfSendEvent: {
-            getparg(event_t*, event);
-            onSendEvent(imfEvent->m_session, event);
-            break;
-        }
+    case ImfGetTextBeforeCursor:
+        imfEvent->gtac.result = onGetTextBeforeCursor(imfEvent->gtac.n, imfEvent->gtac.flags);
+        break;
 
-        case ImfSendAsyncEvent: {
-            getparg(event_t*, event);
-            onSendAsyncEvent(imfEvent->m_session, event);
-            break;
-        }
+    case ImfSendEvent:
+        imfEvent->sae.result = onSendEvent(imfEvent->sae.event);
+        break;
 
-        case ImfSetComposingRegion: {
-            getarg(int32_t, start);
-            getarg(int32_t, end);
-            int32_t ret = onSetComposingRegion(imfEvent->m_session, start, end);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
+    case ImfSetComposingRegion:
+        imfEvent->scr.result = onSetComposingRegion(imfEvent->scr.start, imfEvent->scr.end);
+        break;
 
-        case ImfSetComposingText: {
-            getparg(spannable_string_t*, text);
-            getarg(int32_t, new_cursor_position);
-            int32_t ret = onSetComposingText(imfEvent->m_session, text, new_cursor_position);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
+    case ImfSetComposingText:
+        imfEvent->sct.result = onSetComposingText(imfEvent->sct.text, imfEvent->sct.new_cursor_position);
+        break;
 
-        case ImfSetSelection: {
-            getarg(int32_t, start);
-            getarg(int32_t, end);
-            int32_t ret = onSetSelection(imfEvent->m_session, start, end);
-            imfEvent->m_result->setResult(QVariant::fromValue(ret));
-            break;
-        }
-        }; //switch
+    case ImfIsTextSelected:
+        imfEvent->its.result = onIsTextSelected(imfEvent->its.pIsSelected);
+        break;
 
-        return true;
-    } else {
-        // standard event processing
-        return QObject::eventFilter(obj, event);
-    }
+    case ImfIsAllTextSelected:
+        imfEvent->its.result = onIsAllTextSelected(imfEvent->its.pIsSelected);
+        break;
+    }; //switch
 }
 
 bool QQnxInputContext::filterEvent( const QEvent *event )
@@ -845,12 +680,12 @@ bool QQnxInputContext::filterEvent( const QEvent *event )
     qInputContextDebug() << Q_FUNC_INFO << event;
 
     switch (event->type()) {
-    case QEvent::CloseSoftwareInputPanel: {
+    case QEvent::CloseSoftwareInputPanel:
         return dispatchCloseSoftwareInputPanel();
-    }
-    case QEvent::RequestSoftwareInputPanel: {
+
+    case QEvent::RequestSoftwareInputPanel:
         return dispatchRequestSoftwareInputPanel();
-    }
+
     default:
         return false;
     }
@@ -869,12 +704,30 @@ void QQnxInputContext::reset()
     endComposition();
 }
 
-void QQnxInputContext::update(Qt::InputMethodQueries queries)
+void QQnxInputContext::commit()
 {
     qInputContextDebug() << Q_FUNC_INFO;
-    reset();
+    endComposition();
+}
 
-    QPlatformInputContext::update(queries);
+void QQnxInputContext::update(Qt::InputMethodQueries queries)
+{
+    qInputContextDebug() << Q_FUNC_INFO << queries;
+
+    if (queries & Qt::ImCursorPosition) {
+        int lastCaret = m_caretPosition;
+        updateCursorPosition();
+        // If caret position has changed we need to inform IMF unless this is just due to our own action
+        // such as committing text.
+        if (hasSession() && !m_isUpdatingText && lastCaret != m_caretPosition) {
+            caret_event_t caretEvent;
+            initEvent(&caretEvent.event, sInputSession, EVENT_CARET, CARET_POS_CHANGED, sizeof(caretEvent));
+            caretEvent.old_pos = lastCaret;
+            caretEvent.new_pos = m_caretPosition;
+            qInputContextDebug() << Q_FUNC_INFO << "ictrl_dispatch_event caret changed" << lastCaret << m_caretPosition;
+            p_ictrl_dispatch_event(&caretEvent.event);
+        }
+    }
 }
 
 void QQnxInputContext::closeSession()
@@ -887,16 +740,23 @@ void QQnxInputContext::closeSession()
         p_ictrl_close_session((input_session_t *)sInputSession);
         sInputSession = 0;
     }
+    // These are likely already in the right state but this depends on the text control
+    // having called reset or commit.  So, just in case, set them to proper values.
+    m_isComposing = false;
+    m_composingText.clear();
 }
 
-void QQnxInputContext::openSession()
+bool QQnxInputContext::openSession()
 {
-    qInputContextDebug() << Q_FUNC_INFO;
     if (!imfAvailable())
-        return;
+        return false;
 
     closeSession();
     sInputSession = p_ictrl_open_session(&ic_funcs);
+
+    qInputContextDebug() << Q_FUNC_INFO;
+
+    return sInputSession != 0;
 }
 
 bool QQnxInputContext::hasSession()
@@ -918,79 +778,89 @@ bool QQnxInputContext::hasSelectedText()
 
 bool QQnxInputContext::dispatchRequestSoftwareInputPanel()
 {
+    qInputContextDebug() << Q_FUNC_INFO << "requesting keyboard" << m_inputPanelVisible;
     m_virtualKeyboard.showKeyboard();
-    qInputContextDebug() << Q_FUNC_INFO << "requesting virtual keyboard";
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input || !inputMethodAccepted())
-        return true;
-
-    if (!hasSession())
-        openSession();
 
-    // This also means that the caret position has moved
-    QInputMethodQueryEvent query(Qt::ImCursorPosition);
-    QCoreApplication::sendEvent(input, &query);
-    int caretPos = query.value(Qt::ImCursorPosition).toInt();
-    caret_event_t caretEvent;
-    memset(&caretEvent, 0, sizeof(caret_event_t));
-    initEvent(&caretEvent.event, sInputSession, EVENT_CARET, CARET_POS_CHANGED);
-    caretEvent.old_pos = m_lastCaretPos;
-    m_lastCaretPos = caretEvent.new_pos = caretPos;
-    p_ictrl_dispatch_event((event_t *)&caretEvent);
     return true;
 }
 
 bool QQnxInputContext::dispatchCloseSoftwareInputPanel()
 {
+    qInputContextDebug() << Q_FUNC_INFO << "hiding keyboard" << m_inputPanelVisible;
     m_virtualKeyboard.hideKeyboard();
-    qInputContextDebug() << Q_FUNC_INFO << "hiding virtual keyboard";
 
-    // This also means we are stopping composition, but we should already have done that.
     return true;
 }
 
 /**
  * IMF Event Dispatchers.
  */
-bool QQnxInputContext::dispatchFocusEvent(FocusEventId id, int hints)
+bool QQnxInputContext::dispatchFocusGainEvent(int inputHints)
 {
-    qInputContextDebug() << Q_FUNC_INFO;
+    if (hasSession())
+        dispatchFocusLossEvent();
 
-    if (!sInputSession) {
-        qWarning() << Q_FUNC_INFO << "Attempt to dispatch a focus event with no input session.";
-        return false;
-    }
+    QObject *input = qGuiApp->focusObject();
 
-    if (!imfAvailable())
+    if (!input || !openSession())
         return false;
 
     // Set the last caret position to 0 since we don't really have one and we don't
     // want to have the old one.
-    m_lastCaretPos = 0;
+    m_caretPosition = 0;
+
+    QInputMethodQueryEvent query(Qt::ImHints);
+    QCoreApplication::sendEvent(input, &query);
 
     focus_event_t focusEvent;
-    memset(&focusEvent, 0, sizeof(focusEvent));
-    initEvent(&focusEvent.event, sInputSession, EVENT_FOCUS, id);
+    initEvent(&focusEvent.event, sInputSession, EVENT_FOCUS, FOCUS_GAINED, sizeof(focusEvent));
     focusEvent.style = DEFAULT_STYLE;
 
-    if (hints && Qt::ImhNoPredictiveText)
+    if (inputHints & Qt::ImhNoPredictiveText)
         focusEvent.style |= NO_PREDICTION | NO_AUTO_CORRECTION;
-    if (hints && Qt::ImhNoAutoUppercase)
+    if (inputHints & Qt::ImhNoAutoUppercase)
         focusEvent.style |= NO_AUTO_TEXT;
 
+    // Following styles are mutually exclusive
+    if (inputHints & Qt::ImhHiddenText) {
+        focusEvent.style |= IMF_PASSWORD_TYPE;
+    } else if (inputHints & Qt::ImhDialableCharactersOnly) {
+        focusEvent.style |= IMF_PHONE_TYPE;
+    } else if (inputHints & Qt::ImhUrlCharactersOnly) {
+        focusEvent.style |= IMF_URL_TYPE;
+    } else if (inputHints & Qt::ImhEmailCharactersOnly) {
+        focusEvent.style |= IMF_EMAIL_TYPE;
+    }
+
+    qInputContextDebug() << Q_FUNC_INFO << "ictrl_dispatch_event focus gain style:" << focusEvent.style;
+
     p_ictrl_dispatch_event((event_t *)&focusEvent);
 
     return true;
 }
 
-bool QQnxInputContext::handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap)
+void QQnxInputContext::dispatchFocusLossEvent()
 {
-    if (!imfAvailable())
+    if (hasSession()) {
+        qInputContextDebug() << Q_FUNC_INFO << "ictrl_dispatch_event focus lost";
+
+        focus_event_t focusEvent;
+        initEvent(&focusEvent.event, sInputSession, EVENT_FOCUS, FOCUS_LOST, sizeof(focusEvent));
+        p_ictrl_dispatch_event((event_t *)&focusEvent);
+        closeSession();
+    }
+}
+
+bool QQnxInputContext::handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap, int sequenceId)
+{
+    Q_UNUSED(scan);
+
+    if (!hasSession())
         return false;
 
     int key = (flags & KEY_SYM_VALID) ? sym : cap;
-    bool navKey = false;
-    switch ( key ) {
+    bool navigationKey = false;
+    switch (key) {
     case KEYCODE_RETURN:
          /* In a single line edit we should end composition because enter might be used by something.
             endComposition();
@@ -1007,27 +877,22 @@ bool QQnxInputContext::handleKeyboardEvent(int flags, int sym, int mod, int scan
         break;
     case  KEYCODE_LEFT:
         key = NAVIGATE_LEFT;
-        navKey = true;
+        navigationKey = true;
         break;
     case  KEYCODE_RIGHT:
         key = NAVIGATE_RIGHT;
-        navKey = true;
+        navigationKey = true;
         break;
     case  KEYCODE_UP:
         key = NAVIGATE_UP;
-        navKey = true;
+        navigationKey = true;
         break;
     case  KEYCODE_DOWN:
         key = NAVIGATE_DOWN;
-        navKey = true;
+        navigationKey = true;
         break;
-    case  KEYCODE_CAPS_LOCK:
-    case  KEYCODE_LEFT_SHIFT:
-    case  KEYCODE_RIGHT_SHIFT:
     case  KEYCODE_LEFT_CTRL:
     case  KEYCODE_RIGHT_CTRL:
-    case  KEYCODE_LEFT_ALT:
-    case  KEYCODE_RIGHT_ALT:
     case  KEYCODE_MENU:
     case  KEYCODE_LEFT_HYPER:
     case  KEYCODE_RIGHT_HYPER:
@@ -1041,85 +906,183 @@ bool QQnxInputContext::handleKeyboardEvent(int flags, int sym, int mod, int scan
         break;
     }
 
-    if ( mod & KEYMOD_CTRL ) {
-        // If CTRL is pressed, just let AIR handle it.  But terminate any composition first
-        //endComposition();
-        return false;
-    }
-
     // Pass the keys we don't know about on through
     if ( key == 0 )
         return false;
 
-    // IMF doesn't need key releases so just swallow them.
-    if (!(flags & KEY_DOWN))
-        return true;
-
-    if ( navKey ) {
+    if (navigationKey) {
         // Even if we're forwarding up events, we can't do this for
         // navigation keys.
         if ( flags & KEY_DOWN ) {
             navigation_event_t navEvent;
-            initEvent(&navEvent.event, sInputSession, EVENT_NAVIGATION, key);
+            initEvent(&navEvent.event, sInputSession, EVENT_NAVIGATION, key, sizeof(navEvent));
             navEvent.magnitude = 1;
-            qInputContextDebug() << Q_FUNC_INFO << "dispatch navigation event " << key;
+            qInputContextDebug() << Q_FUNC_INFO << "ictrl_dispatch_even navigation" << key;
             p_ictrl_dispatch_event(&navEvent.event);
         }
-    }
-    else {
+    } else {
         key_event_t keyEvent;
-        initEvent(&keyEvent.event, sInputSession, EVENT_KEY, flags & KEY_DOWN ? IMF_KEY_DOWN : IMF_KEY_UP);
-        keyEvent.key_code = key;
-        keyEvent.character = 0;
-        keyEvent.meta_key_state = 0;
+        initEvent(&keyEvent.event, sInputSession, EVENT_KEY, flags & KEY_DOWN ? IMF_KEY_DOWN : IMF_KEY_UP,
+                  sizeof(keyEvent));
+        keyEvent.key_code = cap;
+        keyEvent.character = sym;
+        keyEvent.meta_key_state = mod;
+        keyEvent.sequence_id = sequenceId;
 
         p_ictrl_dispatch_event(&keyEvent.event);
-        qInputContextDebug() << Q_FUNC_INFO << "dispatch key event " << key;
+        qInputContextDebug() << Q_FUNC_INFO << "ictrl_dispatch_even key" << key;
     }
 
-    scan = 0;
     return true;
 }
 
-void QQnxInputContext::endComposition()
+void QQnxInputContext::updateCursorPosition()
 {
-    if (!m_isComposing)
+    QObject *input = qGuiApp->focusObject();
+    if (!input)
         return;
 
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
+    QInputMethodQueryEvent query(Qt::ImCursorPosition);
+    QCoreApplication::sendEvent(input, &query);
+    m_caretPosition = query.value(Qt::ImCursorPosition).toInt();
+
+    qInputContextDebug() << Q_FUNC_INFO << m_caretPosition;
+}
+
+void QQnxInputContext::endComposition()
+{
+    if (!m_isComposing)
         return;
 
-    QList<QInputMethodEvent::Attribute> attributes;
-    QInputMethodEvent event(QLatin1String(""), attributes);
-    event.setCommitString(m_composingText);
-    m_composingText = QString();
-    m_isComposing = false;
-    QCoreApplication::sendEvent(input, &event);
+    finishComposingText();
 
-    action_event_t actionEvent;
-    memset(&actionEvent, 0, sizeof(actionEvent));
-    initEvent(&actionEvent.event, sInputSession, EVENT_ACTION, ACTION_END_COMPOSITION);
-    p_ictrl_dispatch_event(&actionEvent.event);
+    if (hasSession()) {
+        action_event_t actionEvent;
+        initEvent(&actionEvent.event, sInputSession, EVENT_ACTION, ACTION_END_COMPOSITION, sizeof(actionEvent));
+        qInputContextDebug() << Q_FUNC_INFO << "ictrl_dispatch_even end composition";
+        p_ictrl_dispatch_event(&actionEvent.event);
+    }
 }
 
-void QQnxInputContext::setComposingText(QString const& composingText)
+void QQnxInputContext::updateComposition(spannable_string_t *text, int32_t new_cursor_position)
 {
-    m_composingText = composingText;
+   QObject *input = qGuiApp->focusObject();
+   if (!input)
+       return;
+
+   if (new_cursor_position > 0)
+       new_cursor_position += text->length - 1;
+
+    m_composingText = QString::fromWCharArray(text->str, text->length);
     m_isComposing = true;
 
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
-        return;
+    qInputContextDebug() << Q_FUNC_INFO << m_composingText << new_cursor_position;
 
     QList<QInputMethodEvent::Attribute> attributes;
-    QTextCharFormat format;
-    format.setFontUnderline(true);
-    attributes.push_back(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, composingText.length(), format));
+    attributes.append(QInputMethodEvent::Attribute(QInputMethodEvent::Cursor,
+                                                   new_cursor_position,
+                                                   1,
+                                                   QVariant()));
+
+    for (unsigned int i = 0; i < text->spans_count; ++i) {
+        QColor highlightColor;
+        bool underline = false;
+
+        if ((text->spans[i].attributes_mask & COMPOSED_TEXT_ATTRIB) != 0)
+            underline = true;
+
+        if ((text->spans[i].attributes_mask & ACTIVE_REGION_ATTRIB) != 0) {
+            underline = true;
+            highlightColor = m_highlightColor[ActiveRegion];
+        } else if ((text->spans[i].attributes_mask & AUTO_CORRECTION_ATTRIB) != 0) {
+            highlightColor = m_highlightColor[AutoCorrected];
+        } else if ((text->spans[i].attributes_mask & REVERT_CORRECTION_ATTRIB) != 0) {
+            highlightColor = m_highlightColor[Reverted];
+        }
 
-    QInputMethodEvent event(composingText, attributes);
+        if (underline || highlightColor.isValid()) {
+            QTextCharFormat format;
+            if (underline)
+                format.setFontUnderline(true);
+            if (highlightColor.isValid())
+                format.setBackground(QBrush(highlightColor));
+            qInputContextDebug() << "    attrib:  " << underline << highlightColor << text->spans[i].start << text->spans[i].end;
+            attributes.append(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, text->spans[i].start,
+                                                           text->spans[i].end - text->spans[i].start + 1, QVariant(format)));
 
+        }
+    }
+    QInputMethodEvent event(m_composingText, attributes);
+    m_isUpdatingText = true;
     QCoreApplication::sendEvent(input, &event);
+    m_isUpdatingText = false;
+
+    updateCursorPosition();
+}
+
+void QQnxInputContext::finishComposingText()
+{
+    QObject *input = qGuiApp->focusObject();
+
+    if (input) {
+        qInputContextDebug() << Q_FUNC_INFO << m_composingText;
+
+        QInputMethodEvent event;
+        event.setCommitString(m_composingText);
+        m_isUpdatingText = true;
+        QCoreApplication::sendEvent(input, &event);
+        m_isUpdatingText = false;
+    }
+    m_composingText = QString();
+    m_isComposing = false;
+
+    updateCursorPosition();
+}
+
+// Return the index relative to a UTF-16 sequence of characters for a index that is relative to the
+// corresponding UTF-32 character string given a starting index in the UTF-16 string and a count
+// of the number of lead surrogates prior to that index.  Updates the highSurrogateCount to reflect the
+// new surrogate characters encountered.
+static int adjustIndex(const QChar *text, int utf32Index, int utf16StartIndex, int *highSurrogateCount)
+{
+    int utf16Index = utf32Index + *highSurrogateCount;
+    while (utf16StartIndex <  utf16Index) {
+        if (text[utf16StartIndex].isHighSurrogate()) {
+            ++utf16Index;
+            ++*highSurrogateCount;
+        }
+        ++utf16StartIndex;
+    }
+    return utf16StartIndex;
+}
+
+int QQnxInputContext::handleSpellCheck(spell_check_event_t *event)
+{
+    // These should never happen.
+    if (sSpellCheckQueue->isEmpty() || event->event.event_id != NOTIFY_SP_CHECK_MISSPELLINGS)
+        return -1;
+
+    SpellCheckInfo callerInfo = sSpellCheckQueue->dequeue();
+    spannable_string_t* spellCheckData = *event->data;
+    QString text = QString::fromWCharArray(spellCheckData->str, spellCheckData->length);
+    // Generate the list of indices indicating misspelled words in the text.  We use end + 1
+    // since it's more conventional to have the end index point just past the string.  We also
+    // can't use the indices directly since they are relative to UTF-32 encoded data and the
+    // conversion to Qt's UTF-16 internal format might cause lengthening.
+    QList<int> indices;
+    int adjustment = 0;
+    int index = 0;
+    for (unsigned int i = 0; i < spellCheckData->spans_count; ++i) {
+        if (spellCheckData->spans[i].attributes_mask & MISSPELLED_WORD_ATTRIB) {
+            index = adjustIndex(text.data(), spellCheckData->spans[i].start, index, &adjustment);
+            indices.push_back(index);
+            index = adjustIndex(text.data(), spellCheckData->spans[i].end + 1, index, &adjustment);
+            indices.push_back(index);
+        }
+    }
+    callerInfo.spellCheckDone(callerInfo.context, text, indices);
+
+    return 0;
 }
 
 int32_t QQnxInputContext::processEvent(event_t *event)
@@ -1128,7 +1091,7 @@ int32_t QQnxInputContext::processEvent(event_t *event)
     switch (event->event_type) {
     case EVENT_SPELL_CHECK: {
         qInputContextDebug() << Q_FUNC_INFO << "EVENT_SPELL_CHECK";
-        result = 0;
+        result = handleSpellCheck(reinterpret_cast<spell_check_event_t *>(event));
         break;
     }
 
@@ -1140,19 +1103,24 @@ int32_t QQnxInputContext::processEvent(event_t *event)
             event->event_id == NAVIGATE_LEFT ? KEYCODE_LEFT :
             event->event_id == NAVIGATE_RIGHT ? KEYCODE_RIGHT : 0;
 
-        QQnxEventThread::injectKeyboardEvent(KEY_DOWN | KEY_CAP_VALID, key, 0, 0, 0);
-        QQnxEventThread::injectKeyboardEvent(KEY_CAP_VALID, key, 0, 0, 0);
+        QQnxScreenEventHandler::injectKeyboardEvent(KEY_DOWN | KEY_CAP_VALID, key, 0, 0, 0);
+        QQnxScreenEventHandler::injectKeyboardEvent(KEY_CAP_VALID, key, 0, 0, 0);
         result = 0;
         break;
     }
 
     case EVENT_KEY: {
-        qInputContextDebug() << Q_FUNC_INFO << "EVENT_KEY";
-        key_event_t *kevent = static_cast<key_event_t *>(event);
-
-        QQnxEventThread::injectKeyboardEvent(KEY_DOWN | KEY_SYM_VALID | KEY_CAP_VALID, kevent->key_code, 0, 0, kevent->key_code);
-        QQnxEventThread::injectKeyboardEvent(KEY_SYM_VALID | KEY_CAP_VALID, kevent->key_code, 0, 0, kevent->key_code);
-
+        key_event_t *kevent = reinterpret_cast<key_event_t *>(event);
+        int keySym = kevent->character != 0 ? kevent->character : kevent->key_code;
+        int keyCap = kevent->key_code;
+        int modifiers = 0;
+        if (kevent->meta_key_state & META_SHIFT_ON)
+            modifiers |= KEYMOD_SHIFT;
+        int flags = KEY_SYM_VALID | KEY_CAP_VALID;
+        if (event->event_id == IMF_KEY_DOWN)
+            flags |= KEY_DOWN;
+        qInputContextDebug() << Q_FUNC_INFO << "EVENT_KEY" << flags << keySym;
+        QQnxScreenEventHandler::injectKeyboardEvent(flags, keySym, modifiers, 0, keyCap);
         result = 0;
         break;
     }
@@ -1179,339 +1147,175 @@ int32_t QQnxInputContext::processEvent(event_t *event)
  * IMF Event Handlers
  */
 
-int32_t QQnxInputContext::onBeginBatchEdit(input_session_t *ic)
-{
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    // We don't care.
-    return 0;
-}
-
-int32_t QQnxInputContext::onClearMetaKeyStates(input_session_t *ic, int32_t states)
-{
-    Q_UNUSED(states);
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    // Should never get called.
-    qCritical() << Q_FUNC_INFO << "onClearMetaKeyStates is unsupported.";
-    return 0;
-}
-
-int32_t QQnxInputContext::onCommitText(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position)
+int32_t QQnxInputContext::onCommitText(spannable_string_t *text, int32_t new_cursor_position)
 {
-    Q_UNUSED(new_cursor_position);  // TODO: How can we set the cursor position it's not part of the API.
-    if (!isSessionOkay(ic))
-        return 0;
-
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
-        return 0;
-
-    QString commitString = QString::fromWCharArray(text->str, text->length);
-
-    qInputContextDebug() << Q_FUNC_INFO << "Committing [" << commitString << "]";
-
-    QList<QInputMethodEvent::Attribute> attributes;
-    QInputMethodEvent event(QLatin1String(""), attributes);
-    event.setCommitString(commitString, 0, 0);
+    Q_UNUSED(new_cursor_position);
 
-    QCoreApplication::sendEvent(input, &event);
-    m_composingText = QString();
+    updateComposition(text, new_cursor_position);
+    finishComposingText();
 
     return 0;
 }
 
-int32_t QQnxInputContext::onDeleteSurroundingText(input_session_t *ic, int32_t left_length, int32_t right_length)
+int32_t QQnxInputContext::onDeleteSurroundingText(int32_t left_length, int32_t right_length)
 {
     qInputContextDebug() << Q_FUNC_INFO << "L:" << left_length << " R:" << right_length;
 
-    if (!isSessionOkay(ic))
-        return 0;
-
     QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
-        return 0;
-
-    if (hasSelectedText()) {
-        QQnxEventThread::injectKeyboardEvent(KEY_DOWN | KEY_CAP_VALID, KEYCODE_DELETE, 0, 0, 0);
-        QQnxEventThread::injectKeyboardEvent(KEY_CAP_VALID, KEYCODE_DELETE, 0, 0, 0);
-        reset();
+    if (!input)
         return 0;
-    }
 
     int replacementLength = left_length + right_length;
     int replacementStart = -left_length;
 
-    QList<QInputMethodEvent::Attribute> attributes;
-    QInputMethodEvent event(QLatin1String(""), attributes);
-    event.setCommitString(QLatin1String(""), replacementStart, replacementLength);
-    QCoreApplication::sendEvent(input, &event);
-
-    return 0;
-}
-
-int32_t QQnxInputContext::onEndBatchEdit(input_session_t *ic)
-{
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    return 0;
-}
-
-int32_t QQnxInputContext::onFinishComposingText(input_session_t *ic)
-{
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
-        return 0;
+    finishComposingText();
 
-    // Only update the control, no need to send a message back to imf (don't call
-    // end composition)
-    QList<QInputMethodEvent::Attribute> attributes;
-    QInputMethodEvent event(QLatin1String(""), attributes);
-    event.setCommitString(m_composingText);
-    m_composingText = QString();
-    m_isComposing = false;
+    QInputMethodEvent event;
+    event.setCommitString(QString(), replacementStart, replacementLength);
+    m_isUpdatingText = true;
     QCoreApplication::sendEvent(input, &event);
+    m_isUpdatingText = false;
 
-    return 0;
-}
-
-int32_t QQnxInputContext::onGetCursorCapsMode(input_session_t *ic, int32_t req_modes)
-{
-    Q_UNUSED(req_modes);
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    // Should never get called.
-    qCritical() << Q_FUNC_INFO << "onGetCursorCapsMode is unsupported.";
+    updateCursorPosition();
 
     return 0;
 }
 
-int32_t QQnxInputContext::onGetCursorPosition(input_session_t *ic)
+int32_t QQnxInputContext::onFinishComposingText()
 {
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
+    finishComposingText();
 
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
-        return 0;
-
-    QInputMethodQueryEvent query(Qt::ImCursorPosition);
-    QCoreApplication::sendEvent(input, &query);
-    m_lastCaretPos = query.value(Qt::ImCursorPosition).toInt();
-
-    return m_lastCaretPos;
-}
-
-extracted_text_t *QQnxInputContext::onGetExtractedText(input_session_t *ic, extracted_text_request_t *request, int32_t flags)
-{
-    Q_UNUSED(flags);
-    Q_UNUSED(request);
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic)) {
-        extracted_text_t *et = (extracted_text_t *)calloc(sizeof(extracted_text_t),1);
-        et->text = reinterpret_cast<spannable_string_t *>(calloc(sizeof(spannable_string_t),1));
-        return et;
-    }
-
-    // Used to update dictionaries, but not supported right now.
-    extracted_text_t *et = (extracted_text_t *)calloc(sizeof(extracted_text_t),1);
-    et->text = reinterpret_cast<spannable_string_t *>(calloc(sizeof(spannable_string_t),1));
-
-    return et;
+    return 0;
 }
 
-spannable_string_t *QQnxInputContext::onGetSelectedText(input_session_t *ic, int32_t flags)
+int32_t QQnxInputContext::onGetCursorPosition()
 {
-    Q_UNUSED(flags);
     qInputContextDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return toSpannableString("");
-
     QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
+    if (!input)
         return 0;
 
-    QInputMethodQueryEvent query(Qt::ImCurrentSelection);
-    QCoreApplication::sendEvent(input, &query);
-    QString text = query.value(Qt::ImCurrentSelection).toString();
+    updateCursorPosition();
 
-    return toSpannableString(text);
+    return m_caretPosition;
 }
 
-spannable_string_t *QQnxInputContext::onGetTextAfterCursor(input_session_t *ic, int32_t n, int32_t flags)
+spannable_string_t *QQnxInputContext::onGetTextAfterCursor(int32_t n, int32_t flags)
 {
     Q_UNUSED(flags);
     qInputContextDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return toSpannableString("");
-
     QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
+    if (!input)
         return toSpannableString("");
 
     QInputMethodQueryEvent query(Qt::ImCursorPosition | Qt::ImSurroundingText);
     QCoreApplication::sendEvent(input, &query);
     QString text = query.value(Qt::ImSurroundingText).toString();
-    m_lastCaretPos = query.value(Qt::ImCursorPosition).toInt();
+    m_caretPosition = query.value(Qt::ImCursorPosition).toInt();
 
-    return toSpannableString(text.mid(m_lastCaretPos+1, n));
+    return toSpannableString(text.mid(m_caretPosition, n));
 }
 
-spannable_string_t *QQnxInputContext::onGetTextBeforeCursor(input_session_t *ic, int32_t n, int32_t flags)
+spannable_string_t *QQnxInputContext::onGetTextBeforeCursor(int32_t n, int32_t flags)
 {
     Q_UNUSED(flags);
     qInputContextDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return toSpannableString("");
-
     QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
+    if (!input)
         return toSpannableString("");
 
     QInputMethodQueryEvent query(Qt::ImCursorPosition | Qt::ImSurroundingText);
     QCoreApplication::sendEvent(input, &query);
     QString text = query.value(Qt::ImSurroundingText).toString();
-    m_lastCaretPos = query.value(Qt::ImCursorPosition).toInt();
+    m_caretPosition = query.value(Qt::ImCursorPosition).toInt();
 
-    if (n < m_lastCaretPos)
-        return toSpannableString(text.mid(m_lastCaretPos - n, n));
+    if (n < m_caretPosition)
+        return toSpannableString(text.mid(m_caretPosition - n, n));
     else
-        return toSpannableString(text.mid(0, m_lastCaretPos));
-}
-
-int32_t QQnxInputContext::onPerformEditorAction(input_session_t *ic, int32_t editor_action)
-{
-    Q_UNUSED(editor_action);
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    // Should never get called.
-    qCritical() << Q_FUNC_INFO << "onPerformEditorAction is unsupported.";
-
-    return 0;
-}
-
-int32_t QQnxInputContext::onReportFullscreenMode(input_session_t *ic, int32_t enabled)
-{
-    Q_UNUSED(enabled);
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    // Should never get called.
-    qCritical() << Q_FUNC_INFO << "onReportFullscreenMode is unsupported.";
-
-    return 0;
-}
-
-int32_t QQnxInputContext::onSendEvent(input_session_t *ic, event_t *event)
-{
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    return processEvent(event);
+        return toSpannableString(text.mid(0, m_caretPosition));
 }
 
-int32_t QQnxInputContext::onSendAsyncEvent(input_session_t *ic, event_t *event)
+int32_t QQnxInputContext::onSendEvent(event_t *event)
 {
     qInputContextDebug() << Q_FUNC_INFO;
 
-    if (!isSessionOkay(ic))
-        return 0;
-
     return processEvent(event);
 }
 
-int32_t QQnxInputContext::onSetComposingRegion(input_session_t *ic, int32_t start, int32_t end)
+int32_t QQnxInputContext::onSetComposingRegion(int32_t start, int32_t end)
 {
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
     QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
+    if (!input)
         return 0;
 
     QInputMethodQueryEvent query(Qt::ImCursorPosition | Qt::ImSurroundingText);
     QCoreApplication::sendEvent(input, &query);
     QString text = query.value(Qt::ImSurroundingText).toString();
-    m_lastCaretPos = query.value(Qt::ImCursorPosition).toInt();
+    m_caretPosition = query.value(Qt::ImCursorPosition).toInt();
 
-    QString empty = QString::fromLatin1("");
-    text = text.mid(start, end - start);
+    qInputContextDebug() << Q_FUNC_INFO << text;
+
+    m_isUpdatingText = true;
 
     // Delete the current text.
+    QInputMethodEvent deleteEvent;
+    deleteEvent.setCommitString(QString(), start - m_caretPosition, end - start);
+    QCoreApplication::sendEvent(input, &deleteEvent);
+
+    m_composingText = text.mid(start, end - start);
+    m_isComposing = true;
+
     QList<QInputMethodEvent::Attribute> attributes;
-    QInputMethodEvent event(empty, attributes);
-    event.setCommitString(empty, start - m_lastCaretPos, end - start);
-    QCoreApplication::sendEvent(input, &event);
+    QTextCharFormat format;
+    format.setFontUnderline(true);
+    attributes.push_back(QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat, 0, m_composingText.length(), format));
+
+    QInputMethodEvent setTextEvent(m_composingText, attributes);
+    QCoreApplication::sendEvent(input, &setTextEvent);
 
-    // Move the specified text into a preedit string.
-    setComposingText(text);
+    m_isUpdatingText = false;
 
     return 0;
 }
 
-int32_t QQnxInputContext::onSetComposingText(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position)
+int32_t QQnxInputContext::onSetComposingText(spannable_string_t *text, int32_t new_cursor_position)
 {
-    Q_UNUSED(new_cursor_position);
-    qInputContextDebug() << Q_FUNC_INFO;
-
-    if (!isSessionOkay(ic))
-        return 0;
-
-    QObject *input = qGuiApp->focusObject();
-    if (!imfAvailable() || !input)
-        return 0;
+    if (text->length > 0) {
+        updateComposition(text, new_cursor_position);
+    } else {
+        // If the composing text is empty we can simply end composition, the visual effect is the same.
+        // However, sometimes one wants to display hint text in an empty text field and for this to work
+        // QQuickTextEdit.inputMethodComposing has to be false if the composition string is empty.
+        m_composingText.clear();
+        finishComposingText();
+    }
+    return 0;
+}
 
-    m_isComposing = true;
+int32_t QQnxInputContext::onIsTextSelected(int32_t* pIsSelected)
+{
+    *pIsSelected = hasSelectedText();
 
-    QString preeditString = QString::fromWCharArray(text->str, text->length);
-    setComposingText(preeditString);
+    qInputContextDebug() << Q_FUNC_INFO << *pIsSelected;
 
     return 0;
 }
 
-int32_t QQnxInputContext::onSetSelection(input_session_t *ic, int32_t start, int32_t end)
+int32_t QQnxInputContext::onIsAllTextSelected(int32_t* pIsSelected)
 {
-    Q_UNUSED(start);
-    Q_UNUSED(end);
-    qInputContextDebug() << Q_FUNC_INFO;
+    QObject *input = qGuiApp->focusObject();
+    if (!input)
+        return -1;
 
-    if (!isSessionOkay(ic))
-        return 0;
+    QInputMethodQueryEvent query(Qt::ImCurrentSelection | Qt::ImSurroundingText);
+    QCoreApplication::sendEvent(input, &query);
+
+    *pIsSelected = query.value(Qt::ImSurroundingText).toString().length() == query.value(Qt::ImCurrentSelection).toString().length();
 
-    // Should never get called.
-    qCritical() << Q_FUNC_INFO << "onSetSelection is unsupported.";
+    qInputContextDebug() << Q_FUNC_INFO << *pIsSelected;
 
     return 0;
 }
@@ -1556,19 +1360,74 @@ void QQnxInputContext::keyboardLocaleChanged(const QLocale &locale)
     }
 }
 
+void QQnxInputContext::setHighlightColor(int index, const QColor &color)
+{
+    qInputContextDebug() << Q_FUNC_INFO << "setHighlightColor" << index << color << qGuiApp->focusObject();
+
+    if (!sInputContextInstance)
+        return;
+
+    // If the focus has changed, revert all colors to the default.
+    if (sInputContextInstance->m_focusObject != qGuiApp->focusObject()) {
+        QColor invalidColor;
+        sInputContextInstance->m_highlightColor[ActiveRegion] = sSelectedColor;
+        sInputContextInstance->m_highlightColor[AutoCorrected] = invalidColor;
+        sInputContextInstance->m_highlightColor[Reverted] = invalidColor;
+        sInputContextInstance->m_focusObject = qGuiApp->focusObject();
+    }
+    if (index >= 0 && index <= Reverted)
+        sInputContextInstance->m_highlightColor[index] = color;
+}
+
 void QQnxInputContext::setFocusObject(QObject *object)
 {
     qInputContextDebug() << Q_FUNC_INFO << "input item=" << object;
 
+    // Ensure the colors are reset if we've a change in focus object
+    setHighlightColor(-1, QColor());
+
     if (!inputMethodAccepted()) {
         if (m_inputPanelVisible)
             hideInputPanel();
+        if (hasSession())
+            dispatchFocusLossEvent();
     } else {
-        m_virtualKeyboard.setInputHintsFromObject(object);
+        QInputMethodQueryEvent query(Qt::ImHints);
+        QCoreApplication::sendEvent(object, &query);
+        int inputHints = query.value(Qt::ImHints).toInt();
+
+        dispatchFocusGainEvent(inputHints);
+
+        m_virtualKeyboard.setInputHints(inputHints);
 
         if (!m_inputPanelVisible)
             showInputPanel();
     }
 }
 
+bool QQnxInputContext::checkSpelling(const QString &text, void *context, void (*spellCheckDone)(void *context, const QString &text, const QList<int> &indices))
+{
+    qInputContextDebug() << Q_FUNC_INFO << "text" << text;
+
+    if (!imfAvailable())
+        return false;
+
+    if (!sSpellCheckSession)
+        sSpellCheckSession = p_ictrl_open_session(&ic_funcs);
+
+    action_event_t spellEvent;
+    initEvent(&spellEvent.event, sSpellCheckSession, EVENT_ACTION, ACTION_CHECK_MISSPELLINGS, sizeof(spellEvent));
+    int len = text.length();
+    spellEvent.event_data = alloca(sizeof(wchar_t) * (len + 1));
+    spellEvent.length_data = text.toWCharArray(static_cast<wchar_t*>(spellEvent.event_data)) * sizeof(wchar_t);
+
+    int rc = p_ictrl_dispatch_event(reinterpret_cast<event_t*>(&spellEvent));
+
+    if (rc == 0) {
+        sSpellCheckQueue->enqueue(SpellCheckInfo(context, spellCheckDone));
+        return true;
+    }
+    return false;
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/qnx/qqnxinputcontext_imf.h b/src/plugins/platforms/qnx/qqnxinputcontext_imf.h
index 1980a99ed9..5028215bbe 100644
--- a/src/plugins/platforms/qnx/qqnxinputcontext_imf.h
+++ b/src/plugins/platforms/qnx/qqnxinputcontext_imf.h
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -43,9 +43,11 @@
 #define QQNXINPUTCONTEXT_H
 
 #include <qpa/qplatforminputcontext.h>
+#include "qqnxscreeneventfilter.h"
 
 #include <QtCore/QLocale>
 #include <QtCore/QMetaType>
+#include <QtCore/QList>
 #include <qpa/qplatformintegration.h>
 
 #include "imf/imf_client.h"
@@ -55,21 +57,30 @@ QT_BEGIN_NAMESPACE
 
 class QQnxAbstractVirtualKeyboard;
 class QQnxIntegration;
+class QQnxImfRequest;
 
-class QQnxInputContext : public QPlatformInputContext
+class QQnxInputContext : public QPlatformInputContext, public QQnxScreenEventFilter
 {
     Q_OBJECT
 public:
     explicit QQnxInputContext(QQnxIntegration *integration, QQnxAbstractVirtualKeyboard &keyboard);
     ~QQnxInputContext();
 
+    // Indices for selecting and setting highlight colors.
+    enum HighlightIndex {
+        ActiveRegion,
+        AutoCorrected,
+        Reverted,
+    };
+
     bool isValid() const;
 
     bool filterEvent(const QEvent *event);
     QRectF keyboardRect() const;
     void reset();
+    void commit();
     void update(Qt::InputMethodQueries);
-    bool handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap);
+    bool handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap, int sequenceId);
 
 
     void showInputPanel();
@@ -79,61 +90,62 @@ public:
     QLocale locale() const;
     void setFocusObject(QObject *object);
 
-protected:
-    // Filters only for IMF events.
-    bool eventFilter(QObject *obj, QEvent *event);
+    static void setHighlightColor(int index, const QColor &color);
+
+    static bool checkSpelling(const QString &text, void *context, void (*spellCheckDone)(void *context, const QString &text, const QList<int> &indices));
 
 private Q_SLOTS:
     void keyboardVisibilityChanged(bool visible);
     void keyboardLocaleChanged(const QLocale &locale);
+    void processImfEvent(QQnxImfRequest *event);
 
 private:
     // IMF Event dispatchers
-    bool dispatchFocusEvent(FocusEventId id, int hints = Qt::ImhNone);
+    bool dispatchFocusGainEvent(int inputHints);
+    void dispatchFocusLossEvent();
     bool dispatchRequestSoftwareInputPanel();
     bool dispatchCloseSoftwareInputPanel();
+    int handleSpellCheck(spell_check_event_t *event);
     int32_t processEvent(event_t *event);
 
     void closeSession();
-    void openSession();
+    bool openSession();
     bool hasSession();
+    void updateCursorPosition();
     void endComposition();
-    void setComposingText(QString const &composingText);
+    void finishComposingText();
     bool hasSelectedText();
+    void updateComposition(spannable_string_t *text, int32_t new_cursor_position);
 
     // IMF Event handlers - these events will come in from QCoreApplication.
-    int32_t onBeginBatchEdit(input_session_t *ic);
-    int32_t onClearMetaKeyStates(input_session_t *ic, int32_t states);
-    int32_t onCommitText(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position);
-    int32_t onDeleteSurroundingText(input_session_t *ic, int32_t left_length, int32_t right_length);
-    int32_t onEndBatchEdit(input_session_t *ic);
-    int32_t onFinishComposingText(input_session_t *ic);
-    int32_t onGetCursorCapsMode(input_session_t *ic, int32_t req_modes);
-    int32_t onGetCursorPosition(input_session_t *ic);
-    extracted_text_t *onGetExtractedText(input_session_t *ic, extracted_text_request_t *request, int32_t flags);
-    spannable_string_t *onGetSelectedText(input_session_t *ic, int32_t flags);
-    spannable_string_t *onGetTextAfterCursor(input_session_t *ic, int32_t n, int32_t flags);
-    spannable_string_t *onGetTextBeforeCursor(input_session_t *ic, int32_t n, int32_t flags);
-    int32_t onPerformEditorAction(input_session_t *ic, int32_t editor_action);
-    int32_t onReportFullscreenMode(input_session_t *ic, int32_t enabled);
-    int32_t onSendEvent(input_session_t *ic, event_t *event);
-    int32_t onSendAsyncEvent(input_session_t *ic, event_t *event);
-    int32_t onSetComposingRegion(input_session_t *ic, int32_t start, int32_t end);
-    int32_t onSetComposingText(input_session_t *ic, spannable_string_t *text, int32_t new_cursor_position);
-    int32_t onSetSelection(input_session_t *ic, int32_t start, int32_t end);
+    int32_t onCommitText(spannable_string_t *text, int32_t new_cursor_position);
+    int32_t onDeleteSurroundingText(int32_t left_length, int32_t right_length);
+    int32_t onGetCursorCapsMode(int32_t req_modes);
+    int32_t onFinishComposingText();
+    int32_t onGetCursorPosition();
+    spannable_string_t *onGetTextAfterCursor(int32_t n, int32_t flags);
+    spannable_string_t *onGetTextBeforeCursor(int32_t n, int32_t flags);
+    int32_t onSendEvent(event_t *event);
+    int32_t onSetComposingRegion(int32_t start, int32_t end);
+    int32_t onSetComposingText(spannable_string_t *text, int32_t new_cursor_position);
+    int32_t onIsTextSelected(int32_t* pIsSelected);
+    int32_t onIsAllTextSelected(int32_t* pIsSelected);
     int32_t onForceUpdate();
 
-    int m_lastCaretPos;
+    int m_caretPosition;
     bool m_isComposing;
     QString m_composingText;
+    bool m_isUpdatingText;
     bool m_inputPanelVisible;
     QLocale m_inputPanelLocale;
+    // The object that had focus when the last highlight color was set.
+    QObject *m_focusObject;
+    // Indexed by HighlightIndex
+    QColor m_highlightColor[3];
     QQnxIntegration *m_integration;
-    QQnxAbstractVirtualKeyboard &m_virtualKeyboad;
+    QQnxAbstractVirtualKeyboard &m_virtualKeyboard;
 };
 
-Q_DECLARE_METATYPE(extracted_text_t*)
-
 QT_END_NAMESPACE
 
 #endif // QQNXINPUTCONTEXT_H
diff --git a/src/plugins/platforms/qnx/qqnxinputcontext_noimf.cpp b/src/plugins/platforms/qnx/qqnxinputcontext_noimf.cpp
index f444d34b5e..9270f1ed6b 100644
--- a/src/plugins/platforms/qnx/qqnxinputcontext_noimf.cpp
+++ b/src/plugins/platforms/qnx/qqnxinputcontext_noimf.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -46,6 +46,7 @@
 
 #include <QtCore/QDebug>
 #include <QtGui/QGuiApplication>
+#include <QtGui/QInputMethodEvent>
 
 #if defined(QQNXINPUTCONTEXT_DEBUG)
 #define qInputContextDebug qDebug
@@ -179,7 +180,11 @@ void QQnxInputContext::setFocusObject(QObject *object)
         if (m_inputPanelVisible)
             hideInputPanel();
     } else {
-        m_virtualKeyboard.setInputHintsFromObject(object);
+        QInputMethodQueryEvent query(Qt::ImHints);
+        QCoreApplication::sendEvent(object, &query);
+        int inputHints = query.value(Qt::ImHints).toInt();
+
+        m_virtualKeyboard.setInputHints(inputHints);
 
         if (!m_inputPanelVisible)
             showInputPanel();
diff --git a/src/plugins/platforms/qnx/qqnxintegration.cpp b/src/plugins/platforms/qnx/qqnxintegration.cpp
index 52f836abbe..5695ef433a 100644
--- a/src/plugins/platforms/qnx/qqnxintegration.cpp
+++ b/src/plugins/platforms/qnx/qqnxintegration.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2013 BlackBerry Limited. All rights reserved.
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -251,6 +251,9 @@ QQnxIntegration::QQnxIntegration(const QStringList &paramList)
 #if defined(QQNX_PPS)
         // Set up the input context
         m_inputContext = new QQnxInputContext(this, *m_virtualKeyboard);
+#if defined(QQNX_IMF)
+        m_screenEventHandler->addScreenEventFilter(m_inputContext);
+#endif
 #endif
     }
 
@@ -271,17 +274,6 @@ QQnxIntegration::~QQnxIntegration()
     delete m_drag;
 #endif
 
-#if defined(QQNX_PPS)
-    // Destroy the hardware button notifier
-    delete m_buttonsNotifier;
-
-    // Destroy input context
-    delete m_inputContext;
-#endif
-
-    // Destroy the keyboard class.
-    delete m_virtualKeyboard;
-
 #if !defined(QT_NO_CLIPBOARD)
     // Delete the clipboard
     delete m_clipboard;
@@ -321,6 +313,17 @@ QQnxIntegration::~QQnxIntegration()
     QQnxGLContext::shutdown();
 #endif
 
+#if defined(QQNX_PPS)
+    // Destroy the hardware button notifier
+    delete m_buttonsNotifier;
+
+    // Destroy input context
+    delete m_inputContext;
+#endif
+
+    // Destroy the keyboard class.
+    delete m_virtualKeyboard;
+
     // Destroy services class
     delete m_services;
 
diff --git a/src/plugins/platforms/qnx/qqnxnativeinterface.cpp b/src/plugins/platforms/qnx/qqnxnativeinterface.cpp
index e468b051cd..d1ceebfebc 100644
--- a/src/plugins/platforms/qnx/qqnxnativeinterface.cpp
+++ b/src/plugins/platforms/qnx/qqnxnativeinterface.cpp
@@ -44,6 +44,9 @@
 #include "qqnxglcontext.h"
 #include "qqnxscreen.h"
 #include "qqnxwindow.h"
+#if defined(QQNX_IMF)
+#include "qqnxinputcontext_imf.h"
+#endif
 
 #include <QtGui/QOpenGLContext>
 #include <QtGui/QScreen>
@@ -91,4 +94,15 @@ void QQnxNativeInterface::setWindowProperty(QPlatformWindow *window, const QStri
     }
 }
 
+QPlatformNativeInterface::NativeResourceForIntegrationFunction QQnxNativeInterface::nativeResourceFunctionForIntegration(const QByteArray &resource)
+{
+#if defined(QQNX_IMF)
+    if (resource == "blackberryIMFSetHighlightColor")
+        return reinterpret_cast<NativeResourceForIntegrationFunction>(QQnxInputContext::setHighlightColor);
+    if (resource == "blackberryIMFCheckSpelling")
+        return reinterpret_cast<NativeResourceForIntegrationFunction>(QQnxInputContext::checkSpelling);
+#endif
+    return 0;
+}
+
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/qnx/qqnxnativeinterface.h b/src/plugins/platforms/qnx/qqnxnativeinterface.h
index dfd386214e..e2fdd32689 100644
--- a/src/plugins/platforms/qnx/qqnxnativeinterface.h
+++ b/src/plugins/platforms/qnx/qqnxnativeinterface.h
@@ -51,8 +51,10 @@ class QQnxNativeInterface : public QPlatformNativeInterface
 public:
     void *nativeResourceForWindow(const QByteArray &resource, QWindow *window);
     void *nativeResourceForScreen(const QByteArray &resource, QScreen *screen);
+
     void *nativeResourceForContext(const QByteArray &resource, QOpenGLContext *context);
     void setWindowProperty(QPlatformWindow *window, const QString &name, const QVariant &value);
+    NativeResourceForIntegrationFunction nativeResourceFunctionForIntegration(const QByteArray &resource);
 };
 
 QT_END_NAMESPACE
diff --git a/src/plugins/platforms/qnx/qqnxscreen.cpp b/src/plugins/platforms/qnx/qqnxscreen.cpp
index a09d6ce1f5..e6c37b8445 100644
--- a/src/plugins/platforms/qnx/qqnxscreen.cpp
+++ b/src/plugins/platforms/qnx/qqnxscreen.cpp
@@ -728,8 +728,6 @@ void QQnxScreen::activateWindowGroup(const QByteArray &id)
 
     if (m_coverWindow)
         m_coverWindow->setExposed(false);
-
-    QWindowSystemInterface::handleWindowActivated(window);
 }
 
 void QQnxScreen::deactivateWindowGroup(const QByteArray &id)
@@ -744,8 +742,6 @@ void QQnxScreen::deactivateWindowGroup(const QByteArray &id)
 
     Q_FOREACH (QQnxWindow *childWindow, m_childWindows)
         childWindow->setExposed(false);
-
-    QWindowSystemInterface::handleWindowActivated(rootWindow()->window());
 }
 
 QQnxWindow *QQnxScreen::rootWindow() const
diff --git a/src/plugins/platforms/qnx/qqnxscreeneventfilter.h b/src/plugins/platforms/qnx/qqnxscreeneventfilter.h
new file mode 100644
index 0000000000..f9ecadd2a9
--- /dev/null
+++ b/src/plugins/platforms/qnx/qqnxscreeneventfilter.h
@@ -0,0 +1,58 @@
+/***************************************************************************
+**
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
+** Contact: http://www.qt-project.org/legal
+**
+** This file is part of the plugins of the Qt Toolkit.
+**
+** $QT_BEGIN_LICENSE:LGPL$
+** 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 Digia.  For licensing terms and
+** conditions see http://qt.digia.com/licensing.  For further information
+** use the contact form at http://qt.digia.com/contact-us.
+**
+** GNU Lesser General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU Lesser
+** General Public License version 2.1 as published by the Free Software
+** Foundation and appearing in the file LICENSE.LGPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU Lesser General Public License version 2.1 requirements
+** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
+**
+** In addition, as a special exception, Digia gives you certain additional
+** rights.  These rights are described in the Digia Qt LGPL Exception
+** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
+**
+** GNU General Public License Usage
+** Alternatively, this file may be used under the terms of the GNU
+** General Public License version 3.0 as published by the Free Software
+** Foundation and appearing in the file LICENSE.GPL included in the
+** packaging of this file.  Please review the following information to
+** ensure the GNU General Public License version 3.0 requirements will be
+** met: http://www.gnu.org/copyleft/gpl.html.
+**
+**
+** $QT_END_LICENSE$
+**
+****************************************************************************/
+
+#ifndef QQNXSCREENEVENTFILTER_H
+#define QQNXSCREENEVENTFILTER_H
+
+QT_BEGIN_NAMESPACE
+
+class QQnxScreenEventFilter
+{
+protected:
+    ~QQnxScreenEventFilter() {}
+
+public:
+    virtual bool handleKeyboardEvent(int flags, int sym, int mod, int scan, int cap, int sequenceId) = 0;
+};
+
+QT_END_NAMESPACE
+
+#endif
diff --git a/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp b/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp
index 6f06797393..1e33e2b50f 100644
--- a/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp
+++ b/src/plugins/platforms/qnx/qqnxscreeneventhandler.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -46,6 +46,7 @@
 #include "qqnxintegration.h"
 #include "qqnxkeytranslator.h"
 #include "qqnxscreen.h"
+#include "qqnxscreeneventfilter.h"
 
 #include <QDebug>
 #include <QGuiApplication>
@@ -90,6 +91,16 @@ QQnxScreenEventHandler::QQnxScreenEventHandler(QQnxIntegration *integration)
     }
 }
 
+void QQnxScreenEventHandler::addScreenEventFilter(QQnxScreenEventFilter *filter)
+{
+    m_eventFilters.append(filter);
+}
+
+void QQnxScreenEventHandler::removeScreenEventFilter(QQnxScreenEventFilter *filter)
+{
+    m_eventFilters.removeOne(filter);
+}
+
 bool QQnxScreenEventHandler::handleEvent(screen_event_t event)
 {
     // get the event type
@@ -256,7 +267,23 @@ void QQnxScreenEventHandler::handleKeyboardEvent(screen_event_t event)
     if (result)
         qFatal("QQNX: failed to query event cap, errno=%d", errno);
 
-    injectKeyboardEvent(flags, sym, modifiers, scan, cap);
+    int sequenceId = 0;
+#if defined(Q_OS_BLACKBERRY)
+    result = screen_get_event_property_iv(event, SCREEN_PROPERTY_SEQUENCE_ID, &sequenceId);
+    if (result)
+        qFatal("QQNX: failed to query event seqId, errno=%d", errno);
+#endif
+
+    bool inject = true;
+    Q_FOREACH (QQnxScreenEventFilter *filter, m_eventFilters) {
+        if (filter->handleKeyboardEvent(flags, sym, modifiers, scan, cap, sequenceId)) {
+            inject = false;
+            break;
+        }
+    }
+
+    if (inject)
+        injectKeyboardEvent(flags, sym, modifiers, scan, cap);
 }
 
 void QQnxScreenEventHandler::handlePointerEvent(screen_event_t event)
@@ -314,10 +341,6 @@ void QQnxScreenEventHandler::handlePointerEvent(screen_event_t event)
         }
     }
 
-    // If we don't have a navigator, we don't get activation events.
-    if (buttonState && w && w != QGuiApplication::focusWindow() && !m_qnxIntegration->supportsNavigatorEvents())
-        QWindowSystemInterface::handleWindowActivated(w);
-
     m_lastMouseWindow = qnxWindow;
 
     // Apply scaling to wheel delta and invert value for Qt. We'll probably want to scale
@@ -589,9 +612,15 @@ void QQnxScreenEventHandler::handleKeyboardFocusPropertyEvent(screen_window_t wi
     if (window && screen_get_window_property_iv(window, SCREEN_PROPERTY_KEYBOARD_FOCUS, &focus) != 0)
         qFatal("QQnx: failed to query keyboard focus property, errno=%d", errno);
 
-    QWindow *w = focus ? QQnxIntegration::window(window) : 0;
-
-    QWindowSystemInterface::handleWindowActivated(w);
+    QWindow *focusWindow = QQnxIntegration::window(window);
+    if (focus) {
+        QWindowSystemInterface::handleWindowActivated(focusWindow);
+    } else if (focusWindow == QGuiApplication::focusWindow()) {
+        // Deactivate only if the window was the focus window.
+        // Screen might send a keyboard focus event for a newly created
+        // window on the secondary screen, with focus 0.
+        QWindowSystemInterface::handleWindowActivated(0);
+    }
 }
 
 #include "moc_qqnxscreeneventhandler.cpp"
diff --git a/src/plugins/platforms/qnx/qqnxscreeneventhandler.h b/src/plugins/platforms/qnx/qqnxscreeneventhandler.h
index 1fdb2c83cd..a7bcd449ee 100644
--- a/src/plugins/platforms/qnx/qqnxscreeneventhandler.h
+++ b/src/plugins/platforms/qnx/qqnxscreeneventhandler.h
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2011 - 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -49,6 +49,7 @@
 QT_BEGIN_NAMESPACE
 
 class QQnxIntegration;
+class QQnxScreenEventFilter;
 #if defined(QQNX_SCREENEVENTTHREAD)
 class QQnxScreenEventThread;
 #endif
@@ -59,6 +60,9 @@ class QQnxScreenEventHandler : public QObject
 public:
     explicit QQnxScreenEventHandler(QQnxIntegration *integration);
 
+    void addScreenEventFilter(QQnxScreenEventFilter *filter);
+    void removeScreenEventFilter(QQnxScreenEventFilter *filter);
+
     bool handleEvent(screen_event_t event);
     bool handleEvent(screen_event_t event, int qnxType);
 
@@ -99,6 +103,7 @@ private:
     screen_window_t m_lastMouseWindow;
     QTouchDevice *m_touchDevice;
     QWindowSystemInterface::TouchPoint m_touchPoints[MaximumTouchPoints];
+    QList<QQnxScreenEventFilter*> m_eventFilters;
 #if defined(QQNX_SCREENEVENTTHREAD)
     QQnxScreenEventThread *m_eventThread;
 #endif
diff --git a/src/plugins/platforms/qnx/qqnxvirtualkeyboardbps.cpp b/src/plugins/platforms/qnx/qqnxvirtualkeyboardbps.cpp
index 11eb4a5082..f3a6887613 100644
--- a/src/plugins/platforms/qnx/qqnxvirtualkeyboardbps.cpp
+++ b/src/plugins/platforms/qnx/qqnxvirtualkeyboardbps.cpp
@@ -1,6 +1,6 @@
 /***************************************************************************
 **
-** Copyright (C) 2012 Research In Motion
+** Copyright (C) 2013 BlackBerry Limited. All rights reserved.
 ** Contact: http://www.qt-project.org/legal
 **
 ** This file is part of the plugins of the Qt Toolkit.
@@ -135,6 +135,10 @@ void QQnxVirtualKeyboardBps::applyKeyboardMode(KeyboardMode mode)
         layout = VIRTUALKEYBOARD_LAYOUT_PIN;
         break;
 
+    case Password:
+        layout = VIRTUALKEYBOARD_LAYOUT_PASSWORD;
+        break;
+
     case Default: // fall through
     default:
         layout = VIRTUALKEYBOARD_LAYOUT_DEFAULT;
diff --git a/src/plugins/platforms/qnx/qqnxwindow.cpp b/src/plugins/platforms/qnx/qqnxwindow.cpp
index 99071cf4f2..9f8c93cce1 100644
--- a/src/plugins/platforms/qnx/qqnxwindow.cpp
+++ b/src/plugins/platforms/qnx/qqnxwindow.cpp
@@ -478,12 +478,7 @@ void QQnxWindow::lower()
 
 void QQnxWindow::requestActivateWindow()
 {
-    qWindowDebug() << Q_FUNC_INFO << "window =" << window();
-
-    // TODO: Tell screen to set keyboard focus to this window.
-
-    // Notify that we gained focus.
-    gainedFocus();
+    // Overwrite the default implementation where the window is activated
 }
 
 
@@ -507,14 +502,6 @@ void QQnxWindow::propagateSizeHints()
     qWindowDebug() << Q_FUNC_INFO << ": ignored";
 }
 
-void QQnxWindow::gainedFocus()
-{
-    qWindowDebug() << Q_FUNC_INFO << "window =" << window();
-
-    // Got focus
-    QWindowSystemInterface::handleWindowActivated(window());
-}
-
 void QQnxWindow::setMMRendererWindowName(const QString &name)
 {
     m_mmRendererWindowName = name;
diff --git a/src/plugins/platforms/qnx/qqnxwindow.h b/src/plugins/platforms/qnx/qqnxwindow.h
index 3c8070b0be..2f44202b4c 100644
--- a/src/plugins/platforms/qnx/qqnxwindow.h
+++ b/src/plugins/platforms/qnx/qqnxwindow.h
@@ -93,7 +93,6 @@ public:
 
     void propagateSizeHints();
 
-    void gainedFocus();
     void setMMRendererWindowName(const QString &name);
     void setMMRendererWindow(screen_window_t handle);
     void clearMMRendererWindow();