Implemented swipe to close in overview mode.

ash/wm/overview/window_selector_item.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/window_selector_item.h"
 
 #include <algorithm>
 #include <vector>
 
 #include "ash/screen_util.h"
@@ skipping 19 matching lines @@
 #include "ui/views/border.h"
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/layout/box_layout.h"
 #include "ui/views/widget/widget.h"
 #include "ui/wm/core/window_util.h"
 
 namespace ash {
 
 namespace {
 
+// The minimum fling velocity which will cause a window to be closed.  Unit is
+// pixels per second.
+const float kMinimumFlingVelocity = 4000.0f;
+
+// The minimum opacity used during touch scroll gestures.
+const float kMinimumOpacity = 0.2f;
+
 // In the conceptual overview table, the window margin is the space reserved
 // around the window within the cell. This margin does not overlap so the
 // closest distance between adjacent windows will be twice this amount.
 static const int kWindowMargin = 30;
 
 // Foreground label color.
 static const SkColor kLabelColor = SK_ColorWHITE;
 
 // Label shadow color.
 static const SkColor kLabelShadow = 0xB0000000;
@@ skipping 15 matching lines @@
 gfx::Rect GetTransformedBounds(aura::Window* window) {
   gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(window->GetRootWindow(),
       window->layer()->GetTargetBounds()));
   gfx::Transform new_transform = TransformAboutPivot(
       gfx::Point(bounds.x(), bounds.y()),
       window->layer()->GetTargetTransform());
   new_transform.TransformRect(&bounds);
   return ToEnclosingRect(bounds);
 }
 
+// Convenvience method to fade in a Window with predefined animation settings.
+// Note: The fade in animation will occur after a delay where the delay is how
+// long the lay out animations take.
+void SetupFadeInAfterLayout(aura::Window* window) {
+  ui::Layer* layer = window->layer();
+  layer->SetOpacity(0.0f);
+  ScopedOverviewAnimationSettings animation_settings(
+      OverviewAnimationType::OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_IN,
+      window);
+  layer->SetOpacity(1.0f);
+}
+
+// Convenience method to fade out a window using the animation settings defined
+// by OverviewAnimationType::OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_OUT.
+void SetupFadeOut(aura::Window* window) {
+  ScopedOverviewAnimationSettings animation_settings(
+      OverviewAnimationType::OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_OUT,
+      window);
+  window->layer()->SetOpacity(0.0f);
+}
+
+// Calculates the window opacity from the given scroll |distance| and the
+// |min opacity_distance|.
+float CalculateOpacityFromScrollDistance(int distance,
+                                         int min_opacity_distance) {
+  float opacity =
+      1.0f - static_cast<float>(abs(distance)) / min_opacity_distance;
+  return std::min(1.0f, std::max(kMinimumOpacity, opacity));
+}
+
 // An image button with a close window icon.
 class OverviewCloseButton : public views::ImageButton {
  public:
   explicit OverviewCloseButton(views::ButtonListener* listener);
   ~OverviewCloseButton() override;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(OverviewCloseButton);
 };
 
 OverviewCloseButton::OverviewCloseButton(views::ButtonListener* listener)
     : views::ImageButton(listener) {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   SetImage(views::CustomButton::STATE_NORMAL,
            rb.GetImageSkiaNamed(IDR_AURA_WINDOW_OVERVIEW_CLOSE));
   SetImage(views::CustomButton::STATE_HOVERED,
            rb.GetImageSkiaNamed(IDR_AURA_WINDOW_OVERVIEW_CLOSE_H));
   SetImage(views::CustomButton::STATE_PRESSED,
            rb.GetImageSkiaNamed(IDR_AURA_WINDOW_OVERVIEW_CLOSE_P));
 }
 
 OverviewCloseButton::~OverviewCloseButton() {
 }
 
 }  // namespace
 
 WindowSelectorItem::OverviewLabelButton::OverviewLabelButton(
-    views::ButtonListener* listener,
+    WindowSelectorItem* selector_item,
     const base::string16& text)
