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,
+#if !defined(NDEBUG)
+  ROTATE_SCREEN,
+  TOGGLE_FULL_SCREEN,

[Daniel Erat, 2011/11/29 16:46:00]

i don't understand why we need the fullscreen action -- it's already defined in
chrome/browser/ui/views/accelerator_table.cc

[mazda, 2011/11/30 14:56:10]

This action is a bit different from the fullscreen action defined in
accelerator_table.cc.
This action maximizes aura::Desktop while the fullscreen action defined in
accelerator_table.cc maximizes a chrome tab.
But I agree that they are confusing and they conflict on Windows, so I think
it's better to change the name and key binding.

What do you think of changing them as follows?

enum name: TOGGLE_DESKTOP_FULL_SCREEN
key binding: Ctrl F11

I changed them that way in the updated CL.

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

Thanks, makes more sense now.

+#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 },
+#if !defined(NDEBUG)
+  { ui::VKEY_HOME, false, true, false, ROTATE_SCREEN },
+  { ui::VKEY_F11, false, false, false, TOGGLE_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() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool CycleForwrard() {
+  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 ToggleFullScreen() {
+  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();
 #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_FULL_SCREEN:
+      return ToggleFullScreen();
+#endif
+    default:
+      NOTREACHED();
   }
-#endif
   return false;
 }
 
 }  // namespace aura_shell