1
=== modified file 'src/client/input/android/android_input_receiver.cpp'
2
--- src/client/input/android/android_input_receiver.cpp	2017-01-18 02:29:37 +0000
3
+++ src/client/input/android/android_input_receiver.cpp	2017-02-06 09:42:51 +0000
4
@@ -103,12 +103,28 @@
5
103
103
6
104
static void map_key_event(std::shared_ptr<mircv::XKBMapper> const& xkb_mapper, MirEvent &ev)
104
static void map_key_event(std::shared_ptr<mircv::XKBMapper> const& xkb_mapper, MirEvent &ev)
7
105
{
105
{
14
106
    // TODO: As XKBMapper is used to track modifier state we need to use a seperate instance
106
    auto const type = mir_event_get_type(&ev);
15
107
    // of XKBMapper per device id (or modify XKBMapper semantics)
107
    if (type == mir_event_type_input)
16
108
    if (mir_event_get_type(&ev) != mir_event_type_input)
108
    {
17
109
        return;
109
        xkb_mapper->map_event(ev);
18
110
110
    }
19
111
    xkb_mapper->map_event(ev);
111
    else if (type == mir_event_type_input_device_state)
20
112
    {
21
113
        auto device_state = mir_event_get_input_device_state_event(&ev);
22
114
        std::vector<uint32_t> keys;
23
115
24
116
        for (size_t index = 0, end_index = mir_input_device_state_event_device_count(device_state);
25
117
             index != end_index; ++index)
26
118
        {
27
119
            auto device_id = mir_input_device_state_event_device_id(device_state, index);
28
120
            auto key_count = mir_input_device_state_event_device_pressed_keys_count(device_state, index);
29
121
            for (decltype(key_count) i = 0; i != key_count; ++i)
30
122
                keys.push_back(
31
123
                    mir_input_device_state_event_device_pressed_keys_for_index(device_state, index, i));
32
124
33
125
            xkb_mapper->set_key_state(device_id, keys);
34
126
        }
35
127
    }
36
112
}
128
}
37
113
129
38
114
}
130
}
39
115
131
40
=== modified file 'src/client/input/xkb_mapper.cpp'
41
--- src/client/input/xkb_mapper.cpp	2017-01-18 02:29:37 +0000
42
+++ src/client/input/xkb_mapper.cpp	2017-02-06 09:42:51 +0000
43
@@ -25,6 +25,7 @@
44
25
25
45
26
#include <sstream>
26
#include <sstream>
46
27
#include <boost/throw_exception.hpp>
27
#include <boost/throw_exception.hpp>
47
28
#include <unordered_set>
48
28
29
49
29
namespace mi = mir::input;
30
namespace mi = mir::input;
50
30
namespace mev = mir::events;
31
namespace mev = mir::events;
51
@@ -59,10 +60,18 @@
52
59
    case XKB_KEY_Super_R: return mir_input_event_modifier_meta_right;
60
    case XKB_KEY_Super_R: return mir_input_event_modifier_meta_right;
53
60
    case XKB_KEY_Caps_Lock: return mir_input_event_modifier_caps_lock;
61
    case XKB_KEY_Caps_Lock: return mir_input_event_modifier_caps_lock;
54
61
    case XKB_KEY_Scroll_Lock: return mir_input_event_modifier_scroll_lock;
62
    case XKB_KEY_Scroll_Lock: return mir_input_event_modifier_scroll_lock;
55
63
    case XKB_KEY_Num_Lock: return mir_input_event_modifier_num_lock;
56
62
    default: return MirInputEventModifiers{0};
64
    default: return MirInputEventModifiers{0};
57
63
    }
65
    }
