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()) {

[flackr, 2015/02/12 20:52:38]

Return early instead.

[bruthig, 2015/02/12 21:28:44]

Done.

+    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: {

[flackr, 2015/02/12 20:52:38]

I still think it would be correct to mark all of the scroll related events as
handled so that nothing else listening to these events thinks that they haven't
been handled yet.

[bruthig, 2015/02/12 21:28:44]

Done.

+          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: {
+        if (abs(delta_x) > GetMinimumCloseDistance()) {
+          transform_window_.Close();
+          break;
+        }
+        ResetScrolledWindow();
+        break;
+      }
+      case ui::ET_SCROLL_FLING_START: {
+        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