Mir

Merge lp:~mir-team/mir/introduce-pointer-event into lp:mir

introduce-pointer-event
Merge into development-branch

Proposed by Robert Carr on 2015-01-06

Status:

Merged

Approved by:

Andreas Pokorny on 2015-01-15

Approved revision:

no longer in the source branch.

Merged at revision:

2228

Proposed branch:

lp:~mir-team/mir/introduce-pointer-event

Merge into:

lp:mir

Diff against target:

753 lines (+491/-33)

9 files modified

client-ABI-sha1sums (+2/-1)
common-ABI-sha1sums (+2/-1)
include/common/mir_toolkit/events/input/input_event.h (+12/-1)
include/common/mir_toolkit/events/input/pointer_input_event.h (+120/-0)
platform-ABI-sha1sums (+2/-1)
server-ABI-sha1sums (+2/-1)
src/client/symbols.map (+6/-0)
src/common/input/input_event.cpp (+137/-1)
tests/unit-tests/input/test_input_event.cpp (+208/-27)

To merge this branch:

bzr merge lp:~mir-team/mir/introduce-pointer-event

Medium

Fix Released

Link a bug report

Reviewer	Review Type	Date Requested	Status
Andreas Pokorny (community)			Approve on 2015-01-15
Alan Griffiths			Approve on 2015-01-15
Daniel van Vugt			Abstain on 2015-01-15
Cemil Azizoglu (community)			Approve on 2015-01-15
Chris Halse Rogers			Approve on 2015-01-14
PS Jenkins bot (community)	continuous-integration		Approve on 2015-01-14
Kevin DuBois (community)		2015-01-06	Approve on 2015-01-07
Review via email: mp+245679@code.launchpad.net

Commit message

Introduce MirPointerEvent

Description of the change

Introduce MirPointerEvents as distinguished from Mir touch events. Recognized via the device class flags provided by android input.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-06:

FAILED: Continuous integration, rev:2194
http://jenkins.qa.ubuntu.com/job/mir-ci/2574/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/739
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/739/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/704/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/571/console
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/704/console

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-06:

FAILED: Continuous integration, rev:2196
http://jenkins.qa.ubuntu.com/job/mir-ci/2576/
Executed test runs:
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-android-vivid-i386-build/742
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-clang-vivid-amd64-build/742
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-vivid-touch/706
    FAILURE: http://jenkins.qa.ubuntu.com/job/mir-vivid-amd64-ci/573/console
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/706
        deb: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-builder-vivid-armhf/706/artifact/work/output/*zip*/output.zip
    SUCCESS: http://jenkins.qa.ubuntu.com/job/mir-mediumtests-runner-mako/3837
    SUCCESS: http://s-jenkins.ubuntu-ci:8080/job/touch-flash-device/16847

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

review: Needs Fixing (continuous-integration)

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-07:

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

review: Approve (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2015-01-07:

needs fixing:
Shouldn't we have the new symbol be in its own stanza in the symbols.map for the client library?

needs info:
With MirPointerInputEventButtons, should we provide a flexible number of buttons?

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2015-01-07:

>> Shouldn't we have the new symbol be in its own stanza in the symbols.map for the client library?

Ah...I didn't know about that. How does this work with the global: * catch in the MIR_CLIENT_8 stanza?

Updated anyway :)

>> With MirPointerInputEventButtons, should we provide a flexible number of buttons?

I've been thinking that once the device introspection API is available it will also be possible to obtain the identifiers for more buttons via that, then you can use the introspection API to query their names etc.

MirPointerInputEventButtons is a bit inflexible though so I've changed

MirPointerInputEventButtons mir_pointer_input_event_get_button_state(MirPointerEvent)

bool mir_pointer_input_event_get_button_state(MirPointerEvent, MirPointerInputEventButton)

This way the button enum is not using flags and it will be easier to expand/use other values in the future.

This way the pointer button enum doesnt have to be flags and wi to expand as time goes on.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-07:

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

review: Needs Fixing (continuous-integration)

Revision history for this message

Kevin DuBois (kdub) wrote on 2015-01-07:

lgtm then

review: Approve

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-08:

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

review: Approve (continuous-integration)

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2015-01-09:

This distinction is confusing:

306 +// Differentiate between MirTouchInputEvents and MirPointerInputEvents based on old device class
307 +MirInputEventType type_from_device_class(int32_t source_class)
308 +{
309 + switch (source_class)
310 + {
311 + case AINPUT_SOURCE_MOUSE:
312 + case AINPUT_SOURCE_TRACKBALL:
313 + case AINPUT_SOURCE_TOUCHPAD:
314 + return mir_input_event_type_pointer;
315 + // Realistically touch events should only come from Stylus and Touchscreen
316 + // device classes...practically its not clear this is a safe assumption.
317 + default:
318 + return mir_input_event_type_touch;
319 + }
320 +}

If "pointer" events don't include the pointiest kind of input (stylus, finger) then we need to clarify the terminology. Perhaps:
   MirAbsoluteInputEvent (stylus, finger)
   MirRelativeInputEvent (mouse, trackball, touchpad)
   MirFocussedInputEvent (keyboard and other buttons)

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2015-01-12:

>> If "pointer" events don't include the pointiest kind of input (stylus, finger)
>> then we need to clarify the terminology

Pointer refers to the system pointer/cursor rather than the "pointiness of the input".

This MP does leave some open questions....e.g. what becomes of joystick events, or how would you get access to raw relative events from a mouse?

This is to be addressed in future MPs through the distinction of raw and synthetic events. For mice, joysticks, etc, the raw event would feature the relative axis. In the case that the relative axis device is controlling the system pointer, a Pointer event will also be generated with a "synthesized_from" member referring to the raw event.

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2015-01-13:

Ah OK. That does kind of clarify another question I had --
Do we mean something that's a physical pointer or something that results in a mouse arrow cursor on screen? I think "pointer" means the latter here.

It sounds like MirRelativeInputEvent might still be more appropriate. At the raw level, they are indeed relative input devices. Only when "cooked" do such devices gain a logical pointing location on screen.

Maybe to avoid confusion over different meanings of pointer, we should say the source of the input is a MirRelativeInputEvent, and that /moves/ a cursor. The ambiguous word "pointer" doesn't need to come into it.

