Gets tab dragging to work in touch mode.

chrome/browser/ui/views/tabs/default_tab_drag_controller.cc

 // Copyright (c) 2012 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 "chrome/browser/ui/views/tabs/default_tab_drag_controller.h"
 
 #include <math.h>
 #include <set>
 
 #include "base/callback.h"
@@ skipping 36 matching lines @@
 #elif defined(OS_WIN)
 #include "chrome/browser/ui/views/tabs/tab_drag_controller2.h"
 #endif
 
 using content::OpenURLParams;
 using content::UserMetricsAction;
 using content::WebContents;
 
 static const int kHorizontalMoveThreshold = 16;  // Pixels.
 
+// Distance from the next/previous stacked before before we consider the tab
+// close enough to trigger moving.
+static const int kStackedDistance = 36;
+
 // If non-null there is a drag underway.
 static DefaultTabDragController* instance_ = NULL;
 
 namespace {
 
 // Delay, in ms, during dragging before we bring a window to front.
 const int kBringToFrontDelay = 750;
 
+// Initial delay before moving tabs when the dragged tab is close to the edge of
+// the stacked tabs.
+const int kMoveAttachedInitialDelay = 600;
+
+// Delay for moving tabs after the initial delay has passed.
+const int kMoveAttachedSubsequentDelay = 300;
+
 // Radius of the rect drawn by DockView.
 const int kRoundedRectRadius = 4;
 
 // Spacing between tab icons when DockView is showing a docking location that
 // contains more than one tab.
 const int kTabSpacing = 4;
 
 // DockView is the view responsible for giving a visual indicator of where a
 // dock is going to occur.
 
@@ skipping 94 matching lines @@
     SkPaint paint;
     paint.setAlpha(128);
     canvas->DrawBitmapInt(image, x, y, paint);
   }
 
   DockInfo::Type type_;
 
   DISALLOW_COPY_AND_ASSIGN(DockView);
 };
 
-// Returns the the x-coordinate of |point| if the type of tabstrip is horizontal
+// Returns the x-coordinate of |point| if the type of tabstrip is horizontal
 // otherwise returns the y-coordinate.
 int MajorAxisValue(const gfx::Point& point, TabStrip* tabstrip) {
   return point.x();
 }
 
 }  // namespace
 
 ///////////////////////////////////////////////////////////////////////////////
 // DockDisplayer
 
@@ skipping 124 matching lines @@
     : source_tabstrip_(NULL),
       attached_tabstrip_(NULL),
       source_tab_offset_(0),
       offset_to_width_ratio_(0),
       old_focused_view_(NULL),
       last_move_screen_loc_(0),
       started_drag_(false),
       active_(true),
       source_tab_index_(std::numeric_limits<size_t>::max()),
       initial_move_(true),