58
64
}
66
}
59
65
67
60
68
bool is_toggle_modifier(MirInputEventModifiers key)
61
69
{
62
70
    return key == mir_input_event_modifier_caps_lock ||
63
71
        key == mir_input_event_modifier_scroll_lock ||
64
72
        key == mir_input_event_modifier_num_lock;
65
73
}
66
74
67
66
MirInputEventModifiers expand_modifiers(MirInputEventModifiers modifiers)
75
MirInputEventModifiers expand_modifiers(MirInputEventModifiers modifiers)
68
67
{
76
{
69
68
    if (modifiers == 0)
77
    if (modifiers == 0)
70
@@ -167,7 +176,7 @@
71
167
        MirInputEventModifiers new_modifier = 0;
176
        MirInputEventModifiers new_modifier = 0;
72
168
        for (auto const& mapping_state : device_mapping)
177
        for (auto const& mapping_state : device_mapping)
73
169
        {
178
        {
75
170
            new_modifier |= mapping_state.second->modifier_state;
179
            new_modifier |= mapping_state.second->modifiers();
76
171
        }
180
        }
77
172
181
78
173
        modifier_state = new_modifier;
182
        modifier_state = new_modifier;
79
@@ -284,6 +293,16 @@
80
284
    return mir_input_event_modifier_none;
293
    return mir_input_event_modifier_none;
81
285
}
294
}
82
286
295
83
296
MirInputEventModifiers mircv::XKBMapper::device_modifiers(MirInputDeviceId id) const
84
297
{
85
298
    std::lock_guard<std::mutex> lg(guard);
86
299
87
300
    auto it = device_mapping.find(id);
88
301
    if (it == end(device_mapping))
89
302
        return mir_input_event_modifier_none;
90
303
    return expand_modifiers(it->second->modifiers());
91
304
}
92
305
93
287
mircv::XKBMapper::XkbMappingState::XkbMappingState(std::shared_ptr<xkb_keymap> const& keymap)
306
mircv::XKBMapper::XkbMappingState::XkbMappingState(std::shared_ptr<xkb_keymap> const& keymap)
94
288
    : keymap{keymap}, state{make_unique_state(this->keymap.get())}
307
    : keymap{keymap}, state{make_unique_state(this->keymap.get())}
95
289
{
308
{
96
@@ -293,8 +312,20 @@
97
293
{
312
{
98
294
    state = make_unique_state(keymap.get());
313
    state = make_unique_state(keymap.get());
99
295
    modifier_state = mir_input_event_modifier_none;
314
    modifier_state = mir_input_event_modifier_none;
100
315
    std::unordered_set<uint32_t> pressed_codes;
101
296
    for (uint32_t scan_code : key_state)
316
    for (uint32_t scan_code : key_state)
103
297
        update_state(to_xkb_scan_code(scan_code), mir_keyboard_action_down, nullptr);
317
    {
104
318
        bool already_pressed = pressed_codes.count(scan_code) > 0;
105
319
106
320
        update_state(to_xkb_scan_code(scan_code),
107
321
                     (already_pressed) ? mir_keyboard_action_up : mir_keyboard_action_down,
108
322
                     nullptr);
109
323
110
324
        if (already_pressed)
111
325
            pressed_codes.erase(scan_code);
112
326
        else
113
327
            pressed_codes.insert(scan_code);
114
328
    }
115
298
}
329
}
116
299
330
117
300
bool mircv::XKBMapper::XkbMappingState::update_and_map(MirEvent& event, mircv::XKBMapper::ComposeState* compose_state)
331
bool mircv::XKBMapper::XkbMappingState::update_and_map(MirEvent& event, mircv::XKBMapper::ComposeState* compose_state)
118
@@ -322,17 +353,26 @@
119
322
    if (action == mir_keyboard_action_up)
353
    if (action == mir_keyboard_action_up)
120
323
    {
354
    {
121
324
        xkb_state_update_key(state.get(), scan_code, XKB_KEY_UP);
355
        xkb_state_update_key(state.get(), scan_code, XKB_KEY_UP);
123
325
        modifier_state = modifier_state & ~mod_change;
356
        // TODO get the modifier state from xkbcommon and apply it
124
357
        // for all other modifiers manually track them here:
125
358
        release_modifier(mod_change);
126
326
    }
359
    }
127
327
    else if (action == mir_keyboard_action_down)
360
    else if (action == mir_keyboard_action_down)
128
328
    {
361
    {
129
329
        xkb_state_update_key(state.get(), scan_code, XKB_KEY_DOWN);
362
        xkb_state_update_key(state.get(), scan_code, XKB_KEY_DOWN);
131
330
        modifier_state = modifier_state | mod_change;
363
        // TODO get the modifier state from xkbcommon and apply it
132
364
        // for all other modifiers manually track them here:
133
365
        press_modifier(mod_change);
134
331
    }
366
    }
135
332
367
136
333
    return key_sym;
368
    return key_sym;
137
334
}
369
}
138
335
370
139
371
MirInputEventModifiers mircv::XKBMapper::XkbMappingState::modifiers() const
140
372
{
141
373
    return modifier_state;
142
374
}
143
375
144
336
mircv::XKBMapper::ComposeState* mircv::XKBMapper::get_compose_state(MirInputDeviceId id)
376
mircv::XKBMapper::ComposeState* mircv::XKBMapper::get_compose_state(MirInputDeviceId id)
145
337
{
377
{
146
338
    auto dev_compose_state = device_composing.find(id);
378
    auto dev_compose_state = device_composing.find(id);
147
@@ -410,3 +450,18 @@
148
410
450
149
411
    return mapped_key;
451
    return mapped_key;
150
412
}
452
}
151
453
152
454
153
455
void mircv::XKBMapper::XkbMappingState::press_modifier(MirInputEventModifiers mod)
154
456
{
155
457
    if (is_toggle_modifier(mod))
156
458
        modifier_state ^= mod;
157
459
    else
158
460
        modifier_state |= mod;
159
461
}
160
462
161
463
void mircv::XKBMapper::XkbMappingState::release_modifier(MirInputEventModifiers mod)
162
464
{
163
465
    if (!is_toggle_modifier(mod))
164
466
        modifier_state &= ~mod;
165
467
}
166
413
468
167
=== modified file 'src/include/common/mir/input/key_mapper.h'
168
--- src/include/common/mir/input/key_mapper.h	2017-01-18 02:29:37 +0000
169
+++ src/include/common/mir/input/key_mapper.h	2017-02-06 09:42:51 +0000
170
@@ -88,6 +88,7 @@
171
88
     */