Similarly, a MirAbsoluteInputEvent (digitizer pen) might also move a cursor, in absolute terms (LP: #1396421)

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2015-01-13:

133 +/* Relative axis containing the speed of the vertical scroll wheel */
134 + mir_pointer_input_axis_vscroll = 2,
135 +/* Relative axis containing the speed of the horizontal scroll wheel */

speed -> change?

looks good to me otherwise

review: Needs Information

Revision history for this message

Robert Carr (robertcarr) wrote on 2015-01-13:

>> speed -> change?

Hey! You're back. Happy new years...we have some fun to have on evdev-input-platform ;)

Hmm. I agree its kind of confusing.

I think speed may be correct because change makes it seem like you are talking about change in the axis state over time. Imagine you are scrolling up and receive a +7...then you reverse the direction of your scroll...at one point you will hit +0 which has to be interpreted as a current scroll speed of zero, not a change in the scroll axis state over time (because the change would be zero). Likewise if this entire reveral of speed (say from +7 to -3) happens in a single input frame, -3 is not your change (which would be 10) but rather just your new negative speed.

I have this sinking feeling that I am turning things over wrong in my head though so will continue to think some today.

Revision history for this message

Robert Carr (robertcarr) wrote on 2015-01-13:

>>
>> It sounds like MirRelativeInputEvent might still be more appropriate. At the raw level, they are
>> indeed relative input devices. Only when "cooked" do such devices gain a logical pointing location
>> on screen.

Yes. Though I am imagining there will only be one MirRawInputEvent type, and the user can introspect whether a given axis is relative or absolute. It seems to be a good strategy to report input in frames which contain snapshots of device state...so it should be easy to mix relative and absolute axis on a single event (e.g. input frame).

>> Maybe to avoid confusion over different meanings of pointer, we should say the source of the input >> is a MirRelativeInputEvent, and that /moves/ a cursor. The ambiguous word "pointer" doesn't need to
>> come into it.

We are close to agreement :). In this model the source is a raw input event with relative axis, and a pointer event is synthesized from it. I don't think pointer is particularly ambiguous and there is a long history of using "pointer" or "cursor" to refer to the onscreen system....pointer/cursor. I don't think this meaning is diluted by the fact that other things have points.

>> Similarly, a MirAbsoluteInputEvent (digitizer pen) might also move a cursor, in absolute terms
>> (LP: #1396421)

Definitely you could enable this via the configuration API. In this case you would get raw absolute axis events, and rather than (in addition to?) a synthetic touch event would receive a synthetic pointer event.

Revision history for this message

Chris Halse Rogers (raof) wrote on 2015-01-14:

Globally: how difficult would it be to use a 24.8 fixed-point scheme? We do want subpixel motion precision, but we don't need all that much precision.

+ /* Axis values or button state has changed for the pointer */
122 + mir_pointer_input_event_action_change = 4

This appears to be a lie¹? It seems to only be for motion; perhaps it should be mir_pointer_input_event_motion?

I think mir_pointer_input_event_action_up/down might be better as mir_pointer_input_event_action_*button*_up/down? It doesn't make sense for a pointer to be up down.

Additionally, there doesn't seem to be a way to figure out *which* button went up/down? You can get the current state through get_button_state, but unless the client maintains the previous button states it can't work out what button changed.

Likewise, we can get the current axis values but not their changes. It would seem sensible for the client to be able to know which ones have changed?

133 +/* Relative axis containing the speed of the vertical scroll wheel */
134 + mir_pointer_input_axis_vscroll = 2,

Are we really reporting the time-derivative of the scroll axis values? Why? We don't get that from the kernel; we get the values themselves.

input_axis_vscroll and input_axis_hscroll should be relative axes. (Most) scroll wheels aren't joysticks; you can just keep spinning them :).

¹: Relevant bit is:
357 +MirPointerInputEventAction mir_pointer_input_event_get_action(MirPointerInputEvent const* pev)
...
373 + case mir_motion_action_move:
374 + case mir_motion_action_hover_move:
375 + case mir_motion_action_outside:
376 + default:
377 + return mir_pointer_input_event_action_change;

Revision history for this message

Chris Halse Rogers (raof) wrote on 2015-01-14:

Mark as needs-fixing, so it gets on my review list.

review: Needs Fixing

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2015-01-14:

I think the ease with which I found the word "pointer" confusing suggests I won't be the last one. We have an opportunity to choose less ambiguous terminology now. Probably not so much later.

Chris:
I don't think fixed point is necessarily better than floats for input. If you have fixed 24.8 (32-bit) then to avoid overflows you need to remember to always work with 64-bit numbers. And of course, you need to shift in the end to get to your whole numbers. OK, yes there's a performance advantage in doing lots of ops with ints instead of floats, but not as great as it used to be. Can anyone cite a specific case for input where sub-pixel precision is important?...

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2015-01-14:

"Needs Fixing" because I think we should seize the opportunity to avoid introducing confusing wording with "pointer". Less ambiguous alternatives mentioned above.

review: Needs Fixing

Revision history for this message

Andreas Pokorny (andreas-pokorny) wrote on 2015-01-14:

> >> speed -> change?
>
> Hey! You're back. Happy new years...we have some fun to have on evdev-input-
> platform ;)
>
> Hmm. I agree its kind of confusing.
>
> I think speed may be correct because change makes it seem like you are talking
> about change in the axis state over time. Imagine you are scrolling up and
> receive a +7...then you reverse the direction of your scroll...at one point
> you will hit +0 which has to be interpreted as a current scroll speed of zero,
> not a change in the scroll axis state over time (because the change would be
> zero). Likewise if this entire reveral of speed (say from +7 to -3) happens in
> a single input frame, -3 is not your change (which would be 10) but rather
> just your new negative speed.
>
> I have this sinking feeling that I am turning things over wrong in my head
> though so will continue to think some today.

Yes in the example above I expect to find a change expressed as the value "-10" attached to the event. I believe you are exposing relative changes along the vertical and horizontal axis.
I do not think that you plan to measure the velocity here.. and expect users to integrate speed change events over time diffs, to get to the amount of ticks scrolled.

So I really think that you mean something like a delta expressed in ticks. How about "ticks"?

review: Needs Fixing

Revision history for this message

Robert Carr (robertcarr) wrote on 2015-01-14:

Fixed vscroll and hscroll comments...I got in to a weird state of confusion imagining spinning scroll balls ;)

Chris other comments:

Updated the actions now button_up and button_down and change...documentation should likewise be more accurate.

Revision history for this message

Robert Carr (robertcarr) wrote on 2015-01-14:

Chris: With respect to previous button and axis state I agree including it would be useful. Until we change the internal MirEvent representaiton it's difficult though. In the meantime clients will have to track the previous button state (just as they do now). Following the transition, we can add backwards compatible new functions to query the collection of changed axis and buttons.

