Views:: Make Labels support text selection.

ui/views/controls/label.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/label.h"
 
 #include <stddef.h>
 
 #include <algorithm>
 #include <cmath>
 #include <limits>
 #include <utility>
 #include <vector>
 
 #include "base/i18n/rtl.h"
 #include "base/logging.h"
 #include "base/profiler/scoped_tracker.h"
 #include "base/strings/string_split.h"
 #include "base/strings/utf_string_conversions.h"
 #include "ui/accessibility/ax_view_state.h"
+#include "ui/base/clipboard/scoped_clipboard_writer.h"
+#include "ui/base/cursor/cursor.h"
 #include "ui/base/default_style.h"
 #include "ui/base/material_design/material_design_controller.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/color_utils.h"
 #include "ui/gfx/geometry/insets.h"
 #include "ui/gfx/text_elider.h"
 #include "ui/native_theme/native_theme.h"
+#include "ui/views/focus/focus_manager.h"
+#include "ui/views/native_cursor.h"
+#include "ui/views/selection_controller.h"
 
 namespace views {
 // static
 const char Label::kViewClassName[] = "Label";
 const int Label::kFocusBorderPadding = 1;
 
 Label::Label() : Label(base::string16()) {
 }
 
 Label::Label(const base::string16& text) : Label(text, GetDefaultFontList()) {
@@ skipping 54 matching lines @@
 
 void Label::SetBackgroundColor(SkColor color) {
   if (background_color_set_ && background_color_ == color)
     return;
   is_first_paint_text_ = true;
   background_color_ = color;
   background_color_set_ = true;
   RecalculateColors();
 }
 
+void Label::SetSelectionTextColor(SkColor color) {
+  if (selection_text_color_set_ && requested_selection_text_color_ == color)
+    return;
+  is_first_paint_text_ = true;
+  requested_selection_text_color_ = color;
+  selection_text_color_set_ = true;
+  RecalculateColors();
+}
+
+void Label::SetSelectionBackgroundColor(SkColor color) {
+  if (selection_background_color_set_ && selection_background_color_ == color)
+    return;
+  is_first_paint_text_ = true;
+  selection_background_color_ = color;
+  selection_background_color_set_ = true;
+  RecalculateColors();
+}
+
 void Label::SetShadows(const gfx::ShadowValues& shadows) {
   // TODO(mukai): early exit if the specified shadows are same.
   is_first_paint_text_ = true;
   render_text_->set_shadows(shadows);
   ResetLayout();
 }
 
 void Label::SetSubpixelRenderingEnabled(bool subpixel_rendering_enabled) {
   if (subpixel_rendering_enabled_ == subpixel_rendering_enabled)
     return;
@@ skipping 27 matching lines @@
 void Label::SetMultiLine(bool multi_line) {
   DCHECK(!multi_line || (elide_behavior_ == gfx::ELIDE_TAIL ||
                          elide_behavior_ == gfx::NO_ELIDE));
   if (this->multi_line() == multi_line)
     return;
   is_first_paint_text_ = true;
   multi_line_ = multi_line;
   if (render_text_->MultilineSupported())
     render_text_->SetMultiline(multi_line);
   render_text_->SetReplaceNewlineCharsWithSymbols(!multi_line);
+  if (multi_line)
+    SetSelectable(false);
   ResetLayout();
 }
 
 void Label::SetObscured(bool obscured) {
   if (this->obscured() == obscured)
     return;
   is_first_paint_text_ = true;
   render_text_->SetObscured(obscured);
   ResetLayout();
 }
@@ skipping 37 matching lines @@
 }
 
 void Label::SetMaximumWidth(int max_width) {
   DCHECK(multi_line());
   DCHECK_EQ(0, fixed_width_);
   max_width_ = max_width;
   SizeToPreferredSize();
 }
 
 base::string16 Label::GetDisplayTextForTesting() {
-  lines_.clear();
+  ClearRenderTextLines();
   MaybeBuildRenderTextLines();
   base::string16 result;
   if (lines_.empty())
     return result;
   result.append(lines_[0]->GetDisplayText());
   for (size_t i = 1; i < lines_.size(); ++i) {
     result.append(1, '\n');
     result.append(lines_[i]->GetDisplayText());
   }
   return result;
 }
 
+bool Label::IsSelectionSupported() const {
+  return !multi_line() && render_text_->IsSelectionSupported();
+}
+
+bool Label::IsSelectable() const {
+  if (selection_controller_) {
+    DCHECK(IsSelectionSupported());
+    return true;
+  }
+  return false;
+}
+
+bool Label::SetSelectable(bool value) {
+  if (value == IsSelectable())
+    return true;
+
+  if (!value) {
+    ClearSelection();
+    selection_controller_.reset();
+    return true;
+  }
+
+  if (!IsSelectionSupported())
+    return false;
+
+  selection_controller_.reset(new SelectionController(this));
+
+// On Linux, update the selection clipboard on a text selection.
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  selection_controller_->set_handles_selection_clipboard(true);
+#endif
+
+  return true;
+}
+
+bool Label::HasSelection() const {
+  const gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  return render_text ? !render_text->selection().is_empty() : false;
+}
+
+void Label::SelectAll() {
+  gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  if (!render_text)
+    return;
+  render_text->SelectAll(false);
+  SchedulePaint();
+}
+
+void Label::ClearSelection() {
+  gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  if (!render_text)
+    return;
+  render_text->ClearSelection();
+  SchedulePaint();
+}
+
+void Label::SelectRange(const gfx::Range& range) {
+  gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  if (render_text && render_text->SelectRange(range))
+    SchedulePaint();
+}
+
 gfx::Insets Label::GetInsets() const {
   gfx::Insets insets = View::GetInsets();
   if (focus_behavior() != FocusBehavior::NEVER) {
     insets += gfx::Insets(kFocusBorderPadding, kFocusBorderPadding,
                           kFocusBorderPadding, kFocusBorderPadding);
   }
   return insets;
 }
 
 int Label::GetBaseline() const {
@@ skipping 59 matching lines @@
     height = render_text_->GetStringSize().height();
   } else {
     std::vector<base::string16> lines = GetLinesForWidth(w);
     height = lines.size() * std::max(line_height(), font_list().GetHeight());
   }
   height -= gfx::ShadowValue::GetMargin(render_text_->shadows()).height();
   return height + GetInsets().height();
 }
 
 void Label::Layout() {
-  lines_.clear();
+  ClearRenderTextLines();
 }
 
 const char* Label::GetClassName() const {
   return kViewClassName;
 }
 
 View* Label::GetTooltipHandlerForPoint(const gfx::Point& point) {
   if (!handles_tooltips_ ||
       (tooltip_text_.empty() && !ShouldShowDefaultTooltip()))
     return NULL;
 
   return HitTestPoint(point) ? this : NULL;
 }
 
 bool Label::CanProcessEventsWithinSubtree() const {
-  // Send events to the parent view for handling.
-  return false;
+  return !!GetRenderTextForSelectionController();
 }
 
 void Label::GetAccessibleState(ui::AXViewState* state) {
   state->role = ui::AX_ROLE_STATIC_TEXT;
   state->AddStateFlag(ui::AX_STATE_READ_ONLY);
   // Note that |render_text_| is never elided (see the comment in Init() too).
   state->name = render_text_->GetDisplayText();
 }
 
 bool Label::GetTooltipText(const gfx::Point& p, base::string16* tooltip) const {
@@ skipping 16 matching lines @@
 
 void Label::OnEnabledChanged() {
   ApplyTextColors();
   View::OnEnabledChanged();
 }
 
 std::unique_ptr<gfx::RenderText> Label::CreateRenderText(
     const base::string16& text,
     gfx::HorizontalAlignment alignment,
     gfx::DirectionalityMode directionality,
-    gfx::ElideBehavior elide_behavior) {
+    gfx::ElideBehavior elide_behavior) const {
   std::unique_ptr<gfx::RenderText> render_text(
       render_text_->CreateInstanceOfSameType());
   render_text->SetHorizontalAlignment(alignment);
   render_text->SetDirectionalityMode(directionality);
   render_text->SetElideBehavior(elide_behavior);
   render_text->SetObscured(obscured());
   render_text->SetMinLineHeight(line_height());
   render_text->SetFontList(font_list());
   render_text->set_shadows(shadows());
   render_text->SetCursorEnabled(false);
@@ skipping 18 matching lines @@
     // TODO(ckocagil): Remove ScopedTracker below once crbug.com/441028 is
     // fixed.
     tracked_objects::ScopedTracker tracking_profile(
         FROM_HERE_WITH_EXPLICIT_FUNCTION("441028 First PaintText()"));
 
     is_first_paint_text_ = false;
     PaintText(canvas);
   } else {
     PaintText(canvas);
   }
-  if (HasFocus() && !ui::MaterialDesignController::IsSecondaryUiMaterial())
+
+  // Check for IsAccessibilityFocusable() to prevent drawing a focus rect for
+  // non-focusable labels with selection, which are given focus explicitly in
+  // OnMousePressed.
+  if (HasFocus() && !ui::MaterialDesignController::IsSecondaryUiMaterial() &&
+      IsAccessibilityFocusable()) {
     canvas->DrawFocusRect(GetFocusBounds());
+  }
 }
 
 void Label::OnNativeThemeChanged(const ui::NativeTheme* theme) {
   UpdateColorsFromTheme(theme);
 }
 
+gfx::NativeCursor Label::GetCursor(const ui::MouseEvent& event) {
+  return GetRenderTextForSelectionController() ? GetNativeIBeamCursor()

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

nit: should this just check IsSelectable?

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

So GetRenderTextForSelectionController() may still return nullptr even if
IsSelectable returns true. This can happen when say the content bounds of the
view are empty. Think this is more appropriate.

+                                               : gfx::kNullCursor;
+}
+
+void Label::OnFocus() {
+  gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  if (render_text) {
+    render_text->set_focused(true);
+    SchedulePaint();
+  }
+  View::OnFocus();
+}
+
+void Label::OnBlur() {
+  gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  if (render_text) {
+    render_text->set_focused(false);
+    SchedulePaint();
+  }
+  View::OnBlur();
+}
+
+bool Label::OnMousePressed(const ui::MouseEvent& event) {
+  if(!GetRenderTextForSelectionController())

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

nit: space after if; ditto elsewhere below, run 'git cl format'.

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

Done.

+    return false;
+
+  // RequestFocus() won't work when the label has FocusBehavior::NEVER. Hence
+  // explicitly set the focused view.
+  // TODO(karandeepb): If a widget with a label having FocusBehavior::NEVER as

[karandeepb, 2016/10/27 07:31:54]

Still need to find a workaround for this. Also, not sure if it's ok to set focus
to a view with FocusBehavior::NEVER. Have suggested a few options here -
https://docs.google.com/document/d/1JTjY8RLE84hxubCAouHuD6xVtvuMnzbqSDZyf_4N6...

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

I think this is probably fine as a temporary solution (I'm not aware of any real
problems forcibly focusing a FocusBehavior::NEVER view, but if we encounter any,
your other doc ideas are good leads!). Nice comment, just cite a tracking bug.

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

Done. Will use the label text selection bug to track this.

+  // the currently focused view (due to selection) was to lose focus, focus
+  // won't be restored to the label (and hence a text selection won't be drawn)
+  // when the widget gets focus again. Fix this.
+  if ((event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton()) &&
+      GetFocusManager()) {
+    GetFocusManager()->SetFocusedView(this);
+  }
+
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  if (event.IsOnlyMiddleMouseButton() && GetFocusManager())
+    GetFocusManager()->SetFocusedView(this);
+#endif
+
+  return selection_controller_->OnMousePressed(event, false);
+}
+
+bool Label::OnMouseDragged(const ui::MouseEvent& event) {

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

aside: Making SelectionController a pre-target event handler (as Scott suggested
in the prior CL), or seeking some other refinement would be nice, but not a
blocker to land this. Ultimately, it'd be great to have one RenderText impl that
supports multi-line, and then we could maybe even make Textfield a Label
subclass, or share more code.

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

As pointed out in the prior CL, making SelectionController a pre-target handler
may not be feasible since we need specific ordering. Eg classes like
OmniboxViewViews and Link override the OnMouse* handlers for Textfield and Label
respectively. Then there is also the TextfieldController class to which we pass
OnMousePressed events in Textfield.
Yeah I think it'd be great, but we should try to clean up the Label
implementation first somehow. The implementation is currently a bit confusing
with multiple render text instances (due to supporting RenderTextMac) used for
drawing which are cleared and created on each layout. Also, there's the
|render_text_| instance which is used for preferred sizing and persisting some
data. 

Some things which may probably be looked at-
1) If we are able to move away from using RenderTextMac on Mac, can we use a
single persistent RenderText instance (like we do in Textfields).
2) Is it necessary to use a separate |render_text_| instance for preferred
sizing.
Can we use a temporary render text instance when necessary and maybe have a
cache layer on top in the Label class? 
3) Also, there's the StyledLabel class which is used for creating a text view
with multiple styles. Haven't looked into it, but it may be possible for Label
or a Label subclass to support the StyledLabel class API, since RenderText
supports different styles for a given piece of text.

