1
=== modified file '3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp'
2
--- 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2015-05-01 08:54:27 +0000
3
+++ 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp	2015-05-14 18:12:40 +0000
4
@@ -20,30 +20,30 @@
5
20
//#define LOG_NDEBUG 0
20
//#define LOG_NDEBUG 0
6
21
21
7
22
// Log detailed debug messages about each inbound event notification to the dispatcher.
22
// Log detailed debug messages about each inbound event notification to the dispatcher.
9
23
#define DEBUG_INBOUND_EVENT_DETAILS 0
23
#define DEBUG_INBOUND_EVENT_DETAILS 1
10
24
24
11
25
// Log detailed debug messages about each outbound event processed by the dispatcher.
25
// Log detailed debug messages about each outbound event processed by the dispatcher.
13
26
#define DEBUG_OUTBOUND_EVENT_DETAILS 0
26
#define DEBUG_OUTBOUND_EVENT_DETAILS 1
14
27
27
15
28
// Log debug messages about the dispatch cycle.
28
// Log debug messages about the dispatch cycle.
17
29
#define DEBUG_DISPATCH_CYCLE 0
29
#define DEBUG_DISPATCH_CYCLE 1
18
30
30
19
31
// Log debug messages about registrations.
31
// Log debug messages about registrations.
21
32
#define DEBUG_REGISTRATION 0
32
#define DEBUG_REGISTRATION 1
22
33
33
25
34
// Log debug messages about input event injection.
34
 // Log debug messages about input event injection.
26
35
#define DEBUG_INJECTION 0
35
#define DEBUG_INJECTION 1
27
36
36
28
37
// Log debug messages about input focus tracking.
37
// Log debug messages about input focus tracking.
30
38
#define DEBUG_FOCUS 0
38
#define DEBUG_FOCUS 1
31
39
39
32
40
// Log debug messages about the app switch latency optimization.
40
// Log debug messages about the app switch latency optimization.
34
41
#define DEBUG_APP_SWITCH 0
41
#define DEBUG_APP_SWITCH 1
35
42
42
36
43
// Log debug messages about hover events.
43
// Log debug messages about hover events.
38
44
#define DEBUG_HOVER 0
44
#define DEBUG_HOVER 1
39
45
45
41
46
#define ENABLE_APP_SWITCH_OPTIMIZATION 0
46
#define ENABLE_APP_SWITCH_OPTIMIZATION 1
42
47
47
43
48
#include "InputDispatcher.h"
48
#include "InputDispatcher.h"
44
49
49
45
@@ -3464,7 +3464,7 @@
46
3464
                        originalKeyCode, keyEntry->action, keyEntry->repeatCount,
3464
                        originalKeyCode, keyEntry->action, keyEntry->repeatCount,
47
3465
                        keyEntry->policyFlags);
3465
                        keyEntry->policyFlags);
48
3466
#endif
3466
#endif
50
3467
                return false;
3467
               return false;
51
3468
            }
3468
            }
52
3469
3469
53
3470
            // Dispatch the unhandled key to the policy.
3470
            // Dispatch the unhandled key to the policy.
54
3471
3471
55
=== modified file 'include/client/mir/events/event_builders.h'
56
--- include/client/mir/events/event_builders.h	2015-05-05 18:01:08 +0000
57
+++ include/client/mir/events/event_builders.h	2015-05-14 18:12:40 +0000
58
@@ -25,7 +25,6 @@
59
25
#include "mir/frontend/surface_id.h"
25
#include "mir/frontend/surface_id.h"
60
26
26
61
27
#include <memory>
27
#include <memory>
62
28
#include <vector>
63
29
#include <functional>
28
#include <functional>
64
30
#include <chrono>
29
#include <chrono>
65
31
30
66
@@ -63,7 +62,7 @@
67
63
// Pointer event
62
// Pointer event
68
64
EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
63
EventUPtr make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
69
65
    MirInputEventModifiers modifiers, MirPointerAction action,
64
    MirInputEventModifiers modifiers, MirPointerAction action,
71
66
    std::vector<MirPointerButton> const& buttons_pressed,
65
    MirPointerButtons buttons_pressed,
72
67
    float x_axis_value, float y_axis_value,
66
    float x_axis_value, float y_axis_value,
73
68
    float hscroll_value, float vscroll_value);
67
    float hscroll_value, float vscroll_value);
74
69
}
68
}
75
70
69
76
=== modified file 'include/client/mir_toolkit/events/input/pointer_event.h'
77
--- include/client/mir_toolkit/events/input/pointer_event.h	2015-03-31 02:35:42 +0000
78
+++ include/client/mir_toolkit/events/input/pointer_event.h	2015-05-14 18:12:40 +0000
79
@@ -68,12 +68,13 @@
80
68
 * Identifiers for pointer buttons
68
 * Identifiers for pointer buttons
81
69
 */
69
 */
82
70
typedef enum {
70
typedef enum {
88
71
    mir_pointer_button_primary   = 1,
71
    mir_pointer_button_primary   = 1 << 0,
89
72
    mir_pointer_button_secondary = 2,
72
    mir_pointer_button_secondary = 1 << 1,
90
73
    mir_pointer_button_tertiary  = 3,
73
    mir_pointer_button_tertiary  = 1 << 2,
91
74
    mir_pointer_button_back      = 4,
74
    mir_pointer_button_back      = 1 << 3,
92
75
    mir_pointer_button_forward   = 5
75
    mir_pointer_button_forward   = 1 << 4
93
76
} MirPointerButton;
76
} MirPointerButton;
94
77
typedef unsigned int MirPointerButtons;
95
77
78
96
78
/**
79
/**
97
79
 * Retrieve the modifier keys pressed when the pointer action occured.
80
 * Retrieve the modifier keys pressed when the pointer action occured.
98
@@ -103,6 +104,15 @@
99
103
    MirPointerButton button);
104
    MirPointerButton button);
100
104
105
101
105
/**
106
/**
102
107
 * Retreive the pointer button state as a masked set of values.
103
108
 *
104
109
 * \param [in] event         The pointer event
105
110
 *
106
111
 * \return                   The button state
107
112
 */
108
113
MirPointerButtons mir_pointer_event_buttons(MirPointerEvent const* event);
109
114
110
115
/**
111
106
 * Retrieve the axis value reported by a given pointer event.
116
 * Retrieve the axis value reported by a given pointer event.
112
107
 *
117
 *
113
108
 *  \param [in] event       The pointer event
118
 *  \param [in] event       The pointer event
114
109
119
115
=== modified file 'src/client/events/event_builders.cpp'
116
--- src/client/events/event_builders.cpp	2015-05-08 20:54:52 +0000
117
+++ src/client/events/event_builders.cpp	2015-05-14 18:12:40 +0000
118
@@ -231,29 +231,40 @@
119
231
231
120
232
namespace
232
namespace
121
233
{
233
{
123
234
MirMotionAction old_action_from_pointer_action(MirPointerAction action, MirMotionButton button_state)
234
MirMotionAction old_action_from_pointer_action(MirPointerAction action, int buttons_pressed)
124
235
{
235
{
125
236
    switch (action)
236
    switch (action)
126
237
    {
237
    {
127
238
    case mir_pointer_action_button_up:
238
    case mir_pointer_action_button_up:
129
239
        return mir_motion_action_up;
239
        return buttons_pressed == 0 ? mir_motion_action_up : mir_motion_action_pointer_up;
130
240
    case mir_pointer_action_button_down:
240
    case mir_pointer_action_button_down:
132
241
        return mir_motion_action_down;
241
        return buttons_pressed == 1 ? mir_motion_action_down : mir_motion_action_pointer_down;
133
242
    case mir_pointer_action_enter:
242
    case mir_pointer_action_enter:
134
243
        return mir_motion_action_hover_enter;
243
        return mir_motion_action_hover_enter;
135
244
    case mir_pointer_action_leave:
244
    case mir_pointer_action_leave:
136
245
        return mir_motion_action_hover_exit;
245
        return mir_motion_action_hover_exit;
137
246
    case mir_pointer_action_motion:
246
    case mir_pointer_action_motion:
139
247
        return button_state ? mir_motion_action_move : mir_motion_action_hover_move;
247
        return buttons_pressed ? mir_motion_action_move : mir_motion_action_hover_move;
140
248
    default:
248
    default:
141
249
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid pointer action"));
249
        BOOST_THROW_EXCEPTION(std::logic_error("Invalid pointer action"));
142
250
    }
250
    }
143
251
}
251
}
144
252
int count_buttons(MirPointerButtons buttons)
145
253
{
146
254
    int ret = 0;
147
255
    if (buttons & mir_pointer_button_primary) ret++;
148
256
    if (buttons & mir_pointer_button_secondary) ret++;
149
257
    if (buttons & mir_pointer_button_tertiary) ret++;
150
258
    if (buttons & mir_pointer_button_forward) ret++;
151
259
    if (buttons & mir_pointer_button_back) ret++;
152
260
153
261
    return ret;
154
262
}
155
252
}
263
}
156
253
264
157
254
mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
265
mir::EventUPtr mev::make_event(MirInputDeviceId device_id, std::chrono::nanoseconds timestamp,
158
255
    MirInputEventModifiers modifiers, MirPointerAction action,
266
    MirInputEventModifiers modifiers, MirPointerAction action,
160
256
    std::vector<MirPointerButton> const& buttons_pressed,
267
    MirPointerButtons buttons_pressed,                               
161
257
    float x_axis_value, float y_axis_value,
268
    float x_axis_value, float y_axis_value,
162
258
    float hscroll_value, float vscroll_value)
269
    float hscroll_value, float vscroll_value)
163
259
{
270
{
164
@@ -266,31 +277,9 @@
165
266
    mev.event_time = timestamp;
277
    mev.event_time = timestamp;
166
267
    mev.modifiers = modifiers;
278
    mev.modifiers = modifiers;
167
268
    mev.source_id = AINPUT_SOURCE_MOUSE;
279
    mev.source_id = AINPUT_SOURCE_MOUSE;
193
269
280
    mev.buttons = buttons_pressed;
194
270
    int button_state = 0;
281
    
195
271
    for (auto button : buttons_pressed)
282
    mev.action = old_action_from_pointer_action(action, count_buttons(buttons_pressed));
171
272
    {
172
273
    switch (button)
173
274
    {
174
275
    case mir_pointer_button_primary:
175
276
        button_state |= mir_motion_button_primary;
176
277
        break;
177
278
    case mir_pointer_button_secondary:
178
279
        button_state |= mir_motion_button_secondary;
179
280
        break;
180
281
    case mir_pointer_button_tertiary:
181
282
        button_state |= mir_motion_button_tertiary;
182
283
        break;
183
284
    case mir_pointer_button_back:
184
285
        button_state |= mir_motion_button_back;
185
286
        break;
186
287
    case mir_pointer_button_forward:
187
288
        button_state |= mir_motion_button_forward;
188
289
        break;
189
290
    }
190
291
    }
191
292
    mev.button_state = static_cast<MirMotionButton>(button_state);
192
293
    mev.action = old_action_from_pointer_action(action, mev.button_state);
196
294
283
197
295
    mev.pointer_count = 1;
284
    mev.pointer_count = 1;
198
296
    auto& pc = mev.pointer_coordinates[0];
285
    auto& pc = mev.pointer_coordinates[0];
199
297
286
200
=== modified file 'src/client/input/android/android_input_lexicon.cpp'
201
--- src/client/input/android/android_input_lexicon.cpp	2015-05-05 18:01:08 +0000
202
+++ src/client/input/android/android_input_lexicon.cpp	2015-05-14 18:12:40 +0000
203
@@ -50,7 +50,7 @@
204
50
            mir_event.motion.source_id = android_event->getSource();
50
            mir_event.motion.source_id = android_event->getSource();
205
51
            mir_event.motion.action = mev->getAction();
51
            mir_event.motion.action = mev->getAction();
206
52
            mir_event.motion.modifiers = mia::mir_modifiers_from_android(mev->getMetaState());
52
            mir_event.motion.modifiers = mia::mir_modifiers_from_android(mev->getMetaState());
208
53
            mir_event.motion.button_state = static_cast<MirMotionButton>(mev->getButtonState());
53
            mir_event.motion.buttons = mia::mir_pointer_buttons_from_android(mev->getButtonState());
209
54
            mir_event.motion.event_time = mev->getEventTime();
54
            mir_event.motion.event_time = mev->getEventTime();
210
55
            mir_event.motion.pointer_count = mev->getPointerCount();
55
            mir_event.motion.pointer_count = mev->getPointerCount();
211
56
            for(unsigned int i = 0; i < mev->getPointerCount(); i++)
56
            for(unsigned int i = 0; i < mev->getPointerCount(); i++)
212
57
57
213
=== modified file 'src/client/input/android/event_conversion_helpers.cpp'
214
--- src/client/input/android/event_conversion_helpers.cpp	2015-05-08 20:44:56 +0000
215
+++ src/client/input/android/event_conversion_helpers.cpp	2015-05-14 18:12:40 +0000
216
@@ -100,3 +100,37 @@
217
100
        return AKEY_EVENT_ACTION_UP;
100
        return AKEY_EVENT_ACTION_UP;
218
101
    }
101
    }
219
102
}
102
}
220
103
221
104
MirPointerButtons mia::mir_pointer_buttons_from_android(int32_t android_state)
222
105
{
223
106
    MirPointerButtons buttons = 0;
224
107
    
225
108
    if (android_state & AMOTION_EVENT_BUTTON_PRIMARY)
226
109
        buttons |= mir_pointer_button_primary;
227
110
    if (android_state & AMOTION_EVENT_BUTTON_SECONDARY)
228
111
        buttons |= mir_pointer_button_secondary;
229
112
    if (android_state & AMOTION_EVENT_BUTTON_TERTIARY)
230
113
        buttons |= mir_pointer_button_tertiary;
231
114
    if (android_state & AMOTION_EVENT_BUTTON_BACK)
232
115
        buttons |= mir_pointer_button_back;
233
116
    if (android_state & AMOTION_EVENT_BUTTON_FORWARD)
234
117
        buttons |= mir_pointer_button_forward;
235
118
236
119
    return buttons;
237
120
}
238
121
239
122
int32_t mia::android_pointer_buttons_from_mir(MirPointerButtons buttons)
240
123
{
241
124
    int32_t android_state = 0;
242
125
    if (buttons & mir_pointer_button_primary)
243
126
        android_state |= AMOTION_EVENT_BUTTON_PRIMARY;
244
127
    if (buttons & mir_pointer_button_secondary)
245
128
        android_state |= AMOTION_EVENT_BUTTON_SECONDARY;
246
129
    if (buttons & mir_pointer_button_tertiary)
247
130
        android_state |= AMOTION_EVENT_BUTTON_TERTIARY;
248
131
    if (buttons & mir_pointer_button_back)
249
132
        android_state |= AMOTION_EVENT_BUTTON_BACK;
250
133
    if (buttons & mir_pointer_button_forward)
251
134
        android_state |= AMOTION_EVENT_BUTTON_FORWARD;
252
135
    return android_state;
253
136
}
254
103
137
255
=== modified file 'src/client/input/input_event.cpp'
256
--- src/client/input/input_event.cpp	2015-05-05 18:01:08 +0000
257
+++ src/client/input/input_event.cpp	2015-05-14 18:12:40 +0000
258
@@ -424,20 +424,26 @@
259
424
   switch (button)
424
   switch (button)
260
425
   {
425
   {
261
426
   case mir_pointer_button_primary:
426
   case mir_pointer_button_primary:
263
427
       return old_mev.button_state & mir_motion_button_primary;
427
       return old_mev.buttons & mir_pointer_button_primary;
264
428
   case mir_pointer_button_secondary:
428
   case mir_pointer_button_secondary:
266
429
       return old_mev.button_state & mir_motion_button_secondary;
429
       return old_mev.buttons & mir_pointer_button_secondary;
267
430
   case mir_pointer_button_tertiary:
430
   case mir_pointer_button_tertiary:
269
431
       return old_mev.button_state & mir_motion_button_tertiary;
431
       return old_mev.buttons & mir_pointer_button_tertiary;
270
432
   case mir_pointer_button_back:
432
   case mir_pointer_button_back:
272
433
       return old_mev.button_state & mir_motion_button_back;
433
       return old_mev.buttons & mir_pointer_button_back;
273
434
   case mir_pointer_button_forward:
434
   case mir_pointer_button_forward:
275
435
       return old_mev.button_state & mir_motion_button_forward;
435
       return old_mev.buttons & mir_pointer_button_forward;
276
436
   default:
436
   default:
277
437
       return false;
437
       return false;
278
438
   }
438
   }
279
439
}
439
}
280
440
440
281
441
MirPointerButtons mir_pointer_event_buttons(MirPointerEvent const* pev)
282
442
{
283
443
   auto const& old_mev = old_mev_from_new(pev);
284
444
   return old_mev.buttons;
285
445
}
286
446
287
441
float mir_pointer_event_axis_value(MirPointerEvent const* pev, MirPointerAxis axis)
447
float mir_pointer_event_axis_value(MirPointerEvent const* pev, MirPointerAxis axis)
288
442
{
448
{
289
443
   auto const& old_mev = old_mev_from_new(pev);
449
   auto const& old_mev = old_mev_from_new(pev);
290
444
450
291
=== modified file 'src/client/symbols.map'
292
--- src/client/symbols.map	2015-05-07 19:41:08 +0000
293
+++ src/client/symbols.map	2015-05-14 18:12:40 +0000
294
@@ -196,6 +196,7 @@
295
196
    mir_buffer_stream_release;
196
    mir_buffer_stream_release;
296
197
    mir_buffer_stream_release_sync;
197
    mir_buffer_stream_release_sync;
297
198
    mir_buffer_stream_is_valid;
198
    mir_buffer_stream_is_valid;
298
199
    mir_pointer_event_buttons; # Move to 8.5
299
199
} MIR_CLIENT_8.3;
200
} MIR_CLIENT_8.3;
300
200
201
301
201
MIR_CLIENT_DETAIL_8 {
202
MIR_CLIENT_DETAIL_8 {
302
@@ -208,6 +209,8 @@
303
208
      mir::input::android::mir_modifiers_from_android*;
209
      mir::input::android::mir_modifiers_from_android*;
304
209
      mir::input::android::mir_keyboard_action_from_android*;
210
      mir::input::android::mir_keyboard_action_from_android*;
305
210
      mir::input::android::android_keyboard_action_from_mir*;
211
      mir::input::android::android_keyboard_action_from_mir*;
306
212
      mir::input::android::mir_pointer_buttons_from_android*;
307
213
      mir::input::android::android_pointer_buttons_from_mir*;
308
211
      mir::client::DefaultConnectionConfiguration::DefaultConnectionConfiguration*;
214
      mir::client::DefaultConnectionConfiguration::DefaultConnectionConfiguration*;
309
212
      mir::client::DefaultConnectionConfiguration::the_surface_map*;
215
      mir::client::DefaultConnectionConfiguration::the_surface_map*;
310
213
      mir::client::DefaultConnectionConfiguration::the_rpc_channel*;
216
      mir::client::DefaultConnectionConfiguration::the_rpc_channel*;
311
214
217
312
=== modified file 'src/include/common/mir/events/event_private.h'
313
--- src/include/common/mir/events/event_private.h	2015-05-07 19:43:49 +0000
314
+++ src/include/common/mir/events/event_private.h	2015-05-14 18:12:40 +0000
315
@@ -60,14 +60,6 @@
316
60
} MirMotionAction;
60
} MirMotionAction;
317
61
61
318
62
typedef enum {
62
typedef enum {
319
63
    mir_motion_button_primary   = 1 << 0,
320
64
    mir_motion_button_secondary = 1 << 1,
321
65
    mir_motion_button_tertiary  = 1 << 2,
322
66
    mir_motion_button_back      = 1 << 3,
323
67
    mir_motion_button_forward   = 1 << 4
324
68
} MirMotionButton;
325
69
326
70
typedef enum {
327
71
   mir_motion_tool_type_unknown = 0,
63
   mir_motion_tool_type_unknown = 0,
328
72
   mir_motion_tool_type_finger  = 1,
64
   mir_motion_tool_type_finger  = 1,
329
73
   mir_motion_tool_type_stylus  = 2,
65
   mir_motion_tool_type_stylus  = 2,
330
@@ -125,7 +117,7 @@
331
125
    int action;
117
    int action;
332
126
    MirInputEventModifiers modifiers;
118
    MirInputEventModifiers modifiers;
333
127
119
335
128
    MirMotionButton button_state;
120
    MirPointerButtons buttons;
336
129
    std::chrono::nanoseconds event_time;
121
    std::chrono::nanoseconds event_time;
337
130
122
338
131
    size_t pointer_count;
123
    size_t pointer_count;
339
132
124
340
=== modified file 'src/include/common/mir/input/android/event_conversion_helpers.h'
341
--- src/include/common/mir/input/android/event_conversion_helpers.h	2015-05-08 20:44:56 +0000
342
+++ src/include/common/mir/input/android/event_conversion_helpers.h	2015-05-14 18:12:40 +0000
343
@@ -31,13 +31,15 @@
344
31
int32_t android_modifiers_from_mir(MirInputEventModifiers modifiers);
31
int32_t android_modifiers_from_mir(MirInputEventModifiers modifiers);
345
32
32
346
33
MirKeyboardAction mir_keyboard_action_from_android(int32_t android_action, int32_t repeat_count);
33
MirKeyboardAction mir_keyboard_action_from_android(int32_t android_action, int32_t repeat_count);
347
34
348
35
// Mir differentiates between mir_keyboard_action_down
34
// Mir differentiates between mir_keyboard_action_down
349
36
// and mir_keyboard_action_repeat whereas android encodes
35
// and mir_keyboard_action_repeat whereas android encodes
350
37
// keyrepeats as AKEY_EVENT_ACTION_DOWN and a repeatCount of > 0
36
// keyrepeats as AKEY_EVENT_ACTION_DOWN and a repeatCount of > 0
351
38
// Thus when converting from MirKeyboardAction to an android
37
// Thus when converting from MirKeyboardAction to an android
352
39
// action we must also fetch a repeat count for the android event.
38
// action we must also fetch a repeat count for the android event.
353
40
int32_t android_keyboard_action_from_mir(int32_t& repeat_count_out, MirKeyboardAction action);
39
int32_t android_keyboard_action_from_mir(int32_t& repeat_count_out, MirKeyboardAction action);
354
40
355
41
MirPointerButtons mir_pointer_buttons_from_android(int32_t android_state);
356
42
int32_t android_pointer_buttons_from_mir(MirPointerButtons buttons);
357
41
}
43
}
358
42
}
44
}
359
43
}
45
}
360
44
46
361
=== modified file 'src/server/input/android/android_input_dispatcher.cpp'
362
--- src/server/input/android/android_input_dispatcher.cpp	2015-05-08 20:54:52 +0000
363
+++ src/server/input/android/android_input_dispatcher.cpp	2015-05-14 18:12:40 +0000
364
@@ -102,7 +102,7 @@
365
102
            event.motion.action,
102
            event.motion.action,
366
103
            0, /* flags */