Revision history for this message

PS Jenkins bot (ps-jenkins) wrote on 2015-01-14:

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

review: Approve (continuous-integration)

Revision history for this message

Chris Halse Rogers (raof) wrote on 2015-01-14:

On Wed, Jan 14, 2015 at 6:35 PM, Daniel van Vugt
<email address hidden> wrote:
> I think the ease with which I found the word "pointer" confusing
> suggests I won't be the last one. We have an opportunity to choose
> less ambiguous terminology now. Probably not so much later.

I don't think we have a better candidate terminology available yet?

The thing is, pointer events *don't* come from any physical input
device; they come from a synthesised virtual pointer.

It shouldn't be called MirRelativeInputEvent because the (the x,y axes
of the event) event is absolute (and the vscroll, hscroll axes are
relative ☺).

And, as you note, absolute devices like the stylus on a tablet *can*
produce MirPointerInputEvents; it would be pretty weird if they
produced RelativeInputEvents.

We *could* have a different model; make everything MirInputDeviceEvent
and then have a special “device 0” virtual pointer device. I'm not
sure if that's any better, though.

>
> Chris:
> I don't think fixed point is necessarily better than floats for
> input. If you have fixed 24.8 (32-bit) then to avoid overflows you
> need to remember to always work with 64-bit numbers. And of course,
> you need to shift in the end to get to your whole numbers. OK, yes
> there's a performance advantage in doing lots of ops with ints
> instead of floats, but not as great as it used to be. Can anyone cite
> a specific case for input where sub-pixel precision is important?...

Sub-pixel precision is important for two cases:

For relative motion events it's flat out necessary - otherwise, it's
possible to move the mouse at a slow but reasonable speed without
generating any non-zero input events.

For absolute events it's necessary if you're doing any sort of
transformation.

Hm. I was suggesting fixed point in part because that's what we get out
of libinput, but it seems that libinput switched to double since I last
looked at it.

Since float will still give us 8bits of subpixel precision all the way
out to 65,000x65,000 pixel outputs that might be enough. The reasons
why we might want doubles include: that's what we get from libinput,
and it gives nested servers some headroom.

If we need to we can double later.

On Wed, Jan 14, 2015 at 6:35 PM, Daniel van Vugt 
<daniel.van.vugt@canonical.com> wrote:
> I think the ease with which I found the word "pointer" confusing 
> suggests I won't be the last one. We have an opportunity to choose 
> less ambiguous terminology now. Probably not so much later.

I don't think we have a better candidate terminology available yet?

The thing is, pointer events *don't* come from any physical input 
device; they come from a synthesised virtual pointer.

It shouldn't be called MirRelativeInputEvent because the (the x,y axes 
of the event) event is absolute (and the vscroll, hscroll axes are 
relative ☺).

And, as you note, absolute devices like the stylus on a tablet *can* 
produce MirPointerInputEvents; it would be pretty weird if they 
produced RelativeInputEvents.

We *could* have a different model; make everything MirInputDeviceEvent 
and then have a special “device 0” virtual pointer device. I'm not 
sure if that's any better, though.

> 
> Chris:
> I don't think fixed point is necessarily better than floats for 
> input. If you have fixed 24.8 (32-bit) then to avoid overflows you 
> need to remember to always work with 64-bit numbers. And of course, 
> you need to shift in the end to get to your whole numbers. OK, yes 
> there's a performance advantage in doing lots of ops with ints 
> instead of floats, but not as great as it used to be. Can anyone cite 
> a specific case for input where sub-pixel precision is important?...

Sub-pixel precision is important for two cases:

For relative motion events it's flat out necessary - otherwise, it's 
possible to move the mouse at a slow but reasonable speed without 
generating any non-zero input events.

For absolute events it's necessary if you're doing any sort of 
transformation.

Hm. I was suggesting fixed point in part because that's what we get out 
of libinput, but it seems that libinput switched to double since I last 
looked at it.

Since float will still give us 8bits of subpixel precision all the way 
out to 65,000x65,000 pixel outputs that might be enough. The reasons 
why we might want doubles include: that's what we get from libinput, 
and it gives nested servers some headroom.

If we need to we can double later.

Revision history for this message

Chris Halse Rogers (raof) wrote on 2015-01-14:

Hm. Rather than “ticks” I think it would be better to describe the scroll axes as measured in pixels. The other axes are measured in pixels, and pixels are a useful unit for scrolling.

Otherwise, ok.

review: Approve

Revision history for this message

Cemil Azizoglu (cemil-azizoglu) wrote on 2015-01-15:

LGTM.

review: Approve

Revision history for this message

Daniel van Vugt (vanvugt) wrote on 2015-01-15:

Alright, I trust all confusion will be resolved later. When we finish designing the client API ;)

review: Abstain

Revision history for this message

Alan Griffiths (alan-griffiths) wrote on 2015-01-15:

review: Approve

Revision history for this message

Andreas Pokorny (andreas-pokorny) on 2015-01-15:

review: Approve

Preview Diff

[H/L] Next/Prev Comment, [J/K] Next/Prev File, [N/P] Next/Prev Hunk

Subscribers

People subscribed via source and target branches

to all changes:

Emanuele Antonio Faraone

Gerry Boland

Mir development team

 === modified file 'client-ABI-sha1sums'
 --- client-ABI-sha1sums	2015-01-14 08:52:38 +0000
 +++ client-ABI-sha1sums	2015-01-14 19:51:52 +0000
@@ -15,8 +15,9 @@
  f4d39e9893ce6308bddd83a49b90f0051f565323  include/common/mir_toolkit/event.h
 f2929415aa423f9551d3c595c439fe1c6efd  include/common/mir_toolkit/events/event_deprecated.h
  cb2358a701db2b9c8d9ba1c877f29f834af259a7  include/common/mir_toolkit/events/event.h
--c591a02a8e9851db342c310cf829d018a1eddb51  include/common/mir_toolkit/events/input/input_event.h
++caaf95ea6c02570ab733ade70aba2ecea810b3a7  include/common/mir_toolkit/events/input/input_event.h
 a12138474e9be218eeb8f14b372af0fcec7e  include/common/mir_toolkit/events/input/key_input_event.h