-    : LabelButton(listener, text),
+    : LabelButton(selector_item, text),
+      selector_item_(selector_item),
       top_padding_(0) {
 }
 
 WindowSelectorItem::OverviewLabelButton::~OverviewLabelButton() {
 }
 
 gfx::Rect WindowSelectorItem::OverviewLabelButton::GetChildAreaBounds() {
   gfx::Rect bounds = GetLocalBounds();
   bounds.Inset(0, top_padding_, 0, 0);
   return bounds;
 }
 
+void WindowSelectorItem::OverviewLabelButton::OnGestureEvent(
+    ui::GestureEvent* event) {
+  selector_item_->OnGestureEvent(event);
+  views::LabelButton::OnGestureEvent(event);
+}
+
 WindowSelectorItem::WindowSelectorItem(aura::Window* window)
     : dimmed_(false),
       root_window_(window->GetRootWindow()),
       transform_window_(window),
       in_bounds_update_(false),
       window_label_button_view_(nullptr),
       close_button_(new OverviewCloseButton(this)) {
   CreateWindowLabel(window->title());
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
@@ skipping 82 matching lines @@
 void WindowSelectorItem::ButtonPressed(views::Button* sender,
                                        const ui::Event& event) {
   if (sender == close_button_) {
     transform_window_.Close();
     return;
   }
   CHECK(sender == window_label_button_view_);
   wm::GetWindowState(transform_window_.window())->Activate();
 }
 
+void WindowSelectorItem::OnGestureEvent(ui::GestureEvent* event) {
+  if (Shell::GetInstance()->window_selector_controller()->
+      swipe_to_close_disabled())
+    return;
+
+  int delta_x = 0;
+  if (event->type() == ui::ET_GESTURE_SCROLL_BEGIN)
+    scroll_x_origin_ = event->x();
+  else
+    delta_x = event->x() - scroll_x_origin_;
+
+  switch (event->type()) {
+    case ui::ET_GESTURE_SCROLL_BEGIN: {
+      // We need to call SetHandled() for the ET_GESTURE_SCROLL_BEGIN event so
+      // that future ET_GESTURE_SCROLL_* events are sent here.
+      event->SetHandled();
+      close_button_->SetEnabled(false);
+      SetupFadeOut(close_button_widget_.GetNativeWindow());
+      break;
+    }
+    case ui::ET_GESTURE_SCROLL_UPDATE: {
+      event->SetHandled();
+      ScopedTransformOverviewWindow::ScopedAnimationSettings
+          animation_settings;
+      transform_window_.BeginScopedAnimation(
+          OverviewAnimationType::OVERVIEW_ANIMATION_SCROLL_SELECTOR_ITEM,
+          &animation_settings);
+
+      gfx::Transform new_transform;
+      new_transform.Translate(delta_x, 0);
+      new_transform.PreconcatTransform(
+          transform_window_.get_overview_transform());
+      transform_window_.SetTransform(root_window(), new_transform);
+
+      const float opacity = CalculateOpacityFromScrollDistance(delta_x,
+          GetMinimumCloseDistance());
+      transform_window_.SetOpacity(opacity);
+      break;
+    }
+    case ui::ET_GESTURE_SCROLL_END: {
+      event->SetHandled();
+      if (abs(delta_x) > GetMinimumCloseDistance()) {
+        transform_window_.Close();
+        break;
+      }
+      ResetScrolledWindow();
+      break;
+    }
+    case ui::ET_SCROLL_FLING_START: {
+      event->SetHandled();
+      if (abs(delta_x) > GetMinimumCloseDistance() ||
+          fabs(event->details().velocity_x()) > kMinimumFlingVelocity) {
+        transform_window_.Close();
+        break;
+      }
+      ResetScrolledWindow();
+      break;
+    }
+    case ui::ET_GESTURE_END:
+      scroll_x_origin_ = 0;
+      break;
+    default:
+      break;
+  }
+}
+
 void WindowSelectorItem::OnWindowDestroying(aura::Window* window) {
   window->RemoveObserver(this);
   transform_window_.OnWindowDestroyed();
 }
 
 void WindowSelectorItem::OnWindowTitleChanged(aura::Window* window) {
   // TODO(flackr): Maybe add the new title to a vector of titles so that we can
   // filter any of the titles the window had while in the overview session.
   window_label_button_view_->SetText(window->title());
   UpdateCloseButtonAccessibilityName();
 }
 
+void WindowSelectorItem::ResetScrolledWindow() {
+  ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
+  transform_window_.BeginScopedAnimation(
+      OverviewAnimationType::OVERVIEW_ANIMATION_CANCEL_SELECTOR_ITEM_SCROLL,
+      &animation_settings);
+
+  transform_window_.SetTransform(root_window(),
+                                  transform_window_.get_overview_transform());
+  transform_window_.SetOpacity(1.0);
+
+  SetupFadeInAfterLayout(close_button_widget_.GetNativeWindow());
+  close_button_->SetEnabled(true);
+}
+
 void WindowSelectorItem::SetItemBounds(const gfx::Rect& target_bounds,
                                        OverviewAnimationType animation_type) {
   DCHECK(root_window_ == GetWindow()->GetRootWindow());
   gfx::Rect screen_bounds = transform_window_.GetTargetBoundsInScreen();
   gfx::Rect selector_item_bounds =
       ScopedTransformOverviewWindow::ShrinkRectToFitPreservingAspectRatio(
           screen_bounds, target_bounds);
   gfx::Transform transform =
       ScopedTransformOverviewWindow::GetTransformForRect(screen_bounds,
           selector_item_bounds);
@@ skipping 13 matching lines @@
 void WindowSelectorItem::UpdateWindowLabel(
     const gfx::Rect& window_bounds,
     OverviewAnimationType animation_type) {
   // If the root window has changed, force the window label to be recreated
   // and faded in on the new root window.
   DCHECK(!window_label_ ||
          window_label_->GetNativeWindow()->GetRootWindow() == root_window_);
 
   if (!window_label_->IsVisible()) {
     window_label_->Show();
-    ScopedOverviewAnimationSettings::SetupFadeInAfterLayout(
-        window_label_->GetNativeWindow());
+    SetupFadeInAfterLayout(window_label_->GetNativeWindow());
   }
 
   gfx::Rect converted_bounds =
       ScreenUtil::ConvertRectFromScreen(root_window_, window_bounds);
   gfx::Rect label_bounds(converted_bounds.x(), converted_bounds.y(),
                          converted_bounds.width(), converted_bounds.height());
   window_label_button_view_->set_top_padding(label_bounds.height() -
                                              kVerticalLabelPadding);
   ScopedOverviewAnimationSettings animation_settings(
       animation_type, window_label_->GetNativeWindow());
@@ skipping 28 matching lines @@
   ui::ResourceBundle& bundle = ui::ResourceBundle::GetSharedInstance();
   window_label_button_view_->SetFontList(
       bundle.GetFontList(ui::ResourceBundle::BoldFont));
   window_label_->SetContentsView(window_label_button_view_);
 }
 
 void WindowSelectorItem::UpdateCloseButtonLayout(
     OverviewAnimationType animation_type) {
   if (!close_button_->visible()) {
     close_button_->SetVisible(true);
-    ScopedOverviewAnimationSettings::SetupFadeInAfterLayout(
-        close_button_widget_.GetNativeWindow());
+    SetupFadeInAfterLayout(close_button_widget_.GetNativeWindow());
   }
   ScopedOverviewAnimationSettings animation_settings(animation_type,
       close_button_widget_.GetNativeWindow());
 
   gfx::Rect transformed_window_bounds = ScreenUtil::ConvertRectFromScreen(
       close_button_widget_.GetNativeWindow()->GetRootWindow(),
       GetTransformedBounds(GetWindow()));
 
   gfx::Transform close_button_transform;
   close_button_transform.Translate(transformed_window_bounds.right(),
                                    transformed_window_bounds.y());
   close_button_widget_.GetNativeWindow()->SetTransform(
       close_button_transform);
 }
 
 void WindowSelectorItem::UpdateCloseButtonAccessibilityName() {
   close_button_->SetAccessibleName(l10n_util::GetStringFUTF16(
       IDS_ASH_OVERVIEW_CLOSE_ITEM_BUTTON_ACCESSIBLE_NAME,
       GetWindow()->title()));
 }
 
+int WindowSelectorItem::GetMinimumCloseDistance() const {
+  return target_bounds_.size().width() / 2;
+}
+
 }  // namespace ash