88
     */
172
89
    virtual void map_event(MirEvent& event) = 0;
89
    virtual void map_event(MirEvent& event) = 0;
173
90
    virtual MirInputEventModifiers modifiers() const = 0;
90
    virtual MirInputEventModifiers modifiers() const = 0;
174
91
    virtual MirInputEventModifiers device_modifiers(MirInputDeviceId id) const = 0;
175
91
92
176
92
protected:
93
protected:
177
93
    KeyMapper(KeyMapper const&) = delete;
94
    KeyMapper(KeyMapper const&) = delete;
178
94
95
179
=== modified file 'src/include/common/mir/input/xkb_mapper.h'
180
--- src/include/common/mir/input/xkb_mapper.h	2017-01-18 02:29:37 +0000
181
+++ src/include/common/mir/input/xkb_mapper.h	2017-02-06 09:42:51 +0000
182
@@ -63,6 +63,7 @@
183
63
    void clear_all_keymaps() override;
63
    void clear_all_keymaps() override;
184
64
    void map_event(MirEvent& event) override;
64
    void map_event(MirEvent& event) override;
185
65
    MirInputEventModifiers modifiers() const override;
65
    MirInputEventModifiers modifiers() const override;
186
66
    MirInputEventModifiers device_modifiers(MirInputDeviceId di) const override;
187
66
67
188
67
protected:
68
protected:
189
68
    XKBMapper(XKBMapper const&) = delete;
69
    XKBMapper(XKBMapper const&) = delete;
190
@@ -89,8 +90,14 @@
191
89
    {
90
    {
192
90
        explicit XkbMappingState(std::shared_ptr<xkb_keymap> const& keymap);
91
        explicit XkbMappingState(std::shared_ptr<xkb_keymap> const& keymap);
193
91
        void set_key_state(std::vector<uint32_t> const& key_state);
92
        void set_key_state(std::vector<uint32_t> const& key_state);
194
93
195
92
        bool update_and_map(MirEvent& event, ComposeState* compose_state);
94
        bool update_and_map(MirEvent& event, ComposeState* compose_state);
196
93
        xkb_keysym_t update_state(uint32_t scan_code, MirKeyboardAction direction, ComposeState* compose_state);
95
        xkb_keysym_t update_state(uint32_t scan_code, MirKeyboardAction direction, ComposeState* compose_state);
197
96
        MirInputEventModifiers modifiers() const;
198
97
    private:
199
98
        void press_modifier(MirInputEventModifiers mod);
200
99
        void release_modifier(MirInputEventModifiers mod);
201
100
202
94
        std::shared_ptr<xkb_keymap> const keymap;
101
        std::shared_ptr<xkb_keymap> const keymap;
203
95
        XKBStatePtr state;
102
        XKBStatePtr state;
204
96
        MirInputEventModifiers modifier_state{0};
103
        MirInputEventModifiers modifier_state{0};
205
97
104
206
=== modified file 'src/server/input/seat_input_device_tracker.cpp'
207
--- src/server/input/seat_input_device_tracker.cpp	2017-01-18 02:29:37 +0000
208
+++ src/server/input/seat_input_device_tracker.cpp	2017-02-06 09:42:51 +0000
209
@@ -31,6 +31,7 @@
210
31
#include "input_modifier_utils.h"
31
#include "input_modifier_utils.h"
211
32
32
212
33
#include <boost/throw_exception.hpp>
33
#include <boost/throw_exception.hpp>
213
34
#include <linux/input.h>
214
34
35
215
35
#include <stdexcept>
36
#include <stdexcept>
216
36
#include <algorithm>
37
#include <algorithm>
217
@@ -115,7 +116,7 @@
218
115
        if (stored_data == end(device_data))
116
        if (stored_data == end(device_data))
219
116
            return true;
117
            return true;
220
117
118
222
118
        return !stored_data->second.allowed_scan_code_action(mir_input_event_get_keyboard_event(event));
119
        return !stored_data->second.allowed_scan_code_action(mir_input_event_get_keyboard_event(event));;
223
119
    }
120
    }
