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 20 matching lines @@
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/button/label_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) {
+  ui::Layer* layer = window->layer();

[flackr, 2015/02/10 17:49:49]

layer is only used once, remove this and access as
window->layer()->SetOpacity(0.0f) below.

[bruthig, 2015/02/12 18:08:55]

Done.

+  ScopedOverviewAnimationSettings animation_settings(
+      OverviewAnimationType::OVERVIEW_ANIMATION_ENTER_OVERVIEW_MODE_FADE_OUT,
+      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.0 - static_cast<float>(abs(distance)) / min_opacity_distance;

[flackr, 2015/02/10 17:49:49]

nit: 1.0 is a double, use 1.0f for float calculation.

[bruthig, 2015/02/12 18:08:55]

Done.

+  return std::min(1.0f, std::max(kMinimumOpacity, opacity));

[flackr, 2015/02/10 17:49:49]

Why std::min with 1.0f? opacity should always be strictly <= 1 from the
caculation above, should it not?

[bruthig, 2015/02/12 18:08:55]

Not if min_opacity_distance < 0.  Alternatively I could
DCHECK(min_opacity_distance > 0).  Thoughts?

[flackr, 2015/02/12 18:52:43]

I'd prefer DCHECK, min_opacity_distance < 0 doesn't make sense.

+}
+
 // 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() {
 }
 
+// Specialized views::LabelButton that captures touch gestures.
+class WindowSelectorItemButton : public views::LabelButton {
+ public:
+  WindowSelectorItemButton(WindowSelectorItem* selector_item,
+                           const base::string16& text);
+
+  // views::LabelButton:
+  void OnGestureEvent(ui::GestureEvent* event) override;
+
+ private:
+  // The WindowSelectorItem that the touch gestures are delegated to.
+  // Not owned.
+  WindowSelectorItem* selector_item_;
+
+  // The original X location for a scroll begin event. |original_x_| is in the
+  // local coordinate space as |this|.

[flackr, 2015/02/10 17:49:49]

s/as |this|/of |this| ?

[bruthig, 2015/02/12 18:08:55]

Done.

+  float scroll_x_origin_;
+
+  DISALLOW_COPY_AND_ASSIGN(WindowSelectorItemButton);
+};
+
+WindowSelectorItemButton::WindowSelectorItemButton(
+    WindowSelectorItem* selector_item,
+    const base::string16& text)
+    : views::LabelButton(selector_item, text),
+      selector_item_(selector_item) {
+}
+
+void WindowSelectorItemButton::OnGestureEvent(ui::GestureEvent* event) {
+  int delta_x = event->x() - scroll_x_origin_;

[flackr, 2015/02/10 17:49:49]

nit: While the variable is not used in this case, this really should be 0 on the
SCROLL_BEGIN. I think it would be cleaner to do something like this at the start
of the method:
int delta_x = 0;
if (event->type() == ui::ET_SCROLL_BEGIN)
  scroll_x_origin_ = event->x();
else
  delta_x = event->x() - scroll_x_origin_;

[bruthig, 2015/02/12 18:08:55]

Done.

+
+  switch (event->type()) {
+    case ui::ET_GESTURE_SCROLL_BEGIN:
+      event->SetHandled();
+      selector_item_->OnScrollBegin();
+      scroll_x_origin_ = event->x();
+      break;
+    case ui::ET_GESTURE_SCROLL_UPDATE:
+      selector_item_->OnScrollUpdate(delta_x);
+      break;
+    case ui::ET_GESTURE_SCROLL_END:
+      selector_item_->OnScrollEnd(delta_x);
+      break;
+    case ui::ET_SCROLL_FLING_START:
+      selector_item_->OnFling(delta_x, fabs(event->details().velocity_x()));

[flackr, 2015/02/10 17:49:49]

I think rather than delegating these events to the selector item the
WindowSelectorItem should just be the views::LabelButton.

[bruthig, 2015/02/12 18:08:55]

Discussed offline but will summarize here.  It would be problematic for the
WindowSelectorItem to be the contents view of a widget that it owned.  Thus it
was decided to leave as is.

+      break;
+    case ui::ET_GESTURE_END:
+      scroll_x_origin_ = 0;
+      break;
+    default:
+      break;
+  }
+  views::LabelButton::OnGestureEvent(event);
+}
+
 }  // namespace
 
 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());
