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 17 matching lines @@
 #include "ui/views/controls/button/image_button.h"
 #include "ui/views/controls/label.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 opacity used during touch scroll gestures.
+const float kMinimumOpacity = 0.2f;

[flackr, 2014/11/07 19:10:52]

0.f seems like a decent close opacity. If you drag and the window becomes
invisible it's obvious that a release will kill it.

[bruthig, 2015/01/02 16:49:17]

I consulted with stevet@ with the 0.2f value. If we want to change it we should
loop him in to the conversation.  I would prefer that we don't delay getting
this CL in based on this and we can always change it later very easily.

+
+// The distance at which the minimum opacity should take effect.
+const float kMinimumOpacityDistance = 200.0f;

[flackr, 2014/11/07 19:10:52]

Shouldn't this be the same as the close distance?

[bruthig, 2015/01/02 16:49:17]

I agree, this should be in sync with the actual close distance.  I will defer
this until we agree on how that distance is calculated.

+
+// 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));
+}
+
 gfx::Rect GetTransformedBounds(aura::Window* window) {
   gfx::RectF bounds(ScreenUtil::ConvertRectToScreen(window->GetRootWindow(),
                                                     window->layer()->bounds()));
   gfx::Transform new_transform;
   new_transform.Translate(bounds.x(), bounds.y());
   new_transform.PreconcatTransform(window->layer()->GetTargetTransform());
   new_transform.Translate(-bounds.x(), -bounds.y());
   new_transform.TransformRect(&bounds);
   return ToEnclosingRect(bounds);
 }
@@ skipping 92 matching lines @@
 
 WindowSelectorItem::WindowListItem::WindowListItem(aura::Window* window)
     : activate_button_(
           new TransparentActivateWindowButton(window->GetRootWindow(), this)),
       transform_window_(new ScopedTransformOverviewWindow(window)) {
 }
 
 WindowSelectorItem::WindowListItem::~WindowListItem() {
 }
 
+void WindowSelectorItem::WindowListItem::Scroll(int delta_x) {
+  const float opacity = CalculateOpacityFromScrollDistance(delta_x);
+  ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
+  transform_window_->BeginScopedAnimation(
+      OverviewAnimationSettingsProvider::AnimationType::SELECTOR_ITEM_SCROLL,
+      &animation_settings);
+
+  gfx::Transform new_transform;
+  new_transform.Translate(delta_x, 0);
+  new_transform.PreconcatTransform(transform_window_->get_overview_transform());
+  transform_window_->SetTransform(transform_window_->window()->GetRootWindow(),
+                                  new_transform);
+
+  transform_window_->SetOpacity(opacity);
+}
+
+void WindowSelectorItem::WindowListItem::CancelScroll() {
+  aura::Window* window = transform_window_->window();
+  ScopedTransformOverviewWindow::ScopedAnimationSettings animation_settings;
+  transform_window_->BeginScopedAnimation(
+      OverviewAnimationSettingsProvider::AnimationType::
+          SELECTOR_ITEM_SCROLL_CANCEL,
+      &animation_settings);
+  // 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.
+  transform_window_->SetOpacity(1.0);
+  transform_window_->SetTransform(window->GetRootWindow(),
+                                  transform_window_->get_overview_transform());
+}
+
 void WindowSelectorItem::WindowListItem::Select() {
   aura::Window* window = transform_window_->window();
   wm::GetWindowState(window)->Activate();
 }
 
 void WindowSelectorItem::WindowListItem::Close() {
   aura::Window* window = transform_window_->window();
   while (::wm::GetTransientParent(window))
     window = ::wm::GetTransientParent(window);
   views::Widget::GetWidgetForNativeView(window)->Close();
@@ skipping 165 matching lines @@
 
   UpdateWindowLabels(target_bounds, root_window, animate);
 
   gfx::Rect inset_bounds(target_bounds);
   inset_bounds.Inset(kWindowMargin, kWindowMargin);
   SetItemBounds(root_window, inset_bounds, animate);
 
   // SetItemBounds is called before UpdateCloseButtonLayout so the close button
   // can properly use the updated windows bounds.
   UpdateCloseButtonLayout(animate);
+  SetCloseWindowDistanceMinimum(target_bounds_.size().width() / 2);
   UpdateSelectorButtons();
 }
 
 void WindowSelectorItem::RecomputeWindowTransforms() {
   if (in_bounds_update_ || target_bounds_.IsEmpty())
     return;
   DCHECK(root_window_);
   base::AutoReset<bool> auto_reset_in_bounds_update(&in_bounds_update_, true);
   gfx::Rect inset_bounds(target_bounds_);
   inset_bounds.Inset(kWindowMargin, kWindowMargin);
@@ skipping 48 matching lines @@
     close_button_widget_.GetNativeWindow()->layer()->SetOpacity(
         window->layer()->GetTargetOpacity());
     // Stack the close button of the moving window on top so that if a user
     // scrolls it over top of another close button and taps them then this one
     // will handle event.
     close_button_widget_.GetNativeWindow()->parent()->StackChildAtTop(
         close_button_widget_.GetNativeWindow());
   }
 }
 