103
            0, /* flags */
367
104
            mia::android_modifiers_from_mir(event.motion.modifiers),
104
            mia::android_modifiers_from_mir(event.motion.modifiers),
369
105
            event.motion.button_state,
105
            mia::android_pointer_buttons_from_mir(event.motion.buttons),
370
106
            0, /* edge_flags */
106
            0, /* edge_flags */
371
107
            event.motion.pointer_count,
107
            event.motion.pointer_count,
372
108
            pointer_properties.data(),
108
            pointer_properties.data(),
373
109
109
374
=== modified file 'src/server/input/android/input_sender.cpp'
375
--- src/server/input/android/input_sender.cpp	2015-05-08 20:54:52 +0000
376
+++ src/server/input/android/input_sender.cpp	2015-05-14 18:12:40 +0000
377
@@ -288,7 +288,7 @@
378
288
        0, /* flags */
288
        0, /* flags */
379
289
        0, /* edge flags */
289
        0, /* edge flags */
380
290
        mia::android_modifiers_from_mir(event.modifiers),
290
        mia::android_modifiers_from_mir(event.modifiers),
382
291
        static_cast<int32_t>(event.button_state),
291
        mia::android_pointer_buttons_from_mir(event.buttons),
383
292
        0.0f,  // event.x_offset,
292
        0.0f,  // event.x_offset,
384
293
        0.0f,  // event.y_offset,
293
        0.0f,  // event.y_offset,
385
294
        0, 0, /* unused x/y precision */
294
        0, 0, /* unused x/y precision */
386
295
295
387
=== modified file 'src/server/input/android/input_translator.cpp'
388
--- src/server/input/android/input_translator.cpp	2015-05-07 19:43:49 +0000
389
+++ src/server/input/android/input_translator.cpp	2015-05-14 18:12:40 +0000
390
@@ -147,7 +147,7 @@
391
147
    mir_event.motion.source_id = args->source;
147
    mir_event.motion.source_id = args->source;
392
148
    mir_event.motion.action = args->action;
148
    mir_event.motion.action = args->action;
393
149
    mir_event.motion.modifiers = mia::mir_modifiers_from_android(args->metaState);
149
    mir_event.motion.modifiers = mia::mir_modifiers_from_android(args->metaState);
395
150
    mir_event.motion.button_state = static_cast<MirMotionButton>(args->buttonState);
150
    mir_event.motion.buttons = mia::mir_pointer_buttons_from_android(args->buttonState);
396
151
    mir_event.motion.event_time = args->eventTime;
151
    mir_event.motion.event_time = args->eventTime;
397
152
    mir_event.motion.pointer_count = args->pointerCount;
152
    mir_event.motion.pointer_count = args->pointerCount;
398
153
    for(unsigned int i = 0; i < args->pointerCount; i++)
153
    for(unsigned int i = 0; i < args->pointerCount; i++)
399
154
154
400
=== modified file 'src/server/input/default_configuration.cpp'
401
--- src/server/input/default_configuration.cpp	2015-05-04 10:45:05 +0000
402
+++ src/server/input/default_configuration.cpp	2015-05-14 18:12:40 +0000
403
@@ -426,6 +426,7 @@
404
426
                                            the_input_reading_multiplexer(),
426
                                            the_input_reading_multiplexer(),
405
427
                                            the_main_loop(),
427
                                            the_main_loop(),
406
428
                                            the_touch_visualizer(),
428
                                            the_touch_visualizer(),
407
429
                                            the_cursor_listener(),
408
429
                                            the_input_region());
430
                                            the_input_region());
409
430
                                    });
431
                                    });
410
431
}
432
}
411
@@ -439,6 +440,7 @@
412
439
                                            the_input_reading_multiplexer(),
440
                                            the_input_reading_multiplexer(),
413
440
                                            the_main_loop(),
441
                                            the_main_loop(),
414
441
                                            the_touch_visualizer(),
442
                                            the_touch_visualizer(),
415
443
                                            the_cursor_listener(),
416
442
                                            the_input_region());
444
                                            the_input_region());
417
443
                                    });
445
                                    });
418
444
}
446
}
419
445
447
420
=== modified file 'src/server/input/default_input_device_hub.cpp'
421
--- src/server/input/default_input_device_hub.cpp	2015-04-14 11:08:21 +0000
422
+++ src/server/input/default_input_device_hub.cpp	2015-05-14 18:12:40 +0000
423
@@ -23,6 +23,7 @@
424
23
#include "mir/input/input_dispatcher.h"
23
#include "mir/input/input_dispatcher.h"
425
24
#include "mir/input/input_device.h"
24
#include "mir/input/input_device.h"
426
25
#include "mir/input/input_device_observer.h"
25
#include "mir/input/input_device_observer.h"
427
26
#include "mir/input/cursor_listener.h"
428
26
#include "mir/input/input_region.h"
27
#include "mir/input/input_region.h"
429
27
#include "mir/events/event_private.h"
28
#include "mir/events/event_private.h"
430
28
#include "mir/dispatch/multiplexing_dispatchable.h"
29
#include "mir/dispatch/multiplexing_dispatchable.h"
431
@@ -42,9 +43,10 @@
432
42
    std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
43
    std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
433
43
    std::shared_ptr<mir::ServerActionQueue> const& observer_queue,
44
    std::shared_ptr<mir::ServerActionQueue> const& observer_queue,
434
44
    std::shared_ptr<TouchVisualizer> const& touch_visualizer,
45
    std::shared_ptr<TouchVisualizer> const& touch_visualizer,
435
46
    std::shared_ptr<CursorListener> const& cursor_listener,
436
45
    std::shared_ptr<InputRegion> const& input_region)
47
    std::shared_ptr<InputRegion> const& input_region)
437
46
    : input_dispatcher(input_dispatcher), input_dispatchable{input_multiplexer}, observer_queue(observer_queue),
48
    : input_dispatcher(input_dispatcher), input_dispatchable{input_multiplexer}, observer_queue(observer_queue),
439
47
      touch_visualizer(touch_visualizer), input_region(input_region)
49
      touch_visualizer(touch_visualizer), cursor_listener(cursor_listener), input_region(input_region)
440
48
{
50
{
441
49
}
51
}
442
50
52
443
@@ -163,9 +165,22 @@
444
163
        BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid input event receivd from device"));
165
        BOOST_THROW_EXCEPTION(std::invalid_argument("Invalid input event receivd from device"));
445
164
166
446
165
    update_spots(mir_event_get_input_event(&event));
167
    update_spots(mir_event_get_input_event(&event));
447
168
    notify_cursor_listener(mir_event_get_input_event(&event));
448
166
    dispatcher->dispatch(event);
169
    dispatcher->dispatch(event);
449
167
}
170
}
450
168
171
451
172
void mi::DefaultInputDeviceHub::RegisteredDevice::notify_cursor_listener(MirInputEvent const* event)
452
173
{
453
174
    if (mir_input_event_get_type(event) != mir_input_event_type_pointer)
454
175
        return;
455
176
456
177
    auto pointer_ev = mir_input_event_get_pointer_event(event);
457
178
    hub->cursor_listener->cursor_moved_to(
458
179
        mir_pointer_event_axis_value(pointer_ev, mir_pointer_axis_x),
459
180
        mir_pointer_event_axis_value(pointer_ev, mir_pointer_axis_y)
460
181
        );
461
182
}
462
183
463
169
void mi::DefaultInputDeviceHub::RegisteredDevice::update_spots(MirInputEvent const* event)
184
void mi::DefaultInputDeviceHub::RegisteredDevice::update_spots(MirInputEvent const* event)
464
170
{
185
{
465
171
    if (mir_input_event_get_type(event) != mir_input_event_type_touch)
186
    if (mir_input_event_get_type(event) != mir_input_event_type_touch)
466
172
187
467
=== modified file 'src/server/input/default_input_device_hub.h'
468
--- src/server/input/default_input_device_hub.h	2015-04-14 11:08:21 +0000
469
+++ src/server/input/default_input_device_hub.h	2015-05-14 18:12:40 +0000
470
@@ -46,6 +46,7 @@
471
46
class InputDeviceObserver;
46
class InputDeviceObserver;
472
47
class TouchVisualizer;
47
class TouchVisualizer;
473
48
class InputRegion;
48
class InputRegion;
474
49
class CursorListener;
475
49
50
476
50
class DefaultInputDeviceHub : public InputDeviceRegistry, public InputDeviceHub
51
class DefaultInputDeviceHub : public InputDeviceRegistry, public InputDeviceHub
477
51
{
52
{
478
@@ -54,6 +55,7 @@
479
54
                          std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
55
                          std::shared_ptr<dispatch::MultiplexingDispatchable> const& input_multiplexer,
480
55
                          std::shared_ptr<ServerActionQueue> const& observer_queue,
56
                          std::shared_ptr<ServerActionQueue> const& observer_queue,
481
56
                          std::shared_ptr<TouchVisualizer> const& touch_visualizer,
57
                          std::shared_ptr<TouchVisualizer> const& touch_visualizer,
482
58
                          std::shared_ptr<CursorListener> const& cursor_listener,
483
57
                          std::shared_ptr<InputRegion> const& input_region);
59
                          std::shared_ptr<InputRegion> const& input_region);
484
58
60
485
59
    // InputDeviceRegistry - calls from mi::Platform
61
    // InputDeviceRegistry - calls from mi::Platform
486
@@ -72,6 +74,7 @@
487
72
    std::shared_ptr<dispatch::MultiplexingDispatchable> const input_dispatchable;
74
    std::shared_ptr<dispatch::MultiplexingDispatchable> const input_dispatchable;
488
73
    std::shared_ptr<ServerActionQueue> const observer_queue;
75
    std::shared_ptr<ServerActionQueue> const observer_queue;
489
74
    std::shared_ptr<TouchVisualizer> const touch_visualizer;
76
    std::shared_ptr<TouchVisualizer> const touch_visualizer;
490
77
    std::shared_ptr<CursorListener> const cursor_listener;
491
75
    std::shared_ptr<InputRegion> const input_region;
78
    std::shared_ptr<InputRegion> const input_region;
492
76
79
493
77
    struct RegisteredDevice : public InputSink
80
    struct RegisteredDevice : public InputSink
494
@@ -89,6 +92,7 @@
495
89
        std::vector<TouchVisualizer::Spot> const& spots() const;
92
        std::vector<TouchVisualizer::Spot> const& spots() const;
496
90
    private:
93
    private:
497
91
        void update_spots(MirInputEvent const* event);
94
        void update_spots(MirInputEvent const* event);
498
95
        void notify_cursor_listener(MirInputEvent const* event);
499
92
        static int32_t create_new_device_id();
96
        static int32_t create_new_device_id();
500
93
        int32_t device_id;
97
        int32_t device_id;
501
94
        std::shared_ptr<InputDevice> const device;
98
        std::shared_ptr<InputDevice> const device;
502
95
99
503
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
504
--- tests/acceptance-tests/test_client_input.cpp	2015-05-04 17:33:07 +0000
505
+++ tests/acceptance-tests/test_client_input.cpp	2015-05-14 18:12:40 +0000
506
@@ -16,20 +16,22 @@
507
16
 * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
16
 * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
508
17
 */
17
 */
509
18
18
510
19
#define MIR_INCLUDE_DEPRECATED_EVENT_HEADER
511
20
512
21
#include "mir/input/input_device_info.h"
19
#include "mir/input/input_device_info.h"
513
22
#include "mir/input/event_filter.h"
20
#include "mir/input/event_filter.h"
514
23
#include "mir/input/composite_event_filter.h"
21
#include "mir/input/composite_event_filter.h"
515
24
22
517
25
#include "mir_test_framework/connected_client_with_a_surface.h"
23
#include "mir_test_framework/headless_in_process_server.h"
518
26
#include "mir_test_framework/fake_input_device.h"
24
#include "mir_test_framework/fake_input_device.h"
519
25
#include "mir_test_framework/placement_applying_shell.h"
520
27
#include "mir_test_framework/stub_server_platform_factory.h"
26
#include "mir_test_framework/stub_server_platform_factory.h"
521
28
#include "mir_test/wait_condition.h"
27
#include "mir_test/wait_condition.h"
522
29
#include "mir_test/spin_wait.h"
28
#include "mir_test/spin_wait.h"
523
30
#include "mir_test/event_matchers.h"
29
#include "mir_test/event_matchers.h"
524
31
#include "mir_test/event_factory.h"
30
#include "mir_test/event_factory.h"
525
32
31
526
32
#include "mir_toolkit/mir_client_library.h"
527
33
#include "mir/events/event_builders.h"
528
34
529
33
#include <gtest/gtest.h>
35
#include <gtest/gtest.h>
530
34
#include <gmock/gmock.h>
36
#include <gmock/gmock.h>
531
35
37
532
@@ -41,17 +43,14 @@
533
41
43
534
42
namespace mi = mir::input;
44
namespace mi = mir::input;
535
43
namespace mt = mir::test;
45
namespace mt = mir::test;
536
46
namespace ms = mir::scene;
537
44
namespace mis = mir::input::synthesis;
47
namespace mis = mir::input::synthesis;
538
45
namespace mtf = mir_test_framework;
48
namespace mtf = mir_test_framework;
539
49
namespace geom = mir::geometry;
540
46
50
541
47
namespace
51
namespace
542
48
{
52
{
543
49
53
544
50
struct MockInputHandler
545
51
{
546
52
    MOCK_METHOD1(handle_input, void(MirEvent const*));
547
53
};
548
54
549
55
struct MockEventFilter : public mi::EventFilter
54
struct MockEventFilter : public mi::EventFilter
550
56
{
55
{
551
57
    // Work around GMock wanting to know how to construct MirEvent
56
    // Work around GMock wanting to know how to construct MirEvent
552
@@ -63,71 +62,127 @@
553
63
    }
62
    }
554
64
};
63
};
555
65
64
557
66
struct TestClientInputNew : mtf::ConnectedClientWithASurface
65
const int surface_width = 100;
558
66
const int surface_height = 100;
559
67
560
68
struct Client
561
67
{
69
{
563
68
    void SetUp() override
70
    MirSurface* surface{nullptr};
564
71
565
72
    MOCK_METHOD1(handle_input, void(MirEvent const*));
566
73
    MOCK_METHOD1(handle_keymap, void(MirEvent const*));
567
74
568
75
    Client(std::string const& con, std::string const& name)
569
69
    {
76
    {
573
70
        ConnectedClientWithASurface::SetUp();
77
        connection = mir_connect_sync(con.c_str(), name.c_str());
574
71
78
575
72
        mir_surface_set_event_handler(surface, handle_input, this);
79
        if (!mir_connection_is_valid(connection))
576
80
        {
577
81
            BOOST_THROW_EXCEPTION(
578
82
                std::runtime_error{std::string{"Failed to connect to test server: "} +
579
83
                mir_connection_get_error_message(connection)});
580
84
        }
581
85
        auto spec = mir_connection_create_spec_for_normal_surface(connection, surface_width,
582
86
                                                                  surface_height, mir_pixel_format_abgr_8888);
583
87
        mir_surface_spec_set_name(spec, name.c_str());
584
88
        surface = mir_surface_create_sync(spec);
585
89
        mir_surface_spec_release(spec);
586
90
        if (!mir_surface_is_valid(surface))
587
91
            BOOST_THROW_EXCEPTION(std::runtime_error{std::string{"Failed creating a surface: "}+
588
92
                mir_surface_get_error_message(surface)});
589
93
590
94
        mir_surface_set_event_handler(surface, handle_event, this);
591
73
        mir_buffer_stream_swap_buffers_sync(
95
        mir_buffer_stream_swap_buffers_sync(
592
74
            mir_surface_get_buffer_stream(surface));
96
            mir_surface_get_buffer_stream(surface));
593
75
97
596
76
        wait_for_surface_to_become_focused_and_exposed();
98
        ready_to_accept_events.wait_for_at_most_seconds(4);
597
77
        ready_to_accept_events.wake_up_everyone();
99
        if (!ready_to_accept_events.woken())
598
100
            BOOST_THROW_EXCEPTION(std::runtime_error("Timeout waiting for surface to become focused and exposed"));
599
78
    }
101
    }
600
79
102
602
80
    static void handle_input(MirSurface*, MirEvent const* ev, void* context)
103
    static void handle_event(MirSurface*, MirEvent const* ev, void* context)
603
81
    {
104
    {
605
82
        auto const client = static_cast<TestClientInputNew*>(context);
105
        auto const client = static_cast<Client*>(context);
606
83
        auto type = mir_event_get_type(ev);
106
        auto type = mir_event_get_type(ev);
607
107
        if (type == mir_event_type_surface)
608
108
        {
609
109
            auto surface_event = mir_event_get_surface_event(ev);
610
110
611
111
            if (mir_surface_attrib_focus == mir_surface_event_get_attribute(surface_event) &&
612
112
                1 == mir_surface_event_get_attribute_value(surface_event))
613
113
                client->ready_to_accept_events.wake_up_everyone();
614
114
        }
615
84
        if (type == mir_event_type_input)
115
        if (type == mir_event_type_input)
623
85
            client->handler.handle_input(ev);
116
            client->handle_input(ev);
624
86
    }
117
        if (type == mir_event_type_keymap)
625
87
118
            client->handle_keymap(ev);
626
88
    void wait_for_surface_to_become_focused_and_exposed()
119
    }
627
89
    {
120
    ~Client()
628
90
        bool success = mt::spin_wait_for_condition_or_timeout(
121
    {
629
91
            [&]
122
        mir_surface_release_sync(surface);
630
123
        mir_connection_release(connection);
631
124
    }
632
125
    MirConnection * connection;
633
126
    mir::test::WaitCondition ready_to_accept_events;
634
127
    mir::test::WaitCondition all_events_received;
635
128
};
636
129
637
130
struct TestClientInput : mtf::HeadlessInProcessServer
638
131
{
639
132
    void SetUp() override
640
133
    {
641
134
        initial_display_layout({screen_geometry});
642
135
643
136
        server.wrap_shell(
644
137
            [this](std::shared_ptr<mir::shell::Shell> const& wrapped)
645
92
            {
138
            {
653
93
                return mir_surface_get_visibility(surface) == mir_surface_visibility_exposed &&
139
                return std::make_shared<mtf::PlacementApplyingShell>(
654
94
                       mir_surface_get_focus(surface) == mir_surface_focused;
140
                    wrapped,
655
95
            },
141
                    input_regions, positions, depths);
656
96
            std::chrono::seconds{5});
142
            });
657
97
143
658
98
        if (!success)
144
        HeadlessInProcessServer::SetUp();
659
99
            throw std::runtime_error("Timeout waiting for surface to become focused and exposed");
145
660
146
        depths[first] = ms::DepthId{0};
661
147
        positions[first] = geom::Rectangle{{0,0}, {surface_width, surface_height}};
662
100
    }
148
    }
663
101
149
664
102
    std::unique_ptr<mtf::FakeInputDevice> fake_keyboard{
150
    std::unique_ptr<mtf::FakeInputDevice> fake_keyboard{
665
103
        mtf::add_fake_input_device(mi::InputDeviceInfo{ 0, "keyboard", "keyboard-uid" , mi::DeviceCapability::keyboard})
151
        mtf::add_fake_input_device(mi::InputDeviceInfo{ 0, "keyboard", "keyboard-uid" , mi::DeviceCapability::keyboard})
666
104
        };
152
        };
670
105
    ::testing::NiceMock<MockInputHandler> handler;
153
    std::unique_ptr<mtf::FakeInputDevice> fake_mouse{
671
106
    mir::test::WaitCondition all_events_received;
154
        mtf::add_fake_input_device(mi::InputDeviceInfo{ 0, "mouse", "mouse-uid" , mi::DeviceCapability::pointer})
672
107
    mir::test::WaitCondition ready_to_accept_events;
155
        };
673
156
    std::unique_ptr<mtf::FakeInputDevice> fake_touch_screen{mtf::add_fake_input_device(mi::InputDeviceInfo{
674
157
        0, "touch screen", "touch-screen-uid", mi::DeviceCapability::touchscreen | mi::DeviceCapability::multitouch})};
675
108
158
676
159
    std::string first{"first"};
677
160
    std::string second{"second"};
678
161
    mtf::ClientInputRegions input_regions;
679
162
    mtf::ClientPositions positions;
680
163
    mtf::ClientDepths depths;
681
164
    geom::Rectangle screen_geometry{{0,0}, {1000,800}};
682
109
    std::shared_ptr<MockEventFilter> mock_event_filter = std::make_shared<MockEventFilter>();
165
    std::shared_ptr<MockEventFilter> mock_event_filter = std::make_shared<MockEventFilter>();
683
110
};
166
};
684
111
167
685
112
}
168
}
686
113
169
687
170
using namespace ::testing;
688
114
171
690
115
TEST_F(TestClientInputNew, clients_receive_keys)
172
TEST_F(TestClientInput, clients_receive_keys)
691
116
{
173
{
693
117
    using namespace testing;
174
    Client first_client(new_connection(), first);
694
118
175
695
119
    InSequence seq;
176
    InSequence seq;
707
120
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_R))));
177
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_R))));
708
121
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_M))));
178
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_M))));
709
122
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_M))));
179
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_M))));
710
123
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_R))));
180
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_R))));
711
124
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_i))));
181
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_i))));
712
125
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_i))));
182
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_i))));
713
126
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_r))));
183
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_r))));
714
127
    EXPECT_CALL(handler, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_r)))).WillOnce(
184
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyUpEvent(), mt::KeyOfSymbol(XKB_KEY_r)))).WillOnce(
715
128
        mt::WakeUp(&all_events_received));
