athena/input/accelerator_manager_impl.cc

   1 // Copyright 2014 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 "athena/input/accelerator_manager_impl.h"
   6
   7 #include "athena/common/switches.h"
   8 #include "athena/input/public/input_manager.h"
   9 #include "base/logging.h"
  10 #include "ui/aura/window.h"
  11 #include "ui/base/accelerators/accelerator_manager.h"
  12 #include "ui/events/event.h"
  13 #include "ui/events/event_target.h"
  14 #include "ui/views/focus/focus_manager.h"
  15 #include "ui/views/focus/focus_manager_delegate.h"
  16 #include "ui/views/focus/focus_manager_factory.h"
  17 #include "ui/wm/core/accelerator_delegate.h"
  18 #include "ui/wm/core/accelerator_filter.h"
  19 #include "ui/wm/core/nested_accelerator_controller.h"
  20 #include "ui/wm/core/nested_accelerator_delegate.h"
  21 #include "ui/wm/public/dispatcher_client.h"
  22
  23 namespace athena {
  24
  25 // This wrapper interface provides a common interface that handles global
  26 // accelerators as well as local accelerators.
  27 class AcceleratorManagerImpl::AcceleratorWrapper {
  28  public:
  29   virtual ~AcceleratorWrapper() {}
  30   virtual void Register(const ui::Accelerator& accelerator,
  31                         ui::AcceleratorTarget* target) = 0;
  32   virtual bool Process(const ui::Accelerator& accelerator) = 0;
  33   virtual ui::AcceleratorTarget* GetCurrentTarget(
  34       const ui::Accelerator& accelertor) const = 0;
  35 };
  36
  37 namespace {
  38
  39 // Accelerators inside nested message loop are handled by
  40 // wm::NestedAcceleratorController while accelerators in normal case are
  41 // handled by wm::AcceleratorFilter. These delegates act bridges in these
  42 // two different environment so that AcceleratorManagerImpl can handle
  43 // accelerators in an uniform way.
  44
  45 class NestedAcceleratorDelegate : public wm::NestedAcceleratorDelegate {
  46  public:
  47   explicit NestedAcceleratorDelegate(
  48       AcceleratorManagerImpl* accelerator_manager)
  49       : accelerator_manager_(accelerator_manager) {}
  50   virtual ~NestedAcceleratorDelegate() {}
  51
  52  private:
  53   // wm::NestedAcceleratorDelegate:
  54   virtual Result ProcessAccelerator(
  55       const ui::Accelerator& accelerator) OVERRIDE {
  56     return accelerator_manager_->Process(accelerator) ? RESULT_PROCESSED
  57                                                       : RESULT_NOT_PROCESSED;
  58   }
  59
  60   AcceleratorManagerImpl* accelerator_manager_;
  61
  62   DISALLOW_COPY_AND_ASSIGN(NestedAcceleratorDelegate);
  63 };
  64
  65 class AcceleratorDelegate : public wm::AcceleratorDelegate {
  66  public:
  67   explicit AcceleratorDelegate(AcceleratorManagerImpl* accelerator_manager)
  68       : accelerator_manager_(accelerator_manager) {}
  69   virtual ~AcceleratorDelegate() {}
  70
  71  private:
  72   // wm::AcceleratorDelegate:
  73   virtual bool ProcessAccelerator(const ui::KeyEvent& event,
  74                                   const ui::Accelerator& accelerator,
  75                                   KeyType key_type) OVERRIDE {
  76     aura::Window* target = static_cast<aura::Window*>(event.target());
  77     if (!target->IsRootWindow() &&
  78         !accelerator_manager_->IsRegistered(accelerator, AF_RESERVED)) {
  79       // TODO(oshima): do the same when the active window is in fullscreen.
  80       return false;
  81     }
  82     return accelerator_manager_->Process(accelerator);
  83   }
  84
  85   AcceleratorManagerImpl* accelerator_manager_;
  86   DISALLOW_COPY_AND_ASSIGN(AcceleratorDelegate);
  87 };
  88
  89 class FocusManagerDelegate : public views::FocusManagerDelegate {
  90  public:
  91   explicit FocusManagerDelegate(AcceleratorManagerImpl* accelerator_manager)
  92       : accelerator_manager_(accelerator_manager) {}
  93   virtual ~FocusManagerDelegate() {}
  94
  95   virtual bool ProcessAccelerator(const ui::Accelerator& accelerator) OVERRIDE {
  96     return accelerator_manager_->Process(accelerator);
  97   }
  98
  99   virtual ui::AcceleratorTarget* GetCurrentTargetForAccelerator(
 100       const ui::Accelerator& accelerator) const OVERRIDE {
 101     return accelerator_manager_->IsRegistered(accelerator, AF_NONE)
 102                ? accelerator_manager_
 103                : NULL;
 104   }
 105
 106  private:
 107   AcceleratorManagerImpl* accelerator_manager_;
 108
 109   DISALLOW_COPY_AND_ASSIGN(FocusManagerDelegate);
 110 };
 111
 112 // Key strokes must be sent to web contents to give them a chance to
 113 // consume them unless they are reserved, and unhandled key events are
 114 // sent back to focus manager asynchronously. This installs the athena's
 115 // focus manager that handles athena shell's accelerators.
 116 class FocusManagerFactory : public views::FocusManagerFactory {
 117  public:
 118   explicit FocusManagerFactory(AcceleratorManagerImpl* accelerator_manager)
 119       : accelerator_manager_(accelerator_manager) {}
 120   virtual ~FocusManagerFactory() {}
 121
 122   virtual views::FocusManager* CreateFocusManager(
 123       views::Widget* widget,
 124       bool desktop_widget) OVERRIDE {
 125     return new views::FocusManager(
 126         widget,
 127         desktop_widget ? NULL : new FocusManagerDelegate(accelerator_manager_));
 128   }
 129
 130  private:
 131   AcceleratorManagerImpl* accelerator_manager_;
 132
 133   DISALLOW_COPY_AND_ASSIGN(FocusManagerFactory);
 134 };
 135
 136 class UIAcceleratorManagerWrapper
 137     : public AcceleratorManagerImpl::AcceleratorWrapper {
 138  public:
 139   UIAcceleratorManagerWrapper()
 140       : ui_accelerator_manager_(new ui::AcceleratorManager) {}
 141   virtual ~UIAcceleratorManagerWrapper() {}
 142
 143   virtual void Register(const ui::Accelerator& accelerator,
 144                         ui::AcceleratorTarget* target) OVERRIDE {
 145     return ui_accelerator_manager_->Register(
 146         accelerator, ui::AcceleratorManager::kNormalPriority, target);
 147   }
 148
 149   virtual bool Process(const ui::Accelerator& accelerator) OVERRIDE {
 150     return ui_accelerator_manager_->Process(accelerator);
 151   }
 152
 153   virtual ui::AcceleratorTarget* GetCurrentTarget(
 154       const ui::Accelerator& accelerator) const OVERRIDE {
 155     return ui_accelerator_manager_->GetCurrentTarget(accelerator);
 156   }
 157
 158  private:
 159   scoped_ptr<ui::AcceleratorManager> ui_accelerator_manager_;
 160
 161   DISALLOW_COPY_AND_ASSIGN(UIAcceleratorManagerWrapper);
 162 };
 163
 164 class FocusManagerWrapper : public AcceleratorManagerImpl::AcceleratorWrapper {
 165  public:
 166   explicit FocusManagerWrapper(views::FocusManager* focus_manager)
 167       : focus_manager_(focus_manager) {}
 168   virtual ~FocusManagerWrapper() {}
 169
 170   virtual void Register(const ui::Accelerator& accelerator,
 171                         ui::AcceleratorTarget* target) OVERRIDE {
 172     return focus_manager_->RegisterAccelerator(
 173         accelerator, ui::AcceleratorManager::kNormalPriority, target);
 174   }
 175
 176   virtual bool Process(const ui::Accelerator& accelerator) OVERRIDE {
 177     NOTREACHED();
 178     return true;
 179   }
 180
 181   virtual ui::AcceleratorTarget* GetCurrentTarget(
 182       const ui::Accelerator& accelerator) const OVERRIDE {
 183     return focus_manager_->GetCurrentTargetForAccelerator(accelerator);
 184   }
 185
 186  private:
 187   views::FocusManager* focus_manager_;
 188
 189   DISALLOW_COPY_AND_ASSIGN(FocusManagerWrapper);
 190 };
 191
 192 }  // namespace
 193
 194 class AcceleratorManagerImpl::InternalData {
 195  public:
 196   InternalData(int command_id, AcceleratorHandler* handler, int flags)
 197       : command_id_(command_id), handler_(handler), flags_(flags) {}
 198
 199   bool IsNonAutoRepeatable() const { return flags_ & AF_NON_AUTO_REPEATABLE; }
 200   bool IsDebug() const { return flags_ & AF_DEBUG; }
 201   int flags() const { return flags_; }
 202
 203   bool IsCommandEnabled() const {
 204     return handler_->IsCommandEnabled(command_id_);
 205   }
 206
 207   bool OnAcceleratorFired(const ui::Accelerator& accelerator) {
 208     return handler_->OnAcceleratorFired(command_id_, accelerator);
 209   }
 210
 211  private:
 212   int command_id_;
 213   AcceleratorHandler* handler_;
 214   int flags_;
 215
 216   // This class is copyable by design.
 217 };
 218
 219 // static
 220 AcceleratorManagerImpl*
 221 AcceleratorManagerImpl::CreateGlobalAcceleratorManager() {
 222   return new AcceleratorManagerImpl(new UIAcceleratorManagerWrapper());
 223 }
 224
 225 scoped_ptr<AcceleratorManager> AcceleratorManagerImpl::CreateForFocusManager(
 226     views::FocusManager* focus_manager) {
 227   return scoped_ptr<AcceleratorManager>(
 228              new AcceleratorManagerImpl(new FocusManagerWrapper(focus_manager)))
 229       .Pass();
 230 }
 231
 232 AcceleratorManagerImpl::~AcceleratorManagerImpl() {
 233   nested_accelerator_controller_.reset();
 234   accelerator_filter_.reset();
 235   // Reset to use the default focus manager because the athena's
 236   // FocusManager has the reference to this object.
 237   views::FocusManagerFactory::Install(NULL);
 238 }
 239
 240 void AcceleratorManagerImpl::Init() {
 241   views::FocusManagerFactory::Install(new FocusManagerFactory(this));
 242
 243   ui::EventTarget* toplevel = InputManager::Get()->GetTopmostEventTarget();
 244   nested_accelerator_controller_.reset(
 245       new wm::NestedAcceleratorController(new NestedAcceleratorDelegate(this)));
 246
 247   scoped_ptr<wm::AcceleratorDelegate> accelerator_delegate(
 248       new AcceleratorDelegate(this));
 249
 250   accelerator_filter_.reset(
 251       new wm::AcceleratorFilter(accelerator_delegate.Pass()));
 252   toplevel->AddPreTargetHandler(accelerator_filter_.get());
 253 }
 254
 255 void AcceleratorManagerImpl::OnRootWindowCreated(aura::Window* root_window) {
 256   aura::client::SetDispatcherClient(root_window,
 257                                     nested_accelerator_controller_.get());
 258 }
 259
 260 bool AcceleratorManagerImpl::Process(const ui::Accelerator& accelerator) {
 261   return accelerator_wrapper_->Process(accelerator);
 262 }
 263
 264 bool AcceleratorManagerImpl::IsRegistered(const ui::Accelerator& accelerator,
 265                                           int flags) const {
 266   std::map<ui::Accelerator, InternalData>::const_iterator iter =
 267       accelerators_.find(accelerator);
 268   if (iter == accelerators_.end())
 269     return false;
 270   DCHECK(accelerator_wrapper_->GetCurrentTarget(accelerator));
 271   return flags == AF_NONE || iter->second.flags() & flags;
 272 }
 273
 274 AcceleratorManagerImpl::AcceleratorManagerImpl(
 275     AcceleratorWrapper* accelerator_wrapper)
 276     : accelerator_wrapper_(accelerator_wrapper),
 277       debug_accelerators_enabled_(switches::IsDebugAcceleratorsEnabled()) {
 278 }
 279
 280 void AcceleratorManagerImpl::RegisterAccelerators(
 281     const AcceleratorData accelerators[],
 282     size_t num_accelerators,
 283     AcceleratorHandler* handler) {
 284   for (size_t i = 0; i < num_accelerators; ++i)
 285     RegisterAccelerator(accelerators[i], handler);
 286 }
 287
 288 void AcceleratorManagerImpl::SetDebugAcceleratorsEnabled(bool enabled) {
 289   debug_accelerators_enabled_ = enabled;
 290 }
 291
 292 bool AcceleratorManagerImpl::AcceleratorPressed(
 293     const ui::Accelerator& accelerator) {
 294   std::map<ui::Accelerator, InternalData>::iterator iter =
 295       accelerators_.find(accelerator);
 296   DCHECK(iter != accelerators_.end());
 297   if (iter == accelerators_.end())
 298     return false;
 299   InternalData& data = iter->second;
 300   if (data.IsDebug() && !debug_accelerators_enabled_)
 301     return false;
 302   if (accelerator.IsRepeat() && data.IsNonAutoRepeatable())
 303     return false;
 304   return data.IsCommandEnabled() ? data.OnAcceleratorFired(accelerator) : false;
 305 }
 306
 307 bool AcceleratorManagerImpl::CanHandleAccelerators() const {
 308   return true;
 309 }
 310
 311 void AcceleratorManagerImpl::RegisterAccelerator(
 312     const AcceleratorData& accelerator_data,
 313     AcceleratorHandler* handler) {
 314   ui::Accelerator accelerator(accelerator_data.keycode,
 315                               accelerator_data.keyevent_flags);
 316   accelerator.set_type(accelerator_data.trigger_event == TRIGGER_ON_PRESS
 317                            ? ui::ET_KEY_PRESSED
 318                            : ui::ET_KEY_RELEASED);
 319   accelerator_wrapper_->Register(accelerator, this);
 320   accelerators_.insert(
 321       std::make_pair(accelerator,
 322                      InternalData(accelerator_data.command_id,
 323                                   handler,
 324                                   accelerator_data.accelerator_flags)));
 325 }
 326
 327 // static
 328 AcceleratorManager* AcceleratorManager::Get() {
 329   return InputManager::Get()->GetAcceleratorManager();
 330 }
 331
 332 // static
 333 scoped_ptr<AcceleratorManager> AcceleratorManager::CreateForFocusManager(
 334     views::FocusManager* focus_manager) {
 335   return AcceleratorManagerImpl::CreateForFocusManager(focus_manager).Pass();
 336 }
 337
 338 }  // namespace athena