1
=== modified file 'include/client/mir_toolkit/client_types.h'
2
--- include/client/mir_toolkit/client_types.h	2017-02-22 14:36:45 +0000
3
+++ include/client/mir_toolkit/client_types.h	2017-03-01 16:08:29 +0000
4
@@ -394,6 +394,7 @@
5
394
typedef struct MirKeyboardConfig MirKeyboardConfig;
394
typedef struct MirKeyboardConfig MirKeyboardConfig;
6
395
typedef struct MirPointerConfig MirPointerConfig;
395
typedef struct MirPointerConfig MirPointerConfig;
7
396
typedef struct MirTouchpadConfig MirTouchpadConfig;
396
typedef struct MirTouchpadConfig MirTouchpadConfig;
8
397
typedef struct MirTouchscreenConfig MirTouchscreenConfig;
9
397
398
10
398
/**
399
/**
11
399
 * MirScreencastParameters is the structure of required information that
400
 * MirScreencastParameters is the structure of required information that
12
400
401
13
=== modified file 'include/client/mir_toolkit/mir_input_device.h'
14
--- include/client/mir_toolkit/mir_input_device.h	2017-02-14 16:08:27 +0000
15
+++ include/client/mir_toolkit/mir_input_device.h	2017-03-01 16:08:29 +0000
16
@@ -572,6 +572,74 @@
17
572
void mir_touchpad_config_set_disable_while_typing(
572
void mir_touchpad_config_set_disable_while_typing(
18
573
    MirTouchpadConfig* conf, bool active);
573
    MirTouchpadConfig* conf, bool active);
19
574
574
20
575
/**
21
576
 * Retrieve a structure containing the touchscreen related config options
22
577
 * of the input device.
23
578
 *
24
579
 * If the input device does not contain a touchscreen, there are no
25
580
 * config options, and the function will return a null pointer.
26
581
 *
27
582
 * \param [in] device   The input device
28
583
 *
29
584
 * \return              The touchscreen config
30
585
 */
31
586
MirTouchscreenConfig const* mir_input_device_get_touchscreen_config(
32
587
    MirInputDevice const* device);
33
588
34
589
/**
35
590
 * Get the output ID of the display the coordinates of this device will be mapped to.
36
591
 *
37
592
 * This setting is ignored when the mapping mode is set to
38
593
 * mir_touchscreen_mapping_mode_to_display_wall.
39
594
 *
40
595
 * \param [in] device   The touchscreen configuration
41
596
 *
42
597
 * \return              The output id
43
598
 */
44
599
uint32_t mir_touchscreen_config_get_output_id(MirTouchscreenConfig const* device);
45
600
46
601
/**
47
602
 * Get the mapping mode used for the touchscreen
48
603
 *
49
604
 * \param [in] device   The touchscreen configuration
50
605
 *
51
606
 * \return              The mapping mode
52
607
 */
53
608
enum MirTouchscreenMappingMode mir_touchscreen_config_get_mapping_mode(MirTouchscreenConfig const* device);
54
609
55
610
/**
56
611
 * Retrieve a mutable structure containing the touchscreen related options
57
612
 * of the input device to change the device configuration.
58
613
 *
59
614
 * If the input device does not contain a touchscreen, there are no
60
615
 * config options, and the function will return a null pointer.
61
616
 *
62
617
 * \param [in] device   The input device
63
618
 *
64
619
 * \return              The touchscreen config
65
620
 */
66
621
MirTouchscreenConfig* mir_input_device_get_mutable_touchscreen_config(
67
622
    MirInputDevice* device);
68
623
69
624
/**
70
625
 * Set the output ID of the display the coordinates of this device will be mapped to.
71
626
 *
72
627
 * This setting is ignored when the mapping mode is set to
73
628
 * mir_touchscreen_mapping_mode_to_display_wall.
74
629
 *
75
630
 * \param [in] config    The touchscreen configuration
76
631
 * \param [in] output    The output id
77
632
 */
78
633
void mir_touchscreen_config_set_output_id(MirTouchscreenConfig* config, uint32_t output);
79
634
80
635
/**
81
636
 * Set the mapping mode used for the touchscreen.
82
637
 *
83
638
 * \param [in] config   The touchscreen configuration
84
639
 * \param [in] mode     The mapping mode
85
640
 */
86
641
void mir_touchscreen_config_set_mapping_mode(MirTouchscreenConfig* config, enum MirTouchscreenMappingMode mode);
87
642
88
575
#ifdef __cplusplus
643
#ifdef __cplusplus
89
576
}
644
}
90
577
#endif
645
#endif
91
578
646
92
=== modified file 'include/core/mir_toolkit/mir_input_device_types.h'
93
--- include/core/mir_toolkit/mir_input_device_types.h	2017-01-18 02:29:37 +0000
94
+++ include/core/mir_toolkit/mir_input_device_types.h	2017-03-01 16:08:29 +0000
95
@@ -113,7 +113,7 @@
96
113
 * i.e handheld devices with builtin touchscreens or external graphic tablets or
113
 * i.e handheld devices with builtin touchscreens or external graphic tablets or
97
114
 * external monitors with touchscreen capabilities.
114
 * external monitors with touchscreen capabilities.
98
115
 */
115
 */
