Merge lp:~mir-team/qtmir/port-to-msh-shell-and-mirevent2 into lp:qtmir

[kevin gunn]

merge of qtmir port to shell and mirevent2

merge of qtmir port to shell and mirevent2

[lp:~mir-team/qtmir/port-to-msh-shell-and-mirevent2]

320. By Andreas Pokorny on 2015-02-04

merged daniels branch into this one

321. By kevin gunn on 2015-02-04

fix typo

322. By Andreas Pokorny on 2015-02-04

duplicate mock entry oO

323. By Andreas Pokorny on 2015-02-04

fix test cases

324. By kevin gunn on 2015-02-05

added mirsurfaceattribute to the qtmir application

Unmerged revisions

324. By kevin gunn on 2015-02-05

added mirsurfaceattribute to the qtmir application

323. By Andreas Pokorny on 2015-02-04

fix test cases

322. By Andreas Pokorny on 2015-02-04

duplicate mock entry oO

321. By kevin gunn on 2015-02-04

fix typo

320. By Andreas Pokorny on 2015-02-04

merged daniels branch into this one

319. By kevin gunn on 2015-02-03

merge port to shell and mir event

318. By Robert Carr on 2015-01-30

Finish touch-event-support

317. By Robert Carr on 2015-01-29

Implement touch mods

316. By Robert Carr on 2015-01-29

Typo

315. By Robert Carr on 2015-01-29

Update to use chrono

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-12-09 14:12:57 +0000
+++ CMakeLists.txt	2015-02-05 10:26:37 +0000
@@ -78,6 +78,7 @@
 pkg_check_modules(GIO_UNIX gio-unix-2.0)
 pkg_check_modules(LTTNG lttng-ust)
 
+add_definitions(-DMIR_REQUIRE_DEPRECATED_EVENT_OPT_IN=1)
 
 # We expect this to be set via debian/rules for GLES builds
 if ("${USE_OPENGLES}" STREQUAL 1)
 
=== modified file 'debian/changelog'
--- debian/changelog	2015-01-15 15:19:46 +0000
+++ debian/changelog	2015-02-05 10:26:37 +0000
@@ -1,3 +1,9 @@
+qtmir (0.4.5) UNRELEASED; urgency=medium
+
+  * Add X-Ubuntu-Supported-Orientations desktop file entry
+
+ -- Daniel d'Andrada <[e-mail]>  Fri, 31 Oct 2014 10:17:42 -0200
+
 qtmir (0.4.4+15.04.20150115-0ubuntu1) vivid; urgency=low
 
   [ Gerry Boland ]
 
=== modified file 'debian/control'
--- debian/control	2015-01-14 09:07:31 +0000
+++ debian/control	2015-02-05 10:26:37 +0000
@@ -10,7 +10,7 @@
 # version. To allow cross-compiling to work, we also must
 # append :native to g++-4.9 so we don't try to run armhf g++
 # on an x86 CPU for example, when cross-compiling.
-               g++-4.9:native,
+               g++-4.9,
                google-mock (>= 1.6.0+svn437),
                libboost-system-dev,
                libfontconfig1-dev,
@@ -26,7 +26,7 @@
                libubuntu-app-launch2-dev,
                libubuntu-application-api-dev (>= 2.1.0),
                libudev-dev,
-               libunity-api-dev (>= 7.92),
+               libunity-api-dev (>= 7.94),
                liburl-dispatcher1-dev,
                libxkbcommon-dev,
                libxrender-dev,
@@ -96,7 +96,7 @@
 Conflicts: libqtmir,
            libunity-mir1,
 Provides: unity-application-impl,
-          unity-application-impl-4,
+          unity-application-impl-5,
 Description: Qt plugin for Unity specific Mir APIs
  QtMir provides Qt/QML bindings for Mir features that are exposed through the
  qtmir-desktop or qtmir-android QPA plugin such as Application management
 
=== modified file 'src/common/debughelpers.cpp'
--- src/common/debughelpers.cpp	2014-08-27 11:51:28 +0000
+++ src/common/debughelpers.cpp	2015-02-05 10:26:37 +0000
@@ -176,31 +176,15 @@
     }
 }
 
-const char *mirMotionActionToStr(int value)
+const char *mirTouchActionToStr(MirTouchInputEventTouchAction action)
 {
-    switch (value) {
-    case mir_motion_action_move:
-        return "move";
-    case mir_motion_action_down:
+    switch (action) {
+    case mir_touch_input_event_action_up:
+        return "up";
+    case mir_touch_input_event_action_down:
         return "down";
-    case mir_motion_action_up:
-        return "up";
-    case mir_motion_action_pointer_down:
-        return "pointer_down";
-    case mir_motion_action_cancel:
-        return "cancel";
-    case mir_motion_action_pointer_up:
-        return "pointer_up";
-    case mir_motion_action_outside:
-        return "outside";
-    case mir_motion_action_hover_move:
-        return "hover_move";
-    case mir_motion_action_scroll:
-        return "scroll";
-    case mir_motion_action_hover_enter:
-        return "hover_enter";
-    case mir_motion_action_hover_exit:
-        return "hover_exit";
+    case mir_touch_input_event_action_change:
+        return "change";
     default:
         return "???";
     }
 
=== modified file 'src/modules/Unity/Application/application.cpp'
--- src/modules/Unity/Application/application.cpp	2015-01-08 12:35:41 +0000
+++ src/modules/Unity/Application/application.cpp	2015-02-05 10:26:37 +0000
@@ -60,12 +60,9 @@
     // FIXME(greyback) need to save long appId internally until ubuntu-app-launch can hide it from us
     m_longAppId = desktopFileReader->file().remove(QRegExp(".desktop$")).split('/').last();
 
-    // FIXME: This is a hack. Remove once we have a real implementation for knowing the supported
-    // orientations of an app
-    m_supportedOrientations = PortraitOrientation
-        | LandscapeOrientation
-        | InvertedPortraitOrientation
-        | InvertedLandscapeOrientation;
+    m_supportedOrientations = m_desktopData->supportedOrientations();
+
+    m_rotatesWindowContents = m_desktopData->rotatesWindowContents();
 }
 
 Application::~Application()
@@ -353,11 +350,16 @@
     return m_longAppId;
 }
 
-Application::SupportedOrientations Application::supportedOrientations() const
+Qt::ScreenOrientations Application::supportedOrientations() const
 {
     return m_supportedOrientations;
 }
 