-      move_only_(false) {
+      move_only_(false),
+      mouse_move_direction_(0) {
   instance_ = this;
 }
 
 DefaultTabDragController::~DefaultTabDragController() {
   if (instance_ == this)
     instance_ = NULL;
 
   MessageLoopForUI::current()->RemoveObserver(this);
 
   // Need to delete the view here manually _before_ we reset the dragged
@@ skipping 15 matching lines @@
     int source_tab_offset,
     const TabStripSelectionModel& initial_selection_model,
     bool move_only) {
   DCHECK(!tabs.empty());
   DCHECK(std::find(tabs.begin(), tabs.end(), source_tab) != tabs.end());
   source_tabstrip_ = source_tabstrip;
   source_tab_offset_ = source_tab_offset;
   start_screen_point_ = GetCursorScreenPoint();
   mouse_offset_ = mouse_offset;
   move_only_ = move_only;
+  last_screen_point_ = start_screen_point_;
 
   if (move_only_) {
     last_move_screen_loc_ =
         MajorAxisValue(start_screen_point_, attached_tabstrip_);
     initial_tab_positions_ = source_tabstrip->GetTabXCoordinates();
   }
 
   drag_data_.resize(tabs.size());
   for (size_t i = 0; i < tabs.size(); ++i)
     InitTabDragData(tabs[i], &(drag_data_[i]));
@@ skipping 26 matching lines @@
   // We need to be the delegate so we receive messages about stuff, otherwise
   // our dragged WebContents may be replaced and subsequently
   // collected/destroyed while the drag is in process, leading to nasty crashes.
   drag_data->original_delegate =
       drag_data->contents->web_contents()->GetDelegate();
   drag_data->contents->web_contents()->SetDelegate(this);
 }
 
 void DefaultTabDragController::Drag() {
   bring_to_front_timer_.Stop();
+  move_stacked_timer_.Stop();
 
   if (!started_drag_) {
     if (!CanStartDrag())
       return;  // User hasn't dragged far enough yet.
 
     started_drag_ = true;
     SaveFocus();
     Attach(source_tabstrip_, gfx::Point());
     // Redirect all mouse events to the TabStrip so that the tab that
     // originated the drag can safely be deleted.
@@ skipping 256 matching lines @@
   if (!target_tabstrip) {
     bring_to_front_timer_.Start(FROM_HERE,
         base::TimeDelta::FromMilliseconds(kBringToFrontDelay), this,
         &DefaultTabDragController::BringWindowUnderMouseToFront);
   }
 
   UpdateDockInfo(screen_point);
 
   if (attached_tabstrip_) {
     if (move_only_)
-      MoveAttachedStacked(screen_point);
+      DragActiveTabStacked(screen_point);
     else
       MoveAttached(screen_point);
   } else {
     MoveDetached(screen_point);
   }
 }
 
-void DefaultTabDragController::MoveAttachedStacked(
+void DefaultTabDragController::DragActiveTabStacked(
     const gfx::Point& screen_point) {
   if (attached_tabstrip_->tab_count() !=
       static_cast<int>(initial_tab_positions_.size()))
     return;  // TODO: should cancel drag if this happens.
 
   int delta = screen_point.x() - start_screen_point_.x();
   attached_tabstrip_->DragActiveTab(initial_tab_positions_, delta);
 }
 
+void DefaultTabDragController::MoveAttachedToNextStackedIndex() {
+  int index = attached_tabstrip_->touch_layout_->active_index();
+  if (index + 1 >= attached_tabstrip_->tab_count())
+    return;
+
+  GetModel(attached_tabstrip_)->MoveSelectedTabsTo(index + 1);
+  StartMoveStackedTimerIfNecessary(kMoveAttachedSubsequentDelay);
+}
+
+void DefaultTabDragController::MoveAttachedToPreviousStackedIndex() {
+  int index = attached_tabstrip_->touch_layout_->active_index();
+  if (index <= attached_tabstrip_->GetMiniTabCount())
+    return;
+
+  GetModel(attached_tabstrip_)->MoveSelectedTabsTo(index - 1);
+  StartMoveStackedTimerIfNecessary(kMoveAttachedSubsequentDelay);
+}
+
 void DefaultTabDragController::MoveAttached(const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);
   DCHECK(!view_.get());
 
+  int move_delta = screen_point.x() - last_screen_point_.x();
+  if (move_delta > 0)
+    mouse_move_direction_ |= kMovedMouseRight;
+  else if (move_delta < 0)
+    mouse_move_direction_ |= kMovedMouseLeft;
+  last_screen_point_ = screen_point;
+
   gfx::Point dragged_view_point = GetAttachedDragPoint(screen_point);
 
-  TabStrip* tab_strip = static_cast<TabStrip*>(attached_tabstrip_);
-
   // Determine the horizontal move threshold. This is dependent on the width
   // of tabs. The smaller the tabs compared to the standard size, the smaller
   // the threshold.
-  double unselected, selected;
-  tab_strip->GetCurrentTabWidths(&unselected, &selected);
-  double ratio = unselected / Tab::GetStandardSize().width();
-  int threshold = static_cast<int>(ratio * kHorizontalMoveThreshold);
+  int threshold = kHorizontalMoveThreshold;
+  if (!attached_tabstrip_->touch_layout_.get()) {
+    double unselected, selected;
+    attached_tabstrip_->GetCurrentTabWidths(&unselected, &selected);
+    double ratio = unselected / Tab::GetStandardSize().width();
+    threshold = static_cast<int>(ratio * kHorizontalMoveThreshold);
+  }
+  // else case: touch tabs never shrink.
 
   std::vector<BaseTab*> tabs(drag_data_.size());
   for (size_t i = 0; i < drag_data_.size(); ++i)
     tabs[i] = drag_data_[i].attached_tab;
 
   bool did_layout = false;
   // Update the model, moving the WebContents from one index to another. Do this
   // only if we have moved a minimum distance since the last reorder (to prevent
   // jitter) or if this the first move and the tabs are not consecutive.
   if ((abs(MajorAxisValue(screen_point, attached_tabstrip_) -
           last_move_screen_loc_) > threshold ||
         (initial_move_ && !AreTabsConsecutive()))) {
     TabStripModel* attached_model = GetModel(attached_tabstrip_);
     gfx::Rect bounds = GetDraggedViewTabStripBounds(dragged_view_point);
     int to_index = GetInsertionIndexForDraggedBounds(bounds);
     TabContentsWrapper* last_contents =
         drag_data_[drag_data_.size() - 1].contents;
     int index_of_last_item =
           attached_model->GetIndexOfTabContents(last_contents);
     if (initial_move_) {
       // TabStrip determines if the tabs needs to be animated based on model
       // position. This means we need to invoke LayoutDraggedTabsAt before
       // changing the model.
       attached_tabstrip_->LayoutDraggedTabsAt(
           tabs, source_tab_drag_data()->attached_tab, dragged_view_point,
           initial_move_);
       did_layout = true;
     }
     attached_model->MoveSelectedTabsTo(to_index);
+
     // Move may do nothing in certain situations (such as when dragging pinned
     // tabs). Make sure the tabstrip actually changed before updating
     // last_move_screen_loc_.
     if (index_of_last_item !=
         attached_model->GetIndexOfTabContents(last_contents)) {
       last_move_screen_loc_ = MajorAxisValue(screen_point, attached_tabstrip_);
     }
   }
 
   if (!did_layout) {
     attached_tabstrip_->LayoutDraggedTabsAt(
         tabs, source_tab_drag_data()->attached_tab, dragged_view_point,
         initial_move_);
   }
 
+  StartMoveStackedTimerIfNecessary(kMoveAttachedInitialDelay);
+
   initial_move_ = false;
 }
 
 void DefaultTabDragController::MoveDetached(const gfx::Point& screen_point) {
   DCHECK(!attached_tabstrip_);
   DCHECK(view_.get());
 
   // Move the View. There are no changes to the model if we're detached.
   view_->MoveTo(screen_point);
 }
 
+void DefaultTabDragController::StartMoveStackedTimerIfNecessary(int delay_ms) {
+  DCHECK(attached_tabstrip_);
+
+  TouchTabStripLayout* touch_layout = attached_tabstrip_->touch_layout_.get();
+  if (!touch_layout)
+    return;
+
+  gfx::Point screen_point = GetCursorScreenPoint();
+  gfx::Point dragged_view_point = GetAttachedDragPoint(screen_point);
+  gfx::Rect bounds = GetDraggedViewTabStripBounds(dragged_view_point);
+  int index = touch_layout->active_index();
+  if (ShouldDragToNextStackedTab(bounds, index)) {
+    move_stacked_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(delay_ms), this,
+        &DefaultTabDragController::MoveAttachedToNextStackedIndex);
+  } else if (ShouldDragToPreviousStackedTab(bounds, index)) {
+    move_stacked_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(delay_ms), this,
+        &DefaultTabDragController::MoveAttachedToPreviousStackedIndex);
+  }
+}
+
 DockInfo DefaultTabDragController::GetDockInfoAtPoint(
     const gfx::Point& screen_point) {
   if (attached_tabstrip_) {
     // If the mouse is over a tab strip, don't offer a dock position.
     return DockInfo();
   }
 
   if (dock_info_.IsValidForPoint(screen_point)) {
     // It's possible any given screen coordinate has multiple docking
     // positions. Check the current info first to avoid having the docking
@@ skipping 100 matching lines @@
     gfx::Point tab_strip_point(screen_point);
     views::View::ConvertPointToView(NULL, attached_tabstrip_, &tab_strip_point);
     tab_strip_point.set_x(
         attached_tabstrip_->GetMirroredXInView(tab_strip_point.x()));
     tab_strip_point.Offset(-mouse_offset_.x(), -mouse_offset_.y());
     gfx::Rect bounds = GetDraggedViewTabStripBounds(tab_strip_point);
     int index = GetInsertionIndexForDraggedBounds(bounds);
     attached_tabstrip_->set_attaching_dragged_tab(true);
     for (size_t i = 0; i < drag_data_.size(); ++i) {
       int add_types = TabStripModel::ADD_NONE;
+      if (attached_tabstrip_->touch_layout_.get()) {
+        // TouchTabStripLayout positions relative to the active tab, if we don't
+        // add the tab as active things bounce around.
+        DCHECK_EQ(1u, drag_data_.size());
+        add_types |= TabStripModel::ADD_ACTIVE;
+      }
       if (drag_data_[i].pinned)
         add_types |= TabStripModel::ADD_PINNED;
       GetModel(attached_tabstrip_)->InsertTabContentsAt(
           index + i, drag_data_[i].contents, add_types);
     }
     attached_tabstrip_->set_attaching_dragged_tab(false);
 
     tabs = GetTabsMatchingDraggedContents(attached_tabstrip_);
   }
   DCHECK_EQ(tabs.size(), drag_data_.size());
@@ skipping 13 matching lines @@
       tabs[source_tab_index_]->width() +
       static_cast<int>(offset_to_width_ratio_ *
                        tabs[source_tab_index_]->width());
   mouse_offset_.set_x(new_x);
 
   // Move the corresponding window to the front.
   attached_tabstrip_->GetWidget()->Activate();
 }
 
 void DefaultTabDragController::Detach() {
+  mouse_move_direction_ = kMovedMouseLeft | kMovedMouseRight;
+
   // Prevent the WebContents HWND from being hidden by any of the model
   // operations performed during the drag.
   source_dragged_contents()->web_contents()->SetCapturingContents(true);
 
   // Calculate the drag bounds.
   std::vector<gfx::Rect> drag_bounds;
   std::vector<BaseTab*> attached_tabs;
   for (size_t i = 0; i < drag_data_.size(); ++i)
     attached_tabs.push_back(drag_data_[i].attached_tab);
   attached_tabstrip_->CalculateBoundsForDraggedTabs(attached_tabs,
@@ skipping 45 matching lines @@
       attached_model->SetSelectionFromModel(selection_model);
   }
 
   // Create the dragged view.
   CreateDraggedView(tab_data, drag_bounds);
 
   attached_tabstrip_->DraggedTabsDetached();
   attached_tabstrip_ = NULL;
 }
 
