Split Screen mode implementation

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 "athena/input/public/accelerator_manager.h"
 #include "athena/screen/public/screen_manager.h"
 #include "athena/wm/bezel_controller.h"
 #include "athena/wm/public/window_manager_observer.h"
 #include "athena/wm/split_view_controller.h"
 #include "athena/wm/window_overview_mode.h"
+#include "athena/wm/window_stack_provider.h"
 #include "base/logging.h"
 #include "base/observer_list.h"
 #include "ui/aura/layout_manager.h"
 #include "ui/aura/window.h"
 #include "ui/wm/public/window_types.h"
 
 namespace athena {
 namespace {
 
 class WindowManagerImpl : public WindowManager,
+                          public WindowStackProvider,
                           public WindowOverviewModeDelegate,
                           public aura::WindowObserver,
                           public AcceleratorHandler {
  public:
   WindowManagerImpl();
   virtual ~WindowManagerImpl();
 
   void Layout();
 
   // WindowManager:
   virtual void ToggleOverview() OVERRIDE {
+    LOG(ERROR) << "ToggleOverview";
     if (overview_) {

[Jun Mukai, 2014/07/25 20:21:30]

Keep in mind that pkotwicz is changing the code around |overview_|, see
crbug.com/396368 for its progress (his first patch was reverted though...)

-      overview_.reset();
       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                         OnOverviewModeExit());
+      overview_.reset();
     } else {
-      overview_ = WindowOverviewMode::Create(container_.get(), this);
+      // Re-stack all windows in the order defined by ordered_windows_.
+      aura::Window::Windows::iterator it;
+      for (it = ordered_windows_.begin(); it != ordered_windows_.end(); ++it) {
+        container_->StackChildAtTop(*it);
+      }
       FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                         OnOverviewModeEnter());
+      overview_ =
+          WindowOverviewMode::Create(container_.get(), GetWindowStack(), this);
     }
   }
 
+  virtual bool IsOverviewModeActive() OVERRIDE {
+    return overview_;
+  }
+
  private:
   enum Command {
     COMMAND_TOGGLE_OVERVIEW,
   };
 
   void InstallAccelerators() {
     const AcceleratorData accelerator_data[] = {
         {TRIGGER_ON_PRESS, ui::VKEY_F6, ui::EF_NONE, COMMAND_TOGGLE_OVERVIEW,
          AF_NONE},
     };
     AcceleratorManager::Get()->RegisterAccelerators(
         accelerator_data, arraysize(accelerator_data), this);
   }
 
   // WindowManager:
   virtual void AddObserver(WindowManagerObserver* observer) OVERRIDE {
     observers_.AddObserver(observer);
   }
 
   virtual void RemoveObserver(WindowManagerObserver* observer) OVERRIDE {
     observers_.RemoveObserver(observer);
   }
 
+  // WindowStackProvider:
+  virtual void MoveWindowToFront(aura::Window* window) OVERRIDE{
+    CHECK_EQ(container_.get(), window->parent());
+    aura::Window::Windows::iterator it = std::find(
+        ordered_windows_.begin(), ordered_windows_.end(), window);
+    DCHECK(it != ordered_windows_.end());
+    ordered_windows_.erase(it);
+    ordered_windows_.push_back(window);
+    container_->StackChildAtTop(window);
+  }
+
+  virtual const aura::Window::Windows& GetWindowStack() OVERRIDE {
+    return ordered_windows_;
+  }
+
   // WindowOverviewModeDelegate:
   virtual void OnSelectWindow(aura::Window* window) OVERRIDE {
-    CHECK_EQ(container_.get(), window->parent());
-    container_->StackChildAtTop(window);

[oshima, 2014/07/28 17:58:43]

This should have called wm::ActivateWindow instead.

[mfomitchev, 2014/08/05 19:56:57]

Done.

+    MoveWindowToFront(window);
     overview_.reset();
     FOR_EACH_OBSERVER(WindowManagerObserver, observers_,
                       OnOverviewModeExit());
   }
 
   // aura::WindowObserver
   virtual void OnWindowDestroying(aura::Window* window) OVERRIDE {
     if (window == container_)
       container_.reset();
   }
 
+  virtual void OnWillRemoveWindow(aura::Window* window) OVERRIDE {
+    aura::Window::Windows::iterator it = std::find(
+        ordered_windows_.begin(), ordered_windows_.end(), window);
+    ordered_windows_.erase(it);
+  }
+
+  virtual void OnWindowAdded(aura::Window* new_window) OVERRIDE {
+    ordered_windows_.push_back(new_window);
+  }
+
   // AcceleratorHandler:
   virtual bool IsCommandEnabled(int command_id) const OVERRIDE { return true; }
   virtual bool OnAcceleratorFired(int command_id,
                                   const ui::Accelerator& accelerator) OVERRIDE {
     switch (command_id) {
       case COMMAND_TOGGLE_OVERVIEW:
         ToggleOverview();
         break;
     }
     return true;
   }
 
   scoped_ptr<aura::Window> container_;
+  aura::Window::Windows ordered_windows_;

[oshima, 2014/07/25 21:41:10]

what's the reason to keep its own list?

[mfomitchev, 2014/07/25 23:27:38]

The order within the container changes when you interact with the UI. When a
window becomes the target of a gesture, it is stacked on top of all the other
windows.

[oshima, 2014/07/28 17:58:42]

StackChildAtTop does change the order within the container. My question was why
you need to keep separate list.

I think we eventually need MRU like ash has, but it should live in resource
management rather than here.

[mfomitchev, 2014/07/28 18:15:00]

I can't rely on the container's window order for the purposes of window-cycling
(alt-tab like behavior). The container's window order changes as the user
interacts with the UI - e.g. when a window becomes the target of a gesture, it
is stacked on top of all the other windows. So what happens is that the window
which is shown always ends up on top of all the other windows. But in order to
implement the cycling, we need the window order to be static - otherwise it's
hard to figure out what the next/prev window is.

[oshima, 2014/07/28 18:35:20]

I know that container's window order isn't enough to implement alt-tab,
and ash has ash/wm/mru_window_tracker for it. What I'm saying is that\
if you're going to implement alt-tab (are you going to add it in this CL?),
then it should be handled by separate entity like ash's mru tracker and use
activation observer, not here.

[mfomitchev, 2014/07/28 18:57:42]

SplitViewController implements window switching - you can swipe left/right to
switch to the next/prev window. You can continue swiping to cycle through all
windows. It's similar to alt-tab in that it needs to know the window order. 

I can factor the functionality out of window manager and into a separate class.
athena::MruWindowTracker?

Note that we can't update MRU order every time we switch to the previous window
by swiping: if we do that, you'll keep cycling between 2 windows: the most
recent and second most recent. Each time you swipe, the second most recent
becomes the most recent, and the most recent becomes trhe second most recent. So
currently the order is only updated when you switch to the overview mode. That
is probably not enough - we'll likely also want to update the order once you've
spent some time in the new window after swiping to it.. or something along those
lines.

[mfomitchev, 2014/08/05 19:56:57]

I have implemented a very basic, stripped down MruWindowTracker. Currently it's
not even tracking the window activations - only creations and deletions. It's
quite possible that it will need to track activations as well in the future, but
it's not clear until we have a defined UX.

   scoped_ptr<WindowOverviewMode> overview_;
   scoped_ptr<BezelController> bezel_controller_;
   scoped_ptr<SplitViewController> split_view_controller_;
   ObserverList<WindowManagerObserver> observers_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowManagerImpl);
 };
 
 class WindowManagerImpl* instance = NULL;
 
@@ skipping 25 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(AthenaContainerLayoutManager);
 };
 
 WindowManagerImpl::WindowManagerImpl() {
   ScreenManager::ContainerParams params("DefaultContainer");
   params.can_activate_children = true;
   container_.reset(ScreenManager::Get()->CreateDefaultContainer(params));
   container_->SetLayoutManager(new AthenaContainerLayoutManager);
   container_->AddObserver(this);
   bezel_controller_.reset(new BezelController(container_.get()));
-  split_view_controller_.reset(new SplitViewController());
+  split_view_controller_.reset(new SplitViewController(
+      container_.get(), this, this));
   bezel_controller_->set_left_right_delegate(split_view_controller_.get());
   container_->AddPreTargetHandler(bezel_controller_.get());
   instance = this;
   InstallAccelerators();
 }
 
 WindowManagerImpl::~WindowManagerImpl() {
   if (container_) {
     container_->RemoveObserver(this);
     container_->RemovePreTargetHandler(bezel_controller_.get());
@@ skipping 33 matching lines @@
   DCHECK(!instance);
 }
 
 // static
 WindowManager* WindowManager::GetInstance() {
   DCHECK(instance);
   return instance;
 }
 
 }  // namespace athena