Merge lp:~mir-team/qtmir/port-to-event-2.0 into lp:qtmir

[Robert Carr]

Port to the new MirEvent API and add support for pointer events.

As when accessing events through the new API pointer events will not present as touch events and not adding the new support would have introduced a regression.

Port qtmir to the new MirEvent API. Also adds support for pointer events (as when accessing events through the new API pointer events will not present as touch events and not adding the new support would have introduced a regression).

Some tests are not totally ported...they may remain unported until the new MirEvent definition is available....

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:318
http://jenkins.qa.ubuntu.com/job/qtmir-ci/203/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/54/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/54/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/203/rebuild

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

In debian/control:

"""
               libmirclient-dev (>= 0.6.0),
               libmircommon-dev,
               libmirserver-dev (>= 0.10.0),
"""

The mir version we depend on should be higher now, right? As I cannot build this branch with the currently released mir version.

--------

Please update the copyright year (ie, add 2015) to all the modified header and cpp files

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

> In debian/control:
>
> """
> libmirclient-dev (>= 0.6.0),
> libmircommon-dev,
> libmirserver-dev (>= 0.10.0),
> """
>
> The mir version we depend on should be higher now, right? As I cannot build
> this branch with the currently released mir version.

And likely adding a minimum version requirement here as well, in CMakeList.txt:

"""
pkg_check_modules(MIRSERVER mirserver REQUIRED)
"""

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:319
http://jenkins.qa.ubuntu.com/job/qtmir-ci/210/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/61/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/61/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/210/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:321
http://jenkins.qa.ubuntu.com/job/qtmir-ci/212/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/63/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/63/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/212/rebuild

review: Needs Fixing (continuous-integration)

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:323
http://jenkins.qa.ubuntu.com/job/qtmir-ci/213/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/64/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/64/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/213/rebuild

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

In mirsurfaceitem.cpp:

"""
namespace {

// 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)
"""

Please follow Qt coding style (function name)

[Daniel d'Andrada (dandrader)]

In mirsurfaceitem.cpp

"""
}
    <- HERE
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);
   <- HERE
    for (int i = 0; i < qtTouchPoints.count(); ++i) {

"""

Some trailing whitespace here and there

[Daniel d'Andrada (dandrader)]

"""
@@ -580,10 +552,10 @@ void MirSurfaceItem::endCurrentTouchSequ

         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);
+ <- HERE
         *m_lastTouchEvent = touchEvent;

         touchEvent.touchPoints.removeAt(0);
"""

More trailing whitespace in mirsurfaceitem.cpp

[PS Jenkins bot (ps-jenkins)]

FAILED: Continuous integration, rev:324
http://jenkins.qa.ubuntu.com/job/qtmir-ci/214/
Executed test runs:
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-amd64-ci/65/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/qtmir-vivid-armhf-ci/65/console

Click here to trigger a rebuild:
http://s-jenkins.ubuntu-ci:8080/job/qtmir-ci/214/rebuild

review: Needs Fixing (continuous-integration)

[Daniel d'Andrada (dandrader)]

In src/platforms/mirserver/qteventfeeder.cpp

"""
 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[] = {
"""

Should also remove the "from android-inpu" comment line

review: Needs Fixing

[Daniel d'Andrada (dandrader)]

In src/platforms/mirserver/qteventfeeder.cpp:

"""
Qt::KeyboardModifiers qt_modifiers_from_mir(MirInputEventModifiers modifiers)
"""

Please use Qt's coding style.

[Daniel d'Andrada (dandrader)]

Looking good.

review: Approve

[lp:~mir-team/qtmir/port-to-event-2.0]

310. By Gerry Boland on 2015-02-06

Explicitly setting GL-mode breaks GTK app rendering. Removing the hack appears to just work Fixes: #1401968
Approved by: Michał Sawicz, Stephen M. Webb, PS Jenkins bot

311. By Michał Sawicz on 2015-02-06

Add moot autopkgtest to run the standard unit tests

312. By Albert Astals Cid on 2015-02-06

Fix demo shell import name
Approved by: Gerry Boland

313. By Daniel d'Andrada on 2015-02-06

Don't suspend&resume the main stage app when switching focus from side to main stage
Approved by: Gerry Boland, PS Jenkins bot

314. By CI Train Bot Account on 2015-02-06

Releasing 0.4.4+15.04.20150206-0ubuntu1

315. By Alan Griffiths on 2015-02-09

Port to the msh::Shell API in Mir
Approved by: Alberto Aguirre, Gerry Boland

316. By Daniel van Vugt on 2015-02-09

QtMir changes required to support the Mir branch of the same name. Landing soon. Fixes: #1395581
Approved by: Gerry Boland

317. By Robert Carr <racarr@ocelot> on 2015-02-09

Bump build-dep to mir 0.11.

318. By CI Train Bot Account on 2015-02-09

Releasing 0.4.4+15.04.20150209-0ubuntu1

[Gerry Boland (gerboland)]

Something weird has happened to the history of this branch. These branches appear to have been reverted:
lp:~alan-griffiths/qtmir/delete-dead-code
lp:~vanvugt/qtmir/fix-buffers_ready_for_compositor
I can't see where the history got confused, perhaps someone better with bzr can figure it out? I made a branch to restore the reversions, but it doesn't deal well with file deletion & re-creation:
lp:~gerboland/qtmir/port-to-event-2.0-fixed

review: Needs Fixing

[lp:~mir-team/qtmir/port-to-event-2.0]

319. By Timo Jyrinki on 2015-02-16

No-change rebuild against Qt 5.4.0.

[Robert Carr (robertcarr)]

https://code.launchpad.net/+branch/~vanvugt/qtmir/fix-buffers_ready_for_compositor contains https://code.launchpad.net/+branch/~alan-griffiths/qtmir/delete-dead-code

so I merged fix-buffers_ready_for_compositor with --take-other and think things should be fine.

[lp:~mir-team/qtmir/port-to-event-2.0]

320. By Robert Carr on 2015-02-19

Port to MirEvent 2.0

[Robert Carr (robertcarr)]

Overwrote a rebased branch with extraneous changes removed.

[lp:~mir-team/qtmir/port-to-event-2.0]

321. By Daniel d'Andrada on 2015-02-20

Fix virtual keyboard bug

While the virtual keyboard was up we were unable to interact
with the application behind it

322. By Daniel d'Andrada on 2015-02-20

Fix typo

[Gerry Boland (gerboland)]

review: Approve

[Robert Carr (robertcarr)]

It looks like the corresponding change from 0.11 is already there from another branch (probably fix-buffers-ready-for-compositor or port-to-msh-Shell)

=== modified file 'CMakeLists.txt'
--- CMakeLists.txt	2014-12-09 14:12:57 +0000
+++ CMakeLists.txt	2015-02-20 15:57:56 +0000
@@ -66,7 +66,7 @@
     message(SEND_ERROR "protoc executable not found! Missing protobuf-compiler package?")
 endif()
 
-pkg_check_modules(MIRSERVER mirserver REQUIRED)
+pkg_check_modules(MIRSERVER mirserver>=0.11 REQUIRED)
 
 pkg_check_modules(GLIB glib-2.0 REQUIRED)
 pkg_check_modules(PROCESS_CPP process-cpp REQUIRED)
@@ -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 'src/common/debughelpers.cpp'
--- src/common/debughelpers.cpp	2014-08-27 11:51:28 +0000
+++ src/common/debughelpers.cpp	2015-02-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-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
@@ -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/mirsurfaceitem.cpp'
--- src/modules/Unity/Application/mirsurfaceitem.cpp	2015-02-20 10:08:31 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.cpp	2015-02-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-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
@@ -45,6 +45,7 @@
 
 // Mir
 #include <mir/geometry/rectangle.h>
+#include <mir/events/event_builders.h>
 #include <mir_toolkit/event.h>
 
 namespace mg = mir::graphics;
@@ -53,160 +54,109 @@
 
 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
+getMirModifiersFromQt(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 = getMirModifiersFromQt(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(QHoverEvent *qtEvent, MirPointerInputEventAction action)
+{
+    auto timestamp = qtEvent->timestamp() * 1000000;
+
+    std::vector<MirPointerInputEventButton> buttons;
+
+    return mir::events::make_event(0 /*DeviceID */, timestamp, mir_input_event_modifier_none, action,
+                                   buttons, qtEvent->posF().x(), qtEvent->posF().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 = getMirModifiersFromQt(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 {
@@ -512,18 +462,34 @@
 
 void MirSurfaceItem::mousePressEvent(QMouseEvent *event)
 {
-    // TODO: Implement for desktop support
-    event->ignore();
+    if (type() == InputMethod) {
+        // FIXME: Hack to get the VKB use case working while we don't have the proper solution in place.
+        if (isMouseInsideUbuntuKeyboard(event)) {
+            auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_down);
+            m_surface->consume(*ev);
+            event->accept();
+        } else {
+            event->ignore();
+        }
+    } else {
+        auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_down);
+        m_surface->consume(*ev);
+        event->accept();
+    }
 }
 
 void MirSurfaceItem::mouseMoveEvent(QMouseEvent *event)
 {
-    Q_UNUSED(event);
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_motion);
+    m_surface->consume(*ev);
+    event->accept();
 }
 
 void MirSurfaceItem::mouseReleaseEvent(QMouseEvent *event)
 {
-    Q_UNUSED(event);
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_button_up);
+    m_surface->consume(*ev);
+    event->accept();
 }
 
 void MirSurfaceItem::wheelEvent(QWheelEvent *event)
@@ -531,20 +497,39 @@
     Q_UNUSED(event);
 }
 
+void MirSurfaceItem::hoverEnterEvent(QHoverEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_enter);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurfaceItem::hoverLeaveEvent(QHoverEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_leave);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
+void MirSurfaceItem::hoverMoveEvent(QHoverEvent *event)
+{
+    auto ev = makeMirEvent(event, mir_pointer_input_event_action_motion);
+    m_surface->consume(*ev);
+    event->accept();
+}
+
 void MirSurfaceItem::keyPressEvent(QKeyEvent *qtEvent)
 {
-    MirEvent mirEvent;
-    if (fillInMirEvent(mirEvent, qtEvent)) {
-        m_surface->consume(mirEvent);
-    }
+    auto ev = makeMirEvent(qtEvent);
+    m_surface->consume(*ev);
+    qtEvent->accept();
 }
 
 void MirSurfaceItem::keyReleaseEvent(QKeyEvent *qtEvent)
 {
-    MirEvent mirEvent;
-    if (fillInMirEvent(mirEvent, qtEvent)) {
-        m_surface->consume(mirEvent);
-    }
+    auto ev = makeMirEvent(qtEvent);
+    m_surface->consume(*ev);
+    qtEvent->accept();
 }
 
 QString MirSurfaceItem::appId() const
@@ -560,8 +545,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);
@@ -585,10 +568,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);
@@ -597,11 +580,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()));
@@ -609,9 +591,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;
@@ -626,6 +607,7 @@
 {
     bool accepted = processTouchEvent(event->type(),
             event->timestamp(),
+            event->modifiers(),
             event->touchPoints(),
             event->touchPointStates());
     event->setAccepted(accepted);
@@ -634,6 +616,7 @@
 bool MirSurfaceItem::processTouchEvent(
         int eventType,
         ulong timestamp,
+        Qt::KeyboardModifiers mods,
         const QList<QTouchEvent::TouchPoint> &touchPoints,
         Qt::TouchPointStates touchPointStates)
 {
@@ -641,7 +624,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;
         }
@@ -649,7 +632,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;
 }
@@ -670,6 +653,18 @@
     return false;
 }
 
+bool MirSurfaceItem::isMouseInsideUbuntuKeyboard(const QMouseEvent *event)
+{
+    UbuntuKeyboardInfo *ubuntuKeyboardInfo = UbuntuKeyboardInfo::instance();
+
+    const QPointF &pos = event->localPos();
+
+    return pos.x() >= ubuntuKeyboardInfo->x()
+        && pos.x() <= (ubuntuKeyboardInfo->x() + ubuntuKeyboardInfo->width())
+        && pos.y() >= ubuntuKeyboardInfo->y()
+        && pos.y() <= (ubuntuKeyboardInfo->y() + ubuntuKeyboardInfo->height());
+}
+
 void MirSurfaceItem::setType(const Type &type)
 {
     if (this->type() != type) {

=== modified file 'src/modules/Unity/Application/mirsurfaceitem.h'
--- src/modules/Unity/Application/mirsurfaceitem.h	2015-02-06 09:47:21 +0000
+++ src/modules/Unity/Application/mirsurfaceitem.h	2015-02-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-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
@@ -108,6 +108,7 @@
     // 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);
 
@@ -126,6 +127,9 @@
     void mousePressEvent(QMouseEvent *event) override;
     void mouseMoveEvent(QMouseEvent *event) override;
     void mouseReleaseEvent(QMouseEvent *event) override;
+    void hoverEnterEvent(QHoverEvent *event) override;
+    void hoverLeaveEvent(QHoverEvent *event) override;
+    void hoverMoveEvent(QHoverEvent *event) override;
     void wheelEvent(QWheelEvent *event) override;
 
     void keyPressEvent(QKeyEvent *event) override;
@@ -158,6 +162,7 @@
     void setSurfaceValid(const bool);
 
     bool hasTouchInsideUbuntuKeyboard(const QList<QTouchEvent::TouchPoint> &touchPoints);
+    bool isMouseInsideUbuntuKeyboard(const QMouseEvent *event);
     void syncSurfaceSizeWithItemSize();
 
     bool clientIsRunning() const;
@@ -166,6 +171,7 @@
     void endCurrentTouchSequence(ulong timestamp);
     void validateAndDeliverTouchEvent(int eventType,
             ulong timestamp,
+            Qt::KeyboardModifiers modifiers,
             const QList<QTouchEvent::TouchPoint> &touchPoints,
             Qt::TouchPointStates touchPointStates);
 
@@ -191,6 +197,7 @@
         TouchEvent &operator= (const QTouchEvent &qtEvent) {
             type = qtEvent.type();
             timestamp = qtEvent.timestamp();
+            modifiers = qtEvent.modifiers();
             touchPoints = qtEvent.touchPoints();
             touchPointStates = qtEvent.touchPointStates();
             return *this;
@@ -200,6 +207,7 @@
 
         int type;
         ulong timestamp;
+        Qt::KeyboardModifiers modifiers;
         QList<QTouchEvent::TouchPoint> touchPoints;
         Qt::TouchPointStates touchPointStates;
     } *m_lastTouchEvent;

=== modified file 'src/platforms/mirserver/qteventfeeder.cpp'
--- src/platforms/mirserver/qteventfeeder.cpp	2015-02-02 12:03:55 +0000
+++ src/platforms/mirserver/qteventfeeder.cpp	2015-02-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright © 2013-2014 Canonical Ltd.
+ * Copyright © 2013-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
@@ -32,13 +32,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[] = {
     XKB_KEY_Escape,                  Qt::Key_Escape,
@@ -182,6 +175,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,69 +218,123 @@
 
 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 getQtModifiersFromMir(MirInputEventModifiers modifiers)
+{
+    int qtModifiers = Qt::NoModifier;
+    if (modifiers & mir_input_event_modifier_shift) {
+        qtModifiers |= Qt::ShiftModifier;
+    }
+    if (modifiers & mir_input_event_modifier_ctrl) {
+        qtModifiers |= Qt::ControlModifier;
+    }
+    if (modifiers & mir_input_event_modifier_alt) {
+        qtModifiers |= Qt::AltModifier;
+    }
+    if (modifiers & mir_input_event_modifier_meta) {
+        qtModifiers |= Qt::MetaModifier;
+    }
+    return static_cast<Qt::KeyboardModifiers>(qtModifiers);
+}
+
+Qt::MouseButton getQtMouseButtonsfromMirPointerEvent(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 = getQtModifiersFromMir(mir_pointer_input_event_get_modifiers(pev));
+    auto buttons = getQtMouseButtonsfromMirPointerEvent(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 = getQtModifiersFromMir(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.
     char s[2];
     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 +344,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 +364,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()

=== modified file 'src/platforms/mirserver/qteventfeeder.h'
--- src/platforms/mirserver/qteventfeeder.h	2015-02-02 12:03:55 +0000
+++ src/platforms/mirserver/qteventfeeder.h	2015-02-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2013-2014 Canonical, Ltd.
+ * Copyright (C) 2013-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
@@ -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);
@@ -67,8 +68,9 @@
     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);
 

=== 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-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-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
@@ -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-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-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
@@ -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	2015-01-27 12:13:48 +0000
+++ tests/modules/ApplicationManager/application_manager_test.cpp	2015-02-20 15:57:56 +0000
@@ -15,6 +15,8 @@
  *
  */
 
+#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
+
 #include <thread>
 #include <condition_variable>
 #include <QSignalSpy>

=== modified file 'tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp'
--- tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-02-06 09:47:21 +0000
+++ tests/modules/MirSurfaceItem/mirsurfaceitem_test.cpp	2015-02-20 15:57:56 +0000
@@ -1,5 +1,5 @@
 /*
- * Copyright (C) 2014 Canonical, Ltd.
+ * Copyright (C) 2014-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
@@ -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 getTouchEvent = [](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 eventMatches = [&](MirEvent const& event,
+                            int touch_count,
+                            MirTouchInputEventTouchAction action,
+                            MirTouchInputEventTouchId touch_id) ->void
+    {
+        auto const* touch_event = getTouchEvent(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) {
+            eventMatches(mirEvent, 1, mir_touch_input_event_action_down, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            eventMatches(mirEvent, 1, mir_touch_input_event_action_change, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            eventMatches(mirEvent, 1, mir_touch_input_event_action_up, 0);
+        }))
+        .WillOnce(Invoke([&] (MirEvent const& mirEvent) {
+            eventMatches(mirEvent, 1, mir_touch_input_event_action_down, 1);
         }));
 
 
@@ -95,19 +111,19 @@
     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;
 }