Views: Extract text selection code from Textfield.

ui/views/selection_controller.cc

+// Copyright 2016 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/selection_controller.h"
+
+#include <algorithm>
+
+#include "ui/events/event.h"
+#include "ui/gfx/render_text.h"
+#include "ui/views/metrics.h"
+#include "ui/views/style/platform_style.h"
+#include "ui/views/view.h"
+
+namespace views {
+
+SelectionController::SelectionController(Delegate* delegate)
+    : aggregated_clicks_(0), delegate_(delegate) {
+  CHECK(delegate);
+}
+
+bool SelectionController::OnMousePressed(const ui::MouseEvent& event,
+                                         bool handled) {
+  TrackMouseClicks(event);
+
+  if (!GetRenderText() || handled)
+    return handled;
+
+  if (event.IsOnlyLeftMouseButton()) {
+    delegate_->OnBeforeMouseAction();
+    bool selection_changed = false;
+    delegate_->SetTextBeingDragged(false);
+    switch (aggregated_clicks_) {
+      case 0:
+        // If the click location is within existing selection, it may be a
+        // potential drag and drop.
+        if (GetRenderText()->IsPointInSelection(event.location())) {
+          delegate_->SetTextBeingDragged(true);
+        } else {
+          MoveCursorTo(event.location(), event.IsShiftDown());
+          selection_changed = true;
+        }
+        break;
+      case 1:
+        // Select the word at the click location on a double click.
+        SelectWordAt(event.location());
+        selection_changed = true;
+        double_click_word_ = GetRenderText()->selection();
+        break;
+      case 2:
+        // Select all the text on a triple click.
+        SelectAll(false);
+        selection_changed = true;
+        break;
+      default:
+        NOTREACHED();
+    }
+    delegate_->OnAfterMouseAction(false, selection_changed);
+  }
+
+// On Linux, middle click should update or paste the selection clipboard.
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  if (event.IsOnlyMiddleMouseButton()) {
+    delegate_->OnBeforeMouseAction();
+    bool text_changed = false;
+    bool selection_changed = false;
+    if (GetRenderText()->IsPointInSelection(event.location())) {
+      ClearSelection();
+      delegate_->UpdateSelectionClipboard();
+      selection_changed = true;
+    } else if (!delegate_->IsReadOnly()) {
+      delegate_->PasteSelectionClipboard(event);
+      selection_changed = text_changed = true;
+    }
+    delegate_->OnAfterMouseAction(text_changed, selection_changed);
+  }
+#endif
+
+  return true;
+}
+
+bool SelectionController::OnMouseDragged(const ui::MouseEvent& event) {
+  // If |drag_selection_timer_| is running, |last_drag_location_| will be used
+  // to update the selection.
+  last_drag_location_ = event.location();
+
+  if (!GetRenderText())
+    return false;
+
+  // Don't adjust the cursor on a potential drag and drop.
+  if (delegate_->HasTextBeingDragged() || !event.IsOnlyLeftMouseButton())
+    return true;
+
+  // A timer is used to continuously scroll while selecting beyond side edges.
+  const int x = event.location().x();
+  if ((x >= 0 && x <= delegate_->GetViewWidth()) ||
+      delegate_->GetDragSelectionDelay() == 0) {
+    drag_selection_timer_.Stop();
+    SelectThroughLastDragLocation();
+  } else if (!drag_selection_timer_.IsRunning()) {
+    // Select through the edge of the visible text, then start the scroll timer.
+    last_drag_location_.set_x(
+        std::min(std::max(0, x), delegate_->GetViewWidth()));

[msw, 2016/10/14 18:54:20]

optional nit: cache delegate_->GetViewWidth()

[karandeepb, 2016/10/17 07:08:15]

Done.

+    SelectThroughLastDragLocation();
+
+    // Todo what happens when this object is destroyed before timer is invoked

[msw, 2016/10/14 18:54:20]

The timer dtor should suffice, right? Remove/Address comment.

[karandeepb, 2016/10/17 07:08:15]

Done.

+    // but it's scheduled?
+    drag_selection_timer_.Start(
+        FROM_HERE,
+        base::TimeDelta::FromMilliseconds(delegate_->GetDragSelectionDelay()),
+        this, &SelectionController::SelectThroughLastDragLocation);
+  }
+
+  return true;
+}
+
+void SelectionController::OnMouseReleased(const ui::MouseEvent& event) {
+  if(!GetRenderText())
+    return;
+
+  delegate_->OnBeforeMouseAction();
+  drag_selection_timer_.Stop();
+
+  bool selection_changed = false;
+
+  // Cancel suspected drag initiations, the user was clicking in the selection.
+  if (delegate_->HasTextBeingDragged()) {
+    selection_changed = true;
+    MoveCursorTo(event.location(), false);
+  }
+  delegate_->SetTextBeingDragged(false);
+  delegate_->UpdateSelectionClipboard();
+  delegate_->OnAfterMouseAction(false, selection_changed);
+}
+
+void SelectionController::SelectAll(bool reversed) {
+  delegate_->OnBeforeSelectionUpdated();
+  GetRenderText()->SelectAll(reversed);
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::SelectWordAt(const gfx::Point& point) {
+  delegate_->OnBeforeSelectionUpdated();
+  gfx::RenderText* render_text = GetRenderText();
+  render_text->MoveCursorTo(point, false);
+  render_text->SelectWord();
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::SelectWord() {
+  delegate_->OnBeforeSelectionUpdated();
+  GetRenderText()->SelectWord();
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::SelectRange(const gfx::Range& range) {
+  delegate_->OnBeforeSelectionUpdated();
+  GetRenderText()->SelectRange(range);
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::MoveCursorTo(const gfx::Point& point, bool select) {
+  delegate_->OnBeforeSelectionUpdated();
+  GetRenderText()->MoveCursorTo(point, select);
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::ClearSelection() {
+  delegate_->OnBeforeSelectionUpdated();
+  GetRenderText()->ClearSelection();
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::SelectTillEdge(gfx::VisualCursorDirection direction) {
+  delegate_->OnBeforeSelectionUpdated();
+  GetRenderText()->MoveCursor(gfx::LINE_BREAK, direction,
+                              gfx::SELECTION_RETAIN);
+  delegate_->OnAfterSelectionUpdated();
+}
+
+void SelectionController::TrackMouseClicks(const ui::MouseEvent& event) {
+  if (event.IsOnlyLeftMouseButton()) {
+    base::TimeDelta time_delta = event.time_stamp() - last_click_time_;
+    if (!last_click_time_.is_null() &&
+        time_delta.InMilliseconds() <= GetDoubleClickInterval() &&
+        !View::ExceededDragThreshold(event.location() - last_click_location_)) {
+      // Upon clicking after a triple click, the count should go back to
+      // double click and alternate between double and triple. This assignment
+      // maps 0 to 1, 1 to 2, 2 to 1.
+      aggregated_clicks_ = (aggregated_clicks_ % 2) + 1;
+    } else {
+      aggregated_clicks_ = 0;
+    }
+    last_click_time_ = event.time_stamp();
+    last_click_location_ = event.location();
+  }
+}
+
+gfx::RenderText* SelectionController::GetRenderText() {
+  return delegate_->GetRenderTextForSelection();
+}
+
+void SelectionController::SelectThroughLastDragLocation() {
+  delegate_->OnBeforeMouseAction();
+
+  // Todo(karandeepb): See if this can be handled at the RenderText level.

[msw, 2016/10/14 18:54:20]

nit: use TODO, unless this capitalization is also a common chromium style for
TODO comments.

[karandeepb, 2016/10/17 07:08:15]

Done.

+  const bool drags_to_end = PlatformStyle::kTextfieldDragVerticallyDragsToEnd;
+  if (drags_to_end && last_drag_location_.y() < 0)
+    SelectTillEdge(gfx::CURSOR_LEFT);
+  else if (drags_to_end && last_drag_location_.y() > delegate_->GetViewHeight())
+    SelectTillEdge(gfx::CURSOR_RIGHT);
+  else
+    MoveCursorTo(last_drag_location_, true);
+
+  if (aggregated_clicks_ == 1) {
+    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);
+    SelectRange(selection);
+  }
+  delegate_->OnAfterMouseAction(false, true);
+}
+
+}  // namespace views