224
120
    return false;
121
    return false;
225
121
}
122
}
226
@@ -251,8 +252,44 @@
227
251
    std::vector<mev::InputDeviceState> devices;
252
    std::vector<mev::InputDeviceState> devices;
228
252
    devices.reserve(device_data.size());
253
    devices.reserve(device_data.size());
229
253
    for (auto const& item : device_data)
254
    for (auto const& item : device_data)
230
255
    {
231
254
        devices.push_back({item.first, item.second.scan_codes, item.second.buttons});
256
        devices.push_back({item.first, item.second.scan_codes, item.second.buttons});
233
255
257
        auto lock_state = key_mapper->device_modifiers(item.first);
234
258
235
259
        bool caps_lock_active = (lock_state & mir_input_event_modifier_caps_lock);
236
260
        bool scroll_lock_active = (lock_state & mir_input_event_modifier_scroll_lock);
237
261
        bool num_lock_active = (lock_state & mir_input_event_modifier_num_lock);
238
262
239
263
        bool contains_caps_lock_pressed = false;
240
264
        bool contains_scroll_lock_pressed = false;
241
265
        bool contains_num_lock_pressed = false;
242
266
243
267
        for (uint32_t scan_code : item.second.scan_codes)
244
268
        {
245
269
            if (scan_code == KEY_CAPSLOCK)
246
270
                contains_caps_lock_pressed = true;
247
271
            else if (scan_code == KEY_SCROLLLOCK)
248
272
                contains_scroll_lock_pressed = true;
249
273
            else if (scan_code == KEY_NUMLOCK)
250
274
                contains_num_lock_pressed = true;
251
275
        }
252
276
253
277
        if (caps_lock_active && !contains_caps_lock_pressed)
254
278
        {
255
279
            devices.back().pressed_keys.push_back(KEY_CAPSLOCK);
256
280
            devices.back().pressed_keys.push_back(KEY_CAPSLOCK);
257
281
        }
258
282
        if (num_lock_active && !contains_num_lock_pressed)
259
283
        {
260
284
            devices.back().pressed_keys.push_back(KEY_NUMLOCK);
261
285
            devices.back().pressed_keys.push_back(KEY_NUMLOCK);
262
286
        }
263
287
        if (scroll_lock_active && !contains_scroll_lock_pressed)
264
288
        {
265
289
            devices.back().pressed_keys.push_back(KEY_SCROLLLOCK);
266
290
            devices.back().pressed_keys.push_back(KEY_SCROLLLOCK);
267
291
        }
268
292
    }
