Split Screen mode implementation

athena/wm/window_overview_mode.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/window_overview_mode.h"
 
 #include <algorithm>
 #include <functional>
 #include <vector>
 
@@ skipping 74 matching lines @@
   }
 
   aura::Window* target_;
   DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
 };
 
 class WindowOverviewModeImpl : public WindowOverviewMode,
                                public ui::EventHandler {
  public:
   WindowOverviewModeImpl(aura::Window* container,
+                         aura::Window::Windows windows,
                          WindowOverviewModeDelegate* delegate)
       : container_(container),
+        windows_(windows),
         delegate_(delegate),
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))) {
     container_->set_target_handler(this);
 
     // Prepare the desired transforms for all the windows, and set the initial
     // state on the windows.
     ComputeTerminalStatesForAllWindows();
     SetInitialWindowStates();
   }
 
   virtual ~WindowOverviewModeImpl() {
     container_->set_target_handler(container_->delegate());
 
-    aura::Window::Windows windows = container_->children();
-    if (windows.empty())
+    if (windows_.empty())
       return;
-    std::for_each(windows.begin(), windows.end(), &RestoreWindowState);
+    std::for_each(windows_.begin(), windows_.end(), &RestoreWindowState);
   }
 
  private:
   // Computes the transforms for all windows in both the topmost and bottom-most
   // positions. The transforms are set in the |kWindowOverviewState| property of
   // the windows.
   void ComputeTerminalStatesForAllWindows() {
-    aura::Window::Windows windows = container_->children();
-    size_t window_count = windows.size();
+    size_t window_count = windows_.size();
     size_t index = 0;
     const gfx::Size container_size = container_->bounds().size();
 
     const int kGapBetweenWindowsBottom = 10;
     const int kGapBetweenWindowsTop = 5;
     const float kMinScale = 0.6f;
     const float kMaxScale = 0.95f;
 
-    for (aura::Window::Windows::reverse_iterator iter = windows.rbegin();
-         iter != windows.rend();
+    for (aura::Window::Windows::const_reverse_iterator iter = windows_.rbegin();
+         iter != windows_.rend();
          ++iter, ++index) {
       aura::Window* window = (*iter);
 
       gfx::Transform top_transform;
       int top = (window_count - index - 1) * kGapBetweenWindowsTop;
       float x_translate = container_size.width() * (1 - kMinScale) / 2.;
       top_transform.Translate(x_translate, top);
       top_transform.Scale(kMinScale, kMinScale);
 
       gfx::Transform bottom_transform;
       int bottom = GetScrollableHeight() - (index * kGapBetweenWindowsBottom);
       x_translate = container_size.width() * (1 - kMaxScale) / 2.;
       bottom_transform.Translate(x_translate, bottom - window->bounds().y());
       bottom_transform.Scale(kMaxScale, kMaxScale);
 
       WindowOverviewState* state = new WindowOverviewState;
       state->top = top_transform;
       state->bottom = bottom_transform;
       state->progress = 0.f;
       state->shadow = CreateShadowForWindow(window);
       window->SetProperty(kWindowOverviewState, state);
     }
   }
 
   // Sets the initial position for the windows for the overview mode.
   void SetInitialWindowStates() {
-    aura::Window::Windows windows = container_->children();
-    size_t window_count = windows.size();
+    size_t window_count = windows_.size();
     // The initial overview state of the topmost three windows.
     const float kInitialProgress[] = { 0.5f, 0.05f, 0.01f };
     for (size_t i = 0; i < window_count; ++i) {
       float progress = 0.f;
-      aura::Window* window = windows[window_count - 1 - i];
+      aura::Window* window = windows_[window_count - 1 - i];
       if (i < arraysize(kInitialProgress))
         progress = kInitialProgress[i];
 
       scoped_refptr<ui::LayerAnimator> animator =
           window->layer()->GetAnimator();
 
       // Unset any in-progress animation.
       {
         ui::ScopedLayerAnimationSettings settings(animator);
         settings.SetPreemptionStrategy(
             ui::LayerAnimator::IMMEDIATELY_SET_NEW_TARGET);
         window->Show();
         window->SetTransform(gfx::Transform());
       }
       // Setup the animation.
       {
         ui::ScopedLayerAnimationSettings settings(animator);
         settings.SetPreemptionStrategy(
             ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
         settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
         SetWindowProgress(window, progress);
       }
     }
   }
 
   scoped_ptr<wm::Shadow> CreateShadowForWindow(aura::Window* window) {
     scoped_ptr<wm::Shadow> shadow(new wm::Shadow());
     shadow->Init(wm::Shadow::STYLE_ACTIVE);
-    shadow->SetContentBounds(gfx::Rect(window->bounds().size()));
+    shadow->SetContentBounds(gfx::Rect(container_->bounds().size()));

[Jun Mukai, 2014/08/05 21:13:39]

Why this needs to be changed to container_?  Is there some case where window !=
container_?

also, if they should be same, it's a good manner to add DCHECK_EQ(window,
container_);

[mfomitchev, 2014/08/06 18:11:32]

conainer_ is window's parent. The reason this was changed is that the window can
be transformed by the split view mode, so if we use window's bounds here, the
shadow will be set on half the window's real bounds.

[Jun Mukai, 2014/08/06 19:56:10]

I got confused. Here's my understanding:
- container_ is the default container, whose size is same as the whole desktop
- the window in overview mode shrunk a bit, to provide the stacking card UI
- this is the shadow for the stacking cards

So making content bounds for container_ doesn't make sense. It just doesn't
appear. Am I wrong?

[mfomitchev, 2014/08/06 20:09:59]

It's the split view transform, not the overview mode transform that is the cause
for this change. I believe this method is called before any overview mode
transforms are applied (and when they are applied - they are applied to both the
window and the shadow), so we don't worry about overview transforms. This method
is implicitly assuming that all windows are full screen before we enter overview
mode, which is incorrect now that windows can be transformed by split view mode.
The fix is to use the container (which is always full screen) for bounds
calculations instead.

[Jun Mukai, 2014/08/06 20:49:01]

Okay

     shadow->layer()->SetVisible(true);
     window->layer()->Add(shadow->layer());
     return shadow.Pass();
   }
 
   aura::Window* SelectWindowAt(ui::LocatedEvent* event) {
     CHECK_EQ(container_, event->target());
     // Find the old targeter to find the target of the event.
     ui::EventTarget* window = container_;
     ui::EventTargeter* targeter = scoped_targeter_->old_targeter();
     while (!targeter && window->GetParentTarget()) {
       window = window->GetParentTarget();
       targeter = window->GetEventTargeter();
     }
     if (!targeter)
       return NULL;
     aura::Window* target = static_cast<aura::Window*>(
         targeter->FindTargetForLocatedEvent(container_, event));
     while (target && target->parent() != container_)
       target = target->parent();
     return target;
   }
 
   // Scroll the window list by |delta_y| amount. |delta_y| is negative when
   // scrolling up; and positive when scrolling down.
   void DoScroll(float delta_y) {
     const float kEpsilon = 1e-3f;
-    aura::Window::Windows windows = container_->children();
     float delta_y_p = std::abs(delta_y) / GetScrollableHeight();
     if (delta_y < 0) {
       // Scroll up. Start with the top-most (i.e. behind-most in terms of
       // z-index) window, and try to scroll them up.
-      for (aura::Window::Windows::iterator iter = windows.begin();
-           delta_y_p > kEpsilon && iter != windows.end();
+      for (aura::Window::Windows::const_iterator iter = windows_.begin();
+           delta_y_p > kEpsilon && iter != windows_.end();
            ++iter) {
         aura::Window* window = (*iter);
         WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
         if (state->progress > kEpsilon) {
           // It is possible to scroll |window| up. Scroll it up, and update
           // |delta_y_p| for the next window.
           float apply = delta_y_p * state->progress;
           SetWindowProgress(window, std::max(0.f, state->progress - apply * 3));
           delta_y_p -= apply;
         }
       }
     } else {
       // Scroll down. Start with the bottom-most (i.e. front-most in terms of
       // z-index) window, and try to scroll them down.
-      for (aura::Window::Windows::reverse_iterator iter = windows.rbegin();
-           delta_y_p > kEpsilon && iter != windows.rend();
+      aura::Window::Windows::const_reverse_iterator iter;
+      for (iter = windows_.rbegin();
+           delta_y_p > kEpsilon && iter != windows_.rend();
            ++iter) {
         aura::Window* window = (*iter);
         WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
         if (1.f - state->progress > kEpsilon) {
           // It is possible to scroll |window| down. Scroll it down, and update
           // |delta_y_p| for the next window.
           SetWindowProgress(window, std::min(1.f, state->progress + delta_y_p));
           delta_y_p /= 2.f;
         }
       }
@@ skipping 29 matching lines @@
       if (select) {
         gesture->SetHandled();
         delegate_->OnSelectWindow(select);
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       DoScroll(gesture->details().scroll_y());
     }
   }
 
   aura::Window* container_;
+  // The stack of windows to show in the overview mode
+  aura::Window::Windows windows_;

[Jun Mukai, 2014/08/05 21:13:38]

Can we set this as const?  I think the order of |windows_| should not change in
the overview mode itself (all it can do is invoking MoveToFront).

[mfomitchev, 2014/08/06 18:11:32]

Done.

   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
+    aura::Window::Windows windows,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
-      new WindowOverviewModeImpl(container, delegate));
+      new WindowOverviewModeImpl(container, windows, delegate));
 }
 
 }  // namespace athena