@@ skipping 96 matching lines @@
   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::OnScrollBegin() {
+  close_button_->SetEnabled(false);
+  SetupFadeOut(close_button_widget_.GetNativeWindow());
+}
+
+void WindowSelectorItem::OnScrollUpdate(int delta_x) {
+  ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
+  transform_window_.BeginScopedAnimation(
+      OverviewAnimationType::OVERVIEW_ANIMATION_SCROLL_SELECTOR_ITEM,

[flackr, 2015/02/10 17:49:49]

It confuses me that we have an animation type for this. i.e. I don't think that
we would ever want an animation making the movement lag behind your finger.

[bruthig, 2015/02/12 18:08:55]

It was a while ago and I can't remember the exact steps to repro but I remember
manipulating a window without creating a ScopedLayerAnimationSettings and
assumed that the changes would be immediate however there was some rogue
ScopedLayerAnimationSettings object in scope that caused the changes to actually
be animated.  Actually having an animation type for this is ensuring that it
will indeed be instant.

[flackr, 2015/02/12 18:52:43]

Acknowledged, though seems like something worth investigating as now we're
violating the expected animation of whatever is calling this. It should just be
on the call stack right? Add a TODO comment explaining this.

+      &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);
+}
+
+void WindowSelectorItem::OnScrollEnd(int delta_x) {
+  if (abs(delta_x) > GetMinimumCloseDistance()) {
+    transform_window_.Close();
+    return;
+  }
+  ResetScrolledWindow();
+}
+
+void WindowSelectorItem::OnFling(int delta_x, float velocity_x) {
+  if (abs(delta_x) > GetMinimumCloseDistance() ||
+      velocity_x > kMinimumFlingVelocity) {
+    transform_window_.Close();
+    return;
+  }
+  ResetScrolledWindow();
+}
+
+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_->SetBorder(views::Border::CreateEmptyBorder(
       label_bounds.height() - kVerticalLabelPadding, 0, 0, 0));
   ScopedOverviewAnimationSettings animation_settings(
       animation_type, window_label_->GetNativeWindow());
 
   window_label_->GetNativeWindow()->SetBounds(label_bounds);
 }
 
 void WindowSelectorItem::CreateWindowLabel(const base::string16& title) {
   window_label_.reset(new views::Widget);
   views::Widget::InitParams params;
   params.type = views::Widget::InitParams::TYPE_POPUP;
   params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
   params.opacity = views::Widget::InitParams::TRANSLUCENT_WINDOW;
   params.parent =
       Shell::GetContainer(root_window_, kShellWindowId_OverlayContainer);
   params.visible_on_all_workspaces = true;
   window_label_->set_focus_on_creation(false);
   window_label_->Init(params);
-  window_label_button_view_ = new views::LabelButton(this, title);
+  if (Shell::GetInstance()->window_selector_controller()->
+      swipe_to_close_disabled())

[flackr, 2015/02/10 17:49:49]

You should check the flag directly here.

[bruthig, 2015/02/12 18:08:55]

The flag check has been moved in to the OverviewLabelButton::OnGestureEvent
method which is called with high frequency so it was decided to not check the
flag directly because it is not optimized for lookup.

+    window_label_button_view_ = new views::LabelButton(this, title);
+  else
+    window_label_button_view_ = new WindowSelectorItemButton(this, title);
   window_label_button_view_->SetTextColor(views::LabelButton::STATE_NORMAL,
                                           kLabelColor);
   window_label_button_view_->SetTextColor(views::LabelButton::STATE_HOVERED,
                                           kLabelColor);
   window_label_button_view_->SetTextColor(views::LabelButton::STATE_PRESSED,
                                           kLabelColor);
   window_label_button_view_->set_animate_on_state_change(false);
   window_label_button_view_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
   window_label_button_view_->SetTextShadows(gfx::ShadowValues(
       1, gfx::ShadowValue(gfx::Point(0, kVerticalShadowOffset), kShadowBlur,
                           kLabelShadow)));
   window_label_button_view_->set_ignore_vertical_overlap(false);
   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