ash/accelerators/accelerator_controller.h

   1 // Copyright (c) 2012 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 #ifndef ASH_ACCELERATORS_ACCELERATOR_CONTROLLER_H_
   6 #define ASH_ACCELERATORS_ACCELERATOR_CONTROLLER_H_
   7
   8 #include <map>
   9 #include <set>
  10
  11 #include "ash/accelerators/exit_warning_handler.h"
  12 #include "ash/ash_export.h"
  13 #include "base/basictypes.h"
  14 #include "base/compiler_specific.h"
  15 #include "base/gtest_prod_util.h"
  16 #include "base/memory/scoped_ptr.h"
  17 #include "ui/base/accelerators/accelerator.h"
  18
  19 namespace ui {
  20 class AcceleratorManager;
  21 }
  22
  23 namespace ash {
  24
  25 struct AcceleratorData;
  26 class BrightnessControlDelegate;
  27 class ExitWarningHandler;
  28 class ImeControlDelegate;
  29 class KeyboardBrightnessControlDelegate;
  30 class ScreenshotDelegate;
  31 class VolumeControlDelegate;
  32
  33 // AcceleratorController provides functions for registering or unregistering
  34 // global keyboard accelerators, which are handled earlier than any windows. It
  35 // also implements several handlers as an accelerator target.
  36 class ASH_EXPORT AcceleratorController : public ui::AcceleratorTarget {
  37  public:
  38   AcceleratorController();
  39   virtual ~AcceleratorController();
  40
  41   // A list of possible ways in which an accelerator should be restricted before
  42   // processing. Any target registered with this controller should respect
  43   // restrictions by calling |GetCurrentAcceleratorRestriction| during
  44   // processing.
  45   enum AcceleratorProcessingRestriction {
  46     // Process the accelerator normally.
  47     RESTRICTION_NONE,
  48
  49     // Don't process the accelerator.
  50     RESTRICTION_PREVENT_PROCESSING,
  51
  52     // Don't process the accelerator and prevent propagation to other targets.
  53     RESTRICTION_PREVENT_PROCESSING_AND_PROPAGATION
  54   };
  55
  56   // Registers a global keyboard accelerator for the specified target. If
  57   // multiple targets are registered for an accelerator, a target registered
  58   // later has higher priority.
  59   void Register(const ui::Accelerator& accelerator,
  60                 ui::AcceleratorTarget* target);
  61
  62   // Unregisters the specified keyboard accelerator for the specified target.
  63   void Unregister(const ui::Accelerator& accelerator,
  64                   ui::AcceleratorTarget* target);
  65
  66   // Unregisters all keyboard accelerators for the specified target.
  67   void UnregisterAll(ui::AcceleratorTarget* target);
  68
  69   // Activates the target associated with the specified accelerator.
  70   // First, AcceleratorPressed handler of the most recently registered target
  71   // is called, and if that handler processes the event (i.e. returns true),
  72   // this method immediately returns. If not, we do the same thing on the next
  73   // target, and so on.
  74   // Returns true if an accelerator was activated.
  75   bool Process(const ui::Accelerator& accelerator);
  76
  77   // Returns true if the |accelerator| is registered.
  78   bool IsRegistered(const ui::Accelerator& accelerator) const;
  79
  80   // Returns true if the |accelerator| is preferred. A preferred accelerator
  81   // is handled before being passed to an window/web contents, unless
  82   // the window is in fullscreen state.
  83   bool IsPreferred(const ui::Accelerator& accelerator) const;
  84
  85   // Returns true if the |accelerator| is reserved. A reserved accelerator
  86   // is always handled and will never be passed to an window/web contents.
  87   bool IsReserved(const ui::Accelerator& accelerator) const;
  88
  89   // Performs the specified action. The |accelerator| may provide additional
  90   // data the action needs. Returns whether an action was performed
  91   // successfully.
  92   bool PerformAction(int action,
  93                      const ui::Accelerator& accelerator);
  94
  95   // Returns the restriction for the current context.
  96   AcceleratorProcessingRestriction GetCurrentAcceleratorRestriction();
  97
  98   // Overridden from ui::AcceleratorTarget:
  99   virtual bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
 100   virtual bool CanHandleAccelerators() const override;
 101
 102   void SetBrightnessControlDelegate(
 103       scoped_ptr<BrightnessControlDelegate> brightness_control_delegate);
 104   void SetImeControlDelegate(
 105       scoped_ptr<ImeControlDelegate> ime_control_delegate);
 106   void SetScreenshotDelegate(
 107       scoped_ptr<ScreenshotDelegate> screenshot_delegate);
 108   BrightnessControlDelegate* brightness_control_delegate() const {
 109     return brightness_control_delegate_.get();
 110   }
 111   ScreenshotDelegate* screenshot_delegate() {
 112     return screenshot_delegate_.get();
 113   }
 114
 115   // Provides access to the ExitWarningHandler for testing.
 116   ExitWarningHandler* GetExitWarningHandlerForTest() {
 117     return &exit_warning_handler_;
 118   }
 119
 120   const ui::Accelerator& previous_accelerator_for_test() const {
 121     return previous_accelerator_;
 122   }
 123
 124  private:
 125   FRIEND_TEST_ALL_PREFIXES(AcceleratorControllerTest, GlobalAccelerators);
 126   FRIEND_TEST_ALL_PREFIXES(AcceleratorControllerTest,
 127                            DontRepeatToggleFullscreen);
 128
 129   // Initializes the accelerators this class handles as a target.
 130   void Init();
 131
 132   // Registers the specified accelerators.
 133   void RegisterAccelerators(const AcceleratorData accelerators[],
 134                             size_t accelerators_length);
 135
 136   // Get the accelerator restriction for the given action. Supply an |action|
 137   // of -1 to get restrictions that apply for the current context.
 138   AcceleratorProcessingRestriction GetAcceleratorProcessingRestriction(
 139       int action);
 140
 141   void SetKeyboardBrightnessControlDelegate(
 142       scoped_ptr<KeyboardBrightnessControlDelegate>
 143       keyboard_brightness_control_delegate);
 144
 145   scoped_ptr<ui::AcceleratorManager> accelerator_manager_;
 146
 147   // TODO(derat): BrightnessControlDelegate is also used by the system tray;
 148   // move it outside of this class.
 149   scoped_ptr<BrightnessControlDelegate> brightness_control_delegate_;
 150   scoped_ptr<ImeControlDelegate> ime_control_delegate_;
 151   scoped_ptr<KeyboardBrightnessControlDelegate>
 152       keyboard_brightness_control_delegate_;
 153   scoped_ptr<ScreenshotDelegate> screenshot_delegate_;
 154
 155   // Remember previous accelerator as some accelerator needs to be fired
 156   // with a specific sequence.
 157   ui::Accelerator previous_accelerator_;
 158
 159   // Handles the exit accelerator which requires a double press to exit and
 160   // shows a popup with an explanation.
 161   ExitWarningHandler exit_warning_handler_;
 162
 163   // A map from accelerators to the AcceleratorAction values, which are used in
 164   // the implementation.
 165   std::map<ui::Accelerator, int> accelerators_;
 166
 167   // Actions allowed when the user is not signed in.
 168   std::set<int> actions_allowed_at_login_screen_;
 169   // Actions allowed when the screen is locked.
 170   std::set<int> actions_allowed_at_lock_screen_;
 171   // Actions allowed when a modal window is up.
 172   std::set<int> actions_allowed_at_modal_window_;
 173   // Preferred actions. See accelerator_table.h for details.
 174   std::set<int> preferred_actions_;
 175   // Reserved actions. See accelerator_table.h for details.
 176   std::set<int> reserved_actions_;
 177   // Actions which will not be repeated while holding the accelerator key.
 178   std::set<int> nonrepeatable_actions_;
 179   // Actions allowed in app mode.
 180   std::set<int> actions_allowed_in_app_mode_;
 181   // Actions disallowed if there are no windows.
 182   std::set<int> actions_needing_window_;
 183
 184   DISALLOW_COPY_AND_ASSIGN(AcceleratorController);
 185 };
 186
 187 }  // namespace ash
 188
 189 #endif  // ASH_ACCELERATORS_ACCELERATOR_CONTROLLER_H_