185
        mt::WakeUp(&first_client.all_events_received));
705
129
706
130
    ready_to_accept_events.wait_for_at_most_seconds(5);
716
131
186
717
132
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_RIGHTSHIFT));
187
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_RIGHTSHIFT));
718
133
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_M));
188
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_M));
719
@@ -138,38 +193,424 @@
720
138
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_R));
193
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_R));
721
139
    fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_R));
194
    fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_R));
722
140
195
735
141
    all_events_received.wait_for_at_most_seconds(10);
196
    first_client.all_events_received.wait_for_at_most_seconds(10);
736
142
}
197
}
737
143
198
738
144
namespace
199
TEST_F(TestClientInput, clients_receive_us_english_mapped_keys)
739
145
{
200
{
740
146
struct TestClientInputNewEventFilter : public TestClientInputNew
201
    Client first_client(new_connection(), first);
741
147
{
202
742
148
    void SetUp() override
203
    InSequence seq;
743
149
    {
204
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_L))));
744
150
        TestClientInputNew::SetUp();
205
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_dollar))))
745
151
        server.the_composite_event_filter()->append(mock_event_filter);
206
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
746
152
    }
207
747
208
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_LEFTSHIFT));
748
209
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_4));
749
210
    first_client.all_events_received.wait_for_at_most_seconds(10);
750
211
}
751
212
752
213
TEST_F(TestClientInput, clients_receive_pointer_inside_window_and_crossing_events)
753
214
{
754
215
    positions[first] = geom::Rectangle{{0,0}, {surface_width, surface_height}};
755
216
    Client first_client(new_connection(), first);
756
217
757
218
    // We should see the cursor enter
758
219
    InSequence seq;
759
220
    EXPECT_CALL(first_client, handle_input(mt::PointerEnterEvent()));
760
221
    EXPECT_CALL(first_client, handle_input(mt::PointerEventWithPosition(surface_width - 1, surface_height - 1)));
761
222
    EXPECT_CALL(first_client, handle_input(mt::PointerLeaveEvent()))
762
223
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
763
224
    // But we should not receive an event for the second movement outside of our surface!
764
225
765
226
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(surface_width - 1, surface_height - 1));
766
227
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(2, 2));
767
228
768
229
    first_client.all_events_received.wait_for_at_most_seconds(120);
769
230
}
770
231
771
232
TEST_F(TestClientInput, clients_receive_button_events_inside_window)
772
233
{
773
234
    Client first_client(new_connection(), first);
774
235
    // The cursor starts at (0, 0).
775
236
    EXPECT_CALL(first_client, handle_input(mt::ButtonDownEvent(0, 0)))
776
237
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
777
238
778
239
    fake_mouse->emit_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
779
240
780
241
    first_client.all_events_received.wait_for_at_most_seconds(10);
781
242
}
782
243
783
244
TEST_F(TestClientInput, clients_receive_many_button_events_inside_window)
784
245
{
785
246
    Client first_client(new_connection(), first);
786
247
    // The cursor starts at (0, 0).
787
248
788
249
    InSequence seq;
789
250
    auto expect_buttons = [&](MirPointerButtons b) {
790
251
        EXPECT_CALL(first_client, handle_input(mt::ButtonsDown(0, 0, b)));
791
252
    };
792
253
793
254
    MirPointerButtons buttons = mir_pointer_button_primary;
794
255
    expect_buttons(buttons);
795
256
    expect_buttons(buttons |= mir_pointer_button_secondary);
796
257
    expect_buttons(buttons |= mir_pointer_button_tertiary);
797
258
    expect_buttons(buttons |= mir_pointer_button_forward);
798
259
    expect_buttons(buttons |= mir_pointer_button_back);
799
260
    expect_buttons(buttons &= ~mir_pointer_button_back);
800
261
    expect_buttons(buttons &= ~mir_pointer_button_forward);
801
262
    expect_buttons(buttons &= ~mir_pointer_button_tertiary);
802
263
    expect_buttons(buttons &= ~mir_pointer_button_secondary);
803
264
    EXPECT_CALL(first_client, handle_input(mt::ButtonsDown(0, 0, 0))).WillOnce(
804
265
        mt::WakeUp(&first_client.all_events_received));
805
266
806
267
    auto press_button = [&](int button) {
807
268
        fake_mouse->emit_event(mis::a_button_down_event().of_button(button).with_action(mis::EventAction::Down));
808
269
    };
809
270
    auto release_button = [&](int button) {
810
271
        fake_mouse->emit_event(mis::a_button_up_event().of_button(button).with_action(mis::EventAction::Up));
811
272
    };
812
273
    press_button(BTN_LEFT);
813
274
    press_button(BTN_RIGHT);
814
275
    press_button(BTN_MIDDLE);
815
276
    press_button(BTN_FORWARD);
816
277
    press_button(BTN_BACK);
817
278
    release_button(BTN_BACK);
818
279
    release_button(BTN_FORWARD);
819
280
    release_button(BTN_MIDDLE);
820
281
    release_button(BTN_RIGHT);
821
282
    release_button(BTN_LEFT);
822
283
823
284
    first_client.all_events_received.wait_for_at_most_seconds(10);
824
285
}
825
286
826
287
TEST_F(TestClientInput, multiple_clients_receive_pointer_inside_windows)
827
288
{
828
289
    int const screen_width = screen_geometry.size.width.as_int();
829
290
    int const screen_height = screen_geometry.size.height.as_int();
830
291
    int const client_height = screen_height / 2;
831
292
    int const client_width = screen_width / 2;
832
293
833
294
    positions[first] = {{0, 0}, {client_width, client_height}};
834
295
    positions[second] = {{client_width, client_height}, {client_width, client_height}};
835
296
836
297
    Client first_client(new_connection(), first);
837
298
    Client second_client(new_connection(), second);
838
299
839
300
    {
840
301
        InSequence seq;
841
302
        EXPECT_CALL(first_client, handle_input(mt::PointerEnterEvent()));
842
303
        EXPECT_CALL(first_client, handle_input(mt::PointerEventWithPosition(client_width - 1, client_height - 1)));
843
304
        EXPECT_CALL(first_client, handle_input(mt::PointerLeaveEvent()))
844
305
            .WillOnce(mt::WakeUp(&first_client.all_events_received));
845
306
    }
846
307
847
308
    {
848
309
        InSequence seq;
849
310
        EXPECT_CALL(second_client, handle_input(mt::PointerEnterEvent()));
850
311
        EXPECT_CALL(second_client, handle_input(mt::PointerEventWithPosition(client_width - 1, client_height - 1)))
851
312
            .WillOnce(mt::WakeUp(&second_client.all_events_received));
852
313
    }
853
314
854
315
    // In the bounds of the first surface
855
316
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(client_width - 1, client_height - 1));
856
317
    // In the bounds of the second surface
857
318
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(client_width, client_height));
858
319
859
320
    first_client.all_events_received.wait_for_at_most_seconds(2);
860
321
    second_client.all_events_received.wait_for_at_most_seconds(2);
861
322
}
862
323
863
324
TEST_F(TestClientInput, clients_do_not_receive_pointer_outside_input_region)
864
325
{
865
326
    int const client_height = surface_height;
866
327
    int const client_width = surface_width;
867
328
868
329
    input_regions[first] = {{{0, 0}, {client_width - 80, client_height}},
869
330
                            {{client_width - 20, 0}, {client_width - 80, client_height}}};
870
331
871
332
    Client first_client(new_connection(), first);
872
333
873
334
    EXPECT_CALL(first_client, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
874
335
    EXPECT_CALL(first_client, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
875
336
    EXPECT_CALL(first_client, handle_input(mt::PointerMovementEvent())).Times(AnyNumber());
876
337
877
338
    {
878
339
        // We should see two of the three button pairs.
879
340
        InSequence seq;
880
341
        EXPECT_CALL(first_client, handle_input(mt::ButtonDownEvent(1, 1)));
881
342
        EXPECT_CALL(first_client, handle_input(mt::ButtonUpEvent(1, 1)));
882
343
        EXPECT_CALL(first_client, handle_input(mt::ButtonDownEvent(99, 99)));
883
344
        EXPECT_CALL(first_client, handle_input(mt::ButtonUpEvent(99, 99)))
884
345
            .WillOnce(mt::WakeUp(&first_client.all_events_received));
885
346
    }
886
347
887
348
    // First we will move the cursor in to the input region on the left side of
888
349
    // the window. We should see a click here.
889
350
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(1, 1));
890
351
    fake_mouse->emit_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
891
352
    fake_mouse->emit_event(mis::a_button_up_event().of_button(BTN_LEFT));
892
353
893
354
    // Now in to the dead zone in the center of the window. We should not see
894
355
    // a click here.
895
356
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(49, 49));
896
357
    fake_mouse->emit_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
897
358
    fake_mouse->emit_event(mis::a_button_up_event().of_button(BTN_LEFT));
898
359
899
360
    // Now in to the right edge of the window, in the right input region.
900
361
    // Again we should see a click.
901
362
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(49, 49));
902
363
    fake_mouse->emit_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
903
364
    fake_mouse->emit_event(mis::a_button_up_event().of_button(BTN_LEFT));
904
365
905
366
    first_client.all_events_received.wait_for_at_most_seconds(5);
