Merge lp:~dandrader/ubuntu/trusty/maliit-framework/orientationAngleMapping into lp:ubuntu/trusty/maliit-framework

[Daniel d'Andrada]

Fix mapping between screen orientations and rotation angles.

Simply use the function that Qt provides for that.

[Bill Filler (bfiller)]

tested with https://code.launchpad.net/~dandrader/ubuntu-keyboard/fixAngleToOrientationMap/+merge/204293 and worked as expected on tablet and N4

Did you perform an exploratory manual test run of the code change and any related functionality on device or emulator?
YES

Did you successfully run all tests found in your component's Test Plan
(https://wiki.ubuntu.com/Process/Merges/TestPlan/<package-name>) on device or emulator?
YES

Did CI run pass? If not, please explain why.
YES

Have you checked that submitter has accurately filled out the submitter checklist and has taken no shortcut?
YES

review: Approve

[Bill Filler (bfiller)]

Are there any related MPs required for this MP to build/function as expected?
YES, https://code.launchpad.net/~dandrader/ubuntu-keyboard/fixAngleToOrientationMap/+merge/204293

[Iain Lane (laney)]

I merged this manually because I didn't see this MP—thanks for the work.

=== added directory '.pc/0006-fix_orientation_to_angle_mapping.patch'
=== added file '.pc/0006-fix_orientation_to_angle_mapping.patch/.timestamp'
=== added directory '.pc/0006-fix_orientation_to_angle_mapping.patch/input-context'
=== added file '.pc/0006-fix_orientation_to_angle_mapping.patch/input-context/minputcontext.cpp'
--- .pc/0006-fix_orientation_to_angle_mapping.patch/input-context/minputcontext.cpp	1970-01-01 00:00:00 +0000
+++ .pc/0006-fix_orientation_to_angle_mapping.patch/input-context/minputcontext.cpp	2014-01-31 18:02:44 +0000
@@ -0,0 +1,794 @@
+/* * This file is part of Maliit framework *
+ *
+ * Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
+ * Copyright (C) 2013 Digia Plc and/or its subsidiary(-ies).
+ * Copyright (C) 2013 Jolla Ltd.
+ *
+ * All rights reserved.
+ *
+ * Contact: [e-mail]
+ *
+ * This library is free software; you can redistribute it and/or
+ * modify it 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.
+ */
+
+
+#include "minputcontext.h"
+
+#include <QGuiApplication>
+#include <QKeyEvent>
+#include <QTextFormat>
+#include <QDebug>
+#include <QByteArray>
+#include <QRectF>
+#include <QLocale>
+#include <QWindow>
+#include <QSharedDataPointer>
+#include <QQuickItem>
+
+namespace
+{
+    const int SoftwareInputPanelHideTimer = 100;
+    const char * const InputContextName = "MInputContext";
+
+    int orientationAngle(Qt::ScreenOrientation orientation)
+    {
+        switch (orientation) {
+        case Qt::PrimaryOrientation: // Urgh.
+        case Qt::PortraitOrientation:
+            return MInputContext::Angle270;
+        case Qt::LandscapeOrientation:
+            return MInputContext::Angle0;
+        case Qt::InvertedPortraitOrientation:
+            return MInputContext::Angle90;
+        case Qt::InvertedLandscapeOrientation:
+            return MInputContext::Angle180;
+        }
+        return MInputContext::Angle0;
+    }
+}
+
+bool MInputContext::debug = false;
+
+
+MInputContext::MInputContext()
+    : imServer(0),
+      active(false),
+      inputPanelState(InputPanelHidden),
+      preeditCursorPos(-1),
+      redirectKeys(false)
+{
+    QByteArray debugEnvVar = qgetenv("MALIIT_DEBUG");
+    if (!debugEnvVar.isEmpty() && debugEnvVar != "0") {
+        qDebug() << "Creating Maliit input context";
+        debug = true;
+    }
+
+    QSharedPointer<Maliit::InputContext::DBus::Address> address(new Maliit::InputContext::DBus::DynamicAddress);
+    imServer = new DBusServerConnection(address);
+
+    sipHideTimer.setSingleShot(true);
+    sipHideTimer.setInterval(SoftwareInputPanelHideTimer);
+    connect(&sipHideTimer, SIGNAL(timeout()), SLOT(sendHideInputMethod()));
+
+    connectInputMethodServer();
+}
+
+MInputContext::~MInputContext()
+{
+    delete imServer;
+}
+
+void MInputContext::connectInputMethodServer()
+{
+    connect(imServer, SIGNAL(connected()), this, SLOT(onDBusConnection()));
+    connect(imServer, SIGNAL(disconnected()), this, SLOT(onDBusDisconnection()));
+
+    // Hook up incoming communication from input method server
+    connect(imServer, SIGNAL(activationLostEvent()), this, SLOT(activationLostEvent()));
+
+    connect(imServer, SIGNAL(imInitiatedHide()), this, SLOT(imInitiatedHide()));
+
+    connect(imServer, SIGNAL(commitString(QString,int,int,int)),
+            this, SLOT(commitString(QString,int,int,int)));
+
+    connect(imServer, SIGNAL(updatePreedit(QString,QList<Maliit::PreeditTextFormat>,int,int,int)),
+            this, SLOT(updatePreedit(QString,QList<Maliit::PreeditTextFormat>,int,int,int)));
+
+    connect(imServer, SIGNAL(keyEvent(int,int,int,QString,bool,int,Maliit::EventRequestType)),
+            this, SLOT(keyEvent(int,int,int,QString,bool,int,Maliit::EventRequestType)));
+
+    connect(imServer, SIGNAL(updateInputMethodArea(QRect)),
+            this, SLOT(updateInputMethodArea(QRect)));
+
+    connect(imServer, SIGNAL(setGlobalCorrectionEnabled(bool)),
+            this, SLOT(setGlobalCorrectionEnabled(bool)));
+
+    connect(imServer, SIGNAL(getPreeditRectangle(QRect&,bool&)),
+            this, SLOT(getPreeditRectangle(QRect&,bool&)));
+
+    connect(imServer, SIGNAL(invokeAction(QString,QKeySequence)), this, SLOT(onInvokeAction(QString,QKeySequence)));
+
+    connect(imServer, SIGNAL(setRedirectKeys(bool)), this, SLOT(setRedirectKeys(bool)));
+
+    connect(imServer, SIGNAL(setDetectableAutoRepeat(bool)),
+            this, SLOT(setDetectableAutoRepeat(bool)));
+
+    connect(imServer, SIGNAL(setSelection(int,int)),
+            this, SLOT(setSelection(int,int)));
+
+    connect(imServer, SIGNAL(getSelection(QString&,bool&)),
+            this, SLOT(getSelection(QString&, bool&)));
+
+    connect(imServer, SIGNAL(setLanguage(QString)),
+            this, SLOT(setLanguage(QString)));
+}
+
+
+bool MInputContext::isValid() const
+{
+    return true;
+}
+
+void MInputContext::setLanguage(const QString &language)
+{
+    QLocale newLocale(language);
+    Qt::LayoutDirection oldDirection = inputDirection();
+
+    if (newLocale != inputLocale) {
+        inputLocale = newLocale;
+        emitLocaleChanged();
+    }
+
+    Qt::LayoutDirection newDirection = inputDirection();
+    if (newDirection != oldDirection) {
+        emitInputDirectionChanged(newDirection);
+    }
+}
+
+void MInputContext::reset()
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    const bool hadPreedit = !preedit.isEmpty();
+
+    // reset input method server, preedit requires synchronization.
+    // rationale: input method might be autocommitting existing preedit without
+    // user interaction.
+    imServer->reset(hadPreedit);
+}
+
+void MInputContext::commit()
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    const bool hadPreedit = !preedit.isEmpty();
+
+    if (hadPreedit) {
+        QList<QInputMethodEvent::Attribute> attributes;
+        if (preeditCursorPos >= 0) {
+            bool valid = false;
+            int start = cursorStartPosition(&valid);
+            if (valid) {
+                attributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection,
+                                                           start + preeditCursorPos, 0, QVariant());
+            }
+        }
+
+        QInputMethodEvent event("", attributes);
+        event.setCommitString(preedit);
+        QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+
+        preedit.clear();
+        preeditCursorPos = -1;
+    }
+
+    imServer->reset(hadPreedit);
+}
+
+void MInputContext::invokeAction(QInputMethod::Action action, int x)
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    if (!inputMethodAccepted())
+        return;
+
+    if (action == QInputMethod::Click) {
+        if (x < 0 || x >= preedit.length()) {
+            reset();
+            return;
+        }
+
+        // To preserve the wire protocol, the "x" argument gets
+        // transferred in widget state instead of being an extra
+        // argument to mouseClickedOnPreedit().
+        QMap<QString, QVariant> stateInformation = getStateInformation();
+        stateInformation["preeditClickPos"] = x;
+        imServer->updateWidgetInformation(stateInformation, false);
+
+        // FIXME: proper positions and preeditClickPos
+        QRect preeditRect;
+        QPoint globalPos;
+        imServer->mouseClickedOnPreedit(globalPos, preeditRect);
+
+    } else {
+        QPlatformInputContext::invokeAction(action, x);
+    }
+}
+
+void MInputContext::update(Qt::InputMethodQueries queries)
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    Q_UNUSED(queries) // fetching everything
+
+    if (queries & Qt::ImPlatformData) {
+        updateInputMethodExtensions();
+    }
+
+    // get the state information of currently focused widget, and pass it to input method server
+    QMap<QString, QVariant> stateInformation = getStateInformation();
+    imServer->updateWidgetInformation(stateInformation, false);
+}
+
+void MInputContext::updateServerOrientation(Qt::ScreenOrientation orientation)
+{
+    if (active) {
+        imServer->appOrientationChanged(orientationAngle(orientation));
+    }
+}
+
+
+void MInputContext::setFocusObject(QObject *focused)
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__ << focused;
+
+    updateInputMethodExtensions();
+
+    QWindow *newFocusWindow = qGuiApp->focusWindow();
+    if (newFocusWindow != window.data()) {
+       if (window) {
+           disconnect(window.data(), SIGNAL(contentOrientationChanged(Qt::ScreenOrientation)),
+                      this, SLOT(updateServerOrientation(Qt::ScreenOrientation)));
+       }
+
+       window = newFocusWindow;
+       if (window) {
+           connect(window.data(), SIGNAL(contentOrientationChanged(Qt::ScreenOrientation)),
+                   this, SLOT(updateServerOrientation(Qt::ScreenOrientation)));
+       }
+    }
+
+    if (focused && !active) {
+        imServer->activateContext();
+        active = true;
+        updateServerOrientation(newFocusWindow->contentOrientation());
+    }
+
+    const QMap<QString, QVariant> stateInformation = getStateInformation();
+    imServer->updateWidgetInformation(stateInformation, true);
+
+    if (inputPanelState == InputPanelShowPending && focused) {
+        sipHideTimer.stop();
+        imServer->showInputMethod();
+        inputPanelState = InputPanelShown;
+    }
+}
+
+bool MInputContext::filterEvent(const QEvent *event)
+{
+    bool eaten = false;
+
+    switch (event->type()) {
+
+    case QEvent::KeyPress:
+    case QEvent::KeyRelease:
+        if (!inputMethodAccepted()) {
+            break;
+        }
+
+        if (redirectKeys) {
+            const QKeyEvent *key = static_cast<const QKeyEvent *>(event);
+            imServer->processKeyEvent(key->type(), static_cast<Qt::Key>(key->key()),
+                                      key->modifiers(), key->text(), key->isAutoRepeat(),
+                                      key->count(), key->nativeScanCode(),
+                                      key->nativeModifiers(), 0 /* currentKeyEventTime */);
+            eaten = true;
+        }
+        break;
+
+    default:
+        break;
+    }
+
+    return eaten;
+}
+
+QRectF MInputContext::keyboardRect() const
+{
+    return keyboardRectangle;
+}
+
+bool MInputContext::isAnimating() const
+{
+    return false; // don't know here when input method server is actually doing transitions
+}
+
+void MInputContext::showInputPanel()
+{
+    if (debug) qDebug() << __PRETTY_FUNCTION__;
+
+    if (inputMethodAccepted()) {
+        sipHideTimer.stop();
+    }
+
+    if (!active || !inputMethodAccepted()) {
+        // in case SIP request comes without a properly focused widget, we
+        // don't ask input method server to be shown. It's done when the next widget
+        // is focused, so the widget state information can be set.
+        inputPanelState = InputPanelShowPending;
+
+    } else {
+        // note: could do this also if panel was hidden
+
+        imServer->showInputMethod();
+        inputPanelState = InputPanelShown;
+    }
+}
+
+void MInputContext::hideInputPanel()
+{
+    if (debug) qDebug() << __PRETTY_FUNCTION__;
+    sipHideTimer.start();
+}
+
+bool MInputContext::isInputPanelVisible() const
+{
+    return !keyboardRectangle.isEmpty();
+}
+
+QLocale MInputContext::locale() const
+{
+    return inputLocale;
+}
+
+Qt::LayoutDirection MInputContext::inputDirection() const
+{
+    return inputLocale.textDirection();
+}
+
+void MInputContext::sendHideInputMethod()
+{
+    imServer->hideInputMethod();
+
+    inputPanelState = InputPanelHidden;
+}
+
+void MInputContext::activationLostEvent()
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    // This method is called when activation was gracefully lost.
+    // There is similar cleaning up done in onDBusDisconnection.
+    active = false;
+    inputPanelState = InputPanelHidden;
+
+    updateInputMethodArea(QRect());
+}
+
+
+void MInputContext::imInitiatedHide()
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    inputPanelState = InputPanelHidden;
+
+    // remove focus on QtQuick2
+    QQuickItem *inputItem = qobject_cast<QQuickItem*>(QGuiApplication::focusObject());
+    if (inputItem) {
+        inputItem->setFocus(false);
+    }
+
+}
+
+void MInputContext::commitString(const QString &string, int replacementStart,
+                                 int replacementLength, int cursorPos)
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    if (imServer->pendingResets()) {
+        return;
+    }
+
+    preedit.clear();
+    preeditCursorPos = -1;
+
+    int start = -1;
+    if (cursorPos >= 0) {
+        bool valid = false;
+        int currentStart = cursorStartPosition(&valid);
+        if (valid) {
+            start = cursorPos + currentStart + replacementStart;
+        }
+    }
+
+    if (start >= 0) {
+        QList<QInputMethodEvent::Attribute> attributes;
+        attributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, start, 0, QVariant());
+        QInputMethodEvent event("", attributes);
+        event.setCommitString(string, replacementStart, replacementLength);
+        QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+
+    } else {
+        QInputMethodEvent event;
+        event.setCommitString(string, replacementStart, replacementLength);
+        QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+    }
+}
+
+
+void MInputContext::updatePreedit(const QString &string,
+                                  const QList<Maliit::PreeditTextFormat> &preeditFormats,
+                                  int replacementStart, int replacementLength, int cursorPos)
+{
+    if (debug) {
+        qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__ << "preedit:" << string
+                 << ", replacementStart:" << replacementStart
+                 << ", replacementLength:" << replacementLength
+                 << ", cursorPos:" << cursorPos;
+    }
+
+    if (imServer->pendingResets()) {
+        return;
+    }
+
+    updatePreeditInternally(string, preeditFormats, replacementStart, replacementLength, cursorPos);
+}
+
+void MInputContext::updatePreeditInternally(const QString &string,
+                                            const QList<Maliit::PreeditTextFormat> &preeditFormats,
+                                            int replacementStart, int replacementLength, int cursorPos)
+{
+    preedit = string;
+    preeditCursorPos = cursorPos;
+
+    QList<QInputMethodEvent::Attribute> attributes;
+    Q_FOREACH (const Maliit::PreeditTextFormat &preeditFormat, preeditFormats) {
+
+        QTextCharFormat format;
+
+        // update style mode
+        switch (preeditFormat.preeditFace) {
+        case Maliit::PreeditNoCandidates:
+            format.setUnderlineStyle(QTextCharFormat::SpellCheckUnderline);
+            format.setUnderlineColor(Qt::red);
+            break;
+        case Maliit::PreeditUnconvertible:
+            format.setForeground(QBrush(QColor(128, 128, 128)));
+            break;
+        case Maliit::PreeditActive:
+            format.setForeground(QBrush(QColor(153, 50, 204)));
+            format.setFontWeight(QFont::Bold);
+            break;
+        case Maliit::PreeditKeyPress:
+        case Maliit::PreeditDefault:
+            format.setUnderlineStyle(QTextCharFormat::SingleUnderline);
+            format.setUnderlineColor(QColor(0, 0, 0));
+            break;
+        }
+
+        attributes << QInputMethodEvent::Attribute(QInputMethodEvent::TextFormat,
+                                                   preeditFormat.start,
+                                                   preeditFormat.length, format);
+    }
+
+    if (cursorPos >= 0) {
+        attributes << QInputMethodEvent::Attribute(QInputMethodEvent::Cursor, cursorPos, 1, QVariant());
+    }
+
+    QInputMethodEvent event(string, attributes);
+    if (replacementStart || replacementLength) {
+        event.setCommitString("", replacementStart, replacementLength);
+    }
+
+    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+}
+
+void MInputContext::keyEvent(int type, int key, int modifiers, const QString &text,
+                             bool autoRepeat, int count,
+                             Maliit::EventRequestType requestType)
+{
+    if (debug) qDebug() << InputContextName << "in" << __PRETTY_FUNCTION__;
+
+    if (qGuiApp->focusWindow() != 0 && requestType != Maliit::EventRequestSignalOnly) {
+        QEvent::Type eventType = static_cast<QEvent::Type>(type);
+        QKeyEvent event(eventType, key, static_cast<Qt::KeyboardModifiers>(modifiers), text, autoRepeat, count);
+        // need window instead of focus item so e.g. QQuickItem::keyPressEvent() gets properly called
+        QGuiApplication::sendEvent(qGuiApp->focusWindow(), &event);
+    }
+}
+
+
+void MInputContext::updateInputMethodArea(const QRect &rect)
+{
+    bool wasVisible = isInputPanelVisible();
+
+    if (rect != keyboardRectangle) {
+        keyboardRectangle = rect;
+        emitKeyboardRectChanged();
+
+        if (wasVisible != isInputPanelVisible()) {
+            emitInputPanelVisibleChanged();
+        }
+    }
+}
+
+
+void MInputContext::setGlobalCorrectionEnabled(bool enabled)
+{
+    Q_UNUSED(enabled)
+    // not handling preedit injections, ignored
+}
+
+
+void MInputContext::getPreeditRectangle(QRect &rectangle, bool &valid) const
+{
+    // not supported
+    rectangle = QRect();
+    valid = false;
+
+    return;
+}
+
+void MInputContext::onInvokeAction(const QString &action, const QKeySequence &sequence)
+{
+    if (debug) qDebug() << InputContextName << __PRETTY_FUNCTION__ << "action" << action;
+
+    // NOTE: currently not trying to trigger action directly
+    static const Qt::KeyboardModifiers AllModifiers = Qt::ShiftModifier | Qt::ControlModifier | Qt::AltModifier
+            | Qt::MetaModifier | Qt::KeypadModifier;
+
+    for (int i = 0; i < sequence.count(); i++) {
+        const int key = sequence[i] & ~AllModifiers;
+        const int modifiers = sequence[i] & AllModifiers;
+        QString text("");
+        if (modifiers == Qt::NoModifier || modifiers == Qt::ShiftModifier) {
+            text = QString(key);
+        }
+        keyEvent(QEvent::KeyPress, key, modifiers, text, false, 1);
+        keyEvent(QEvent::KeyRelease, key, modifiers, text, false, 1);
+    }
+}
+
+void MInputContext::onDBusDisconnection()
+{
+    if (debug) qDebug() << __PRETTY_FUNCTION__;
+
+    active = false;
+    redirectKeys = false;
+
+    updateInputMethodArea(QRect());
+}
+
+void MInputContext::onDBusConnection()
+{
+    if (debug) qDebug() << __PRETTY_FUNCTION__;
+
+    // using one attribute extension for everything
+    imServer->registerAttributeExtension(0, QString());
+
+    // Force activation, since setFocusWidget may have been called after
+    // onDBusDisconnection set active to false or before the dbus connection.
+    active = false;
+
+    if (inputMethodAccepted()) {
+        setFocusObject(QGuiApplication::focusObject());
+        if (inputPanelState != InputPanelHidden) {
+            imServer->showInputMethod();
+            inputPanelState = InputPanelShown;
+        }
+    }
+}
+
+void MInputContext::notifyOrientationAboutToChange(MInputContext::OrientationAngle angle)
+{
+    // can get called from signal so cannot be sure we are really currently active
+    if (active) {
+        imServer->appOrientationAboutToChange(static_cast<int>(angle));
+    }
+}
+
+void MInputContext::notifyOrientationChanged(MInputContext::OrientationAngle angle)
+{
+    // can get called from signal so cannot be sure we are really currently active
+    if (active) {
+        imServer->appOrientationChanged(static_cast<int>(angle));
+    }
+}
+
+Maliit::TextContentType MInputContext::contentType(Qt::InputMethodHints hints) const
+{
+    Maliit::TextContentType type = Maliit::FreeTextContentType;
+    hints &= Qt::ImhExclusiveInputMask;
+
+    if (hints == Qt::ImhFormattedNumbersOnly || hints == Qt::ImhDigitsOnly) {
+        type = Maliit::NumberContentType;
+    } else if (hints == Qt::ImhDialableCharactersOnly) {
+        type = Maliit::PhoneNumberContentType;
+    } else if (hints == Qt::ImhEmailCharactersOnly) {
+        type = Maliit::EmailContentType;
+    } else if (hints == Qt::ImhUrlCharactersOnly) {
+        type = Maliit::UrlContentType;
+    }
+
+    return type;
+}
+
+void MInputContext::setRedirectKeys(bool enabled)
+{
+    redirectKeys = enabled;
+}
+
+void MInputContext::setDetectableAutoRepeat(bool enabled)
+{
+    Q_UNUSED(enabled);
+    qWarning() << "Detectable autorepeat not supported.";
+}
+
+QMap<QString, QVariant> MInputContext::getStateInformation() const
+{
+    QMap<QString, QVariant> stateInformation;
+
+    stateInformation["focusState"] = inputMethodAccepted();
+
+    if (!inputMethodAccepted()) {
+        return stateInformation;
+    }
+
+    QInputMethodQueryEvent query(Qt::ImQueryAll);
+    QGuiApplication::sendEvent(qGuiApp->focusObject(), &query);
+
+    QVariant queryResult;
+
+    queryResult = query.value(Qt::ImSurroundingText);
+    if (queryResult.isValid()) {
+        stateInformation["surroundingText"] = queryResult.toString();
+    }
+
+    queryResult = query.value(Qt::ImCursorPosition);
+    if (queryResult.isValid()) {
+        stateInformation["cursorPosition"] = queryResult.toInt();
+    }
+
+    queryResult = query.value(Qt::ImAnchorPosition);
+    if (queryResult.isValid()) {
+        stateInformation["anchorPosition"] = queryResult.toInt();
+    }
+
+    queryResult = query.value(Qt::ImHints);
+    Qt::InputMethodHints hints = static_cast<Qt::InputMethodHints>(queryResult.toUInt());
+
+    // content type value
+    // Deprecated, replaced by just transmitting all hints (see below):
+    // FIXME: Remove once MAbstractInputMethod API for this got deprecated/removed.
+    stateInformation["contentType"] = contentType(hints);
+
+    stateInformation["autocapitalizationEnabled"] = !(hints & Qt::ImhNoAutoUppercase);
+    stateInformation["hiddenText"] = static_cast<bool>(hints & Qt::ImhHiddenText);
+    stateInformation["predictionEnabled"] = ! static_cast<bool>(hints & Qt::ImhNoPredictiveText);
+
+    stateInformation["maliit-inputmethod-hints"] = QVariant(static_cast<qint64>(hints));
+
+    // is text selected
+    queryResult = query.value(Qt::ImCurrentSelection);
+    if (queryResult.isValid()) {
+        stateInformation["hasSelection"] = !(queryResult.toString().isEmpty());
+    }
+
+    QWindow *window = qGuiApp->focusWindow();
+    if (window) {
+        stateInformation["winId"] = static_cast<qulonglong>(window->winId());
+    }
+
+    queryResult = query.value(Qt::ImCursorRectangle);
+    if (queryResult.isValid()) {
+        QRect rect = queryResult.toRect();
+        rect = qGuiApp->inputMethod()->inputItemTransform().mapRect(rect);
+        if (window) {
+            stateInformation["cursorRectangle"] = QRect(window->mapToGlobal(rect.topLeft()), rect.size());
+        }
+    }
+
+    stateInformation["toolbarId"] = 0; // Global extension id. And bad state parameter name for it.
+
+    return stateInformation;
+}
+
+void MInputContext::setSelection(int start, int length)
+{
+    if (!inputMethodAccepted())
+        return;
+
+    QList<QInputMethodEvent::Attribute> attributes;
+    attributes << QInputMethodEvent::Attribute(QInputMethodEvent::Selection, start,
+                                                length, QVariant());
+    QInputMethodEvent event("", attributes);
+    QGuiApplication::sendEvent(qGuiApp->focusObject(), &event);
+}
+
+void MInputContext::getSelection(QString &selection, bool &valid) const
+{
+    selection.clear();
+
+    QString selectionText;
+    valid = false;
+
+    if (!inputMethodAccepted()) {
+        return;
+    }
+
+    QInputMethodQueryEvent query(Qt::ImCurrentSelection);
+    QGuiApplication::sendEvent(qGuiApp->focusObject(), &query);
+
+    QVariant queryResult = query.value(Qt::ImCurrentSelection);
+    valid = queryResult.isValid();
+    selectionText = queryResult.toString();
+
+    selection = selectionText;
+}
+
+int MInputContext::cursorStartPosition(bool *valid)
+{
+    int start = -1;
+    if (valid) {
+        *valid = false;
+    }
+
+    if (!inputMethodAccepted()) {
+        return start;
+    }
+
+    QInputMethodQueryEvent query(Qt::ImCursorPosition | Qt::ImAnchorPosition);
+    QGuiApplication::sendEvent(qGuiApp->focusObject(), &query);
+
+    // obtain the cursor absolute position
+    QVariant queryResult = query.value(Qt::ImCursorPosition);
+    if (queryResult.isValid()) {
+        int absCursorPos = queryResult.toInt();
+
+        // Fetch anchor position too but don't require it.
+        queryResult = query.value(Qt::ImAnchorPosition);
+        int absAnchorPos = queryResult.isValid() ? queryResult.toInt() : absCursorPos;
+
+        // In case of selection, base cursorPos on start of it.
+        start = qMin<int>(absCursorPos, absAnchorPos);
+        *valid = true;
+    }
+
+    return start;
+}
+
+void MInputContext::updateInputMethodExtensions()
+{
+    if (!inputMethodAccepted()) {
+        return;
+    }
+    if (debug) qDebug() << InputContextName << __PRETTY_FUNCTION__;
+
+    QVariantMap extensions = qGuiApp->focusObject()->property("__inputMethodExtensions").toMap();
+    QVariant value;
+    value = extensions.value("enterKeyIconSource");
+    imServer->setExtendedAttribute(0, "/keys", "actionKey", "icon", QVariant(value.toUrl().toString()));
+
+    value = extensions.value("enterKeyText");
+    imServer->setExtendedAttribute(0, "/keys", "actionKey", "label", QVariant(value.toString()));
+
+    value = extensions.value("enterKeyEnabled");
+    imServer->setExtendedAttribute(0, "/keys", "actionKey", "enabled", value.isValid() ? value.toBool() : true);
+
+    value = extensions.value("enterKeyHighlighted");
+    imServer->setExtendedAttribute(0, "/keys", "actionKey", "highlighted", value.isValid() ? value.toBool() : false);
+}