100
116
enum MirTouchscreenMappingMode
116
typedef enum MirTouchscreenMappingMode
101
117
{
117
{
102
118
    /**
118
    /**
103
119
     * Map the device coordinates onto specific output.
119
     * Map the device coordinates onto specific output.
104
@@ -123,7 +123,7 @@
105
123
     * Map the device coordinates onto the whole wall of outputs.
123
     * Map the device coordinates onto the whole wall of outputs.
106
124
     */
124
     */
107
125
    mir_touchscreen_mapping_mode_to_display_wall
125
    mir_touchscreen_mapping_mode_to_display_wall
109
126
};
126
} MirTouchscreenMappingMode;
110
127
127
111
128
128
112
129
#ifdef __cplusplus
129
#ifdef __cplusplus
113
130
130
114
=== modified file 'include/platform/mir/input/input_sink.h'
115
--- include/platform/mir/input/input_sink.h	2016-07-07 09:59:19 +0000
116
+++ include/platform/mir/input/input_sink.h	2017-03-01 16:08:29 +0000
117
@@ -22,14 +22,40 @@
118
22
22
119
23
#include "mir_toolkit/event.h"
23
#include "mir_toolkit/event.h"
120
24
#include "mir/geometry/rectangle.h"
24
#include "mir/geometry/rectangle.h"
122
25
#include "mir/geometry/displacement.h"
25
#include "mir/geometry/point.h"
123
26
26
124
27
#include <vector>
27
#include <vector>
125
28
#include <array>
126
28
29
127
29
namespace mir
30
namespace mir
128
30
{
31
{
129
31
namespace input
32
namespace input
130
32
{
33
{
131
34
132
35
struct OutputInfo
133
36
{
134
37
    using Matrix = std::array<float,6>; // 2x3 row major matrix
135
38
    OutputInfo() {}
136
39
    OutputInfo(bool active, geometry::Size size, Matrix const& transformation)
137
40
        : active{active}, output_size{size}, output_to_scene(transformation)
138
41
    {}
139
42
140
43
    bool active{false};
141
44
    geometry::Size output_size;
142
45
    Matrix output_to_scene{{1,0,0,
143
46
                            0,1,0}};
144
47
145
48
    inline void transform_to_scene(float& x, float& y) const
146
49
    {
147
50
        auto original_x = x;
148
51
        auto original_y = y;
149
52
        auto const& mat = output_to_scene;
150
53
151
54
        x = mat[0]*original_x + mat[1]*original_y + mat[2]*1;
152
55
        y = mat[3]*original_x + mat[4]*original_y + mat[5]*1;
153
56
    }
154
57
};
155
58
156
33
class InputSink
59
class InputSink
157
34
{
60
{
158
35
public:
61
public:
159
@@ -41,6 +67,13 @@
160
41
     */
67
     */
161
42
    virtual mir::geometry::Rectangle bounding_rectangle() const = 0;
68
    virtual mir::geometry::Rectangle bounding_rectangle() const = 0;
162
43
69
163
70
    /**!
164
71
     * Obtain the output information for a specific ouput.
165
72
     *
166
73
     * \param[in] output_id the id of the output
167
74
     */
168
75
    virtual OutputInfo output_info(uint32_t output_id) const = 0;
169
76
170
44
    /**
77
    /**
171
45
     * \name Device State interface of InputSink
78
     * \name Device State interface of InputSink
172
46
     *
79
     *
173
47
80
174
=== modified file 'include/platform/mir/input/touchscreen_settings.h'
175
--- include/platform/mir/input/touchscreen_settings.h	2017-02-03 13:42:56 +0000
176
+++ include/platform/mir/input/touchscreen_settings.h	2017-03-01 16:08:29 +0000
177
@@ -30,6 +30,11 @@
178
30
30
179
31
struct TouchscreenSettings
31
struct TouchscreenSettings
180
32
{
32
{
181
33
    TouchscreenSettings() {}
182
34
    TouchscreenSettings(uint32_t output_id, MirTouchscreenMappingMode mode)
183
35
        : output_id{output_id}, mapping_mode{mode}
184
36
    {}
185
37
186
33
    /**
38
    /**
187
34
     * Configures the output the input device should map its coordinates to.
39
     * Configures the output the input device should map its coordinates to.
188
35
     * The value of this setting is only relevant when the mapping mode is
40
     * The value of this setting is only relevant when the mapping mode is
189
36
41
190
=== modified file 'include/test/mir_test_framework/fake_input_device.h'
191
--- include/test/mir_test_framework/fake_input_device.h	2017-01-18 02:29:37 +0000
192
+++ include/test/mir_test_framework/fake_input_device.h	2017-03-01 16:08:29 +0000
193
@@ -24,6 +24,14 @@
194
24
#include <chrono>
24
#include <chrono>
195
25
#include <functional>
25
#include <functional>
196
26
26
197
27
namespace mir
198
28
{
199
29
namespace input
200
30
{
201
31
class InputDevice;
202
32
}
203
33
}
204
34
205
27
namespace mir_test_framework
35
namespace mir_test_framework
206
28
{
36
{
207
29
37
208
@@ -52,6 +60,7 @@
209
52
    virtual void emit_touch_sequence(std::function<mir::input::synthesis::TouchParameters(int)> const& generate_parameters,
60
    virtual void emit_touch_sequence(std::function<mir::input::synthesis::TouchParameters(int)> const& generate_parameters,
210
53
                                     int count,
61
                                     int count,
211
54
                                     std::chrono::duration<double> delay) = 0;
62
                                     std::chrono::duration<double> delay) = 0;
212
63
    virtual void on_new_configuration_do(std::function<void(mir::input::InputDevice const& device)> callback) = 0;
213
55
64
214
56
    FakeInputDevice(FakeInputDevice const&) = delete;
65
    FakeInputDevice(FakeInputDevice const&) = delete;
215
57
    FakeInputDevice& operator=(FakeInputDevice const&) = delete;
66
    FakeInputDevice& operator=(FakeInputDevice const&) = delete;
216
58
67
217
=== modified file 'src/client/mir_input_device_api.cpp'
218
--- src/client/mir_input_device_api.cpp	2017-02-09 10:49:40 +0000
219
+++ src/client/mir_input_device_api.cpp	2017-03-01 16:08:29 +0000
220
@@ -20,6 +20,7 @@
221
20
#include "mir/input/mir_keyboard_config.h"
20
#include "mir/input/mir_keyboard_config.h"
222
21
#include "mir/input/mir_pointer_config.h"
21
#include "mir/input/mir_pointer_config.h"
223
22
#include "mir/input/mir_touchpad_config.h"
22
#include "mir/input/mir_touchpad_config.h"
224
23
#include "mir/input/mir_touchscreen_config.h"
225
23
#include "mir/require.h"
24
#include "mir/require.h"
226
24
#include "handle_event_exception.h"
25
#include "handle_event_exception.h"
227
25
26
228
@@ -282,3 +283,37 @@
229
282
{
283
{
230
283
    conf->disable_while_typing(active);
284
    conf->disable_while_typing(active);
231
284
})
285
})
232
286
233
287
MirTouchscreenConfig const* mir_input_device_get_touchscreen_config(MirInputDevice const* device) MIR_HANDLE_EVENT_EXCEPTION(
234
288
{
235
289
    if (device->has_touchscreen_config())
236
290
        return &device->touchscreen_config();
237
291
    return nullptr;
238
292
})
239
293
240
294
uint32_t mir_touchscreen_config_get_output_id(MirTouchscreenConfig const* config) MIR_HANDLE_EVENT_EXCEPTION(
241
295
{
242
296
    return config->output_id();
243
297
})
244
298
245
299
MirTouchscreenMappingMode mir_touchscreen_config_get_mapping_mode(MirTouchscreenConfig const* config) MIR_HANDLE_EVENT_EXCEPTION(
246
300
{
247
301
    return config->mapping_mode();
248
302
})
249
303
250
304
MirTouchscreenConfig* mir_input_device_get_mutable_touchscreen_config(MirInputDevice* device)  MIR_HANDLE_EVENT_EXCEPTION(
251
305
{
252
306
    if (device->has_touchscreen_config())
253
307
        return &device->touchscreen_config();
254
308
    return nullptr;
255
309
})
256
310
257
311
void mir_touchscreen_config_set_output_id(MirTouchscreenConfig* config, uint32_t id) MIR_HANDLE_EVENT_EXCEPTION(
258
312
{
259
313
    return config->output_id(id);
260
314
})
261
315
262
316
void mir_touchscreen_config_set_mapping_mode(MirTouchscreenConfig* config, MirTouchscreenMappingMode mode) MIR_HANDLE_EVENT_EXCEPTION(
263
317
{
264
318
    return config->mapping_mode(mode);
265
319
})
266
285
320
267
=== modified file 'src/client/symbols.map'
268
--- src/client/symbols.map	2017-02-24 14:11:28 +0000
269
+++ src/client/symbols.map	2017-03-01 16:08:29 +0000
270
@@ -616,6 +616,8 @@
271
616
    mir_get_client_api_version;
616
    mir_get_client_api_version;
272
617
    mir_input_device_get_keyboard_config;
617
    mir_input_device_get_keyboard_config;
273
618
    mir_input_device_get_mutable_keyboard_config;
618
    mir_input_device_get_mutable_keyboard_config;
274
619
    mir_input_device_get_mutable_touchscreen_config;
275
620
    mir_input_device_get_touchscreen_config;
276
619
    mir_keyboard_config_get_keymap_layout;
621
    mir_keyboard_config_get_keymap_layout;
277
620
    mir_keyboard_config_get_keymap_model;
622
    mir_keyboard_config_get_keymap_model;
278
621
    mir_keyboard_config_get_keymap_options;
623
    mir_keyboard_config_get_keymap_options;
279
@@ -627,4 +629,8 @@
280
627
    mir_keyboard_event_key_text;
629
    mir_keyboard_event_key_text;
281
628
    mir_output_get_logical_height;
630
    mir_output_get_logical_height;
282
629
    mir_output_get_logical_width;
631
    mir_output_get_logical_width;
283
632
    mir_touchscreen_config_get_mapping_mode;
284
633
    mir_touchscreen_config_get_output_id;
285
634
    mir_touchscreen_config_set_mapping_mode;
286
635
    mir_touchscreen_config_set_output_id;
287
630
} MIR_CLIENT_0.26.1;
636
} MIR_CLIENT_0.26.1;
288
631
637
289
=== modified file 'src/include/server/mir/input/seat.h'
290
--- src/include/server/mir/input/seat.h	2017-01-18 02:29:37 +0000
291
+++ src/include/server/mir/input/seat.h	2017-03-01 16:08:29 +0000
292
@@ -33,6 +33,8 @@
293
33
namespace input
33
namespace input
294
34
{
34
{
295
35
class Device;
35
class Device;
296
36
class OutputInfo;
297
37
298
36
class Seat
38
class Seat
299
37
{
39
{
300
38
public:
40
public:
301
@@ -41,7 +43,6 @@
302
41
    virtual void add_device(Device const& device) = 0;
43
    virtual void add_device(Device const& device) = 0;
303
42
    virtual void remove_device(Device const& device) = 0;
44
    virtual void remove_device(Device const& device) = 0;
304
43
    virtual void dispatch_event(MirEvent& event) = 0;
45
    virtual void dispatch_event(MirEvent& event) = 0;
305
44
    virtual geometry::Rectangle get_rectangle_for(Device const& dev) = 0;
306
45
    virtual EventUPtr create_device_state() = 0;
46
    virtual EventUPtr create_device_state() = 0;
307
46
47
308
47
    virtual void set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes) = 0;
48
    virtual void set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes) = 0;
309
@@ -49,6 +50,9 @@
310
49
    virtual void set_cursor_position(float cursor_x, float cursor_y) = 0;
50
    virtual void set_cursor_position(float cursor_x, float cursor_y) = 0;
311
50
    virtual void set_confinement_regions(geometry::Rectangles const& regions) = 0;
51
    virtual void set_confinement_regions(geometry::Rectangles const& regions) = 0;
312
51
    virtual void reset_confinement_regions() = 0;
52
    virtual void reset_confinement_regions() = 0;
313
53
314
54
    virtual geometry::Rectangle bounding_rectangle() const = 0;
315
55
    virtual input::OutputInfo output_info(uint32_t output_id) const = 0;
316
52
private:
56
private:
317
53
    Seat(Seat const&) = delete;
57
    Seat(Seat const&) = delete;
318
54
    Seat& operator=(Seat const&) = delete;
58
    Seat& operator=(Seat const&) = delete;
319
55
59
320
=== modified file 'src/platforms/evdev/libinput_device.cpp'
321
--- src/platforms/evdev/libinput_device.cpp	2017-02-03 01:10:42 +0000
322
+++ src/platforms/evdev/libinput_device.cpp	2017-03-01 16:08:29 +0000
323
@@ -114,7 +114,10 @@
324
114
            // Not yet provided by libinput.
114
            // Not yet provided by libinput.
325
115
            break;
115
            break;
326
116
        case LIBINPUT_EVENT_TOUCH_FRAME:
116
        case LIBINPUT_EVENT_TOUCH_FRAME:
328
117
            sink->handle_input(*convert_touch_frame(libinput_event_get_touch_event(event)));
117
            if (is_output_active())
329
118
            {
330
119
                sink->handle_input(*convert_touch_frame(libinput_event_get_touch_event(event)));
331
120
            }
332
118
            break;
121
            break;
333
119
        default:
122
        default:
334
120
            break;
123
            break;
335
@@ -184,6 +187,7 @@
336
184
    auto const action = mir_pointer_action_motion;
187
    auto const action = mir_pointer_action_motion;
337
185
    auto const hscroll_value = 0.0f;
188
    auto const hscroll_value = 0.0f;
338
186
    auto const vscroll_value = 0.0f;
189
    auto const vscroll_value = 0.0f;
339
190
    // either the bounding box .. or the specific output ..
340
187
    auto const screen = sink->bounding_rectangle();
191
    auto const screen = sink->bounding_rectangle();
341
188
    uint32_t const width = screen.size.width.as_int();
192
    uint32_t const width = screen.size.width.as_int();
342
189
    uint32_t const height = screen.size.height.as_int();
193
    uint32_t const height = screen.size.height.as_int();
343
@@ -290,9 +294,10 @@
344
290
294
345
291
void mie::LibInputDevice::update_contact_data(ContactData & data, MirTouchAction action, libinput_event_touch* touch)
295
void mie::LibInputDevice::update_contact_data(ContactData & data, MirTouchAction action, libinput_event_touch* touch)
346
292
{
296
{
350
293
    auto const screen = sink->bounding_rectangle();
297
    auto info = get_output_info();
351
294
    uint32_t const width = screen.size.width.as_int();
298
352
295
    uint32_t const height = screen.size.height.as_int();
299
    uint32_t width = info.output_size.width.as_int();
353
300
    uint32_t height = info.output_size.height.as_int();
354
296
301
355
297
    data.action = action;
302
    data.action = action;
356
298
    data.pressure = libinput_event_touch_get_pressure(touch);
303
    data.pressure = libinput_event_touch_get_pressure(touch);
357
@@ -300,6 +305,8 @@
358
300
    data.y = libinput_event_touch_get_y_transformed(touch, height);
305
    data.y = libinput_event_touch_get_y_transformed(touch, height);
359
301
    data.major = libinput_event_touch_get_major_transformed(touch, width, height);
306
    data.major = libinput_event_touch_get_major_transformed(touch, width, height);
360
302
    data.minor = libinput_event_touch_get_minor_transformed(touch, width, height);
307
    data.minor = libinput_event_touch_get_minor_transformed(touch, width, height);
361
308
362
309
    info.transform_to_scene(data.x, data.y);
363
303
}
310
}
364
304
311
365
305
void mie::LibInputDevice::handle_touch_motion(libinput_event_touch* touch)
312
void mie::LibInputDevice::handle_touch_motion(libinput_event_touch* touch)
366
@@ -351,6 +358,10 @@
367
351
        }
358
        }
368
352
    }
359
    }
369
353
360
370
361
    if (contains(caps, mi::DeviceCapability::touchscreen) &&
371
362
        !contains(info.capabilities, mi::DeviceCapability::touchscreen))
372
363
        touchscreen = mi::TouchscreenSettings{};
373
364
374
354
    info = mi::InputDeviceInfo{name, unique_id.str(), caps};
365
    info = mi::InputDeviceInfo{name, unique_id.str(), caps};
375
355
}
366
}
376
356
367
377
@@ -364,6 +375,40 @@
378
364
    return devices.front().get();
375
    return devices.front().get();
379
365
}
376
}
380
366
377
381
378
mi::OutputInfo mie::LibInputDevice::get_output_info() const
382
379
{
383
380
    if (touchscreen.is_set() && touchscreen.value().mapping_mode == mir_touchscreen_mapping_mode_to_output)
384
381
    {
385
382
        return sink->output_info(touchscreen.value().output_id);
386
383
    }
387
384
    else
388
385
    {
389
386
        auto scene_bbox = sink->bounding_rectangle();
390
387
        return mi::OutputInfo(
391
388
            true,
392
389
            scene_bbox.size,
393
390
            mi::OutputInfo::Matrix{{1.0f, 0.0f, float(scene_bbox.top_left.x.as_int()),
394
391
                                    0.0f, 1.0f, float(scene_bbox.top_left.y.as_int())}});
395
392
    }
396
393
}
397
394
398
395
bool mie::LibInputDevice::is_output_active() const
399
396
{
400
397
    if (!sink)
401
398
        return false;
402
399
403
400
    if (touchscreen.is_set())
404
401
    {
405
402
        auto const& touchscreen_config = touchscreen.value();
406
403
        if (touchscreen_config.mapping_mode == mir_touchscreen_mapping_mode_to_output)
407
404
        {
408
405
            auto output = sink->output_info(touchscreen_config.output_id);
409
406
            return output.active;
410
407
        }
411
408
    }
412
409
    return true;
413
410
}
414
411
415
367
mir::optional_value<mi::PointerSettings> mie::LibInputDevice::get_pointer_settings() const
412
mir::optional_value<mi::PointerSettings> mie::LibInputDevice::get_pointer_settings() const
416
368
{
413
{
417
369
    if (!contains(info.capabilities, mi::DeviceCapability::pointer))
414
    if (!contains(info.capabilities, mi::DeviceCapability::pointer))
418
370
415
419
=== modified file 'src/platforms/evdev/libinput_device.h'
420
--- src/platforms/evdev/libinput_device.h	2017-02-03 01:10:42 +0000
421
+++ src/platforms/evdev/libinput_device.h	2017-03-01 16:08:29 +0000
422
@@ -41,6 +41,7 @@
423
41
{
41
{
424
42
namespace input
42
namespace input
425
43
{
43
{
426
44
class OutputInfo;
427
44
class InputReport;
45
class InputReport;
428
45
namespace evdev
46
namespace evdev
429
46
{
47
{
430
@@ -77,6 +78,8 @@
431
77
    void handle_touch_up(libinput_event_touch* touch);
78
    void handle_touch_up(libinput_event_touch* touch);
432
78
    void handle_touch_motion(libinput_event_touch* touch);
79
    void handle_touch_motion(libinput_event_touch* touch);
433
79
    void update_device_info();
80
    void update_device_info();
434
81
    bool is_output_active() const;
435
82
    OutputInfo get_output_info() const;
436
80
83
437
81
    std::shared_ptr<InputReport> report;
84
    std::shared_ptr<InputReport> report;
438
82
    std::shared_ptr<::libinput> lib;
85
    std::shared_ptr<::libinput> lib;
439
83
86
440
=== modified file 'src/server/graphics/nested/input_platform.cpp'
441
--- src/server/graphics/nested/input_platform.cpp	2017-02-20 13:19:28 +0000
442
+++ src/server/graphics/nested/input_platform.cpp	2017-03-01 16:08:29 +0000
443
@@ -104,7 +104,15 @@
444
104
            touchpad_settings = settings;
104
            touchpad_settings = settings;
445
105
        }
105
        }
446
106
106
448
107
        // TODO Forwars config when mirclient API is there
107
        auto touchscreen_config = mir_input_device_get_touchscreen_config(dev);
449
108
        if (touchscreen_config && contains(device_info.capabilities, mi::DeviceCapability::touchscreen))
450
109
        {
451
110
            mi::TouchscreenSettings settings;
452
111
            settings.output_id = mir_touchscreen_config_get_output_id(touchscreen_config);
453
112
            settings.mapping_mode = mir_touchscreen_config_get_mapping_mode(touchscreen_config);
454
113
455
114
            touchscreen_settings = settings;
456
115
        }
457
108
    }
116
    }
458
109
117
459
110
    void start(mi::InputSink* destination, mi::EventBuilder* builder) override
118
    void start(mi::InputSink* destination, mi::EventBuilder* builder) override
460
@@ -251,7 +259,15 @@
461
251
        if (touchscreen_settings.is_set() && touchscreen_settings.value() == new_settings)
259
        if (touchscreen_settings.is_set() && touchscreen_settings.value() == new_settings)
462
252
            return;
260
            return;
463
253
261
465
254
        // TODO update the MirInputConfig..
262
        auto ts_conf = mir_input_device_get_mutable_touchscreen_config(device);
466
263
467
264
        if (ts_conf)
468
265
        {
469
266
            mir_touchscreen_config_set_output_id(ts_conf, new_settings.output_id);
470
267
            mir_touchscreen_config_set_mapping_mode(ts_conf, new_settings.mapping_mode);
471
268
472
269
            emit_device_change();
473
270
        }
474
255
    }
271
    }
475
256
272
476
257
    MirInputDeviceId device_id;
273
    MirInputDeviceId device_id;
477
258
274
478
=== modified file 'src/server/input/basic_seat.cpp'
479
--- src/server/input/basic_seat.cpp	2017-01-18 02:29:37 +0000
480
+++ src/server/input/basic_seat.cpp	2017-03-01 16:08:29 +0000
481
@@ -19,29 +19,147 @@
482
19
19
483
20
#include "basic_seat.h"
20
#include "basic_seat.h"
484
21
#include "mir/input/device.h"
21
#include "mir/input/device.h"
486
22
#include "mir/input/input_region.h"
22
#include "mir/input/input_sink.h"
487
23
#include "mir/graphics/display_configuration_observer.h"
488
24
#include "mir/graphics/display_configuration.h"
489
25
#include "mir/graphics/transformation.h"
490
26
#include "mir/geometry/rectangle.h"
491
27
#include "mir/geometry/point.h"
492
28
#include "mir/geometry/size.h"
493
29
#include "mir_toolkit/common.h"
494
23
30
495
24
#include <algorithm>
31
#include <algorithm>
496
32
#include <array>
497
25
33
498
26
namespace mi = mir::input;
34
namespace mi = mir::input;
499
27
namespace mf = mir::frontend;
35
namespace mf = mir::frontend;
500
36
namespace mg = mir::graphics;
501
37
namespace geom = mir::geometry;
502
38
503
39
struct mi::BasicSeat::OutputTracker : mg::DisplayConfigurationObserver
504
40
{
505
41
    OutputTracker(SeatInputDeviceTracker& tracker)
506
42
        : input_state_tracker{tracker}
507
43
    {
508
44
    }
509
45
510
46
    void update_outputs(mg::DisplayConfiguration const& conf)
511
47
    {
512
48
        std::lock_guard<std::mutex> lock(output_mutex);
513
49
        outputs.clear();
514
50
        geom::Rectangles output_rectangles;
515
51
        conf.for_each_output(
516
52
            [this, &output_rectangles](mg::DisplayConfigurationOutput const& output)
517
53
            {
518
54
                if (!output.used || !output.connected)
519
55
                    return;
520
56
                if (!output.valid() || (output.current_mode_index >= output.modes.size()))
521
57
                    return;
522
58
523
59
                // TODO make the decision whether display that is used but powered off should emit
524
60
                // touch screen events in a policy
525
61
                bool active = output.power_mode == mir_power_mode_on;
526
62
527
63
                auto output_size = output.modes[output.current_mode_index].size;
528
64
                auto width = output_size.width.as_int();
529
65
                auto height = output_size.height.as_int();
530
66
                OutputInfo::Matrix output_matrix{{
531
67
                    1.0f, 0.0f, float(output.top_left.x.as_int()),
532
68
                    0.0f, 1.0f, float(output.top_left.y.as_int())}};
533
69
534
70
                switch(output.orientation)
535
71
                {
536
72
                case mir_orientation_left:
537
73
                    output_matrix[3] = -1;
538
74
                    output_matrix[5] += width;
539
75
                    break;
540
76
                case mir_orientation_right:
541
77
                    output_matrix[1] = -1;
542
78
                    output_matrix[2] += height;
543
79
                    break;
544
80
                case mir_orientation_inverted:
545
81
                    output_matrix[0] = -1;
546
82
                    output_matrix[2] += width;
547
83
                    output_matrix[4] = -1;
548
84
                    output_matrix[5] += height;
549
85
                default:
550
86
                    break;
551
87
                }
552
88
                if (active)
553
89
                    output_rectangles.add(output.extents());
554
90
                outputs.insert(std::make_pair(output.id.as_value(), OutputInfo{active, output_size, output_matrix}));
555
91
            });
556
92
        input_state_tracker.update_outputs(output_rectangles);
557
93
        bounding_rectangle = output_rectangles.bounding_rectangle();
558
94
    }
559
95
560
96
    void initial_configuration(std::shared_ptr<mg::DisplayConfiguration const> const& config) override
561
97
    {
562
98
        update_outputs(*config.get());
563
99
    }
564
100
565
101
    void configuration_applied(std::shared_ptr<mg::DisplayConfiguration const> const& config) override
566
102
    {
567
103
        update_outputs(*config.get());
568
104
    }
569
105
570
106
    void base_configuration_updated(std::shared_ptr<mg::DisplayConfiguration const> const&) override
571
107
    {}
572
108
573
109
    void session_configuration_applied(std::shared_ptr<mf::Session> const&,
574
110
        std::shared_ptr<mg::DisplayConfiguration> const&) override
575
111
    {}
576
112
577
113
    void session_configuration_removed(std::shared_ptr<mf::Session> const&) override
578
114
    {}
579
115
580
116
    void configuration_failed(
581
117
        std::shared_ptr<mg::DisplayConfiguration const> const&,
582
118
        std::exception const&) override
583
119
    {}
584
120
585
121
    void catastrophic_configuration_error(
586
122
        std::shared_ptr<mg::DisplayConfiguration const> const&,
587
123
        std::exception const&) override
588
124
    {}
589
125
590
126
    geom::Rectangle get_bounding_rectangle() const
591
127
    {
592
128
        std::lock_guard<std::mutex> lock(output_mutex);
593
129
        return bounding_rectangle;
594
130
    }
595
131
596
132
    mi::OutputInfo get_output_info(uint32_t output) const
597
133
    {
598
134
        std::lock_guard<std::mutex> lock(output_mutex);
599
135
        auto pos = outputs.find(output);
600
136
        if (pos != end(outputs))
601
137
            return pos->second;
602
138
        return OutputInfo{};
603
139
    }
604
140
private:
605
141
    mutable std::mutex output_mutex;
606
142
    mi::SeatInputDeviceTracker& input_state_tracker;
607
143
    std::unordered_map<uint32_t, mi::OutputInfo> outputs;
608
144
    geom::Rectangle bounding_rectangle;
609
145
};
610
28
146
611
29
mi::BasicSeat::BasicSeat(std::shared_ptr<mi::InputDispatcher> const& dispatcher,
147
mi::BasicSeat::BasicSeat(std::shared_ptr<mi::InputDispatcher> const& dispatcher,
612
30
                         std::shared_ptr<mi::TouchVisualizer> const& touch_visualizer,
148
                         std::shared_ptr<mi::TouchVisualizer> const& touch_visualizer,
613
31
                         std::shared_ptr<mi::CursorListener> const& cursor_listener,
149
                         std::shared_ptr<mi::CursorListener> const& cursor_listener,
615
32
                         std::shared_ptr<mi::InputRegion> const& input_region,
150
                         std::shared_ptr<Registrar> const& registrar,
616
33
                         std::shared_ptr<mi::KeyMapper> const& key_mapper,
151
                         std::shared_ptr<mi::KeyMapper> const& key_mapper,
617
34
                         std::shared_ptr<time::Clock> const& clock,
152
                         std::shared_ptr<time::Clock> const& clock,
618
35
                         std::shared_ptr<mi::SeatObserver> const& observer) :
153
                         std::shared_ptr<mi::SeatObserver> const& observer) :
619
36
      input_state_tracker{dispatcher,
154
      input_state_tracker{dispatcher,
620
37
                          touch_visualizer,
155
                          touch_visualizer,
621
38
                          cursor_listener,
156
                          cursor_listener,
622
39
                          input_region,
623
40
                          key_mapper,
157
                          key_mapper,
624
41
                          clock,
158
                          clock,
625
42
                          observer},
159
                          observer},
627
43
      input_region{input_region}
160
      output_tracker{std::make_shared<OutputTracker>(input_state_tracker)}
628
44
{
161
{
629
162
    registrar->register_interest(output_tracker);
630
45
}
163
}
631
46
164
632
47
void mi::BasicSeat::add_device(input::Device const& device)
165
void mi::BasicSeat::add_device(input::Device const& device)
633
@@ -59,13 +177,14 @@
634
59
    input_state_tracker.dispatch(event);
177
    input_state_tracker.dispatch(event);
635
60
}
178
}
636
61
179
644
62
mir::geometry::Rectangle mi::BasicSeat::get_rectangle_for(input::Device const&)
180
geom::Rectangle mi::BasicSeat::bounding_rectangle() const
645
63
{
181
{
646
64
    // TODO: With knowledge of the outputs attached to this seat and the output the given input
182
    return output_tracker->get_bounding_rectangle();
647
65
    // device is associated this method should only return the rectangle of that output. For now
183
}
648
66
    // we rely on the existing workaround in DisplayInputRegion::bounding_rectangle() which
184
649
67
    // assumes that only the first output may have a touch screen associated to it.
185
mi::OutputInfo mi::BasicSeat::output_info(uint32_t output_id) const
650
68
    return input_region->bounding_rectangle();
186
{
651
187
    return output_tracker->get_output_info(output_id);
652
69
}
188
}
653
70
189
654
71
mir::EventUPtr mi::BasicSeat::create_device_state()
190
mir::EventUPtr mi::BasicSeat::create_device_state()
655
@@ -88,7 +207,7 @@
656
88
    input_state_tracker.set_cursor_position(cursor_x, cursor_y);
207
    input_state_tracker.set_cursor_position(cursor_x, cursor_y);
657
89
}
208
}
658
90
209
660
91
void mi::BasicSeat::set_confinement_regions(geometry::Rectangles const& regions)
210
void mi::BasicSeat::set_confinement_regions(geom::Rectangles const& regions)
661
92
{
211
{
662
93
    input_state_tracker.set_confinement_regions(regions);
212
    input_state_tracker.set_confinement_regions(regions);
663
94
}
213
}
664
@@ -97,3 +216,4 @@
665
97
{
216
{
666
98
    input_state_tracker.reset_confinement_regions();
217
    input_state_tracker.reset_confinement_regions();
667
99
}
218
}
668
219
669
100
220
670
=== modified file 'src/server/input/basic_seat.h'
671
--- src/server/input/basic_seat.h	2017-01-18 02:29:37 +0000
672
+++ src/server/input/basic_seat.h	2017-03-01 16:08:29 +0000
673
@@ -20,9 +20,10 @@
674
20
#ifndef MIR_BASIC_SEAT_H_
20
#ifndef MIR_BASIC_SEAT_H_
675
21
#define MIR_BASIC_SEAT_H_
21
#define MIR_BASIC_SEAT_H_
676
22
22
677
23
#include "seat_input_device_tracker.h"
678
23
#include "mir/input/seat.h"
24
#include "mir/input/seat.h"
679
24
#include "mir/frontend/event_sink.h"
25
#include "mir/frontend/event_sink.h"
681
25
#include "seat_input_device_tracker.h"
26
#include "mir/observer_registrar.h"
682
26
27
683
27
#include <mutex>
28
#include <mutex>
684
28
29
685
@@ -32,6 +33,10 @@
686
32
{
33
{
687
33
class Clock;
34
class Clock;
688
34
}
35
}
689
36
namespace graphics
690
37
{
691
38
class DisplayConfigurationObserver;
692
39
}
693
35
namespace input
40
namespace input
694
36
{
41
{
695
37
class TouchVisualizer;
42
class TouchVisualizer;
696
@@ -44,10 +49,11 @@
697
44
class BasicSeat : public Seat
49
class BasicSeat : public Seat
698
45
{
50
{
699
46
public:
51
public:
700
52
    using Registrar = ObserverRegistrar<graphics::DisplayConfigurationObserver>;
701
47
    BasicSeat(std::shared_ptr<InputDispatcher> const& dispatcher,
53
    BasicSeat(std::shared_ptr<InputDispatcher> const& dispatcher,
702
48
              std::shared_ptr<TouchVisualizer> const& touch_visualizer,
54
              std::shared_ptr<TouchVisualizer> const& touch_visualizer,
703
49
              std::shared_ptr<CursorListener> const& cursor_listener,
55
              std::shared_ptr<CursorListener> const& cursor_listener,
705
50
              std::shared_ptr<InputRegion> const& input_region,
56
              std::shared_ptr<Registrar> const& registrar,
706
51
              std::shared_ptr<KeyMapper> const& key_mapper,
57
              std::shared_ptr<KeyMapper> const& key_mapper,
707
52
              std::shared_ptr<time::Clock> const& clock,
58
              std::shared_ptr<time::Clock> const& clock,
708
53
              std::shared_ptr<SeatObserver> const& observer);
59
              std::shared_ptr<SeatObserver> const& observer);
709
@@ -55,17 +61,19 @@
710
55
    void add_device(Device const& device) override;
61
    void add_device(Device const& device) override;
711
56
    void remove_device(Device const& device) override;
62
    void remove_device(Device const& device) override;
712
57
    void dispatch_event(MirEvent& event) override;
63
    void dispatch_event(MirEvent& event) override;
717
58
    geometry::Rectangle get_rectangle_for(Device const& dev) override;
64
    geometry::Rectangle bounding_rectangle() const override;
718
59
    virtual EventUPtr create_device_state() override;
65
    input::OutputInfo output_info(uint32_t output_id) const override;
719
60
    virtual void set_confinement_regions(geometry::Rectangles const& regions) override;
66
    EventUPtr create_device_state() override;
720
61
    virtual void reset_confinement_regions() override;
67
    void set_confinement_regions(geometry::Rectangles const& regions) override;
721
68
    void reset_confinement_regions() override;
722
62
69
723
63
    void set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes) override;
70
    void set_key_state(Device const& dev, std::vector<uint32_t> const& scan_codes) override;
724
64
    void set_pointer_state(Device const& dev, MirPointerButtons buttons) override;
71
    void set_pointer_state(Device const& dev, MirPointerButtons buttons) override;
725
65
    void set_cursor_position(float cursor_x, float cursor_y) override;
72
    void set_cursor_position(float cursor_x, float cursor_y) override;
726
66
private:
73
private:
727
67
    SeatInputDeviceTracker input_state_tracker;
74
    SeatInputDeviceTracker input_state_tracker;
729
68
    std::shared_ptr<InputRegion> const input_region;
75
    struct OutputTracker;
730
76
    std::shared_ptr<OutputTracker> const output_tracker;
731
69
};
77
};
732
70
}
78
}
733
71
}
79
}
734
72
80
735
=== modified file 'src/server/input/default_configuration.cpp'
736
--- src/server/input/default_configuration.cpp	2017-02-16 05:44:15 +0000
737
+++ src/server/input/default_configuration.cpp	2017-03-01 16:08:29 +0000
738
@@ -297,7 +297,7 @@
739
297
                    the_input_dispatcher(),
297
                    the_input_dispatcher(),
740
298
                    the_touch_visualizer(),
298
                    the_touch_visualizer(),
741
299
                    the_cursor_listener(),
299
                    the_cursor_listener(),
743
300
                    the_input_region(),
300
                    the_display_configuration_observer_registrar(),
744
301
                    the_key_mapper(),
301
                    the_key_mapper(),
745
302
                    the_clock(),
302
                    the_clock(),
746
303
                    the_seat_observer());
303
                    the_seat_observer());
747
304
304
748
=== modified file 'src/server/input/default_input_device_hub.cpp'
749
--- src/server/input/default_input_device_hub.cpp	2017-02-27 18:23:08 +0000
750
+++ src/server/input/default_input_device_hub.cpp	2017-03-01 16:08:29 +0000
751
@@ -201,7 +201,15 @@
752
201
    if (!seat)
201
    if (!seat)
753
202
        BOOST_THROW_EXCEPTION(std::runtime_error("Device not started and has no seat assigned"));
202
        BOOST_THROW_EXCEPTION(std::runtime_error("Device not started and has no seat assigned"));
754
203
203
756
204
    return seat->get_rectangle_for(*handle);
204
    return seat->bounding_rectangle();
757
205
}
758
206
759
207
mi::OutputInfo mi::DefaultInputDeviceHub::RegisteredDevice::output_info(uint32_t output_id) const
760
208
{
761
209
    if (!seat)
762
210
        BOOST_THROW_EXCEPTION(std::runtime_error("Device not started and has no seat assigned"));
763
211
764
212
    return seat->output_info(output_id);
765
205
}
213
}
766
206
214
767
207
void mi::DefaultInputDeviceHub::RegisteredDevice::key_state(std::vector<uint32_t> const& scan_codes)
215
void mi::DefaultInputDeviceHub::RegisteredDevice::key_state(std::vector<uint32_t> const& scan_codes)
768
208
216
769
=== modified file 'src/server/input/default_input_device_hub.h'
770
--- src/server/input/default_input_device_hub.h	2017-02-27 18:23:08 +0000
771
+++ src/server/input/default_input_device_hub.h	2017-03-01 16:08:29 +0000
772
@@ -104,7 +104,8 @@
773
104
                         std::shared_ptr<cookie::Authority> const& cookie_authority,
104
                         std::shared_ptr<cookie::Authority> const& cookie_authority,
774
105
                         std::shared_ptr<DefaultDevice> const& handle);
105
                         std::shared_ptr<DefaultDevice> const& handle);
775
106
        void handle_input(MirEvent& event) override;
106
        void handle_input(MirEvent& event) override;
777
107
        mir::geometry::Rectangle bounding_rectangle() const override;
107
        geometry::Rectangle bounding_rectangle() const override;
778
108
        input::OutputInfo output_info(uint32_t output_id) const override;
779
108
        bool device_matches(std::shared_ptr<InputDevice> const& dev) const;
109
        bool device_matches(std::shared_ptr<InputDevice> const& dev) const;
780
109
        void start(std::shared_ptr<Seat> const& seat);
110
        void start(std::shared_ptr<Seat> const& seat);
781
110
        void stop();
111
        void stop();
782
111
112
783
=== modified file 'src/server/input/seat_input_device_tracker.cpp'
784
--- src/server/input/seat_input_device_tracker.cpp	2017-02-17 07:03:56 +0000
785
+++ src/server/input/seat_input_device_tracker.cpp	2017-03-01 16:08:29 +0000
786
@@ -20,7 +20,6 @@
787
20
#include "seat_input_device_tracker.h"
20
#include "seat_input_device_tracker.h"
788
21
#include "mir/input/device.h"
21
#include "mir/input/device.h"
789
22
#include "mir/input/cursor_listener.h"
22
#include "mir/input/cursor_listener.h"
790
23
#include "mir/input/input_region.h"
791
24
#include "mir/input/input_dispatcher.h"
23
#include "mir/input/input_dispatcher.h"
792
25
#include "mir/input/key_mapper.h"
24
#include "mir/input/key_mapper.h"
793
26
#include "mir/input/seat_observer.h"
25
#include "mir/input/seat_observer.h"
794
@@ -45,12 +44,11 @@
795
45
mi::SeatInputDeviceTracker::SeatInputDeviceTracker(std::shared_ptr<InputDispatcher> const& dispatcher,
44
mi::SeatInputDeviceTracker::SeatInputDeviceTracker(std::shared_ptr<InputDispatcher> const& dispatcher,
796
46
                                                   std::shared_ptr<TouchVisualizer> const& touch_visualizer,
45
                                                   std::shared_ptr<TouchVisualizer> const& touch_visualizer,
797
47
                                                   std::shared_ptr<CursorListener> const& cursor_listener,
46
                                                   std::shared_ptr<CursorListener> const& cursor_listener,
798
48
                                                   std::shared_ptr<InputRegion> const& input_region,
799
49
                                                   std::shared_ptr<KeyMapper> const& key_mapper,
47
                                                   std::shared_ptr<KeyMapper> const& key_mapper,
800
50
                                                   std::shared_ptr<time::Clock> const& clock,
48
                                                   std::shared_ptr<time::Clock> const& clock,
801
51
                                                   std::shared_ptr<SeatObserver> const& observer)
49
                                                   std::shared_ptr<SeatObserver> const& observer)
802
52
    : dispatcher{dispatcher}, touch_visualizer{touch_visualizer}, cursor_listener{cursor_listener},
50
    : dispatcher{dispatcher}, touch_visualizer{touch_visualizer}, cursor_listener{cursor_listener},
804
53
      input_region{input_region}, key_mapper{key_mapper}, clock{clock}, observer{observer}, buttons{0}
51
      key_mapper{key_mapper}, clock{clock}, observer{observer}, buttons{0}
805
54
{
52
{
806
55
}
53
}
807
56
54
808
@@ -231,10 +229,16 @@
809
231
    observer->seat_reset_confinement_regions();
229
    observer->seat_reset_confinement_regions();
810
232
}
230
}
811
233
231
812
232
void mi::SeatInputDeviceTracker::update_outputs(geom::Rectangles const& output_regions)
813
233
{
814
234
    std::lock_guard<std::mutex> lg(output_mutex);
815
235
    input_region = output_regions;
816
236
}
817
237
818
234
void mi::SeatInputDeviceTracker::confine_function(mir::geometry::Point& p) const
238
void mi::SeatInputDeviceTracker::confine_function(mir::geometry::Point& p) const
819
235
{
239
{
820
236
    std::lock_guard<std::mutex> lg(region_mutex);
240
    std::lock_guard<std::mutex> lg(region_mutex);
822
237
    input_region->confine(p);
241
    input_region.confine(p);
823
238
    confined_region.confine(p);
242
    confined_region.confine(p);
824
239
}
243
}
825
240
244
826
241
245
827
=== modified file 'src/server/input/seat_input_device_tracker.h'
828
--- src/server/input/seat_input_device_tracker.h	2017-02-17 07:03:56 +0000
829
+++ src/server/input/seat_input_device_tracker.h	2017-03-01 16:08:29 +0000
830
@@ -23,7 +23,10 @@
831
23
#include "mir/input/touch_visualizer.h"
23
#include "mir/input/touch_visualizer.h"
832
24
#include "mir/geometry/point.h"
24
#include "mir/geometry/point.h"
833
25
#include "mir/geometry/rectangles.h"
25
#include "mir/geometry/rectangles.h"
834
26
#include "mir/geometry/size.h"
835
27
#include "mir/optional_value.h"
836
26
#include "mir_toolkit/event.h"
28
#include "mir_toolkit/event.h"
837
29
838
27
#include <unordered_map>
30
#include <unordered_map>
839
28
#include <memory>
31
#include <memory>
840
29
#include <mutex>
32
#include <mutex>
841
@@ -56,7 +59,6 @@
842
56
    SeatInputDeviceTracker(std::shared_ptr<InputDispatcher> const& dispatcher,
59
    SeatInputDeviceTracker(std::shared_ptr<InputDispatcher> const& dispatcher,
843
57
                           std::shared_ptr<TouchVisualizer> const& touch_visualizer,
60
                           std::shared_ptr<TouchVisualizer> const& touch_visualizer,
844
58
                           std::shared_ptr<CursorListener> const& cursor_listener,
61
                           std::shared_ptr<CursorListener> const& cursor_listener,
845
59
                           std::shared_ptr<InputRegion> const& input_region,
846
60
                           std::shared_ptr<KeyMapper> const& key_mapper,
62
                           std::shared_ptr<KeyMapper> const& key_mapper,
847
61
                           std::shared_ptr<time::Clock> const& clock,
63
                           std::shared_ptr<time::Clock> const& clock,
848
62
                           std::shared_ptr<SeatObserver> const& observer);
64
                           std::shared_ptr<SeatObserver> const& observer);
849
@@ -74,6 +76,8 @@
850
74
    void set_cursor_position(float cursor_x, float cursor_y);
76
    void set_cursor_position(float cursor_x, float cursor_y);
851
75
    void set_confinement_regions(geometry::Rectangles const& region);
77
    void set_confinement_regions(geometry::Rectangles const& region);
852
76
    void reset_confinement_regions();
78
    void reset_confinement_regions();
853
79
854
80
    void update_outputs(geometry::Rectangles const& outputs);
855
77
private:
81
private:
856
78
    void update_seat_properties(MirInputEvent const* event);
82
    void update_seat_properties(MirInputEvent const* event);
857
79
    void update_cursor(MirPointerEvent const* event);
83
    void update_cursor(MirPointerEvent const* event);
858
@@ -86,7 +90,6 @@
859
86
    std::shared_ptr<InputDispatcher> const dispatcher;
90
    std::shared_ptr<InputDispatcher> const dispatcher;
860
87
    std::shared_ptr<TouchVisualizer> const touch_visualizer;
91
    std::shared_ptr<TouchVisualizer> const touch_visualizer;
861
88
    std::shared_ptr<CursorListener> const cursor_listener;
92
    std::shared_ptr<CursorListener> const cursor_listener;
862
89
    std::shared_ptr<InputRegion> const input_region;
863
90
    std::shared_ptr<KeyMapper> const key_mapper;
93
    std::shared_ptr<KeyMapper> const key_mapper;
864
91
    std::shared_ptr<time::Clock> const clock;
94
    std::shared_ptr<time::Clock> const clock;
865
92
    std::shared_ptr<SeatObserver> const observer;
95
    std::shared_ptr<SeatObserver> const observer;
866
@@ -102,6 +105,9 @@
867
102
        MirPointerButtons buttons{0};
105
        MirPointerButtons buttons{0};
868
103
        std::vector<TouchVisualizer::Spot> spots;
106
        std::vector<TouchVisualizer::Spot> spots;
869
104
        std::vector<uint32_t> scan_codes;
107
        std::vector<uint32_t> scan_codes;
870
108
871
109
        MirTouchscreenMappingMode mapping_mode{mir_touchscreen_mapping_mode_to_output};
872
110
        mir::optional_value<uint32_t> output_id;
873
105
    };
111
    };
874
106
112
875
107
    // Libinput's acceleration curve means the cursor moves by non-integer
113
    // Libinput's acceleration curve means the cursor moves by non-integer
876
@@ -115,6 +121,9 @@
877
115
121
878
116
    std::mutex mutable device_state_mutex;
122
    std::mutex mutable device_state_mutex;
879
117
    std::mutex mutable region_mutex;
123
    std::mutex mutable region_mutex;
880
124
881
125
    std::mutex mutable output_mutex;
882
126
    geometry::Rectangles input_region;
883
118
};
127
};
884
119
128
885
120
}
129
}
886
121
130
887
=== modified file 'src/server/scene/surface_stack.cpp'
888
--- src/server/scene/surface_stack.cpp	2017-01-20 12:32:45 +0000
889
+++ src/server/scene/surface_stack.cpp	2017-03-01 16:08:29 +0000
890
@@ -309,11 +309,7 @@
891
309
    RecursiveReadLock lg(guard);
309
    RecursiveReadLock lg(guard);
892
310
    for (auto &surface : surfaces)
310
    for (auto &surface : surfaces)
893
311
    {
311
    {
899
312
        if (surface->query(mir_window_attrib_visibility) ==
312
        callback(surface);
895
313
            MirWindowVisibility::mir_window_visibility_exposed)
896
314
        {
897
315
            callback(surface);
898
316
        }
900
317
    }
313
    }
901
318
}
314
}
902
319
315
903
320
316
904
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
905
--- tests/acceptance-tests/test_client_input.cpp	2017-02-22 14:36:45 +0000
906
+++ tests/acceptance-tests/test_client_input.cpp	2017-03-01 16:08:29 +0000
907
@@ -24,6 +24,8 @@
908
24
#include "mir/scene/surface.h"
24
#include "mir/scene/surface.h"
909
25
#include "mir/input/mir_touchpad_config.h"
25
#include "mir/input/mir_touchpad_config.h"
910
26
#include "mir/input/mir_input_config.h"
26
#include "mir/input/mir_input_config.h"
911
27
#include "mir/input/input_device.h"
912
28
#include "mir/input/touchscreen_settings.h"
913
27
29
914
28
#include "mir_test_framework/headless_in_process_server.h"
30
#include "mir_test_framework/headless_in_process_server.h"
915
29
#include "mir_test_framework/fake_input_device.h"
31
#include "mir_test_framework/fake_input_device.h"
916
@@ -95,6 +97,22 @@
917
95
    }
97
    }
918
96
};
98
};
919
97
99
920
100
921
101
template<typename SetCallback, typename Apply>
922
102
void apply_and_wait_for_completion(MirConnection* connection, SetCallback set_callback, Apply apply)
923
103
{
924
104
    mt::Signal change_complete;
925
105
    set_callback(connection,
926
106
                 [](MirConnection*, void* context)
927
107
                 {
928
108
                     static_cast<mt::Signal*>(context)->raise(); 
929
109
                 },
930
110
                 &change_complete
931
111
                );
932
112
    apply(connection);
933
113
    ASSERT_TRUE(change_complete.wait_for(10s));
934
114
}
935
115
936
98
const int surface_width = 100;
116
const int surface_width = 100;
937
99
const int surface_height = 100;
117
const int surface_height = 100;
938
100
118
939
@@ -356,6 +374,35 @@
940
356
    }
374
    }
941
357
};
375
};
942
358
376
943
377
struct TestClientInputWithTwoScreens : TestClientInput
944
378
{
945
379
    geom::Rectangle second_screen{{1000,0}, {200,400}};
946
380
947
381
    int const width{second_screen.size.width.as_int()};
948
382
    int const height{second_screen.size.height.as_int()};
949
383
    float const touch_range = mtf::FakeInputDevice::maximum_touch_axis_value - mtf::FakeInputDevice::minimum_touch_axis_value + 1;
950
384
    float const scale_to_device_width = touch_range / width;
951
385
    float const scale_to_device_height = touch_range / height;
952
386
953
387
    void SetUp() override
954
388
    {
955
389
        initial_display_layout({screen_geometry, second_screen});
956
390
957
391
        server.wrap_shell(
958
392
            [this](std::shared_ptr<mir::shell::Shell> const& wrapped)
959
393
            {
960
394
                shell = std::make_shared<mtf::PlacementApplyingShell>(wrapped, input_regions, positions);
961
395
                return shell;
962
396
            });
963
397
964
398
        HeadlessInProcessServer::SetUp();
965
399
966
400
        // make surface span over both outputs to test coordinates mapped into second ouput:
967
401
        positions[first] =
968
402
            geom::Rectangle{{0, 0}, {second_screen.bottom_right().x.as_int(), second_screen.bottom_right().y.as_int()}};
969
403
    }
970
404
};
971
405
972
359
}
406
}
973
360
407
974
361
TEST_F(TestClientInput, clients_receive_keys)
408
TEST_F(TestClientInput, clients_receive_keys)
975
@@ -1246,19 +1293,14 @@
976
1246
    mir_pointer_config_set_acceleration(pointer_config, mir_pointer_acceleration_adaptive);
1293
    mir_pointer_config_set_acceleration(pointer_config, mir_pointer_acceleration_adaptive);
977
1247
    mir_pointer_config_set_acceleration_bias(pointer_config, increased_acceleration);
1294
    mir_pointer_config_set_acceleration_bias(pointer_config, increased_acceleration);
978
1248
1295
981
1249
    mt::Signal changes_complete;
1296
    apply_and_wait_for_completion(
980
1250
    mir_connection_set_input_config_change_callback(
982
1251
        a_client.connection,
1297
        a_client.connection,
984
1252
        [](MirConnection*, void* context)
1298
        mir_connection_set_input_config_change_callback,
985
1299
        [config](MirConnection* connection)
986
1253
        {
1300
        {
995
1254
            static_cast<mt::Signal*>(context)->raise();
1301
            mir_connection_apply_session_input_config(connection, config);
996
1255
        },
1302
            mir_input_config_release(config);
997
1256
        &changes_complete
1303
        });
990
1257
        );
991
1258
    mir_connection_apply_session_input_config(a_client.connection, config);
992
1259
    mir_input_config_release(config);
993
1260
994
1261
    EXPECT_TRUE(changes_complete.wait_for(10s));
998
1262
1304
999
1263
    config = mir_connection_create_input_config(a_client.connection);
1305
    config = mir_connection_create_input_config(a_client.connection);
1000
1264
    mouse = get_mutable_device_with_capabilities(config, mir_input_device_capability_pointer);
1306
    mouse = get_mutable_device_with_capabilities(config, mir_input_device_capability_pointer);
1001
@@ -1353,19 +1395,14 @@
1002
1353
1395
1003
1354
    mir_pointer_config_set_acceleration(pointer_config, mir_pointer_acceleration_adaptive);
1396
    mir_pointer_config_set_acceleration(pointer_config, mir_pointer_acceleration_adaptive);
1004
1355
1397
1007
1356
    mt::Signal changes_complete;
1398
    apply_and_wait_for_completion(
1006
1357
    mir_connection_set_input_config_change_callback(
1008
1358
        unfocused_client.connection,
1399
        unfocused_client.connection,
1010
1359
        [](MirConnection*, void* context)
1400
        mir_connection_set_input_config_change_callback,
1011
1401
        [config](MirConnection* connection)
1012
1360
        {
1402
        {
1021
1361
            static_cast<mt::Signal*>(context)->raise();
1403
            mir_connection_set_base_input_config(connection, config);
1022
1362
        },
1404
            mir_input_config_release(config);
1023
1363
        &changes_complete
1405
        });
1016
1364
        );
1017
1365
    mir_connection_set_base_input_config(unfocused_client.connection, config);
1018
1366
    mir_input_config_release(config);
1019
1367
1020
1368
    EXPECT_TRUE(changes_complete.wait_for(10s));
1024
1369
1406
1025
1370
    config = mir_connection_create_input_config(unfocused_client.connection);
1407
    config = mir_connection_create_input_config(unfocused_client.connection);
1026
1371
    mouse = get_mutable_device_with_capabilities(config, mir_input_device_capability_pointer);
1408
    mouse = get_mutable_device_with_capabilities(config, mir_input_device_capability_pointer);
1027
@@ -1414,19 +1451,14 @@
1028
1414
1451
1029
1415
    mir_pointer_config_set_acceleration(pointer_config, mir_pointer_acceleration_adaptive);
1452
    mir_pointer_config_set_acceleration(pointer_config, mir_pointer_acceleration_adaptive);
1030
1416
1453
1033
1417
    mt::Signal changes_complete;
1454
    apply_and_wait_for_completion(
1032
1418
    mir_connection_set_input_config_change_callback(
1034
1419
        focused_client.connection,
1455
        focused_client.connection,
1036
1420
        [](MirConnection*, void* context)
1456
        mir_connection_set_input_config_change_callback,
1037
1457
        [config](MirConnection* connection)
1038
1421
        {
1458
        {
1047
1422
            static_cast<mt::Signal*>(context)->raise();
1459
            mir_connection_set_base_input_config(connection, config);
1048
1423
        },
1460
            mir_input_config_release(config);
1049
1424
        &changes_complete
1461
        });
1042
1425
        );
1043
1426
    mir_connection_set_base_input_config(focused_client.connection, config);
1044
1427
    mir_input_config_release(config);
1045
1428
1046
1429
    changes_complete.wait_for(10s);
1050
1430
1462
1051
1431
    config = mir_connection_create_input_config(focused_client.connection);
1463
    config = mir_connection_create_input_config(focused_client.connection);
1052
1432
    mouse = get_mutable_device_with_capabilities(config, mir_input_device_capability_pointer);
1464
    mouse = get_mutable_device_with_capabilities(config, mir_input_device_capability_pointer);
1053
@@ -1511,3 +1543,145 @@
1054
1511
1543
1055
1512
    EXPECT_TRUE(wait_for_error.wait_for(10s));
1544
    EXPECT_TRUE(wait_for_error.wait_for(10s));
1056
1513
}
1545
}
1057
1546
1058
1547
TEST_F(TestClientInput, touchscreen_config_is_mutable)
1059
1548
{
1060
1549
    wait_for_input_devices();
1061
1550
1062
1551
    Client a_client(new_connection(), first);
1063
1552
    auto config = mir_connection_create_input_config(a_client.connection);
1064
1553
    auto touchscreen = get_mutable_device_with_capabilities(config,
1065
1554
                                                 mir_input_device_capability_touchscreen|
1066
1555
                                                 mir_input_device_capability_multitouch);
1067
1556
    ASSERT_THAT(touchscreen, Ne(nullptr));
1068
1557
1069
1558
    auto touchscreen_config = mir_input_device_get_mutable_touchscreen_config(touchscreen);
1070
1559
1071
1560
    mir_touchscreen_config_set_output_id(touchscreen_config, 4);
1072
1561
    mir_touchscreen_config_set_mapping_mode(touchscreen_config, mir_touchscreen_mapping_mode_to_display_wall);
1073
1562
1074
1563
    EXPECT_THAT(mir_touchscreen_config_get_mapping_mode(touchscreen_config), Eq(mir_touchscreen_mapping_mode_to_display_wall));
1075
1564
    EXPECT_THAT(mir_touchscreen_config_get_output_id(touchscreen_config), Eq(4));
1076
1565
1077
1566
    mir_input_config_release(config);
1078
1567
}
1079
1568
1080
1569
TEST_F(TestClientInputWithTwoScreens, touchscreen_can_be_mapped_to_second_output)
1081
1570
{
1082
1571
    wait_for_input_devices();
1083
1572
    uint32_t const second_output = 2;
1084
1573
    int const touch_x = 10;
1085
1574
    int const touch_y = 10;
1086
1575
1087
1576
    int const expected_x = touch_x + second_screen.top_left.x.as_int();
1088
1577
    int const expected_y = touch_y + second_screen.top_left.y.as_int();
1089
1578
1090
1579
    mt::Signal touchscreen_ready;
1091
1580
    fake_touch_screen->on_new_configuration_do(
1092
1581
        [&touchscreen_ready, second_output](mi::InputDevice const& dev)
1093
1582
        {
1094
1583
            auto ts = dev.get_touchscreen_settings();
1095
1584
            if (ts.is_set() && ts.value().output_id == second_output)
1096
1585
                touchscreen_ready.raise();
1097
1586
        });
1098
1587
1099
1588
    Client client(new_connection(), first);
1100
1589
    auto config = mir_connection_create_input_config(client.connection);
1101
1590
    auto touchscreen = get_mutable_device_with_capabilities(config,
1102
1591
                                                            mir_input_device_capability_touchscreen|
1103
1592
                                                            mir_input_device_capability_multitouch);
1104
1593
    auto touchscreen_config = mir_input_device_get_mutable_touchscreen_config(touchscreen);
1105
1594
    mir_touchscreen_config_set_output_id(touchscreen_config, second_output);
1106
1595
    mir_touchscreen_config_set_mapping_mode(touchscreen_config, mir_touchscreen_mapping_mode_to_output);
1107
1596
1108
1597
    apply_and_wait_for_completion(
1109
1598
        client.connection,
1110
1599
        mir_connection_set_input_config_change_callback,
1111
1600
        [config](MirConnection* connection)
1112
1601
        {
1113
1602
            mir_connection_set_base_input_config(connection, config);
1114
1603
            mir_input_config_release(config);
1115
1604
        });
1116
1605
1117
1606
    EXPECT_TRUE(touchscreen_ready.wait_for(10s));
1118
1607
    EXPECT_CALL(client, handle_input(mt::TouchEvent(expected_x, expected_y)))
1119
1608
        .WillOnce(mt::WakeUp(&client.all_events_received));
1120
1609
    fake_touch_screen->emit_event(mis::a_touch_event()
1121
1610
                           .at_position({touch_x*scale_to_device_width, touch_y*scale_to_device_height}));
1122
1611
1123
1612
    EXPECT_TRUE(client.all_events_received.wait_for(10s));
1124
1613
}
1125
1614
1126
1615
TEST_F(TestClientInputWithTwoScreens, touchscreen_mapped_to_deactivated_output_is_filtered_out)
1127
1616
{
1128
1617
    wait_for_input_devices();
1129
1618
    uint32_t const second_output = 2;
1130
1619
    int const touch_x = 10;
1131
1620
    int const touch_y = 10;
1132
1621
1133
1622
    int const expected_x = second_screen.top_left.x.as_int() + touch_x;
1134
1623
    int const expected_y = second_screen.top_left.y.as_int() + touch_y;
1135
1624
1136
1625
    Client client(new_connection(), first);
1137
1626
    auto display_config = mir_connection_create_display_configuration(client.connection);
1138
1627
    auto second_output_ptr = mir_display_config_get_mutable_output(display_config, 1);
1139
1628
    mir_output_set_power_mode(second_output_ptr, mir_power_mode_off);
1140
1629
1141
1630
    apply_and_wait_for_completion(
1142
1631
        client.connection,
1143
1632
        mir_connection_set_display_config_change_callback,
1144
1633
        [display_config](MirConnection* con)
1145
1634
        {
1146
1635
            mir_connection_preview_base_display_configuration(con, display_config, 10);
1147
1636
        });
1148
1637
1149
1638
    apply_and_wait_for_completion(
1150
1639
        client.connection,
1151
1640
        mir_connection_set_display_config_change_callback,
1152
1641
        [display_config](MirConnection* con)
1153
1642
        {
1154
1643
            mir_connection_confirm_base_display_configuration(con, display_config);
1155
1644
            mir_display_config_release(display_config);
1156
1645
        });
1157
1646
1158
1647
    display_config = mir_connection_create_display_configuration(client.connection);
1159
1648
    ASSERT_THAT(mir_output_get_power_mode(mir_display_config_get_output(display_config, 1)), Eq(mir_power_mode_off));
1160
1649
    mir_display_config_release(display_config);
1161
1650
1162
1651
    mt::Signal touchscreen_ready;
1163
1652
    fake_touch_screen->on_new_configuration_do(
1164
1653
        [&touchscreen_ready, second_output](mi::InputDevice const& dev)
1165
1654
        {
1166
1655
            auto ts = dev.get_touchscreen_settings();
1167
1656
            if (ts.is_set()
1168
1657
                && ts.value().output_id == second_output
1169
1658
                && ts.value().mapping_mode == mir_touchscreen_mapping_mode_to_output)
1170
1659
                touchscreen_ready.raise();
1171
1660
        });
1172
1661
1173
1662
    auto config = mir_connection_create_input_config(client.connection);
1174
1663
    auto touchscreen = get_mutable_device_with_capabilities(config,
1175
1664
                                                            mir_input_device_capability_touchscreen|
1176
1665
                                                            mir_input_device_capability_multitouch);
1177
1666
    auto touchscreen_config = mir_input_device_get_mutable_touchscreen_config(touchscreen);
1178
1667
1179
1668
    mir_touchscreen_config_set_output_id(touchscreen_config, second_output);
1180
1669
    mir_touchscreen_config_set_mapping_mode(touchscreen_config, mir_touchscreen_mapping_mode_to_output);
1181
1670
1182
1671
    apply_and_wait_for_completion(
1183
1672
        client.connection,
1184
1673
        mir_connection_set_input_config_change_callback,
1185
1674
        [config](MirConnection* connection)
1186
1675
        {
1187
1676
            mir_connection_set_base_input_config(connection, config);
1188
1677
            mir_input_config_release(config);
1189
1678
        });
1190
1679
1191
1680
    EXPECT_TRUE(touchscreen_ready.wait_for(10s));
1192
1681
    ON_CALL(client, handle_input(mt::TouchEvent(expected_x, expected_y)))
1193
1682
        .WillByDefault(mt::WakeUp(&client.all_events_received));
1194
1683
    fake_touch_screen->emit_event(mis::a_touch_event()
1195
1684
                           .at_position({touch_x*scale_to_device_width, touch_y*scale_to_device_height}));
1196
1685
1197
1686
    EXPECT_FALSE(client.all_events_received.wait_for(5s));
1198
1687
}
1199
1514
1688
1200
=== modified file 'tests/include/mir/test/doubles/mock_input_seat.h'
1201
--- tests/include/mir/test/doubles/mock_input_seat.h	2017-01-18 02:29:37 +0000
1202
+++ tests/include/mir/test/doubles/mock_input_seat.h	2017-03-01 16:08:29 +0000
1203
@@ -21,6 +21,7 @@
1204
21
21
1205
22
#include "mir/input/seat.h"
22
#include "mir/input/seat.h"
1206
23
#include "mir/input/device.h"
23
#include "mir/input/device.h"
1207
24
#include "mir/input/input_sink.h"
1208
24
#include "mir/test/gmock_fixes.h"
25
#include "mir/test/gmock_fixes.h"
1209
25
26
1210
26
#include <gmock/gmock.h>
27
#include <gmock/gmock.h>
1211
@@ -36,13 +37,14 @@
1212
36
    MOCK_METHOD1(add_device, void(input::Device const& device));
37
    MOCK_METHOD1(add_device, void(input::Device const& device));
1213
37
    MOCK_METHOD1(remove_device, void(input::Device const& device));
38
    MOCK_METHOD1(remove_device, void(input::Device const& device));
1214
38
    MOCK_METHOD1(dispatch_event, void(MirEvent& event));
39
    MOCK_METHOD1(dispatch_event, void(MirEvent& event));
1215
39
    MOCK_METHOD1(get_rectangle_for, geometry::Rectangle(input::Device const& dev));
1216
40
    MOCK_METHOD0(create_device_state, mir::EventUPtr());
40
    MOCK_METHOD0(create_device_state, mir::EventUPtr());
1217
41
    MOCK_METHOD2(set_key_state, void(input::Device const&, std::vector<uint32_t> const&));
41
    MOCK_METHOD2(set_key_state, void(input::Device const&, std::vector<uint32_t> const&));
1218
42
    MOCK_METHOD2(set_pointer_state, void (input::Device const&, MirPointerButtons));
42
    MOCK_METHOD2(set_pointer_state, void (input::Device const&, MirPointerButtons));
1219
43
    MOCK_METHOD2(set_cursor_position, void (float, float));
43
    MOCK_METHOD2(set_cursor_position, void (float, float));
1220
44
    MOCK_METHOD1(set_confinement_regions, void(geometry::Rectangles const&));
44
    MOCK_METHOD1(set_confinement_regions, void(geometry::Rectangles const&));
1221
45
    MOCK_METHOD0(reset_confinement_regions, void());
45
    MOCK_METHOD0(reset_confinement_regions, void());
1222
46
    MOCK_CONST_METHOD0(bounding_rectangle, geometry::Rectangle());
1223
47
    MOCK_CONST_METHOD1(output_info, input::OutputInfo(uint32_t));
1224
46
};
48
};
1225
47
}
49
}
1226
48
}
50
}
1227
49
51
1228
=== modified file 'tests/include/mir/test/doubles/mock_input_sink.h'
1229
--- tests/include/mir/test/doubles/mock_input_sink.h	2016-07-07 09:59:19 +0000
1230
+++ tests/include/mir/test/doubles/mock_input_sink.h	2017-03-01 16:08:29 +0000
1231
@@ -35,6 +35,7 @@
1232
35
    MOCK_METHOD1(handle_input, void(MirEvent&));
35
    MOCK_METHOD1(handle_input, void(MirEvent&));
1233
36
    MOCK_METHOD1(confine_pointer, void(mir::geometry::Point&));
36
    MOCK_METHOD1(confine_pointer, void(mir::geometry::Point&));
1234
37
    MOCK_CONST_METHOD0(bounding_rectangle, mir::geometry::Rectangle());
37
    MOCK_CONST_METHOD0(bounding_rectangle, mir::geometry::Rectangle());
1235
38
    MOCK_CONST_METHOD1(output_info, mir::input::OutputInfo(uint32_t));
1236
38
    MOCK_METHOD1(key_state, void(std::vector<uint32_t> const&));
39
    MOCK_METHOD1(key_state, void(std::vector<uint32_t> const&));
1237
39
    MOCK_METHOD1(pointer_state, void(MirPointerButtons));
40
    MOCK_METHOD1(pointer_state, void(MirPointerButtons));
1238
40
};
41
};
1239
41
42
1240
=== modified file 'tests/integration-tests/input/test_single_seat_setup.cpp'
1241
--- tests/integration-tests/input/test_single_seat_setup.cpp	2017-02-15 07:38:33 +0000
1242
+++ tests/integration-tests/input/test_single_seat_setup.cpp	2017-03-01 16:08:29 +0000
1243
@@ -24,7 +24,6 @@
1244
24
#include "mir/test/doubles/mock_input_device.h"
24
#include "mir/test/doubles/mock_input_device.h"
1245
25
#include "mir/test/doubles/mock_input_device_observer.h"
25
#include "mir/test/doubles/mock_input_device_observer.h"
1246
26
#include "mir/test/doubles/mock_input_dispatcher.h"
26
#include "mir/test/doubles/mock_input_dispatcher.h"
1247
27
#include "mir/test/doubles/mock_input_region.h"
1248
28
#include "mir/test/doubles/mock_touch_visualizer.h"
27
#include "mir/test/doubles/mock_touch_visualizer.h"
1249
29
#include "mir/test/doubles/mock_cursor_listener.h"
28
#include "mir/test/doubles/mock_cursor_listener.h"
1250
30
#include "mir/test/doubles/mock_input_manager.h"
29
#include "mir/test/doubles/mock_input_manager.h"
1251
@@ -36,10 +35,12 @@
1252
36
#include "mir/test/event_matchers.h"
35
#include "mir/test/event_matchers.h"
1253
37
#include "mir/test/doubles/advanceable_clock.h"
36
#include "mir/test/doubles/advanceable_clock.h"
1254
38
#include "mir/test/fake_shared.h"
37
#include "mir/test/fake_shared.h"
1255
38
#include "mir/test/doubles/stub_display_configuration.h"
1256
39
39
1257
40
#include "mir/dispatch/multiplexing_dispatchable.h"
40
#include "mir/dispatch/multiplexing_dispatchable.h"
1258
41
#include "mir/cookie/authority.h"
41
#include "mir/cookie/authority.h"
1259
42
#include "mir/graphics/buffer.h"
42
#include "mir/graphics/buffer.h"
1260
43
#include "mir/graphics/display_configuration_observer.h"
1261
43
44
1262
44
#include "mir/input/device.h"
45
#include "mir/input/device.h"
1263
45
#include "mir/input/xkb_mapper.h"
46
#include "mir/input/xkb_mapper.h"
1264
@@ -73,17 +74,47 @@
1265
73
}
74
}
1266
74
}
75
}
1267
75
76
1268
77
namespace
1269
78
{
1270
79
1271
76
MATCHER_P(DeviceMatches, device_info, "")
80
MATCHER_P(DeviceMatches, device_info, "")
1272
77
{
81
{
1273
78
    return arg.name() == device_info.name &&
82
    return arg.name() == device_info.name &&
1274
79
        arg.unique_id() == device_info.unique_id;
83
        arg.unique_id() == device_info.unique_id;
1275
80
}
84
}
1276
81
85
1277
86
struct FakeDisplayConfigurationObserverRegistrar : mir::ObserverRegistrar<mir::graphics::DisplayConfigurationObserver>
1278
87
{
1279
88
    using Observer = mir::graphics::DisplayConfigurationObserver;
1280
89
    mtd::StubDisplayConfig output{{geom::Rectangle{{0, 0}, {100, 100}}}};
1281
90
    void register_interest(std::weak_ptr<Observer> const& obs) override
1282
91
    {
1283
92
        observer = obs;
1284
93
        auto o = observer.lock();
1285
94
        o->initial_configuration(mt::fake_shared(output));
1286
95
    }
1287
96
    void register_interest(
1288
97
        std::weak_ptr<Observer> const& obs,
1289
98
        mir::Executor&) override
1290
99
    {
1291
100
        observer = obs;
1292
101
    }
1293
102
    void unregister_interest(Observer const&) override
1294
103
    {
1295
104
        observer.reset();
1296
105
    }
1297
106
    void update_output(geom::Size const& output_size)
1298
107
    {
1299
108
        output.outputs[0].modes[0].size = output_size;
1300
109
        auto o = observer.lock();
1301
110
        o->configuration_applied(mt::fake_shared(output));
1302
111
    }
1303
112
    std::weak_ptr<Observer> observer;
1304
113
};
1305
82
struct SingleSeatInputDeviceHubSetup : ::testing::Test
114
struct SingleSeatInputDeviceHubSetup : ::testing::Test
1306
83
{
115
{
1307
84
    mtd::TriggeredMainLoop observer_loop;
116
    mtd::TriggeredMainLoop observer_loop;
1308
85
    NiceMock<mtd::MockInputDispatcher> mock_dispatcher;
117
    NiceMock<mtd::MockInputDispatcher> mock_dispatcher;
1309
86
    NiceMock<mtd::MockInputRegion> mock_region;
1310
87
    std::shared_ptr<mir::cookie::Authority> cookie_authority = mir::cookie::Authority::create();
118
    std::shared_ptr<mir::cookie::Authority> cookie_authority = mir::cookie::Authority::create();
1311
88
    NiceMock<mtd::MockCursorListener> mock_cursor_listener;
119
    NiceMock<mtd::MockCursorListener> mock_cursor_listener;
1312
89
    NiceMock<mtd::MockTouchVisualizer> mock_visualizer;
120
    NiceMock<mtd::MockTouchVisualizer> mock_visualizer;
1313
@@ -95,12 +126,14 @@
1314
95
    mtd::MockInputManager mock_input_manager;
126
    mtd::MockInputManager mock_input_manager;
1315
96
    mtd::StubSessionContainer stub_session_container;
127
    mtd::StubSessionContainer stub_session_container;
1316
97
    ms::BroadcastingSessionEventSink session_event_sink;
128
    ms::BroadcastingSessionEventSink session_event_sink;
1323
98
    mi::BasicSeat seat{
129
    FakeDisplayConfigurationObserverRegistrar display_config;
1324
99
        mt::fake_shared(mock_dispatcher),mt::fake_shared(mock_visualizer), mt::fake_shared(mock_cursor_listener),
130
    mi::BasicSeat seat{mt::fake_shared(mock_dispatcher),      mt::fake_shared(mock_visualizer),
1325
100
        mt::fake_shared(mock_region), mt::fake_shared(key_mapper), mt::fake_shared(clock), mt::fake_shared(mock_seat_observer)};
131
                       mt::fake_shared(mock_cursor_listener), mt::fake_shared(display_config),
1326
101
    mi::DefaultInputDeviceHub hub{
132
                       mt::fake_shared(key_mapper),           mt::fake_shared(clock),
1327
102
        mt::fake_shared(seat), mt::fake_shared(multiplexer), mt::fake_shared(observer_loop),
133
                       mt::fake_shared(mock_seat_observer)};
1328
103
        cookie_authority, mt::fake_shared(key_mapper), mt::fake_shared(mock_status_listener)};
134
    mi::DefaultInputDeviceHub hub{mt::fake_shared(seat),          mt::fake_shared(multiplexer),
1329
135
                                  mt::fake_shared(observer_loop), cookie_authority,
1330
136
                                  mt::fake_shared(key_mapper),    mt::fake_shared(mock_status_listener)};
1331
104
    NiceMock<mtd::MockInputDeviceObserver> mock_observer;
137
    NiceMock<mtd::MockInputDeviceObserver> mock_observer;
1332
105
    mi::ConfigChanger changer{
138
    mi::ConfigChanger changer{
1333
106
        mt::fake_shared(mock_input_manager),
139
        mt::fake_shared(mock_input_manager),
1334
@@ -130,6 +163,8 @@
1335
130
    }
163
    }
1336
131
};
164
};
1337
132
165
1338
166
}
1339
167
1340
133
TEST_F(SingleSeatInputDeviceHubSetup, input_sink_posts_events_to_input_dispatcher)
168
TEST_F(SingleSeatInputDeviceHubSetup, input_sink_posts_events_to_input_dispatcher)
1341
134
{
169
{
1342
135
    mi::InputSink* sink;
170
    mi::InputSink* sink;
1343
@@ -198,13 +233,12 @@
1344
198
    sink->handle_input(*touch_event_4);
233
    sink->handle_input(*touch_event_4);
1345
199
}
234
}
1346
200
235
1347
201
1348
202
TEST_F(SingleSeatInputDeviceHubSetup, tracks_pointer_position)
236
TEST_F(SingleSeatInputDeviceHubSetup, tracks_pointer_position)
1349
203
{
237
{
1350
204
    geom::Point first{10,10}, second{20,20}, third{10,30};
238
    geom::Point first{10,10}, second{20,20}, third{10,30};
1354
205
    EXPECT_CALL(mock_region, confine(first));
239
    EXPECT_CALL(mock_cursor_listener, cursor_moved_to(first.x.as_int(), first.y.as_int()));
1355
206
    EXPECT_CALL(mock_region, confine(second));
240
    EXPECT_CALL(mock_cursor_listener, cursor_moved_to(second.x.as_int(), second.y.as_int()));
1356
207
    EXPECT_CALL(mock_region, confine(third));
241
    EXPECT_CALL(mock_cursor_listener, cursor_moved_to(third.x.as_int(), third.y.as_int()));
1357
208
242
1358
209
    mi::InputSink* sink;
243
    mi::InputSink* sink;
1359
210
    mi::EventBuilder* builder;
244
    mi::EventBuilder* builder;
1360
@@ -223,9 +257,8 @@
1361
223
TEST_F(SingleSeatInputDeviceHubSetup, confines_pointer_movement)
257
TEST_F(SingleSeatInputDeviceHubSetup, confines_pointer_movement)
1362
224
{
258
{
1363
225
    geom::Point confined_pos{10, 18};
259
    geom::Point confined_pos{10, 18};
1364
260
    display_config.update_output(geom::Size{confined_pos.x.as_int() + 1, confined_pos.y.as_int() + 1});
1365
226
261
1366
227
    ON_CALL(mock_region,confine(_))
1367
228
        .WillByDefault(SetArgReferee<0>(confined_pos));
1368
229
    EXPECT_CALL(mock_cursor_listener, cursor_moved_to(confined_pos.x.as_int(), confined_pos.y.as_int())).Times(2);
262
    EXPECT_CALL(mock_cursor_listener, cursor_moved_to(confined_pos.x.as_int(), confined_pos.y.as_int())).Times(2);
1369
230
263
1370
231
    mi::InputSink* sink;
264
    mi::InputSink* sink;
1371
232
265
1372
=== modified file 'tests/mir_test_framework/fake_input_device_impl.cpp'
1373
--- tests/mir_test_framework/fake_input_device_impl.cpp	2017-02-03 01:10:42 +0000
1374
+++ tests/mir_test_framework/fake_input_device_impl.cpp	2017-03-01 16:08:29 +0000
1375
@@ -110,14 +110,27 @@
1376
110
        });
110
        });
1377
111
}
111
}
1378
112
112
1379
113
void mtf::FakeInputDeviceImpl::on_new_configuration_do(std::function<void(mir::input::InputDevice const& device)> callback)
1380
114
{
1381
115
    device->set_apply_settings_callback(callback);
1382
116
}
1383
117
void mtf::FakeInputDeviceImpl::InputDevice::set_apply_settings_callback(std::function<void(mir::input::InputDevice const&)> const& callback)
1384
118
{
1385
119
    std::lock_guard<std::mutex> lock(config_callback_mutex);
1386
120
    this->callback = callback;
1387
121
}
1388
113
122
1389
114
mtf::FakeInputDeviceImpl::InputDevice::InputDevice(mi::InputDeviceInfo const& info,
123
mtf::FakeInputDeviceImpl::InputDevice::InputDevice(mi::InputDeviceInfo const& info,
1390
115
                                                   std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable)
124
                                                   std::shared_ptr<mir::dispatch::Dispatchable> const& dispatchable)
1392
116
    : info(info), queue{dispatchable}, buttons{0}
125
    : info(info), queue{dispatchable}, buttons{0}, callback([](mir::input::InputDevice const&){})
1393
117
{
126
{
1394
118
    // the default setup results in a direct mapping of input velocity to output velocity.
127
    // the default setup results in a direct mapping of input velocity to output velocity.
1395
119
    settings.acceleration = mir_pointer_acceleration_none;
128
    settings.acceleration = mir_pointer_acceleration_none;
1396
120
    settings.cursor_acceleration_bias = 0.0;
129
    settings.cursor_acceleration_bias = 0.0;
1397
130
1398
131
    // add default setup for touchscreen..
1399
132
    if (contains(info.capabilities, mi::DeviceCapability::touchscreen))
1400
133
        touchscreen = mi::TouchscreenSettings{};
1401
121
}
134
}
1402
122
135
1403
123
void mtf::FakeInputDeviceImpl::InputDevice::synthesize_events(synthesis::KeyParameters const& key_params)
136
void mtf::FakeInputDeviceImpl::InputDevice::synthesize_events(synthesis::KeyParameters const& key_params)
1404
@@ -211,13 +224,15 @@
1405
211
    float abs_x = touch.abs_x;
224
    float abs_x = touch.abs_x;
1406
212
    float abs_y = touch.abs_y;
225
    float abs_y = touch.abs_y;
1407
213
    map_touch_coordinates(abs_x, abs_y);
226
    map_touch_coordinates(abs_x, abs_y);
1415
214
    // those values would need scaling too as soon as they can be controlled by the caller
227
1416
215
228
    if (is_output_active())
1417
216
    auto touch_event = builder->touch_event(
229
    {
1418
217
        event_time,
230
        auto touch_event = builder->touch_event(
1419
218
        {{MirTouchId{1}, touch_action, mir_touch_tooltype_finger, abs_x, abs_y, 1.0f, 8.0f, 5.0f, 0.0f}});
231
            event_time,
1420
219
232
            {{MirTouchId{1}, touch_action, mir_touch_tooltype_finger, abs_x, abs_y, 1.0f, 8.0f, 5.0f, 0.0f}});
1421
220
    sink->handle_input(*touch_event);
233
1422
234
        sink->handle_input(*touch_event);
1423
235
    }
1424
221
}
236
}
1425
222
237
1426
223
mir::optional_value<mi::PointerSettings> mtf::FakeInputDeviceImpl::InputDevice::get_pointer_settings() const
238
mir::optional_value<mi::PointerSettings> mtf::FakeInputDeviceImpl::InputDevice::get_pointer_settings() const
1427
@@ -235,6 +250,7 @@
1428
235
    if (!contains(info.capabilities, mi::DeviceCapability::pointer))
250
    if (!contains(info.capabilities, mi::DeviceCapability::pointer))
1429
236
        return;
251
        return;
1430
237
    this->settings = settings;
252
    this->settings = settings;
1431
253
    trigger_callback();
1432
238
}
254
}
1433
239
255
1434
240
mir::optional_value<mi::TouchpadSettings> mtf::FakeInputDeviceImpl::InputDevice::get_touchpad_settings() const
256
mir::optional_value<mi::TouchpadSettings> mtf::FakeInputDeviceImpl::InputDevice::get_touchpad_settings() const
1435
@@ -250,6 +266,17 @@
1436
250
{
266
{
1437
251
    // Not applicable for configuration since FakeInputDevice just
267
    // Not applicable for configuration since FakeInputDevice just
1438
252
    // forwards already interpreted events.
268
    // forwards already interpreted events.
1439
269
    trigger_callback();
1440
270
}
1441
271
1442
272
void mtf::FakeInputDeviceImpl::InputDevice::trigger_callback() const
1443
273
{
1444
274
    decltype(callback) stored_callback;
1445
275
    {
1446
276
        std::lock_guard<std::mutex> lock(config_callback_mutex);
1447
277
        stored_callback = callback;
1448
278
    }
1449
279
    stored_callback(*this);
1450
253
}
280
}
1451
254
281
1452
255
mir::optional_value<mi::TouchscreenSettings> mtf::FakeInputDeviceImpl::InputDevice::get_touchscreen_settings() const
282
mir::optional_value<mi::TouchscreenSettings> mtf::FakeInputDeviceImpl::InputDevice::get_touchscreen_settings() const
1453
@@ -267,17 +294,22 @@
1454
267
    if (!contains(info.capabilities, mi::DeviceCapability::touchscreen))
294
    if (!contains(info.capabilities, mi::DeviceCapability::touchscreen))
1455
268
        return;
295
        return;
1456
269
    this->touchscreen = new_settings;
296
    this->touchscreen = new_settings;
1457
297
1458
298
    trigger_callback();
1459
270
}
299
}
1460
271
300
1461
272
void mtf::FakeInputDeviceImpl::InputDevice::map_touch_coordinates(float& x, float& y)
301
void mtf::FakeInputDeviceImpl::InputDevice::map_touch_coordinates(float& x, float& y)
1462
273
{
302
{
1465
274
    // TODO take orientation of input sink into account?
303
    auto info = get_output_info();
1464
275
    auto area = sink->bounding_rectangle();
1466
276
    auto touch_range = FakeInputDevice::maximum_touch_axis_value - FakeInputDevice::minimum_touch_axis_value + 1;
304
    auto touch_range = FakeInputDevice::maximum_touch_axis_value - FakeInputDevice::minimum_touch_axis_value + 1;
1471
277
    auto x_scale = area.size.width.as_int() / float(touch_range);
305
    auto const width = info.output_size.width.as_int();
1472
278
    auto y_scale = area.size.height.as_int() / float(touch_range);
306
    auto const height = info.output_size.height.as_int();
1473
279
    x = (x - float(FakeInputDevice::minimum_touch_axis_value))*x_scale + area.top_left.x.as_int();
307
    auto x_scale = width / float(touch_range);
1474
280
    y = (y - float(FakeInputDevice::minimum_touch_axis_value))*y_scale + area.top_left.y.as_int();
308
    auto y_scale = height / float(touch_range);
1475
309
    x = (x - float(FakeInputDevice::minimum_touch_axis_value))*x_scale;
1476
310
    y = (y - float(FakeInputDevice::minimum_touch_axis_value))*y_scale;
1477
311
1478
312
    info.transform_to_scene(x, y);
1479
281
}
313
}
1480
282
314
1481
283
void mtf::FakeInputDeviceImpl::InputDevice::start(mi::InputSink* destination, mi::EventBuilder* event_builder)
315
void mtf::FakeInputDeviceImpl::InputDevice::start(mi::InputSink* destination, mi::EventBuilder* event_builder)
1482
@@ -293,3 +325,33 @@
1483
293
    builder = nullptr;
325
    builder = nullptr;
1484
294
    mtf::StubInputPlatform::unregister_dispatchable(queue);
326
    mtf::StubInputPlatform::unregister_dispatchable(queue);
1485
295
}
327
}
1486
328
1487
329
mi::OutputInfo mtf::FakeInputDeviceImpl::InputDevice::get_output_info() const
1488
330
{
1489
331
    if (touchscreen.mapping_mode == mir_touchscreen_mapping_mode_to_output)
1490
332
    {
1491
333
        return sink->output_info(touchscreen.output_id);
1492
334
    }
1493
335
    else
1494
336
    {
1495
337
        auto scene_bbox = sink->bounding_rectangle();
1496
338
        return mi::OutputInfo(
1497
339
            true,
1498
340
            scene_bbox.size,
1499
341
            mi::OutputInfo::Matrix{{1.0f, 0.0f, float(scene_bbox.top_left.x.as_int()),
1500
342
                                    0.0f, 1.0f, float(scene_bbox.top_left.y.as_int())}});
1501
343
    }
1502
344
}
1503
345
1504
346
bool mtf::FakeInputDeviceImpl::InputDevice::is_output_active() const
1505
347
{
1506
348
    if (!sink)
1507
349
        return false;
1508
350
1509
351
    if (touchscreen.mapping_mode == mir_touchscreen_mapping_mode_to_output)
1510
352
    {
1511
353
        auto output = sink->output_info(touchscreen.output_id);
1512
354
        return output.active;
1513
355
    }
1514
356
    return true;
1515
357
}
1516
296
358
1517
=== modified file 'tests/mir_test_framework/fake_input_device_impl.h'
1518
--- tests/mir_test_framework/fake_input_device_impl.h	2017-02-03 01:10:42 +0000
1519
+++ tests/mir_test_framework/fake_input_device_impl.h	2017-03-01 16:08:29 +0000
1520
@@ -27,8 +27,15 @@
1521
27
#include "mir/input/input_device_info.h"
27
#include "mir/input/input_device_info.h"
1522
28
#include "mir/geometry/point.h"
28
#include "mir/geometry/point.h"
1523
29
29
1524
30
#include <mutex>
1525
31
#include <functional>
1526
32
1527
30
namespace mir
33
namespace mir
1528
31
{
34
{
1529
35
namespace input
1530
36
{
1531
37
class OutputInfo;
1532
38
}
1533
32
namespace dispatch
39
namespace dispatch
1534
33
{
40
{
1535
34
class ActionQueue;
41
class ActionQueue;
1536
@@ -50,6 +57,7 @@
1537
50
    void emit_touch_sequence(std::function<mir::input::synthesis::TouchParameters(int)> const& event_generator,
57
    void emit_touch_sequence(std::function<mir::input::synthesis::TouchParameters(int)> const& event_generator,
1538
51
                             int count,
58
                             int count,
1539
52
                             std::chrono::duration<double> delay) override;
59
                             std::chrono::duration<double> delay) override;
1540
60
    virtual void on_new_configuration_do(std::function<void(mir::input::InputDevice const& device)> callback) override;
1541
53
61
1542
54
private:
62
private:
1543
55
    class InputDevice : public mir::input::InputDevice
63
    class InputDevice : public mir::input::InputDevice
1544
@@ -76,11 +84,15 @@
1545
76
        void apply_settings(mir::input::TouchpadSettings const& settings) override;
84
        void apply_settings(mir::input::TouchpadSettings const& settings) override;
1546
77
        mir::optional_value<mir::input::TouchscreenSettings> get_touchscreen_settings() const override;
85
        mir::optional_value<mir::input::TouchscreenSettings> get_touchscreen_settings() const override;
1547
78
        void apply_settings(mir::input::TouchscreenSettings const& settings) override;
86
        void apply_settings(mir::input::TouchscreenSettings const& settings) override;
1548
87
        void set_apply_settings_callback(std::function<void(mir::input::InputDevice const&)> const& callback);
1549
79
88
1550
80
    private:
89
    private:
1551
81
        MirPointerAction update_buttons(mir::input::synthesis::EventAction action, MirPointerButton button);
90
        MirPointerAction update_buttons(mir::input::synthesis::EventAction action, MirPointerButton button);
1552
82
        void update_position(int rel_x, int rel_y);
91
        void update_position(int rel_x, int rel_y);
1553
83
        void map_touch_coordinates(float& x, float& y);
92
        void map_touch_coordinates(float& x, float& y);
1554
93
        mir::input::OutputInfo get_output_info() const;
1555
94
        bool is_output_active() const;
1556
95
        void trigger_callback() const;
1557
84
96
1558
85
        mir::input::InputSink* sink{nullptr};
97
        mir::input::InputSink* sink{nullptr};
1559
86
        mir::input::EventBuilder* builder{nullptr};
98
        mir::input::EventBuilder* builder{nullptr};
1560
@@ -90,6 +102,8 @@
1561
90
        MirPointerButtons buttons;
102
        MirPointerButtons buttons;
1562
91
        mir::input::PointerSettings settings;
103
        mir::input::PointerSettings settings;
1563
92
        mir::input::TouchscreenSettings touchscreen;
104
        mir::input::TouchscreenSettings touchscreen;
1564
105
        mutable std::mutex config_callback_mutex;
1565
106
        std::function<void(mir::input::InputDevice const&)> callback;
1566
93
    };
107
    };
1567
94
    std::shared_ptr<mir::dispatch::ActionQueue> queue;
108
    std::shared_ptr<mir::dispatch::ActionQueue> queue;
1568
95
    std::shared_ptr<InputDevice> device;
109
    std::shared_ptr<InputDevice> device;
1569
96
110
1570
=== modified file 'tests/unit-tests/input/evdev/test_libinput_device.cpp'
1571
--- tests/unit-tests/input/evdev/test_libinput_device.cpp	2017-01-18 02:29:37 +0000
1572
+++ tests/unit-tests/input/evdev/test_libinput_device.cpp	2017-03-01 16:08:29 +0000
1573
@@ -31,6 +31,7 @@
1574
31
#include "mir/test/event_matchers.h"
31
#include "mir/test/event_matchers.h"
1575
32
#include "mir/test/doubles/mock_libinput.h"
32
#include "mir/test/doubles/mock_libinput.h"
1576
33
#include "mir/test/doubles/mock_input_seat.h"
33
#include "mir/test/doubles/mock_input_seat.h"
1577
34
#include "mir/test/doubles/mock_input_sink.h"
1578
34
#include "mir/test/gmock_fixes.h"
35
#include "mir/test/gmock_fixes.h"
1579
35
#include "mir/test/fake_shared.h"
36
#include "mir/test/fake_shared.h"
1580
36
#include "mir/udev/wrapper.h"
37
#include "mir/udev/wrapper.h"
1581
@@ -63,20 +64,7 @@
1582
63
};
64
};
1583
64
65
1584
65
using namespace ::testing;
66
using namespace ::testing;
1599
66
67
using Matrix = mi::OutputInfo::Matrix;
1586
67
struct MockInputSink : mi::InputSink
1587
68
{
1588
69
    MockInputSink()
1589
70
    {
1590
71
        ON_CALL(*this, bounding_rectangle())
1591
72
            .WillByDefault(Return(geom::Rectangle({0,0}, {100,100})));
1592
73
    }
1593
74
    MOCK_METHOD1(handle_input,void(MirEvent &));
1594
75
    MOCK_METHOD1(confine_pointer, void(geom::Point&));
1595
76
    MOCK_CONST_METHOD0(bounding_rectangle, geom::Rectangle());
1596
77
    MOCK_METHOD1(key_state, void(std::vector<uint32_t> const&));
1597
78
    MOCK_METHOD1(pointer_state, void(MirPointerButtons));
1598
79
};
1600
80
68
1601
81
struct MockEventBuilder : mi::EventBuilder
69
struct MockEventBuilder : mi::EventBuilder
1602
82
{
70
{
1603
@@ -128,7 +116,7 @@
1604
128
struct LibInputDevice : public ::testing::Test
116
struct LibInputDevice : public ::testing::Test
1605
129
{
117
{
1606
130
    mtf::LibInputEnvironment env;
118
    mtf::LibInputEnvironment env;
1608
131
    ::testing::NiceMock<MockInputSink> mock_sink;
119
    ::testing::NiceMock<mtd::MockInputSink> mock_sink;
1609
132
    ::testing::NiceMock<MockEventBuilder> mock_builder;
120
    ::testing::NiceMock<MockEventBuilder> mock_builder;
1610
133
    std::shared_ptr<libinput> lib;
121
    std::shared_ptr<libinput> lib;
1611
134
122
1612
@@ -145,6 +133,8 @@
1613
145
133
1614
146
    LibInputDevice()
134
    LibInputDevice()
1615
147
    {
135
    {
1616
136
        ON_CALL(mock_sink, bounding_rectangle())
1617
137
            .WillByDefault(Return(geom::Rectangle({0,0}, {100,100})));
1618
148
        lib = mie::make_libinput(fake_udev);
138
        lib = mie::make_libinput(fake_udev);
1619
149
    }
139
    }
1620
150
140
1621
@@ -268,6 +258,16 @@
1622
268
{
258
{
1623
269
    libinput_device*const fake_device = setup_touchscreen();
259
    libinput_device*const fake_device = setup_touchscreen();
1624
270
    mie::LibInputDevice touch_screen{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
260
    mie::LibInputDevice touch_screen{mir::report::null_input_report(), mie::make_libinput_device(lib, fake_device)};
1625
261
1626
262
    const float x = 10;
1627
263
    const float y = 5;
1628
264
    const uint32_t output_id = 2;
1629
265
    const float output_x_pos = 20;
1630
266
    const float output_y_pos = 50;
1631
267
    const float screen_x_pos = 70;
1632
268
    const float screen_y_pos = 30;
1633
269
    const int width = 100;
1634
270
    const int height = 200;
1635
271
};
271
};
1636
272
272
1637
273
struct LibInputDeviceOnTouchpad : public LibInputDevice
273
struct LibInputDeviceOnTouchpad : public LibInputDevice
1638
@@ -777,3 +777,169 @@
1639
777
    lib.reset();
777
    lib.reset();
1640
778
    device_ptr.reset();
778
    device_ptr.reset();
1641
779
}
779
}
1642
780
1643
781
TEST_F(LibInputDeviceOnTouchScreen, device_maps_to_selected_output)
1644
782
{
1645
783
    const float x = 30;
1646
784
    const float y = 20;
1647
785
    const uint32_t output_id = 2;
1648
786
    const float output_x_pos = 20;
1649
787
    const float output_y_pos = 50;
1650
788
    const int width = 100;
1651
789
    const int height = 200;
1652
790
1653
791
    EXPECT_CALL(mock_sink, bounding_rectangle())
1654
792
        .Times(0);
1655
793
    EXPECT_CALL(mock_sink, output_info(output_id))
1656
794
        .WillRepeatedly(Return(
1657
795
                mi::OutputInfo{
1658
796
                    true,
1659
797
                    geom::Size{width, height},
1660
798
                    Matrix{{1.0f, 0.0f, output_x_pos,
1661
799
                            0.0f, 1.0f, output_y_pos}}}));
1662
800
    EXPECT_CALL(mock_sink,
1663
801
                handle_input(
1664
802
                    mt::TouchContact(
1665
803
                        0,
1666
804
                        mir_touch_action_down,
1667
805
                        x + output_x_pos,
1668
806
                        y + output_y_pos)))
1669
807
        .Times(1);
1670
808
1671
809
    touch_screen.apply_settings(mi::TouchscreenSettings{output_id, mir_touchscreen_mapping_mode_to_output});
1672
810
    touch_screen.start(&mock_sink, &mock_builder);
1673
811
1674
812
    env.mock_libinput.setup_touch_event(fake_device, LIBINPUT_EVENT_TOUCH_DOWN, event_time_1, 0, x, y, 0, 0, 0, 0);
1675
813
    env.mock_libinput.setup_touch_frame(fake_device, event_time_1);
1676
814
1677
815
    process_events(touch_screen);
1678
816
}
1679
817
1680
818
TEST_F(LibInputDeviceOnTouchScreen, device_maps_to_left_rotated_output)
1681
819
{
1682
820
    const float x = 10;
1683
821
    const float y = 5;
1684
822
    const uint32_t output_id = 2;
1685
823
    const float output_x_pos = 20;
1686
824
    const float output_y_pos = 50;
1687
825
    const int width = 100;
1688
826
    const int height = 200;
1689
827
1690
828
    EXPECT_CALL(mock_sink, bounding_rectangle())
1691
829
        .Times(0);
1692
830
    EXPECT_CALL(mock_sink, output_info(output_id))
1693
831
        .WillRepeatedly(Return(
1694
832
                mi::OutputInfo{
1695
833
                               true,
1696
834
                               geom::Size{width, height},
1697
835
                               Matrix{{0.0f, 1.0f, output_x_pos,
1698
836
                                       -1.0f, 0.0f, width + output_y_pos}}}));
1699
837
    EXPECT_CALL(mock_sink,
1700
838
                handle_input(
1701
839
                    mt::TouchContact(
1702
840
                        0,
1703
841
                        mir_touch_action_down,
1704
842
                        output_x_pos + y,
1705
843
                        output_y_pos + width - x)))
1706
844
        .Times(1);
1707
845
1708
846
    touch_screen.apply_settings(mi::TouchscreenSettings{output_id, mir_touchscreen_mapping_mode_to_output});
1709
847
    touch_screen.start(&mock_sink, &mock_builder);
1710
848
1711
849
    env.mock_libinput.setup_touch_event(fake_device, LIBINPUT_EVENT_TOUCH_DOWN, event_time_1, 0, x, y, 0, 0, 0, 0);
1712
850
    env.mock_libinput.setup_touch_frame(fake_device, event_time_1);
1713
851
1714
852
    process_events(touch_screen);
1715
853
}
1716
854
1717
855
TEST_F(LibInputDeviceOnTouchScreen, device_maps_to_right_rotated_output)
1718
856
{
1719
857
    EXPECT_CALL(mock_sink, bounding_rectangle())
1720
858
        .Times(0);
1721
859
    EXPECT_CALL(mock_sink, output_info(output_id))
1722
860
        .WillRepeatedly(Return(
1723
861
                mi::OutputInfo{
1724
862
                    true,
1725
863
                    geom::Size{width, height},
1726
864
                    Matrix{{0.0f, -1.0f, height + output_x_pos,
1727
865
                            1.0f, 0.0f, output_y_pos}}}));
1728
866
    EXPECT_CALL(mock_sink,
1729
867
                handle_input(
1730
868
                    mt::TouchContact(
1731
869
                        0,
1732
870
                        mir_touch_action_down,
1733
871
                        output_x_pos + height - y,
1734
872
                        output_y_pos + x)))
1735
873
        .Times(1);
1736
874
1737
875
    touch_screen.apply_settings(mi::TouchscreenSettings{output_id, mir_touchscreen_mapping_mode_to_output});
1738
876
    touch_screen.start(&mock_sink, &mock_builder);
1739
877
1740
878
    env.mock_libinput.setup_touch_event(fake_device, LIBINPUT_EVENT_TOUCH_DOWN, event_time_1, 0, x, y, 0, 0, 0, 0);
1741
879
    env.mock_libinput.setup_touch_frame(fake_device, event_time_1);
1742
880
1743
881
    process_events(touch_screen);
1744
882
}
1745
883
1746
884
TEST_F(LibInputDeviceOnTouchScreen, device_maps_to_inverted_output)
1747
885
{
1748
886
    EXPECT_CALL(mock_sink, bounding_rectangle())
1749
887
        .Times(0);
1750
888
    EXPECT_CALL(mock_sink, output_info(output_id))
1751
889
        .WillRepeatedly(Return(
1752
890
                mi::OutputInfo{
1753
891
                    true,
1754
892
                    geom::Size{width, height},
1755
893
                    Matrix{{-1.0f, 0.0f, width + output_x_pos,
1756
894
                            0.0f, -1.0f, height + output_y_pos}}}));
1757
895
    EXPECT_CALL(mock_sink,
1758
896
                handle_input(
1759
897
                    mt::TouchContact(
1760
898
                        0,
1761
899
                        mir_touch_action_down,
1762
900
                        output_x_pos + width - x,
1763
901
                        output_y_pos + height - y)))
1764
902
        .Times(1);
1765
903
1766
904
    touch_screen.apply_settings(mi::TouchscreenSettings{output_id, mir_touchscreen_mapping_mode_to_output});
1767
905
    touch_screen.start(&mock_sink, &mock_builder);
1768
906
1769
907
    env.mock_libinput.setup_touch_event(fake_device, LIBINPUT_EVENT_TOUCH_DOWN, event_time_1, 0, x, y, 0, 0, 0, 0);
1770
908
    env.mock_libinput.setup_touch_frame(fake_device, event_time_1);
1771
909
1772
910
    process_events(touch_screen);
1773
911
}
1774
912
1775
913
TEST_F(LibInputDeviceOnTouchScreen, display_wall_device_maps_to_bounding_rectangle)
1776
914
{
1777
915
    EXPECT_CALL(mock_sink, output_info(output_id))
1778
916
        .Times(0);
1779
917
    EXPECT_CALL(mock_sink, bounding_rectangle())
1780
918
        .WillOnce(Return(geom::Rectangle{geom::Point{screen_x_pos, screen_y_pos}, geom::Size{100, 100}}));
1781
919
    EXPECT_CALL(mock_sink, handle_input(mt::TouchContact(0, mir_touch_action_down, x + screen_x_pos, y + screen_y_pos)))
1782
920
        .Times(1);
1783
921
1784
922
    touch_screen.apply_settings(mi::TouchscreenSettings{output_id, mir_touchscreen_mapping_mode_to_display_wall});
1785
923
    touch_screen.start(&mock_sink, &mock_builder);
1786
924
1787
925
    env.mock_libinput.setup_touch_event(fake_device, LIBINPUT_EVENT_TOUCH_DOWN, event_time_1, 0, x, y, 0, 0, 0, 0);
1788
926
    env.mock_libinput.setup_touch_frame(fake_device, event_time_1);
1789
927
1790
928
    process_events(touch_screen);
1791
929
}
1792
930
1793
931
TEST_F(LibInputDeviceOnTouchScreen, drops_touchscreen_event_on_deactivated_output)
1794
932
{
1795
933
    EXPECT_CALL(mock_sink, handle_input(_)).Times(0);
1796
934
1797
935
    ON_CALL(mock_sink, output_info(output_id))
1798
936
        .WillByDefault(Return(mi::OutputInfo{false, geom::Size{width, height}, Matrix{{1,0,0,0,1,0}}}));
1799
937
1800
938
    touch_screen.apply_settings(mi::TouchscreenSettings{output_id, mir_touchscreen_mapping_mode_to_output});
1801
939
1802
940
    touch_screen.start(&mock_sink, &mock_builder);
1803
941
    env.mock_libinput.setup_touch_event(fake_device, LIBINPUT_EVENT_TOUCH_DOWN, event_time_1, 0, x, y, 0, 0, 0, 0);
1804
942
    env.mock_libinput.setup_touch_frame(fake_device, event_time_1);
1805
943
1806
944
    process_events(touch_screen);
1807
945
}
1808
780
946
1809
=== modified file 'tests/unit-tests/input/test_seat_input_device_tracker.cpp'
1810
--- tests/unit-tests/input/test_seat_input_device_tracker.cpp	2017-01-18 02:29:37 +0000
1811
+++ tests/unit-tests/input/test_seat_input_device_tracker.cpp	2017-03-01 16:08:29 +0000
1812
@@ -22,7 +22,6 @@
1813
22
#include "mir/input/xkb_mapper.h"
22
#include "mir/input/xkb_mapper.h"
1814
23
#include "mir/test/doubles/mock_input_device.h"
23
#include "mir/test/doubles/mock_input_device.h"
1815
24
#include "mir/test/doubles/mock_input_dispatcher.h"
24
#include "mir/test/doubles/mock_input_dispatcher.h"
1816
25
#include "mir/test/doubles/mock_input_region.h"
1817
26
#include "mir/test/doubles/mock_cursor_listener.h"
25
#include "mir/test/doubles/mock_cursor_listener.h"
1818
27
#include "mir/test/doubles/mock_touch_visualizer.h"
26
#include "mir/test/doubles/mock_touch_visualizer.h"
1819
28
#include "mir/test/doubles/mock_input_seat.h"
27
#include "mir/test/doubles/mock_input_seat.h"
1820
@@ -53,7 +52,6 @@
1821
53
{
52
{
1822
54
    mi::EventBuilder* builder;
53
    mi::EventBuilder* builder;
1823
55
    Nice<mtd::MockInputDispatcher> mock_dispatcher;
54
    Nice<mtd::MockInputDispatcher> mock_dispatcher;
1824
56
    Nice<mtd::MockInputRegion> mock_region;
1825
57
    Nice<mtd::MockCursorListener> mock_cursor_listener;
55
    Nice<mtd::MockCursorListener> mock_cursor_listener;
1826
58
    Nice<mtd::MockTouchVisualizer> mock_visualizer;
56
    Nice<mtd::MockTouchVisualizer> mock_visualizer;
1827
59
    Nice<mtd::MockInputSeat> mock_seat;
57
    Nice<mtd::MockInputSeat> mock_seat;
1828
@@ -70,8 +68,7 @@
1829
70
    mi::receiver::XKBMapper mapper;
68
    mi::receiver::XKBMapper mapper;
1830
71
    mi::SeatInputDeviceTracker tracker{
69
    mi::SeatInputDeviceTracker tracker{
1831
72
        mt::fake_shared(mock_dispatcher), mt::fake_shared(mock_visualizer), mt::fake_shared(mock_cursor_listener),
70
        mt::fake_shared(mock_dispatcher), mt::fake_shared(mock_visualizer), mt::fake_shared(mock_cursor_listener),
1834
73
        mt::fake_shared(mock_region),     mt::fake_shared(mapper),          mt::fake_shared(clock),
71
        mt::fake_shared(mapper),          mt::fake_shared(clock),           mt::fake_shared(mock_seat_report)};
1833
74
        mt::fake_shared(mock_seat_report)};
1835
75
72
1836
76
    std::chrono::nanoseconds arbitrary_timestamp;
73
    std::chrono::nanoseconds arbitrary_timestamp;
1837
77
};
74
};
1838
78
75
1839
=== modified file 'tests/unit-tests/scene/test_surface_stack.cpp'
1840
--- tests/unit-tests/scene/test_surface_stack.cpp	2017-02-15 14:45:41 +0000
1841
+++ tests/unit-tests/scene/test_surface_stack.cpp	2017-03-01 16:08:29 +0000
1842
@@ -989,7 +989,7 @@
1843
989
    stack.emit_scene_changed();
989
    stack.emit_scene_changed();
1844
990
}
990
}
1845
991
991
1847
992
TEST_F(SurfaceStack, only_enumerates_exposed_input_surfaces)
992
TEST_F(SurfaceStack, for_each_enumerates_all_input_surfaces)
1848
993
{
993
{
1849
994
    using namespace ::testing;
994
    using namespace ::testing;
1850
995
995
1851
@@ -1007,7 +1007,7 @@
1852
1007
    };
1007
    };
1853
1008
1008
1854
1009
    stack.for_each(count_exposed_surfaces);
1009
    stack.for_each(count_exposed_surfaces);
1856
1010
    EXPECT_THAT(num_exposed_surfaces, Eq(1));
1010
    EXPECT_THAT(num_exposed_surfaces, Eq(3));
1857
1011
}
1011
}
1858
1012
1012
1859
1013
using namespace ::testing;
1013
using namespace ::testing;
Reviewer	Review Type	Date Requested	Status
Daniel van Vugt			Abstain on 2017-03-03
Mir CI Bot	continuous-integration		Approve on 2017-03-01
Alan Griffiths		2017-02-08	Approve on 2017-02-24
Review via email: mp+316709@code.launchpad.net