906
367
}
907
368
908
369
TEST_F(TestClientInput, scene_obscure_motion_events_by_stacking)
909
370
{
910
371
    auto smaller_geometry = screen_geometry;
911
372
    smaller_geometry.size.width =
912
373
        geom::Width{screen_geometry.size.width.as_uint32_t() / 2};
913
374
914
375
    positions[first] = screen_geometry;
915
376
    positions[second] = smaller_geometry;
916
377
    depths[second] = ms::DepthId{1};
917
378
918
379
    Client first_client(new_connection(), first);
919
380
    Client second_client(new_connection(), second);
920
381
921
382
    EXPECT_CALL(first_client, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
922
383
    EXPECT_CALL(first_client, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
923
384
    EXPECT_CALL(first_client, handle_input(mt::PointerMovementEvent())).Times(AnyNumber());
924
385
    {
925
386
        // We should only see one button event sequence.
926
387
        InSequence seq;
927
388
        EXPECT_CALL(first_client, handle_input(mt::ButtonDownEvent(501, 1)));
928
389
        EXPECT_CALL(first_client, handle_input(mt::ButtonUpEvent(501, 1)))
929
390
            .WillOnce(mt::WakeUp(&first_client.all_events_received));
930
391
    }
931
392
932
393
    EXPECT_CALL(second_client, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
933
394
    EXPECT_CALL(second_client, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
934
395
    EXPECT_CALL(second_client, handle_input(mt::PointerMovementEvent())).Times(AnyNumber());
935
396
    {
936
397
        // Likewise we should only see one button sequence.
937
398
        InSequence seq;
938
399
        EXPECT_CALL(second_client, handle_input(mt::ButtonDownEvent(1, 1)));
939
400
        EXPECT_CALL(second_client, handle_input(mt::ButtonUpEvent(1, 1)))
940
401
            .WillOnce(mt::WakeUp(&second_client.all_events_received));
941
402
    }
942
403
943
404
    // First we will move the cursor in to the region where client 2 obscures client 1
944
405
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(1, 1));
945
406
    fake_mouse->emit_event(
946
407
        mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
947
408
    fake_mouse->emit_event(mis::a_button_up_event().of_button(BTN_LEFT));
948
409
    // Now we move to the unobscured region of client 1
949
410
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(500, 0));
950
411
    fake_mouse->emit_event(mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
951
412
    fake_mouse->emit_event(mis::a_button_up_event().of_button(BTN_LEFT));
952
413
953
414
    first_client.all_events_received.wait_for_at_most_seconds(5);
954
415
    second_client.all_events_received.wait_for_at_most_seconds(5);
955
416
}
956
417
957
418
TEST_F(TestClientInput, hidden_clients_do_not_receive_pointer_events)
958
419
{
959
420
    depths[second] = ms::DepthId{1};
960
421
    positions[second] = {{0,0}, {surface_width, surface_height}};
961
422
962
423
    Client first_client(new_connection(), first);
963
424
    Client second_client(new_connection(), second);
964
425
965
426
    EXPECT_CALL(second_client, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
966
427
    EXPECT_CALL(second_client, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
967
428
    EXPECT_CALL(second_client, handle_input(mt::PointerEventWithPosition(1, 1)))
968
429
        .WillOnce(mt::WakeUp(&second_client.all_events_received));
969
430
970
431
    EXPECT_CALL(first_client, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
971
432
    EXPECT_CALL(first_client, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
972
433
    EXPECT_CALL(first_client, handle_input(mt::PointerEventWithPosition(2, 2)))
973
434
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
974
435
975
436
    // We send one event and then hide the surface on top before sending the next.
976
437
    // So we expect each of the two surfaces to receive one event
977
438
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(1,1));
978
439
979
440
    second_client.all_events_received.wait_for_at_most_seconds(2);
980
441
981
442
    server.the_shell()->focused_session()->hide();
982
443
983
444
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(1,1));
984
445
    first_client.all_events_received.wait_for_at_most_seconds(2);
985
446
}
986
447
987
448
TEST_F(TestClientInput, clients_receive_pointer_within_coordinate_system_of_window)
988
449
{
989
450
    int const screen_width = screen_geometry.size.width.as_int();
990
451
    int const screen_height = screen_geometry.size.height.as_int();
991
452
    int const client_height = screen_height / 2;
992
453
    int const client_width = screen_width / 2;
993
454
994
455
    positions[first] = {{screen_width / 2, screen_height / 2}, {client_width, client_height}};
995
456
996
457
    Client first_client(new_connection(), first);
997
458
998
459
    InSequence seq;
999
460
    EXPECT_CALL(first_client, handle_input(mt::PointerEnterEvent()));
1000
461
    EXPECT_CALL(first_client, handle_input(mt::PointerEventWithPosition(80, 170)))
1001
462
        .Times(AnyNumber())
1002
463
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
1003
464
1004
465
    server.the_shell()->focused_surface()->move_to(geom::Point{screen_width / 2 - 40, screen_height / 2 - 80});
1005
466
1006
467
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(screen_width / 2 + 40, screen_height / 2 + 90));
1007
468
1008
469
    first_client.all_events_received.wait_for_at_most_seconds(2);
1009
470
}
1010
471
1011
472
// TODO: Consider tests for more input devices with custom mapping (i.e. joysticks...)
1012
473
TEST_F(TestClientInput, usb_direct_input_devices_work)
1013
474
{
1014
475
    float const minimum_touch = mtf::FakeInputDevice::minimum_touch_axis_value;
1015
476
    float const maximum_touch = mtf::FakeInputDevice::maximum_touch_axis_value;
1016
477
    auto const display_width = screen_geometry.size.width.as_float();
1017
478
    auto const display_height = screen_geometry.size.height.as_float();
1018
479
1019
480
    // We place a click 10% in to the touchscreens space in both axis,
1020
481
    // and a second at 0,0. Thus we expect to see a click at
1021
482
    // .1*screen_width/height and a second at zero zero.
1022
483
    float const abs_touch_x_1 = minimum_touch + (maximum_touch - minimum_touch) * 0.1f;
1023
484
    float const abs_touch_y_1 = minimum_touch + (maximum_touch - minimum_touch) * 0.1f;
1024
485
    float const abs_touch_x_2 = 0;
1025
486
    float const abs_touch_y_2 = 0;
1026
487
1027
488
    float const expected_scale_x = display_width / (maximum_touch - minimum_touch + 1.0f);
1028
489
    float const expected_scale_y = display_height / (maximum_touch - minimum_touch + 1.0f);
1029
490
1030
491
    float const expected_motion_x_1 = expected_scale_x * abs_touch_x_1;
1031
492
    float const expected_motion_y_1 = expected_scale_y * abs_touch_y_1;
1032
493
    float const expected_motion_x_2 = expected_scale_x * abs_touch_x_2;
1033
494
    float const expected_motion_y_2 = expected_scale_y * abs_touch_y_2;
1034
495
1035
496
    positions[first] = screen_geometry;
1036
497
1037
498
    Client first_client(new_connection(), first);
1038
499
1039
500
    InSequence seq;
1040
501
    EXPECT_CALL(first_client, handle_input(
1041
502
        mt::TouchEvent(expected_motion_x_1, expected_motion_y_1)));
1042
503
    EXPECT_CALL(first_client, handle_input(
1043
504
        mt::TouchEventInDirection(expected_motion_x_1,
1044
505
                                  expected_motion_y_1,
1045
506
                                  expected_motion_x_2,
1046
507
                                  expected_motion_y_2)))
1047
508
        .Times(AnyNumber())
1048
509
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
1049
510
1050
511
    fake_touch_screen->emit_event(mis::a_touch_event()
1051
512
                                  .at_position({abs_touch_x_1, abs_touch_y_1}));
1052
513
    // Sleep here to trigger more failures (simulate slow machine)
1053
514
    // TODO why would that cause failures?b
1054
515
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
1055
516
    fake_touch_screen->emit_event(mis::a_touch_event()
1056
517
                                  .with_action(mis::TouchParameters::Action::Move)
1057
518
                                  .at_position({abs_touch_x_2, abs_touch_y_2}));
1058
519
1059
520
    first_client.all_events_received.wait_for_at_most_seconds(2);
1060
521
}
1061
522
1062
523
TEST_F(TestClientInput, send_mir_input_events_through_surface)
1063
524
{
1064
525
    Client first_client(new_connection(), first);
1065
526
1066
527
    EXPECT_CALL(first_client, handle_input(mt::KeyDownEvent()))
1067
528
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
1068
529
1069
530
    auto key_event = mir::events::make_event(MirInputDeviceId{0}, std::chrono::nanoseconds(0), mir_keyboard_action_down, 0, KEY_M,
1070
531
        mir_input_event_modifier_none);
1071
532
1072
533
    server.the_shell()->focused_surface()->consume(*key_event);
1073
534
1074
535
    first_client.all_events_received.wait_for_at_most_seconds(2);
1075
536
}
1076
537
1077
538
TEST_F(TestClientInput, clients_receive_keymap_change_events)
1078
539
{
1079
540
    Client first_client(new_connection(), first);
1080
541
1081
542
    xkb_rule_names names;
1082
543
    names.rules = "evdev";
1083
544
    names.model = "pc105";
1084
545
    names.layout = "dvorak";
1085
546
    names.variant = "";
1086
547
    names.options = "";
1087
548
1088
549
    EXPECT_CALL(first_client, handle_keymap(mt::KeymapEventWithRules(names)))
1089
550
        .Times(1)
1090
551
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
1091
552
1092
553
    server.the_shell()->focused_surface()->set_keymap(names);
1093
554
    first_client.all_events_received.wait_for_at_most_seconds(2);
1094
555
}
1095
556
1096
557
TEST_F(TestClientInput, keymap_changes_change_keycode_received)
1097
558
{
1098
559
    Client first_client(new_connection(), first);
1099
560
1100
561
    xkb_rule_names names;
1101
562
    names.rules = "evdev";
1102
563
    names.model = "pc105";
1103
564
    names.layout = "us";
1104
565
    names.variant = "dvorak";
1105
566
    names.options = "";
1106
567
1107
568
    mt::WaitCondition first_event_received,
1108
569
        client_sees_keymap_change;
1109
570
1110
571
    InSequence seq;
1111
572
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_n))));
1112
573
    EXPECT_CALL(first_client, handle_input(mt::KeyUpEvent()))
1113
574
        .WillOnce(mt::WakeUp(&first_event_received));
1114
575
    EXPECT_CALL(first_client, handle_keymap(mt::KeymapEventWithRules(names)))
1115
576
        .WillOnce(mt::WakeUp(&client_sees_keymap_change));
1116
577
1117
578
    EXPECT_CALL(first_client, handle_input(AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_b))));
1118
579
    EXPECT_CALL(first_client, handle_input(mt::KeyUpEvent()))
1119
580
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
1120
581
1121
582
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_N));
1122
583
    fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_N));
1123
584
1124
585
    first_event_received.wait_for_at_most_seconds(60);
1125
586
1126
587
    server.the_shell()->focused_surface()->set_keymap(names);
1127
588
1128
589
    client_sees_keymap_change.wait_for_at_most_seconds(60);
1129
590
1130
591
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_N));
1131
592
    fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_N));
1132
593
1133
594
    first_client.all_events_received.wait_for_at_most_seconds(5);
1134
595
}
1135
596
1136
597
TEST_F(TestClientInput, event_filter_may_consume_events)
1137
598
{
1138
153
    std::shared_ptr<MockEventFilter> mock_event_filter = std::make_shared<MockEventFilter>();
599
    std::shared_ptr<MockEventFilter> mock_event_filter = std::make_shared<MockEventFilter>();
1141
154
};
600
    server.the_composite_event_filter()->append(mock_event_filter);
1140
155
}
1142
156
601
1146
157
TEST_F(TestClientInputNewEventFilter, event_filter_may_consume_events)
602
    Client first_client(new_connection(), first);
1144
158
{
1145
159
    using namespace ::testing;
1147
160
603
1148
161
    InSequence seq;
604
    InSequence seq;
1149
162
    EXPECT_CALL(*mock_event_filter, handle(_)).WillOnce(Return(true));
605
    EXPECT_CALL(*mock_event_filter, handle(_)).WillOnce(Return(true));
1150
163
    EXPECT_CALL(*mock_event_filter, handle(_)).WillOnce(
606
    EXPECT_CALL(*mock_event_filter, handle(_)).WillOnce(
1152
164
            DoAll(mt::WakeUp(&all_events_received), Return(true)));
607
            DoAll(mt::WakeUp(&first_client.all_events_received), Return(true)));
1153
165
608
1154
166
    // Since we handle the events in the filter the client should not receive them.
609
    // Since we handle the events in the filter the client should not receive them.
1158
167
    EXPECT_CALL(handler, handle_input(_)).Times(0);
610
    EXPECT_CALL(first_client, handle_input(_)).Times(0);
1156
168
1157
169
    ready_to_accept_events.wait_for_at_most_seconds(5);
1159
170
611
1160
171
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_M));
612
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_M));
1161
172
    fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_M));
613
    fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_M));
1162
173
614
1164
174
    all_events_received.wait_for_at_most_seconds(10);
615
    first_client.all_events_received.wait_for_at_most_seconds(10);
1165
175
}
616
}
1166
176
617
1167
=== modified file 'tests/acceptance-tests/test_surface_modifications.cpp'
1168
--- tests/acceptance-tests/test_surface_modifications.cpp	2015-05-05 18:01:08 +0000
1169
+++ tests/acceptance-tests/test_surface_modifications.cpp	2015-05-14 18:12:40 +0000
1170
@@ -93,7 +93,6 @@
1171
93
    void generate_alt_click_at(Point const& click_position)
93
    void generate_alt_click_at(Point const& click_position)
