1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
|
// Copyright 2014 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/events/ozone/evdev/keyboard_evdev.h"
#include "base/single_thread_task_runner.h"
#include "base/thread_task_runner_handle.h"
#include "ui/events/event.h"
#include "ui/events/event_constants.h"
#include "ui/events/event_utils.h"
#include "ui/events/keycodes/dom/keycode_converter.h"
#include "ui/events/ozone/evdev/event_modifiers_evdev.h"
#include "ui/events/ozone/evdev/keyboard_util_evdev.h"
#include "ui/events/ozone/layout/keyboard_layout_engine.h"
#include "ui/events/ozone/layout/keyboard_layout_engine_manager.h"
#include "ui/events/ozone/layout/layout_util.h"
namespace ui {
// We can't include ui/events/keycodes/dom/dom_code.h here because of
// conflicts with preprocessor macros in <linux/input.h>, so we use the
// same underlying data with an additional prefix.
#define USB_KEYMAP(usb, xkb, win, mac, code, id) DOM_CODE_ ## id = usb
#define USB_KEYMAP_DECLARATION enum class DomCode
#include "ui/events/keycodes/dom/keycode_converter_data.inc"
#undef USB_KEYMAP
#undef USB_KEYMAP_DECLARATION
namespace {
const int kRepeatDelayMs = 500;
const int kRepeatIntervalMs = 50;
int EventFlagToEvdevModifier(int flag) {
switch (flag) {
case EF_CAPS_LOCK_DOWN:
return EVDEV_MODIFIER_CAPS_LOCK;
case EF_SHIFT_DOWN:
return EVDEV_MODIFIER_SHIFT;
case EF_CONTROL_DOWN:
return EVDEV_MODIFIER_CONTROL;
case EF_ALT_DOWN:
return EVDEV_MODIFIER_ALT;
case EF_ALTGR_DOWN:
return EVDEV_MODIFIER_ALTGR;
case EF_MOD3_DOWN:
return EVDEV_MODIFIER_MOD3;
case EF_LEFT_MOUSE_BUTTON:
return EVDEV_MODIFIER_LEFT_MOUSE_BUTTON;
case EF_MIDDLE_MOUSE_BUTTON:
return EVDEV_MODIFIER_MIDDLE_MOUSE_BUTTON;
case EF_RIGHT_MOUSE_BUTTON:
return EVDEV_MODIFIER_RIGHT_MOUSE_BUTTON;
case EF_BACK_MOUSE_BUTTON:
return EVDEV_MODIFIER_BACK_MOUSE_BUTTON;
case EF_FORWARD_MOUSE_BUTTON:
return EVDEV_MODIFIER_FORWARD_MOUSE_BUTTON;
case EF_COMMAND_DOWN:
return EVDEV_MODIFIER_COMMAND;
default:
return EVDEV_MODIFIER_NONE;
}
}
} // namespace
KeyboardEvdev::KeyboardEvdev(EventModifiersEvdev* modifiers,
KeyboardLayoutEngine* keyboard_layout_engine,
const EventDispatchCallback& callback)
: callback_(callback),
modifiers_(modifiers),
keyboard_layout_engine_(keyboard_layout_engine),
weak_ptr_factory_(this) {
repeat_delay_ = base::TimeDelta::FromMilliseconds(kRepeatDelayMs);
repeat_interval_ = base::TimeDelta::FromMilliseconds(kRepeatIntervalMs);
}
KeyboardEvdev::~KeyboardEvdev() {
}
void KeyboardEvdev::OnKeyChange(unsigned int key,
bool down,
bool suppress_auto_repeat,
base::TimeDelta timestamp,
int device_id) {
if (key > KEY_MAX)
return;
bool was_down = key_state_.test(key);
bool is_repeat = down && was_down;
if (!down && !was_down)
return; // Key already released.
key_state_.set(key, down);
UpdateKeyRepeat(key, down, suppress_auto_repeat, device_id);
DispatchKey(key, down, is_repeat, timestamp, device_id);
}
void KeyboardEvdev::SetCapsLockEnabled(bool enabled) {
modifiers_->SetModifierLock(EVDEV_MODIFIER_CAPS_LOCK, enabled);
}
bool KeyboardEvdev::IsCapsLockEnabled() {
return (modifiers_->GetModifierFlags() & EF_CAPS_LOCK_DOWN) != 0;
}
bool KeyboardEvdev::IsAutoRepeatEnabled() {
return auto_repeat_enabled_;
}
void KeyboardEvdev::SetAutoRepeatEnabled(bool enabled) {
auto_repeat_enabled_ = enabled;
}
void KeyboardEvdev::SetAutoRepeatRate(const base::TimeDelta& delay,
const base::TimeDelta& interval) {
repeat_delay_ = delay;
repeat_interval_ = interval;
}
void KeyboardEvdev::GetAutoRepeatRate(base::TimeDelta* delay,
base::TimeDelta* interval) {
*delay = repeat_delay_;
*interval = repeat_interval_;
}
void KeyboardEvdev::UpdateModifier(int modifier_flag, bool down) {
if (modifier_flag == EF_NONE)
return;
int modifier = EventFlagToEvdevModifier(modifier_flag);
if (modifier == EVDEV_MODIFIER_NONE)
return;
// TODO post-X11: Revise remapping to not use EF_MOD3_DOWN.
// Currently EF_MOD3_DOWN means that the CapsLock key is currently down,
// and EF_CAPS_LOCK_DOWN means the caps lock state is enabled (and the
// key may or may not be down, but usually isn't). There does need to
// to be two different flags, since the physical CapsLock key is subject
// to remapping, but the caps lock state (which can be triggered in a
// variety of ways) is not.
if (modifier == EVDEV_MODIFIER_CAPS_LOCK)
modifiers_->UpdateModifier(EVDEV_MODIFIER_MOD3, down);
else
modifiers_->UpdateModifier(modifier, down);
}
void KeyboardEvdev::UpdateKeyRepeat(unsigned int key,
bool down,
bool suppress_auto_repeat,
int device_id) {
if (!auto_repeat_enabled_ || suppress_auto_repeat)
StopKeyRepeat();
else if (key != repeat_key_ && down)
StartKeyRepeat(key, device_id);
else if (key == repeat_key_ && !down)
StopKeyRepeat();
}
void KeyboardEvdev::StartKeyRepeat(unsigned int key, int device_id) {
repeat_key_ = key;
repeat_device_id_ = device_id;
repeat_sequence_++;
ScheduleKeyRepeat(repeat_delay_);
}
void KeyboardEvdev::StopKeyRepeat() {
repeat_key_ = KEY_RESERVED;
repeat_sequence_++;
}
void KeyboardEvdev::ScheduleKeyRepeat(const base::TimeDelta& delay) {
base::ThreadTaskRunnerHandle::Get()->PostDelayedTask(
FROM_HERE, base::Bind(&KeyboardEvdev::OnRepeatTimeout,
weak_ptr_factory_.GetWeakPtr(), repeat_sequence_),
delay);
}
void KeyboardEvdev::OnRepeatTimeout(unsigned int sequence) {
if (repeat_sequence_ != sequence)
return;
// Post a task behind any pending key releases in the message loop
// FIFO. This ensures there's no spurious repeats during periods of UI
// thread jank.
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&KeyboardEvdev::OnRepeatCommit,
weak_ptr_factory_.GetWeakPtr(), repeat_sequence_));
}
void KeyboardEvdev::OnRepeatCommit(unsigned int sequence) {
if (repeat_sequence_ != sequence)
return;
DispatchKey(repeat_key_, true /* down */, true /* repeat */,
EventTimeForNow(), repeat_device_id_);
ScheduleKeyRepeat(repeat_interval_);
}
void KeyboardEvdev::DispatchKey(unsigned int key,
bool down,
bool repeat,
base::TimeDelta timestamp,
int device_id) {
DomCode dom_code =
KeycodeConverter::NativeKeycodeToDomCode(EvdevCodeToNativeCode(key));
if (dom_code == DomCode::DOM_CODE_NONE)
return;
int flags = modifiers_->GetModifierFlags();
DomKey dom_key;
KeyboardCode key_code;
uint32 platform_keycode = 0;
if (!keyboard_layout_engine_->Lookup(dom_code, flags, &dom_key,
&key_code, &platform_keycode)) {
return;
}
if (!repeat) {
int flag = ModifierDomKeyToEventFlag(dom_key);
UpdateModifier(flag, down);
}
KeyEvent event(down ? ET_KEY_PRESSED : ET_KEY_RELEASED, key_code, dom_code,
modifiers_->GetModifierFlags(), dom_key, timestamp);
event.set_source_device_id(device_id);
if (platform_keycode)
event.set_platform_keycode(platform_keycode);
callback_.Run(&event);
}
} // namespace ui
|
