src/ash/sticky_keys/sticky_keys_controller.cc

   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
   3 // found in the LICENSE file.
   4
   5 #include "ash/sticky_keys/sticky_keys_controller.h"
   6
   7 #include "ash/sticky_keys/sticky_keys_overlay.h"
   8 #include "base/basictypes.h"
   9 #include "base/debug/stack_trace.h"
  10 #include "ui/aura/window.h"
  11 #include "ui/aura/window_tracker.h"
  12 #include "ui/aura/window_tree_host.h"
  13 #include "ui/events/event.h"
  14 #include "ui/events/event_processor.h"
  15 #include "ui/events/keycodes/keyboard_code_conversion.h"
  16
  17 namespace ash {
  18
  19 namespace {
  20
  21 // Returns true if the type of mouse event should be modified by sticky keys.
  22 bool ShouldModifyMouseEvent(const ui::MouseEvent& event) {
  23   ui::EventType type = event.type();
  24   return type == ui::ET_MOUSE_PRESSED || type == ui::ET_MOUSE_RELEASED ||
  25          type == ui::ET_MOUSEWHEEL;
  26 }
  27
  28 // Handle the common tail of event rewriting.
  29 ui::EventRewriteStatus RewriteUpdate(bool consumed,
  30                                      bool released,
  31                                      int mod_down_flags,
  32                                      int* flags) {
  33   int changed_down_flags = mod_down_flags & ~*flags;
  34   *flags |= mod_down_flags;
  35   if (consumed)
  36     return ui::EVENT_REWRITE_DISCARD;
  37   if (released)
  38     return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
  39   if (changed_down_flags)
  40     return ui::EVENT_REWRITE_REWRITTEN;
  41   return ui::EVENT_REWRITE_CONTINUE;
  42 }
  43
  44 }  // namespace
  45
  46 ///////////////////////////////////////////////////////////////////////////////
  47 //  StickyKeys
  48 StickyKeysController::StickyKeysController()
  49     : enabled_(false),
  50       mod3_enabled_(false),
  51       altgr_enabled_(false) {
  52 }
  53
  54 StickyKeysController::~StickyKeysController() {
  55 }
  56
  57 void StickyKeysController::Enable(bool enabled) {
  58   if (enabled_ != enabled) {
  59     enabled_ = enabled;
  60
  61     // Reset key handlers when activating sticky keys to ensure all
  62     // the handlers' states are reset.
  63     if (enabled_) {
  64       shift_sticky_key_.reset(new StickyKeysHandler(ui::EF_SHIFT_DOWN));
  65       alt_sticky_key_.reset(new StickyKeysHandler(ui::EF_ALT_DOWN));
  66       altgr_sticky_key_.reset(new StickyKeysHandler(ui::EF_ALTGR_DOWN));
  67       ctrl_sticky_key_.reset(new StickyKeysHandler(ui::EF_CONTROL_DOWN));
  68       mod3_sticky_key_.reset(new StickyKeysHandler(ui::EF_MOD3_DOWN));
  69
  70       overlay_.reset(new StickyKeysOverlay());
  71       overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_);
  72       overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_);
  73     } else if (overlay_) {
  74       overlay_->Show(false);
  75     }
  76   }
  77 }
  78
  79 void StickyKeysController::SetModifiersEnabled(bool mod3_enabled,
  80                                                bool altgr_enabled) {
  81   mod3_enabled_ = mod3_enabled;
  82   altgr_enabled_ = altgr_enabled;
  83   if (overlay_) {
  84     overlay_->SetModifierVisible(ui::EF_ALTGR_DOWN, altgr_enabled_);
  85     overlay_->SetModifierVisible(ui::EF_MOD3_DOWN, mod3_enabled_);
  86   }
  87 }
  88
  89 bool StickyKeysController::HandleKeyEvent(const ui::KeyEvent& event,
  90                                           ui::KeyboardCode key_code,
  91                                           int* mod_down_flags,
  92                                           bool* released) {
  93   return shift_sticky_key_->HandleKeyEvent(
  94              event, key_code, mod_down_flags, released) ||
  95          alt_sticky_key_->HandleKeyEvent(
  96              event, key_code, mod_down_flags, released) ||
  97          altgr_sticky_key_->HandleKeyEvent(
  98              event, key_code, mod_down_flags, released) ||
  99          ctrl_sticky_key_->HandleKeyEvent(
 100              event, key_code, mod_down_flags, released) ||
 101          mod3_sticky_key_->HandleKeyEvent(
 102              event, key_code, mod_down_flags, released);
 103 }
 104
 105 bool StickyKeysController::HandleMouseEvent(const ui::MouseEvent& event,
 106                                             int* mod_down_flags,
 107                                             bool* released) {
 108   return shift_sticky_key_->HandleMouseEvent(
 109              event, mod_down_flags, released) ||
 110          alt_sticky_key_->HandleMouseEvent(
 111              event, mod_down_flags, released) ||
 112          altgr_sticky_key_->HandleMouseEvent(
 113              event, mod_down_flags, released) ||
 114          ctrl_sticky_key_->HandleMouseEvent(
 115              event, mod_down_flags, released) ||
 116          mod3_sticky_key_->HandleMouseEvent(
 117              event, mod_down_flags, released);
 118 }
 119
 120 bool StickyKeysController::HandleScrollEvent(const ui::ScrollEvent& event,
 121                                              int* mod_down_flags,
 122                                              bool* released) {
 123   return shift_sticky_key_->HandleScrollEvent(
 124              event, mod_down_flags, released) ||
 125          alt_sticky_key_->HandleScrollEvent(
 126              event, mod_down_flags, released) ||
 127          altgr_sticky_key_->HandleScrollEvent(
 128              event, mod_down_flags, released) ||
 129          ctrl_sticky_key_->HandleScrollEvent(
 130              event, mod_down_flags, released) ||
 131          mod3_sticky_key_->HandleScrollEvent(
 132              event, mod_down_flags, released);
 133 }
 134
 135 ui::EventRewriteStatus StickyKeysController::RewriteKeyEvent(
 136     const ui::KeyEvent& event,
 137     ui::KeyboardCode key_code,
 138     int* flags) {
 139   if (!enabled_)
 140     return ui::EVENT_REWRITE_CONTINUE;
 141   int mod_down_flags = 0;
 142   bool released = false;
 143   bool consumed = HandleKeyEvent(event, key_code, &mod_down_flags, &released);
 144   UpdateOverlay();
 145   return RewriteUpdate(consumed, released, mod_down_flags, flags);
 146 }
 147
 148 ui::EventRewriteStatus StickyKeysController::RewriteMouseEvent(
 149     const ui::MouseEvent& event,
 150     int* flags) {
 151   if (!enabled_)
 152     return ui::EVENT_REWRITE_CONTINUE;
 153   int mod_down_flags = 0;
 154   bool released = false;
 155   bool consumed = HandleMouseEvent(event, &mod_down_flags, &released);
 156   UpdateOverlay();
 157   return RewriteUpdate(consumed, released, mod_down_flags, flags);
 158 }
 159
 160 ui::EventRewriteStatus StickyKeysController::RewriteScrollEvent(
 161     const ui::ScrollEvent& event,
 162     int* flags) {
 163   if (!enabled_)
 164     return ui::EVENT_REWRITE_CONTINUE;
 165   int mod_down_flags = 0;
 166   bool released = false;
 167   bool consumed = HandleScrollEvent(event, &mod_down_flags, &released);
 168   UpdateOverlay();
 169   return RewriteUpdate(consumed, released, mod_down_flags, flags);
 170 }
 171
 172 ui::EventRewriteStatus StickyKeysController::NextDispatchEvent(
 173     scoped_ptr<ui::Event>* new_event) {
 174   DCHECK(new_event);
 175   new_event->reset();
 176   int remaining = shift_sticky_key_->GetModifierUpEvent(new_event) +
 177                   alt_sticky_key_->GetModifierUpEvent(new_event) +
 178                   altgr_sticky_key_->GetModifierUpEvent(new_event) +
 179                   ctrl_sticky_key_->GetModifierUpEvent(new_event) +
 180                   mod3_sticky_key_->GetModifierUpEvent(new_event);
 181   if (!new_event)
 182     return ui::EVENT_REWRITE_CONTINUE;
 183   if (remaining)
 184     return ui::EVENT_REWRITE_DISPATCH_ANOTHER;
 185   return ui::EVENT_REWRITE_REWRITTEN;
 186 }
 187
 188 void StickyKeysController::UpdateOverlay() {
 189   overlay_->SetModifierKeyState(
 190       ui::EF_SHIFT_DOWN, shift_sticky_key_->current_state());
 191   overlay_->SetModifierKeyState(
 192       ui::EF_CONTROL_DOWN, ctrl_sticky_key_->current_state());
 193   overlay_->SetModifierKeyState(
 194       ui::EF_ALT_DOWN, alt_sticky_key_->current_state());
 195   overlay_->SetModifierKeyState(
 196       ui::EF_ALTGR_DOWN, altgr_sticky_key_->current_state());
 197   overlay_->SetModifierKeyState(
 198       ui::EF_MOD3_DOWN, mod3_sticky_key_->current_state());
 199
 200   bool key_in_use =
 201       shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
 202       alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
 203       altgr_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
 204       ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
 205       mod3_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED;
 206
 207   overlay_->Show(enabled_ && key_in_use);
 208 }
 209
 210 StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
 211   return overlay_.get();
 212 }
 213
 214 ///////////////////////////////////////////////////////////////////////////////
 215 //  StickyKeysHandler
 216 StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag)
 217     : modifier_flag_(modifier_flag),
 218       current_state_(STICKY_KEY_STATE_DISABLED),
 219       preparing_to_enable_(false),
 220       scroll_delta_(0) {
 221 }
 222
 223 StickyKeysHandler::~StickyKeysHandler() {
 224 }
 225
 226 bool StickyKeysHandler::HandleKeyEvent(const ui::KeyEvent& event,
 227                                        ui::KeyboardCode key_code,
 228                                        int* mod_down_flags,
 229                                        bool* released) {
 230   switch (current_state_) {
 231     case STICKY_KEY_STATE_DISABLED:
 232       return HandleDisabledState(event, key_code);
 233     case STICKY_KEY_STATE_ENABLED:
 234       return HandleEnabledState(event, key_code, mod_down_flags, released);
 235     case STICKY_KEY_STATE_LOCKED:
 236       return HandleLockedState(event, key_code, mod_down_flags, released);
 237   }
 238   NOTREACHED();
 239   return false;
 240 }
 241
 242 bool StickyKeysHandler::HandleMouseEvent(
 243     const ui::MouseEvent& event,
 244     int* mod_down_flags,
 245     bool* released) {
 246   if (ShouldModifyMouseEvent(event))
 247     preparing_to_enable_ = false;
 248
 249   if (current_state_ == STICKY_KEY_STATE_DISABLED ||
 250       !ShouldModifyMouseEvent(event)) {
 251     return false;
 252   }
 253   DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
 254          current_state_ == STICKY_KEY_STATE_LOCKED);
 255
 256   *mod_down_flags |= modifier_flag_;
 257   // Only disable on the mouse released event in normal, non-locked mode.
 258   if (current_state_ == STICKY_KEY_STATE_ENABLED &&
 259       event.type() != ui::ET_MOUSE_PRESSED) {
 260     current_state_ = STICKY_KEY_STATE_DISABLED;
 261     *released = true;
 262     return false;
 263   }
 264
 265   return false;
 266 }
 267
 268 bool StickyKeysHandler::HandleScrollEvent(
 269     const ui::ScrollEvent& event,
 270     int* mod_down_flags,
 271     bool* released) {
 272   preparing_to_enable_ = false;
 273   if (current_state_ == STICKY_KEY_STATE_DISABLED)
 274     return false;
 275   DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
 276          current_state_ == STICKY_KEY_STATE_LOCKED);
 277
 278   // We detect a direction change if the current |scroll_delta_| is assigned
 279   // and the offset of the current scroll event has the opposing sign.
 280   bool direction_changed = false;
 281   if (current_state_ == STICKY_KEY_STATE_ENABLED &&
 282       event.type() == ui::ET_SCROLL) {
 283     int offset = event.y_offset();
 284     if (scroll_delta_)
 285       direction_changed = offset * scroll_delta_ <= 0;
 286     scroll_delta_ = offset;
 287   }
 288
 289   if (!direction_changed)
 290     *mod_down_flags |= modifier_flag_;
 291
 292   // We want to modify all the scroll events in the scroll sequence, which ends
 293   // with a fling start event. We also stop when the scroll sequence changes
 294   // direction.
 295   if (current_state_ == STICKY_KEY_STATE_ENABLED &&
 296       (event.type() == ui::ET_SCROLL_FLING_START || direction_changed)) {
 297     current_state_ = STICKY_KEY_STATE_DISABLED;
 298     scroll_delta_ = 0;
 299     *released = true;
 300     return false;
 301   }
 302
 303   return false;
 304 }
 305
 306 int StickyKeysHandler::GetModifierUpEvent(scoped_ptr<ui::Event>* new_event) {
 307   if (current_state_ != STICKY_KEY_STATE_DISABLED || !modifier_up_event_)
 308     return 0;
 309   DCHECK(new_event);
 310   if (*new_event)
 311     return 1;
 312   new_event->reset(modifier_up_event_.release());
 313   return 0;
 314 }
 315
 316 StickyKeysHandler::KeyEventType StickyKeysHandler::TranslateKeyEvent(
 317     ui::EventType type,
 318     ui::KeyboardCode key_code) {
 319   bool is_target_key = false;
 320   if (key_code == ui::VKEY_SHIFT ||
 321       key_code == ui::VKEY_LSHIFT ||
 322       key_code == ui::VKEY_RSHIFT) {
 323     is_target_key = (modifier_flag_ == ui::EF_SHIFT_DOWN);
 324   } else if (key_code == ui::VKEY_CONTROL ||
 325       key_code == ui::VKEY_LCONTROL ||
 326       key_code == ui::VKEY_RCONTROL) {
 327     is_target_key = (modifier_flag_ == ui::EF_CONTROL_DOWN);
 328   } else if (key_code == ui::VKEY_MENU ||
 329       key_code == ui::VKEY_LMENU ||
 330       key_code == ui::VKEY_RMENU) {
 331     is_target_key = (modifier_flag_ == ui::EF_ALT_DOWN);
 332   } else if (key_code == ui::VKEY_ALTGR) {
 333     is_target_key = (modifier_flag_ == ui::EF_ALTGR_DOWN);
 334   } else if (key_code == ui::VKEY_OEM_8) {
 335     is_target_key = (modifier_flag_ == ui::EF_MOD3_DOWN);
 336   } else {
 337     return type == ui::ET_KEY_PRESSED ?
 338         NORMAL_KEY_DOWN : NORMAL_KEY_UP;
 339   }
 340
 341   if (is_target_key) {
 342     return type == ui::ET_KEY_PRESSED ?
 343         TARGET_MODIFIER_DOWN : TARGET_MODIFIER_UP;
 344   }
 345   return type == ui::ET_KEY_PRESSED ?
 346       OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP;
 347 }
 348
 349 bool StickyKeysHandler::HandleDisabledState(const ui::KeyEvent& event,
 350                                             ui::KeyboardCode key_code) {
 351   switch (TranslateKeyEvent(event.type(), key_code)) {
 352     case TARGET_MODIFIER_UP:
 353       if (preparing_to_enable_) {
 354         preparing_to_enable_ = false;
 355         scroll_delta_ = 0;
 356         current_state_ = STICKY_KEY_STATE_ENABLED;
 357         modifier_up_event_.reset(new ui::KeyEvent(event));
 358         return true;
 359       }
 360       return false;
 361     case TARGET_MODIFIER_DOWN:
 362       preparing_to_enable_ = true;
 363       return false;
 364     case NORMAL_KEY_DOWN:
 365       preparing_to_enable_ = false;
 366       return false;
 367     case NORMAL_KEY_UP:
 368     case OTHER_MODIFIER_DOWN:
 369     case OTHER_MODIFIER_UP:
 370       return false;
 371   }
 372   NOTREACHED();
 373   return false;
 374 }
 375
 376 bool StickyKeysHandler::HandleEnabledState(const ui::KeyEvent& event,
 377                                            ui::KeyboardCode key_code,
 378                                            int* mod_down_flags,
 379                                            bool* released) {
 380   switch (TranslateKeyEvent(event.type(), key_code)) {
 381     case NORMAL_KEY_UP:
 382     case TARGET_MODIFIER_DOWN:
 383       return false;
 384     case TARGET_MODIFIER_UP:
 385       current_state_ = STICKY_KEY_STATE_LOCKED;
 386       modifier_up_event_.reset();
 387       return true;
 388     case NORMAL_KEY_DOWN: {
 389       current_state_ = STICKY_KEY_STATE_DISABLED;
 390       *mod_down_flags |= modifier_flag_;
 391       *released = true;
 392       return false;
 393     }
 394     case OTHER_MODIFIER_DOWN:
 395     case OTHER_MODIFIER_UP:
 396       return false;
 397   }
 398   NOTREACHED();
 399   return false;
 400 }
 401
 402 bool StickyKeysHandler::HandleLockedState(const ui::KeyEvent& event,
 403                                           ui::KeyboardCode key_code,
 404                                           int* mod_down_flags,
 405                                           bool* released) {
 406   switch (TranslateKeyEvent(event.type(), key_code)) {
 407     case TARGET_MODIFIER_DOWN:
 408       return true;
 409     case TARGET_MODIFIER_UP:
 410       current_state_ = STICKY_KEY_STATE_DISABLED;
 411       return false;
 412     case NORMAL_KEY_DOWN:
 413     case NORMAL_KEY_UP:
 414       *mod_down_flags |= modifier_flag_;
 415       return false;
 416     case OTHER_MODIFIER_DOWN:
 417     case OTHER_MODIFIER_UP:
 418       return false;
 419   }
 420   NOTREACHED();
 421   return false;
 422 }
 423
 424 }  // namespace ash