athena: Fix overview mode for split-view mode.

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>
 
 #include "athena/wm/overview_toolbar.h"
 #include "athena/wm/public/window_list_provider.h"
+#include "athena/wm/split_view_controller.h"
 #include "base/bind.h"
 #include "base/macros.h"
 #include "ui/aura/scoped_window_targeter.h"
 #include "ui/aura/window.h"
 #include "ui/aura/window_delegate.h"
 #include "ui/aura/window_property.h"
 #include "ui/aura/window_targeter.h"
 #include "ui/aura/window_tree_host.h"
 #include "ui/compositor/closure_animation_observer.h"
 #include "ui/compositor/compositor.h"
@@ skipping 77 matching lines @@
   aura::Window* target_;
   DISALLOW_COPY_AND_ASSIGN(StaticWindowTargeter);
 };
 
 class WindowOverviewModeImpl : public WindowOverviewMode,
                                public ui::EventHandler,
                                public ui::CompositorAnimationObserver {
  public:
   WindowOverviewModeImpl(aura::Window* container,
                          const WindowListProvider* window_list_provider,
+                         SplitViewController* split_view_controller,
                          WindowOverviewModeDelegate* delegate)
       : container_(container),
         window_list_provider_(window_list_provider),
         delegate_(delegate),
         scoped_targeter_(new aura::ScopedWindowTargeter(
             container,
             scoped_ptr<ui::EventTargeter>(
                 new StaticWindowTargeter(container)))),
-        dragged_window_(NULL) {
+        dragged_window_(NULL),
+        split_({false, NULL, NULL}) {
+    CHECK(delegate_);
     container_->set_target_handler(this);
 
+    split_.enabled = split_view_controller->IsSplitViewModeActive();
+    if (split_.enabled) {
+      split_.left = split_view_controller->left_window();
+      split_.right = split_view_controller->right_window();
+    }
+
     // 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());
     RemoveAnimationObserver();
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
@@ skipping 11 matching lines @@
     size_t index = 0;
 
     for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
          iter != windows.rend();
          ++iter, ++index) {
       aura::Window* window = (*iter);
       wm::SetShadowType(window, wm::SHADOW_TYPE_RECTANGULAR_ALWAYS_ACTIVE);
 
       WindowOverviewState* state = new WindowOverviewState;
       window->SetProperty(kWindowOverviewState, state);
+      if (split_.enabled && (window == split_.left || window == split_.right)) {
+        // Do not let the left/right windows be scrolled.
+        int x_translate = window->bounds().width() * (1 - kMaxScale) / 2;
+        state->top.Translate(x_translate, window->bounds().height() * 0.65);
+        state->top.Scale(kMaxScale, kMaxScale);
+        state->bottom = state->top;
+        --index;
+        continue;
+      }
       UpdateTerminalStateForWindowAtIndex(window, index, windows.size());
     }
   }
 
   void UpdateTerminalStateForWindowAtIndex(aura::Window* window,
                                            size_t index,
                                            size_t window_count) {
     const int kGapBetweenWindowsBottom = 10;
     const int kGapBetweenWindowsTop = 5;
 
@@ skipping 16 matching lines @@
     WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
     CHECK(state);
     state->top = top_transform;
     state->bottom = bottom_transform;
     state->progress = 0.f;
   }
 
   // Sets the initial position for the windows for the overview mode.
   void SetInitialWindowStates() {
     aura::Window::Windows windows = window_list_provider_->GetWindowList();
-    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) {
+    size_t index = 0;
+    for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
+         iter != windows.rend();
+         ++iter) {
       float progress = 0.f;
-      aura::Window* window = windows[window_count - 1 - i];
-      if (i < arraysize(kInitialProgress))
-        progress = kInitialProgress[i];
+      aura::Window* window = *iter;
+      if (split_.enabled && (window == split_.left || window == split_.right)) {
+        progress = 1;
+      } else {
+        if (index < arraysize(kInitialProgress))
+          progress = kInitialProgress[index];
+        ++index;
+      }
 
       scoped_refptr<ui::LayerAnimator> animator =
           window->layer()->GetAnimator();
 
       // Unset any in-progress animation.
       animator->AbortAllAnimations();
       window->Show();
       window->SetTransform(gfx::Transform());
       // Setup the animation.
       {
@@ skipping 60 matching lines @@
           // |delta_y_p| for the next window.
           SetWindowProgress(window, std::min(1.f, state->progress + delta_y_p));
           delta_y_p /= 2.f;
         }
       }
     }
   }
 
   int GetScrollableHeight() const {
     const float kScrollableFraction = 0.65f;
-    return container_->bounds().height() * kScrollableFraction;
+    const float kScrollableFractionInSplit = 0.5f;
+    const float fraction =
+        split_.enabled ? kScrollableFractionInSplit : kScrollableFraction;
+    return container_->bounds().height() * fraction;
   }
 
   void CreateFlingerFor(const ui::GestureEvent& event) {
     gfx::Vector2dF velocity(event.details().velocity_x(),
                             event.details().velocity_y());
     fling_.reset(new ui::FlingCurve(velocity, gfx::FrameTime::Now()));
   }
 
   void AddAnimationObserver() {
     ui::Compositor* compositor = container_->GetHost()->compositor();
@@ skipping 147 matching lines @@
     OverviewToolbar::ActionType action = overview_toolbar_->current_action();
     overview_toolbar_.reset();
     if (action == OverviewToolbar::ACTION_TYPE_SPLIT)
       delegate_->OnSplitViewMode(NULL, dragged_window_);
     else if (ShouldCloseDragWindow(gesture))
       CloseDragWindow(gesture);
     else
       RestoreDragWindow();
   }
 
