athena: Allow getting into split-view mode from overview-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/common/closure_animation_observer.h"
+#include "athena/wm/overview_toolbar.h"
 #include "athena/wm/public/window_list_provider.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/compositor.h"
@@ skipping 271 matching lines @@
 
   void RemoveAnimationObserver() {
     ui::Compositor* compositor = container_->GetHost()->compositor();
     if (compositor->HasAnimationObserver(this))
       compositor->RemoveAnimationObserver(this);
   }
 
   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);
     transform.Translate(-dragged_distance.x(), 0);
     dragged_window_->SetTransform(transform);
 
+    // Update the toolbar.
+    const int kMinDistanceForActionButtons = 20;
+    if (fabs(dragged_distance.x()) > kMinDistanceForActionButtons)
+      overview_toolbar_->ShowActionButtons();
+    else
+      overview_toolbar_->HideActionButtons();
+
+    // See if the touch-point is above one of the action-buttons.
+    OverviewToolbar::ActionType new_action =
+        overview_toolbar_->GetHighlightAction(event);
+
+    // If the touch-point is not above any of the action buttons, then highlight
+    // the close-button by default, if the user has dragged enough to close the
+    // window.
+    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);
+
+    // 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 =
-        gfx::Tween::FloatValueBetween(ratio, kMaxOpacity, kMinOpacity);
-    dragged_window_->layer()->SetOpacity(opacity);
+        (new_action == OverviewToolbar::ACTION_TYPE_SPLIT)
+            ? 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);
+    }
   }
 
   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 58 matching lines @@
 
     ui::ScopedLayerAnimationSettings settings(
         dragged_window_->layer()->GetAnimator());
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
     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)
+      delegate_->OnSplitViewMode(NULL, dragged_window_);

[mfomitchev, 2014/08/13 15:12:31]

Why not pass the left window here as well? The bottom window in the stack should
be the left window, and it seems it would be cleaner if the overview mode
ensured that rather than relying on SplitViewController.

[sadrul, 2014/08/13 16:20:12]

The purpose here is to tell the delegate that the user has explicitly selected
the window on the right. The delegate (which is responsible for actually going
into the split-view mode) is responsible for deciding whether to keep the
foremost window on the left, or whether to switch to a different window on the
left (e.g. if the selected window on the right belongs to a multi-window app,
perhaps the left window would switch to a window that belongs to the same app).
That's a detail the overview-mode itself does not need to worry about.

[mfomitchev, 2014/08/13 17:42:52]

Acknowledged.

+    else if (ShouldCloseDragWindow(gesture))
+      CloseDragWindow(gesture);
+    else
+      RestoreDragWindow();
+  }
+
   // 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);
       }
     } else if (mouse->type() == ui::ET_MOUSEWHEEL) {
       DoScroll(static_cast<ui::MouseWheelEvent*>(mouse)->y_offset());
@@ skipping 10 matching lines @@
       aura::Window* select = SelectWindowAt(gesture);
       if (select) {
         gesture->SetHandled();
         delegate_->OnSelectWindow(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) {
       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_) {
-        if (ShouldCloseDragWindow(*gesture))
-          CloseDragWindow(*gesture);
-        else
-          RestoreDragWindow();
-      }
+      if (dragged_window_)
+        EndDragWindow(*gesture);
       gesture->SetHandled();
     } else if (gesture->type() == ui::ET_SCROLL_FLING_START) {
       if (dragged_window_) {
-        if (ShouldCloseDragWindow(*gesture))
-          CloseDragWindow(*gesture);
-        else
-          RestoreDragWindow();
+        EndDragWindow(*gesture);
       } else {
         CreateFlingerFor(*gesture);
         AddAnimationObserver();
       }
       gesture->SetHandled();
     } else if (gesture->type() == ui::ET_GESTURE_TAP_DOWN) {
       if (fling_) {
         fling_.reset();
         RemoveAnimationObserver();
         gesture->SetHandled();
@@ skipping 24 matching lines @@
 
   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_;
 
   DISALLOW_COPY_AND_ASSIGN(WindowOverviewModeImpl);
 };
 
 }  // namespace
 
 // static
 scoped_ptr<WindowOverviewMode> WindowOverviewMode::Create(
     aura::Window* container,
     const WindowListProvider* window_list_provider,
     WindowOverviewModeDelegate* delegate) {
   return scoped_ptr<WindowOverviewMode>(
       new WindowOverviewModeImpl(container, window_list_provider, delegate));
 }
 
 }  // namespace athena