athena: Change the scrolling behaviour of the windows in 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>
 
@@ skipping 14 matching lines @@
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/events/event_handler.h"
 #include "ui/events/gestures/fling_curve.h"
 #include "ui/gfx/frame_time.h"
 #include "ui/gfx/transform.h"
 #include "ui/wm/core/shadow_types.h"
 #include "ui/wm/core/window_util.h"
 
 namespace {
 
+const float kOverviewDefaultScale = 0.75f;
+
 struct WindowOverviewState {
-  // The transform for when the window is at the topmost position.
-  gfx::Transform top;
-
-  // The transform for when the window is at the bottom-most position.
-  gfx::Transform bottom;
-
   // The current overview state of the window. 0.f means the window is at the
   // topmost position. 1.f means the window is at the bottom-most position.
   float progress;
+
+  float max_y;
+  float min_y;

[oshima, 2014/09/10 00:19:42]

please document them.

[sadrul, 2014/09/10 04:38:40]

Done.

+
+  bool split;
 };
 
 }  // namespace
 
 DECLARE_WINDOW_PROPERTY_TYPE(WindowOverviewState*)
 DEFINE_OWNED_WINDOW_PROPERTY_KEY(WindowOverviewState,
                                  kWindowOverviewState,
                                  NULL)
 namespace athena {
 
 namespace {
 
+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);

[oshima, 2014/09/10 00:19:42]

define const for 0.65 

[sadrul, 2014/09/10 04:38:40]

Done.

+  transform.Scale(scale, scale);
+  return transform;
+}
+
 // Gets the transform for the window in its current state.
-gfx::Transform GetTransformForState(WindowOverviewState* state) {
-  return gfx::Tween::TransformValueBetween(state->progress,
-                                           state->top,
-                                           state->bottom);
+gfx::Transform GetTransformForState(aura::Window* window,
+                                    WindowOverviewState* state) {
+  if (state->split)
+    return GetTransformForSplitWindow(window, kOverviewDefaultScale);
+
+  const float kStartShrinking = 0.07;

[oshima, 2014/09/10 00:19:42]

kProgressToStartShrinking ?

[sadrul, 2014/09/10 04:38:40]

Done.

+  const float kOverviewScale = 0.75f;
+  float scale = kOverviewScale;
+  if (state->progress < kStartShrinking) {
+    const float kShrunkScale = 0.7f;

[oshima, 2014/09/10 00:19:42]

kShrunkMinimumScale ?

[sadrul, 2014/09/10 04:38:40]

Done.

+    scale = gfx::Tween::FloatValueBetween(state->progress / kStartShrinking,
+                                          kShrunkScale,
+                                          kOverviewScale);
+  }
+  int container_width = window->parent()->bounds().width();
+  int window_width = window->bounds().width();
+  int window_x = window->bounds().x();
+  float x_translate =
+      (container_width - (window_width * scale)) / 2 - window_x;
+  float y_translate = gfx::Tween::FloatValueBetween(state->progress,
+                                                    state->min_y,
+                                                    state->max_y);
+  gfx::Transform transform;
+  transform.Translate(x_translate, y_translate);
+  transform.Scale(scale, scale);
+  return transform;
 }
 
 // Sets the progress-state for the window in the overview mode.
 void SetWindowProgress(aura::Window* window, float progress) {
   WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
   state->progress = progress;
-  window->SetTransform(GetTransformForState(state));
+
+  gfx::Transform transform = GetTransformForState(window, state);
+  window->SetTransform(transform);
 }
 
 void HideWindowIfNotVisible(aura::Window* window,
                             SplitViewController* split_view_controller) {
   bool should_hide = true;
   if (split_view_controller->IsSplitViewModeActive()) {
     should_hide = window != split_view_controller->left_window() &&
                   window != split_view_controller->right_window();
   } else {
     should_hide = !wm::IsActiveWindow(window);
@@ skipping 26 matching lines @@
 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 {
@@ skipping 68 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.
-        state->top = GetTransformForSplitWindow(window, kMaxScale);
-        state->bottom = state->top;
+        gfx::Transform transform =
+            GetTransformForSplitWindow(window, kOverviewDefaultScale);
+        state->max_y = state->min_y = transform.To2dTranslation().y();
+        state->split = true;
         --index;
         continue;
       }
+      state->split = false;
       UpdateTerminalStateForWindowAtIndex(window, index, windows.size());
     }
   }
 
   // Computes the terminal states (i.e. the transforms for the top-most and
   // bottom-most position in the stack) for |window|. |window_count| is the
   // number of windows in the stack, and |index| is the position of the window
   // in the stack (0 being the front-most window).
   void UpdateTerminalStateForWindowAtIndex(aura::Window* window,
                                            size_t index,
                                            size_t window_count) {
     const int kGapBetweenWindowsBottom = 10;
     const int kGapBetweenWindowsTop = 5;
 
-    const int container_width = container_->bounds().width();
-    const int window_width = window->bounds().width();
-    const int window_x = window->bounds().x();
-    gfx::Transform top_transform;
     int top = (window_count - index - 1) * kGapBetweenWindowsTop;
-    float x_translate =
-        (container_width - (window_width * kMinScale)) / 2 - window_x;
-    top_transform.Translate(x_translate, top);
-    top_transform.Scale(kMinScale, kMinScale);
-
-    gfx::Transform bottom_transform;
     int bottom = GetScrollableHeight() - (index * kGapBetweenWindowsBottom);
-    x_translate = (container_width - (window_width * kMaxScale)) / 2 - window_x;
-    bottom_transform.Translate(x_translate, bottom - window->bounds().y());
-    bottom_transform.Scale(kMaxScale, kMaxScale);
 
     WindowOverviewState* state = window->GetProperty(kWindowOverviewState);
     CHECK(state);
-    state->top = top_transform;
-    state->bottom = bottom_transform;
+    if (state->split)
+      return;
+    state->min_y = top;
+    state->max_y = bottom - window->bounds().y();
     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();
     // The initial overview state of the topmost three windows.
     const float kInitialProgress[] = { 0.5f, 0.05f, 0.01f };
     size_t index = 0;
     for (aura::Window::Windows::const_reverse_iterator iter = windows.rbegin();
@@ skipping 82 matching lines @@
           // 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;
         }
       }
     }
   }
 
   int GetScrollableHeight() const {
-    const float kScrollableFraction = 0.65f;
+    const float kScrollableFraction = 0.85f;
     const float kScrollableFractionInSplit = 0.5f;
     const float fraction = split_view_controller_->IsSplitViewModeActive()
                                ? kScrollableFractionInSplit
                                : kScrollableFraction;
     return container_->bounds().height() * fraction;
   }
 
   void CreateFlingerFor(const ui::GestureEvent& event) {
     gfx::Vector2dF velocity(event.details().velocity_x(),
                             event.details().velocity_y());
@@ skipping 29 matching lines @@
 
   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);