269
256
    auto out_ev = mev::make_event(
293
    auto out_ev = mev::make_event(
270
257
        clock->now().time_since_epoch(),
294
        clock->now().time_since_epoch(),
271
258
        buttons,
295
        buttons,
272
259
296
273
=== modified file 'tests/acceptance-tests/test_client_input.cpp'
274
--- tests/acceptance-tests/test_client_input.cpp	2017-02-06 03:54:54 +0000
275
+++ tests/acceptance-tests/test_client_input.cpp	2017-02-06 09:42:51 +0000
276
@@ -18,7 +18,10 @@
277
18
18
278
19
#include "mir/input/input_device_info.h"
19
#include "mir/input/input_device_info.h"
279
20
#include "mir/input/event_filter.h"
20
#include "mir/input/event_filter.h"
280
21
#include "mir/input/keymap.h"
281
21
#include "mir/input/composite_event_filter.h"
22
#include "mir/input/composite_event_filter.h"
282
23
#include "mir/scene/session.h"
283
24
#include "mir/scene/surface.h"
284
22
#include "mir/input/mir_touchpad_config.h"
25
#include "mir/input/mir_touchpad_config.h"
285
23
#include "mir/input/mir_input_config.h"
26
#include "mir/input/mir_input_config.h"
286
24
27
287
@@ -45,6 +48,7 @@
288
45
#include <linux/input.h>
48
#include <linux/input.h>
289
46
49
290
47
#include <condition_variable>
50
#include <condition_variable>
291
51
#include <unordered_map>
292
48
#include <chrono>
52
#include <chrono>
293
49
#include <atomic>
53
#include <atomic>
294
50
#include <mutex>
54
#include <mutex>
295
@@ -98,12 +102,52 @@
296
98
{
102
{
297
99
}
103
}
298
100
104
299
105
struct SurfaceTrackingShell : mir::shell::ShellWrapper
300
106
{
301
107
    SurfaceTrackingShell(
302
108
        std::shared_ptr<mir::shell::Shell> wrapped_shell)
303
109
        : ShellWrapper{wrapped_shell}, wrapped_shell{wrapped_shell}
304
110
    {}
305
111
306
112
    mir::frontend::SurfaceId create_surface(
307
113
        std::shared_ptr<mir::scene::Session> const& session,
308
114
        mir::scene::SurfaceCreationParameters const& params,
309
115
        std::shared_ptr<mir::frontend::EventSink> const& sink) override
310
116
    {
311
117
        auto surface_id = wrapped_shell->create_surface(session, params, sink);
312
118
313
119
        tracked_surfaces[session->name()] =  TrackedSurface{session, surface_id};
314
120
315
121
        return surface_id;
316
122
    }
317
123
318
124
    std::shared_ptr<mir::scene::Surface> get_surface(std::string const& session_name)
319
125
    {
320
126
        if (end(tracked_surfaces) == tracked_surfaces.find(session_name))
321
127
            return nullptr;
322
128
        TrackedSurface & tracked_surface = tracked_surfaces[session_name];
323
129
        auto session = tracked_surface.session.lock();
324
130
        if (!session)
325
131
            return nullptr;
326
132
        return session->surface(tracked_surface.surface);
327
133
    }
328
134
329
135
    struct TrackedSurface
330
136
    {
331
137
        std::weak_ptr<mir::scene::Session> session;
332
138
        mir::frontend::SurfaceId surface;
333
139
    };
334
140
    std::unordered_map<std::string, TrackedSurface> tracked_surfaces;
335
141
    std::shared_ptr<mir::shell::Shell> wrapped_shell;
336
142
};
337
143
338
101
struct Client
144
struct Client
339
102
{
145
{
340
103
    MirWindow* window{nullptr};
146
    MirWindow* window{nullptr};
341
104
147
342
105
    MOCK_METHOD1(handle_input, void(MirEvent const*));
148
    MOCK_METHOD1(handle_input, void(MirEvent const*));
343
106
    MOCK_METHOD1(handle_keymap, void(MirEvent const*));
149
    MOCK_METHOD1(handle_keymap, void(MirEvent const*));
344
150
    MOCK_METHOD1(handle_input_device_state, void(MirEvent const*));
345
107
151
346
108
    Client(std::string const& con, std::string const& name)
152
    Client(std::string const& con, std::string const& name)
347
109
    {
153
    {
348
@@ -146,7 +190,12 @@
349
146
            mir_window_focus_state_focused == value)
190
            mir_window_focus_state_focused == value)
350
147
            focused = true;
191
            focused = true;
351
148
192
353
149
        if (exposed && focused)
193
        test_and_raise();
354
194
    }
355
195
356
196
    void test_and_raise()
357
197
    {
358
198
        if (exposed && focused && input_device_state_received)
359
150
            ready_to_accept_events.raise();
199
            ready_to_accept_events.raise();
360
151
    }
200
    }
361
152
201
362
@@ -164,6 +213,12 @@
363
164
            client->handle_input(ev);
213
            client->handle_input(ev);
364
165
        if (type == mir_event_type_keymap)
214
        if (type == mir_event_type_keymap)
365
166
            client->handle_keymap(ev);
215
            client->handle_keymap(ev);
366
216
        if (type == mir_event_type_input_device_state)
367
217
        {
368
218
            client->input_device_state_received = true;
369
219
            client->test_and_raise();
370
220
            client->handle_input_device_state(ev);
371
221
        }
372
167
    }
222
    }