++489e8bae7c3e949ac449b09bd3bf554dae0e8986  include/common/mir_toolkit/events/input/pointer_input_event.h
  de7c23453e6d897296f32e49d9ba952a1baa0200  include/common/mir_toolkit/events/input/touch_input_event.h
 e85a50e2de651589da3ced70e0fc0a915f26  include/common/mir_toolkit/events/orientation_event.h
  f623dcf3c2ed134c1be20106eb54bcccc84af462  include/common/mir_toolkit/events/prompt_session_event.h
 === modified file 'common-ABI-sha1sums'
 --- common-ABI-sha1sums	2015-01-14 08:52:38 +0000
 +++ common-ABI-sha1sums	2015-01-14 19:51:52 +0000
@@ -22,8 +22,9 @@
  f4d39e9893ce6308bddd83a49b90f0051f565323  include/common/mir_toolkit/event.h
 f2929415aa423f9551d3c595c439fe1c6efd  include/common/mir_toolkit/events/event_deprecated.h
  cb2358a701db2b9c8d9ba1c877f29f834af259a7  include/common/mir_toolkit/events/event.h
--c591a02a8e9851db342c310cf829d018a1eddb51  include/common/mir_toolkit/events/input/input_event.h
++caaf95ea6c02570ab733ade70aba2ecea810b3a7  include/common/mir_toolkit/events/input/input_event.h
 a12138474e9be218eeb8f14b372af0fcec7e  include/common/mir_toolkit/events/input/key_input_event.h
++489e8bae7c3e949ac449b09bd3bf554dae0e8986  include/common/mir_toolkit/events/input/pointer_input_event.h
  de7c23453e6d897296f32e49d9ba952a1baa0200  include/common/mir_toolkit/events/input/touch_input_event.h
 e85a50e2de651589da3ced70e0fc0a915f26  include/common/mir_toolkit/events/orientation_event.h
  f623dcf3c2ed134c1be20106eb54bcccc84af462  include/common/mir_toolkit/events/prompt_session_event.h
 === modified file 'include/common/mir_toolkit/events/input/input_event.h'
 --- include/common/mir_toolkit/events/input/input_event.h	2014-12-17 00:03:09 +0000
 +++ include/common/mir_toolkit/events/input/input_event.h	2015-01-14 19:51:52 +0000
@@ -35,7 +35,8 @@
  typedef enum {
      mir_input_event_type_key = 0,
--    mir_input_event_type_touch = 1
++    mir_input_event_type_touch = 1,
++    mir_input_event_type_pointer = 2
  } MirInputEventType;
  /**
@@ -69,6 +70,7 @@
  #include "mir_toolkit/events/input/touch_input_event.h"
  #include "mir_toolkit/events/input/key_input_event.h"
++#include "mir_toolkit/events/input/pointer_input_event.h"
  #ifdef __cplusplus
  /**
@@ -120,6 +122,15 @@
   */
  MirTouchInputEvent const* mir_input_event_get_touch_input_event(MirInputEvent const* ev);
++/*
++ * Retrieve the MirPointerInputEvent associated with a given input event.
++ *
++ * \param[in] event The input event
++ * \return          The MirPointerInputEvent or NULL if event type is not
++ *                  mir_input_event_type_pointer
++ */
++MirPointerInputEvent const* mir_input_event_get_pointer_input_event(MirInputEvent const* ev);
++
  #ifdef __cplusplus
+ }
  /**@}*/
 === added file 'include/common/mir_toolkit/events/input/pointer_input_event.h'
 --- include/common/mir_toolkit/events/input/pointer_input_event.h	1970-01-01 00:00:00 +0000
 +++ include/common/mir_toolkit/events/input/pointer_input_event.h	2015-01-14 19:51:52 +0000
@@ -0,0 +1,120 @@
++/*
++ * 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 warranty of
++ * MERCHANTABILITY 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/>.
++ *
++ * Authored by: Robert Carr <robert.carr@canonical.com>
++ */
++
++#ifndef MIR_TOOLKIT_POINTER_INPUT_EVENT_H_
++#define MIR_TOOLKIT_POINTER_INPUT_EVENT_H_
++
++#include <stdbool.h>
++
++#ifdef __cplusplus
++/**
++ * \addtogroup mir_toolkit
++ * @{
++ */
++extern "C" {
++#endif
++
++/**
++ * An event type describing a change in pointer device state.
++ */
++typedef struct MirPointerInputEvent MirPointerInputEvent;
++
++/**
++ * Possible pointer actions
++ */
++typedef enum {
++    /* A pointer button has come up */
++    mir_pointer_input_event_action_button_up = 0,
++    /* A pointer button has gone down */
++    mir_pointer_input_event_action_button_down = 1,
++    /* The pointer has entered the surface to which this event was delivered */
++    mir_pointer_input_event_action_enter = 2,
++    /* The pointer has left the surface to which this event was delivered */
++    mir_pointer_input_event_action_leave = 3,
++    /* Axis values have changed for the pointer */
++    mir_pointer_input_event_action_motion = 4
++} MirPointerInputEventAction;
++
++/**
++ * Identifiers for pointer axis
++ */
++typedef enum {
++/* Absolute axis containing the x coordinate of the pointer */
++    mir_pointer_input_axis_x = 0,
++/* Absolute axis containing the y coordinate of the pointer */
++    mir_pointer_input_axis_y = 1,
++/* Relative axis containing ticks reported by the vertical scroll wheel */
++    mir_pointer_input_axis_vscroll = 2,
++/* Relative axis containing ticks reported by the horizontal scroll wheel */
++    mir_pointer_input_axis_hscroll = 3
++} MirPointerInputEventAxis;
++
++/*
++ * Identifiers for pointer buttons
++ */
++typedef enum {
++    mir_pointer_input_button_primary   = 1,
++    mir_pointer_input_button_secondary = 2,
++    mir_pointer_input_button_tertiary  = 3,
++    mir_pointer_input_button_back      = 4,
++    mir_pointer_input_button_forward   = 5
++} MirPointerInputEventButton;
++
++/**
++ * Retrieve the modifier keys pressed when the pointer action occured.
++ *
++ *   \param [in] event The pointer event
++ *   \return           The modifier mask
++ */
++MirInputEventModifiers mir_pointer_input_event_get_modifiers(MirPointerInputEvent const* event);
++
++/**
++ * Retrieve the action which occured to generate a given pointer event.
++ *
++ *  \param [in] event       The pointer event
++ *  \return                 Action performed by the pointer
++ */
++MirPointerInputEventAction mir_pointer_input_event_get_action(MirPointerInputEvent const* event);
++
++/**
++ * Retrieve the state of a given pointer button when the action occurred.
++ *
++ * \param [in] event         The pointer event
++ * \param [in] button        The button to check
++ *
++ * \return                   Whether the given button is depressed
++ */
++bool mir_pointer_input_event_get_button_state(MirPointerInputEvent const* event,
++    MirPointerInputEventButton button);
++
++/**
++ * Retrieve the axis value reported by a given pointer event.
++ *
++ *  \param [in] event       The pointer event
++ *  \param [in] axis        The axis to retreive a value from
++ *  \return                 The value of the given axis
++ */
++float mir_pointer_input_event_get_axis_value(MirPointerInputEvent const* event,
++    MirPointerInputEventAxis axis);
++
++#ifdef __cplusplus
++}
++/**@}*/
++#endif
++
++#endif /* MIR_TOOLKIT_POINTER_INPUT_EVENT_H_ */
 === modified file 'platform-ABI-sha1sums'
 --- platform-ABI-sha1sums	2015-01-14 08:52:38 +0000
 +++ platform-ABI-sha1sums	2015-01-14 19:51:52 +0000