+bool Application::rotatesWindowContents() const
+{
+    return m_rotatesWindowContents;
+}
+
 Session* Application::session() const
 {
     return m_session;
 
=== modified file 'src/modules/Unity/Application/application.h'
--- src/modules/Unity/Application/application.h	2015-01-08 12:35:41 +0000
+++ src/modules/Unity/Application/application.h	2015-02-05 10:26:37 +0000
@@ -47,27 +47,15 @@
 {
     Q_OBJECT
 
-    Q_FLAGS(Orientation SupportedOrientations)
-
     Q_PROPERTY(QString desktopFile READ desktopFile CONSTANT)
     Q_PROPERTY(QString exec READ exec CONSTANT)
     Q_PROPERTY(bool fullscreen READ fullscreen NOTIFY fullscreenChanged)
     Q_PROPERTY(Stage stage READ stage WRITE setStage NOTIFY stageChanged)
-    Q_PROPERTY(SupportedOrientations supportedOrientations READ supportedOrientations CONSTANT)
     Q_PROPERTY(Session* session READ session NOTIFY sessionChanged DESIGNABLE false)
 
 public:
     Q_DECLARE_FLAGS(Stages, Stage)
 
-    // Matching Qt::ScreenOrientation values for convenience
-    enum Orientation {
-        PortraitOrientation = 0x1,
-        LandscapeOrientation = 0x2,
-        InvertedPortraitOrientation = 0x4,
-        InvertedLandscapeOrientation = 0x8
-    };
-    Q_DECLARE_FLAGS(SupportedOrientations, Orientation)
-
     Application(const QSharedPointer<TaskController>& taskController,
                 const QSharedPointer<SharedWakelock>& sharedWakelock,
                 DesktopFileReader *desktopFileReader,
@@ -90,6 +78,8 @@
     QColor splashColor() const override;
     QColor splashColorHeader() const override;
     QColor splashColorFooter() const override;
+    Qt::ScreenOrientations supportedOrientations() const override;
+    bool rotatesWindowContents() const override;
 
     void setStage(Stage stage);
     void setState(State state);
@@ -105,7 +95,6 @@
     bool fullscreen() const;
 
     Stages supportedStages() const;
-    SupportedOrientations supportedOrientations() const;
 
     pid_t pid() const;
 
@@ -140,7 +129,8 @@
     bool m_focused;
     bool m_canBeResumed;
     QStringList m_arguments;
-    SupportedOrientations m_supportedOrientations;
+    Qt::ScreenOrientations m_supportedOrientations;
+    bool m_rotatesWindowContents;
     Session *m_session;
 
     friend class ApplicationManager;
@@ -151,6 +141,5 @@
 } // namespace qtmir
 
 Q_DECLARE_METATYPE(qtmir::Application*)
-Q_DECLARE_OPERATORS_FOR_FLAGS(qtmir::Application::SupportedOrientations)
 
 #endif  // APPLICATION_H
 
=== modified file 'src/modules/Unity/Application/application_manager.cpp'
--- src/modules/Unity/Application/application_manager.cpp	2015-01-07 17:56:07 +0000
+++ src/modules/Unity/Application/application_manager.cpp	2015-02-05 10:26:37 +0000
@@ -61,33 +61,6 @@
 
 namespace {
 
-// FIXME: AppManager should not implement policy based on display geometry, shell should do that
-bool forceAllAppsIntoMainStage(const QSharedPointer<MirServer> &mirServer)
-{
-    const int tabletModeMinimimWithGU = 100;
-
-    // Obtain display size
-    mir::geometry::Rectangles view_area;
-    mirServer->the_display()->for_each_display_buffer(
-        [&view_area](const mir::graphics::DisplayBuffer & db)
-        {
-            view_area.add(db.view_area());
-        });
-
-    // Get current Grid Unit value
-    int gridUnitPx = 8;
-    QByteArray gridUnitString = qgetenv("GRID_UNIT_PX");
-    if (!gridUnitString.isEmpty()) {
-        bool ok;
-        int value = gridUnitString.toInt(&ok);
-        if (ok) {
-            gridUnitPx = value;
-        }
-    }
-
-    return (view_area.bounding_rectangle().size.width.as_int() < tabletModeMinimimWithGU * gridUnitPx);
-}
-
 // FIXME: To be removed once shell has fully adopted short appIds!!
 QString toShortAppIdIfPossible(const QString &appId) {
     QRegExp longAppIdMask("[a-z0-9][a-z0-9+.-]+_[a-zA-Z0-9+.-]+_[0-9][a-zA-Z0-9.+:~-]*");
@@ -413,7 +386,9 @@
     if (m_focusedApplication) {
         m_focusedApplication->setFocused(false);
         Application *lastApplication = applicationForStage(application->stage());
-        suspendApplication(lastApplication);
+        if (lastApplication != application) {
+            suspendApplication(lastApplication);
+        }
     }
 
     if (application->stage() == Application::MainStage) {
@@ -539,10 +514,6 @@
             return;
         }
 
-        // override stage if necessary (i.e. side stage invalid on phone)
-        if (application->stage() == Application::SideStage && forceAllAppsIntoMainStage(m_mirServer))
-            application->setStage(Application::MainStage);
-
         add(application);
         Q_EMIT focusRequested(appId);
     }
 
=== modified file 'src/modules/Unity/Application/desktopfilereader.cpp'
--- src/modules/Unity/Application/desktopfilereader.cpp	2014-10-07 13:43:17 +0000
+++ src/modules/Unity/Application/desktopfilereader.cpp	2015-02-05 10:26:37 +0000
@@ -68,6 +68,8 @@
     : d_ptr(new DesktopFileReaderPrivate(this))
 {
     Q_D(DesktopFileReader);
+    qCDebug(QTMIR_APPLICATIONS) << "Loading desktop file" << desktopFile.absoluteFilePath()
+            << "for appId" << appId;
 
     d->appId = appId;
     d->file = desktopFile.absoluteFilePath();
@@ -202,6 +204,100 @@
     return d->getKey("X-Ubuntu-Splash-Color-Footer");
 }
 
+Qt::ScreenOrientations DesktopFileReader::supportedOrientations() const
+{
+    Q_D(const DesktopFileReader);
+    Qt::ScreenOrientations result;
+
+    if (!parseOrientations(d->getKey("X-Ubuntu-Supported-Orientations"), result)) {
+        qCWarning(QTMIR_APPLICATIONS) << d->file << "has an invalid X-Ubuntu-Supported-Orientations entry.";
+    }
+
+    return result;
+}
+
+bool DesktopFileReader::rotatesWindowContents() const
+{
+    Q_D(const DesktopFileReader);
+    bool result;
+
+    if (!parseBoolean(d->getKey("X-Ubuntu-Rotates-Window-Contents"), result)) {
+        qCWarning(QTMIR_APPLICATIONS) << d->file << "has an invalid X-Ubuntu-Rotates-Window-Contents entry.";
+    }
+
+    return result;
+}
+
+bool DesktopFileReader::parseOrientations(const QString &rawString, Qt::ScreenOrientations &result)
+{
+    // Default to all orientations
+    result = Qt::PortraitOrientation | Qt::LandscapeOrientation
+        | Qt::InvertedPortraitOrientation | Qt::InvertedLandscapeOrientation;
+
+    if (rawString.isEmpty()) {
+        return true;
+    }
+
+    Qt::ScreenOrientations parsedOrientations = 0;
+    bool ok = true;
+
+    QStringList orientationsList = rawString
+            .simplified()
+            .replace(QChar(','), ";")
+            .remove(QChar(' '))
+            .remove(QChar('-'))
+            .remove(QChar('_'))
+            .toLower()
+            .split(";");
+
+    for (int i = 0; i < orientationsList.count() && ok; ++i) {
+        const QString &orientationString = orientationsList.at(i);
+        if (orientationString.isEmpty()) {
+            // skip it
+            continue;
+        }
+
+        if (orientationString == "portrait") {
+            parsedOrientations |= Qt::PortraitOrientation;
+        } else if (orientationString == "landscape") {
+            parsedOrientations |= Qt::LandscapeOrientation;
+        } else if (orientationString == "invertedportrait") {
+            parsedOrientations |= Qt::InvertedPortraitOrientation;
+        } else if (orientationString == "invertedlandscape") {
+            parsedOrientations |= Qt::InvertedLandscapeOrientation;
+        } else if (orientationsList.count() == 1 && orientationString == "primary") {
+            // Special case: primary orientation must be alone
+            // There's no sense in supporting primary orientation + other orientations
+            // like "primary,landscape"
+            parsedOrientations = Qt::PrimaryOrientation;
+        } else {
+            ok = false;
+        }
+    }
+
+    if (ok) {
+        result = parsedOrientations;
+    }
+
+    return ok;
+}
+
+bool DesktopFileReader::parseBoolean(const QString &rawString, bool &result)
+{
+    QString cookedString = rawString.trimmed().toLower();
+
+    result = cookedString == "y"
+          || cookedString == "1"
+          || cookedString == "yes"
+          || cookedString == "true";
+
+    return result || rawString.isEmpty()
+        || cookedString == "n"
+        || cookedString == "0"
+        || cookedString == "no"
+        || cookedString == "false";
+}
+
 bool DesktopFileReader::loaded() const
 {
     Q_D(const DesktopFileReader);
 
=== modified file 'src/modules/Unity/Application/desktopfilereader.h'
--- src/modules/Unity/Application/desktopfilereader.h	2014-10-14 19:39:43 +0000
+++ src/modules/Unity/Application/desktopfilereader.h	2015-02-05 10:26:37 +0000
@@ -55,8 +55,13 @@
     virtual QString splashColor() const;
     virtual QString splashColorHeader() const;
     virtual QString splashColorFooter() const;
+    virtual Qt::ScreenOrientations supportedOrientations() const;
+    virtual bool rotatesWindowContents() const;
     virtual bool loaded() const;
 
+    static bool parseOrientations(const QString &rawString, Qt::ScreenOrientations &result);
+    static bool parseBoolean(const QString &rawString, bool &result);
+
 protected:
     DesktopFileReader(const QString &appId, const QFileInfo &desktopFile);
 
 
=== modified file 'src/modules/Unity/Application/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-01-14 09:07:41 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-02-05 10:26:37 +0000
@@ -44,6 +44,7 @@
 
 // Mir
 #include <mir/geometry/rectangle.h>
+#include <mir/events/event_builders.h>
 #include <mir_toolkit/event.h>
 
 namespace mg = mir::graphics;
@@ -52,160 +53,99 @@
 
 namespace {
 
-bool fillInMirEvent(MirEvent &mirEvent, QKeyEvent *qtEvent)
-{
-    mirEvent.type = mir_event_type_key;
-
-    // don't care
-    mirEvent.key.device_id = 0;
-    mirEvent.key.source_id = 0;
-
-    switch (qtEvent->type()) {
-        case QEvent::KeyPress:
-            mirEvent.key.action = mir_key_action_down;
-            break;
-        case QEvent::KeyRelease:
-            mirEvent.key.action = mir_key_action_up;
-            break;
-        default:
-            return false;
-    }
-
-    // don't care
-    mirEvent.key.flags = (MirKeyFlag)0;
-
-    mirEvent.key.modifiers = qtEvent->nativeModifiers();
-    mirEvent.key.key_code = qtEvent->nativeVirtualKey();
-    mirEvent.key.scan_code = qtEvent->nativeScanCode();
-
-    // TODO: It's not the best that we lose the actual repeat count from
-    // the original mir event (pre QtEventFeeder)...of course it will
-    // not matter for Qt clients...so this is an improvement for now.
-    mirEvent.key.repeat_count = qtEvent->isAutoRepeat() ? 1 : 0;
-
-    // Don't care
-    mirEvent.key.down_time = 0;
-
-    mirEvent.key.event_time = qtEvent->timestamp() * 1000000;
-
-    // Don't care
-    mirEvent.key.is_system_key = 0;
-
-    return true;
-}
-
-bool fillInMirEvent(MirEvent &mirEvent,
-                    const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
-                    Qt::TouchPointStates qtTouchPointStates,
-                    ulong qtTimestamp)
-{
-    mirEvent.type = mir_event_type_motion;
-
-    // Hardcoding it for now
-    // TODO: Gather this info from a QTouchDevice-derived class created by QtEventFeeder
-    mirEvent.motion.device_id = 0;
-    mirEvent.motion.source_id = 0x00001002; // AINPUT_SOURCE_TOUCHSCREEN; https://bugs.launchpad.net/bugs/1311687
-
-    // NB: it's assumed that touch points are pressed and released
-    // one at a time.
-
-    if (qtTouchPointStates.testFlag(Qt::TouchPointPressed)) {
-        if (qtTouchPoints.count() > 1) {
-            mirEvent.motion.action = mir_motion_action_pointer_down;
-        } else {
-            mirEvent.motion.action = mir_motion_action_down;
-        }
-    } else if (qtTouchPointStates.testFlag(Qt::TouchPointReleased)) {
-        if (qtTouchPoints.count() > 1) {
-            mirEvent.motion.action = mir_motion_action_pointer_up;
-        } else {
-            mirEvent.motion.action = mir_motion_action_up;
-        }
-    } else {
-            mirEvent.motion.action = mir_motion_action_move;
-    }
-
-    // not used
-    mirEvent.motion.flags = (MirMotionFlag) 0;
-
-    // TODO: map QInputEvent::modifiers()
-    mirEvent.motion.modifiers = 0;
-
-    // not used
-    mirEvent.motion.edge_flags = 0;
-
-    // TODO
-    mirEvent.motion.button_state = (MirMotionButton) 0;
-
-    // Does it matter?
-    mirEvent.motion.x_offset = 0.;
-    mirEvent.motion.y_offset = 0.;
-    mirEvent.motion.x_precision = 0.1;
-    mirEvent.motion.y_precision = 0.1;
-
-    // TODO. Not useful to Qt at least...
-    mirEvent.motion.down_time = 0;
-
-    // Note: QtEventFeeder scales the event time down, scale it back up - precision is
-    // lost but the time difference should still be accurate to milliseconds
-    mirEvent.motion.event_time = static_cast<nsecs_t>(qtTimestamp) * 1000000;
-
-    mirEvent.motion.pointer_count = qtTouchPoints.count();
-
+// Would be better if QMouseEvent had nativeModifiers
+MirInputEventModifiers
+mir_modifiers_from_qt(Qt::KeyboardModifiers mods)
+{
+    MirInputEventModifiers m_mods = mir_input_event_modifier_none;
+    if (mods & Qt::ShiftModifier)
+        m_mods |= mir_input_event_modifier_shift;
+    if (mods & Qt::ControlModifier)
+        m_mods |= mir_input_event_modifier_ctrl;
+    if (mods & Qt::AltModifier)
+        m_mods |= mir_input_event_modifier_alt;
+    if (mods & Qt::MetaModifier)
+        m_mods |= mir_input_event_modifier_meta;
+
+    return m_mods;
+}
+
+mir::EventUPtr makeMirEvent(QMouseEvent *qtEvent, MirPointerInputEventAction action)
+{
+    auto timestamp = qtEvent->timestamp() * 1000000;
+    auto modifiers = mir_modifiers_from_qt(qtEvent->modifiers());
+
+    std::vector<MirPointerInputEventButton> buttons;
+    if (qtEvent->buttons() & Qt::LeftButton)
+        buttons.push_back(mir_pointer_input_button_primary);
+    if (qtEvent->buttons() & Qt::RightButton)
+        buttons.push_back(mir_pointer_input_button_secondary);
+    if (qtEvent->buttons() & Qt::MidButton)
+        buttons.push_back(mir_pointer_input_button_tertiary);
+
+    return mir::events::make_event(0 /*DeviceID */, timestamp, modifiers, action,
+                                   buttons, qtEvent->x(), qtEvent->y(), 0, 0);
+}
+
+mir::EventUPtr makeMirEvent(QKeyEvent *qtEvent)
+{
+    MirKeyInputEventAction action = mir_key_input_event_action_down;
+    switch (qtEvent->type())
+    {
+    case QEvent::KeyPress:
+        action = mir_key_input_event_action_down;
+        break;
+    case QEvent::KeyRelease:
+        action = mir_key_input_event_action_up;
+        break;
+    default:
+        break;
+    }
+    if (qtEvent->isAutoRepeat())
+        action = mir_key_input_event_action_repeat;
+
+    return mir::events::make_event(0 /* DeviceID */, qtEvent->timestamp() * 1000000,
+                           action, qtEvent->nativeVirtualKey(),
+                           qtEvent->nativeScanCode(),
+                           qtEvent->nativeModifiers());
+}
+    
+mir::EventUPtr makeMirEvent(Qt::KeyboardModifiers qmods,
+                            const QList<QTouchEvent::TouchPoint> &qtTouchPoints,
+                            Qt::TouchPointStates /* qtTouchPointStates */,
+                            ulong qtTimestamp)
+{
+    auto modifiers = mir_modifiers_from_qt(qmods);
+    auto ev = mir::events::make_event(0, static_cast<int64_t>(qtTimestamp) * 1000000,
+                                      modifiers);
+   
     for (int i = 0; i < qtTouchPoints.count(); ++i) {
         auto touchPoint = qtTouchPoints.at(i);
-        auto &pointer = mirEvent.motion.pointer_coordinates[i];
-
-        // FIXME: https://bugs.launchpad.net/mir/+bug/1311699
-        // When multiple touch points are transmitted with a MirEvent
-        // and one of them (only one is allowed) indicates a presse
-        // state change the index is encoded in the second byte of the
-        // action value.
-        const int mir_motion_event_pointer_index_shift = 8;
-        if (mirEvent.motion.action == mir_motion_action_pointer_up &&
-            touchPoint.state() == Qt::TouchPointReleased)
-        {
-            mirEvent.motion.action |= i << mir_motion_event_pointer_index_shift;
-        }
-        if (mirEvent.motion.action == mir_motion_action_pointer_down &&
-            touchPoint.state() == Qt::TouchPointPressed)
-        {
-            mirEvent.motion.action |= i << mir_motion_event_pointer_index_shift;
-        }
-
-
-        pointer.id = touchPoint.id();
-        pointer.x = touchPoint.pos().x();
-        pointer.y = touchPoint.pos().y();
-
-        // FIXME: https://bugs.launchpad.net/mir/+bug/1311809
-
-        if (touchPoint.rawScreenPositions().isEmpty()) {
-            pointer.raw_x = 0.;
-            pointer.raw_y = 0.;
-        } else {
-            pointer.raw_x = touchPoint.rawScreenPositions().at(0).x();
-            pointer.raw_y =  touchPoint.rawScreenPositions().at(0).y();
-        }
-
-        pointer.touch_major = touchPoint.rect().width();
-        pointer.touch_minor = touchPoint.rect().height();
-        pointer.size = 0.;
-        pointer.pressure = touchPoint.pressure();
-        pointer.orientation = 0.;
-        pointer.vscroll = 0.;
-        pointer.hscroll = 0.;
-
-        // TODO: Mir supports a wider set of tool types (finger, stylus, mouse, eraser, unknown).
-        // so just because we are not TouchPoint::Pen does not mean we are motion_tool_type_finger...
-        // however this is the best we can do with the QtEventFeeder approach.
+        auto id = touchPoint.id();
+
+        MirTouchInputEventTouchAction action = mir_touch_input_event_action_change;
+        if (touchPoint.state() == Qt::TouchPointReleased)
+        {
+            action = mir_touch_input_event_action_up;
+        }
+        if (touchPoint.state() == Qt::TouchPointPressed)
+        {
+            action = mir_touch_input_event_action_down;
+        }
+
+        MirTouchInputEventTouchTooltype tooltype = mir_touch_input_tool_type_finger;
         if (touchPoint.flags() & QTouchEvent::TouchPoint::Pen)
-            pointer.tool_type = mir_motion_tool_type_stylus;
-        else
-            pointer.tool_type = mir_motion_tool_type_finger;
+            tooltype = mir_touch_input_tool_type_stylus;
+
+        mir::events::add_touch(*ev, id, action, tooltype,
+                               touchPoint.pos().x(), touchPoint.pos().y(),
+                               touchPoint.pressure(),
+                               touchPoint.rect().width(),
+                               touchPoint.rect().height(),
+                               0 /* size */);
     }
 
-    return true;
+    return ev;
 }
 
 } // namespace {
@@ -243,7 +183,7 @@
     , m_session(session)
     , m_firstFrameDrawn(false)
     , m_live(true)
-    , m_orientation(Qt::PortraitOrientation)
+    , m_orientationAngle(Angle0)
     , m_textureProvider(nullptr)
     , m_lastTouchEvent(nullptr)
 {
@@ -352,49 +292,42 @@
     return static_cast<MirSurfaceItem::State>(m_surface->state());
 }
 
-Qt::ScreenOrientation MirSurfaceItem::orientation() const
+MirSurfaceItem::OrientationAngle MirSurfaceItem::orientationAngle() const
 {
-    return m_orientation;
+    return m_orientationAngle;
 }
 
-void MirSurfaceItem::setOrientation(const Qt::ScreenOrientation orientation)
+void MirSurfaceItem::setOrientationAngle(MirSurfaceItem::OrientationAngle angle)
 {
-    qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::setOrientation - orientation=" << orientation;
+    qCDebug(QTMIR_SURFACES, "MirSurfaceItem::setOrientationAngle(%d)", angle);
 
-    if (m_orientation == orientation)
+    if (m_orientationAngle == angle)
         return;
 
     MirOrientation mirOrientation;
-    Qt::ScreenOrientation nativeOrientation = QGuiApplication::primaryScreen()->nativeOrientation();
-    const bool landscapeNativeOrientation = (nativeOrientation == Qt::LandscapeOrientation);
-
-    Qt::ScreenOrientation requestedOrientation = orientation;
-    if (orientation == Qt::PrimaryOrientation) { // means orientation equals native orientation, set it as such
-        requestedOrientation = nativeOrientation;
-    }
-
-    switch(requestedOrientation) {
-    case Qt::PortraitOrientation:
-        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_right : mir_orientation_normal;
-        break;
-    case Qt::LandscapeOrientation:
-        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_normal : mir_orientation_left;
-        break;
-    case Qt::InvertedPortraitOrientation:
-        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_left : mir_orientation_inverted;
-        break;
-    case Qt::InvertedLandscapeOrientation:
-        mirOrientation = (landscapeNativeOrientation) ? mir_orientation_inverted : mir_orientation_right;
+
+    switch (angle) {
+    case Angle0:
+        mirOrientation = mir_orientation_normal;
+        break;
+    case Angle90:
+        mirOrientation = mir_orientation_right;
+        break;
+    case Angle180:
+        mirOrientation = mir_orientation_inverted;
+        break;
+    case Angle270:
+        mirOrientation = mir_orientation_left;
         break;
     default:
-        qWarning("Unrecognized Qt::ScreenOrientation!");
+        qCWarning(QTMIR_SURFACES, "Unsupported orientation angle: %d", angle);
         return;
     }
 
     m_surface->set_orientation(mirOrientation);
 
-    m_orientation = orientation;
-    Q_EMIT orientationChanged();
+    m_orientationAngle = angle;
+    Q_EMIT orientationAngleChanged(angle);
 }
 
 QString MirSurfaceItem::name() const
@@ -440,10 +373,11 @@
     ensureProvider();
     bool textureUpdated = false;
 
+    const void* const user_id = (void*)123;
     std::unique_ptr<mg::Renderable> renderable =
-        m_surface->compositor_snapshot((void*)123/*user_id*/);
+        m_surface->compositor_snapshot(user_id);
 
-    if (renderable->buffers_ready_for_compositor() > 0) {
+    if (m_surface->buffers_ready_for_compositor(user_id) > 0) {
         if (!m_textureProvider->t) {
             m_textureProvider->t = new MirBufferSGTexture(renderable->buffer());
         } else {
@@ -455,7 +389,7 @@
         textureUpdated = true;
     }
 
-    if (renderable->buffers_ready_for_compositor() > 0) {
+    if (m_surface->buffers_ready_for_compositor(user_id) > 0) {
         QTimer::singleShot(0, this, SLOT(update()));
         // restart the frame dropper so that we have enough time to render the next frame.
         m_frameDropperTimer.start();
@@ -507,18 +441,20 @@
 
 void MirSurfaceItem::mousePressEvent(QMouseEvent *event)
 {
-    // TODO: Implement for desktop support
-    event->ignore();
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_down);
+    m_surface->consume(*ev);
 }
 
 void MirSurfaceItem::mouseMoveEvent(QMouseEvent *event)
 {
-    Q_UNUSED(event);
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_motion);
+    m_surface->consume(*ev);
 }
 
 void MirSurfaceItem::mouseReleaseEvent(QMouseEvent *event)
 {
-    Q_UNUSED(event);
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_up);
+    m_surface->consume(*ev);
 }
 
 void MirSurfaceItem::wheelEvent(QWheelEvent *event)
@@ -528,18 +464,14 @@
 
 void MirSurfaceItem::keyPressEvent(QKeyEvent *qtEvent)
 {
-    MirEvent mirEvent;
-    if (fillInMirEvent(mirEvent, qtEvent)) {
-        m_surface->consume(mirEvent);
-    }
+    auto ev = makeMirEvent(qtEvent);
+    m_surface->consume(*ev);
 }
 
 void MirSurfaceItem::keyReleaseEvent(QKeyEvent *qtEvent)
 {
-    MirEvent mirEvent;
-    if (fillInMirEvent(mirEvent, qtEvent)) {
-        m_surface->consume(mirEvent);
-    }
+    auto ev = makeMirEvent(qtEvent);
+    m_surface->consume(*ev);
 }
 
 QString MirSurfaceItem::appId() const
@@ -555,8 +487,6 @@
 
 void MirSurfaceItem::endCurrentTouchSequence(ulong timestamp)
 {
-    MirEvent mirEvent;
-
     Q_ASSERT(m_lastTouchEvent);
     Q_ASSERT(m_lastTouchEvent->type != QEvent::TouchEnd);
     Q_ASSERT(m_lastTouchEvent->touchPoints.count() > 0);
@@ -580,10 +510,10 @@
 
         touchEvent.updateTouchPointStatesAndType();
 
-        if (fillInMirEvent(mirEvent, touchEvent.touchPoints,
-                           touchEvent.touchPointStates, touchEvent.timestamp)) {
-            m_surface->consume(mirEvent);
-        }
+        auto ev = makeMirEvent(touchEvent.modifiers, touchEvent.touchPoints, 
+                               touchEvent.touchPointStates, touchEvent.timestamp);
+        m_surface->consume(*ev);
+        
         *m_lastTouchEvent = touchEvent;
 
         touchEvent.touchPoints.removeAt(0);
@@ -592,11 +522,10 @@
 
 void MirSurfaceItem::validateAndDeliverTouchEvent(int eventType,
             ulong timestamp,
+            Qt::KeyboardModifiers mods,
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates)
 {
-    MirEvent mirEvent;
-
     if (eventType == QEvent::TouchBegin && m_lastTouchEvent && m_lastTouchEvent->type != QEvent::TouchEnd) {
         qCWarning(QTMIR_SURFACES) << qPrintable(QString("MirSurfaceItem(%1) - Got a QEvent::TouchBegin while "
             "there's still an active/unfinished touch sequence.").arg(appId()));
@@ -604,9 +533,8 @@
         endCurrentTouchSequence(timestamp);
     }
 
-    if (fillInMirEvent(mirEvent, touchPoints, touchPointStates, timestamp)) {
-        m_surface->consume(mirEvent);
-    }
+    auto ev = makeMirEvent(mods, touchPoints, touchPointStates, timestamp);
+    m_surface->consume(*ev);
 
     if (!m_lastTouchEvent) {
         m_lastTouchEvent = new TouchEvent;
@@ -621,6 +549,7 @@
 {
     bool accepted = processTouchEvent(event->type(),
             event->timestamp(),
+            event->modifiers(),
             event->touchPoints(),
             event->touchPointStates());
     event->setAccepted(accepted);
@@ -629,6 +558,7 @@
 bool MirSurfaceItem::processTouchEvent(
         int eventType,
         ulong timestamp,
+        Qt::KeyboardModifiers mods,
         const QList<QTouchEvent::TouchPoint> &touchPoints,
         Qt::TouchPointStates touchPointStates)
 {
@@ -636,7 +566,7 @@
     if (type() == InputMethod && eventType == QEvent::TouchBegin) {
         // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
         if (hasTouchInsideUbuntuKeyboard(touchPoints)) {
-            validateAndDeliverTouchEvent(eventType, timestamp, touchPoints, touchPointStates);
+            validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
         } else {
             accepted = false;
         }
@@ -644,7 +574,7 @@
     } else {
         // NB: If we are getting QEvent::TouchUpdate or QEvent::TouchEnd it's because we've
         // previously accepted the corresponding QEvent::TouchBegin
-        validateAndDeliverTouchEvent(eventType, timestamp, touchPoints, touchPointStates);
+        validateAndDeliverTouchEvent(eventType, timestamp, mods, touchPoints, touchPointStates);
     }
     return accepted;
 }
@@ -747,18 +677,17 @@
 {
     QMutexLocker locker(&m_mutex);
 
-    std::unique_ptr<mg::Renderable> renderable =
-        m_surface->compositor_snapshot((void*)123/*user_id*/);
+    const void* const user_id = (void*)123;  // TODO: Multimonitor support
 
-    while (renderable->buffers_ready_for_compositor() > 0) {
+    while (m_surface->buffers_ready_for_compositor(user_id) > 0) {
         // The line below looks like an innocent, effect-less, getter. But as this
         // method returns a unique_pointer, not holding its reference causes the
         // buffer to be destroyed/released straight away.
-        m_surface->compositor_snapshot((void*)123/*user_id*/)->buffer();
+        m_surface->compositor_snapshot(user_id)->buffer();
         qCDebug(QTMIR_SURFACES) << "MirSurfaceItem::dropPendingBuffers()"
             << "surface =" << this
             << "buffer dropped."
-            << renderable->buffers_ready_for_compositor()
+            << m_surface->buffers_ready_for_compositor(user_id)
             << "left.";
     }
 }
 
=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-01-14 08:24:29 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-02-05 10:26:37 +0000
@@ -47,12 +47,17 @@
     Q_OBJECT
     Q_ENUMS(Type)
     Q_ENUMS(State)
+    Q_ENUMS(OrientationAngle)
 
     Q_PROPERTY(Type type READ type NOTIFY typeChanged)
     Q_PROPERTY(State state READ state NOTIFY stateChanged)
     Q_PROPERTY(QString name READ name NOTIFY nameChanged)
     Q_PROPERTY(bool live READ live NOTIFY liveChanged)
-    Q_PROPERTY(Qt::ScreenOrientation orientation READ orientation WRITE setOrientation NOTIFY orientationChanged DESIGNABLE false)
+
+    // How many degrees, clockwise, the UI in the surface has to rotate to match with the
+    // shell UI orientation
+    Q_PROPERTY(OrientationAngle orientationAngle READ orientationAngle WRITE setOrientationAngle
+               NOTIFY orientationAngleChanged DESIGNABLE false)
 
 public:
     explicit MirSurfaceItem(std::shared_ptr<mir::scene::Surface> surface,
@@ -81,12 +86,18 @@
         Fullscreen = mir_surface_state_fullscreen,
     };
 
+    enum OrientationAngle {
+        Angle0 = 0,
+        Angle90 = 90,
+        Angle180 = 180,
+        Angle270 = 270
+    };
+
     //getters
     Type type() const;
     State state() const;
     QString name() const;
     bool live() const;
-    Qt::ScreenOrientation orientation() const;
     SessionInterface *session() const;
 
     Q_INVOKABLE void release();
@@ -100,12 +111,15 @@
 
     bool isFirstFrameDrawn() const { return m_firstFrameDrawn; }
 
-    void setOrientation(const Qt::ScreenOrientation orientation);
+    OrientationAngle orientationAngle() const;
+    void setOrientationAngle(OrientationAngle angle);
+
     void setSession(SessionInterface *app);
 
     // to allow easy touch event injection from tests
     bool processTouchEvent(int eventType,
             ulong timestamp,
+            Qt::KeyboardModifiers modifiers,
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates);
 
@@ -113,7 +127,7 @@
     void typeChanged();
     void stateChanged();
     void nameChanged();
-    void orientationChanged();
+    void orientationAngleChanged(OrientationAngle angle);
     void liveChanged(bool live);
     void firstFrameDrawn(MirSurfaceItem *item);
 
@@ -164,6 +178,7 @@
     void endCurrentTouchSequence(ulong timestamp);
     void validateAndDeliverTouchEvent(int eventType,
             ulong timestamp,
+            Qt::KeyboardModifiers modifiers,
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates);
 
@@ -173,7 +188,9 @@
     QPointer<SessionInterface> m_session;
     bool m_firstFrameDrawn;
     bool m_live;
-    Qt::ScreenOrientation m_orientation; //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
+
+    //FIXME -  have to save the state as Mir has no getter for it (bug:1357429)
+    OrientationAngle m_orientationAngle;
 
     QMirSurfaceTextureProvider *m_textureProvider;
 
@@ -188,6 +205,7 @@
         TouchEvent &operator= (const QTouchEvent &qtEvent) {
             type = qtEvent.type();
             timestamp = qtEvent.timestamp();
+            modifiers = qtEvent.modifiers();
             touchPoints = qtEvent.touchPoints();
             touchPointStates = qtEvent.touchPointStates();
             return *this;
@@ -197,6 +215,7 @@
 
         int type;
         ulong timestamp;
+        Qt::KeyboardModifiers modifiers;
         QList<QTouchEvent::TouchPoint> touchPoints;
         Qt::TouchPointStates touchPointStates;
     } *m_lastTouchEvent;
@@ -207,5 +226,6 @@
 } // namespace qtmir
 
 Q_DECLARE_METATYPE(qtmir::MirSurfaceItem*)
+Q_DECLARE_METATYPE(qtmir::MirSurfaceItem::OrientationAngle)
 
 #endif // MIRSURFACEITEM_H
 
=== modified file 'src/modules/Unity/Application/mirsurfacemanager.cpp'
--- src/modules/Unity/Application/mirsurfacemanager.cpp	2014-12-16 15:55:29 +0000
+++ src/modules/Unity/Application/mirsurfacemanager.cpp	2015-02-05 10:26:37 +0000
@@ -31,7 +31,7 @@
 #include "nativeinterface.h"
 #include "mirserver.h"
 #include "sessionlistener.h"
-#include "surfaceconfigurator.h"
+#include "mirshell.h"
 #include "logging.h"
 
 Q_LOGGING_CATEGORY(QTMIR_SURFACES, "qtmir.surfaces")
@@ -51,9 +51,9 @@
                      manager, &MirSurfaceManager::onSessionDestroyingSurface);
 }
 
-void connectToSurfaceConfigurator(MirSurfaceManager *manager, SurfaceConfigurator *surfaceConfigurator)
+void connectToShell(MirSurfaceManager *manager, MirShell *shell)
 {
-    QObject::connect(surfaceConfigurator, &SurfaceConfigurator::surfaceAttributeChanged,
+    QObject::connect(shell, &MirShell::surfaceAttributeChanged,
                      manager, &MirSurfaceManager::onSurfaceAttributeChanged);
 }
 
@@ -70,12 +70,12 @@
         }
 
         SessionListener *sessionListener = static_cast<SessionListener*>(nativeInterface->nativeResourceForIntegration("SessionListener"));
-        SurfaceConfigurator *surfaceConfigurator = static_cast<SurfaceConfigurator*>(nativeInterface->nativeResourceForIntegration("SessionConfigurator"));
+        MirShell *shell = static_cast<MirShell*>(nativeInterface->nativeResourceForIntegration("Shell"));
 
         the_surface_manager = new MirSurfaceManager(nativeInterface->m_mirServer, SessionManager::singleton());
 
         connectToSessionListener(the_surface_manager, sessionListener);
-        connectToSurfaceConfigurator(the_surface_manager, surfaceConfigurator);
+        connectToShell(the_surface_manager, shell);
     }
     return the_surface_manager;
 }
 
=== modified file 'src/modules/Unity/Application/plugin.cpp'
--- src/modules/Unity/Application/plugin.cpp	2014-10-06 11:37:56 +0000
+++ src/modules/Unity/Application/plugin.cpp	2015-02-05 10:26:37 +0000
@@ -78,6 +78,7 @@
         qRegisterMetaType<qtmir::Session*>("Session*");
         qRegisterMetaType<qtmir::SessionInterface*>("SessionInterface*");
         qRegisterMetaType<qtmir::SessionModel*>("SessionModel*");
+        qRegisterMetaType<MirSurfaceAttrib>("MirSurfaceAttrib");
 
         qmlRegisterUncreatableType<unity::shell::application::ApplicationManagerInterface>(
                     uri, 0, 1, "ApplicationManagerInterface", "Abstract interface. Cannot be created in QML");
 
=== modified file 'src/modules/Unity/Application/sessionmanager.cpp'
--- src/modules/Unity/Application/sessionmanager.cpp	2014-12-01 11:05:01 +0000
+++ src/modules/Unity/Application/sessionmanager.cpp	2015-02-05 10:26:37 +0000
@@ -26,7 +26,7 @@
 #include "nativeinterface.h"
 #include "mirserver.h"
 #include "sessionlistener.h"
-#include "surfaceconfigurator.h"
+#include "mirshell.h"
 #include "logging.h"
 #include "promptsessionlistener.h"
 
 
=== modified file 'src/platforms/mirserver/CMakeLists.txt'
--- src/platforms/mirserver/CMakeLists.txt	2014-12-12 15:15:06 +0000
+++ src/platforms/mirserver/CMakeLists.txt	2015-02-05 10:26:37 +0000
@@ -38,16 +38,14 @@
 
 set(MIRSERVER_QPA_PLUGIN_SRC
     ../../common/debughelpers.cpp
-    focussetter.cpp
+    mirshell.cpp
     qteventfeeder.cpp
     plugin.cpp
     qmirserver.cpp
     sessionauthorizer.cpp
     sessionlistener.cpp
-    surfaceconfigurator.cpp
     surfaceobserver.cpp
     promptsessionlistener.cpp
-    mirplacementstrategy.cpp
     mirserver.cpp
     mirserverstatuslistener.cpp
     display.cpp
 
=== removed file 'src/platforms/mirserver/focussetter.cpp'
--- src/platforms/mirserver/focussetter.cpp	2014-07-02 11:06:22 +0000
+++ src/platforms/mirserver/focussetter.cpp	1970-01-01 00:00:00 +0000
@@ -1,24 +0,0 @@
-/*
- * Copyright (C) 2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "focussetter.h"
-
-void FocusSetter::set_focus_to(std::shared_ptr<mir::scene::Session> const&)
-{
-    // no-op
-    // The focus concept live entirely inside the shell qml scene. Therefore
-    // we don't want anything in mir to intervene with it
-}
 
=== removed file 'src/platforms/mirserver/focussetter.h'
--- src/platforms/mirserver/focussetter.h	2014-07-02 11:06:22 +0000
+++ src/platforms/mirserver/focussetter.h	1970-01-01 00:00:00 +0000
@@ -1,28 +0,0 @@
-/*
- * Copyright (C) 2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef QPAMIRSERVER_FOCUS_SETTER_H
-#define QPAMIRSERVER_FOCUS_SETTER_H
-
-#include <mir/shell/focus_setter.h>
-
-class FocusSetter : public mir::shell::FocusSetter
-{
-public:
-    void set_focus_to(std::shared_ptr<mir::scene::Session> const& new_focus) override;
-};
-
-#endif // QPAMIRSERVER_FOCUS_SETTER_H
 
=== removed file 'src/platforms/mirserver/mirplacementstrategy.cpp'
--- src/platforms/mirserver/mirplacementstrategy.cpp	2014-09-22 18:06:58 +0000
+++ src/platforms/mirserver/mirplacementstrategy.cpp	1970-01-01 00:00:00 +0000
@@ -1,59 +0,0 @@
-/*
- * Copyright (C) 2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "mirplacementstrategy.h"
-#include "logging.h"
-#include "tracepoints.h" // generated from tracepoints.tp
-
-#include <mir/geometry/rectangle.h>
-#include <mir/shell/display_layout.h>
-#include <mir/scene/surface_creation_parameters.h>
-
-namespace ms = mir::scene;
-namespace msh = mir::shell;
-
-MirPlacementStrategy::MirPlacementStrategy(
-        std::shared_ptr<msh::DisplayLayout> const& display_layout)
-    : m_displayLayout(display_layout)
-{
-    qCDebug(QTMIR_MIR_MESSAGES) << "MirPlacementStrategy::MirPlacementStrategy";
-}
-
-ms::SurfaceCreationParameters
-MirPlacementStrategy::place(ms::Session const& /*session*/,
-        ms::SurfaceCreationParameters const& requestParameters)
-{
-    tracepoint(qtmirserver, surfacePlacementStart);
-
-    // TODO: Callback unity8 so that it can make a decision on that.
-    //       unity8 must bear in mind that the called function will be on a Mir thread though.
-    //       The QPA shouldn't be deciding for itself on such things.
-
-    ms::SurfaceCreationParameters placedParameters = requestParameters;
-
-    // Just make it fullscreen for now
-    mir::geometry::Rectangle rect{requestParameters.top_left, requestParameters.size};
-    m_displayLayout->size_to_output(rect);
-    placedParameters.size = rect.size;
-
-    qCDebug(QTMIR_MIR_MESSAGES) << "MirPlacementStrategy: requested ("
-        << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and returned ("
-        << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
-
-    tracepoint(qtmirserver, surfacePlacementEnd);
-
-    return placedParameters;
-}
 
=== removed file 'src/platforms/mirserver/mirplacementstrategy.h'
--- src/platforms/mirserver/mirplacementstrategy.h	2014-04-17 22:25:39 +0000
+++ src/platforms/mirserver/mirplacementstrategy.h	1970-01-01 00:00:00 +0000
@@ -1,42 +0,0 @@
-/*
- * Copyright (C) 2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef MIRSERVERQPA_MIR_PLACEMENT_STRATEGY_H
-#define MIRSERVERQPA_MIR_PLACEMENT_STRATEGY_H
-
-#include <mir/scene/placement_strategy.h>
-
-#include <memory>
-
-namespace mir {
-    namespace shell {
-        class DisplayLayout;
-    }
-}
-
-class MirPlacementStrategy : public mir::scene::PlacementStrategy
-{
-public:
-    MirPlacementStrategy(std::shared_ptr<mir::shell::DisplayLayout> const& display_layout);
-
-    mir::scene::SurfaceCreationParameters place(mir::scene::Session const& session,
-            mir::scene::SurfaceCreationParameters const& request_parameters) override;
-
-private:
-    std::shared_ptr<mir::shell::DisplayLayout> const m_displayLayout;
-};
-
-#endif //  MIRSERVERQPA_MIR_PLACEMENT_STRATEGY_H
 
=== modified file 'src/platforms/mirserver/mirserver.cpp'
--- src/platforms/mirserver/mirserver.cpp	2014-12-03 12:06:30 +0000
+++ src/platforms/mirserver/mirserver.cpp	2015-02-05 10:26:37 +0000
@@ -19,13 +19,11 @@
 #include "mirserver.h"
 
 // local
-#include "focussetter.h"
+#include "mirshell.h"
 #include "mirglconfig.h"
-#include "mirplacementstrategy.h"
 #include "mirserverstatuslistener.h"
 #include "promptsessionlistener.h"
 #include "sessionlistener.h"
-#include "surfaceconfigurator.h"
 #include "sessionauthorizer.h"
 #include "qtcompositor.h"
 #include "qteventfeeder.h"
@@ -53,11 +51,6 @@
     set_command_line_handler(&ignore_unparsed_arguments);
     set_command_line(argc, argv);
 
-    override_the_placement_strategy([this]
-        {
-            return std::make_shared<MirPlacementStrategy>(the_shell_display_layout());
-        });
-
     override_the_session_listener([]
         {
             return std::make_shared<SessionListener>();
@@ -68,11 +61,6 @@
             return std::make_shared<PromptSessionListener>();
         });
 
-    override_the_surface_configurator([]
-        {
-            return std::make_shared<SurfaceConfigurator>();
-        });
-
     override_the_session_authorizer([]
         {
             return std::make_shared<SessionAuthorizer>();
@@ -102,9 +90,17 @@
             return std::make_shared<MirServerStatusListener>();
         });
 
-    override_the_shell_focus_setter([]
+    override_the_shell([this]
         {
-            return std::make_shared<FocusSetter>();
+            auto const shell = std::make_shared<MirShell>(
+                the_input_targeter(),
+                the_surface_coordinator(),
+                the_session_coordinator(),
+                the_prompt_session_manager(),
+                the_shell_display_layout());
+
+            m_shell = shell;
+            return shell;
         });
 
     set_terminator([&](int)
@@ -157,10 +153,7 @@
     return static_cast<PromptSessionListener*>(sharedPtr.get());
 }
 
-SurfaceConfigurator *MirServer::surfaceConfigurator()
+MirShell *MirServer::shell()
 {
-    auto sharedPtr = the_surface_configurator();
-    if (sharedPtr.unique()) return 0;
-
-    return static_cast<SurfaceConfigurator*>(sharedPtr.get());
+    return m_shell.lock().get();
 }
 
=== modified file 'src/platforms/mirserver/mirserver.h'
--- src/platforms/mirserver/mirserver.h	2014-12-02 14:55:17 +0000
+++ src/platforms/mirserver/mirserver.h	2015-02-05 10:26:37 +0000
@@ -23,7 +23,7 @@
 class QtEventFeeder;
 class SessionListener;
 class SessionAuthorizer;
-class SurfaceConfigurator;
+class MirShell;
 class PromptSessionListener;
 
 // We use virtual inheritance of mir::Server to facilitate derived classes (e.g. testing)
@@ -34,7 +34,7 @@
 
     Q_PROPERTY(SessionAuthorizer* sessionAuthorizer READ sessionAuthorizer CONSTANT)
     Q_PROPERTY(SessionListener* sessionListener READ sessionListener CONSTANT)
-    Q_PROPERTY(SurfaceConfigurator* surfaceConfigurator READ surfaceConfigurator CONSTANT)
+    Q_PROPERTY(MirShell* shell READ shell CONSTANT)
     Q_PROPERTY(PromptSessionListener* promptSessionListener READ promptSessionListener CONSTANT)
 
 public:
@@ -58,10 +58,11 @@
     SessionAuthorizer *sessionAuthorizer();
     SessionListener *sessionListener();
     PromptSessionListener *promptSessionListener();
-    SurfaceConfigurator *surfaceConfigurator();
+    MirShell *shell();
 
 private:
     std::shared_ptr<QtEventFeeder> m_qtEventFeeder;
+    std::weak_ptr<MirShell> m_shell;
 };
 
 #endif // MIRSERVER_H
 
=== added file 'src/platforms/mirserver/mirshell.cpp'
--- src/platforms/mirserver/mirshell.cpp	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/mirshell.cpp	2015-02-05 10:26:37 +0000
@@ -0,0 +1,75 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "mirshell.h"
+#include "logging.h"
+#include "tracepoints.h" // generated from tracepoints.tp
+
+#include <mir/geometry/rectangle.h>
+#include <mir/scene/session.h>
+#include <mir/scene/surface_creation_parameters.h>
+#include <mir/shell/display_layout.h>
+
+namespace ms = mir::scene;
+using mir::shell::AbstractShell;
+
+MirShell::MirShell(
+    std::shared_ptr<mir::shell::InputTargeter> const& input_targeter,
+    std::shared_ptr<mir::scene::SurfaceCoordinator> const& surface_coordinator,
+    std::shared_ptr<mir::scene::SessionCoordinator> const& session_coordinator,
+    std::shared_ptr<mir::scene::PromptSessionManager> const& prompt_session_manager,
+    std::shared_ptr<mir::shell::DisplayLayout> const& display_layout) :
+    AbstractShell(input_targeter, surface_coordinator, session_coordinator, prompt_session_manager),
+    m_displayLayout{display_layout}
+{
+    qCDebug(QTMIR_MIR_MESSAGES) << "MirShell::MirShell";
+}
+
+mir::frontend::SurfaceId MirShell::create_surface(std::shared_ptr<ms::Session> const& session, ms::SurfaceCreationParameters const& requestParameters)
+{
+    tracepoint(qtmirserver, surfacePlacementStart);
+
+     // TODO: Callback unity8 so that it can make a decision on that.
+     //       unity8 must bear in mind that the called function will be on a Mir thread though.
+     //       The QPA shouldn't be deciding for itself on such things.
+
+     ms::SurfaceCreationParameters placedParameters = requestParameters;
+
+     // Just make it fullscreen for now
+     mir::geometry::Rectangle rect{requestParameters.top_left, requestParameters.size};
+     m_displayLayout->size_to_output(rect);
+     placedParameters.size = rect.size;
+
+     qCDebug(QTMIR_MIR_MESSAGES) << "MirShell::create_surface(): size requested ("
+         << requestParameters.size.width.as_int() << "," << requestParameters.size.height.as_int() << ") and placed ("
+         << placedParameters.size.width.as_int() << "," << placedParameters.size.height.as_int() << ")";
+
+     tracepoint(qtmirserver, surfacePlacementEnd);
+
+     return AbstractShell::create_surface(session, placedParameters);
+}
+
+int MirShell::set_surface_attribute(
+    std::shared_ptr<mir::scene::Session> const& session,
+    std::shared_ptr<mir::scene::Surface> const& surface,
+    MirSurfaceAttrib attrib,
+    int value)
+{
+    auto const result = AbstractShell::set_surface_attribute(session, surface, attrib, value);
+    Q_EMIT surfaceAttributeChanged(surface.get(), attrib, result);
+
+    return result;
+}
 
=== added file 'src/platforms/mirserver/mirshell.h'
--- src/platforms/mirserver/mirshell.h	1970-01-01 00:00:00 +0000
+++ src/platforms/mirserver/mirshell.h	2015-02-05 10:26:37 +0000
@@ -0,0 +1,56 @@
+/*
+ * Copyright © 2015 Canonical Ltd.
+ *
+ * This program is free software: you can redistribute it and/or modify it under
+ * the terms of the GNU Lesser General Public License version 3, as published by
+ * the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
+ * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * Lesser General Public License for more details.
+ *
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#ifndef QPAMIRSERVER_SHELL_H
+#define QPAMIRSERVER_SHELL_H
+
+#include <mir/shell/abstract_shell.h>
+#include <QObject>
+
+namespace mir {
+    namespace shell {
+        class DisplayLayout;
+    }
+}
+
+class MirShell : public QObject, public mir::shell::AbstractShell
+{
+    Q_OBJECT
+
+public:
+    MirShell(
+        std::shared_ptr<mir::shell::InputTargeter> const& input_targeter,
+        std::shared_ptr<mir::scene::SurfaceCoordinator> const& surface_coordinator,
+        std::shared_ptr<mir::scene::SessionCoordinator> const& session_coordinator,
+        std::shared_ptr<mir::scene::PromptSessionManager> const& prompt_session_manager,
+        std::shared_ptr<mir::shell::DisplayLayout> const& display_layout);
+
+    virtual mir::frontend::SurfaceId create_surface(std::shared_ptr<mir::scene::Session> const& session, mir::scene::SurfaceCreationParameters const& params);
+
+    int set_surface_attribute(
+        std::shared_ptr<mir::scene::Session> const& session,
+        std::shared_ptr<mir::scene::Surface> const& surface,
+        MirSurfaceAttrib attrib,
+        int value) override;
+
+Q_SIGNALS:
+    void surfaceAttributeChanged(mir::scene::Surface const*, const MirSurfaceAttrib, const int);
+
+private:
+    std::shared_ptr<mir::shell::DisplayLayout> const m_displayLayout;
+};
+
+#endif /* QPAMIRSERVER_SHELL_H */
 
=== modified file 'src/platforms/mirserver/nativeinterface.cpp'
--- src/platforms/mirserver/nativeinterface.cpp	2014-12-01 11:05:01 +0000
+++ src/platforms/mirserver/nativeinterface.cpp	2015-02-05 10:26:37 +0000
@@ -29,8 +29,8 @@
 
     if (resource == "SessionAuthorizer")
         result = m_mirServer->sessionAuthorizer();
-    else if (resource == "SessionConfigurator")
-        result = m_mirServer->surfaceConfigurator();
+    else if (resource == "Shell")
+        result = m_mirServer->shell();
     else if (resource == "SessionListener")
         result = m_mirServer->sessionListener();
     else if (resource == "PromptSessionListener")
 
=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2015-01-05 21:42:31 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2015-02-05 10:26:37 +0000
@@ -33,11 +33,6 @@
 Q_LOGGING_CATEGORY(QTMIR_MIR_INPUT, "qtmir.mir.input")
 
 // from android-input AMOTION_EVENT_ACTION_*, hidden inside mir bowels
-// mir headers should define them
-const int QtEventFeeder::MirEventActionMask = 0xff;
-const int QtEventFeeder::MirEventActionPointerIndexMask = 0xff00;
-const int QtEventFeeder::MirEventActionPointerIndexShift = 8;
-
 
 // XKB Keysyms which do not map directly to Qt types (i.e. Unicode points)
 static const uint32_t KeyTable[] = {
@@ -182,6 +177,15 @@
         Q_ASSERT(!mTopLevelWindow.isNull());
         QWindowSystemInterface::handleTouchEvent(mTopLevelWindow.data(), timestamp, device, points, mods);
     }
+
+    void handleMouseEvent(ulong timestamp, QPointF point, Qt::MouseButton buttons, Qt::KeyboardModifiers modifiers) override
+    {
+        Q_ASSERT(!mTopLevelWindow.isNull());
+        QWindowSystemInterface::handleMouseEvent(mTopLevelWindow.data(), timestamp, point, point, // local and global point are the same
+            buttons, modifiers);
+    }
+
+
 private:
     QPointer<QWindow> mTopLevelWindow;
 };
@@ -216,55 +220,109 @@
 
 void QtEventFeeder::dispatch(MirEvent const& event)
 {
-    switch (event.type) {
-    case mir_event_type_key:
-        dispatchKey(event.key);
-        break;
-    case mir_event_type_motion:
-        dispatchMotion(event.motion);
-        break;
-    case mir_event_type_surface:
-        // Just ignore these events: it doesn't make sense to pass them on.
-        break;
+    auto type = mir_event_get_type(&event);
+    if (type != mir_event_type_input)
+        return;
+    auto iev = mir_event_get_input_event(&event);
+    
+    switch (mir_input_event_get_type(iev)) {
+    case mir_input_event_type_key:
+        dispatchKey(iev);
+        break;
+    case mir_input_event_type_touch:
+        dispatchTouch(iev);
+        break;
+    case mir_input_event_type_pointer:
+        dispatchPointer(iev);
     default:
-        // mir_event_type_surface and mir_event_type_resize events go through
-        // mir's own protobuf channel instead of the android_input one. The latter
-        // being the one we're dealing with here.
-        qFatal("QtEventFeeder got unsupported event type from mir");
         break;
     }
 }
 
-void QtEventFeeder::dispatchKey(MirKeyEvent const& event)
-{
-    if (!mQtWindowSystem->hasTargetWindow())
-        return;
-
-    ulong timestamp = event.event_time / 1000000;
-    xkb_keysym_t xk_sym = static_cast<xkb_keysym_t>(event.key_code);
+namespace
+{
+
+Qt::KeyboardModifiers qt_modifiers_from_mir(MirInputEventModifiers modifiers)
+{
+    int q_modifiers = Qt::NoModifier;
+    if (modifiers & mir_input_event_modifier_shift) {
+        q_modifiers |= Qt::ShiftModifier;
+    }
+    if (modifiers & mir_input_event_modifier_ctrl) {
+        q_modifiers |= Qt::ControlModifier;
+    }
+    if (modifiers & mir_input_event_modifier_alt) {
+        q_modifiers |= Qt::AltModifier;
+    }
+    if (modifiers & mir_input_event_modifier_meta) {
+        q_modifiers |= Qt::MetaModifier;
+    }
+    return static_cast<Qt::KeyboardModifiers>(q_modifiers);
+}
+
+Qt::MouseButton extract_buttons(MirPointerInputEvent const* pev)
+{
+    int buttons = Qt::NoButton;
+    if (mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_primary))
+        buttons |= Qt::LeftButton;
+    if (mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_secondary))
+        buttons |= Qt::RightButton;
+    if (mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_tertiary))
+        buttons |= Qt::MidButton;
+
+    // TODO: Should mir back and forward buttons exist?
+    // should they be Qt::X button 1 and 2?
+    return static_cast<Qt::MouseButton>(buttons);
+}
+}
+
+void QtEventFeeder::dispatchPointer(MirInputEvent const* ev)
+{
+    if (!mQtWindowSystem->hasTargetWindow())
+        return;
+    
+    auto timestamp = mir_input_event_get_event_time(ev) / 1000000;
+
+    auto pev = mir_input_event_get_pointer_input_event(ev);
+    auto modifiers = qt_modifiers_from_mir(mir_pointer_input_event_get_modifiers(pev));
+    auto buttons = extract_buttons(pev);
+
+    auto local_point = QPointF(mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_x),
+                               mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_y));
+    
+    mQtWindowSystem->handleMouseEvent(timestamp, local_point,
+                                      buttons, modifiers);
+}
+
+void QtEventFeeder::dispatchKey(MirInputEvent const* event)
+{
+    if (!mQtWindowSystem->hasTargetWindow())
+        return;
+
+    ulong timestamp = mir_input_event_get_event_time(event) / 1000000;
+
+    auto kev = mir_input_event_get_key_input_event(event);
+    xkb_keysym_t xk_sym = mir_key_input_event_get_key_code(kev);
 
     // Key modifier and unicode index mapping.
-    const int kEventModifiers = event.modifiers;
-    Qt::KeyboardModifiers modifiers = Qt::NoModifier;
-    if (kEventModifiers & mir_key_modifier_shift) {
-        modifiers |= Qt::ShiftModifier;
-    }
-    if (kEventModifiers & mir_key_modifier_ctrl) {
-        modifiers |= Qt::ControlModifier;
-    }
-    if (kEventModifiers & mir_key_modifier_alt) {
-        modifiers |= Qt::AltModifier;
-    }
-    if (kEventModifiers & mir_key_modifier_meta) {
-        modifiers |= Qt::MetaModifier;
-    }
+    auto modifiers = qt_modifiers_from_mir(mir_key_input_event_get_modifiers(kev));
 
     // Key action
-    QEvent::Type keyType;
-    if (event.action == mir_key_action_down) {
+    QEvent::Type keyType = QEvent::KeyRelease;
+    bool is_auto_rep = false;
+    
+    switch (mir_key_input_event_get_action(kev))
+    {
+    case mir_key_input_event_action_repeat:
+        is_auto_rep = true; // fall-through
+    case mir_key_input_event_action_down:
         keyType = QEvent::KeyPress;
-    } else {
+        break;
+    case mir_key_input_event_action_up:
         keyType = QEvent::KeyRelease;
+        break;
+    default:
+        break;
     }
 
     // Key event propagation.
@@ -272,13 +330,13 @@
     int keyCode = translateKeysym(xk_sym, s, sizeof(s));
     QString text = QString::fromLatin1(s);
     
-    bool is_auto_rep = event.repeat_count > 0;
-
     QPlatformInputContext* context = QGuiApplicationPrivate::platformIntegration()->inputContext();
     if (context) {
         // TODO: consider event.repeat_count
         QKeyEvent qKeyEvent(keyType, keyCode, modifiers,
-                            event.scan_code, event.key_code, event.modifiers,
+                            mir_key_input_event_get_scan_code(kev),
+                            mir_key_input_event_get_key_code(kev),
+                            mir_key_input_event_get_modifiers(kev),
                             text, is_auto_rep);
         qKeyEvent.setTimestamp(timestamp);
         if (context->filterEvent(&qKeyEvent)) {
@@ -288,27 +346,17 @@
     }
 
     mQtWindowSystem->handleExtendedKeyEvent(timestamp, keyType, keyCode, modifiers,
-            event.scan_code, event.key_code, event.modifiers, text, is_auto_rep);
+        mir_key_input_event_get_scan_code(kev),
+        mir_key_input_event_get_key_code(kev),
+        mir_key_input_event_get_modifiers(kev), text, is_auto_rep);
 }
 
-void QtEventFeeder::dispatchMotion(MirMotionEvent const& event)
+void QtEventFeeder::dispatchTouch(MirInputEvent const* event)
 {
     if (!mQtWindowSystem->hasTargetWindow())
         return;
 
-    const int mirMotionAction = event.action & MirEventActionMask;
-
-    // Ignore the events that do not interest us (or that we currently don't support or know
-    // how to translate into Qt events)
-    if (mirMotionAction != mir_motion_action_move
-            && mirMotionAction != mir_motion_action_down
-            && mirMotionAction != mir_motion_action_up
-            && mirMotionAction != mir_motion_action_pointer_down
-            && mirMotionAction != mir_motion_action_pointer_up
-            && mirMotionAction != mir_motion_action_cancel) {
-        return;
-    }
-
+    auto tev = mir_input_event_get_touch_input_event(event);
 
     // FIXME(loicm) Max pressure is device specific. That one is for the Samsung Galaxy Nexus. That
     //     needs to be fixed as soon as the compat input lib adds query support.
@@ -318,72 +366,48 @@
 
     // TODO: Is it worth setting the Qt::TouchPointStationary ones? Currently they are left
     //       as Qt::TouchPointMoved
-    const int kPointerCount = (int) event.pointer_count;
+    const int kPointerCount = mir_touch_input_event_get_touch_count(tev);
     for (int i = 0; i < kPointerCount; ++i) {
         QWindowSystemInterface::TouchPoint touchPoint;
 
-        const float kX = event.pointer_coordinates[i].x;
-        const float kY = event.pointer_coordinates[i].y;
-        const float kW = event.pointer_coordinates[i].touch_major;
-        const float kH = event.pointer_coordinates[i].touch_minor;
-        const float kP = event.pointer_coordinates[i].pressure;
-        touchPoint.id = event.pointer_coordinates[i].id;
+        const float kX = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_x);
+        const float kY = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_y);
+        const float kW = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_touch_major);
+        const float kH = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_touch_minor);
+        const float kP = mir_touch_input_event_get_touch_axis_value(tev, i, mir_touch_input_axis_pressure);
+        touchPoint.id = mir_touch_input_event_get_touch_id(tev, i);
+        
         touchPoint.normalPosition = QPointF(kX / kWindowGeometry.width(), kY / kWindowGeometry.height());
         touchPoint.area = QRectF(kX - (kW / 2.0), kY - (kH / 2.0), kW, kH);
         touchPoint.pressure = kP / kMaxPressure;
-        touchPoint.state = Qt::TouchPointMoved;
+        switch (mir_touch_input_event_get_touch_action(tev, i))
+        {
+        case mir_touch_input_event_action_up:
+            touchPoint.state = Qt::TouchPointReleased;
+            break;
+        case mir_touch_input_event_action_down:
+            touchPoint.state = Qt::TouchPointPressed;
+            break;
+        case mir_touch_input_event_action_change:
+            touchPoint.state = Qt::TouchPointMoved;
+            break;
+        default:
+            break;
+        }
 
         touchPoints.append(touchPoint);
     }
 
-    switch (mirMotionAction) {
-    case mir_motion_action_move:
-        // No extra work needed.
-        break;
-
-    case mir_motion_action_down:
-        // NB: hardcoded index 0 because there's only a single touch point in this case
-        touchPoints[0].state = Qt::TouchPointPressed;
-        break;
-
-    case mir_motion_action_up:
-        touchPoints[0].state = Qt::TouchPointReleased;
-        break;
-
-    case mir_motion_action_pointer_down: {
-        const int index = (event.action & MirEventActionPointerIndexMask) >>
-            MirEventActionPointerIndexShift;
-        touchPoints[index].state = Qt::TouchPointPressed;
-        break;
-        }
-
-    case mir_motion_action_cancel:
-    case mir_motion_action_pointer_up: {
-        const int index = (event.action & MirEventActionPointerIndexMask) >>
-            MirEventActionPointerIndexShift;
-        touchPoints[index].state = Qt::TouchPointReleased;
-        break;
-        }
-
-    case mir_motion_action_outside:
-    case mir_motion_action_hover_move:
-    case mir_motion_action_scroll:
-    case mir_motion_action_hover_enter:
-    case mir_motion_action_hover_exit:
-    default:
-        // Should never reach this point. If so, it's a programming error.
-        qFatal("Trying to handle unsupported motion event action");
-    }
-
     // Qt needs a happy, sane stream of touch events. So let's make sure we're not forwarding
     // any insanity.
     validateTouches(touchPoints);
 
     // Touch event propagation.
     mQtWindowSystem->handleTouchEvent(
-            event.event_time / 1000000, //scales down the nsec_t (int64) to fit a ulong, precision lost but time difference suitable
-            mTouchDevice,
-            touchPoints);
+        //scales down the nsec_t (int64) to fit a ulong, precision lost but time difference suitable
+        mir_input_event_get_event_time(event) / 1000000,
+        mTouchDevice,
+        touchPoints);
 }
 
 void QtEventFeeder::start()
