Implemented swipe to close in overview mode.

ash/wm/overview/scoped_transform_overview_window.cc

 // Copyright 2013 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 "ash/wm/overview/scoped_transform_overview_window.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/screen_util.h"
+#include "ash/shell.h"
 #include "ash/shell_window_ids.h"
 #include "ash/wm/overview/scoped_overview_animation_settings.h"
 #include "ash/wm/overview/scoped_window_copy.h"
+#include "ash/wm/overview/window_selector_controller.h"
 #include "ash/wm/overview/window_selector_item.h"
 #include "ash/wm/window_state.h"
 #include "ash/wm/window_util.h"
 #include "base/macros.h"
 #include "ui/aura/client/aura_constants.h"
 #include "ui/aura/client/screen_position_client.h"
 #include "ui/aura/window.h"
 #include "ui/compositor/scoped_layer_animation_settings.h"
 #include "ui/gfx/animation/tween.h"
 #include "ui/gfx/transform_util.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_animations.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 
 namespace {
 
 // The opacity level that windows will be set to when they are restored.
 const float kRestoreWindowOpacity = 1.0f;
 
+// The minimum opacity used during touch scroll gestures.
+const float kMinimumOpacity = 0.2f;
+
+// The distance at which the minimum opacity should take effect.
+const float kMinimumOpacityDistance = 200.0f;
+
 aura::Window* GetTransientRoot(aura::Window* window) {
   while (::wm::GetTransientParent(window))
     window = ::wm::GetTransientParent(window);
   return window;
 }
 
+// Calculates the window opacity from the given scroll |distance|.
+float CalculateOpacityFromScrollDistance(int distance) {
+  float opacity =
+      1.0 - static_cast<float>(abs(distance)) / kMinimumOpacityDistance;
+  return std::min(1.0f, std::max(kMinimumOpacity, opacity));
+}
+
 // An iterator class that traverses an aura::Window and all of it's transient
 // descendants.
 class TransientDescendantIterator {
  public:
   // Creates an empty iterator.
   TransientDescendantIterator();
 
   // Copy constructor required for iterator purposes.
   TransientDescendantIterator(
       const TransientDescendantIterator& other) = default;
@@ skipping 107 matching lines @@
 
 TransientDescendantIteratorRange GetTransientTreeIterator(
     aura::Window* window) {
   return TransientDescendantIteratorRange(
       TransientDescendantIterator(GetTransientRoot(window)));
 }
 
 }  // namespace
 
 ScopedTransformOverviewWindow::ScopedTransformOverviewWindow(
-        aura::Window* window)
+    aura::Window* window)
     : window_(window),
       activate_button_(new TransparentActivateWindowButton(
           window_->GetRootWindow(), this)),
       minimized_(window->GetProperty(aura::client::kShowStateKey) ==
                  ui::SHOW_STATE_MINIMIZED),
       ignored_by_shelf_(wm::GetWindowState(window)->ignored_by_shelf()),
       overview_started_(false),
       original_transform_(window->layer()->GetTargetTransform()),
       original_opacity_(window->layer()->GetTargetOpacity()) {
 }
@@ skipping 116 matching lines @@
     window->SetTransform(new_transform);
   }
 }
 
 void ScopedTransformOverviewWindow::SetOpacity(float opacity) {
   for (const auto& window : GetTransientTreeIterator(window_)) {
     window->layer()->SetOpacity(opacity);
   }
 }
 
+void ScopedTransformOverviewWindow::Scroll(int delta_x) {
+  const float opacity = CalculateOpacityFromScrollDistance(delta_x);
+
+  ScopedOverviewAnimationSettings animation_settings(
+      OverviewAnimationType::SELECTOR_ITEM_SCROLL,
+      window());
+  gfx::Transform new_transform;
+  new_transform.Translate(delta_x, 0);
+  new_transform.PreconcatTransform(get_overview_transform());
+  SetTransform(window()->GetRootWindow(), new_transform);
+
+  SetOpacity(opacity);
+}
+
+void ScopedTransformOverviewWindow::CancelScroll() {
+  ScopedOverviewAnimationSettings animation_settings(
+    OverviewAnimationType::SELECTOR_ITEM_SCROLL_CANCEL,
+    window());
+
+  // The target opacity is set before the transform so that the
+  // WindowSelectorItem::OnWindowTransformed handler can properly
+  // update the opacity of the close button to the window's target
+  // opacity.
+  SetOpacity(1.0);
+  SetTransform(window()->GetRootWindow(),
+               get_overview_transform());
+}
+
 void ScopedTransformOverviewWindow::Select() {
   wm::GetWindowState(window_)->Activate();
 }
 
 void ScopedTransformOverviewWindow::Close() {
   aura::Window* window = GetTransientRoot(window_);
   views::Widget::GetWidgetForNativeView(window)->Close();
 }
 
 void ScopedTransformOverviewWindow::PrepareForOverview() {
   DCHECK(!overview_started_);
   overview_started_ = true;
   wm::GetWindowState(window_)->set_ignored_by_shelf(true);
   RestoreWindow();
 }
 
 }  // namespace ash