[msw, 2016/11/01 23:42:21]

Yeah, these would be good tasks to pursue, I'm in favor of them.

+  if(!GetRenderTextForSelectionController())
+    return false;
+
+  return selection_controller_->OnMouseDragged(event);
+}
+
+void Label::OnMouseReleased(const ui::MouseEvent& event) {
+  if(!GetRenderTextForSelectionController())
+    return;
+
+  selection_controller_->OnMouseReleased(event);
+}
+
+void Label::OnMouseCaptureLost() {
+  if(!GetRenderTextForSelectionController())
+    return;
+
+  selection_controller_->OnMouseCaptureLost();
+}
+
 void Label::OnDeviceScaleFactorChanged(float device_scale_factor) {
   View::OnDeviceScaleFactorChanged(device_scale_factor);
   // When the device scale factor is changed, some font rendering parameters is
   // changed (especially, hinting). The bounding box of the text has to be
   // re-computed based on the new parameters. See crbug.com/441439
   ResetLayout();
 }
 
 void Label::VisibilityChanged(View* starting_from, bool is_visible) {
   if (!is_visible)
-    lines_.clear();
+    ClearRenderTextLines();
+}
+
+gfx::RenderText* Label::GetRenderTextForSelectionController() {
+  return const_cast<gfx::RenderText*>(
+      static_cast<const Label*>(this)->GetRenderTextForSelectionController());
+}
+
+bool Label::IsReadOnly() const {
+  return true;
+}
+
+bool Label::SupportsDrag() const {
+  return false;
+}
+
+bool Label::HasTextBeingDragged() const {
+  return false;
+}
+
+void Label::SetTextBeingDragged(bool value) {
+  NOTREACHED();
+}
+
+int Label::GetViewHeight() const {
+  return height();
+}
+
+int Label::GetViewWidth() const {
+  return width();
+}
+
+int Label::GetDragSelectionDelay() const {
+  // Labels don't need to use a repeating timer to update the drag selection.
+  // Since the cursor is disabled for labels, a selection outside the display
+  // area won't change the text in the display area. It is expected that all the
+  // text will fit in the display area for labels anyway.
+  return 0;
+}
+
+void Label::OnBeforePointerAction() {}
+
+void Label::OnAfterPointerAction(bool text_changed, bool selection_changed) {
+  DCHECK(!text_changed);
+  if (selection_changed)
+    SchedulePaint();
+}
+
+bool Label::PasteSelectionClipboard() {
+  NOTREACHED();
+  return false;
+}
+
+void Label::UpdateSelectionClipboard() {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  DCHECK(render_text);
+  if (!obscured()) {

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

nit: do this before getting |render_text|

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

Obsolete.

+    const base::string16 selected_text =
+        render_text->GetTextFromRange(render_text->selection());
+    ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_SELECTION)
+        .WriteText(selected_text);
+  }
+#endif
+}
+
+const gfx::RenderText* Label::GetRenderTextForSelectionController() const {
+  if (!IsSelectable())
+    return nullptr;
+  MaybeBuildRenderTextLines();
+
+  // This may happen when the content bounds of the view are empty.
+  if (lines_.empty())
+    return nullptr;
+
+  DCHECK_EQ(1u, lines_.size());
+  return lines_[0].get();
 }
 
 void Label::Init(const base::string16& text, const gfx::FontList& font_list) {
   render_text_.reset(gfx::RenderText::CreateInstance());
   render_text_->SetHorizontalAlignment(gfx::ALIGN_CENTER);
   render_text_->SetDirectionalityMode(gfx::DIRECTIONALITY_FROM_TEXT);
   // NOTE: |render_text_| should not be elided at all. This is used to keep some
   // properties and to compute the size of the string.
   render_text_->SetElideBehavior(gfx::NO_ELIDE);
   render_text_->SetFontList(font_list);
   render_text_->SetCursorEnabled(false);
   render_text_->SetWordWrapBehavior(gfx::TRUNCATE_LONG_WORDS);
 
   elide_behavior_ = gfx::ELIDE_TAIL;
   enabled_color_set_ = disabled_color_set_ = background_color_set_ = false;
+  selection_text_color_set_ = selection_background_color_set_ = false;
   subpixel_rendering_enabled_ = true;
   auto_color_readability_ = true;
   multi_line_ = false;
   UpdateColorsFromTheme(GetNativeTheme());
   handles_tooltips_ = true;
   collapse_when_hidden_ = false;
   fixed_width_ = 0;
   max_width_ = 0;
   is_first_paint_text_ = true;
   SetText(text);
 }
 
 void Label::ResetLayout() {
   InvalidateLayout();
   PreferredSizeChanged();
   SchedulePaint();
-  lines_.clear();
+  ClearRenderTextLines();
 }
 