373
168
    ~Client()
223
    ~Client()
374
169
    {
224
    {
375
@@ -181,6 +236,7 @@
376
181
    mir::test::Signal all_events_received;
236
    mir::test::Signal all_events_received;
377
182
    bool exposed = false;
237
    bool exposed = false;
378
183
    bool focused = false;
238
    bool focused = false;
379
239
    bool input_device_state_received = false;
380
184
};
240
};
381
185
241
382
186
struct DeviceCounter : mi::InputDeviceObserver
242
struct DeviceCounter : mi::InputDeviceObserver
383
@@ -216,7 +272,8 @@
384
216
            [this](std::shared_ptr<mir::shell::Shell> const& wrapped)
272
            [this](std::shared_ptr<mir::shell::Shell> const& wrapped)
385
217
            {
273
            {
386
218
                shell = std::make_shared<mtf::PlacementApplyingShell>(wrapped, input_regions, positions);
274
                shell = std::make_shared<mtf::PlacementApplyingShell>(wrapped, input_regions, positions);
388
219
                return shell;
275
                surfaces = std::make_shared<SurfaceTrackingShell>(shell);
389
276
                return surfaces;
390
220
            });
277
            });
391
221
        server.override_the_session_authorizer([this] { return mt::fake_shared(stub_authorizer); });
278
        server.override_the_session_authorizer([this] { return mt::fake_shared(stub_authorizer); });
392
222
279
393
@@ -225,7 +282,13 @@
394
225
        positions[first] = geom::Rectangle{{0,0}, {surface_width, surface_height}};
282
        positions[first] = geom::Rectangle{{0,0}, {surface_width, surface_height}};
395
226
    }
283
    }
396
227
284
397
285
    std::shared_ptr<mir::scene::Surface> get_surface(std::string const& name)
398
286
    {
399
287
        return surfaces->get_surface(name);
400
288
    }
401
289
402
228
    std::shared_ptr<mtf::PlacementApplyingShell> shell;
290
    std::shared_ptr<mtf::PlacementApplyingShell> shell;
403
291
    std::shared_ptr<SurfaceTrackingShell> surfaces;
404
229
    std::string const keyboard_name = "keyboard";
292
    std::string const keyboard_name = "keyboard";
405
230
    std::string const keyboard_unique_id = "keyboard-uid";
293
    std::string const keyboard_unique_id = "keyboard-uid";
406
231
    std::string const mouse_name = "mouse";
294
    std::string const mouse_name = "mouse";
407
@@ -939,6 +1002,81 @@
408
939
    mir_input_config_release(config);
1002
    mir_input_config_release(config);
409
940
}
1003
}
410
941
1004
411
1005
TEST_F(TestClientInput, num_lock_is_off_on_startup)
412
1006
{
413
1007
    Client a_client(new_connection(), first);
414
1008
415
1009
    EXPECT_CALL(a_client, handle_input(mt::KeyOfSymbol(XKB_KEY_KP_Left)))
416
1010
        .WillOnce(mt::WakeUp(&a_client.all_events_received));
417
1011
418
1012
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_KP4));
419
1013
    a_client.all_events_received.wait_for(10s);
420
1014
}
421
1015
422
1016
TEST_F(TestClientInput, keeps_num_lock_state_after_focus_change)
423
1017
{
424
1018
    Client first_client(new_connection(), first);
425
1019
426
1020
    {
427
1021
        Client second_client(new_connection(), second);
428
1022
        EXPECT_CALL(second_client, handle_input(mt::KeyDownEvent()));
429
1023
        EXPECT_CALL(second_client, handle_input(mt::KeyUpEvent()))
430
1024
            .WillOnce(mt::WakeUp(&second_client.all_events_received));
431
1025
432
1026
        fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_NUMLOCK));
433
1027
        fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_NUMLOCK));
434
1028
435
1029
        second_client.all_events_received.wait_for(10s);
436
1030
    }
437
1031
438
1032
    EXPECT_CALL(first_client, handle_input(mt::KeyOfSymbol(XKB_KEY_KP_4)))
