InputManager/AcceleratorManager for athena

athena/home/home_card_impl.cc

 // Copyright 2014 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 "athena/home/public/home_card.h"
 
 #include "athena/home/home_card_delegate_view.h"
+#include "athena/input/public/accelerator_manager.h"
+#include "athena/input/public/input_manager.h"
 #include "athena/screen/public/screen_manager.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/visibility_controller.h"
 #include "ui/wm/core/window_animations.h"
 
 namespace athena {
 namespace {
 
@@ skipping 37 matching lines @@
                       kHomeCardHorizontalMargin,
                       0);
     SetChildBoundsDirect(home_card, card_bounds);
   }
 
   aura::Window* container_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardLayoutManager);
 };
 
-class HomeCardImpl : public HomeCard {
+class HomeCardImpl : public HomeCard, public AcceleratorHandler {
  public:
   HomeCardImpl();
   virtual ~HomeCardImpl();
 
   void Init();
 
  private:
+  enum Command {
+    COMMAND_SHOW_HOME_CARD,
+  };
+  void InstallAccelerators();
+
+  // AcceleratorHandler:
+  virtual bool IsCommandEnabled(int command_id) const OVERRIDE { return true; }
+  virtual bool OnAcceleratorFired(int command_id,
+                                  const ui::Accelerator& accelerator) OVERRIDE {
+    DCHECK_EQ(COMMAND_SHOW_HOME_CARD, command_id);
+    home_card_widget_->Show();
+    return true;
+  }
+
   views::Widget* home_card_widget_;
 
   DISALLOW_COPY_AND_ASSIGN(HomeCardImpl);
 };
 
 HomeCardImpl::HomeCardImpl() : home_card_widget_(NULL) {
   DCHECK(!instance);
   instance = this;
 }
 
 HomeCardImpl::~HomeCardImpl() {
   DCHECK(instance);
   home_card_widget_->CloseNow();
   instance = NULL;
 }
 
 void HomeCardImpl::Init() {
+  InstallAccelerators();
+
   aura::Window* container =
       ScreenManager::Get()->CreateContainer("HomeCardContainer");
   container->SetLayoutManager(new HomeCardLayoutManager(container));
   wm::SetChildWindowVisibilityChangesAnimated(container);
 
   views::Widget::InitParams params(
       views::Widget::InitParams::TYPE_WINDOW_FRAMELESS);
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.delegate = new HomeCardDelegateView();
   params.parent = container;
 
   home_card_widget_ = new views::Widget;
   home_card_widget_->Init(params);
   home_card_widget_->GetNativeView()->SetName("HomeCardWidget");
 
   aura::Window* home_card_window = home_card_widget_->GetNativeView();
   wm::SetWindowVisibilityAnimationType(
       home_card_window, wm::WINDOW_VISIBILITY_ANIMATION_TYPE_FADE);
   wm::SetWindowVisibilityAnimationTransition(home_card_window,
                                              wm::ANIMATE_BOTH);
 
   home_card_widget_->Show();
 }
 
+void HomeCardImpl::InstallAccelerators() {
+  const AcceleratorData accelerator_data[] = {
+    {TRIGGER_ON_PRESS, ui::VKEY_L, ui::EF_CONTROL_DOWN, COMMAND_SHOW_HOME_CARD,
+     AF_NONE},

[Jun Mukai, 2014/06/04 04:02:34]

I am not sure if splitting the table into each of the handlers would be a better
design than having a single table of all accelerators.

At least to me for now, having a giant table would be slightly beneficial
because the developers can easily check if there is an accelerator for a
specific key combination; and easier to create the keyboard shortcut overlays /
helpers.

[oshima, 2014/06/04 04:24:26]

That's actually not true. ChromeOS+ash already has two tables, one in ash and
another in
browser. We're relying on a runtime check and a unit test to make sure that
there is no overlaps. If you never hit these failures, then you were just lucky.
(It did hit me in the past)

And having global table breaks modularity, which I want to avoid in athena.

+  };
+  InputManager::Get()->GetAcceleratorManager()->RegisterAccelerators(
+      accelerator_data, arraysize(accelerator_data), this);
+}
+
 }  // namespace
 
 // static
 HomeCard* HomeCard::Create() {
   (new HomeCardImpl())->Init();
   DCHECK(instance);
   return instance;
 }
 
 // static
 void HomeCard::Shutdown() {
   DCHECK(instance);
   delete instance;
   instance = NULL;
 }
 
 }  // namespace athena