+  void SelectWindow(aura::Window* window) {
+    if (!split_.enabled) {
+      delegate_->OnSelectWindow(window);
+    } else {
+      // If the selected window is one of the left/right windows, then keep the
+      // current state.
+      if (window == split_.left || window == split_.right) {
+        delegate_->OnSplitViewMode(split_.left, split_.right);
+      } else {
+        delegate_->OnSelectWindow(window);
+      }
+    }
+  }
+
   // ui::EventHandler:
   virtual void OnMouseEvent(ui::MouseEvent* mouse) OVERRIDE {
     if (mouse->type() == ui::ET_MOUSE_PRESSED) {
       aura::Window* select = SelectWindowAt(mouse);
       if (select) {
         mouse->SetHandled();
-        delegate_->OnSelectWindow(select);
+        SelectWindow(select);
       }
     } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
       DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
     }
   }
 
   virtual void OnScrollEvent(ui::ScrollEvent* scroll) OVERRIDE {
     if (scroll->type() == ui::ET_SCROLL)
       DoScroll(scroll->y_offset());
   }
 
   virtual void OnGestureEvent(ui::GestureEvent* gesture) OVERRIDE {
     if (gesture->type() == ui::ET_GESTURE_TAP) {
       aura::Window* select = SelectWindowAt(gesture);
       if (select) {
         gesture->SetHandled();
-        delegate_->OnSelectWindow(select);
+        SelectWindow(select);
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_BEGIN) {
       if (std::abs(gesture->details().scroll_x_hint()) >
           std::abs(gesture->details().scroll_y_hint()) * 2) {
         dragged_start_location_ = gesture->location();
         dragged_window_ = SelectWindowAt(gesture);
         if (dragged_window_)
           overview_toolbar_.reset(new OverviewToolbar(container_));
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
@@ skipping 33 matching lines @@
     if (scroll.IsZero()) {
       fling_.reset();
       RemoveAnimationObserver();
     } else {
       DoScroll(scroll.y());
     }
   }
 
   const int kMinDistanceForDismissal = 300;
   const float kMinScale = 0.6f;
-  const float kMaxScale = 0.95f;
+  const float kMaxScale = 0.75f;
   const float kMaxOpacity = 1.0f;
   const float kMinOpacity = 0.2f;
 
   aura::Window* container_;
   // Provider of the stack of windows to show in the overview mode. Not owned.
   const WindowListProvider* window_list_provider_;
   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
   scoped_ptr<ui::FlingCurve> fling_;
 
   aura::Window* dragged_window_;
   gfx::Point dragged_start_location_;
   scoped_ptr<OverviewToolbar> overview_toolbar_;
 
+  struct {
+    bool enabled;
+    aura::Window* left;
+    aura::Window* right;
+  } split_;
+
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
     const WindowListProvider* window_list_provider,
+    SplitViewController* split_view_controller,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
-      new WindowOverviewModeImpl(container, window_list_provider, delegate));
+      new WindowOverviewModeImpl(container, window_list_provider,
+                                 split_view_controller, delegate));
 }
 
 }  // namespace athena