+    gfx::Transform transform = GetTransformForState(dragged_window_,
+                                                    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();
 
@@ skipping 31 matching lines @@
             : 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;
+      float scale = kOverviewDefaultScale;
       if (split_drop == split_view_controller_->left_window())
         scale = kMaxScaleForSplitTarget;
       TransformSplitWindowScale(split_view_controller_->left_window(), scale);
 
-      scale = kMaxScale;
+      scale = kOverviewDefaultScale;
       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)
@@ skipping 21 matching lines @@
           dragged_window_->GetProperty(kWindowOverviewState);
       CHECK(dragged_state);
       gfx::Transform transform = dragged_window_->layer()->transform();
       gfx::RectF transformed_bounds = dragged_window_->bounds();
       transform.TransformRect(&transformed_bounds);
       float transform_x = 0.f;
       if (gesture.location().x() > dragged_start_location_.x())
         transform_x = container_->bounds().right() - transformed_bounds.x();
       else
         transform_x = -(transformed_bounds.x() + transformed_bounds.width());
-      float scale = gfx::Tween::FloatValueBetween(
-          dragged_state->progress, kMinScale, kMaxScale);
-      transform.Translate(transform_x / scale, 0);
+      transform.Translate(transform_x / kOverviewDefaultScale, 0);
       dragged_window_->SetTransform(transform);
       dragged_window_->layer()->SetOpacity(kMinOpacity);
     }
 
     const aura::Window::Windows list = window_list_provider_->GetWindowList();
     CHECK(!list.empty());
     if (list.front() == dragged_window_) {
       // There's no window behind |dragged_window_|. So move the windows in
       // front take a step back.
       for (aura::Window::Windows::const_reverse_iterator iter = list.rbegin();
@@ skipping 39 matching lines @@
   void RestoreDragWindow() {
     CHECK(dragged_window_);
     WindowOverviewState* dragged_state =
         dragged_window_->GetProperty(kWindowOverviewState);
     CHECK(dragged_state);
 
     ui::ScopedLayerAnimationSettings settings(
         dragged_window_->layer()->GetAnimator());
     settings.SetPreemptionStrategy(
         ui::LayerAnimator::IMMEDIATELY_ANIMATE_TO_NEW_TARGET);
-    dragged_window_->SetTransform(GetTransformForState(dragged_state));
+    dragged_window_->SetTransform(GetTransformForState(dragged_window_,
+                                                       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) {
@@ skipping 124 matching lines @@
     gfx::Vector2dF scroll = fling_->GetScrollAmountAtTime(timestamp);
     if (scroll.IsZero()) {
       fling_.reset();
       RemoveAnimationObserver();
     } 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_;
@@ skipping 14 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