@@ -396,12 +420,12 @@
     // not used
 }
 
-void QtEventFeeder::configuration_changed(nsecs_t when)
+void QtEventFeeder::configuration_changed(std::chrono::nanoseconds when)
 {
     Q_UNUSED(when);
 }
 
-void QtEventFeeder::device_reset(int32_t device_id, nsecs_t when)
+void QtEventFeeder::device_reset(int32_t device_id, std::chrono::nanoseconds when)
 {
     Q_UNUSED(device_id);
     Q_UNUSED(when);
 
=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2014-08-28 12:22:55 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2015-02-05 10:26:37 +0000
@@ -51,6 +51,7 @@
         virtual void handleTouchEvent(ulong timestamp, QTouchDevice *device,
                 const QList<struct QWindowSystemInterface::TouchPoint> &points,
                 Qt::KeyboardModifiers mods = Qt::NoModifier) = 0;
+        virtual void handleMouseEvent(ulong timestamp, QPointF point, Qt::MouseButton buttons, Qt::KeyboardModifiers modifiers) = 0;
     };
 
     QtEventFeeder(QtWindowSystemInterface *windowSystem = nullptr);
@@ -60,15 +61,16 @@
     static const int MirEventActionPointerIndexMask;
     static const int MirEventActionPointerIndexShift;
 
-    void configuration_changed(nsecs_t when) override;
-    void device_reset(int32_t device_id, nsecs_t when) override;
+    void configuration_changed(std::chrono::nanoseconds when) override;
+    void device_reset(int32_t device_id, std::chrono::nanoseconds when) override;
     void dispatch(MirEvent const& event) override;
     void start() override;
     void stop() override;
 
 private:
-    void dispatchKey(MirKeyEvent const& event);
-    void dispatchMotion(MirMotionEvent const& event);
+    void dispatchKey(MirInputEvent const* event);
+    void dispatchTouch(MirInputEvent const* event);
+    void dispatchPointer(MirInputEvent const* event);
     void validateTouches(QList<QWindowSystemInterface::TouchPoint> &touchPoints);
     bool validateTouch(QWindowSystemInterface::TouchPoint &touchPoint);
 
 
=== removed file 'src/platforms/mirserver/surfaceconfigurator.cpp'
--- src/platforms/mirserver/surfaceconfigurator.cpp	2014-04-02 16:10:34 +0000
+++ src/platforms/mirserver/surfaceconfigurator.cpp	1970-01-01 00:00:00 +0000
@@ -1,34 +0,0 @@
-/*
- * Copyright (C) 2013,2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include "surfaceconfigurator.h"
-
-namespace ms = mir::scene;
-
-SurfaceConfigurator::SurfaceConfigurator()
-{
-    qRegisterMetaType<MirSurfaceAttrib>("MirSurfaceAttrib");
-}
-
-int SurfaceConfigurator::select_attribute_value(ms::Surface const&, MirSurfaceAttrib, int requested_value)
-{
-    return requested_value;
-}
-
-void SurfaceConfigurator::attribute_set(ms::Surface const& surface, MirSurfaceAttrib attrib, int value)
-{
-    Q_EMIT surfaceAttributeChanged(&surface, attrib, value);
-}
 
=== removed file 'src/platforms/mirserver/surfaceconfigurator.h'
--- src/platforms/mirserver/surfaceconfigurator.h	2014-04-02 16:10:34 +0000
+++ src/platforms/mirserver/surfaceconfigurator.h	1970-01-01 00:00:00 +0000
@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2013,2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#ifndef SURFACECONFIGURATOR_H
-#define SURFACECONFIGURATOR_H
-
-#include <QObject>
-
-#include <mir/scene/surface_configurator.h>
-#include <mir_toolkit/common.h>
-
-namespace mir { namespace scene { class Surface; }}
-
-class SurfaceConfigurator : public QObject, public mir::scene::SurfaceConfigurator
-{
-    Q_OBJECT
-
-public:
-    SurfaceConfigurator();
-
-    int select_attribute_value(mir::scene::Surface const&, MirSurfaceAttrib, int) override;
-    void attribute_set(mir::scene::Surface const&, MirSurfaceAttrib, int) override;
-
-Q_SIGNALS:
-    void surfaceAttributeChanged(mir::scene::Surface const*, const MirSurfaceAttrib, const int);
-};
-
-#endif // SURFACECONFIGURATOR_H
 
=== modified file 'tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h'
--- tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2014-08-28 12:20:13 +0000
+++ tests/mirserver/QtEventFeeder/mock_qtwindowsystem.h	2015-02-05 10:26:37 +0000
@@ -34,6 +34,7 @@
     MOCK_METHOD4(handleTouchEvent, void(ulong timestamp, QTouchDevice *device,
             const QList<struct QWindowSystemInterface::TouchPoint> &points,
             Qt::KeyboardModifiers mods));
+    MOCK_METHOD4(handleMouseEvent, void(ulong, QPointF, Qt::MouseButton, Qt::KeyboardModifiers));
 };
 
 namespace testing
 
=== modified file 'tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp'
--- tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2014-08-28 13:12:30 +0000
+++ tests/mirserver/QtEventFeeder/qteventfeeder_test.cpp	2015-02-05 10:26:37 +0000
@@ -15,6 +15,8 @@
  *
  */
 
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
 #include <gmock/gmock.h>
 #include <gtest/gtest.h>
 
