Add shoftcut (ctrl-f6) to toggle split view

athena/wm/window_manager_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/wm/public/window_manager.h"
 
 #include <algorithm>
 
 #include "athena/common/container_priorities.h"
 #include "athena/input/public/accelerator_manager.h"
@@ skipping 29 matching lines @@
   void Layout();
 
   // WindowManager:
   virtual void ToggleOverview() OVERRIDE;
 
   virtual bool IsOverviewModeActive() OVERRIDE;
 
  private:
   enum Command {
     CMD_TOGGLE_OVERVIEW,
+    CMD_TOGGLE_SPLIT_VIEW,
   };
 
   // Sets whether overview mode is active.
   void SetInOverview(bool active);
 
   void InstallAccelerators();
 
   // WindowManager:
   virtual void AddObserver(WindowManagerObserver* observer) OVERRIDE;
   virtual void RemoveObserver(WindowManagerObserver* observer) OVERRIDE;
@@ skipping 96 matching lines @@
     if ((*iter)->type() == ui::wm::WINDOW_TYPE_NORMAL)
       (*iter)->SetBounds(bounds);
   }
 }
 
 void WindowManagerImpl::ToggleOverview() {
   SetInOverview(overview_.get() == NULL);
 }
 
 bool WindowManagerImpl::IsOverviewModeActive() {
-  return overview_;
+  return !!overview_;
 }
 
 void WindowManagerImpl::SetInOverview(bool active) {
   bool in_overview = !!overview_;
   if (active == in_overview)
     return;
 
   if (active) {
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeEnter());
     // Re-stack all windows in the order defined by mru_window_tracker_.
     aura::Window::Windows window_list = mru_window_tracker_->GetWindowList();
     aura::Window::Windows::iterator it;
     for (it = window_list.begin(); it != window_list.end(); ++it)
       container_->StackChildAtTop(*it);
-    overview_ = WindowOverviewMode::Create(container_.get(),
-                                           mru_window_tracker_.get(),
-                                           this);
+    overview_ = WindowOverviewMode::Create(
+        container_.get(), mru_window_tracker_.get(), this);
   } else {
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeExit());
   }
 }
 
 void WindowManagerImpl::InstallAccelerators() {
   const AcceleratorData accelerator_data[] = {
       {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, CMD_TOGGLE_OVERVIEW,
        AF_NONE},
+      {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_CONTROL_DOWN,
+       CMD_TOGGLE_SPLIT_VIEW, AF_NONE},
   };
   AcceleratorManager::Get()->RegisterAccelerators(
       accelerator_data, arraysize(accelerator_data), this);
 }
 
 void WindowManagerImpl::AddObserver(WindowManagerObserver* observer) {
   observers_.AddObserver(observer);
 }
 
 void WindowManagerImpl::RemoveObserver(WindowManagerObserver* observer) {
   observers_.RemoveObserver(observer);
 }
 
 void WindowManagerImpl::OnSelectWindow(aura::Window* window) {
   mru_window_tracker_->MoveToFront(window);
   wm::ActivateWindow(window);
   SetInOverview(false);
 }
 
 void WindowManagerImpl::OnWindowAdded(aura::Window* new_window) {
+  // TODO(oshima): Creating a new window should simply updates the overview
+  // mode.
   if (new_window->type() == ui::wm::WINDOW_TYPE_NORMAL)
     SetInOverview(false);
 }
 
 void WindowManagerImpl::OnWindowDestroying(aura::Window* window) {
   if (window == container_)
     container_.reset();
 }
 
 bool WindowManagerImpl::IsCommandEnabled(int command_id) const {
   return true;
 }
 
 bool WindowManagerImpl::OnAcceleratorFired(int command_id,
                                            const ui::Accelerator& accelerator) {
   switch (command_id) {
     case CMD_TOGGLE_OVERVIEW:
       ToggleOverview();
       break;
+    case CMD_TOGGLE_SPLIT_VIEW:
+      split_view_controller_->ToggleSplitView();
+      break;
   }
   return true;
 }
 
 aura::Window* WindowManagerImpl::GetWindowBehind(aura::Window* window) {
   const aura::Window::Windows& windows = container_->children();
   aura::Window::Windows::const_iterator iter =
       std::find(windows.begin(), windows.end(), window);
   CHECK(iter != windows.end());
   return (iter == windows.begin()) ? NULL : *(iter - 1);
@@ skipping 64 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena