athena: Improve the overview mode support 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>
 
@@ skipping 80 matching lines @@
       ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
   settings.SetTransitionDuration(base::TimeDelta::FromMilliseconds(250));
 
   settings.AddObserver(new ui::ClosureAnimationObserver(
       base::Bind(&HideWindowIfNotVisible, window, split_view_controller)));
 
   window->SetTransform(gfx::Transform());
   wm::SetShadowType(window, wm::SHADOW_TYPE_NONE);
 }
 
+gfx::RectF GetTransformedBounds(aura::Window* window) {
+  gfx::Transform transform;
+  gfx::RectF bounds = window->bounds();
+  transform.Translate(bounds.x(), bounds.y());
+  transform.PreconcatTransform(window->layer()->transform());
+  transform.Translate(-bounds.x(), -bounds.y());
+  transform.TransformRect(&bounds);
+  return bounds;
+}
+
+gfx::Transform GetTransformForSplitWindow(aura::Window* window, float scale) {
+  int x_translate = window->bounds().width() * (1 - scale) / 2;
+  gfx::Transform transform;
+  transform.Translate(x_translate, window->bounds().height() * 0.65);
+  transform.Scale(scale, scale);
+  return transform;
+}
+
+void TransformSplitWindowScale(aura::Window* window, float scale) {
+  gfx::Transform transform = window->layer()->GetTargetTransform();
+  if (transform.Scale2d() == gfx::Vector2dF(scale, scale))
+    return;
+  ui::ScopedLayerAnimationSettings settings(window->layer()->GetAnimator());
+  window->SetTransform(GetTransformForSplitWindow(window, scale));
+}
+
 // Always returns the same target.
 class StaticWindowTargeter : public aura::WindowTargeter {
  public:
   explicit StaticWindowTargeter(aura::Window* target) : target_(target) {}
   virtual ~StaticWindowTargeter() {}
 
  private:
   // aura::WindowTargeter:
   virtual ui::EventTarget* FindTargetForEvent(ui::EventTarget* root,
                                               ui::Event* event) OVERRIDE {
@@ skipping 60 matching lines @@
          ++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_view_controller_->IsSplitViewModeActive() &&
           (window == split_view_controller_->left_window() ||
            window == split_view_controller_->right_window())) {
         // 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->top = GetTransformForSplitWindow(window, kMaxScale);
         state->bottom = state->top;
         --index;
         continue;
       }
       UpdateTerminalStateForWindowAtIndex(window, index, windows.size());
     }
   }
 
   void UpdateTerminalStateForWindowAtIndex(aura::Window* window,
                                            size_t index,
@@ skipping 142 matching lines @@
     if (!compositor->HasAnimationObserver(this))
       compositor->AddAnimationObserver(this);
   }
 
   void RemoveAnimationObserver() {
     ui::Compositor* compositor = container_->GetHost()->compositor();
     if (compositor->HasAnimationObserver(this))
       compositor->RemoveAnimationObserver(this);
   }
 
+  aura::Window* IsSplitWindowDropTarget(const ui::GestureEvent& event) const {

[oshima, 2014/09/03 20:02:58]

Can this really be const?
(split_view_controller_->left_window() isn't const)

also I prefer to call it GetXxx if it returns aura::Window.

[sadrul, 2014/09/03 20:14:27]

The compiler doesn't seem to complain. (I can remove it though if you want. I
added it for readability)
Renamed to GetSplitWindowDropTarget().

[oshima, 2014/09/03 20:53:48]

I'm actually onthe fence as split_view_controller isn't really owned by this
object.
I'm fine to leave it as is.

 

+    if (!split_view_controller_->IsSplitViewModeActive())
+      return NULL;
+    CHECK(dragged_window_);
+    CHECK_NE(split_view_controller_->left_window(), dragged_window_);
+    CHECK_NE(split_view_controller_->right_window(), dragged_window_);
+    aura::Window* window = split_view_controller_->left_window();
+    if (GetTransformedBounds(window).Contains(event.location()))
+      return window;
+    window = split_view_controller_->right_window();
+    if (GetTransformedBounds(window).Contains(event.location()))
+      return window;
+    return NULL;
+  }
+
   void DragWindow(const ui::GestureEvent& event) {
     CHECK(dragged_window_);
     CHECK_EQ(ui::ET_GESTURE_SCROLL_UPDATE, event.type());
     CHECK(overview_toolbar_);
     gfx::Vector2dF dragged_distance =
         dragged_start_location_ - event.location();
     WindowOverviewState* dragged_state =
         dragged_window_->GetProperty(kWindowOverviewState);
     CHECK(dragged_state);
     gfx::Transform transform = GetTransformForState(dragged_state);
@@ skipping 17 matching lines @@
     if (new_action == OverviewToolbar::ACTION_TYPE_NONE) {
       if (fabs(dragged_distance.x()) > kMinDistanceForDismissal)
         new_action = OverviewToolbar::ACTION_TYPE_CLOSE;
       else
         new_action = OverviewToolbar::ACTION_TYPE_NONE;
     }
     OverviewToolbar::ActionType previous_action =
         overview_toolbar_->current_action();
     overview_toolbar_->SetHighlightAction(new_action);
 
+    aura::Window* split_drop = IsSplitWindowDropTarget(event);
+
     // If the user has selected to get into split-view mode, then show the
     // window with full opacity. Otherwise, fade it out as it closes. Animate
     // the opacity if transitioning to/from the split-view button.
     bool animate_opacity =
         (new_action != previous_action) &&
         ((new_action == OverviewToolbar::ACTION_TYPE_SPLIT) ||
          (previous_action == OverviewToolbar::ACTION_TYPE_SPLIT));
     float ratio = std::min(
         1.f, std::abs(dragged_distance.x()) / kMinDistanceForDismissal);
     float opacity =
-        (new_action == OverviewToolbar::ACTION_TYPE_SPLIT)
+        (new_action == OverviewToolbar::ACTION_TYPE_SPLIT || split_drop)
             ? 1
             : gfx::Tween::FloatValueBetween(ratio, kMaxOpacity, kMinOpacity);
     if (animate_opacity) {
       ui::ScopedLayerAnimationSettings settings(
           dragged_window_->layer()->GetAnimator());
       dragged_window_->layer()->SetOpacity(opacity);
     } else {
       dragged_window_->layer()->SetOpacity(opacity);
     }
+
+    if (split_view_controller_->IsSplitViewModeActive()) {
+      float scale = kMaxScale;
+      if (split_drop == split_view_controller_->left_window())
+        scale = kMaxScaleForSplitTarget;
+      TransformSplitWindowScale(split_view_controller_->left_window(), scale);
+
+      scale = kMaxScale;
+      if (split_drop == split_view_controller_->right_window())
+        scale = kMaxScaleForSplitTarget;
+      TransformSplitWindowScale(split_view_controller_->right_window(), scale);
+    }
   }
 
   bool ShouldCloseDragWindow(const ui::GestureEvent& event) const {
     gfx::Vector2dF dragged_distance =
         dragged_start_location_ - event.location();
     if (event.type() == ui::ET_GESTURE_SCROLL_END)
       return std::abs(dragged_distance.x()) >= kMinDistanceForDismissal;
     CHECK_EQ(ui::ET_SCROLL_FLING_START, event.type());
     const bool dragging_towards_right = dragged_distance.x() < 0;
     const bool swipe_towards_right = event.details().velocity_x() > 0;
@@ skipping 62 matching lines @@
     dragged_window_->SetTransform(GetTransformForState(dragged_state));
     dragged_window_->layer()->SetOpacity(1.f);
     dragged_window_ = NULL;
   }
 
   void EndDragWindow(const ui::GestureEvent& gesture) {
     CHECK(dragged_window_);
     CHECK(overview_toolbar_);
     OverviewToolbar::ActionType action = overview_toolbar_->current_action();
     overview_toolbar_.reset();
-    if (action == OverviewToolbar::ACTION_TYPE_SPLIT)
+    if (action == OverviewToolbar::ACTION_TYPE_SPLIT) {
       delegate_->OnSplitViewMode(NULL, dragged_window_);
-    else if (ShouldCloseDragWindow(gesture))
+      return;
+    }
+
+    // If the window is dropped on one of the left/right windows in split-mode,
+    // then switch that window.
+    aura::Window* split_drop = IsSplitWindowDropTarget(gesture);
+    if (split_drop) {
+      aura::Window* left = split_view_controller_->left_window();
+      aura::Window* right = split_view_controller_->right_window();
+      if (left == split_drop)
+        left = dragged_window_;
+      else
+        right = dragged_window_;
+      delegate_->OnSplitViewMode(left, right);
+      return;
+    }
+
+    if (ShouldCloseDragWindow(gesture))
       CloseDragWindow(gesture);
     else
       RestoreDragWindow();
   }
 
   void SelectWindow(aura::Window* window) {
     if (!split_view_controller_->IsSplitViewModeActive()) {
       delegate_->OnSelectWindow(window);
     } else {
       // If the selected window is one of the left/right windows, then keep the
@@ skipping 31 matching lines @@
       aura::Window* select = SelectWindowAt(gesture);
       if (select) {
         gesture->SetHandled();
         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_)
+        if (split_view_controller_->IsSplitViewModeActive() &&
+            (dragged_window_ == split_view_controller_->left_window() ||
+             dragged_window_ == split_view_controller_->right_window())) {
+          dragged_window_ = NULL;

[oshima, 2014/09/03 20:02:58]

does this mean I cannot close the window in split view mode?
shouldn't we exit the split view if one of left/right window is closed instead?

[sadrul, 2014/09/03 20:14:27]

Yes. I am going to do that in the next patch. I have added a TODO comment here
explaining the rationale for now.

+        }
+
+        if (dragged_window_) {
+          // Show the toolbar (for closing a window, or going into split-view
+          // mode). If already in split-view mode, then do not show the 'Split'
+          // option.
           overview_toolbar_.reset(new OverviewToolbar(container_));
+          if (split_view_controller_->IsSplitViewModeActive()) {
+            overview_toolbar_->DisableAction(
+                OverviewToolbar::ACTION_TYPE_SPLIT);
+          }
+        }
       }
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_UPDATE) {
       if (dragged_window_)
         DragWindow(*gesture);
       else
         DoScroll(gesture->details().scroll_y());
       gesture->SetHandled();
     } else if (gesture->type() == ui::ET_GESTURE_SCROLL_END) {
       if (dragged_window_)
         EndDragWindow(*gesture);
@@ skipping 28 matching lines @@
     } else {
       DoScroll(scroll.y());
     }
   }
 
   const int kMinDistanceForDismissal = 300;
   const float kMinScale = 0.6f;
   const float kMaxScale = 0.75f;
   const float kMaxOpacity = 1.0f;
   const float kMinOpacity = 0.2f;
+  const float kMaxScaleForSplitTarget = 0.9f;
 
   aura::Window* container_;
   // Provider of the stack of windows to show in the overview mode. Not owned.
   const WindowListProvider* window_list_provider_;
   SplitViewController* split_view_controller_;
 
   WindowOverviewModeDelegate* delegate_;
   scoped_ptr<aura::ScopedWindowTargeter> scoped_targeter_;
   scoped_ptr<ui::FlingCurve> fling_;
 
@@ skipping 11 matching lines @@
     aura::Window* container,
     const WindowListProvider* window_list_provider,
     SplitViewController* split_view_controller,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider,
                                  split_view_controller, delegate));
 }
 
 }  // namespace athena