@@ -22,8 +22,9 @@
  f4d39e9893ce6308bddd83a49b90f0051f565323  include/common/mir_toolkit/event.h
 f2929415aa423f9551d3c595c439fe1c6efd  include/common/mir_toolkit/events/event_deprecated.h
  cb2358a701db2b9c8d9ba1c877f29f834af259a7  include/common/mir_toolkit/events/event.h
--c591a02a8e9851db342c310cf829d018a1eddb51  include/common/mir_toolkit/events/input/input_event.h
++caaf95ea6c02570ab733ade70aba2ecea810b3a7  include/common/mir_toolkit/events/input/input_event.h
 a12138474e9be218eeb8f14b372af0fcec7e  include/common/mir_toolkit/events/input/key_input_event.h
++489e8bae7c3e949ac449b09bd3bf554dae0e8986  include/common/mir_toolkit/events/input/pointer_input_event.h
  de7c23453e6d897296f32e49d9ba952a1baa0200  include/common/mir_toolkit/events/input/touch_input_event.h
 e85a50e2de651589da3ced70e0fc0a915f26  include/common/mir_toolkit/events/orientation_event.h
  f623dcf3c2ed134c1be20106eb54bcccc84af462  include/common/mir_toolkit/events/prompt_session_event.h
 === modified file 'server-ABI-sha1sums'
 --- server-ABI-sha1sums	2015-01-14 08:52:38 +0000
 +++ server-ABI-sha1sums	2015-01-14 19:51:52 +0000
@@ -22,8 +22,9 @@
  f4d39e9893ce6308bddd83a49b90f0051f565323  include/common/mir_toolkit/event.h
 f2929415aa423f9551d3c595c439fe1c6efd  include/common/mir_toolkit/events/event_deprecated.h
  cb2358a701db2b9c8d9ba1c877f29f834af259a7  include/common/mir_toolkit/events/event.h
--c591a02a8e9851db342c310cf829d018a1eddb51  include/common/mir_toolkit/events/input/input_event.h
++caaf95ea6c02570ab733ade70aba2ecea810b3a7  include/common/mir_toolkit/events/input/input_event.h
 a12138474e9be218eeb8f14b372af0fcec7e  include/common/mir_toolkit/events/input/key_input_event.h
++489e8bae7c3e949ac449b09bd3bf554dae0e8986  include/common/mir_toolkit/events/input/pointer_input_event.h
  de7c23453e6d897296f32e49d9ba952a1baa0200  include/common/mir_toolkit/events/input/touch_input_event.h
 e85a50e2de651589da3ced70e0fc0a915f26  include/common/mir_toolkit/events/orientation_event.h
  f623dcf3c2ed134c1be20106eb54bcccc84af462  include/common/mir_toolkit/events/prompt_session_event.h
 === modified file 'src/client/symbols.map'
 --- src/client/symbols.map	2015-01-14 02:35:56 +0000
 +++ src/client/symbols.map	2015-01-14 19:51:52 +0000
@@ -36,5 +36,11 @@
  } MIR_CLIENT_8.1;
  MIR_CLIENT_8.3 {
++  global:
++    mir_input_event_get_pointer_input_event;
++    mir_pointer_input_event_get_modifiers;
++    mir_pointer_input_event_get_action;
++    mir_pointer_input_event_get_button_state;
++    mir_pointer_input_event_get_axis_value;
      mir_connection_create_spec_for_menu_surface;
  } MIR_CLIENT_8.2;
 \ No newline at end of file
 === modified file 'src/common/input/input_event.cpp'
 --- src/common/input/input_event.cpp	2014-12-17 21:44:45 +0000
 +++ src/common/input/input_event.cpp	2015-01-14 19:51:52 +0000
@@ -58,22 +58,75 @@
+     }
+ }
++// Never exposed in old event, so lets avoid leaking it in to a header now.
++enum
++{
++    AINPUT_SOURCE_CLASS_MASK = 0x000000ff,
++
++    AINPUT_SOURCE_CLASS_BUTTON = 0x00000001,
++    AINPUT_SOURCE_CLASS_POINTER = 0x00000002,
++    AINPUT_SOURCE_CLASS_NAVIGATION = 0x00000004,
++    AINPUT_SOURCE_CLASS_POSITION = 0x00000008,
++    AINPUT_SOURCE_CLASS_JOYSTICK = 0x00000010
++};
++enum
++{
++    AINPUT_SOURCE_UNKNOWN = 0x00000000,
++
++    AINPUT_SOURCE_KEYBOARD = 0x00000100 | AINPUT_SOURCE_CLASS_BUTTON,
++    AINPUT_SOURCE_DPAD = 0x00000200 | AINPUT_SOURCE_CLASS_BUTTON,
++    AINPUT_SOURCE_GAMEPAD = 0x00000400 | AINPUT_SOURCE_CLASS_BUTTON,
++    AINPUT_SOURCE_TOUCHSCREEN = 0x00001000 | AINPUT_SOURCE_CLASS_POINTER,
++    AINPUT_SOURCE_MOUSE = 0x00002000 | AINPUT_SOURCE_CLASS_POINTER,
++    AINPUT_SOURCE_STYLUS = 0x00004000 | AINPUT_SOURCE_CLASS_POINTER,
++    AINPUT_SOURCE_TRACKBALL = 0x00010000 | AINPUT_SOURCE_CLASS_NAVIGATION,
++    AINPUT_SOURCE_TOUCHPAD = 0x00100000 | AINPUT_SOURCE_CLASS_POSITION,
++    AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
++
++    AINPUT_SOURCE_ANY = 0xffffff00
++};
++
  MirEvent const* old_ev_from_new(MirInputEvent const* ev)