@@ -191,34 +193,3 @@
     ASSERT_TRUE(Mock::VerifyAndClearExpectations(mockWindowSystem));
 }
 
-TEST_F(QtEventFeederTest, IgnoreHovering)
-{
-    setIrrelevantMockWindowSystemExpectations();
-    EXPECT_CALL(*mockWindowSystem, handleTouchEvent(_,_,_,_)).Times(0);
-
-    MirEvent mirEvent;
-    mirEvent.type = mir_event_type_motion;
-    mirEvent.motion.pointer_count = 1;
-    mirEvent.motion.pointer_coordinates[0].id = 0;
-    mirEvent.motion.pointer_coordinates[0].x = 10;
-    mirEvent.motion.pointer_coordinates[0].y = 10;
-    mirEvent.motion.pointer_coordinates[0].touch_major = 1;
-    mirEvent.motion.pointer_coordinates[0].touch_minor = 1;
-    mirEvent.motion.pointer_coordinates[0].pressure = 10;
-    mirEvent.motion.action = mir_motion_action_hover_enter;
-    mirEvent.motion.event_time = 123 * 1000000;
-
-    qtEventFeeder->dispatch(mirEvent);
-
-    mirEvent.motion.pointer_coordinates[0].x = 20;
-    mirEvent.motion.pointer_coordinates[0].y = 20;
-    mirEvent.motion.action = mir_motion_action_hover_move;
-    mirEvent.motion.event_time = 125 * 1000000;
-
-    qtEventFeeder->dispatch(mirEvent);
-
-    mirEvent.motion.action = mir_motion_action_hover_exit;
-    mirEvent.motion.event_time = 127 * 1000000;
-
-    qtEventFeeder->dispatch(mirEvent);
-}
 
