Label selection experiment

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"
 
 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();
+  ClearLines();
   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::SetSelectable(bool value) {
+  if (value == selectable())
+    return true;
+
+  if (value && !IsSelectionSupported())
+    return false;
+
+  ClearSelection();
+  selection_controller_.reset(value ? new SelectionController(this) : nullptr);
+  return true;
+}
+
+bool Label::HasSelection() {
+  gfx::RenderText* render_text = GetRenderTextForSelection();
+  return render_text ? !render_text->selection().is_empty() : false;
+}
+
+void Label::SelectAll() {
+  if (!GetRenderTextForSelection())
+    return;
+  GetRenderTextForSelection()->SelectAll(false);
+  OnSelectionUpdated();
+}
+
+void Label::ClearSelection() {
+  if (!GetRenderTextForSelection())
+    return;
+  GetRenderTextForSelection()->ClearSelection();
+  OnSelectionUpdated();
+}
+
+void Label::SelectRange(const gfx::Range& range) {
+  if (!GetRenderTextForSelection())
+    return;
+  if (GetRenderTextForSelection()->SelectRange(range))
+    OnSelectionUpdated();
+}
+
 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();
+  ClearLines();
 }
 
 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 selectable();
 }
 
 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 55 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 GetRenderTextForSelection() ? GetNativeIBeamCursor()
+                                     : gfx::kNullCursor;
+}
+
+void Label::OnFocus() {
+  if (GetRenderTextForSelection()) {
+    GetRenderTextForSelection()->set_focused(true);
+    SchedulePaint();
+  }
+  View::OnFocus();
+}
+
+void Label::OnBlur() {
+  if (GetRenderTextForSelection()) {
+    GetRenderTextForSelection()->set_focused(false);
+    SchedulePaint();
+  }
+  View::OnBlur();
+}
+
+bool Label::OnMousePressed(const ui::MouseEvent& event) {
+  DCHECK(selectable());
+  if (!GetRenderTextForSelection())
+    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
+  // 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.
+  // Todo is giving focus to a view with FocusBehavior::NEVER ok?
+  if (GetFocusManager())
+    GetFocusManager()->SetFocusedView(this);
+  return selection_controller_->OnMousePressed(event, false);
+}
+
+bool Label::OnMouseDragged(const ui::MouseEvent& event) {
+  DCHECK(GetRenderTextForSelection());
+  return selection_controller_->OnMouseDragged(event);
+}
+
+void Label::OnMouseReleased(const ui::MouseEvent& event) {
+  DCHECK(GetRenderTextForSelection());
+  selection_controller_->OnMouseReleased(event);
+}
+
 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();
+    ClearLines();
+}
+
+gfx::RenderText* Label::GetRenderTextForSelection() {
+  if (!selectable())
+    return nullptr;
+  DCHECK(IsSelectionSupported());
+  MaybeBuildRenderTextLines();
+  if (lines_.empty())
+    return nullptr;
+  DCHECK_EQ(1u, lines_.size());
+  return lines_[0].get();
+}
+
+bool Label::IsReadOnly() const {
+  return true;
+}
+
+bool Label::SupportsDrag() const {
+  return false;
+}
+
+bool Label::HasTextBeingDragged() const {
+  return false;
+}
+
+void Label::SetTextBeingDragged(bool value) {}
+
+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 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::OnBeforeMouseAction() {
+  DCHECK(!performing_mouse_action_);
+  DCHECK(GetRenderTextForSelection());
+  performing_mouse_action_ = true;
+}
+
+void Label::OnAfterMouseAction(bool text_changed, bool selection_changed) {
+  DCHECK(!text_changed);
+  DCHECK(performing_mouse_action_);
+  DCHECK(GetRenderTextForSelection());
+  performing_mouse_action_ = false;
+  if (selection_changed)
+    OnSelectionUpdated();
+}
+
+void Label::OnBeforeSelectionUpdated() {
+  DCHECK(performing_mouse_action_);
+}
+
+void Label::OnAfterSelectionUpdated() {
+  DCHECK(performing_mouse_action_);
+  OnSelectionUpdated();
+}
+
+void Label::PasteSelectionClipboard(const ui::MouseEvent& event) {}
+
+void Label::UpdateSelectionClipboard() {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  gfx::RenderText* render_text = GetRenderTextForSelection();
+  if (performing_mouse_action_ && !obscured() && render_text) {
+    base::string16 selected_text =
+        render_text->GetTextFromRange(render_text->selection());
+    ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_SELECTION)
+        .WriteText(selected_text);
+  }
+#endif
 }
 
 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;
+  performing_mouse_action_ = false;
   SetText(text);
 }
 
 void Label::ResetLayout() {
   InvalidateLayout();
   PreferredSizeChanged();
   SchedulePaint();
-  lines_.clear();
+  ClearLines();
 }
 
 void Label::MaybeBuildRenderTextLines() {
   if (!lines_.empty())
     return;
 
   gfx::Rect rect = GetContentsBounds();
   if (focus_behavior() != FocusBehavior::NEVER)
     rect.Inset(kFocusBorderPadding, kFocusBorderPadding);
   if (rect.IsEmpty())
@@ skipping 33 matching lines @@
       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]);
   }
+
+  if (GetRenderTextForSelection())
+    GetRenderTextForSelection()->set_focused(HasFocus());
+
+  if (last_selection_range_) {
+    SelectRange(last_selection_range_.value());
+    last_selection_range_.reset();
+  }
+
   ApplyTextColors();
 }
 
 gfx::Rect Label::GetFocusBounds() {
   MaybeBuildRenderTextLines();
 
   gfx::Rect focus_bounds;
   if (lines_.empty()) {
     focus_bounds = gfx::Rect(GetTextSize());
   } else {
@@ skipping 58 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() {
   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_) {
+    // Todo create new default for labels or rename Textfield to Text?
+    requested_selection_text_color_ = theme->GetSystemColor(
+        ui::NativeTheme::kColorId_TextfieldSelectionColor);
+  }
+  if (!selection_background_color_set_) {
+    selection_background_color_ = theme->GetSystemColor(
+        ui::NativeTheme::kColorId_TextfieldSelectionBackgroundFocused);
+  }
   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::OnSelectionUpdated() {
+  if (performing_mouse_action_)
+    return;
+  SchedulePaint();
+}
+
+void Label::ClearLines() {
+  // Persist the selection range if there is an active selection.
+  if (HasSelection())
+    last_selection_range_ = GetRenderTextForSelection()->selection();
+  lines_.clear();
+}
+
 }  // namespace views