+ {
      return reinterpret_cast<MirEvent const*>(ev);
+ }
++
  MirKeyEvent const& old_kev_from_new(MirKeyInputEvent const* ev)
+ {
      auto old_ev = reinterpret_cast<MirEvent const*>(ev);
      expect_old_event_type(old_ev, mir_event_type_key);
      return old_ev->key;
+ }
++
  MirMotionEvent const& old_mev_from_new(MirTouchInputEvent const* ev)
+ {
      auto old_ev = reinterpret_cast<MirEvent const*>(ev);
      expect_old_event_type(old_ev, mir_event_type_motion);
      return old_ev->motion;
+ }
++
++MirMotionEvent const& old_mev_from_new(MirPointerInputEvent const* ev)
++{
++    auto old_ev = reinterpret_cast<MirEvent const*>(ev);
++    expect_old_event_type(old_ev, mir_event_type_motion);
++    return old_ev->motion;
++}
++
++// Differentiate between MirTouchInputEvents and MirPointerInputEvents based on old device class
++MirInputEventType type_from_device_class(int32_t source_class)
++{
++    switch (source_class)
++    {
++    case AINPUT_SOURCE_MOUSE:
++    case AINPUT_SOURCE_TRACKBALL:
++    case AINPUT_SOURCE_TOUCHPAD:
++        return mir_input_event_type_pointer;
++    // Realistically touch events should only come from Stylus and Touchscreen
++    // device classes...practically its not clear this is a safe assumption.
++    default:
++        return mir_input_event_type_touch;
++    }
++}
+ }
  MirInputEventType mir_input_event_get_type(MirInputEvent const* ev)
@@ -91,7 +144,7 @@
      case mir_event_type_key:
          return mir_input_event_type_key;
      case mir_event_type_motion:
--        return mir_input_event_type_touch;
++        return type_from_device_class(old_ev->motion.source_id);
      default:
          abort();
+     }
@@ -377,3 +430,86 @@
          return -1;
+     }
+ }
++
++/* Pointer event accessors */
++MirPointerInputEvent const* mir_input_event_get_pointer_input_event(MirInputEvent const* ev)
++{
++    if(mir_input_event_get_type(ev) != mir_input_event_type_pointer)
++    {
++        mir::log_critical("expected pointer input event but event was of type " +
++            input_event_type_to_string(mir_input_event_get_type(ev)));
++        abort();
++    }
++
++    return reinterpret_cast<MirPointerInputEvent const*>(ev);
++}
++
++MirInputEventModifiers mir_pointer_input_event_get_modifiers(MirPointerInputEvent const* pev)
++{
++    auto const& old_mev = old_mev_from_new(pev);
++    return old_modifiers_to_new(static_cast<MirKeyModifier>(old_mev.modifiers));
++}
++
++MirPointerInputEventAction mir_pointer_input_event_get_action(MirPointerInputEvent const* pev)
++{
++    auto const& old_mev = old_mev_from_new(pev);
++    auto masked_action = old_mev.action & MIR_EVENT_ACTION_MASK;
++    switch (masked_action)
++    {
++    case mir_motion_action_up:
++    case mir_motion_action_pointer_up:
++        return mir_pointer_input_event_action_button_up;
++    case mir_motion_action_down:
++    case mir_motion_action_pointer_down:
++        return mir_pointer_input_event_action_button_down;
++    case mir_motion_action_hover_enter:
++        return mir_pointer_input_event_action_enter;
++    case mir_motion_action_hover_exit:
++        return mir_pointer_input_event_action_leave;
++    case mir_motion_action_move:
++    case mir_motion_action_hover_move:
++    case mir_motion_action_outside:
++    default:
++        return mir_pointer_input_event_action_motion;
++    }
++}
++
++bool mir_pointer_input_event_get_button_state(MirPointerInputEvent const* pev,
++    MirPointerInputEventButton button)
++{
++   auto const& old_mev = old_mev_from_new(pev);
++   switch (button)
++   {
++   case mir_pointer_input_button_primary:
++       return old_mev.button_state & mir_motion_button_primary;
++   case mir_pointer_input_button_secondary:
++       return old_mev.button_state & mir_motion_button_secondary;
++   case mir_pointer_input_button_tertiary:
++       return old_mev.button_state & mir_motion_button_tertiary;
++   case mir_pointer_input_button_back:
++       return old_mev.button_state & mir_motion_button_back;
++   case mir_pointer_input_button_forward:
++       return old_mev.button_state & mir_motion_button_forward;
++   default:
++       return false;
++   }
++}
++
++float mir_pointer_input_event_get_axis_value(MirPointerInputEvent const* pev, MirPointerInputEventAxis axis)
++{
++   auto const& old_mev = old_mev_from_new(pev);
++   switch (axis)
++   {
++   case mir_pointer_input_axis_x:
++       return old_mev.pointer_coordinates[0].x;
++   case mir_pointer_input_axis_y:
++       return old_mev.pointer_coordinates[0].y;
++   case mir_pointer_input_axis_vscroll:
++       return old_mev.pointer_coordinates[0].vscroll;
++   case mir_pointer_input_axis_hscroll:
++       return old_mev.pointer_coordinates[0].hscroll;
++   default:
++       mir::log_critical("Invalid axis enumeration " + std::to_string(axis));
++       abort();
++   }
++}
 === modified file 'tests/unit-tests/input/test_input_event.cpp'
 --- tests/unit-tests/input/test_input_event.cpp	2014-12-17 00:03:09 +0000
 +++ tests/unit-tests/input/test_input_event.cpp	2015-01-14 19:51:52 +0000
@@ -24,17 +24,65 @@
  // See: https://bugs.launchpad.net/mir/+bug/1311699
  #define MIR_EVENT_ACTION_POINTER_INDEX_MASK 0xff00
  #define MIR_EVENT_ACTION_POINTER_INDEX_SHIFT 8;
