Show overlay displaying the state of all sticky keys when it is enabled.

ash/sticky_keys/sticky_keys_controller.cc

 // Copyright 2013 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 "ash/sticky_keys/sticky_keys_controller.h"
 
 #if defined(USE_X11)
 #include <X11/extensions/XInput2.h>
 #include <X11/Xlib.h>
 #undef RootWindow
 #endif
 
+#include "ash/sticky_keys/sticky_keys_overlay.h"
 #include "base/basictypes.h"
 #include "base/debug/stack_trace.h"
 #include "ui/aura/root_window.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_tracker.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_code_conversion.h"
 
 namespace ash {
 
@@ skipping 59 matching lines @@
   DCHECK(target);
   target->GetDispatcher()->AsWindowTreeHostDelegate()
       ->OnHostScrollEvent(event);
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeys
 StickyKeysController::StickyKeysController()
-    : enabled_(false),
-      shift_sticky_key_(
-          new StickyKeysHandler(ui::EF_SHIFT_DOWN,
-                              new StickyKeysHandlerDelegateImpl())),
-      alt_sticky_key_(
-          new StickyKeysHandler(ui::EF_ALT_DOWN,
-                                new StickyKeysHandlerDelegateImpl())),
-      ctrl_sticky_key_(
-          new StickyKeysHandler(ui::EF_CONTROL_DOWN,
-                                new StickyKeysHandlerDelegateImpl())) {
+    : enabled_(false) {
 }
 
 StickyKeysController::~StickyKeysController() {
 }
 
 void StickyKeysController::Enable(bool enabled) {
   if (enabled_ != enabled) {
     enabled_ = enabled;
 
     // Reset key handlers when activating sticky keys to ensure all
     // the handlers' states are reset.
     if (enabled_) {
       shift_sticky_key_.reset(
           new StickyKeysHandler(ui::EF_SHIFT_DOWN,
-                              new StickyKeysHandlerDelegateImpl()));
+                                new StickyKeysHandlerDelegateImpl()));
       alt_sticky_key_.reset(
           new StickyKeysHandler(ui::EF_ALT_DOWN,
                                 new StickyKeysHandlerDelegateImpl()));
       ctrl_sticky_key_.reset(
           new StickyKeysHandler(ui::EF_CONTROL_DOWN,
                                 new StickyKeysHandlerDelegateImpl()));
+
+      overlay_.reset(new StickyKeysOverlay());
+    } else if (overlay_.get()) {
+      overlay_->Show(false);
     }
   }
 }
 
 bool StickyKeysController::HandleKeyEvent(ui::KeyEvent* event) {
   return shift_sticky_key_->HandleKeyEvent(event) ||
       alt_sticky_key_->HandleKeyEvent(event) ||
       ctrl_sticky_key_->HandleKeyEvent(event);
 }
 
 bool StickyKeysController::HandleMouseEvent(ui::MouseEvent* event) {
   return shift_sticky_key_->HandleMouseEvent(event) ||
       alt_sticky_key_->HandleMouseEvent(event) ||
       ctrl_sticky_key_->HandleMouseEvent(event);
 }
 
 bool StickyKeysController::HandleScrollEvent(ui::ScrollEvent* event) {
   return shift_sticky_key_->HandleScrollEvent(event) ||
       alt_sticky_key_->HandleScrollEvent(event) ||
       ctrl_sticky_key_->HandleScrollEvent(event);
 }
 
 void StickyKeysController::OnKeyEvent(ui::KeyEvent* event) {
   // Do not consume a translated key event which is generated by an IME.
   if (event->type() == ui::ET_TRANSLATED_KEY_PRESS ||
       event->type() == ui::ET_TRANSLATED_KEY_RELEASE) {
     return;
   }
 
-  if (enabled_ && HandleKeyEvent(event))
-    event->StopPropagation();
+  if (enabled_) {
+    if (HandleKeyEvent(event))
+      event->StopPropagation();
+    UpdateOverlay();
+  }
 }
 
 void StickyKeysController::OnMouseEvent(ui::MouseEvent* event) {
-  if (enabled_ && HandleMouseEvent(event))
-    event->StopPropagation();
+  if (enabled_) {
+    if (HandleMouseEvent(event))
+      event->StopPropagation();
+    UpdateOverlay();
+  }
 }
 
 void StickyKeysController::OnScrollEvent(ui::ScrollEvent* event) {
-  if (enabled_ && HandleScrollEvent(event))
-    event->StopPropagation();
+  if (enabled_) {
+    if (HandleScrollEvent(event))
+      event->StopPropagation();
+    UpdateOverlay();
+  }
+}
+
+void StickyKeysController::UpdateOverlay() {
+  overlay_->SetModifierKeyState(
+      ui::EF_SHIFT_DOWN, shift_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(
+      ui::EF_CONTROL_DOWN, ctrl_sticky_key_->current_state());
+  overlay_->SetModifierKeyState(
+      ui::EF_ALT_DOWN, alt_sticky_key_->current_state());
+
+  bool key_in_use =
+      shift_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
+      alt_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED ||
+      ctrl_sticky_key_->current_state() != STICKY_KEY_STATE_DISABLED;
+
+  overlay_->Show(enabled_ && key_in_use);
+}
+
+StickyKeysOverlay* StickyKeysController::GetOverlayForTest() {
+  return overlay_.get();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 //  StickyKeysHandler
-StickyKeysHandler::StickyKeysHandler(ui::EventFlags target_modifier_flag,
+StickyKeysHandler::StickyKeysHandler(ui::EventFlags modifier_flag,
                                      StickyKeysHandlerDelegate* delegate)
-    : modifier_flag_(target_modifier_flag),
-      current_state_(DISABLED),
+    : modifier_flag_(modifier_flag),
+      current_state_(STICKY_KEY_STATE_DISABLED),
       event_from_myself_(false),
       preparing_to_enable_(false),
       scroll_delta_(0),
       delegate_(delegate) {
 }
 
 StickyKeysHandler::~StickyKeysHandler() {
 }
 
 StickyKeysHandler::StickyKeysHandlerDelegate::StickyKeysHandlerDelegate() {
 }
 
 StickyKeysHandler::StickyKeysHandlerDelegate::~StickyKeysHandlerDelegate() {
 }
 
 bool StickyKeysHandler::HandleKeyEvent(ui::KeyEvent* event) {
   if (event_from_myself_)
     return false;  // Do not handle self-generated key event.
   switch (current_state_) {
-    case DISABLED:
+    case STICKY_KEY_STATE_DISABLED:
       return HandleDisabledState(event);
-    case ENABLED:
+    case STICKY_KEY_STATE_ENABLED:
       return HandleEnabledState(event);
-    case LOCKED:
+    case STICKY_KEY_STATE_LOCKED:
       return HandleLockedState(event);
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleMouseEvent(ui::MouseEvent* event) {
   if (ShouldModifyMouseEvent(event))
     preparing_to_enable_ = false;
 
-  if (event_from_myself_ || current_state_ == DISABLED
+  if (event_from_myself_ || current_state_ == STICKY_KEY_STATE_DISABLED
       || !ShouldModifyMouseEvent(event)) {
     return false;
   }
-  DCHECK(current_state_ == ENABLED || current_state_ == LOCKED);
+  DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
+         current_state_ == STICKY_KEY_STATE_LOCKED);
 
   AppendModifier(event);
   // Only disable on the mouse released event in normal, non-locked mode.
-  if (current_state_ == ENABLED && event->type() != ui::ET_MOUSE_PRESSED) {
-    current_state_ = DISABLED;
+  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
+      event->type() != ui::ET_MOUSE_PRESSED) {
+    current_state_ = STICKY_KEY_STATE_DISABLED;
     DispatchEventAndReleaseModifier(event);
     return true;
   }
 
   return false;
 }
 
 bool StickyKeysHandler::HandleScrollEvent(ui::ScrollEvent* event) {
   preparing_to_enable_ = false;
-  if (event_from_myself_ || current_state_ == DISABLED)
+  if (event_from_myself_ || current_state_ == STICKY_KEY_STATE_DISABLED)
     return false;
-  DCHECK(current_state_ == ENABLED || current_state_ == LOCKED);
+  DCHECK(current_state_ == STICKY_KEY_STATE_ENABLED ||
+         current_state_ == STICKY_KEY_STATE_LOCKED);
 
   // We detect a direction change if the current |scroll_delta_| is assigned
   // and the offset of the current scroll event has the opposing sign.
   bool direction_changed = false;
-  if (current_state_ == ENABLED && event->type() == ui::ET_SCROLL) {
+  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
+      event->type() == ui::ET_SCROLL) {
     int offset = event->y_offset();
     if (scroll_delta_)
       direction_changed = offset * scroll_delta_ <= 0;
     scroll_delta_ = offset;
   }
 
   if (!direction_changed)
     AppendModifier(event);
 
   // We want to modify all the scroll events in the scroll sequence, which ends
   // with a fling start event. We also stop when the scroll sequence changes
   // direction.
-  if (current_state_ == ENABLED &&
+  if (current_state_ == STICKY_KEY_STATE_ENABLED &&
       (event->type() == ui::ET_SCROLL_FLING_START || direction_changed)) {
-    current_state_ = DISABLED;
+    current_state_ = STICKY_KEY_STATE_DISABLED;
     scroll_delta_ = 0;
     DispatchEventAndReleaseModifier(event);
     return true;
   }
 
   return false;
 }
 
 StickyKeysHandler::KeyEventType
     StickyKeysHandler::TranslateKeyEvent(ui::KeyEvent* event) {
@@ skipping 22 matching lines @@
   return event->type() == ui::ET_KEY_PRESSED ?
       OTHER_MODIFIER_DOWN : OTHER_MODIFIER_UP;
 }
 
 bool StickyKeysHandler::HandleDisabledState(ui::KeyEvent* event) {
   switch (TranslateKeyEvent(event)) {
     case TARGET_MODIFIER_UP:
       if (preparing_to_enable_) {
         preparing_to_enable_ = false;
         scroll_delta_ = 0;
-        current_state_ = ENABLED;
+        current_state_ = STICKY_KEY_STATE_ENABLED;
         modifier_up_event_.reset(new ui::KeyEvent(*event));
         return true;
       }
       return false;
     case TARGET_MODIFIER_DOWN:
       preparing_to_enable_ = true;
       return false;
     case NORMAL_KEY_DOWN:
       preparing_to_enable_ = false;
       return false;
     case NORMAL_KEY_UP:
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleEnabledState(ui::KeyEvent* event) {
   switch (TranslateKeyEvent(event)) {
     case NORMAL_KEY_UP:
     case TARGET_MODIFIER_DOWN:
       return true;
     case TARGET_MODIFIER_UP:
-      current_state_ = LOCKED;
+      current_state_ = STICKY_KEY_STATE_LOCKED;
       modifier_up_event_.reset();
       return true;
     case NORMAL_KEY_DOWN: {
-      current_state_ = DISABLED;
+      current_state_ = STICKY_KEY_STATE_DISABLED;
       AppendModifier(event);
       DispatchEventAndReleaseModifier(event);
       return true;
     }
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
   return false;
 }
 
 bool StickyKeysHandler::HandleLockedState(ui::KeyEvent* event) {
   switch (TranslateKeyEvent(event)) {
     case TARGET_MODIFIER_DOWN:
       return true;
     case TARGET_MODIFIER_UP:
-      current_state_ = DISABLED;
+      current_state_ = STICKY_KEY_STATE_DISABLED;
       return false;
     case NORMAL_KEY_DOWN:
     case NORMAL_KEY_UP:
       AppendModifier(event);
       return false;
     case OTHER_MODIFIER_DOWN:
     case OTHER_MODIFIER_UP:
       return false;
   }
   NOTREACHED();
@@ skipping 88 matching lines @@
           &xievent->mods.effective));
     }
   }
 #elif defined(USE_OZONE)
   NOTIMPLEMENTED() << "Modifier key is not handled";
 #endif
   event->set_flags(event->flags() | modifier_flag_);
 }
 
 }  // namespace ash