-void Label::MaybeBuildRenderTextLines() {
+void Label::MaybeBuildRenderTextLines() const {
   if (!lines_.empty())
     return;
 
   gfx::Rect rect = GetContentsBounds();
   if (focus_behavior() != FocusBehavior::NEVER)
     rect.Inset(kFocusBorderPadding, kFocusBorderPadding);
   if (rect.IsEmpty())
     return;
   rect.Inset(-gfx::ShadowValue::GetMargin(shadows()));
 
@@ skipping 12 matching lines @@
   // Text eliding is not supported for multi-lined Labels.
   // TODO(mukai): Add multi-lined elided text support.
   gfx::ElideBehavior elide_behavior =
       multi_line() ? gfx::NO_ELIDE : elide_behavior_;
   if (!multi_line() || render_text_->MultilineSupported()) {
     std::unique_ptr<gfx::RenderText> render_text =
         CreateRenderText(text(), alignment, directionality, elide_behavior);
     render_text->SetDisplayRect(rect);
     render_text->SetMultiline(multi_line());
     render_text->SetWordWrapBehavior(render_text_->word_wrap_behavior());
+
+    // Setup render text for selection controller.
+    if (IsSelectable()) {
+      render_text->set_focused(HasFocus());
+      if (last_selection_range_)
+        render_text->SelectRange(last_selection_range_.value());
+    }
+
     lines_.push_back(std::move(render_text));
   } else {
     std::vector<base::string16> lines = GetLinesForWidth(rect.width());
     if (lines.size() > 1)
       rect.set_height(std::max(line_height(), font_list().GetHeight()));
 
     const int bottom = GetContentsBounds().bottom();
     for (size_t i = 0; i < lines.size() && rect.y() <= bottom; ++i) {
       std::unique_ptr<gfx::RenderText> line =
           CreateRenderText(lines[i], alignment, directionality, elide_behavior);
       line->SetDisplayRect(rect);
       lines_.push_back(std::move(line));
       rect.set_y(rect.y() + rect.height());
     }
     // Append the remaining text to the last visible line.
     for (size_t i = lines_.size(); i < lines.size(); ++i)
       lines_.back()->SetText(lines_.back()->text() + lines[i]);
   }
+
+  last_selection_range_.reset();
   ApplyTextColors();
 }
 
-gfx::Rect Label::GetFocusBounds() {
+gfx::Rect Label::GetFocusBounds() const {
   MaybeBuildRenderTextLines();
 
   gfx::Rect focus_bounds;
   if (lines_.empty()) {
     focus_bounds = gfx::Rect(GetTextSize());
   } else {
     for (size_t i = 0; i < lines_.size(); ++i) {
       gfx::Point origin;
       origin += lines_[i]->GetLineOffset(0);
       focus_bounds.Union(gfx::Rect(origin, lines_[i]->GetStringSize()));
@@ skipping 54 matching lines @@
 
 void Label::RecalculateColors() {
   actual_enabled_color_ = auto_color_readability_ ?
       color_utils::GetReadableColor(requested_enabled_color_,
                                     background_color_) :
       requested_enabled_color_;
   actual_disabled_color_ = auto_color_readability_ ?
       color_utils::GetReadableColor(requested_disabled_color_,
                                     background_color_) :
       requested_disabled_color_;
+  actual_selection_text_color_ =
+      auto_color_readability_
+          ? color_utils::GetReadableColor(requested_selection_text_color_,
+                                          selection_background_color_)
+          : requested_selection_text_color_;
 
   ApplyTextColors();
   SchedulePaint();
 }
 
-void Label::ApplyTextColors() {
+void Label::ApplyTextColors() const {
   SkColor color = enabled() ? actual_enabled_color_ : actual_disabled_color_;
   bool subpixel_rendering_suppressed =
       SkColorGetA(background_color_) != 0xFF || !subpixel_rendering_enabled_;
   for (size_t i = 0; i < lines_.size(); ++i) {
     lines_[i]->SetColor(color);
+    lines_[i]->set_selection_color(actual_selection_text_color_);
+    lines_[i]->set_selection_background_focused_color(
+        selection_background_color_);
     lines_[i]->set_subpixel_rendering_suppressed(subpixel_rendering_suppressed);
   }
 }
 
 void Label::UpdateColorsFromTheme(const ui::NativeTheme* theme) {
   if (!enabled_color_set_) {
     requested_enabled_color_ = theme->GetSystemColor(
         ui::NativeTheme::kColorId_LabelEnabledColor);
   }
   if (!disabled_color_set_) {
     requested_disabled_color_ = theme->GetSystemColor(
         ui::NativeTheme::kColorId_LabelDisabledColor);
   }
   if (!background_color_set_) {
     background_color_ =
         theme->GetSystemColor(ui::NativeTheme::kColorId_DialogBackground);
   }
+  if (!selection_text_color_set_) {
+    requested_selection_text_color_ = theme->GetSystemColor(
+        ui::NativeTheme::kColorId_LabelTextSelectionColor);
+  }
+  if (!selection_background_color_set_) {
+    selection_background_color_ = theme->GetSystemColor(
+        ui::NativeTheme::kColorId_LabelTextSelectionBackgroundFocused);
+  }
   RecalculateColors();
 }
 
 bool Label::ShouldShowDefaultTooltip() const {
   const gfx::Size text_size = GetTextSize();
   const gfx::Size size = GetContentsBounds().size();
   return !obscured() && (text_size.width() > size.width() ||
                          (multi_line() && text_size.height() > size.height()));
 }
 
+void Label::ClearRenderTextLines() const {
+  // Persist the selection range if there is an active selection.
+  if (HasSelection())
+    last_selection_range_ = GetRenderTextForSelectionController()->selection();
+  lines_.clear();
+}
+
 }  // namespace views