OLD | NEW |
1 // Copyright 2013 The Chromium Authors. All rights reserved. | 1 // Copyright 2013 The Chromium Authors. All rights reserved. |
2 // Use of this source code is governed by a BSD-style license that can be | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // found in the LICENSE file. | 3 // found in the LICENSE file. |
4 | 4 |
5 #include "ash/sticky_keys/sticky_keys_controller.h" | 5 #include "ash/sticky_keys/sticky_keys_controller.h" |
6 | 6 |
7 #include "ash/sticky_keys/sticky_keys_overlay.h" | 7 #include "ash/sticky_keys/sticky_keys_overlay.h" |
8 #include "base/debug/stack_trace.h" | 8 #include "base/debug/stack_trace.h" |
9 #include "ui/aura/window.h" | 9 #include "ui/aura/window.h" |
10 #include "ui/aura/window_tracker.h" | 10 #include "ui/aura/window_tracker.h" |
11 #include "ui/aura/window_tree_host.h" | 11 #include "ui/aura/window_tree_host.h" |
12 #include "ui/events/event.h" | 12 #include "ui/events/event.h" |
13 #include "ui/events/event_processor.h" | 13 #include "ui/events/event_processor.h" |
14 #include "ui/events/keycodes/keyboard_code_conversion.h" | 14 #include "ui/events/keycodes/keyboard_code_conversion.h" |
15 | 15 |
16 namespace ash { | 16 namespace ash { |
17 | 17 |
18 namespace { | 18 namespace { |
19 | 19 |
20 // Returns true if the type of mouse event should be modified by sticky keys. | 20 // Returns true if the type of mouse event should be modified by sticky keys. |
21 bool ShouldModifyMouseEvent(const ui::MouseEvent& event) { | 21 bool ShouldModifyMouseEvent(const ui::MouseEvent& event) { |
22 ui::EventType type = event.type(); | 22 ui::EventType type = event.type(); |
23 return type == ui::ET_MOUSE_PRESSED || type == ui::ET_MOUSE_RELEASED || | 23 return type == ui::ET_MOUSE_PRESSED || type == ui::ET_MOUSE_RELEASED || |
24 type == ui::ET_MOUSEWHEEL; | 24 type == ui::ET_MOUSEWHEEL; |
25 } | 25 } |
26 | 26 |
27 // Handle the common tail of event rewriting. | 27 // Handle the common tail of event rewriting. |
28 ui::EventRewriteStatus RewriteUpdate(bool consumed, | 28 ui::EventRewriteStatus RewriteUpdate( |
29 bool released, | 29 bool consumed, |
30 int mod_down_flags, | 30 bool released, |
31 int* flags) { | 31 int mod_down_flags, |
32 int changed_down_flags = mod_down_flags & ~*flags; | 32 const ui::Event& event, |
33 *flags |= mod_down_flags; | 33 std::unique_ptr<ui::Event>* rewritten_event) { |
34 if (consumed) | 34 if (consumed) |
35 return ui::EVENT_REWRITE_DISCARD; | 35 return ui::EVENT_REWRITE_DISCARD; |
36 if (released) | 36 if (mod_down_flags & ~event.flags()) { |
37 return ui::EVENT_REWRITE_DISPATCH_ANOTHER; | 37 *rewritten_event = ui::Event::Clone(event); |
38 if (changed_down_flags) | 38 (*rewritten_event)->set_flags(event.flags() | mod_down_flags); |
39 return ui::EVENT_REWRITE_REWRITTEN; | 39 return released ? ui::EVENT_REWRITE_DISPATCH_ANOTHER |
| 40 : ui::EVENT_REWRITE_REWRITTEN; |
| 41 } |
40 return ui::EVENT_REWRITE_CONTINUE; | 42 return ui::EVENT_REWRITE_CONTINUE; |
41 } | 43 } |
42 | 44 |
43 } // namespace | 45 } // namespace |
44 | 46 |
45 /////////////////////////////////////////////////////////////////////////////// | 47 /////////////////////////////////////////////////////////////////////////////// |
46 // StickyKeys | 48 // StickyKeys |
47 StickyKeysController::StickyKeysController() | 49 StickyKeysController::StickyKeysController() |
48 : enabled_(false), mod3_enabled_(false), altgr_enabled_(false) {} | 50 : enabled_(false), mod3_enabled_(false), altgr_enabled_(false) {} |
49 | 51 |
(...skipping 25 matching lines...) Expand all Loading... |
75 void StickyKeysController::SetModifiersEnabled(bool mod3_enabled, | 77 void StickyKeysController::SetModifiersEnabled(bool mod3_enabled, |
76 bool altgr_enabled) { | 78 bool altgr_enabled) { |
77 mod3_enabled_ = mod3_enabled; | 79 mod3_enabled_ = mod3_enabled; |
78 altgr_enabled_ = altgr_enabled; | 80 altgr_enabled_ = altgr_enabled; |
79 if (overlay_) { | 81 if (overlay_) { |
80 overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_); | 82 overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_); |
81 overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_); | 83 overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_); |
82 } | 84 } |
83 } | 85 } |
84 | 86 |
85 bool StickyKeysController::HandleKeyEvent(const ui::KeyEvent& event, | 87 StickyKeysOverlay* StickyKeysController::GetOverlayForTest() { |
86 ui::KeyboardCode key_code, | 88 return overlay_.get(); |
87 int* mod_down_flags, | |
88 bool* released) { | |
89 return shift_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags, | |
90 released) || | |
91 alt_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags, | |
92 released) || | |
93 altgr_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags, | |
94 released) || | |
95 ctrl_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags, | |
96 released) || | |
97 mod3_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags, | |
98 released) || | |
99 search_sticky_key_->HandleKeyEvent(event, key_code, mod_down_flags, | |
100 released); | |
101 } | 89 } |
102 | 90 |
103 bool StickyKeysController::HandleMouseEvent(const ui::MouseEvent& event, | 91 ui::EventRewriteStatus StickyKeysController::RewriteEvent( |
104 int* mod_down_flags, | 92 const ui::Event& event, |
105 bool* released) { | 93 std::unique_ptr<ui::Event>* rewritten_event) { |
106 return shift_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) || | 94 DCHECK(rewritten_event); |
107 alt_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) || | |
108 altgr_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) || | |
109 ctrl_sticky_key_->HandleMouseEvent(event, mod_down_flags, released) || | |
110 mod3_sticky_key_->HandleMouseEvent(event, mod_down_flags, released); | |
111 } | |
112 | |
113 bool StickyKeysController::HandleScrollEvent(const ui::ScrollEvent& event, | |
114 int* mod_down_flags, | |
115 bool* released) { | |
116 return shift_sticky_key_->HandleScrollEvent(event, mod_down_flags, | |
117 released) || | |
118 alt_sticky_key_->HandleScrollEvent(event, mod_down_flags, released) || | |
119 altgr_sticky_key_->HandleScrollEvent(event, mod_down_flags, | |
120 released) || | |
121 ctrl_sticky_key_->HandleScrollEvent(event, mod_down_flags, released) || | |
122 mod3_sticky_key_->HandleScrollEvent(event, mod_down_flags, released); | |
123 } | |
124 | |
125 ui::EventRewriteStatus StickyKeysController::RewriteKeyEvent( | |
126 const ui::KeyEvent& event, | |
127 ui::KeyboardCode key_code, | |
128 int* flags) { | |
129 if (!enabled_) | 95 if (!enabled_) |
130 return ui::EVENT_REWRITE_CONTINUE; | 96 return ui::EVENT_REWRITE_CONTINUE; |
131 int mod_down_flags = 0; | |
132 bool released = false; | |
133 bool consumed = HandleKeyEvent(event, key_code, &mod_down_flags, &released); | |
134 UpdateOverlay(); | |
135 return RewriteUpdate(consumed, released, mod_down_flags, flags); | |
136 } | |
137 | 97 |
138 ui::EventRewriteStatus StickyKeysController::RewriteMouseEvent( | 98 if (event.IsKeyEvent()) |
139 const ui::MouseEvent& event, | 99 return RewriteKeyEvent(*event.AsKeyEvent(), rewritten_event); |
140 int* flags) { | |
141 if (!enabled_) | |
142 return ui::EVENT_REWRITE_CONTINUE; | |
143 int mod_down_flags = 0; | |
144 bool released = false; | |
145 bool consumed = HandleMouseEvent(event, &mod_down_flags, &released); | |
146 UpdateOverlay(); | |
147 return RewriteUpdate(consumed, released, mod_down_flags, flags); | |
148 } | |
149 | 100 |
150 ui::EventRewriteStatus StickyKeysController::RewriteScrollEvent( | 101 if (event.IsMouseEvent()) |
151 const ui::ScrollEvent& event, | 102 return RewriteMouseEvent(*event.AsMouseEvent(), rewritten_event); |
152 int* flags) { | 103 |
153 if (!enabled_) | 104 if (event.IsScrollEvent()) |
154 return ui::EVENT_REWRITE_CONTINUE; | 105 return RewriteScrollEvent(*event.AsScrollEvent(), rewritten_event); |
155 int mod_down_flags = 0; | 106 |
156 bool released = false; | 107 NOTREACHED(); |
157 bool consumed = HandleScrollEvent(event, &mod_down_flags, &released); | 108 return ui::EVENT_REWRITE_CONTINUE; |
158 UpdateOverlay(); | |
159 return RewriteUpdate(consumed, released, mod_down_flags, flags); | |
160 } | 109 } |
161 | 110 |
162 ui::EventRewriteStatus StickyKeysController::NextDispatchEvent( | 111 ui::EventRewriteStatus StickyKeysController::NextDispatchEvent( |
| 112 const ui::Event& last_event, |
163 std::unique_ptr<ui::Event>* new_event) { | 113 std::unique_ptr<ui::Event>* new_event) { |
164 DCHECK(new_event); | 114 DCHECK(new_event); |
165 new_event->reset(); | 115 new_event->reset(); |
166 int remaining = shift_sticky_key_->GetModifierUpEvent(new_event) + | 116 int remaining = shift_sticky_key_->GetModifierUpEvent(new_event) + |
167 alt_sticky_key_->GetModifierUpEvent(new_event) + | 117 alt_sticky_key_->GetModifierUpEvent(new_event) + |
168 altgr_sticky_key_->GetModifierUpEvent(new_event) + | 118 altgr_sticky_key_->GetModifierUpEvent(new_event) + |
169 ctrl_sticky_key_->GetModifierUpEvent(new_event) + | 119 ctrl_sticky_key_->GetModifierUpEvent(new_event) + |
170 mod3_sticky_key_->GetModifierUpEvent(new_event) + | 120 mod3_sticky_key_->GetModifierUpEvent(new_event) + |
171 search_sticky_key_->GetModifierUpEvent(new_event); | 121 search_sticky_key_->GetModifierUpEvent(new_event); |
172 if (!new_event) | 122 if (!new_event) |
173 return ui::EVENT_REWRITE_CONTINUE; | 123 return ui::EVENT_REWRITE_CONTINUE; |
174 if (remaining) | 124 if (remaining) |
175 return ui::EVENT_REWRITE_DISPATCH_ANOTHER; | 125 return ui::EVENT_REWRITE_DISPATCH_ANOTHER; |
176 return ui::EVENT_REWRITE_REWRITTEN; | 126 return ui::EVENT_REWRITE_REWRITTEN; |
177 } | 127 } |
178 | 128 |
| 129 ui::EventRewriteStatus StickyKeysController::RewriteKeyEvent( |
| 130 const ui::KeyEvent& event, |
| 131 std::unique_ptr<ui::Event>* rewritten_event) { |
| 132 DCHECK(enabled_); |
| 133 int mod_down_flags = 0; |
| 134 bool released = false; |
| 135 bool consumed = |
| 136 shift_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) || |
| 137 alt_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) || |
| 138 altgr_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) || |
| 139 ctrl_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) || |
| 140 mod3_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released) || |
| 141 search_sticky_key_->HandleKeyEvent(event, &mod_down_flags, &released); |
| 142 UpdateOverlay(); |
| 143 return RewriteUpdate(consumed, released, mod_down_flags, event, |
| 144 rewritten_event); |
| 145 } |
| 146 |
| 147 ui::EventRewriteStatus StickyKeysController::RewriteMouseEvent( |
| 148 const ui::MouseEvent& event, |
| 149 std::unique_ptr<ui::Event>* rewritten_event) { |
| 150 DCHECK(enabled_); |
| 151 int mod_down_flags = 0; |
| 152 bool released = false; |
| 153 bool consumed = |
| 154 shift_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) || |
| 155 alt_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) || |
| 156 altgr_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) || |
| 157 ctrl_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released) || |
| 158 mod3_sticky_key_->HandleMouseEvent(event, &mod_down_flags, &released); |
| 159 return RewriteUpdate(consumed, released, mod_down_flags, event, |
| 160 rewritten_event); |
| 161 } |
| 162 |
| 163 ui::EventRewriteStatus StickyKeysController::RewriteScrollEvent( |
| 164 const ui::ScrollEvent& event, |
| 165 std::unique_ptr<ui::Event>* rewritten_event) { |
| 166 DCHECK(enabled_); |
| 167 int mod_down_flags = 0; |
| 168 bool released = false; |
| 169 bool consumed = |
| 170 shift_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) || |
| 171 alt_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) || |
| 172 altgr_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) || |
| 173 ctrl_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released) || |
| 174 mod3_sticky_key_->HandleScrollEvent(event, &mod_down_flags, &released); |
| 175 return RewriteUpdate(consumed, released, mod_down_flags, event, |
| 176 rewritten_event); |
| 177 } |
| 178 |
179 void StickyKeysController::UpdateOverlay() { | 179 void StickyKeysController::UpdateOverlay() { |
180 overlay_->SetModifierKeyState(ui::EF_SHIFT_DOWN, | 180 overlay_->SetModifierKeyState(ui::EF_SHIFT_DOWN, |
181 shift_sticky_key_->current_state()); | 181 shift_sticky_key_->current_state()); |
182 overlay_->SetModifierKeyState(ui::EF_CONTROL_DOWN, | 182 overlay_->SetModifierKeyState(ui::EF_CONTROL_DOWN, |
183 ctrl_sticky_key_->current_state()); | 183 ctrl_sticky_key_->current_state()); |
184 overlay_->SetModifierKeyState(ui::EF_ALT_DOWN, | 184 overlay_->SetModifierKeyState(ui::EF_ALT_DOWN, |
185 alt_sticky_key_->current_state()); | 185 alt_sticky_key_->current_state()); |
186 overlay_->SetModifierKeyState(ui::EF_COMMAND_DOWN, | 186 overlay_->SetModifierKeyState(ui::EF_COMMAND_DOWN, |
187 search_sticky_key_->current_state()); | 187 search_sticky_key_->current_state()); |
188 overlay_->SetModifierKeyState(ui::EF_ALTGR_DOWN, | 188 overlay_->SetModifierKeyState(ui::EF_ALTGR_DOWN, |
189 altgr_sticky_key_->current_state()); | 189 altgr_sticky_key_->current_state()); |
190 overlay_->SetModifierKeyState(ui::EF_MOD3_DOWN, | 190 overlay_->SetModifierKeyState(ui::EF_MOD3_DOWN, |
191 mod3_sticky_key_->current_state()); | 191 mod3_sticky_key_->current_state()); |
192 | 192 |
193 bool key_in_use = | 193 bool key_in_use = |
194 shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || | 194 shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || |
195 alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || | 195 alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || |
196 altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || | 196 altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || |
197 ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || | 197 ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || |
198 search_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || | 198 search_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED || |
199 mod3_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED; | 199 mod3_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED; |
200 | 200 |
201 overlay_->Show(enabled_ && key_in_use); | 201 overlay_->Show(enabled_ && key_in_use); |
202 } | 202 } |
203 | 203 |
204 StickyKeysOverlay* StickyKeysController::GetOverlayForTest() { | |
205 return overlay_.get(); | |
206 } | |
207 | |
208 /////////////////////////////////////////////////////////////////////////////// | 204 /////////////////////////////////////////////////////////////////////////////// |
209 // StickyKeysHandler | 205 // StickyKeysHandler |
210 StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag) | 206 StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag) |
211 : modifier_flag_(modifier_flag), | 207 : modifier_flag_(modifier_flag), |
212 current_state_(STICKY_KEY_STATE_DISABLED), | 208 current_state_(STICKY_KEY_STATE_DISABLED), |
213 preparing_to_enable_(false), | 209 preparing_to_enable_(false), |
214 scroll_delta_(0) {} | 210 scroll_delta_(0) {} |
215 | 211 |
216 StickyKeysHandler::~StickyKeysHandler() {} | 212 StickyKeysHandler::~StickyKeysHandler() {} |
217 | 213 |
218 bool StickyKeysHandler::HandleKeyEvent(const ui::KeyEvent& event, | 214 bool StickyKeysHandler::HandleKeyEvent(const ui::KeyEvent& event, |
219 ui::KeyboardCode key_code, | |
220 int* mod_down_flags, | 215 int* mod_down_flags, |
221 bool* released) { | 216 bool* released) { |
222 switch (current_state_) { | 217 switch (current_state_) { |
223 case STICKY_KEY_STATE_DISABLED: | 218 case STICKY_KEY_STATE_DISABLED: |
224 return HandleDisabledState(event, key_code); | 219 return HandleDisabledState(event); |
225 case STICKY_KEY_STATE_ENABLED: | 220 case STICKY_KEY_STATE_ENABLED: |
226 return HandleEnabledState(event, key_code, mod_down_flags, released); | 221 return HandleEnabledState(event, mod_down_flags, released); |
227 case STICKY_KEY_STATE_LOCKED: | 222 case STICKY_KEY_STATE_LOCKED: |
228 return HandleLockedState(event, key_code, mod_down_flags, released); | 223 return HandleLockedState(event, mod_down_flags, released); |
229 } | 224 } |
230 NOTREACHED(); | 225 NOTREACHED(); |
231 return false; | 226 return false; |
232 } | 227 } |
233 | 228 |
234 bool StickyKeysHandler::HandleMouseEvent(const ui::MouseEvent& event, | 229 bool StickyKeysHandler::HandleMouseEvent(const ui::MouseEvent& event, |
235 int* mod_down_flags, | 230 int* mod_down_flags, |
236 bool* released) { | 231 bool* released) { |
237 if (ShouldModifyMouseEvent(event)) | 232 if (ShouldModifyMouseEvent(event)) |
238 preparing_to_enable_ = false; | 233 preparing_to_enable_ = false; |
(...skipping 88 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
327 return type == ui::ET_KEY_PRESSED ? NORMAL_KEY_DOWN : NORMAL_KEY_UP; | 322 return type == ui::ET_KEY_PRESSED ? NORMAL_KEY_DOWN : NORMAL_KEY_UP; |
328 } | 323 } |
329 | 324 |
330 if (is_target_key) { | 325 if (is_target_key) { |
331 return type == ui::ET_KEY_PRESSED ? TARGET_MODIFIER_DOWN | 326 return type == ui::ET_KEY_PRESSED ? TARGET_MODIFIER_DOWN |
332 : TARGET_MODIFIER_UP; | 327 : TARGET_MODIFIER_UP; |
333 } | 328 } |
334 return type == ui::ET_KEY_PRESSED ? OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP; | 329 return type == ui::ET_KEY_PRESSED ? OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP; |
335 } | 330 } |
336 | 331 |
337 bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event, | 332 bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event) { |
338 ui::KeyboardCode key_code) { | 333 switch (TranslateKeyEvent(event.type(), event.key_code())) { |
339 switch (TranslateKeyEvent(event.type(), key_code)) { | |
340 case TARGET_MODIFIER_UP: | 334 case TARGET_MODIFIER_UP: |
341 if (preparing_to_enable_) { | 335 if (preparing_to_enable_) { |
342 preparing_to_enable_ = false; | 336 preparing_to_enable_ = false; |
343 scroll_delta_ = 0; | 337 scroll_delta_ = 0; |
344 current_state_ = STICKY_KEY_STATE_ENABLED; | 338 current_state_ = STICKY_KEY_STATE_ENABLED; |
345 modifier_up_event_.reset(new ui::KeyEvent(event)); | 339 modifier_up_event_.reset(new ui::KeyEvent(event)); |
346 return true; | 340 return true; |
347 } | 341 } |
348 return false; | 342 return false; |
349 case TARGET_MODIFIER_DOWN: | 343 case TARGET_MODIFIER_DOWN: |
350 preparing_to_enable_ = true; | 344 preparing_to_enable_ = true; |
351 return false; | 345 return false; |
352 case NORMAL_KEY_DOWN: | 346 case NORMAL_KEY_DOWN: |
353 preparing_to_enable_ = false; | 347 preparing_to_enable_ = false; |
354 return false; | 348 return false; |
355 case NORMAL_KEY_UP: | 349 case NORMAL_KEY_UP: |
356 case OTHER_MODIFIER_DOWN: | 350 case OTHER_MODIFIER_DOWN: |
357 case OTHER_MODIFIER_UP: | 351 case OTHER_MODIFIER_UP: |
358 return false; | 352 return false; |
359 } | 353 } |
360 NOTREACHED(); | 354 NOTREACHED(); |
361 return false; | 355 return false; |
362 } | 356 } |
363 | 357 |
364 bool StickyKeysHandler::HandleEnabledState(const ui::KeyEvent& event, | 358 bool StickyKeysHandler::HandleEnabledState(const ui::KeyEvent& event, |
365 ui::KeyboardCode key_code, | |
366 int* mod_down_flags, | 359 int* mod_down_flags, |
367 bool* released) { | 360 bool* released) { |
368 switch (TranslateKeyEvent(event.type(), key_code)) { | 361 switch (TranslateKeyEvent(event.type(), event.key_code())) { |
369 case NORMAL_KEY_UP: | 362 case NORMAL_KEY_UP: |
370 case TARGET_MODIFIER_DOWN: | 363 case TARGET_MODIFIER_DOWN: |
371 return false; | 364 return false; |
372 case TARGET_MODIFIER_UP: | 365 case TARGET_MODIFIER_UP: |
373 current_state_ = STICKY_KEY_STATE_LOCKED; | 366 current_state_ = STICKY_KEY_STATE_LOCKED; |
374 modifier_up_event_.reset(); | 367 modifier_up_event_.reset(); |
375 return true; | 368 return true; |
376 case NORMAL_KEY_DOWN: { | 369 case NORMAL_KEY_DOWN: { |
377 current_state_ = STICKY_KEY_STATE_DISABLED; | 370 current_state_ = STICKY_KEY_STATE_DISABLED; |
378 *mod_down_flags |= modifier_flag_; | 371 *mod_down_flags |= modifier_flag_; |
379 *released = true; | 372 *released = true; |
380 return false; | 373 return false; |
381 } | 374 } |
382 case OTHER_MODIFIER_DOWN: | 375 case OTHER_MODIFIER_DOWN: |
383 case OTHER_MODIFIER_UP: | 376 case OTHER_MODIFIER_UP: |
384 return false; | 377 return false; |
385 } | 378 } |
386 NOTREACHED(); | 379 NOTREACHED(); |
387 return false; | 380 return false; |
388 } | 381 } |
389 | 382 |
390 bool StickyKeysHandler::HandleLockedState(const ui::KeyEvent& event, | 383 bool StickyKeysHandler::HandleLockedState(const ui::KeyEvent& event, |
391 ui::KeyboardCode key_code, | |
392 int* mod_down_flags, | 384 int* mod_down_flags, |
393 bool* released) { | 385 bool* released) { |
394 switch (TranslateKeyEvent(event.type(), key_code)) { | 386 switch (TranslateKeyEvent(event.type(), event.key_code())) { |
395 case TARGET_MODIFIER_DOWN: | 387 case TARGET_MODIFIER_DOWN: |
396 return true; | 388 return true; |
397 case TARGET_MODIFIER_UP: | 389 case TARGET_MODIFIER_UP: |
398 current_state_ = STICKY_KEY_STATE_DISABLED; | 390 current_state_ = STICKY_KEY_STATE_DISABLED; |
399 return false; | 391 return false; |
400 case NORMAL_KEY_DOWN: | 392 case NORMAL_KEY_DOWN: |
401 case NORMAL_KEY_UP: | 393 case NORMAL_KEY_UP: |
402 *mod_down_flags |= modifier_flag_; | 394 *mod_down_flags |= modifier_flag_; |
403 return false; | 395 return false; |
404 case OTHER_MODIFIER_DOWN: | 396 case OTHER_MODIFIER_DOWN: |
405 case OTHER_MODIFIER_UP: | 397 case OTHER_MODIFIER_UP: |
406 return false; | 398 return false; |
407 } | 399 } |
408 NOTREACHED(); | 400 NOTREACHED(); |
409 return false; | 401 return false; |
410 } | 402 } |
411 | 403 |
412 } // namespace ash | 404 } // namespace ash |
OLD | NEW |