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

ash/sticky_keys/sticky_keys_controller.h

 // 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.
 
 #ifndef ASH_STICKY_KEYS_STICKY_KEYS_CONTROLLER_H_
 #define ASH_STICKY_KEYS_STICKY_KEYS_CONTROLLER_H_
 
 #include "ash/ash_export.h"
+#include "ash/sticky_keys/sticky_keys_constants.h"
 #include "base/memory/scoped_ptr.h"
 #include "ui/events/event_constants.h"
 #include "ui/events/event_handler.h"
 
 namespace ui {
 class Event;
 class KeyEvent;
 class MouseEvent;
 }  // namespace ui
 
 namespace aura {
 class Window;
 }  // namespace aura
 
 namespace ash {
 
+class StickyKeysOverlay;
 class StickyKeysHandler;
 
 // StickyKeysController is an accessibility feature for users to be able to
 // compose key and mouse event with modifier keys without simultaneous key
 // press event. Instead they can compose events separately pressing each of the
 // modifier keys involved.
 // e.g. Composing Ctrl + T
 //       User Action   : The KeyEvent widget will receives
 // ----------------------------------------------------------
 // 1. Press Ctrl key   : Ctrl Keydown.
@@ skipping 23 matching lines @@
 //
 // StickyKeysController is disabled by default.
 class ASH_EXPORT StickyKeysController : public ui::EventHandler {
  public:
   StickyKeysController();
   virtual ~StickyKeysController();
 
   // Activate sticky keys to intercept and modify incoming events.
   void Enable(bool enabled);
 
+  // Overridden from ui::EventHandler:
+  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
+  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
+  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+
+  // Returns the StickyKeyOverlay used by the controller. Ownership is not
+  // passed.
+  StickyKeysOverlay* GetOverlayForTest();
+
  private:
   // Handles keyboard event. Returns true if Sticky key consumes keyboard event.
   bool HandleKeyEvent(ui::KeyEvent* event);
 
   // Handles mouse event. Returns true if sticky key consumes mouse event.
   bool HandleMouseEvent(ui::MouseEvent* event);
 
   // Handles scroll event. Returns true if sticky key consumes scroll event.
   bool HandleScrollEvent(ui::ScrollEvent* event);
 
-  // Overridden from ui::EventHandler:
-  virtual void OnKeyEvent(ui::KeyEvent* event) OVERRIDE;
-  virtual void OnMouseEvent(ui::MouseEvent* event) OVERRIDE;
-  virtual void OnScrollEvent(ui::ScrollEvent* event) OVERRIDE;
+  // Updates the overlay UI with the current state of the sticky keys.
+  void UpdateOverlay();
 
   // Whether sticky keys is activated and modifying events.
   bool enabled_;
 
   // Sticky key handlers.
   scoped_ptr<StickyKeysHandler> shift_sticky_key_;
   scoped_ptr<StickyKeysHandler> alt_sticky_key_;
   scoped_ptr<StickyKeysHandler> ctrl_sticky_key_;
 
+  scoped_ptr<StickyKeysOverlay> overlay_;
+
   DISALLOW_COPY_AND_ASSIGN(StickyKeysController);
 };
 
 // StickyKeysHandler handles key event and controls sticky keysfor specific
 // modifier keys. If monitored keyboard events are recieved, StickyKeysHandler
 // changes internal state. If non modifier keyboard events or mouse events are
 // received, StickyKeysHandler will append modifier based on internal state.
 // For other events, StickyKeysHandler does nothing.
 //
 // The DISABLED state is default state and any incoming non modifier keyboard
@@ skipping 31 matching lines @@
                                   aura::Window* target) = 0;
 
     // Dispatches mouse event synchronously.
     virtual void DispatchMouseEvent(ui::MouseEvent* event,
                                     aura::Window* target) = 0;
 
     // Dispatches scroll event synchronously.
     virtual void DispatchScrollEvent(ui::ScrollEvent* event,
                                      aura::Window* target) = 0;
   };
-  // Represents Sticky Key state.
-  enum StickyKeyState {
-    // The sticky key is disabled. Incomming non modifier key events are not
-    // affected.
-    DISABLED,
-    // The sticky key is enabled. Incomming non modifier key down events are
-    // modified with |modifier_flag_|. After that, sticky key state become
-    // DISABLED.
-    ENABLED,
-    // The sticky key is locked. Incomming non modifier key down events are
-    // modified with |modifier_flag_|.
-    LOCKED,
-  };
 
   // This class takes an ownership of |delegate|.
   StickyKeysHandler(ui::EventFlags modifier_flag,
                     StickyKeysHandlerDelegate* delegate);
   ~StickyKeysHandler();
 
   // Handles key event. Returns true if key is consumed.
   bool HandleKeyEvent(ui::KeyEvent* event);
 
   // Handles a mouse event. Returns true if mouse event is consumed.
@@ skipping 35 matching lines @@
   void DispatchEventAndReleaseModifier(ui::Event* event);
 
   // Adds |modifier_flags_| to a native X11 event state mask.
   void AppendNativeEventMask(unsigned int* state);
 
   // Adds |modifier_flags_| into |event|.
   void AppendModifier(ui::KeyEvent* event);
   void AppendModifier(ui::MouseEvent* event);
   void AppendModifier(ui::ScrollEvent* event);
 
-  // The modifier flag to be monitored and appended.
+  // The modifier flag to be monitored and appended to events.
   const ui::EventFlags modifier_flag_;
 
   // The current sticky key status.
   StickyKeyState current_state_;
 
   // True if the received key event is sent by StickyKeyHandler.
   bool event_from_myself_;
 
   // True if we received the TARGET_MODIFIER_DOWN event while in the DISABLED
   // state but before we receive the TARGET_MODIFIER_UP event. Normal
@@ skipping 10 matching lines @@
   scoped_ptr<ui::KeyEvent> modifier_up_event_;
 
   scoped_ptr<StickyKeysHandlerDelegate> delegate_;
 
   DISALLOW_COPY_AND_ASSIGN(StickyKeysHandler);
 };
 
 }  // namespace ash
 
 #endif  // ASH_STICKY_KEYS_STICKY_KEYS_CONTROLLER_H_