1172
94
    {
94
    {
1173
95
        auto const modifiers = mir_input_event_modifier_alt;
95
        auto const modifiers = mir_input_event_modifier_alt;
1174
96
        std::vector<MirPointerButton> depressed_buttons{mir_pointer_button_tertiary};
1175
97
96
1176
98
        auto const x_axis_value = click_position.x.as_float();
97
        auto const x_axis_value = click_position.x.as_float();
1177
99
        auto const y_axis_value = click_position.y.as_float();
98
        auto const y_axis_value = click_position.y.as_float();
1178
@@ -102,7 +101,7 @@
1179
102
        auto const action = mir_pointer_action_button_down;
101
        auto const action = mir_pointer_action_button_down;
1180
103
102
1181
104
        auto const click_event = mev::make_event(device_id, timestamp, modifiers,
103
        auto const click_event = mev::make_event(device_id, timestamp, modifiers,
1183
105
            action, depressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
104
            action, mir_pointer_button_tertiary, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
1184
106
105
1185
107
        server.the_shell()->handle(*click_event);
106
        server.the_shell()->handle(*click_event);
1186
108
    }
107
    }
1187
@@ -110,7 +109,6 @@
1188
110
    void generate_alt_move_to(Point const& drag_position)
109
    void generate_alt_move_to(Point const& drag_position)
1189
111
    {
110
    {
1190
112
        auto const modifiers = mir_input_event_modifier_alt;
111
        auto const modifiers = mir_input_event_modifier_alt;
1191
113
        std::vector<MirPointerButton> depressed_buttons{mir_pointer_button_tertiary};
1192
114
112
1193
115
        auto const x_axis_value = drag_position.x.as_float();
113
        auto const x_axis_value = drag_position.x.as_float();
1194
116
        auto const y_axis_value = drag_position.y.as_float();
114
        auto const y_axis_value = drag_position.y.as_float();
1195
@@ -119,7 +117,7 @@
1196
119
        auto const action = mir_pointer_action_motion;
117
        auto const action = mir_pointer_action_motion;
1197
120
118
1198
121
        auto const drag_event = mev::make_event(device_id, timestamp, modifiers,
119
        auto const drag_event = mev::make_event(device_id, timestamp, modifiers,
1200
122
            action, depressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
120
            action, mir_pointer_button_tertiary, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
1201
123
121
1202
124
        server.the_shell()->handle(*drag_event);
122
        server.the_shell()->handle(*drag_event);
1203
125
    }
123
    }
1204
126
124
1205
=== modified file 'tests/acceptance-tests/test_surface_placement.cpp'
1206
--- tests/acceptance-tests/test_surface_placement.cpp	2015-05-05 18:01:08 +0000
1207
+++ tests/acceptance-tests/test_surface_placement.cpp	2015-05-14 18:12:40 +0000
1208
@@ -121,7 +121,7 @@
1209
121
        MirInputDeviceId const device_id{7};
121
        MirInputDeviceId const device_id{7};
1210
122
122
1211
123
        auto const modifiers = mir_input_event_modifier_none;
123
        auto const modifiers = mir_input_event_modifier_none;
1213
124
        std::vector<MirPointerButton> depressed_buttons{mir_pointer_button_primary};
124
        auto const depressed_buttons = mir_pointer_button_primary;
1214
125
125
1215
126
        auto const x_axis_value = click_position.x.as_float();
126
        auto const x_axis_value = click_position.x.as_float();
1216
127
        auto const y_axis_value = click_position.y.as_float();
127
        auto const y_axis_value = click_position.y.as_float();
1217
128
128
1218
=== modified file 'tests/acceptance-tests/throwback/CMakeLists.txt'
1219
--- tests/acceptance-tests/throwback/CMakeLists.txt	2015-04-13 14:53:35 +0000
1220
+++ tests/acceptance-tests/throwback/CMakeLists.txt	2015-05-14 18:12:40 +0000
1221
@@ -9,7 +9,6 @@
1222
9
9
1223
10
  clients.cpp
10
  clients.cpp
1224
11
  test_client_cursor_api.cpp
11
  test_client_cursor_api.cpp
1225
12
  test_client_input.cpp
1226
13
  test_custom_input_targeter.cpp
12
  test_custom_input_targeter.cpp
1227
14
  test_focus_selection.cpp
13
  test_focus_selection.cpp
1228
15
  test_touchspot_visualization.cpp
14
  test_touchspot_visualization.cpp
1229
16
15
1230
=== removed file 'tests/acceptance-tests/throwback/test_client_input.cpp'
1231
--- tests/acceptance-tests/throwback/test_client_input.cpp	2015-05-05 17:11:45 +0000
1232
+++ tests/acceptance-tests/throwback/test_client_input.cpp	1970-01-01 00:00:00 +0000
1233
@@ -1,704 +0,0 @@
1234
1
/*
1235
2
 * Copyright © 2013-2015 Canonical Ltd.
1236
3
 *
1237
4
 * This program is free software: you can redistribute it and/or modify
1238
5
 * it under the terms of the GNU General Public License version 3 as
1239
6
 * published by the Free Software Foundation.
1240
7
 *
1241
8
 * This program is distributed in the hope that it will be useful,
1242
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
1243
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
1244
11
 * GNU General Public License for more details.
1245
12
 *
1246
13
 * You should have received a copy of the GNU General Public License
1247
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
1248
15
 *
1249
16
 * Authored by: Robert Carr <robert.carr@canonical.com>
1250
17
 *              Andreas Pokorny <andreas.pokorny@canonical.com>
1251
18
 *              Alexandros Frantzis <alexandros.frantzis@canonical.com>
1252
19
 */
1253
20
1254
21
#include "mir/events/event_private.h"
1255
22
#include "mir/shell/shell_wrapper.h"
1256
23
#include "mir/scene/surface_creation_parameters.h"
1257
24
#include "mir/scene/surface.h"
1258
25
#include "mir/scene/session.h"
1259
26
#include "src/server/scene/session_container.h"
1260
27
1261
28
#include "mir_test_framework/in_process_server.h"
1262
29
#include "mir_test_framework/using_stub_client_platform.h"
1263
30
#include "mir_test_framework/fake_event_hub_server_configuration.h"
1264
31
#include "mir_test_framework/declarative_placement_strategy.h"
1265
32
#include "mir_test/wait_condition.h"
1266
33
#include "mir_test/fake_event_hub.h"
1267
34
#include "mir_test/event_matchers.h"
1268
35
#include "mir_test/spin_wait.h"
1269
36
1270
37
#include "mir_toolkit/mir_client_library.h"
1271
38
1272
39
#include <linux/input.h>
1273
40
1274
41
#include <gtest/gtest.h>
1275
42
#include <gmock/gmock.h>
1276
43
#include <cstring>
1277
44
1278
45
namespace mf = mir::frontend;
1279
46
namespace mt = mir::test;
1280
47
namespace mtf = mir_test_framework;
1281
48
namespace mis = mir::input::synthesis;
1282
49
namespace mia = mir::input::android;
1283
50
namespace msh = mir::shell;
1284
51
namespace ms = mir::scene;
1285
52
namespace geom = mir::geometry;
1286
53
1287
54
namespace
1288
55
{
1289
56
1290
57
struct MockInputHandler
1291
58
{
1292
59
    MOCK_METHOD1(handle_input, void(MirEvent const*));
1293
60
};
1294
61
1295
62
struct InputClient
1296
63
{
1297
64
    InputClient(std::string const& connect_string, std::string const& client_name)
1298
65
        : connect_string{connect_string}, client_name{client_name}
1299
66
    {
1300
67
    }
1301
68
1302
69
1303
70
    ~InputClient()
1304
71
    {
1305
72
        if (client_thread.joinable())
1306
73
            client_thread.join();
1307
74
    }
1308
75
1309
76
    void start()
1310
77
    {
1311
78
        client_thread = std::thread{[this] { run(); }};
1312
79
        ready_to_accept_events.wait_for_at_most_seconds(5);
1313
80
    }
1314
81
1315
82
    void run()
1316
83
    {
1317
84
        auto const connection =
1318
85
            mir_connect_sync(connect_string.c_str(), client_name.c_str());
1319
86
1320
87
        auto spec = mir_connection_create_spec_for_normal_surface(connection, surface_width,
1321
88
            surface_height, mir_pixel_format_bgr_888);
1322
89
        mir_surface_spec_set_name(spec, client_name.c_str());
1323
90
        surface = mir_surface_create_sync(spec);
1324
91
        mir_surface_spec_release(spec);
1325
92
1326
93
        mir_surface_set_event_handler(surface, handle_input, this);
1327
94
        mir_buffer_stream_swap_buffers_sync(
1328
95
            mir_surface_get_buffer_stream(surface));
1329
96
1330
97
        wait_for_surface_to_become_focused_and_exposed();
1331
98
1332
99
        ready_to_accept_events.wake_up_everyone();
1333
100
        all_events_received.wait_for_at_most_seconds(10);
1334
101
1335
102
        mir_surface_release_sync(surface);
1336
103
        mir_connection_release(connection);
1337
104
    }
1338
105
1339
106
    static void handle_input(MirSurface*, MirEvent const* ev, void* context)
1340
107
    {
1341
108
        auto const client = static_cast<InputClient*>(context);
1342
109
1343
110
        if (mir_event_get_type(ev) == mir_event_type_surface)
1344
111
            return;
1345
112
1346
113
        client->handler.handle_input(ev);
1347
114
    }
1348
115
1349
116
    void wait_for_surface_to_become_focused_and_exposed()
1350
117
    {
1351
118
        bool success = mt::spin_wait_for_condition_or_timeout(
1352
119
            [&]
1353
120
            {
1354
121
                return mir_surface_get_visibility(surface) == mir_surface_visibility_exposed &&
1355
122
                       mir_surface_get_focus(surface) == mir_surface_focused;
1356
123
            },
1357
124
            std::chrono::seconds{5});
1358
125
1359
126
        if (!success)
1360
127
            throw std::runtime_error("Timeout waiting for surface to become focused and exposed");
1361
128
    }
1362
129
1363
130
    static int const surface_width = 100;
1364
131
    static int const surface_height = 100;
1365
132
1366
133
    std::string const connect_string;
1367
134
    std::string const client_name;
1368
135
1369
136
    std::thread client_thread;
1370
137
    MockInputHandler handler;
1371
138
    mir::test::WaitCondition all_events_received;
1372
139
    mir::test::WaitCondition ready_to_accept_events;
1373
140
    
1374
141
    MirSurface* surface;
1375
142
};
1376
143
1377
144
using ClientInputRegions = std::map<std::string, std::vector<geom::Rectangle>>;
1378
145
1379
146
struct RegionApplyingShell : msh::ShellWrapper
1380
147
{
1381
148
    RegionApplyingShell(
1382
149
        std::shared_ptr<msh::Shell> wrapped_coordinator,
1383
150
        ClientInputRegions const& client_input_regions)
1384
151
        : msh::ShellWrapper(wrapped_coordinator),
1385
152
          client_input_regions(client_input_regions)
1386
153
    {
1387
154
    }
1388
155
1389
156
    mf::SurfaceId create_surface(
1390
157
        std::shared_ptr<ms::Session> const& session,
1391
158
        ms::SurfaceCreationParameters const& params) override
1392
159
    {
1393
160
        auto const id = wrapped->create_surface(session, params);
1394
161
1395
162
        auto const surface = session->surface(id);
1396
163
1397
164
        if (client_input_regions.find(params.name) != client_input_regions.end())
1398
165
            surface->set_input_region(client_input_regions.at(params.name));
1399
166
1400
167
        return id;
1401
168
    }
1402
169
1403
170
    ClientInputRegions const& client_input_regions;
1404
171
};
1405
172
1406
173
struct TestServerConfiguration : mtf::FakeEventHubServerConfiguration
1407
174
{
1408
175
    TestServerConfiguration(geom::Rectangle const& screen_geometry)
1409
176
        : mtf::FakeEventHubServerConfiguration(
1410
177
              std::vector<geom::Rectangle>{screen_geometry})
1411
178
    {
1412
179
    }
1413
180
1414
181
    std::shared_ptr<mir::scene::PlacementStrategy> the_placement_strategy() override
1415
182
    {
1416
183
        return std::make_shared<mtf::DeclarativePlacementStrategy>(
1417
184
            FakeEventHubServerConfiguration::the_placement_strategy(),
1418
185
            client_geometries, client_depths);
1419
186
    }
1420
187
1421
188
    std::shared_ptr<msh::Shell>
1422
189
    wrap_shell(std::shared_ptr<msh::Shell> const& wrapped) override
1423
190
    {
1424
191
        return std::make_shared<RegionApplyingShell>(
1425
192
            wrapped,
1426
193
            client_input_regions);
1427
194
    }
1428
195
1429
196
    mtf::SurfaceGeometries client_geometries;
1430
197
    mtf::SurfaceDepths client_depths;
1431
198
    ClientInputRegions client_input_regions;
1432
199
};
1433
200
1434
201
struct TestClientInput : mtf::InProcessServer
1435
202
{
1436
203
    mir::DefaultServerConfiguration& server_config() override
1437
204
    {
1438
205
        return server_configuration_;
1439
206
    }
1440
207
1441
208
    TestServerConfiguration& test_server_config()
1442
209
    {
1443
210
        return server_configuration_;
1444
211
    }
1445
212
1446
213
    std::shared_ptr<mir::input::android::FakeEventHub> fake_event_hub()
1447
214
    {
1448
215
        return server_configuration_.fake_event_hub;
1449
216
    }
1450
217
1451
218
    std::string const test_client_name_1{"client1"};
1452
219
    std::string const test_client_name_2{"client2"};
1453
220
    geom::Rectangle const screen_geometry{{0, 0}, {1000, 800}};
1454
221
    TestServerConfiguration server_configuration_{screen_geometry};
1455
222
    mtf::UsingStubClientPlatform using_stub_client_platform;
1456
223
};
1457
224
1458
225
}
1459
226
1460
227
TEST_F(TestClientInput, clients_receive_key_input)
1461
228
{
1462
229
    using namespace testing;
1463
230
1464
231
    InputClient client{new_connection(), test_client_name_1};
1465
232
    
1466
233
    InSequence seq;
1467
234
    EXPECT_CALL(client.handler, handle_input(mt::KeyDownEvent())).Times(1);
1468
235
    EXPECT_CALL(client.handler, handle_input(mt::KeyRepeatEvent())).Times(1);
1469
236
    EXPECT_CALL(client.handler, handle_input(mt::KeyRepeatEvent()))
1470
237
        .WillOnce(mt::WakeUp(&client.all_events_received));
1471
238
1472
239
    int const num_events_produced = 3;
1473
240
1474
241
    client.start();
1475
242
1476
243
    for (int i = 0; i < num_events_produced; i++)
1477
244
        fake_event_hub()->synthesize_event(
1478
245
            mis::a_key_down_event().of_scancode(KEY_ENTER));
1479
246
}
1480
247
1481
248
TEST_F(TestClientInput, clients_receive_us_english_mapped_keys)
1482
249
{
1483
250
    using namespace testing;
1484
251
1485
252
    InputClient client{new_connection(), test_client_name_1};
1486
253
1487
254
    InSequence seq;
1488
255
1489
256
    EXPECT_CALL(client.handler,
1490
257
                handle_input(
1491
258
                    AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_Shift_L))));
1492
259
    EXPECT_CALL(client.handler,
1493
260
                handle_input(
1494
261
                    AllOf(mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_dollar))))
1495
262
        .WillOnce(mt::WakeUp(&client.all_events_received));
1496
263
1497
264
    client.start();
1498
265
1499
266
    fake_event_hub()->synthesize_event(
1500
267
        mis::a_key_down_event().of_scancode(KEY_LEFTSHIFT));
1501
268
    fake_event_hub()->synthesize_event(
1502
269
        mis::a_key_down_event().of_scancode(KEY_4));
1503
270
}
1504
271
1505
272
TEST_F(TestClientInput, clients_receive_pointer_inside_window_and_crossing_events)
1506
273
{
1507
274
    using namespace testing;
1508
275
1509
276
    InputClient client{new_connection(), test_client_name_1};
1510
277
1511
278
    InSequence seq;
1512
279
1513
280
    // We should see the cursor enter
1514
281
    EXPECT_CALL(client.handler, handle_input(mt::PointerEnterEvent()));
1515
282
    EXPECT_CALL(client.handler,
1516
283
                handle_input(
1517
284
                    mt::PointerEventWithPosition(
1518
285
                        InputClient::surface_width - 1,
1519
286
                        InputClient::surface_height - 1)));
1520
287
    EXPECT_CALL(client.handler, handle_input(mt::PointerLeaveEvent()))
1521
288
        .WillOnce(mt::WakeUp(&client.all_events_received));
1522
289
    // But we should not receive an event for the second movement outside of our surface!
1523
290
1524
291
    client.start();
1525
292
1526
293
    fake_event_hub()->synthesize_event(
1527
294
        mis::a_pointer_event().with_movement(
1528
295
            InputClient::surface_width - 1,
1529
296
            InputClient::surface_height - 1));
1530
297
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(2,2));
1531
298
}
1532
299
1533
300
TEST_F(TestClientInput, clients_receive_button_events_inside_window)
1534
301
{
1535
302
    using namespace testing;
1536
303
1537
304
    InputClient client{new_connection(), test_client_name_1};
1538
305
1539
306
    // The cursor starts at (0, 0).
1540
307
    EXPECT_CALL(client.handler, handle_input(mt::ButtonDownEvent(0, 0)))
1541
308
        .WillOnce(mt::WakeUp(&client.all_events_received));
1542
309
1543
310
    client.start();
1544
311
1545
312
    fake_event_hub()->synthesize_event(
1546
313
        mis::a_button_down_event()
1547
314
            .of_button(BTN_LEFT)
1548
315
            .with_action(mis::EventAction::Down));
1549
316
}
1550
317
1551
318
TEST_F(TestClientInput, multiple_clients_receive_pointer_inside_windows)
1552
319
{
1553
320
    using namespace testing;
1554
321
1555
322
    int const screen_width = screen_geometry.size.width.as_int();
1556
323
    int const screen_height = screen_geometry.size.height.as_int();
1557
324
    int const client_height = screen_height / 2;
1558
325
    int const client_width = screen_width / 2;
1559
326
1560
327
    test_server_config().client_geometries[test_client_name_1] =
1561
328
        {{0, 0}, {client_width, client_height}};
1562
329
    test_server_config().client_geometries[test_client_name_2] =
1563
330
        {{screen_width / 2, screen_height / 2}, {client_width, client_height}};
1564
331
1565
332
    InputClient client1{new_connection(), test_client_name_1};
1566
333
    InputClient client2{new_connection(), test_client_name_2};
1567
334
1568
335
    {
1569
336
        InSequence seq;
1570
337
        EXPECT_CALL(client1.handler, handle_input(mt::PointerEnterEvent()));
1571
338
        EXPECT_CALL(client1.handler,
1572
339
                    handle_input(
1573
340
                        mt::PointerEventWithPosition(client_width - 1, client_height - 1)));
1574
341
        EXPECT_CALL(client1.handler, handle_input(mt::PointerLeaveEvent()))
1575
342
            .WillOnce(mt::WakeUp(&client1.all_events_received));
1576
343
    }
1577
344
1578
345
    {
1579
346
        InSequence seq;
1580
347
        EXPECT_CALL(client2.handler, handle_input(mt::PointerEnterEvent()));
1581
348
        EXPECT_CALL(client2.handler,
1582
349
                    handle_input(
1583
350
                        mt::PointerEventWithPosition(client_width - 1, client_height - 1)))
1584
351
            .WillOnce(mt::WakeUp(&client2.all_events_received));
1585
352
    }
1586
353
1587
354
    client1.start();
1588
355
    client2.start();
1589
356
1590
357
    // In the bounds of the first surface
1591
358
    fake_event_hub()->synthesize_event(
1592
359
        mis::a_pointer_event().with_movement(screen_width / 2 - 1, screen_height / 2 - 1));
1593
360
    // In the bounds of the second surface
1594
361
    fake_event_hub()->synthesize_event(
1595
362
        mis::a_pointer_event().with_movement(screen_width / 2, screen_height / 2));
1596
363
}
1597
364
1598
365
TEST_F(TestClientInput, clients_do_not_receive_pointer_outside_input_region)
1599
366
{
1600
367
    using namespace testing;
1601
368
1602
369
    int const client_height = InputClient::surface_height;
1603
370
    int const client_width = InputClient::surface_width;
1604
371
1605
372
    test_server_config().client_input_regions[test_client_name_1] = {
1606
373
        {{0, 0}, {client_width - 80, client_height}},
1607
374
        {{client_width - 20, 0}, {client_width - 80, client_height}}};
1608
375
1609
376
    InputClient client{new_connection(), test_client_name_1};
1610
377
1611
378
    EXPECT_CALL(client.handler, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
1612
379
    EXPECT_CALL(client.handler, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
1613
380
    EXPECT_CALL(client.handler, handle_input(mt::PointerMovementEvent())).Times(AnyNumber());
1614
381
1615
382
    {
1616
383
        // We should see two of the three button pairs.
1617
384
        InSequence seq;
1618
385
        EXPECT_CALL(client.handler, handle_input(mt::ButtonDownEvent(1, 1)));
1619
386
        EXPECT_CALL(client.handler, handle_input(mt::ButtonUpEvent(1, 1)));
1620
387
        EXPECT_CALL(client.handler, handle_input(mt::ButtonDownEvent(99, 99)));
1621
388
        EXPECT_CALL(client.handler, handle_input(mt::ButtonUpEvent(99, 99)))
1622
389
            .WillOnce(mt::WakeUp(&client.all_events_received));
1623
390
    }
1624
391
1625
392
    client.start();
1626
393
1627
394
    // First we will move the cursor in to the input region on the left side of
1628
395
    // the window. We should see a click here.
1629
396
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(1, 1));
1630
397
    fake_event_hub()->synthesize_event(
1631
398
        mis::a_button_down_event()
1632
399
            .of_button(BTN_LEFT)
1633
400
            .with_action(mis::EventAction::Down));
1634
401
    fake_event_hub()->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
1635
402
    // Now in to the dead zone in the center of the window. We should not see
1636
403
    // a click here.
1637
404
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(49, 49));
1638
405
    fake_event_hub()->synthesize_event(
1639
406
        mis::a_button_down_event()
1640
407
            .of_button(BTN_LEFT)
1641
408
            .with_action(mis::EventAction::Down));
1642
409
    fake_event_hub()->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
1643
410
    // Now in to the right edge of the window, in the right input region.
1644
411
    // Again we should see a click.
1645
412
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(49, 49));
1646
413
    fake_event_hub()->synthesize_event(
1647
414
        mis::a_button_down_event()
1648
415
            .of_button(BTN_LEFT)
1649
416
            .with_action(mis::EventAction::Down));
1650
417
    fake_event_hub()->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