=== modified file 'tests/modules/ApplicationManager/application_manager_test.cpp'
--- tests/modules/ApplicationManager/application_manager_test.cpp	2014-11-13 16:26:03 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2015-02-05 10:26:37 +0000
@@ -15,6 +15,8 @@
  *
  */
 
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
 #include <thread>
 #include <condition_variable>
 #include <QSignalSpy>
@@ -2135,3 +2137,100 @@
         cv.wait(lk, [&] { return done; } );
     }
 }
+
+/*
+   1 - launch and focus a main stage app
+     * main stage app is running and focused
+   2 - launch and focus a side stage app
+     * main stage app is running but is not focused
+     * side stage app is running and has focus
+   3 - focus the main stage app
+     * main stage app is running and has focus
+     * side stage app is running but is not focused
+
+   This is a regression test for the bug where on step 3, the main stage app was momentarily
+   suspended and then resumed again.
+ */
+TEST_F(ApplicationManagerTests, focusMainStageAfterSideStage)
+{
+    using namespace testing;
+
+    QString webbrowserAppId("webbrowser-app");
+    quint64 webbrowserPID = 123;
+    std::shared_ptr<mir::scene::Surface> webbrowserSurface(nullptr);
+
+    QString dialerAppId("dialer-app");
+    quint64 dialerPID = 456;
+    std::shared_ptr<mir::scene::Surface> dialerSurface(nullptr);
+
+    /*** Start webbrowser-app (main stage) ***/
+
+    ON_CALL(appController,appIdHasProcessId(webbrowserPID, webbrowserAppId)).WillByDefault(Return(true));
+
+    {
+        auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(webbrowserAppId, QFileInfo());
+        ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+        ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(webbrowserAppId));
+        ON_CALL(*mockDesktopFileReader, stageHint()).WillByDefault(Return("MainStage"));
+
+        ON_CALL(desktopFileReaderFactory, createInstance(webbrowserAppId, _))
+            .WillByDefault(Return(mockDesktopFileReader));
+    }
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(webbrowserAppId, _))
+            .Times(1)
+            .WillOnce(Return(true));
+
+    /*auto application =*/ applicationManager.startApplication(webbrowserAppId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(webbrowserAppId);
+
+    {
+        bool authed = false;
+        applicationManager.authorizeSession(webbrowserPID, authed);
+        EXPECT_EQ(authed, true);
+    }
+
+    auto webbrowserSession = std::make_shared<mir::scene::MockSession>(webbrowserAppId.toStdString(), webbrowserPID);
+    sessionManager.onSessionStarting(webbrowserSession);
+    applicationManager.focusApplication(webbrowserAppId);
+    applicationManager.onSessionCreatedSurface(webbrowserSession.get(), webbrowserSurface);
+
+    /*** Start dialer-app (side stage) ***/
+
+    ON_CALL(appController, appIdHasProcessId(dialerPID, dialerAppId)).WillByDefault(Return(true));
+
+    {
+        auto mockDesktopFileReader = new NiceMock<MockDesktopFileReader>(dialerAppId, QFileInfo());
+        ON_CALL(*mockDesktopFileReader, loaded()).WillByDefault(Return(true));
+        ON_CALL(*mockDesktopFileReader, appId()).WillByDefault(Return(dialerAppId));
+        ON_CALL(*mockDesktopFileReader, stageHint()).WillByDefault(Return("SideStage"));
+
+        ON_CALL(desktopFileReaderFactory, createInstance(dialerAppId, _))
+            .WillByDefault(Return(mockDesktopFileReader));
+    }
+
+    EXPECT_CALL(appController, startApplicationWithAppIdAndArgs(dialerAppId, _))
+            .Times(1)
+            .WillOnce(Return(true));
+
+    /*auto application =*/ applicationManager.startApplication(dialerAppId, ApplicationManager::NoFlag);
+    applicationManager.onProcessStarting(dialerAppId);
+
+    {
+        bool authed = false;
+        applicationManager.authorizeSession(dialerPID, authed);
+        EXPECT_EQ(authed, true);
+    }
+
+    auto dialerSession = std::make_shared<mir::scene::MockSession>(dialerAppId.toStdString(), dialerPID);
+    sessionManager.onSessionStarting(dialerSession);
+    applicationManager.focusApplication(dialerAppId);
+    applicationManager.onSessionCreatedSurface(dialerSession.get(), dialerSurface);
+
+    /*** Focus webbrowser ***/
+
+    // Nothing should happen as it's already the running main stage app
+    EXPECT_CALL(*webbrowserSession.get(), set_lifecycle_state(_))
+            .Times(0);
+    applicationManager.focusApplication(webbrowserAppId);
+}
 