+void WindowSelectorItem::Scroll(int delta_x) {
+  for (WindowList::iterator iter = window_list_.begin();
+       iter != window_list_.end();
+       iter++) {
+    (*iter)->Scroll(delta_x);
+  }
+}
+
+void WindowSelectorItem::CancelScroll() {
+  for (WindowList::iterator iter = window_list_.begin();
+       iter != window_list_.end();
+       iter++) {
+    (*iter)->CancelScroll();
+  }
+}
+
 void WindowSelectorItem::Select() {
   aura::Window* selection_window = SelectionWindow();
   if (selection_window)
     wm::GetWindowState(selection_window)->Activate();
 }
 
+void WindowSelectorItem::Close() {
+  for (WindowList::iterator iter = window_list_.begin();
+       iter != window_list_.end();
+       iter++) {
+    (*iter)->Close();
+  }
+}
+
 void WindowSelectorItem::SetItemBounds(aura::Window* root_window,
                                        const gfx::Rect& target_bounds,
                                        bool animate) {
   gfx::Rect bounding_rect;
   for (WindowList::iterator iter = window_list_.begin();
        iter != window_list_.end();
        ++iter) {
     bounding_rect.Union((*iter)->transform_window()->GetBoundsInScreen());
   }
   set_bounds(
@@ skipping 130 matching lines @@
   window_label_view_->SetText(title);
   views::BoxLayout* layout = new views::BoxLayout(views::BoxLayout::kVertical,
                                                   0,
                                                   kVerticalLabelPadding,
                                                   0);
   window_label_view_->SetLayoutManager(layout);
   window_label_->SetContentsView(window_label_view_);
   window_label_->Show();
 }
 
+void WindowSelectorItem::SetCloseWindowDistanceMinimum(int distance) {
+  selector_item_activate_window_button_->SetCloseWindowDistanceMinimum(
+      distance);
+  for (WindowList::iterator iter = window_list_.begin();
+       iter != window_list_.end();
+       ++iter) {
+    (*iter)->activate_button()->SetCloseWindowDistanceMinimum(distance);
+  }
+}
+
 void WindowSelectorItem::UpdateSelectorButtons() {
   selector_item_activate_window_button_->SetBounds(target_bounds());
 
   if (window_list_.size() == 0) {
     selector_item_activate_window_button_->SetAccessibleName(
         base::EmptyString16());
   } else {
     selector_item_activate_window_button_->SetAccessibleName(
         window_list_.front()->transform_window()->window()->title());
   }
@@ skipping 42 matching lines @@
 void WindowSelectorItem::UpdateCloseButtonAccessibilityName() {
   std::vector<base::string16> name_parts;
   name_parts.push_back(SelectionWindow() ? SelectionWindow()->title()
                                          : base::EmptyString16());
   name_parts.push_back(l10n_util::GetStringUTF16(IDS_APP_CLOSE));
   close_button_->SetAccessibleName(
       JoinString(name_parts, base::ASCIIToUTF16(" - ")));
 }
 
 }  // namespace ash