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/accelerator_manager.h"
 #include "ui/base/models/accelerator.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 {
+  kActivateBrowserByIndex,
+  kActivateLastBrowser,
+  kCloseFocusedNonChromeWindow,
+  kCycleBackward,
+  kCycleFowrard,
+  kLaunchTerminal,
+  kResizeLeft,
+  kResizeRight,
+  kTakeRegionScreenshot,
+  kTakeRootScreenshot,
+  kToggleMaximized,

[Daniel Erat, 2011/11/28 16:39:54]

many of these are related to UI that i don't think is going to be implemented in
aura.  i think that it'd be better to hold off on adding them here until they're
needed.  i would say that we should stick with just kCycleBackward and
kCycleForward (which is misspelled as "Fowrard" here) for now.

[mazda, 2011/11/29 15:19:35]

OK. I hold off most of them for now.
We also need TakeRootScreenshot? There is already an issue
(http://crbug.com/105198).

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

yeah, i'm okay with leaving screenshot-taking in since we'll need it.  maybe
just rename it to TAKE_SCREENSHOT for now?

+#if !defined(NDEBUG)
+  kRotateScreen,
+  kToggleClientWindowDebugging,
+  kToggleDamageDebugging,
+  kToggleFullScreen,
+  kToggleProfiler,

[Daniel Erat, 2011/11/28 16:39:54]

kToggleClientWindowDebugging, kToggleDamageDebugging, and kToggleProfiler should
be removed -- they don't make sense without the X window manager

[mazda, 2011/11/29 15:19:35]

Done.

+#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_1, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_2, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_3, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_4, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_5, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_6, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_7, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_8, false, false, true, kActivateBrowserByIndex },
+  { ui::VKEY_9, false, false, true, kActivateLastBrowser },
+  { ui::VKEY_W, true, true, false, kCloseFocusedNonChromeWindow },
+  { ui::VKEY_TAB, true, false, true, kCycleBackward },
+  { ui::VKEY_TAB, false, false, true, kCycleFowrard },
+  { ui::VKEY_T, false, true, true, kLaunchTerminal },
+  { ui::VKEY_OEM_COMMA, false, false, true, kResizeLeft },
+  { ui::VKEY_OEM_PERIOD, false, false, true, kResizeRight },
+  { ui::VKEY_F5, true, true, false, kTakeRegionScreenshot },
+  { ui::VKEY_PRINT, true, false, false, kTakeRegionScreenshot },
+  { ui::VKEY_F5, false, true, false, kTakeRootScreenshot },
+  { ui::VKEY_PRINT, false, false, false, kTakeRootScreenshot },
+  { ui::VKEY_F5, false, false, false, kToggleMaximized },
+#if !defined(NDEBUG)
+  { ui::VKEY_HOME, false, true, false, kRotateScreen },
+  { ui::VKEY_W, true, true, true, kToggleClientWindowDebugging },
+  { ui::VKEY_D, true, true, true, kToggleDamageDebugging },
+  { ui::VKEY_F11, false, false, false, kToggleFullScreen },
+  { ui::VKEY_P, true, true, true, kToggleProfiler },
+#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 ActivateBrowserByIndex(int index) {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool ActivateLastBrowser() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool CloseFocusedNonChromeWindow() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool CycleBackward() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool CycleFowrard() {

[Ben Goodger (Google), 2011/11/28 16:40:15]

Forward

[mazda, 2011/11/29 15:19:35]

Done.

+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool LaunchTerminal() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool ResizeLeft() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool ResizeRight() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool TakeRegionScreenshot() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool TakeRootScreenshot() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool ToggleMaximized() {
+  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 ToggleClientWindowDebugging() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool ToggleDamageDebugging() {
+  NOTIMPLEMENTED();
+  return false;
+}
+
+bool ToggleFullScreen() {
+  aura::Desktop::GetInstance()->ToggleFullScreen();
+  return true;
+}
+
+bool ToggleProfiler() {
+  NOTIMPLEMENTED();
+  return false;
 }
 #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 kActivateBrowserByIndex:
+      return ActivateBrowserByIndex(accelerator.key_code() - ui::VKEY_1);
+    case kActivateLastBrowser:
+      return ActivateLastBrowser();
+    case kCloseFocusedNonChromeWindow:
+      return CloseFocusedNonChromeWindow();
+    case kCycleBackward:
+      return CycleBackward();
+    case kCycleFowrard:
+      return CycleFowrard();
+    case kLaunchTerminal:
+      return LaunchTerminal();
+    case kResizeLeft:
+      return ResizeLeft();
+    case kResizeRight:
+      return ResizeRight();
+    case kTakeRegionScreenshot:
+      return TakeRegionScreenshot();
+    case kTakeRootScreenshot:
+      return TakeRootScreenshot();
+    case kToggleMaximized:
+      return ToggleMaximized();
 #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 kRotateScreen:
+      return RotateScreen();
+    case kToggleClientWindowDebugging:
+      return ToggleClientWindowDebugging();
+    case kToggleDamageDebugging:
+      return ToggleDamageDebugging();
+    case kToggleFullScreen:
+      return ToggleFullScreen();
+    case kToggleProfiler:
+      return ToggleProfiler();
+#endif
+    default:
+      NOTREACHED();
   }
-#endif
   return false;
 }
 
 }  // namespace aura_shell