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 261 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_);
+    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