439
1033
        .WillOnce(mt::WakeUp(&first_client.all_events_received));
440
1034
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_KP4));
441
1035
    first_client.all_events_received.wait_for(10s);
442
1036
}
443
1037
444
1038
TEST_F(TestClientInput, reestablishes_num_lock_state_in_client_with_surface_keymap)
445
1039
{
446
1040
    Client a_client_with_keymap(new_connection(), first);
447
1041
448
1042
    mir::test::Signal keymap_received;
449
1043
    mir::test::Signal device_state_received;
450
1044
451
1045
    EXPECT_CALL(a_client_with_keymap, handle_keymap(_))
452
1046
        .WillOnce(mt::WakeUp(&keymap_received));
453
1047
    EXPECT_CALL(a_client_with_keymap,
454
1048
                handle_input_device_state(
455
1049
                    mt::DeviceStateWithPressedKeys(std::vector<uint32_t>{KEY_NUMLOCK, KEY_NUMLOCK})))
456
1050
        .WillOnce(mt::WakeUp(&device_state_received));
457
1051
458
1052
    get_surface(first)->set_keymap(MirInputDeviceId{0}, "pc105", "de", "", "");
459
1053
    keymap_received.wait_for(4s);
460
1054
461
1055
    {
462
1056
        Client a_client(new_connection(), second);
463
1057
464
1058
        EXPECT_CALL(a_client, handle_input(mt::KeyDownEvent()));
465
1059
        EXPECT_CALL(a_client, handle_input(mt::KeyUpEvent()));
466
1060
        EXPECT_CALL(a_client, handle_input(AllOf(mt::KeyDownEvent(),mt::KeyOfSymbol(XKB_KEY_KP_4))));
467
1061
        EXPECT_CALL(a_client, handle_input(AllOf(mt::KeyUpEvent(),mt::KeyOfSymbol(XKB_KEY_KP_4))))
468
1062
            .WillOnce(mt::WakeUp(&a_client.all_events_received));
469
1063
470
1064
        fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_NUMLOCK));
471
1065
        fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_NUMLOCK));
472
1066
        fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_KP4));
473
1067
        fake_keyboard->emit_event(mis::a_key_up_event().of_scancode(KEY_KP4));
474
1068
475
1069
        a_client.all_events_received.wait_for(10s);
476
1070
    }
477
1071
    device_state_received.wait_for(4s);
478
1072
    EXPECT_CALL(a_client_with_keymap, handle_input(mt::KeyOfSymbol(XKB_KEY_KP_4)))
479
1073
        .WillOnce(mt::WakeUp(&a_client_with_keymap.all_events_received));
480
1074
481
1075
    fake_keyboard->emit_event(mis::a_key_down_event().of_scancode(KEY_KP4));
482
1076
483
1077
    a_client_with_keymap.all_events_received.wait_for(10s);
484
1078
}
485
1079
486
942
TEST_F(TestClientInput, initial_mouse_configuration_can_be_querried)
1080
TEST_F(TestClientInput, initial_mouse_configuration_can_be_querried)
487
943
{
1081
{
488
944
    wait_for_input_devices();
1082
    wait_for_input_devices();
489
945
1083
490
=== modified file 'tests/include/mir/test/doubles/mock_key_mapper.h'
491
--- tests/include/mir/test/doubles/mock_key_mapper.h	2017-01-18 02:29:37 +0000
492
+++ tests/include/mir/test/doubles/mock_key_mapper.h	2017-02-06 09:42:51 +0000
493
@@ -41,6 +41,7 @@
494
41
    MOCK_METHOD0(clear_all_keymaps, void());
41
    MOCK_METHOD0(clear_all_keymaps, void());
495
42
    MOCK_METHOD1(map_event, void(MirEvent& event));
42
    MOCK_METHOD1(map_event, void(MirEvent& event));
496
43
    MOCK_CONST_METHOD0(modifiers, MirInputEventModifiers());
43
    MOCK_CONST_METHOD0(modifiers, MirInputEventModifiers());
497
44
    MOCK_CONST_METHOD1(device_modifiers, MirInputEventModifiers(MirInputDeviceId));
498
44
};
45
};
499
45
46
500
46
47
Reviewer	Review Type	Date Requested	Status
Alexandros Frantzis (community)		2016-07-06	Approve on 2017-02-07
Mir CI Bot	continuous-integration		Approve on 2017-02-06
Review via email: mp+299353@code.launchpad.net