1651
418
}
1652
419
1653
420
TEST_F(TestClientInput, scene_obscure_motion_events_by_stacking)
1654
421
{
1655
422
    using namespace testing;
1656
423
1657
424
    auto smaller_geometry = screen_geometry;
1658
425
    smaller_geometry.size.width =
1659
426
        geom::Width{screen_geometry.size.width.as_uint32_t() / 2};
1660
427
1661
428
    test_server_config().client_geometries[test_client_name_1] = screen_geometry;
1662
429
    test_server_config().client_geometries[test_client_name_2] = smaller_geometry;
1663
430
    test_server_config().client_depths[test_client_name_1] = ms::DepthId{0};
1664
431
    test_server_config().client_depths[test_client_name_2] = ms::DepthId{1};
1665
432
1666
433
    InputClient client1{new_connection(), test_client_name_1};
1667
434
    InputClient client2{new_connection(), test_client_name_2};
1668
435
1669
436
    EXPECT_CALL(client1.handler, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
1670
437
    EXPECT_CALL(client1.handler, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
1671
438
    EXPECT_CALL(client1.handler, handle_input(mt::PointerMovementEvent())).Times(AnyNumber());
1672
439
    {
1673
440
        // We should only see one button event sequence.
1674
441
        InSequence seq;
1675
442
        EXPECT_CALL(client1.handler, handle_input(mt::ButtonDownEvent(501, 1)));
1676
443
        EXPECT_CALL(client1.handler, handle_input(mt::ButtonUpEvent(501, 1)))
1677
444
            .WillOnce(mt::WakeUp(&client1.all_events_received));
1678
445
    }
1679
446
1680
447
    EXPECT_CALL(client2.handler, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
1681
448
    EXPECT_CALL(client2.handler, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
1682
449
    EXPECT_CALL(client2.handler, handle_input(mt::PointerMovementEvent())).Times(AnyNumber());
1683
450
    {
1684
451
        // Likewise we should only see one button sequence.
1685
452
        InSequence seq;
1686
453
        EXPECT_CALL(client2.handler, handle_input(mt::ButtonDownEvent(1, 1)));
1687
454
        EXPECT_CALL(client2.handler, handle_input(mt::ButtonUpEvent(1, 1)))
1688
455
            .WillOnce(mt::WakeUp(&client2.all_events_received));
1689
456
    }
1690
457
1691
458
    client1.start();
1692
459
    client2.start();
1693
460
1694
461
    // First we will move the cursor in to the region where client 2 obscures client 1
1695
462
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(1, 1));
1696
463
    fake_event_hub()->synthesize_event(
1697
464
        mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
1698
465
    fake_event_hub()->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
1699
466
    // Now we move to the unobscured region of client 1
1700
467
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(500, 0));
1701
468
    fake_event_hub()->synthesize_event(
1702
469
        mis::a_button_down_event().of_button(BTN_LEFT).with_action(mis::EventAction::Down));
1703
470
    fake_event_hub()->synthesize_event(mis::a_button_up_event().of_button(BTN_LEFT));
1704
471
}
1705
472
1706
473
TEST_F(TestClientInput, hidden_clients_do_not_receive_pointer_events)
1707
474
{
1708
475
    using namespace testing;
1709
476
1710
477
    mt::WaitCondition second_client_done;
1711
478
1712
479
    test_server_config().client_depths[test_client_name_1] = ms::DepthId{0};
1713
480
    test_server_config().client_depths[test_client_name_2] = ms::DepthId{1};
1714
481
1715
482
    InputClient client1{new_connection(), test_client_name_1};
1716
483
    InputClient client2{new_connection(), test_client_name_2};
1717
484
1718
485
    EXPECT_CALL(client1.handler, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
1719
486
    EXPECT_CALL(client1.handler, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
1720
487
    EXPECT_CALL(client1.handler, handle_input(mt::PointerEventWithPosition(2, 2)))
1721
488
        .WillOnce(mt::WakeUp(&client1.all_events_received));
1722
489
1723
490
    EXPECT_CALL(client2.handler, handle_input(mt::PointerEnterEvent())).Times(AnyNumber());
1724
491
    EXPECT_CALL(client2.handler, handle_input(mt::PointerLeaveEvent())).Times(AnyNumber());
1725
492
    EXPECT_CALL(client2.handler, handle_input(mt::PointerEventWithPosition(1, 1)))
1726
493
        .WillOnce(DoAll(mt::WakeUp(&second_client_done),
1727
494
                        mt::WakeUp(&client2.all_events_received)));
1728
495
1729
496
    client1.start();
1730
497
    client2.start();
1731
498
1732
499
    // We send one event and then hide the surface on top before sending the next.
1733
500
    // So we expect each of the two surfaces to receive one even
1734
501
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(1,1));
1735
502
    // We use a fence to ensure we do not hide the client
1736
503
    // before event dispatch occurs
1737
504
    second_client_done.wait_for_at_most_seconds(60);
1738
505
1739
506
    server_config().the_session_container()->for_each(
1740
507
        [&](std::shared_ptr<ms::Session> const& session) -> void
1741
508
        {
1742
509
            if (session->name() == test_client_name_2)
1743
510
                session->hide();
1744
511
        });
1745
512
    // As the surface will not be unocludded immediately when the other surface is
1746
513
    // hidden (due to the compositor feedback approach used)
1747
514
    // See bug: https://bugs.launchpad.net/mir/+bug/1408168
1748
515
    client1.wait_for_surface_to_become_focused_and_exposed();
1749
516
1750
517
    fake_event_hub()->synthesize_event(mis::a_pointer_event().with_movement(1,1));
1751
518
}
1752
519
1753
520
TEST_F(TestClientInput, clients_receive_pointer_within_coordinate_system_of_window)
1754
521
{
1755
522
    using namespace testing;
1756
523
1757
524
    int const screen_width = screen_geometry.size.width.as_int();
1758
525
    int const screen_height = screen_geometry.size.height.as_int();
1759
526
    int const client_height = screen_height / 2;
1760
527
    int const client_width = screen_width / 2;
1761
528
1762
529
    test_server_config().client_geometries[test_client_name_1] =
1763
530
        {{screen_width / 2, screen_height / 2}, {client_width, client_height}};
1764
531
1765
532
    InputClient client1{new_connection(), test_client_name_1};
1766
533
1767
534
    InSequence seq;
1768
535
    EXPECT_CALL(client1.handler, handle_input(mt::PointerEnterEvent()));
1769
536
    EXPECT_CALL(client1.handler, handle_input(mt::PointerEventWithPosition(80, 170)))
1770
537
        .Times(AnyNumber())
1771
538
        .WillOnce(mt::WakeUp(&client1.all_events_received));
1772
539
1773
540
    client1.start();
1774
541
1775
542
    server_config().the_session_container()->for_each(
1776
543
        [&](std::shared_ptr<ms::Session> const& session) -> void
1777
544
        {
1778
545
            session->default_surface()->move_to(
1779
546
                geom::Point{screen_width / 2 - 40, screen_height / 2 - 80});
1780
547
        });
1781
548
1782
549
    fake_event_hub()->synthesize_event(
1783
550
        mis::a_pointer_event().with_movement(screen_width / 2 + 40, screen_height / 2 + 90));
1784
551
}
1785
552
1786
553
// TODO: Consider tests for more input devices with custom mapping (i.e. joysticks...)
1787
554
TEST_F(TestClientInput, usb_direct_input_devices_work)
1788
555
{
1789
556
    using namespace ::testing;
1790
557
1791
558
    auto const minimum_touch = mia::FakeEventHub::TouchScreenMinAxisValue;
1792
559
    auto const maximum_touch = mia::FakeEventHub::TouchScreenMaxAxisValue;
1793
560
    auto const display_width = screen_geometry.size.width.as_uint32_t();
1794
561
    auto const display_height = screen_geometry.size.height.as_uint32_t();
1795
562
1796
563
    // We place a click 10% in to the touchscreens space in both axis,
1797
564
    // and a second at 0,0. Thus we expect to see a click at
1798
565
    // .1*screen_width/height and a second at zero zero.
1799
566
    static int const abs_touch_x_1 = minimum_touch + (maximum_touch - minimum_touch) * 0.1;
1800
567
    static int const abs_touch_y_1 = minimum_touch + (maximum_touch - minimum_touch) * 0.1;
1801
568
    static int const abs_touch_x_2 = 0;
1802
569
    static int const abs_touch_y_2 = 0;
1803
570
1804
571
    static float const expected_scale_x =
1805
572
        float(display_width) / (maximum_touch - minimum_touch + 1);
1806
573
    static float const expected_scale_y =
1807
574
        float(display_height) / (maximum_touch - minimum_touch + 1);
1808
575
1809
576
    static float const expected_motion_x_1 = expected_scale_x * abs_touch_x_1;
1810
577
    static float const expected_motion_y_1 = expected_scale_y * abs_touch_y_1;
1811
578
    static float const expected_motion_x_2 = expected_scale_x * abs_touch_x_2;
1812
579
    static float const expected_motion_y_2 = expected_scale_y * abs_touch_y_2;
1813
580
1814
581
    test_server_config().client_geometries[test_client_name_1] = screen_geometry;
1815
582
1816
583
    InputClient client1{new_connection(), test_client_name_1};
1817
584
1818
585
    InSequence seq;
1819
586
    EXPECT_CALL(client1.handler, handle_input(
1820
587
        mt::TouchEvent(expected_motion_x_1, expected_motion_y_1)));
1821
588
    EXPECT_CALL(client1.handler, handle_input(
1822
589
        mt::TouchEventInDirection(expected_motion_x_1,
1823
590
                                  expected_motion_y_1,
1824
591
                                  expected_motion_x_2,
1825
592
                                  expected_motion_y_2)))
1826
593
        .WillOnce(mt::WakeUp(&client1.all_events_received));
1827
594
1828
595
    client1.start();
1829
596
1830
597
    fake_event_hub()->synthesize_event(
1831
598
        mis::a_touch_event().at_position({abs_touch_x_1, abs_touch_y_1}));
1832
599
    // Sleep here to trigger more failures (simulate slow machine)
1833
600
    std::this_thread::sleep_for(std::chrono::milliseconds(10));
1834
601
    fake_event_hub()->synthesize_event(
1835
602
        mis::a_touch_event().at_position({abs_touch_x_2, abs_touch_y_2}));
1836
603
}
1837
604
1838
605
TEST_F(TestClientInput, send_mir_input_events_through_surface)
1839
606
{
1840
607
    InputClient client1{new_connection(), test_client_name_1};
1841
608
1842
609
    EXPECT_CALL(client1.handler, handle_input(mt::KeyDownEvent()))
1843
610
        .WillOnce(mt::WakeUp(&client1.all_events_received));
1844
611
1845
612
    client1.start();
1846
613
1847
614
    server_config().the_session_container()->for_each(
1848
615
        [] (std::shared_ptr<ms::Session> const& session) -> void
1849
616
        {
1850
617
            MirEvent key_event;
1851
618
            std::memset(&key_event, 0, sizeof key_event);
1852
619
            key_event.type = mir_event_type_key;
1853
620
            key_event.key.action = mir_keyboard_action_down;
1854
621
1855
622
            session->default_surface()->consume(key_event);
1856
623
        });
1857
624
}
1858
625
1859
626
TEST_F(TestClientInput, clients_receive_keymap_change_events)
1860
627
{
1861
628
    using namespace testing;
1862
629
1863
630
    mt::WaitCondition first_event_received;
1864
631
    InputClient client{new_connection(), test_client_name_1};
1865
632
1866
633
    xkb_rule_names names;
1867
634
    names.rules = "evdev";
1868
635
    names.model = "pc105";
1869
636
    names.layout = "dvorak";
1870
637
    names.variant = "";
1871
638
    names.options = "";
1872
639
    
1873
640
    InSequence seq;
1874
641
    EXPECT_CALL(client.handler, handle_input(
1875
642
        mt::KeymapEventWithRules(names)))
1876
643
        .Times(1).WillOnce(mt::WakeUp(&client.all_events_received));
1877
644
1878
645
    client.start();
1879
646
1880
647
    server_config().the_session_container()->for_each(
1881
648
        [names] (std::shared_ptr<ms::Session> const& session) -> void
1882
649
        {
1883
650
            session->default_surface()->set_keymap(names);
1884
651
        });
1885
652
}
1886
653
1887
654
1888
655
TEST_F(TestClientInput, keymap_changes_change_keycode_received)
1889
656
{
1890
657
    using namespace testing;
1891
658
1892
659
    xkb_rule_names names;
1893
660
    names.rules = "evdev";
1894
661
    names.model = "pc105";
1895
662
    names.layout = "us";
1896
663
    names.variant = "dvorak";
1897
664
    names.options = "";
1898
665
1899
666
    mt::WaitCondition first_event_received,
1900
667
        client_sees_keymap_change;
1901
668
    InputClient client{new_connection(), test_client_name_1};
1902
669
    
1903
670
    InSequence seq;
1904
671
    EXPECT_CALL(client.handler, handle_input(AllOf(
1905
672
        mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_n)))).Times(1);
1906
673
    EXPECT_CALL(client.handler, handle_input(mt::KeyUpEvent()))
1907
674
        .Times(1).WillOnce(mt::WakeUp(&first_event_received));
1908
675
    EXPECT_CALL(client.handler, handle_input(
1909
676
        mt::KeymapEventWithRules(names)))
1910
677
        .Times(1).WillOnce(mt::WakeUp(&client_sees_keymap_change));
1911
678
    EXPECT_CALL(client.handler, handle_input(AllOf(
1912
679
        mt::KeyDownEvent(), mt::KeyOfSymbol(XKB_KEY_b)))).Times(1);
1913
680
    EXPECT_CALL(client.handler, handle_input(mt::KeyUpEvent()))
1914
681
        .Times(1).WillOnce(mt::WakeUp(&client.all_events_received));
1915
682
1916
683
    client.start();
1917
684
1918
685
    fake_event_hub()->synthesize_event(
1919
686
        mis::a_key_down_event().of_scancode(KEY_N));
1920
687
    fake_event_hub()->synthesize_event(
1921
688
        mis::a_key_up_event().of_scancode(KEY_N));
1922
689
1923
690
    first_event_received.wait_for_at_most_seconds(60);
1924
691
    
1925
692
    server_config().the_session_container()->for_each(
1926
693
        [&names] (std::shared_ptr<ms::Session> const& session) -> void
1927
694
        {
1928
695
            session->default_surface()->set_keymap(names);
1929
696
        });
1930
697
1931
698
    client_sees_keymap_change.wait_for_at_most_seconds(60);
1932
699
1933
700
    fake_event_hub()->synthesize_event(
1934
701
        mis::a_key_down_event().of_scancode(KEY_N));
1935
702
    fake_event_hub()->synthesize_event(
1936
703
        mis::a_key_up_event().of_scancode(KEY_N));
1937
704
}
1938
705
0
1939
=== modified file 'tests/acceptance-tests/throwback/test_custom_input_targeter.cpp'
1940
--- tests/acceptance-tests/throwback/test_custom_input_targeter.cpp	2015-05-07 07:07:20 +0000
1941
+++ tests/acceptance-tests/throwback/test_custom_input_targeter.cpp	2015-05-14 18:12:40 +0000
1942
@@ -40,7 +40,6 @@
1943
40
namespace ms = mir::scene;
40
namespace ms = mir::scene;
1944
41
namespace mi = mir::input;
41
namespace mi = mir::input;
1945
42
namespace mt = mir::test;
42
namespace mt = mir::test;
1946
43
namespace mtd = mt::doubles;
1947
44
namespace mt = mir::test;
43
namespace mt = mir::test;
1948
45
namespace mc = mir::compositor;
44
namespace mc = mir::compositor;
1949
46
namespace mtf = mir_test_framework;
45
namespace mtf = mir_test_framework;
1950
47
46
1951
=== modified file 'tests/include/mir_test/event_matchers.h'
1952
--- tests/include/mir_test/event_matchers.h	2015-05-07 07:07:20 +0000
1953
+++ tests/include/mir_test/event_matchers.h	2015-05-14 18:12:40 +0000
1954
@@ -135,10 +135,9 @@
1955
135
        return false;
135
        return false;
1956
136
    
136
    
1957
137
    if(mir_keyboard_event_modifiers(kev) != modifiers)
137
    if(mir_keyboard_event_modifiers(kev) != modifiers)
1960
138
        {
138
    {
1959
139
            printf("modifiers: %d vs expected %d \n", mir_keyboard_event_modifiers(kev), modifiers);
1961
140
        return false;
139
        return false;
1963
141
        }
140
    }
1964
142
    
141
    
1965
143
    return true;
142
    return true;
1966
144
}
143
}
1967
@@ -229,36 +228,38 @@
1968
229
    return false;
228
    return false;
1969
230
}
229
}
1970
231
230
1971
231
inline bool button_event_matches(MirPointerEvent const* pev, float x, float y, MirPointerAction action, MirPointerButtons button_state,
1972
232
                                  bool check_action = true)
1973
233
{
1974
234
    if (pev == nullptr)
1975
235
        return false;
1976
236
    if (check_action && mir_pointer_event_action(pev) != action)
1977
237
        return false;
1978
238
    if (mir_pointer_event_buttons(pev) != button_state)
1979
239
        return false;
1980
240
    if (mir_pointer_event_axis_value(pev, mir_pointer_axis_x) != x)
1981
241
        return false;
1982
242
    if (mir_pointer_event_axis_value(pev, mir_pointer_axis_y) != y)
1983
243
        return false;
1984
244
    return true;
1985
245
}
1986
246
1987
232
MATCHER_P2(ButtonDownEvent, x, y, "")
247
MATCHER_P2(ButtonDownEvent, x, y, "")
1988
233
{
248
{
1989
234
    auto pev = maybe_pointer_event(to_address(arg));
249
    auto pev = maybe_pointer_event(to_address(arg));
2001
235
    if (pev == nullptr)
250
    return button_event_matches(pev, x, y, mir_pointer_action_button_down, mir_pointer_button_primary);
1991
236
        return false;
1992
237
    if (mir_pointer_event_action(pev) != mir_pointer_action_button_down)
1993
238
        return false;
1994
239
    if (mir_pointer_event_button_state(pev, mir_pointer_button_primary) == false)
1995
240
        return false;
1996
241
    if (mir_pointer_event_axis_value(pev, mir_pointer_axis_x) != x)
1997
242
        return false;
1998
243
    if (mir_pointer_event_axis_value(pev, mir_pointer_axis_y) != y)
1999
244
        return false;
2000
245
    return true;
2002
246
}
251
}
2003
247
252
2004
248
MATCHER_P2(ButtonUpEvent, x, y, "")
253
MATCHER_P2(ButtonUpEvent, x, y, "")
2005
249
{
254
{
2006
250
    auto pev = maybe_pointer_event(to_address(arg));
255
    auto pev = maybe_pointer_event(to_address(arg));
2018
251
    if (pev == nullptr)
256
    return button_event_matches(pev, x, y, mir_pointer_action_button_up, 0);
2019
252
        return false;
257
}
2020
253
    if (mir_pointer_event_action(pev) != mir_pointer_action_button_up)
258
2021
254
        return false;
259
MATCHER_P3(ButtonsDown, x, y, buttons, "")
2022
255
    if (mir_pointer_event_button_state(pev, mir_pointer_button_primary) == true)
260
{
2023
256
        return false;
261
    auto pev = maybe_pointer_event(to_address(arg));
2024
257
    if (mir_pointer_event_axis_value(pev, mir_pointer_axis_x) != x)
262
    return button_event_matches(pev, x, y, mir_pointer_action_button_down, buttons, false);
2014
258
        return false;
2015
259
    if (mir_pointer_event_axis_value(pev, mir_pointer_axis_y) != y)
2016
260
        return false;
2017
261
    return true;
2025
262
}
263
}
2026
263
264
2027
264
MATCHER_P2(TouchEvent, x, y, "")
265
MATCHER_P2(TouchEvent, x, y, "")
2028
@@ -269,9 +270,9 @@
2029
269
270
2030
270
    if (mir_touch_event_action(tev, 0) != mir_touch_action_down)
271
    if (mir_touch_event_action(tev, 0) != mir_touch_action_down)
2031
271
        return false;
272
        return false;
2033
272
    if (mir_touch_event_axis_value(tev, 0, mir_touch_axis_x) != x)
273
    if (std::abs(mir_touch_event_axis_value(tev, 0, mir_touch_axis_x) - x) > 0.5f)
2034
273
        return false;
274
        return false;
2036
274
    if (mir_touch_event_axis_value(tev, 0, mir_touch_axis_y) != y)
275
    if (std::abs(mir_touch_event_axis_value(tev, 0, mir_touch_axis_y) - y) > 0.5f)
2037
275
        return false;
276
        return false;
2038
276
277
2039
277
    return true;
278
    return true;
2040
278
279
2041
=== modified file 'tests/include/mir_test_framework/input_testing_server_configuration.h'
2042
--- tests/include/mir_test_framework/input_testing_server_configuration.h	2015-03-31 09:10:52 +0000
2043
+++ tests/include/mir_test_framework/input_testing_server_configuration.h	2015-05-14 18:12:40 +0000
2044
@@ -31,24 +31,6 @@
2045
31
#include <atomic>
31
#include <atomic>
2046
32
#include <thread>
32
#include <thread>
2047
33
33
2048
34
namespace mir
2049
35
{
2050
36
namespace input
2051
37
{
2052
38
namespace android
2053
39
{
2054
40
class FakeEventHub;
2055
41
}
2056
42
}
2057
43
namespace test
2058
44
{
2059
45
namespace doubles
2060
46
{
2061
47
class FakeEventHubInputConfiguration;
2062
48
}
2063
49
}
2064
50
}
2065
51
2066
52
namespace mir_test_framework
34
namespace mir_test_framework
2067
53
{
35
{
2068
54
36
2069
@@ -61,20 +43,16 @@
2070
61
    void on_start() override;
43
    void on_start() override;
2071
62
    void on_exit() override;
44
    void on_exit() override;
2072
63
45
2073
64
    std::shared_ptr<droidinput::EventHubInterface> the_event_hub() override;
2074
65
    std::shared_ptr<mir::input::InputManager> the_input_manager() override;
46
    std::shared_ptr<mir::input::InputManager> the_input_manager() override;
2075
66
    std::shared_ptr<mir::input::InputDispatcher> the_input_dispatcher() override;
47
    std::shared_ptr<mir::input::InputDispatcher> the_input_dispatcher() override;
2076
67
    std::shared_ptr<mir::shell::InputTargeter> the_input_targeter() override;
48
    std::shared_ptr<mir::shell::InputTargeter> the_input_targeter() override;
2077
68
    std::shared_ptr<mir::input::InputSender> the_input_sender() override;
49
    std::shared_ptr<mir::input::InputSender> the_input_sender() override;
2078
69
50
2079
70
2080
71
protected:
51
protected:
2081
72
    virtual void inject_input() = 0;
52
    virtual void inject_input() = 0;
2082
73
53
2083
74
    void wait_until_client_appears(std::string const& surface_name);
54
    void wait_until_client_appears(std::string const& surface_name);
2084
75
55
2085
76
private:
2086
77
    std::shared_ptr<mir::input::android::FakeEventHub> fake_event_hub;
2087
78
    std::thread input_injection_thread;
56
    std::thread input_injection_thread;
2088
79
};
57
};
2089
80
58
2090
81
59
2091
=== added file 'tests/include/mir_test_framework/placement_applying_shell.h'
2092
--- tests/include/mir_test_framework/placement_applying_shell.h	1970-01-01 00:00:00 +0000
2093
+++ tests/include/mir_test_framework/placement_applying_shell.h	2015-05-14 18:12:40 +0000
2094
@@ -0,0 +1,59 @@
2095
1
/*
2096
2
 * Copyright © 2015 Canonical Ltd.
2097
3
 *
2098
4
 * This program is free software: you can redistribute it and/or modify it
2099
5
 * under the terms of the GNU General Public License version 3,
2100
6
 * as published by the Free Software Foundation.
2101
7
 *
2102
8
 * This program is distributed in the hope that it will be useful,
2103
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2104
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2105
11
 * GNU General Public License for more details.
2106
12
 *
2107
13
 * You should have received a copy of the GNU General Public License
2108
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2109
15
 *
2110
16
 * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
2111
17
 */
2112
18
2113
19
#ifndef MIR_TEST_FRAMEWORK_PLACEMENT_APPLYING_SHELL_H_
2114
20
#define MIR_TEST_FRAMEWORK_PLACEMENT_APPLYING_SHELL_H_
2115
21
2116
22
#include "mir/shell/shell_wrapper.h"
2117
23
#include "mir/geometry/rectangle.h"
2118
24
#include "mir/scene/depth_id.h"
2119
25
2120
26
#include "mir/scene/session.h"
2121
27
#include "mir/scene/surface.h"
2122
28
#include "mir/scene/surface_creation_parameters.h"
2123
29
2124
30
#include <vector>
2125
31
#include <string>
2126
32
#include <map>
2127
33
2128
34
namespace mir_test_framework
2129
35
{
2130
36
using ClientInputRegions = std::map<std::string, std::vector<mir::geometry::Rectangle>>;
2131
37
using ClientPositions = std::map<std::string, mir::geometry::Rectangle>;
2132
38
using ClientDepths = std::map<std::string, mir::scene::DepthId>;
2133
39
2134
40
struct PlacementApplyingShell : mir::shell::ShellWrapper
2135
41
{
2136
42
    PlacementApplyingShell(
2137
43
        std::shared_ptr<mir::shell::Shell> wrapped_coordinator,
2138
44
        ClientInputRegions const& client_input_regions,
2139
45
        ClientPositions const& client_positions,
2140
46
        ClientDepths const& client_depths);
2141
47
2142
48
    mir::frontend::SurfaceId create_surface(
2143
49
        std::shared_ptr<mir::scene::Session> const& session,
2144
50
        mir::scene::SurfaceCreationParameters const& params) override;
2145
51
private:
2146
52
    ClientInputRegions const& client_input_regions;
2147
53
    ClientPositions const& client_positions;
2148
54
    ClientDepths const& client_depths;
2149
55
};
2150
56
2151
57
}
2152
58
2153
59
#endif
2154
0
60
2155
=== modified file 'tests/integration-tests/input/CMakeLists.txt'
2156
--- tests/integration-tests/input/CMakeLists.txt	2015-04-16 22:11:07 +0000
2157
+++ tests/integration-tests/input/CMakeLists.txt	2015-05-14 18:12:40 +0000
2158
@@ -1,12 +1,9 @@
2159
1
list(
1
list(
2160
2
  APPEND INTEGRATION_TESTS_SRCS
2
  APPEND INTEGRATION_TESTS_SRCS
2161
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_configuring_input_manager.cpp
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_configuring_input_manager.cpp
2162
4
  ${CMAKE_CURRENT_SOURCE_DIR}/test_cursor_listener.cpp
2163
4
)
5
)
2164
5
6
2165
6
if(NOT MIR_TEST_PLATFORM STREQUAL "android")
2166
7
  add_subdirectory(android)