=== modified file '.pc/applied-patches'
--- .pc/applied-patches	2013-07-23 19:47:04 +0000
+++ .pc/applied-patches	2014-01-31 18:02:44 +0000
@@ -3,3 +3,4 @@
 0003-prediction.patch
 0004-fix_activationlostevent.patch
 0005-testability.patch
+0006-fix_orientation_to_angle_mapping.patch

=== modified file 'debian/changelog'
--- debian/changelog	2014-01-24 13:49:59 +0000
+++ debian/changelog	2014-01-31 18:02:44 +0000
@@ -1,3 +1,9 @@
+maliit-framework (0.99.0+git20130615+97e8335-0ubuntu6) trusty; urgency=medium
+
+  * Fix mapping between screen orientations and rotation angles. (LP: #1251330)
+
+ -- Daniel d'Andrada <[e-mail]>  Fri, 31 Jan 2014 15:59:27 -0200
+
 maliit-framework (0.99.0+git20130615+97e8335-0ubuntu5) trusty; urgency=medium
 
   * Modify xvfb command to successfully pass tests (LP: #1272249)

=== added file 'debian/patches/0006-fix_orientation_to_angle_mapping.patch'
--- debian/patches/0006-fix_orientation_to_angle_mapping.patch	1970-01-01 00:00:00 +0000
+++ debian/patches/0006-fix_orientation_to_angle_mapping.patch	2014-01-31 18:02:44 +0000
@@ -0,0 +1,38 @@
+Author: Daniel d'Andrada <[e-mail]>
+Bug: https://bugs.launchpad.net/ubuntu-keyboard/+bug/1251330
+Forwarded: no
+Description: Fix mapping between screen orientations and rotation angles.
+ Simply use the function that Qt provides for that.
+Index: orientationAngleMapping/input-context/minputcontext.cpp
+===================================================================
+--- orientationAngleMapping.orig/input-context/minputcontext.cpp	2014-01-31 15:40:11.336846000 -0200
++++ orientationAngleMapping/input-context/minputcontext.cpp	2014-01-31 15:41:15.171087065 -0200
+@@ -24,6 +24,7 @@
+ #include <QDebug>
+ #include <QByteArray>
+ #include <QRectF>
++#include <QScreen>
+ #include <QLocale>
+ #include <QWindow>
+ #include <QSharedDataPointer>
+@@ -36,18 +37,8 @@
+ 
+     int orientationAngle(Qt::ScreenOrientation orientation)
+     {
+-        switch (orientation) {
+-        case Qt::PrimaryOrientation: // Urgh.
+-        case Qt::PortraitOrientation:
+-            return MInputContext::Angle270;
+-        case Qt::LandscapeOrientation:
+-            return MInputContext::Angle0;
+-        case Qt::InvertedPortraitOrientation:
+-            return MInputContext::Angle90;
+-        case Qt::InvertedLandscapeOrientation:
+-            return MInputContext::Angle180;
+-        }
+-        return MInputContext::Angle0;
++        QScreen *screen = qGuiApp->primaryScreen();
++        return screen->angleBetween(screen->primaryOrientation(), orientation);
+     }
+ }
+ 

=== modified file 'debian/patches/series'
--- debian/patches/series	2013-07-23 19:47:04 +0000
+++ debian/patches/series	2014-01-31 18:02:44 +0000
@@ -3,3 +3,4 @@
 0003-prediction.patch
 0004-fix_activationlostevent.patch
 0005-testability.patch
+0006-fix_orientation_to_angle_mapping.patch

=== modified file 'input-context/minputcontext.cpp'
--- input-context/minputcontext.cpp	2013-07-23 19:47:04 +0000
+++ input-context/minputcontext.cpp	2014-01-31 18:02:44 +0000
@@ -24,6 +24,7 @@
 #include <QDebug>
 #include <QByteArray>
 #include <QRectF>
+#include <QScreen>
 #include <QLocale>
 #include <QWindow>
 #include <QSharedDataPointer>
@@ -36,18 +37,8 @@
 
     int orientationAngle(Qt::ScreenOrientation orientation)
     {
-        switch (orientation) {
-        case Qt::PrimaryOrientation: // Urgh.
-        case Qt::PortraitOrientation:
-            return MInputContext::Angle270;
-        case Qt::LandscapeOrientation:
-            return MInputContext::Angle0;
-        case Qt::InvertedPortraitOrientation:
-            return MInputContext::Angle90;
-        case Qt::InvertedLandscapeOrientation:
-            return MInputContext::Angle180;
-        }
-        return MInputContext::Angle0;
+        QScreen *screen = qGuiApp->primaryScreen();
+        return screen->angleBetween(screen->primaryOrientation(), orientation);
     }
 }