Register global accelerators and add placeholders for handling them.

ui/aura_shell/shell_accelerator_controller.cc

 // Copyright (c) 2011 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 "ui/aura_shell/shell_accelerator_controller.h"
 
+#include "base/logging.h"
 #include "ui/aura/desktop.h"
 #include "ui/aura/event.h"
 #include "ui/aura_shell/shell.h"
 #include "ui/base/accelerators/accelerator.h"
 #include "ui/base/accelerators/accelerator_manager.h"
 #include "ui/gfx/compositor/layer_animation_sequence.h"
 #include "ui/gfx/compositor/layer_animator.h"
 #include "ui/gfx/compositor/screen_rotation.h"
 
 namespace {
 
+enum AcceleratorAction {
+  CYCLE_BACKWARD,
+  CYCLE_FORWRARD,

[Daniel Erat, 2011/11/30 16:25:31]

typo: FORWRARD -> FORWARD

[mazda, 2011/11/30 18:36:41]

Oh... Thanks again.

+  TAKE_SCREENSHOT,
+#if !defined(NDEBUG)
+  ROTATE_SCREEN,
+  TOGGLE_DESKTOP_FULL_SCREEN,
+#endif
+};
+
 // Acceleraters handled by ShellAcceleratorController.
 struct AcceleratorData {
   ui::KeyboardCode keycode;
   bool shift;
   bool ctrl;
   bool alt;
+  AcceleratorAction action;
 } kAcceleratorData[] = {
-  { ui::VKEY_F11, false, false, false },
-  { ui::VKEY_HOME, false, true, false },
+  { ui::VKEY_TAB, true, false, true, CYCLE_BACKWARD },
+  { ui::VKEY_TAB, false, false, true, CYCLE_FORWRARD },
+  { ui::VKEY_F5, false, true, false, TAKE_SCREENSHOT },
+  { ui::VKEY_PRINT, false, false, false, TAKE_SCREENSHOT },
+#if !defined(NDEBUG)
+  { ui::VKEY_HOME, false, true, false, ROTATE_SCREEN },
+  { ui::VKEY_F11, false, true, false, TOGGLE_DESKTOP_FULL_SCREEN },
+#endif
 };
 
-// Registers the accelerators with ShellAcceleratorController.
-void RegisterAccelerators(aura_shell::ShellAcceleratorController* controller) {
-  for (size_t i = 0; i < arraysize(kAcceleratorData); ++i) {
-    controller->Register(ui::Accelerator(kAcceleratorData[i].keycode,
-                                         kAcceleratorData[i].shift,
-                                         kAcceleratorData[i].ctrl,
-                                         kAcceleratorData[i].alt),
-                         controller);
-  }
+bool CycleBackward() {

[Daniel Erat, 2011/11/30 16:25:31]

do we really need return values for all of these, or are you just doing it so
you can return directly from the case statements in AcceleratorPressed()? 
(presumably the return value controls whether we stop event propagation or not,
but at the time when we're actually trying to perform these actions, i think
that we always want to stop propagation, right?)

[mazda, 2011/11/30 18:36:41]

Right. It's mostly for convenience of using them in the case statements as you
mentioned, and the return value controls event propagation.
I also thought it might be useful to enable each function to choose not handling
the accelerator under certain condition. But I cannot think of a concrete case
so far, so I'm not stick with the idea of returning bool value.

[Daniel Erat, 2011/11/30 20:47:36]

I'd be more okay with the return values if these methods had names like
HandleCycleBackward() and HandleTakeScreenshot(), I think.  Without any comments
saying otherwise, when a function has a bool return value, I assume that it's
going to return true on success and false otherwise.  If taking a screenshot
fails for some reason, we'd still want propagation to stop, though.

(Also, I'll point out that even though you're saving a break or return for each
of the commands in AcceleratorPressed(), those lines are getting added back as a
"return true" at the end of each of these methods.) :-P

+  // TODO(mazda): http://crbug.com/105204
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool CycleForwrard() {
+  // TODO(mazda): http://crbug.com/105204
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool TakeScreenshot() {
+  // TODO(mazda): http://crbug.com/105198
+  NOTIMPLEMENTED();
+  return false;
 }
 
 #if !defined(NDEBUG)
 // Rotates the screen.
-void RotateScreen() {
+bool RotateScreen() {
   static int i = 0;
   int delta = 0;
   switch (i) {
     case 0: delta = 90; break;
     case 1: delta = 90; break;
     case 2: delta = 90; break;
     case 3: delta = 90; break;
     case 4: delta = -90; break;
     case 5: delta = -90; break;
     case 6: delta = -90; break;
     case 7: delta = -90; break;
     case 8: delta = -90; break;
     case 9: delta = 180; break;
     case 10: delta = 180; break;
     case 11: delta = 90; break;
     case 12: delta = 180; break;
     case 13: delta = 180; break;
   }
   i = (i + 1) % 14;
   aura::Desktop::GetInstance()->layer()->GetAnimator()->set_preemption_strategy(
       ui::LayerAnimator::REPLACE_QUEUED_ANIMATIONS);
   scoped_ptr<ui::LayerAnimationSequence> screen_rotation(
       new ui::LayerAnimationSequence(new ui::ScreenRotation(delta)));
   screen_rotation->AddObserver(aura::Desktop::GetInstance());
   aura::Desktop::GetInstance()->layer()->GetAnimator()->ScheduleAnimation(
       screen_rotation.release());
+  return true;
+}
+
+bool ToggleDesktopFullScreen() {
+  aura::Desktop::GetInstance()->ToggleFullScreen();
+  return true;
 }
 #endif
 
 }  // namespace
 
 namespace aura_shell {
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellAcceleratorController, public:
 
 ShellAcceleratorController::ShellAcceleratorController()
     : accelerator_manager_(new ui::AcceleratorManager) {
-  RegisterAccelerators(this);
+  Init();
 }
 
 ShellAcceleratorController::~ShellAcceleratorController() {
 }
 
+void ShellAcceleratorController::Init() {
+  for (size_t i = 0; i < arraysize(kAcceleratorData); ++i) {
+    ui::Accelerator accelerator(kAcceleratorData[i].keycode,
+                                kAcceleratorData[i].shift,
+                                kAcceleratorData[i].ctrl,
+                                kAcceleratorData[i].alt);
+    Register(accelerator, this);
+    accelerators_.insert(std::make_pair(accelerator,
+                                        kAcceleratorData[i].action));
+  }
+}
+
 void ShellAcceleratorController::Register(
     const ui::Accelerator& accelerator,
     ui::AcceleratorTarget* target) {
   accelerator_manager_->Register(accelerator, target);
 }
 
 void ShellAcceleratorController::Unregister(
     const ui::Accelerator& accelerator,
     ui::AcceleratorTarget* target) {
   accelerator_manager_->Unregister(accelerator, target);
 }
 
 void ShellAcceleratorController::UnregisterAll(
     ui::AcceleratorTarget* target) {
   accelerator_manager_->UnregisterAll(target);
 }
 
 bool ShellAcceleratorController::Process(const ui::Accelerator& accelerator) {
   return accelerator_manager_->Process(accelerator);
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // ShellAcceleratorController, ui::AcceleratorTarget implementation:
 
 bool ShellAcceleratorController::AcceleratorPressed(
     const ui::Accelerator& accelerator) {
+  std::map<ui::Accelerator, int>::const_iterator i =
+      accelerators_.find(accelerator);
+  DCHECK(i != accelerators_.end());
+  switch (static_cast<AcceleratorAction>(i->second)) {
+    case CYCLE_BACKWARD:
+      return CycleBackward();
+    case CYCLE_FORWRARD:
+      return CycleForwrard();
+    case TAKE_SCREENSHOT:
+      return TakeScreenshot();
 #if !defined(NDEBUG)
-  if (accelerator.key_code() == ui::VKEY_F11) {
-    aura::Desktop::GetInstance()->ToggleFullScreen();
-    return true;
-  } else if (accelerator.key_code() == ui::VKEY_HOME &&
-             accelerator.IsCtrlDown()) {
-    RotateScreen();
-    return true;
+    case ROTATE_SCREEN:
+      return RotateScreen();
+    case TOGGLE_DESKTOP_FULL_SCREEN:
+      return ToggleDesktopFullScreen();
+#endif
+    default:
+      NOTREACHED();
   }
-#endif
   return false;
 }
 
 }  // namespace aura_shell