2167
8
endif()
2168
9
2169
10
set(
7
set(
2170
11
  INTEGRATION_TESTS_SRCS
8
  INTEGRATION_TESTS_SRCS
2171
12
  ${INTEGRATION_TESTS_SRCS}
9
  ${INTEGRATION_TESTS_SRCS}
2172
13
10
2173
=== removed directory 'tests/integration-tests/input/android'
2174
=== removed file 'tests/integration-tests/input/android/CMakeLists.txt'
2175
--- tests/integration-tests/input/android/CMakeLists.txt	2015-05-06 12:57:11 +0000
2176
+++ tests/integration-tests/input/android/CMakeLists.txt	1970-01-01 00:00:00 +0000
2177
@@ -1,9 +0,0 @@
2178
1
list(
2179
2
  APPEND INTEGRATION_TESTS_SRCS
2180
3
  ${CMAKE_CURRENT_SOURCE_DIR}/test_android_cursor_listener.cpp
2181
4
)
2182
5
2183
6
set(
2184
7
  INTEGRATION_TESTS_SRCS
2185
8
  ${INTEGRATION_TESTS_SRCS}
2186
9
  PARENT_SCOPE)
2187
10
0
2188
=== renamed file 'tests/integration-tests/input/android/test_android_cursor_listener.cpp' => 'tests/integration-tests/input/test_cursor_listener.cpp'
2189
--- tests/integration-tests/input/android/test_android_cursor_listener.cpp	2015-04-20 20:07:52 +0000
2190
+++ tests/integration-tests/input/test_cursor_listener.cpp	2015-05-14 18:12:40 +0000
2191
@@ -20,8 +20,10 @@
2192
20
#include "mir/events/event_private.h"
20
#include "mir/events/event_private.h"
2193
21
21
2194
22
#include "mir_test/fake_shared.h"
22
#include "mir_test/fake_shared.h"
2197
23
#include "mir_test/fake_event_hub.h"
23
#include "mir_test_framework/fake_input_device.h"
2198
24
#include "mir_test_framework/fake_event_hub_server_configuration.h"
24
#include "mir_test_framework/stubbed_server_configuration.h"
2199
25
#include "mir_test_framework/stub_server_platform_factory.h"
2200
26
#include "mir_test_framework/temporary_environment_value.h"
2201
25
#include "mir_test_doubles/stub_input_enumerator.h"
27
#include "mir_test_doubles/stub_input_enumerator.h"
2202
26
#include "mir_test_doubles/stub_touch_visualizer.h"
28
#include "mir_test_doubles/stub_touch_visualizer.h"
2203
27
#include "mir_test/wait_condition.h"
29
#include "mir_test/wait_condition.h"
2204
@@ -30,17 +32,18 @@
2205
30
#include "mir/input/cursor_listener.h"
32
#include "mir/input/cursor_listener.h"
2206
31
#include "mir/input/input_dispatcher.h"
33
#include "mir/input/input_dispatcher.h"
2207
32
#include "mir/input/input_manager.h"
34
#include "mir/input/input_manager.h"
2208
35
#include "mir/input/input_device_info.h"
2209
36
#include "mir_test_framework/executable_path.h"
2210
33
37
2211
34
#include <gmock/gmock.h>
38
#include <gmock/gmock.h>
2212
35
#include <gtest/gtest.h>
39
#include <gtest/gtest.h>
2213
36
40
2214
37
#include <thread>
41
#include <thread>
2215
42
#include <cstdlib>
2216
38
43
2217
39
namespace mi = mir::input;
44
namespace mi = mir::input;
2218
40
namespace mia = mir::input::android;
2219
41
namespace mis = mir::input::synthesis;
45
namespace mis = mir::input::synthesis;
2220
42
namespace mt = mir::test;
46
namespace mt = mir::test;
2221
43
namespace mtd = mir::test::doubles;
2222
44
namespace mtf = mir_test_framework;
47
namespace mtf = mir_test_framework;
2223
45
48
2224
46
namespace
49
namespace
2225
@@ -54,8 +57,11 @@
2226
54
    ~MockCursorListener() noexcept {}
57
    ~MockCursorListener() noexcept {}
2227
55
};
58
};
2228
56
59
2230
57
struct AndroidCursorListenerIntegrationTest : testing::Test, mtf::FakeEventHubServerConfiguration
60
struct CursorListenerIntegrationTest : testing::Test, mtf::StubbedServerConfiguration
2231
58
{
61
{
2232
62
    mtf::TemporaryEnvironmentValue input_lib{"MIR_SERVER_PLATFORM_INPUT_LIB", mtf::server_platform("input-stub.so").c_str()};
2233
63
    mtf::TemporaryEnvironmentValue real_input{"MIR_SERVER_TESTS_USE_REAL_INPUT", "1"};
2234
64
2235
59
    bool is_key_repeat_enabled() const override
65
    bool is_key_repeat_enabled() const override
2236
60
    {
66
    {
2237
61
        return false;
67
        return false;
2238
@@ -83,11 +89,15 @@
2239
83
    MockCursorListener cursor_listener;
89
    MockCursorListener cursor_listener;
2240
84
    std::shared_ptr<mi::InputManager> input_manager;
90
    std::shared_ptr<mi::InputManager> input_manager;
2241
85
    std::shared_ptr<mi::InputDispatcher> input_dispatcher;
91
    std::shared_ptr<mi::InputDispatcher> input_dispatcher;
2242
92
2243
93
    std::unique_ptr<mtf::FakeInputDevice> fake_mouse{
2244
94
        mtf::add_fake_input_device(mi::InputDeviceInfo{ 0, "mouse", "mouse-uid" , mi::DeviceCapability::pointer})
2245
95
        };
2246
86
};
96
};
2247
87
97
2248
88
}
98
}
2249
89
99
2251
90
TEST_F(AndroidCursorListenerIntegrationTest, cursor_listener_receives_motion)
100
TEST_F(CursorListenerIntegrationTest, cursor_listener_receives_motion)
2252
91
{
101
{
2253
92
    using namespace ::testing;
102
    using namespace ::testing;
2254
93
103
2255
@@ -98,10 +108,7 @@
2256
98
108
2257
99
    EXPECT_CALL(cursor_listener, cursor_moved_to(x, y)).Times(1).WillOnce(mt::WakeUp(wait_condition));
109
    EXPECT_CALL(cursor_listener, cursor_moved_to(x, y)).Times(1).WillOnce(mt::WakeUp(wait_condition));
2258
100
110
2263
101
    fake_event_hub->synthesize_builtin_cursor_added();
111
    fake_mouse->emit_event(mis::a_pointer_event().with_movement(x, y));
2260
102
    fake_event_hub->synthesize_device_scan_complete();
2261
103
2262
104
    fake_event_hub->synthesize_event(mis::a_pointer_event().with_movement(x, y));
2264
105
112
2265
106
    wait_condition->wait_for_at_most_seconds(10);
113
    wait_condition->wait_for_at_most_seconds(10);
2266
107
}
114
}
2267
108
115
2268
=== modified file 'tests/mir_test_framework/CMakeLists.txt'
2269
--- tests/mir_test_framework/CMakeLists.txt	2015-04-30 11:36:36 +0000
2270
+++ tests/mir_test_framework/CMakeLists.txt	2015-05-14 18:12:40 +0000
2271
@@ -46,6 +46,7 @@
2272
46
  fake_event_hub_server_configuration.cpp
46
  fake_event_hub_server_configuration.cpp
2273
47
  any_surface.cpp
47
  any_surface.cpp
2274
48
  headless_nested_server_runner.cpp
48
  headless_nested_server_runner.cpp
2275
49
  placement_applying_shell.cpp