=== modified file 'tests/modules/DesktopFileReader/desktopfilereader_test.cpp'
--- tests/modules/DesktopFileReader/desktopfilereader_test.cpp	2014-10-14 23:15:46 +0000
+++ tests/modules/DesktopFileReader/desktopfilereader_test.cpp	2015-02-05 10:26:37 +0000
@@ -126,3 +126,73 @@
     EXPECT_EQ(reader->comment(), "Ubuntu 简易计算器");
     EXPECT_EQ(reader->splashTitle(), "计算器 2.0");
 }
+
+TEST(DesktopFileReader, parseOrientations)
+{
+    using namespace ::testing;
+
+    const Qt::ScreenOrientations defaultOrientations = Qt::PortraitOrientation | Qt::LandscapeOrientation
+        | Qt::InvertedPortraitOrientation | Qt::InvertedLandscapeOrientation;
+    bool ok;
+    Qt::ScreenOrientations orientations;
+
+    ok = DesktopFileReader::parseOrientations(QString(), orientations);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(defaultOrientations, orientations);
+
+    ok = DesktopFileReader::parseOrientations("An invalid string!", orientations);
+    ASSERT_FALSE(ok);
+    EXPECT_EQ(defaultOrientations, orientations);
+
+    ok = DesktopFileReader::parseOrientations("landscape", orientations);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(Qt::LandscapeOrientation, orientations);
+
+    ok = DesktopFileReader::parseOrientations("   InvertedPortrait  , Portrait ", orientations);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(Qt::InvertedPortraitOrientation | Qt::PortraitOrientation, orientations);
+
+    ok = DesktopFileReader::parseOrientations(",inverted-landscape, inverted_portrait, ", orientations);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(Qt::InvertedPortraitOrientation | Qt::InvertedLandscapeOrientation, orientations);
+
+    ok = DesktopFileReader::parseOrientations(",inverted-landscape, some-invalid-text, ", orientations);
+    ASSERT_FALSE(ok);
+    EXPECT_EQ(defaultOrientations, orientations);
+
+    ok = DesktopFileReader::parseOrientations("landscape;portrait", orientations);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(Qt::PortraitOrientation | Qt::LandscapeOrientation, orientations);
+
+    ok = DesktopFileReader::parseOrientations("primary", orientations);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(Qt::PrimaryOrientation, orientations);
+
+    ok = DesktopFileReader::parseOrientations("landscpe,primary", orientations);
+    ASSERT_FALSE(ok);
+    EXPECT_EQ(defaultOrientations, orientations);
+}
+
+TEST(DesktopFileReader, parseBoolean)
+{
+    using namespace ::testing;
+
+    bool ok;
+    bool boolean;
+
+    ok = DesktopFileReader::parseBoolean(QString(), boolean);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(false, boolean);
+
+    ok = DesktopFileReader::parseBoolean("  Yes ", boolean);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(true, boolean);
+
+    ok = DesktopFileReader::parseBoolean("False", boolean);
+    ASSERT_TRUE(ok);
+    EXPECT_EQ(false, boolean);
+
+    ok = DesktopFileReader::parseBoolean("Hello World!", boolean);
+    ASSERT_FALSE(ok);
+    EXPECT_EQ(false, boolean);
+}
 
