Views:: Make Labels support text selection.

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"
@@ skipping 14 matching lines @@
 bool SelectionController::OnMousePressed(const ui::MouseEvent& event,
                                          bool handled) {
   gfx::RenderText* render_text = GetRenderText();
   DCHECK(render_text);
 
   TrackMouseClicks(event);
   if (handled)
     return true;
 
   if (event.IsOnlyLeftMouseButton()) {
-    delegate_->SetTextBeingDragged(false);
+    if (delegate_->SupportsDrag())

[msw, 2016/10/28 06:30:26]

Is this just disabling something that otherwise works or is it entirely not
supported by Labels (and would require non-trivial work to support)? If it's the
former, let's remove the flag and support dragging selected text from labels to
be dropped elsewhere; if it's the latter, then this is fine for now, but we
might want to investigate adding support later (maybe file/cite a bug?).

[karandeepb, 2016/11/01 11:06:25]

To support dragging selected text, Labels would need to implement
DragController. Have added a TODO to Label::SupportsDrag.

The implementation would be almost similar to the Textfield one. It seems that
as you suggested, Textfield and Label can share more code by being in the same
class hierarchy. But again, probably the Label implementation can be simplified
first. 

Will put up a CL subsequently duplicating some of the code in Textfield for
dragging selected text.

+      delegate_->SetTextBeingDragged(false);
+
     switch (aggregated_clicks_) {
       case 0:
         // If the click location is within an existing selection, it may be a
         // potential drag and drop.
-        if (render_text->IsPointInSelection(event.location())) {
+        if (delegate_->SupportsDrag() &&
+            render_text->IsPointInSelection(event.location())) {
           delegate_->SetTextBeingDragged(true);
         } else {
           delegate_->OnBeforePointerAction();
           const bool selection_changed =
               render_text->MoveCursorTo(event.location(), event.IsShiftDown());
           delegate_->OnAfterPointerAction(false, selection_changed);
         }
         break;
       case 1:
         // Select the word at the click location on a double click.
@@ skipping 69 matching lines @@
 
   drag_selection_timer_.Stop();
 
   // Cancel suspected drag initiations, the user was clicking in the selection.
   if (delegate_->HasTextBeingDragged()) {
     delegate_->OnBeforePointerAction();
     const bool selection_changed =
         render_text->MoveCursorTo(event.location(), false);
     delegate_->OnAfterPointerAction(false, selection_changed);
   }
-  delegate_->SetTextBeingDragged(false);
+
+  if (delegate_->SupportsDrag())
+    delegate_->SetTextBeingDragged(false);
 
   if (handles_selection_clipboard_ && !render_text->selection().is_empty())
     delegate_->UpdateSelectionClipboard();
 }
 
 void SelectionController::OnMouseCaptureLost() {
   gfx::RenderText* render_text = GetRenderText();
   DCHECK(render_text);
 
   drag_selection_timer_.Stop();
@@ skipping 24 matching lines @@
   return delegate_->GetRenderTextForSelectionController();
 }
 
 void SelectionController::SelectThroughLastDragLocation() {
   gfx::RenderText* render_text = GetRenderText();
   DCHECK(render_text);
 
   delegate_->OnBeforePointerAction();
 
   // TODO(karandeepb): See if this can be handled at the RenderText level.
-  const bool drags_to_end = PlatformStyle::kTextfieldDragVerticallyDragsToEnd;
+  const bool drags_to_end = PlatformStyle::kTextDragVerticallyDragsToEnd;
   if (drags_to_end && last_drag_location_.y() < 0) {
     render_text->MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT,
                             gfx::SELECTION_RETAIN);
   } else if (drags_to_end &&
              last_drag_location_.y() > delegate_->GetViewHeight()) {
     render_text->MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT,
                             gfx::SELECTION_RETAIN);
   } else {
     render_text->MoveCursorTo(last_drag_location_, true);
   }
 
   if (aggregated_clicks_ == 1) {
     render_text->SelectWord();
     // Expand the selection so the initially selected word remains selected.
     gfx::Range selection = render_text->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);
     render_text->SelectRange(selection);
   }
   delegate_->OnAfterPointerAction(false, true);
 }
 
 }  // namespace views