+int DefaultTabDragController::GetInsertionIndexFrom(
+    const gfx::Rect& dragged_bounds,
+    int start,
+    int delta) const {
+  for (int i = start, tab_count = attached_tabstrip_->tab_count();
+       i >= 0 && i < tab_count; i += delta) {
+    const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
+    gfx::Rect left_half, right_half;
+    ideal_bounds.SplitVertically(&left_half, &right_half);
+    if (dragged_bounds.x() >= right_half.x() &&
+        dragged_bounds.x() < right_half.right()) {
+      return i + 1;
+    } else if (dragged_bounds.x() >= left_half.x() &&
+               dragged_bounds.x() < left_half.right()) {
+      return i;
+    }
+  }
+  return -1;
+}
+
 int DefaultTabDragController::GetInsertionIndexForDraggedBounds(
     const gfx::Rect& dragged_bounds) const {
-  int right_tab_x = 0;
   int index = -1;
-  for (int i = 0; i < attached_tabstrip_->tab_count(); ++i) {
-    const gfx::Rect& ideal_bounds = attached_tabstrip_->ideal_bounds(i);
-    gfx::Rect left_half, right_half;
-    ideal_bounds.SplitVertically(&left_half, &right_half);
-    right_tab_x = right_half.right();
-    if (dragged_bounds.x() >= right_half.x() &&
-        dragged_bounds.x() < right_half.right()) {
-      index = i + 1;
-      break;
-    } else if (dragged_bounds.x() >= left_half.x() &&
-               dragged_bounds.x() < left_half.right()) {
-      index = i;
-      break;
+  if (attached_tabstrip_->touch_layout_.get()) {
+    index = GetInsertionIndexForDraggedBoundsStacked(dragged_bounds);
+    if (index != -1) {
+      // Only move the tab to the left/right if the user actually moved the
+      // mouse that way. This is necessary as tabs with stacked tabs
+      // before/after them have multiple drag positions.
+      int active_index = attached_tabstrip_->touch_layout_->active_index();
+      if ((index < active_index &&
+           (mouse_move_direction_ & kMovedMouseLeft) == 0) ||
+          (index > active_index &&
+           (mouse_move_direction_ & kMovedMouseRight) == 0)) {
+        index = active_index;
+      }
     }
+  } else {
+    index = GetInsertionIndexFrom(dragged_bounds, 0, 1);
   }
   if (index == -1) {
+    int tab_count = attached_tabstrip_->tab_count();
+    int right_tab_x = tab_count == 0 ? 0 :
+        attached_tabstrip_->ideal_bounds(tab_count - 1).right();
     if (dragged_bounds.right() > right_tab_x) {
       index = GetModel(attached_tabstrip_)->count();
     } else {
       index = 0;
     }
   }
 
   if (!drag_data_[0].attached_tab) {
     // If 'attached_tab' is NULL, it means we're in the process of attaching and
     // don't need to constrain the index.
     return index;
   }
 
   int max_index = GetModel(attached_tabstrip_)->count() -
       static_cast<int>(drag_data_.size());
   return std::max(0, std::min(max_index, index));
 }
 
+bool DefaultTabDragController::ShouldDragToNextStackedTab(
+    const gfx::Rect& dragged_bounds,
+    int index) const {
+  if (index + 1 >= attached_tabstrip_->tab_count() ||
+      !attached_tabstrip_->touch_layout_->IsStacked(index + 1) ||
+      (mouse_move_direction_ & kMovedMouseRight) == 0)
+    return false;
+
+  int active_x = attached_tabstrip_->ideal_bounds(index).x();
+  int next_x = attached_tabstrip_->ideal_bounds(index + 1).x();
+  int mid_x = std::min(next_x - kStackedDistance,
+                       active_x + (next_x - active_x) / 4);
+  return dragged_bounds.x() >= mid_x;
+}
+
+bool DefaultTabDragController::ShouldDragToPreviousStackedTab(
+    const gfx::Rect& dragged_bounds,
+    int index) const {
+  if (index - 1 < attached_tabstrip_->GetMiniTabCount() ||
+      !attached_tabstrip_->touch_layout_->IsStacked(index - 1) ||
+      (mouse_move_direction_ & kMovedMouseLeft) == 0)
+    return false;
+
+  int active_x = attached_tabstrip_->ideal_bounds(index).x();
+  int previous_x = attached_tabstrip_->ideal_bounds(index - 1).x();
+  int mid_x = std::max(previous_x + kStackedDistance,
+                       active_x - (active_x - previous_x) / 4);
+  return dragged_bounds.x() <= mid_x;
+}
+
+int DefaultTabDragController::GetInsertionIndexForDraggedBoundsStacked(
+    const gfx::Rect& dragged_bounds) const {
+  TouchTabStripLayout* touch_layout = attached_tabstrip_->touch_layout_.get();
+  int active_index = touch_layout->active_index();
+  // Search from the active index to the front of the tabstrip. Do this as tabs
+  // overlap each other from the active index.
+  int index = GetInsertionIndexFrom(dragged_bounds, active_index, -1);
+  if (index != active_index)
+    return index;
+  if (index == -1)
+    return GetInsertionIndexFrom(dragged_bounds, active_index + 1, 1);
+
+  // The position to drag to corresponds to the active tab. If the next/previous
+  // tab is stacked, then shorten the distance used to determine insertion
+  // bounds. We do this as GetInsertionIndexFrom() uses the bounds of the
+  // tabs. When tabs are stacked the next/previous tab is on top of the tab.
+  if (active_index + 1 < attached_tabstrip_->tab_count() &&
+      touch_layout->IsStacked(active_index + 1)) {
+    index = GetInsertionIndexFrom(dragged_bounds, active_index + 1, 1);
+    if (index == -1 && ShouldDragToNextStackedTab(dragged_bounds, active_index))
+      index = active_index + 1;
+    else if (index == -1)
+      index = active_index;
+  } else if (ShouldDragToPreviousStackedTab(dragged_bounds, active_index)) {
+    index = active_index - 1;
+  }
+  return index;
+}
+
 gfx::Rect DefaultTabDragController::GetDraggedViewTabStripBounds(
     const gfx::Point& tab_strip_point) {
   // attached_tab is NULL when inserting into a new tabstrip.
   if (source_tab_drag_data()->attached_tab) {
     return gfx::Rect(tab_strip_point.x(), tab_strip_point.y(),
                      source_tab_drag_data()->attached_tab->width(),
                      source_tab_drag_data()->attached_tab->height());
   }
 
   double sel_width, unselected_width;
   static_cast<TabStrip*>(attached_tabstrip_)->GetCurrentTabWidths(
       &sel_width, &unselected_width);
   return gfx::Rect(tab_strip_point.x(), tab_strip_point.y(),
                    static_cast<int>(sel_width),
                    Tab::GetStandardSize().height());
 }
 
 gfx::Point DefaultTabDragController::GetAttachedDragPoint(
     const gfx::Point& screen_point) {
   DCHECK(attached_tabstrip_);  // The tab must be attached.
 
   gfx::Point tab_loc(screen_point);
   views::View::ConvertPointToView(NULL, attached_tabstrip_, &tab_loc);
   int x =
       attached_tabstrip_->GetMirroredXInView(tab_loc.x()) - mouse_offset_.x();
-  int y = tab_loc.y() - mouse_offset_.y();
 
   // TODO: consider caching this.
   std::vector<BaseTab*> attached_tabs;
   for (size_t i = 0; i < drag_data_.size(); ++i)
     attached_tabs.push_back(drag_data_[i].attached_tab);
-
   int size = attached_tabstrip_->GetSizeNeededForTabs(attached_tabs);
-
   int max_x = attached_tabstrip_->width() - size;
-  x = std::min(std::max(x, 0), max_x);
-  y = 0;
-  return gfx::Point(x, y);
+  return gfx::Point(std::min(std::max(x, 0), max_x), 0);
 }
 
 std::vector<BaseTab*> DefaultTabDragController::GetTabsMatchingDraggedContents(
     TabStrip* tabstrip) {
   TabStripModel* model = GetModel(attached_tabstrip_);
   std::vector<BaseTab*> tabs;
   for (size_t i = 0; i < drag_data_.size(); ++i) {
     int model_index = model->GetIndexOfTabContents(drag_data_[i].contents);
     if (model_index == TabStripModel::kNoTab)
       return std::vector<BaseTab*>();
     tabs.push_back(tabstrip->tab_at(model_index));
   }
   return tabs;
 }
 
 void DefaultTabDragController::EndDragImpl(EndDragType type) {
   active_ = false;
 
   bring_to_front_timer_.Stop();
+  move_stacked_timer_.Stop();
 
   // Hide the current dock controllers.
   for (size_t i = 0; i < dock_controllers_.size(); ++i) {
     // Be sure and clear the controller first, that way if Hide ends up
     // deleting the controller it won't call us back.
     dock_controllers_[i]->clear_controller();
     dock_controllers_[i]->Hide();
   }
   dock_controllers_.clear();
   dock_windows_.clear();
@@ skipping 396 matching lines @@
 }
 
 // static
 bool TabDragController::IsActive() {
 #if defined(USE_AURA) || defined(OS_WIN)
   return TabDragController2::IsActive() || (instance_ && instance_->active());
 #else
   return instance_ && instance_->active();
 #endif
 }