2276
49
)
50
)
2277
50
51
2278
51
list(APPEND TEST_FRAMEWORK_SRCS
52
list(APPEND TEST_FRAMEWORK_SRCS
2279
52
53
2280
=== modified file 'tests/mir_test_framework/fake_input_device_impl.cpp'
2281
--- tests/mir_test_framework/fake_input_device_impl.cpp	2015-05-07 20:41:25 +0000
2282
+++ tests/mir_test_framework/fake_input_device_impl.cpp	2015-05-14 18:12:40 +0000
2283
@@ -144,7 +144,7 @@
2284
144
144
2285
145
mtf::FakeInputDeviceImpl::InputDevice::InputDevice(mi::InputDeviceInfo const& info,
145
mtf::FakeInputDeviceImpl::InputDevice::InputDevice(mi::InputDeviceInfo const& info,
2286
146
                                                   std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable)
146
                                                   std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable)
2288
147
    : info(info), queue{dispatchable}
147
    : info(info), queue{dispatchable}, buttons{0}
2289
148
{
148
{
2290
149
}
149
}
2291
150
150
2292
@@ -197,12 +197,12 @@
2293
197
{
197
{
2294
198
    if (action == synthesis::EventAction::Down)
198
    if (action == synthesis::EventAction::Down)
2295
199
    {
199
    {
2297
200
        buttons.push_back(button);
200
        buttons |= button;
2298
201
        return mir_pointer_action_button_down;
201
        return mir_pointer_action_button_down;
2299
202
    }
202
    }
2300
203
    else
203
    else
2301
204
    {
204
    {
2303
205
        buttons.erase(remove(begin(buttons), end(buttons), button));
205
        buttons &= ~button;
2304
206
        return mir_pointer_action_button_up;
206
        return mir_pointer_action_button_up;
2305
207
    }
207
    }
2306
208
}
208
}
2307
209
209
2308
=== modified file 'tests/mir_test_framework/fake_input_device_impl.h'
2309
--- tests/mir_test_framework/fake_input_device_impl.h	2015-05-04 07:28:06 +0000
2310
+++ tests/mir_test_framework/fake_input_device_impl.h	2015-05-14 18:12:40 +0000
2311
@@ -25,8 +25,6 @@
2312
25
#include "mir/input/input_device_info.h"
25
#include "mir/input/input_device_info.h"
2313
26
#include "mir/geometry/point.h"
26
#include "mir/geometry/point.h"
2314
27
27
2315
28
#include <vector>
2316
29
2317
30
namespace mir
28
namespace mir
2318
31
{
29
{
2319
32
namespace dispatch
30
namespace dispatch
2320
@@ -76,7 +74,7 @@
2321
76
        std::shared_ptr<mir::dispatch::Dispatchable> const queue;
74
        std::shared_ptr<mir::dispatch::Dispatchable> const queue;
2322
77
        uint32_t modifiers{0};
75
        uint32_t modifiers{0};
2323
78
        mir::geometry::Point pos, scroll;
76
        mir::geometry::Point pos, scroll;
2325
79
        std::vector<MirPointerButton> buttons;
77
        MirPointerButtons buttons;
2326
80
    };
78
    };
2327
81
    std::shared_ptr<mir::dispatch::ActionQueue> queue;
79
    std::shared_ptr<mir::dispatch::ActionQueue> queue;
2328
82
    std::shared_ptr<InputDevice> device;
80
    std::shared_ptr<InputDevice> device;
2329
83
81
2330
=== modified file 'tests/mir_test_framework/input_testing_server_options.cpp'
2331
--- tests/mir_test_framework/input_testing_server_options.cpp	2015-03-31 02:35:42 +0000
2332
+++ tests/mir_test_framework/input_testing_server_options.cpp	2015-05-14 18:12:40 +0000
2333
@@ -24,7 +24,6 @@
2334
24
#include "mir/frontend/session.h"
24
#include "mir/frontend/session.h"
2335
25
#include "mir/input/composite_event_filter.h"
25
#include "mir/input/composite_event_filter.h"
2336
26
26
2337
27
#include "mir_test/fake_event_hub.h"
2338
28
#include "mir_test/wait_condition.h"
27
#include "mir_test/wait_condition.h"
2339
29
28
2340
30
#include <boost/throw_exception.hpp>
29
#include <boost/throw_exception.hpp>
2341
@@ -41,7 +40,6 @@
2342
41
namespace ms = mir::shell;
40
namespace ms = mir::shell;
2343
42
namespace mia = mi::android;
41
namespace mia = mi::android;
2344
43
namespace geom = mir::geometry;
42
namespace geom = mir::geometry;
2345
44
namespace mtd = mir::test::doubles;
2346
45
43
2347
46
mtf::InputTestingServerConfiguration::InputTestingServerConfiguration()
44
mtf::InputTestingServerConfiguration::InputTestingServerConfiguration()
2348
47
{
45
{
2349
@@ -96,18 +94,3 @@
2350
96
{
94
{
2351
97
    return DefaultServerConfiguration::the_input_sender();
95
    return DefaultServerConfiguration::the_input_sender();
2352
98
}
96
}
2353
99
2354
100
std::shared_ptr<droidinput::EventHubInterface> mtf::InputTestingServerConfiguration::the_event_hub()
2355
101
{
2356
102
    if (!fake_event_hub)
2357
103
    {
2358
104
        fake_event_hub = std::make_shared<mia::FakeEventHub>();
2359
105
2360
106
        fake_event_hub->synthesize_builtin_keyboard_added();
2361
107
        fake_event_hub->synthesize_builtin_cursor_added();
2362
108
        fake_event_hub->synthesize_usb_touchscreen_added();
2363
109
        fake_event_hub->synthesize_device_scan_complete();
2364
110
    }
2365
111
2366
112
    return fake_event_hub;
2367
113
}
2368
114
97
2369
=== added file 'tests/mir_test_framework/placement_applying_shell.cpp'
2370
--- tests/mir_test_framework/placement_applying_shell.cpp	1970-01-01 00:00:00 +0000
2371
+++ tests/mir_test_framework/placement_applying_shell.cpp	2015-05-14 18:12:40 +0000
2372
@@ -0,0 +1,59 @@
2373
1
/*
2374
2
 * Copyright © 2015 Canonical Ltd.
2375
3
 *
2376
4
 * This program is free software: you can redistribute it and/or modify it
2377
5
 * under the terms of the GNU General Public License version 3,
2378
6
 * as published by the Free Software Foundation.
2379
7
 *
2380
8
 * This program is distributed in the hope that it will be useful,
2381
9
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
2382
10
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
2383
11
 * GNU General Public License for more details.
2384
12
 *
2385
13
 * You should have received a copy of the GNU General Public License
2386
14
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
2387
15
 *
2388
16
 * Authored by: Andreas Pokorny <andreas.pokorny@canonical.com>
2389
17
 */
2390
18
2391
19
#include "mir_test_framework/placement_applying_shell.h"
2392
20
2393
21
namespace mtf = mir_test_framework;
2394
22
2395
23
mtf::PlacementApplyingShell::PlacementApplyingShell(std::shared_ptr<mir::shell::Shell> wrapped_coordinator,
2396
24
                                                    ClientInputRegions const& client_input_regions,
2397
25
                                                    ClientPositions const& client_positions,
2398
26
                                                    ClientDepths const& client_depths) :
2399
27
    mir::shell::ShellWrapper(wrapped_coordinator),
2400
28
    client_input_regions(client_input_regions),
2401
29
    client_positions(client_positions),
2402
30
    client_depths(client_depths)
2403
31
{
2404
32
}
2405
33
2406
34
mir::frontend::SurfaceId mtf::PlacementApplyingShell::create_surface(
2407
35
        std::shared_ptr<mir::scene::Session> const& session,
2408
36
        mir::scene::SurfaceCreationParameters const& params)
2409
37
{
2410
38
    auto creation_parameters = params;
2411
39
2412
40
    auto depth = client_depths.find(params.name);
2413
41
    if (depth != client_depths.end())
2414
42
        creation_parameters.depth = depth->second;
2415
43
2416
44
    auto const id = wrapped->create_surface(session, creation_parameters);
2417
45
    auto const surface = session->surface(id);
2418
46
2419
47
    auto position= client_positions.find(params.name);
2420
48
    if (position != client_positions.end())
2421
49
    {
2422
50
        surface->move_to(position->second.top_left);
2423
51
        surface->resize(position->second.size);
2424
52
    }
2425
53
2426
54
    auto regions = client_input_regions.find(params.name);
2427
55
    if (regions != client_input_regions.end())
2428
56
        surface->set_input_region(regions->second);
2429
57
2430
58
    return id;
2431
59
}
2432
0
60
2433
=== modified file 'tests/unit-tests/input/android/test_android_input_dispatcher.cpp'
2434
--- tests/unit-tests/input/android/test_android_input_dispatcher.cpp	2015-05-05 18:01:08 +0000
2435
+++ tests/unit-tests/input/android/test_android_input_dispatcher.cpp	2015-05-14 18:12:40 +0000
2436
@@ -173,15 +173,16 @@
2437
173
    std::memset(expected_coords, 0, sizeof(expected_coords));
173
    std::memset(expected_coords, 0, sizeof(expected_coords));
2438
174
    std::memset(expected_properties, 0, sizeof(expected_properties));
174
    std::memset(expected_properties, 0, sizeof(expected_properties));
2439
175
    MirEvent event;
175
    MirEvent event;
2440
176
    std::memset(&event, 0, sizeof(event));
2441
177
    
2442
176
    event.type = mir_event_type_motion;
178
    event.type = mir_event_type_motion;
2443
177
    event.motion.pointer_count = 1;
179
    event.motion.pointer_count = 1;
2444
178
    event.motion.event_time = std::chrono::nanoseconds(2);
180
    event.motion.event_time = std::chrono::nanoseconds(2);
2445
179
    event.motion.device_id = 3;
181
    event.motion.device_id = 3;
2446
180
    event.motion.source_id = 4;
182
    event.motion.source_id = 4;
2447
181
    event.motion.action = mir_motion_action_scroll;
183
    event.motion.action = mir_motion_action_scroll;
2451
182
    event.motion.modifiers = mir_input_event_modifier_shift,
184
    event.motion.modifiers = mir_input_event_modifier_shift;
2452
183
    event.motion.button_state =
185
    event.motion.buttons = mir_pointer_button_forward | mir_pointer_button_secondary;
2450
184
        static_cast<MirMotionButton>(mir_motion_button_forward | mir_motion_button_secondary);
2453
185
186
2454
186
    auto & pointer = event.motion.pointer_coordinates[0];
187
    auto & pointer = event.motion.pointer_coordinates[0];
2455
187
    pointer.id = 1;
188
    pointer.id = 1;
2456
@@ -215,7 +216,7 @@
2457
215
                                          event.motion.action,
216
                                          event.motion.action,
2458
216
                                          0, /* flags */
217
                                          0, /* flags */
2459
217
                                          AMETA_SHIFT_ON,
218
                                          AMETA_SHIFT_ON,
2461
218
                                          event.motion.button_state,
219
                                          AMOTION_EVENT_BUTTON_FORWARD | AMOTION_EVENT_BUTTON_SECONDARY,
2462
219
                                          0, /* edge_flags */
220
                                          0, /* edge_flags */
2463
220
                                          event.motion.pointer_count,
221
                                          event.motion.pointer_count,
2464
221
                                          expected_properties,
222
                                          expected_properties,
2465
222
223
2466
=== modified file 'tests/unit-tests/input/android/test_android_input_lexicon.cpp'
2467
--- tests/unit-tests/input/android/test_android_input_lexicon.cpp	2015-05-05 18:01:08 +0000
2468
+++ tests/unit-tests/input/android/test_android_input_lexicon.cpp	2015-05-14 18:12:40 +0000
2469
@@ -78,7 +78,7 @@
2470
78
    const int32_t flags = 4;
78
    const int32_t flags = 4;
2471
79
    const int32_t edge_flags = 5;
79
    const int32_t edge_flags = 5;
2472
80
    const int32_t meta_state = 6;
80
    const int32_t meta_state = 6;
2474
81
    const int32_t button_state = 7;
81
    const int32_t button_state = 0;
2475
82
    const float x_offset = 8;
82
    const float x_offset = 8;
2476
83
    const float y_offset = 9;
83
    const float y_offset = 9;
2477
84
    const float x_precision = 10;
84
    const float x_precision = 10;
2478
@@ -134,7 +134,6 @@
2479
134
134
2480
135
    auto mir_motion_ev = &mir_ev.motion;
135
    auto mir_motion_ev = &mir_ev.motion;
2481
136
136
2482
137
    EXPECT_EQ(mir_motion_ev->button_state, button_state);
2483
138
    EXPECT_EQ(mir_motion_ev->event_time, event_time);
137
    EXPECT_EQ(mir_motion_ev->event_time, event_time);
2484
139
138
2485
140
    EXPECT_EQ(mir_motion_ev->pointer_count, pointer_count);
139
    EXPECT_EQ(mir_motion_ev->pointer_count, pointer_count);
2486
@@ -170,7 +169,6 @@
2487
170
    const int32_t flags = 4;
169
    const int32_t flags = 4;
2488
171
    const int32_t edge_flags = 5;
170
    const int32_t edge_flags = 5;
2489
172
    const int32_t meta_state = 6;
171
    const int32_t meta_state = 6;
2490
173
    const int32_t button_state = 7;
2491
174
    const float x_offset = 8;
172
    const float x_offset = 8;
2492
175
    const float y_offset = 9;
173
    const float y_offset = 9;
2493
176
    const float x_precision = 10;
174
    const float x_precision = 10;
2494
@@ -223,7 +221,7 @@
2495
223
    }
221
    }
2496
224
222
2497
225
    android_motion_ev->initialize(device_id, source_id, action, flags,
223
    android_motion_ev->initialize(device_id, source_id, action, flags,
2499
226
                                  edge_flags, meta_state, button_state,
224
                                  edge_flags, meta_state, 0,
2500
227
                                  x_offset, y_offset, x_precision, y_precision,
225
                                  x_offset, y_offset, x_precision, y_precision,
2501
228
                                  down_time, event_time, pointer_count,
226
                                  down_time, event_time, pointer_count,
2502
229
                                  pointer_properties, pointer_coords);
227
                                  pointer_properties, pointer_coords);
2503
@@ -241,7 +239,6 @@
2504
241
239
2505
242
    auto mir_motion_ev = &mir_ev.motion;
240
    auto mir_motion_ev = &mir_ev.motion;
2506
243
241
2507
244
    EXPECT_EQ(mir_motion_ev->button_state, button_state);
2508
245
    EXPECT_EQ(mir_motion_ev->event_time, event_time);
242
    EXPECT_EQ(mir_motion_ev->event_time, event_time);
2509
246
    EXPECT_EQ(mir_motion_ev->pointer_count, pointer_count);
243
    EXPECT_EQ(mir_motion_ev->pointer_count, pointer_count);
2510
247
244
2511
248
245
2512
=== modified file 'tests/unit-tests/input/android/test_input_translator.cpp'
2513
--- tests/unit-tests/input/android/test_input_translator.cpp	2015-05-07 19:43:49 +0000
2514
+++ tests/unit-tests/input/android/test_input_translator.cpp	2015-05-14 18:12:40 +0000
2515
@@ -266,8 +266,7 @@
2516
266
    expected.motion.source_id = 4;
266
    expected.motion.source_id = 4;
2517
267
    expected.motion.action = mir_motion_action_scroll;
267
    expected.motion.action = mir_motion_action_scroll;
2518
268
    expected.motion.modifiers = 6;
268
    expected.motion.modifiers = 6;
2521
269
    expected.motion.button_state =
269
    expected.motion.buttons = mir_pointer_button_forward | mir_pointer_button_secondary;
2520
270
        static_cast<MirMotionButton>(mir_motion_button_forward | mir_motion_button_secondary);
2522
271
270
2523
272
    auto & pointer = expected.motion.pointer_coordinates[0];
271
    auto & pointer = expected.motion.pointer_coordinates[0];
2524
273
    pointer.id = 1;
272
    pointer.id = 1;
2525
@@ -303,7 +302,7 @@
2526
303
                                          expected.motion.action,
302
                                          expected.motion.action,
2527
304
                                          0, /* flags */
303
                                          0, /* flags */
2528
305
                                          expected.motion.modifiers,
304
                                          expected.motion.modifiers,
2530
306
                                          expected.motion.button_state,
305
                                          AMOTION_EVENT_BUTTON_FORWARD | AMOTION_EVENT_BUTTON_SECONDARY,
2531
307
                                          0, /* edge flags */
306
                                          0, /* edge flags */
2532
308
                                          expected.motion.pointer_count,
307
                                          expected.motion.pointer_count,
2533
309
                                          properties,
308
                                          properties,
2534
310
309
2535
=== modified file 'tests/unit-tests/input/test_default_input_device_hub.cpp'
2536
--- tests/unit-tests/input/test_default_input_device_hub.cpp	2015-05-07 20:41:25 +0000
2537
+++ tests/unit-tests/input/test_default_input_device_hub.cpp	2015-05-14 18:12:40 +0000
2538
@@ -31,6 +31,7 @@
2539
31
#include "mir/dispatch/multiplexing_dispatchable.h"
31
#include "mir/dispatch/multiplexing_dispatchable.h"
2540
32
#include "mir/dispatch/action_queue.h"
32
#include "mir/dispatch/action_queue.h"
2541
33
#include "mir/events/event_builders.h"
33
#include "mir/events/event_builders.h"
2542
34
#include "mir/input/cursor_listener.h"
2543
34
35
2544
35
#include <gmock/gmock.h>
36
#include <gmock/gmock.h>
2545
36
#include <gtest/gtest.h>
37
#include <gtest/gtest.h>
2546
@@ -73,6 +74,13 @@
2547
73
    MOCK_METHOD0(changes_complete, void());
74
    MOCK_METHOD0(changes_complete, void());
2548
74
};
75
};
2549
75
76
2550
77
struct MockCursorListener : public mi::CursorListener
2551
78
{
2552
79
    MOCK_METHOD2(cursor_moved_to, void(float, float));
2553
80
2554
81
    ~MockCursorListener() noexcept {}
2555
82
};
2556
83
2557
76
struct MockInputDevice : public mi::InputDevice
84
struct MockInputDevice : public mi::InputDevice
2558
77
{
85
{
2559
78
    mir::dispatch::ActionQueue queue;
86
    mir::dispatch::ActionQueue queue;
2560
@@ -90,11 +98,12 @@
2561
90
    mtd::TriggeredMainLoop observer_loop;
98
    mtd::TriggeredMainLoop observer_loop;
2562
91
    Nice<mtd::MockInputDispatcher> mock_dispatcher;
99
    Nice<mtd::MockInputDispatcher> mock_dispatcher;
2563
92
    Nice<mtd::MockInputRegion> mock_region;
100
    Nice<mtd::MockInputRegion> mock_region;
2564
101
    Nice<MockCursorListener> mock_cursor_listener;
2565
93
    Nice<MockTouchVisualizer> mock_visualizer;
102
    Nice<MockTouchVisualizer> mock_visualizer;
2566
94
    mir::dispatch::MultiplexingDispatchable multiplexer;
103
    mir::dispatch::MultiplexingDispatchable multiplexer;
2567
95
    mi::DefaultInputDeviceHub hub{mt::fake_shared(mock_dispatcher), mt::fake_shared(multiplexer),
104
    mi::DefaultInputDeviceHub hub{mt::fake_shared(mock_dispatcher), mt::fake_shared(multiplexer),
2568
96
                                  mt::fake_shared(observer_loop), mt::fake_shared(mock_visualizer),
105
                                  mt::fake_shared(observer_loop), mt::fake_shared(mock_visualizer),
2570
97
                                  mt::fake_shared(mock_region)};
106
                                  mt::fake_shared(mock_cursor_listener), mt::fake_shared(mock_region)};
2571
98
    Nice<MockInputDeviceObserver> mock_observer;
107
    Nice<MockInputDeviceObserver> mock_observer;
2572
99
    Nice<MockInputDevice> device;
108
    Nice<MockInputDevice> device;
2573
100
    Nice<MockInputDevice> another_device;
109
    Nice<MockInputDevice> another_device;
2574
@@ -352,3 +361,21 @@
2575
352
    EXPECT_THAT(pos1, Eq(confined_pos));
361
    EXPECT_THAT(pos1, Eq(confined_pos));
2576
353
    EXPECT_THAT(pos2, Eq(confined_pos));
362
    EXPECT_THAT(pos2, Eq(confined_pos));
2577
354
}
363
}
2578
364
2579
365
TEST_F(InputDeviceHubTest, forwards_pointer_updates_to_cursor_listener)
2580
366
{
2581
367
    using namespace ::testing;
2582
368
2583
369
    auto x = 12.2f, y = 14.3f;
2584
370
    auto event = mir::events::make_event(0, std::chrono::nanoseconds(0),
2585
371
        mir_input_event_modifier_none, mir_pointer_action_motion, 0,
2586
372
        x, y, 0.0f, 0.0f);
2587
373
2588
374
    EXPECT_CALL(mock_cursor_listener, cursor_moved_to(x, y)).Times(1);
2589
375
2590
376
    mi::InputSink* sink;
2591
377
    capture_input_sink(device, sink);
2592
378
    hub.add_device(mt::fake_shared(device));
2593
379
2594
380
    sink->handle_input(*event);
2595
381
}
2596
355
382
2597
=== modified file 'tests/unit-tests/input/test_event_builders.cpp'
2598
--- tests/unit-tests/input/test_event_builders.cpp	2015-05-08 20:54:52 +0000
2599
+++ tests/unit-tests/input/test_event_builders.cpp	2015-05-14 18:12:40 +0000
2600
@@ -99,8 +99,7 @@
2601
99
TEST_F(InputEventBuilder, makes_valid_pointer_event)
99
TEST_F(InputEventBuilder, makes_valid_pointer_event)
2602
100
{
100
{
2603
101
    MirPointerAction action = mir_pointer_action_enter;
101
    MirPointerAction action = mir_pointer_action_enter;
2606
102
    std::vector<MirPointerButton> depressed_buttons = 
102
    auto depressed_buttons = mir_pointer_button_back | mir_pointer_button_tertiary;
2605
103
        {mir_pointer_button_back, mir_pointer_button_tertiary};
2607
104
    float x_axis_value = 3.9, y_axis_value = 7.4, hscroll_value = .9, vscroll_value = .3;
103
    float x_axis_value = 3.9, y_axis_value = 7.4, hscroll_value = .9, vscroll_value = .3;
2608
105
    auto ev = mev::make_event(device_id, timestamp, modifiers, 
104
    auto ev = mev::make_event(device_id, timestamp, modifiers, 
2609
106
        action, depressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
105
        action, depressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
2610
@@ -162,11 +161,10 @@
2611
162
161
2612
163
TEST_F(InputEventBuilder, map_to_hover_if_no_button_pressed)
162
TEST_F(InputEventBuilder, map_to_hover_if_no_button_pressed)
2613
164
{
163
{
2614
165
    std::vector<MirPointerButton> no_pressed_buttons;
2615
166
    float x_axis_value = 3.9, y_axis_value = 7.4, hscroll_value = .9, vscroll_value = .3;
164
    float x_axis_value = 3.9, y_axis_value = 7.4, hscroll_value = .9, vscroll_value = .3;
2616
167
    MirPointerAction action = mir_pointer_action_motion;
165
    MirPointerAction action = mir_pointer_action_motion;
2617
168
    auto ev = mev::make_event(device_id, timestamp, modifiers,
166
    auto ev = mev::make_event(device_id, timestamp, modifiers,
2619
169
        action, no_pressed_buttons, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
167
        action, 0, x_axis_value, y_axis_value, hscroll_value, vscroll_value);
2620
170
    auto e = ev.get();
168
    auto e = ev.get();
2621
171
169
2622
172
    auto ie = mir_event_get_input_event(e);
170
    auto ie = mir_event_get_input_event(e);
2623
173
171
2624
=== modified file 'tests/unit-tests/input/test_input_event.cpp'
2625
--- tests/unit-tests/input/test_input_event.cpp	2015-05-05 18:01:08 +0000
2626
+++ tests/unit-tests/input/test_input_event.cpp	2015-05-14 18:12:40 +0000
2627
@@ -61,15 +61,21 @@
2628
61
MirEvent a_key_ev()
61
MirEvent a_key_ev()
2629
62
{
62
{
2630
63
    MirEvent key_ev;
63
    MirEvent key_ev;
2631
64
    memset(&key_ev, 0, sizeof(key_ev));
2632
65
    
2633
64
    key_ev.type = mir_event_type_key;
66
    key_ev.type = mir_event_type_key;
2634
67
    
2635
65
    return key_ev;
68
    return key_ev;
2636
66
}
69
}
2637
67
70
2638
68
MirEvent a_motion_ev(int device_class = AINPUT_SOURCE_UNKNOWN)
71
MirEvent a_motion_ev(int device_class = AINPUT_SOURCE_UNKNOWN)
2639
69
{
72
{
2640
70
    MirEvent motion_ev;
73
    MirEvent motion_ev;
2641
74
    memset(&motion_ev, 0, sizeof(motion_ev));
2642
75
    
2643
71
    motion_ev.type = mir_event_type_motion;
76
    motion_ev.type = mir_event_type_motion;
2644
72
    motion_ev.motion.source_id = device_class;
77
    motion_ev.motion.source_id = device_class;
2645
78
    
2646
73
    return motion_ev;
79
    return motion_ev;
2647
74
}
80
}
2648
75
81
2649
@@ -350,13 +356,13 @@
2650
350
{
356
{
2651
351
    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
357
    auto old_ev = a_motion_ev(AINPUT_SOURCE_MOUSE);
2652
352
358
2654
353
    old_ev.motion.button_state = mir_motion_button_primary;
359
    old_ev.motion.buttons = mir_pointer_button_primary;
2655
354
    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
360
    auto pev = mir_input_event_get_pointer_event(mir_event_get_input_event(&old_ev));
2656
355
    
361
    
2657
356
    EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
362
    EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
2658
357
    EXPECT_FALSE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
363
    EXPECT_FALSE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
2659
358
364
2661
359
    old_ev.motion.button_state = static_cast<MirMotionButton>(old_ev.motion.button_state | (mir_motion_button_secondary));
365
    old_ev.motion.buttons |=  mir_pointer_button_secondary;
2662
360
366
2663
361
    EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
367
    EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_primary));
2664
362
    EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
368
    EXPECT_TRUE(mir_pointer_event_button_state(pev, mir_pointer_button_secondary));
2665
363
369
2666
=== modified file 'tests/unit-tests/scene/test_abstract_shell.cpp'
2667
--- tests/unit-tests/scene/test_abstract_shell.cpp	2015-05-11 18:19:27 +0000
2668
+++ tests/unit-tests/scene/test_abstract_shell.cpp	2015-05-14 18:12:40 +0000
2669
@@ -283,7 +283,7 @@
2670
283
{
283
{
2671
284
    MirInputEventModifiers const modifiers{mir_input_event_modifier_none};
284
    MirInputEventModifiers const modifiers{mir_input_event_modifier_none};
2672
285
    MirPointerAction const action{mir_pointer_action_button_down};
285
    MirPointerAction const action{mir_pointer_action_button_down};
2674
286
    std::vector<MirPointerButton> const buttons_pressed{mir_pointer_button_primary};
286
    auto const buttons_pressed = mir_pointer_button_primary;
2675
287
    float const x_axis_value{0.0};
287
    float const x_axis_value{0.0};
2676
288
    float const y_axis_value{0.0};
288
    float const y_axis_value{0.0};
2677
289
    float const hscroll_value{0.0};
289
    float const hscroll_value{0.0};
Status:	Superseded
Proposed branch:	lp:~mir-team/mir/unify-pointer-button
Merge into:	lp:mir
Prerequisite:	lp:~mir-team/mir/remaining-nsec-removal
Diff against target:	2677 lines (+854/-963) 40 files modified 3rd_party/android-input/android/frameworks/base/services/input/InputDispatcher.cpp (+11/-11) include/client/mir/events/event_builders.h (+1/-2) include/client/mir_toolkit/events/input/pointer_event.h (+15/-5) src/client/events/event_builders.cpp (+19/-30) src/client/input/android/android_input_lexicon.cpp (+1/-1) src/client/input/android/event_conversion_helpers.cpp (+34/-0) src/client/input/input_event.cpp (+11/-5) src/client/symbols.map (+3/-0) src/include/common/mir/events/event_private.h (+1/-9) src/include/common/mir/input/android/event_conversion_helpers.h (+3/-1) src/server/input/android/android_input_dispatcher.cpp (+1/-1) src/server/input/android/input_sender.cpp (+1/-1) src/server/input/android/input_translator.cpp (+1/-1) src/server/input/default_configuration.cpp (+2/-0) src/server/input/default_input_device_hub.cpp (+16/-1) src/server/input/default_input_device_hub.h (+4/-0) tests/acceptance-tests/test_client_input.cpp (+510/-69) tests/acceptance-tests/test_surface_modifications.cpp (+2/-4) tests/acceptance-tests/test_surface_placement.cpp (+1/-1) tests/acceptance-tests/throwback/CMakeLists.txt (+0/-1) tests/acceptance-tests/throwback/test_client_input.cpp (+0/-704) tests/acceptance-tests/throwback/test_custom_input_targeter.cpp (+0/-1) tests/include/mir_test/event_matchers.h (+28/-27) tests/include/mir_test_framework/input_testing_server_configuration.h (+0/-22) tests/include/mir_test_framework/placement_applying_shell.h (+59/-0) tests/integration-tests/input/CMakeLists.txt (+1/-4) tests/integration-tests/input/android/CMakeLists.txt (+0/-9) tests/integration-tests/input/test_cursor_listener.cpp (+17/-10) tests/mir_test_framework/CMakeLists.txt (+1/-0) tests/mir_test_framework/fake_input_device_impl.cpp (+3/-3) tests/mir_test_framework/fake_input_device_impl.h (+1/-3) tests/mir_test_framework/input_testing_server_options.cpp (+0/-17) tests/mir_test_framework/placement_applying_shell.cpp (+59/-0) tests/unit-tests/input/android/test_android_input_dispatcher.cpp (+5/-4) tests/unit-tests/input/android/test_android_input_lexicon.cpp (+2/-5) tests/unit-tests/input/android/test_input_translator.cpp (+2/-3) tests/unit-tests/input/test_default_input_device_hub.cpp (+28/-1) tests/unit-tests/input/test_event_builders.cpp (+2/-4) tests/unit-tests/input/test_input_event.cpp (+8/-2) tests/unit-tests/scene/test_abstract_shell.cpp (+1/-1)
To merge this branch:	bzr merge lp:~mir-team/mir/unify-pointer-button
Related bugs:	Link a bug report
Reviewer	Review Type	Date Requested	Status
Alan Griffiths			Needs Fixing on 2015-05-13
Alexandros Frantzis (community)		2015-05-05	Approve on 2015-05-13
Daniel van Vugt			Needs Fixing on 2015-05-13
PS Jenkins bot (community)	continuous-integration		Approve on 2015-05-12
Andreas Pokorny (community)			Approve on 2015-05-12
Kevin DuBois (community)			Needs Information on 2015-05-11
Review via email: mp+258322@code.launchpad.net