=== modified file 'tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp'
--- tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2014-12-12 15:15:06 +0000
+++ tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-02-05 10:26:37 +0000
@@ -15,6 +15,8 @@
  *
  */
 
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
 #include <gtest/gtest.h>
 
 #include <QLoggingCategory>
@@ -60,29 +62,43 @@
     EXPECT_CALL(*mockSurface, type()).Times(AnyNumber()).WillRepeatedly(Return(mir_surface_type_normal));
     EXPECT_CALL(*mockSession, setSurface(_)).Times(AnyNumber());
 
+    auto get_touch_event = [](MirEvent const& event) -> MirTouchInputEvent const*
+    {
+        if (mir_event_get_type(&event) != mir_event_type_input)
+            return nullptr;
+        auto const* input_event = mir_event_get_input_event(&event);
+        if (mir_input_event_get_type(input_event) != mir_input_event_type_touch)
+            return nullptr;
+        return mir_input_event_get_touch_input_event(input_event);
+    };
+
+    auto event_matches = [&](MirEvent const& event,
+                            int touch_count,
+                            MirTouchInputEventTouchAction action,
+                            MirTouchInputEventTouchId touch_id) ->void
+    {
+        auto const* touch_event = get_touch_event(event);
+        ASSERT_NE(touch_event, nullptr);
+        ASSERT_EQ(touch_count, mir_touch_input_event_get_touch_count(touch_event));
+        ASSERT_EQ(action, mir_touch_input_event_get_touch_action(touch_event,0));
+        ASSERT_EQ(touch_id, mir_touch_input_event_get_touch_id(touch_event,0));
+    };
+
     // The touch event sequence we expect mir::input::surface to receive from MirSurfaceItem.
     // It should properly finish the sequence for touch 0 ('down', 'move' and 'up') before starting
     // the sequence for touch 1.
     EXPECT_CALL(*mockSurface, consume(_))
-        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
-            ASSERT_EQ(mir_motion_action_down, mirEvent.motion.action);
-            ASSERT_EQ(1, mirEvent.motion.pointer_count);
-            ASSERT_EQ(0, mirEvent.motion.pointer_coordinates[0].id);
-        }))
-        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
-            ASSERT_EQ(mir_motion_action_move, mirEvent.motion.action);
-            ASSERT_EQ(1, mirEvent.motion.pointer_count);
-            ASSERT_EQ(0, mirEvent.motion.pointer_coordinates[0].id);
-        }))
-        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
-            ASSERT_EQ(mir_motion_action_up, mirEvent.motion.action);
-            ASSERT_EQ(1, mirEvent.motion.pointer_count);
-            ASSERT_EQ(0, mirEvent.motion.pointer_coordinates[0].id);
-        }))
-        .WillOnce(Invoke([] (MirEvent const& mirEvent) {
-            ASSERT_EQ(mir_motion_action_down, mirEvent.motion.action);
-            ASSERT_EQ(1, mirEvent.motion.pointer_count);
-            ASSERT_EQ(1, mirEvent.motion.pointer_coordinates[0].id);
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            event_matches(mirEvent, 1, mir_touch_input_event_action_down, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            event_matches(mirEvent, 1, mir_touch_input_event_action_change, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            event_matches(mirEvent, 1, mir_touch_input_event_action_up, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            event_matches(mirEvent, 1, mir_touch_input_event_action_down, 1);
         }));
 
 
@@ -95,18 +111,18 @@
     touchPoints[0].setId(0);
     touchPoints[0].setState(Qt::TouchPointPressed);
     surfaceItem->processTouchEvent(QEvent::TouchBegin,
-            timestamp, touchPoints, touchPoints[0].state());
+        timestamp, Qt::NoModifier, touchPoints, touchPoints[0].state());
 
     touchPoints[0].setState(Qt::TouchPointMoved);
     surfaceItem->processTouchEvent(QEvent::TouchUpdate,
-            timestamp + 10, touchPoints, touchPoints[0].state());
+        timestamp + 10, Qt::NoModifier, touchPoints, touchPoints[0].state());
 
     // Starting a new touch sequence (with touch 1) without ending the current one
     // (wich has touch 0).
     touchPoints[0].setId(1);
     touchPoints[0].setState(Qt::TouchPointPressed);
     surfaceItem->processTouchEvent(QEvent::TouchBegin,
-            timestamp + 20, touchPoints, touchPoints[0].state());
+        timestamp + 20, Qt::NoModifier, touchPoints, touchPoints[0].state());
     
     delete surfaceItem;
     delete mockSession;
 
=== removed file 'tests/modules/common/mock_focus_controller.h'
--- tests/modules/common/mock_focus_controller.h	2014-09-11 16:18:40 +0000
+++ tests/modules/common/mock_focus_controller.h	1970-01-01 00:00:00 +0000
@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2014 Canonical, Ltd.
- *
- * This program is free software: you can redistribute it and/or modify it under
- * the terms of the GNU Lesser General Public License version 3, as published by
- * the Free Software Foundation.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT
- * ANY WARRANTY; without even the implied warranties of MERCHANTABILITY,
- * SATISFACTORY QUALITY, or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program.  If not, see <http://www.gnu.org/licenses/>.
- *
- */
-
-#ifndef MOCK_MIR_SHELL_FOCUS_CONTROLLER_H
-#define MOCK_MIR_SHELL_FOCUS_CONTROLLER_H
-
-#include <mir/shell/focus_controller.h>
-#include <gmock/gmock.h>
-
-#include <string>
-
-namespace mir {
-namespace shell {
-
-class MockFocusController : public FocusController
-{
-public:
-    MOCK_METHOD0(focus_next, void());
-    MOCK_CONST_METHOD0(focussed_application, std::weak_ptr<scene::Session>());
-    MOCK_METHOD1(set_focus_to, void(std::shared_ptr<scene::Session>const&));
-};
-
-} // namespace shell
-} // namespace mir
-
-#endif // MOCK_MIR_SHELL_FOCUS_CONTROLLER_H_
 
=== modified file 'tests/modules/common/mock_mir_session.h'
--- tests/modules/common/mock_mir_session.h	2015-01-07 15:35:29 +0000
+++ tests/modules/common/mock_mir_session.h	2015-02-05 10:26:37 +0000
@@ -49,6 +49,7 @@
 
     MOCK_CONST_METHOD0(default_surface, std::shared_ptr<Surface>());
     MOCK_CONST_METHOD1(get_surface, std::shared_ptr<frontend::Surface>(frontend::SurfaceId));
+    MOCK_CONST_METHOD1(surface, std::shared_ptr<scene::Surface>(frontend::SurfaceId));
 
     MOCK_METHOD1(take_snapshot, void(SnapshotCallback const&));
     MOCK_METHOD1(set_lifecycle_state, void(MirLifecycleState));
 
=== modified file 'tests/modules/common/mock_renderable.h'
--- tests/modules/common/mock_renderable.h	2014-09-11 16:18:40 +0000
+++ tests/modules/common/mock_renderable.h	2015-02-05 10:26:37 +0000
@@ -34,9 +34,7 @@
     MOCK_CONST_METHOD0(screen_position, geometry::Rectangle());
     MOCK_CONST_METHOD0(alpha, float() );
     MOCK_CONST_METHOD0(transformation, glm::mat4());
-    MOCK_CONST_METHOD0(visible, bool());
     MOCK_CONST_METHOD0(shaped, bool());
-    MOCK_CONST_METHOD0(buffers_ready_for_compositor, int());
 };
 
 } // namespace graphics
 
=== modified file 'tests/modules/common/mock_surface.h'
--- tests/modules/common/mock_surface.h	2015-01-06 17:28:52 +0000
+++ tests/modules/common/mock_surface.h	2015-02-05 10:26:37 +0000
@@ -36,6 +36,7 @@
     MOCK_CONST_METHOD0(input_bounds, geometry::Rectangle());
     MOCK_CONST_METHOD0(top_left, geometry::Point());
     MOCK_CONST_METHOD0(size, geometry::Size());
+    MOCK_CONST_METHOD0(parent, std::shared_ptr<Surface>());
 
     std::unique_ptr<graphics::Renderable> compositor_snapshot(void const* /*compositor_id*/) const
     {
@@ -64,6 +65,7 @@
     MOCK_CONST_METHOD0(input_channel, std::shared_ptr<input::InputChannel>());
     MOCK_METHOD1(set_reception_mode, void(input::InputReceptionMode mode));
     MOCK_METHOD0(request_client_surface_close, void());
+    MOCK_CONST_METHOD1(buffers_ready_for_compositor, int(void const*));
 
     // from mir::input::surface
     MOCK_CONST_METHOD1(input_area_contains, bool(geometry::Point const& point));
 
=== modified file 'tests/modules/common/qtmir_test.h'
--- tests/modules/common/qtmir_test.h	2015-01-09 11:24:44 +0000
+++ tests/modules/common/qtmir_test.h	2015-02-05 10:26:37 +0000
@@ -33,7 +33,6 @@
 #include "mock_desktop_file_reader.h"
 #include "mock_proc_info.h"
 #include "mock_mir_session.h"
-#include "mock_focus_controller.h"
 #include "mock_prompt_session_manager.h"
 #include "mock_prompt_session.h"
 #include "mock_shared_wakelock.h"