--
--TEST(InputEvent, old_style_key_and_motion_events_are_input_events)
++#define MIR_EVENT_ACTION_MASK 0xff
++
++// TODO: Refactor event initializers
++
++namespace
++{
++// Never exposed in old event, so lets avoid leaking it in to a header now.
++enum
++{
++    AINPUT_SOURCE_CLASS_MASK = 0x000000ff,
++
++    AINPUT_SOURCE_CLASS_BUTTON = 0x00000001,
++    AINPUT_SOURCE_CLASS_POINTER = 0x00000002,
++    AINPUT_SOURCE_CLASS_NAVIGATION = 0x00000004,
++    AINPUT_SOURCE_CLASS_POSITION = 0x00000008,
++    AINPUT_SOURCE_CLASS_JOYSTICK = 0x00000010
++};
++enum
++{
++    AINPUT_SOURCE_UNKNOWN = 0x00000000,
++
++    AINPUT_SOURCE_KEYBOARD = 0x00000100 | AINPUT_SOURCE_CLASS_BUTTON,
++    AINPUT_SOURCE_DPAD = 0x00000200 | AINPUT_SOURCE_CLASS_BUTTON,
++    AINPUT_SOURCE_GAMEPAD = 0x00000400 | AINPUT_SOURCE_CLASS_BUTTON,
++    AINPUT_SOURCE_TOUCHSCREEN = 0x00001000 | AINPUT_SOURCE_CLASS_POINTER,
++    AINPUT_SOURCE_MOUSE = 0x00002000 | AINPUT_SOURCE_CLASS_POINTER,
++    AINPUT_SOURCE_STYLUS = 0x00004000 | AINPUT_SOURCE_CLASS_POINTER,
++    AINPUT_SOURCE_TRACKBALL = 0x00010000 | AINPUT_SOURCE_CLASS_NAVIGATION,
++    AINPUT_SOURCE_TOUCHPAD = 0x00100000 | AINPUT_SOURCE_CLASS_POSITION,
++    AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,
++
++    AINPUT_SOURCE_ANY = 0xffffff00
++};
++
++MirEvent a_key_ev()
+ {
      MirEvent key_ev;
      key_ev.type = mir_event_type_key;
++    return key_ev;
++}
++
++MirEvent a_motion_ev(int device_class = AINPUT_SOURCE_UNKNOWN)
++{
++    MirEvent motion_ev;
++    motion_ev.type = mir_event_type_motion;
++    motion_ev.motion.source_id = device_class;
++    return motion_ev;
++}
++
++}
++
++TEST(InputEvent, old_style_key_and_motion_events_are_input_events)
++{
++    auto key_ev = a_key_ev();
      EXPECT_EQ(mir_event_type_input, mir_event_get_type(&key_ev));
      EXPECT_EQ(mir_input_event_type_key, mir_input_event_get_type(mir_event_get_input_event(&key_ev)));
--    MirEvent motion_ev;
--    motion_ev.type = mir_event_type_motion;
++    auto motion_ev = a_motion_ev();
      EXPECT_EQ(mir_event_type_input, mir_event_get_type(&motion_ev));
      EXPECT_NE(nullptr, mir_event_get_input_event(&motion_ev));
@@ -45,7 +93,7 @@
  TEST(CommonInputEventProperties, device_id_taken_from_old_style_event)
+ {
      int64_t dev_id_1 = 17, dev_id_2 = 23;
--    MirEvent old_ev;
++    auto old_ev = a_motion_ev();
      old_ev.type = mir_event_type_motion;
      old_ev.motion.device_id = dev_id_1;
@@ -61,9 +109,8 @@
  TEST(CommonInputEventProperties, event_time_taken_from_old_style_event)
+ {
      int64_t event_time_1 = 79, event_time_2 = 83;
--    MirEvent old_ev;
--
--    old_ev.type = mir_event_type_motion;
++    auto old_ev = a_motion_ev();
++
      old_ev.motion.event_time = event_time_1;
      EXPECT_EQ(event_time_1, mir_input_event_get_event_time(
          mir_event_get_input_event(&old_ev)));
@@ -76,8 +123,7 @@
  TEST(KeyInputEventProperties, up_and_down_actions_copied_from_old_style_event)
+ {
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_key;
++    auto old_ev = a_key_ev();
      old_ev.key.action = mir_key_action_down;
      old_ev.key.repeat_count = 0;
@@ -91,8 +137,8 @@
  TEST(KeyInputEventProperties, repeat_action_produced_from_non_zero_repeat_count_in_old_style_event)
+ {
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_key;
++    auto old_ev = a_key_ev();
++
      old_ev.key.action = mir_key_action_down;
      old_ev.key.repeat_count = 1;
@@ -106,8 +152,7 @@
      int scan_code = 31;
      MirKeyModifier old_modifiers = mir_key_modifier_shift;
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_key;
++    auto old_ev = a_key_ev();
      old_ev.key.key_code = key_code;
      old_ev.key.scan_code = scan_code;
      old_ev.key.modifiers = old_modifiers;
@@ -121,9 +166,8 @@
  TEST(TouchInputEventProperties, touch_count_taken_from_pointer_count)
+ {
      unsigned const pointer_count = 3;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_motion;
      old_ev.motion.action = mir_motion_action_down;
      old_ev.motion.pointer_count = pointer_count;
@@ -134,8 +178,8 @@
  TEST(TouchInputEventProperties, touch_id_comes_from_pointer_coordinates)
+ {
      unsigned const touch_id = 31;
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_motion;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
++
      old_ev.motion.action = mir_motion_action_down;
      old_ev.motion.pointer_count = 1;
      old_ev.motion.pointer_coordinates[0].id = touch_id;
@@ -147,8 +191,7 @@
  // mir_motion_action_up/down represent the start of a gesture. pointers only go up/down one at a time
  TEST(TouchInputEventProperties, down_and_up_actions_are_taken_from_old_event)
+ {
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_motion;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
      old_ev.motion.action = mir_motion_action_down;
      old_ev.motion.pointer_count = 1;
@@ -156,12 +199,11 @@
      EXPECT_EQ(mir_touch_input_event_action_down, mir_touch_input_event_get_touch_action(tev, 0));
+ }
--TEST(TouchInputEventProperties, pointer_up_down_applies_only_to_masked_action)
++TEST(TouchInputEventProperties, touch_up_down_applies_only_to_masked_action)
+ {
      int const masked_pointer_index = 1;
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_motion;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
      old_ev.motion.action = masked_pointer_index << MIR_EVENT_ACTION_POINTER_INDEX_SHIFT;
      old_ev.motion.action = (old_ev.motion.action & MIR_EVENT_ACTION_POINTER_INDEX_MASK) | mir_motion_action_pointer_up;
      old_ev.motion.pointer_count = 3;
@@ -174,8 +216,7 @@
  TEST(TouchInputEventProperties, tool_type_copied_from_old_pc)
+ {
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_motion;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
      auto& old_mev = old_ev.motion;
      old_mev.pointer_count = 4;
@@ -193,8 +234,7 @@
  TEST(TouchInputEventProperties, axis_values_used_by_qtmir_copied)
+ {
      float x_value = 19, y_value = 23, touch_major = .3, touch_minor = .2, pressure = .9, size = 1111;
--    MirEvent old_ev;
--    old_ev.type = mir_event_type_motion;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_TOUCHSCREEN);
      old_ev.motion.pointer_count = 1;
      auto &old_pc = old_ev.motion.pointer_coordinates[0];
      old_pc.x = x_value;
@@ -212,3 +252,144 @@
      EXPECT_EQ(pressure, mir_touch_input_event_get_touch_axis_value(tev, 0, mir_touch_input_axis_pressure));
      EXPECT_EQ(size, mir_touch_input_event_get_touch_axis_value(tev, 0, mir_touch_input_axis_size));
+ }
++
++/* Pointer and touch event differentiation */
++
++namespace
++{
++struct DeviceClassTestParameters
++{
++    MirInputEventType expected_type;
++    int32_t device_class;
++};
++
++struct DeviceClassTest : public testing::Test, testing::WithParamInterface<DeviceClassTestParameters>
++{
++};
++}
++
++TEST_P(DeviceClassTest, pointer_and_touch_events_differentiated_on_device_class)
++{
++    auto const& param = GetParam();
++    auto old_ev = a_motion_ev(param.device_class);
++
++    auto iev = mir_event_get_input_event(&old_ev);
++    EXPECT_EQ(param.expected_type, mir_input_event_get_type(iev));
++}
++
++INSTANTIATE_TEST_CASE_P(MouseDeviceClassTest,
++    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_pointer, AINPUT_SOURCE_MOUSE}));
++
++INSTANTIATE_TEST_CASE_P(TouchpadDeviceClassTest,
++    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_pointer, AINPUT_SOURCE_TOUCHPAD}));
++
++INSTANTIATE_TEST_CASE_P(TrackballDeviceClassTest,
++    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_pointer, AINPUT_SOURCE_TRACKBALL}));
++
++INSTANTIATE_TEST_CASE_P(TouchscreenDeviceClassTest,
++    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_touch, AINPUT_SOURCE_TOUCHSCREEN}));
++
++INSTANTIATE_TEST_CASE_P(StylusDeviceClassTest,
++    DeviceClassTest, ::testing::Values(DeviceClassTestParameters{mir_input_event_type_touch, AINPUT_SOURCE_STYLUS}));
++
++/* Pointer event property accessors */
++
++TEST(PointerInputEventProperties, modifiers_taken_from_old_style_ev)
++{
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
++    old_ev.motion.modifiers = mir_key_modifier_shift;
++
++    auto pointer_event =
++        mir_input_event_get_pointer_input_event(mir_event_get_input_event(&old_ev));
++    EXPECT_EQ(mir_input_event_modifier_shift, mir_pointer_input_event_get_modifiers(pointer_event));
++}
++
++namespace
++{
++struct ActionTestParameters
++{
++    MirMotionAction old_action;
++    MirPointerInputEventAction new_action;
++};
++
++struct MotionToPointerActionTest : public testing::Test, testing::WithParamInterface<ActionTestParameters>
++{
++};
++}
++
++TEST_P(MotionToPointerActionTest, old_style_action_translated_to_new_style)
++{
++    auto const& params = GetParam();
++
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
++
++    auto shift = 0 << MIR_EVENT_ACTION_POINTER_INDEX_SHIFT;
++    old_ev.motion.action = (shift & MIR_EVENT_ACTION_POINTER_INDEX_MASK) | params.old_action;
++    EXPECT_EQ(params.new_action,
++        mir_pointer_input_event_get_action(mir_input_event_get_pointer_input_event(mir_event_get_input_event(&old_ev))));
++}
++
++INSTANTIATE_TEST_CASE_P(MotionPointerUpTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_pointer_up, mir_pointer_input_event_action_button_up}));
++
++INSTANTIATE_TEST_CASE_P(MotionPointerDownTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_pointer_down, mir_pointer_input_event_action_button_down}));
++
++INSTANTIATE_TEST_CASE_P(MotionEnterTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_hover_enter, mir_pointer_input_event_action_enter}));
++
++INSTANTIATE_TEST_CASE_P(MotionLeaveTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_hover_exit, mir_pointer_input_event_action_leave}));
++
++INSTANTIATE_TEST_CASE_P(MotionPointerMoveTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_move, mir_pointer_input_event_action_motion}));
++
++INSTANTIATE_TEST_CASE_P(MotionPointerHoverMoveTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_hover_move, mir_pointer_input_event_action_motion}));
++
++INSTANTIATE_TEST_CASE_P(MotionPointerOutsideMoveTest,
++    MotionToPointerActionTest, ::testing::Values(
++        ActionTestParameters{mir_motion_action_outside, mir_pointer_input_event_action_motion}));
++
++TEST(PointerInputEventProperties, button_state_translated)
++{
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
++
++    old_ev.motion.button_state = mir_motion_button_primary;
++    auto pev = mir_input_event_get_pointer_input_event(mir_event_get_input_event(&old_ev));
++
++    EXPECT_TRUE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_primary));
++    EXPECT_FALSE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_secondary));
++
++    old_ev.motion.button_state = static_cast<MirMotionButton>(old_ev.motion.button_state | (mir_motion_button_secondary));
++
++    EXPECT_TRUE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_primary));
++    EXPECT_TRUE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_secondary));
++
++    EXPECT_FALSE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_tertiary));
++    EXPECT_FALSE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_back));
++    EXPECT_FALSE(mir_pointer_input_event_get_button_state(pev, mir_pointer_input_button_forward));
++}
++
++TEST(PointerInputEventProperties, axis_values_copied)
++{
++    float x = 7, y = 9.3, hscroll = 13, vscroll = 17;
++    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
++    old_ev.motion.pointer_count = 0;
++    old_ev.motion.pointer_coordinates[0].x = x;
++    old_ev.motion.pointer_coordinates[0].y = y;
++    old_ev.motion.pointer_coordinates[0].vscroll = vscroll;
++    old_ev.motion.pointer_coordinates[0].hscroll = hscroll;
++
++    auto pev = mir_input_event_get_pointer_input_event(mir_event_get_input_event(&old_ev));
++    EXPECT_EQ(x, mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_x));
++    EXPECT_EQ(y, mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_y));
++    EXPECT_EQ(vscroll, mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_vscroll));
++    EXPECT_EQ(hscroll, mir_pointer_input_event_get_axis_value(pev, mir_pointer_input_axis_hscroll));
++}