Make Textfield scroll continuously when dragging beyond edges.

ui/views/controls/textfield/textfield.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 "ui/views/controls/textfield/textfield.h"
 
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "grit/ui_strings.h"
@@ skipping 294 matching lines @@
     return;
   model_->InsertText(new_text);
   OnCaretBoundsChanged();
   SchedulePaint();
 }
 
 base::i18n::TextDirection Textfield::GetTextDirection() const {
   return GetRenderText()->GetTextDirection();
 }
 
+base::string16 Textfield::GetSelectedText() const {
+  return model_->GetSelectedText();
+}
+
 void Textfield::SelectAll(bool reversed) {
   model_->SelectAll(reversed);
   UpdateSelectionClipboard();
   UpdateAfterChange(false, true);
 }
 
-base::string16 Textfield::GetSelectedText() const {
-  return model_->GetSelectedText();
-}
-
 void Textfield::ClearSelection() {
   model_->ClearSelection();
   UpdateAfterChange(false, true);
 }
 
 bool Textfield::HasSelection() const {
   return !GetSelectedRange().is_empty();
 }
 
 SkColor Textfield::GetTextColor() const {
@@ skipping 210 matching lines @@
         PasteSelectionClipboard(event);
       }
     }
 #endif
   }
 
   return true;
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
+  last_drag_location_ = event.location();
+
   // Don't adjust the cursor on a potential drag and drop, or if the mouse
   // movement from the last mouse click does not exceed the drag threshold.
   if (initiating_drag_ || !event.IsOnlyLeftMouseButton() ||
-      !ExceededDragThreshold(event.location() - last_click_location_)) {
+      !ExceededDragThreshold(last_drag_location_ - last_click_location_)) {
     return true;
   }
 
-  OnBeforeUserAction();
-  model_->MoveCursorTo(event.location(), true);
-  if (aggregated_clicks_ == 1) {
-    model_->SelectWord();
-    // Expand the selection so the initially selected word remains selected.
-    gfx::Range selection = GetRenderText()->selection();
-    const size_t min = std::min(selection.GetMin(),
-                                double_click_word_.GetMin());
-    const size_t max = std::max(selection.GetMax(),
-                                double_click_word_.GetMax());
-    const bool reversed = selection.is_reversed();
-    selection.set_start(reversed ? max : min);
-    selection.set_end(reversed ? min : max);
-    model_->SelectRange(selection);
+  // A timer is used to continuously scroll while selecting beyond side edges.
+  if (last_drag_location_.x() > 0 && last_drag_location_.x() < size().width()) {
+    drag_selection_timer_.Stop();
+    SelectThroughLastDragLocation();
+  } else if (!drag_selection_timer_.IsRunning()) {
+    drag_selection_timer_.Start(
+        FROM_HERE, base::TimeDelta::FromMilliseconds(100), this,
+        &Textfield::SelectThroughLastDragLocation);
   }
-  UpdateAfterChange(false, true);
-  OnAfterUserAction();
+
   return true;
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
   OnBeforeUserAction();
+  drag_selection_timer_.Stop();
   // Cancel suspected drag initiations, the user was clicking in the selection.
   if (initiating_drag_)
     MoveCursorTo(event.location(), false);
   initiating_drag_ = false;
   UpdateSelectionClipboard();
   OnAfterUserAction();
 }
 
 bool Textfield::OnKeyPressed(const ui::KeyEvent& event) {
   bool handled = controller_ && controller_->HandleKeyEvent(this, event);
@@ skipping 941 matching lines @@
     render_text->DrawCursor(canvas, drop_cursor_position_);
 
   canvas->Restore();
 }
 
 void Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
   if (model_->MoveCursorTo(point, select))
     UpdateAfterChange(false, true);
 }
 
+void Textfield::SelectThroughLastDragLocation() {
+  OnBeforeUserAction();
+  model_->MoveCursorTo(last_drag_location_, true);

[Peter Kasting, 2014/05/21 22:44:28]

How does this work with off-Textfield cursor locations?  Does it pretend the
textfield is infinitely wide, and then select to "where the mouse would be"?  If
so, doesn't this mean that the further off the side the user places the mouse
cursor, the more text will be selected on every timer tick?

It seems like, ideally, we'd have a high-framerate (60 Hz) animation that
scrolled-in-and-selected a small amount of new text each frame, regardless of
how far off the side the mouse cursor is.

[msw, 2014/05/21 23:15:10]

Yes, that's how it works currently, and I think it's reasonable. That's how
Blink and Mac/Win/GTK native textfields work, except that for some of those
(like the Win native textfield), the selection is updated on drag events, and
not on a regularly occurring timer.
I agree that we ultimately want a smoother animation, but think we'd want to
increase the rate of scrolling as the user moves the mouse further beyond the
edge (providing the same correlation as Blink and Mac/Win/GTK native textfields
and this behavior I'm adding).

However, the smoother animation would require non-trivial changes to RenderText
and Textfield (we'd need to update the display offset disjoint from the cursor
position), which might open a bigger can of worms. I think the current behavior
is straightforward and a good V1 compromise, and I'll leave the bug open for
animation smoothing.

+  if (aggregated_clicks_ == 1) {
+    model_->SelectWord();
+    // Expand the selection so the initially selected word remains selected.
+    gfx::Range selection = GetRenderText()->selection();
+    const size_t min = std::min(selection.GetMin(),
+                                double_click_word_.GetMin());
+    const size_t max = std::max(selection.GetMax(),
+                                double_click_word_.GetMax());
+    const bool reversed = selection.is_reversed();
+    selection.set_start(reversed ? max : min);
+    selection.set_end(reversed ? min : max);
+    model_->SelectRange(selection);
+  }
+  UpdateAfterChange(false, true);
+  OnAfterUserAction();
+}
+
 void Textfield::OnCaretBoundsChanged() {
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);
   if (touch_selection_controller_)
     touch_selection_controller_->SelectionChanged();
 }
 
 void Textfield::OnBeforeUserAction() {
   DCHECK(!performing_user_action_);
   performing_user_action_ = true;
@@ skipping 126 matching lines @@
       const size_t length = selection_clipboard_text.length();
       range = gfx::Range(range.start() + length, range.end() + length);
     }
     model_->MoveCursorTo(gfx::SelectionModel(range, affinity));
     UpdateAfterChange(true, true);
     OnAfterUserAction();
   }
 }
 
 }  // namespace views