Views:: Make Labels support text selection.

ui/views/controls/label.h

 // 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.
 
 #ifndef UI_VIEWS_CONTROLS_LABEL_H_
 #define UI_VIEWS_CONTROLS_LABEL_H_
 
 #include "base/compiler_specific.h"
 #include "base/gtest_prod_util.h"
 #include "base/macros.h"
 #include "ui/gfx/render_text.h"
+#include "ui/views/selection_controller_delegate.h"
 #include "ui/views/view.h"
 
 namespace views {
+class LabelTest;
+class SelectionController;
 
 // A view subclass that can display a string.
-class VIEWS_EXPORT Label : public View {
+class VIEWS_EXPORT Label : public View, public SelectionControllerDelegate {
  public:
   // Internal class name.
   static const char kViewClassName[];
 
   // The padding for the focus border when rendering focused text.
   static const int kFocusBorderPadding;
 
   Label();
   explicit Label(const base::string16& text);
   Label(const base::string16& text, const gfx::FontList& font_list);
@@ skipping 16 matching lines @@
   // ensure that the foreground colors are readable over the background color.
   void SetAutoColorReadabilityEnabled(bool enabled);
 
   // Sets the color.  This will automatically force the color to be readable
   // over the current background color, if auto color readability is enabled.
   virtual void SetEnabledColor(SkColor color);
   void SetDisabledColor(SkColor color);
 
   SkColor enabled_color() const { return actual_enabled_color_; }
 
-  // Sets the background color.  This won't be explicitly drawn, but the label
+  // Sets the background color. This won't be explicitly drawn, but the label
   // will force the text color to be readable over it.
   void SetBackgroundColor(SkColor color);
   SkColor background_color() const { return background_color_; }
 
+  // Sets the selection text color. This will automatically force the color to
+  // be readable over the selection background color, if auto color readability
+  // is enabled. Initialized with system default.
+  void SetSelectionTextColor(SkColor color);

[sky, 2016/11/03 03:23:20]

Is setting the selection colors really needed? AFAICT no one actually uses it.

[karandeepb, 2016/11/03 10:38:56]

Yeah for textfields there are no usages of SetSelectionTextColor. However since
Labels are generally rendered with a custom background/text color, I think this
will be useful. For example, no. of usages of SetTextColor/SetBackgroundColor
for Labels and Textfields are 86/29 vs 4/7 respectively. Of course Labels are
used more often though.

+  SkColor selection_text_color() const { return actual_selection_text_color_; }
+
+  // Sets the selection background color. Initialized with system default.
+  void SetSelectionBackgroundColor(SkColor color);
+  SkColor selection_background_color() const {
+    return selection_background_color_;
+  }
+
   // Set drop shadows underneath the text.
   void SetShadows(const gfx::ShadowValues& shadows);
   const gfx::ShadowValues& shadows() const { return render_text_->shadows(); }
 
   // Sets whether subpixel rendering is used; the default is true, but this
   // feature also requires an opaque background color.
   // TODO(mukai): rename this as SetSubpixelRenderingSuppressed() to keep the
   // consistency with RenderText field name.
   void SetSubpixelRenderingEnabled(bool subpixel_rendering_enabled);
 
@@ skipping 50 matching lines @@
 
   // Like SizeToFit, but uses a smaller width if possible.
   void SetMaximumWidth(int max_width);
 
   // Sets whether the preferred size is empty when the label is not visible.
   void set_collapse_when_hidden(bool value) { collapse_when_hidden_ = value; }
 
   // Get the text as displayed to the user, respecting the obscured flag.
   base::string16 GetDisplayTextForTesting();
 
+  // Returns true if the label is selectable. Default is false.
+  bool selectable() const { return !!selection_controller_; }
+
+  // Sets whether the label is selectable. False is returned if the call fails,
+  // i.e. when selection is not supported but |selectable| is true.
+  bool SetSelectable(bool selectable);

[sky, 2016/11/03 03:23:20]

Couple of questions:
Is the plan to make selection always supported? If not, how come?

What do you expect callers to do with a return value of false?

Is there a reason not to make all labels selectable?

[karandeepb, 2016/11/03 10:38:56]

Cases where selection is not supported-
1) MacViews currently uses RenderTextMac which does not support text selection.
Have created a bug to track the migration of Views::Labels to HarfBuzz.
2) Multiline labels do not currently support text selection. There are changes
required in RenderTextHarfBuzz which I'll be working on subsequently.
3) Links do not support text selection. Don't think they should, since a click
event inside a link should click the link. On Webcontents, a click inside a
Link, clicks the link, while a drag drags it. 
Yeah it's not useful probably. Can remove it.
For example, we don't want Labels inside buttons to intercept mouse events for
text selection. Also, looking at the native Cocoa UI (where text selection is
supported), some text views support selection while others do not. I think we'll
only want to make labels selectable where we want the user to say copy the text
(like crbug.com/437993 demands).

Also, quoting one of your comments from an earlier attempt at this
(https://codereview.chromium.org/1272363002/)-
"I haven't looked at your patch, but make sure you don't change the default
context-menu/mouse/focus handling at all. Sites should have to opt into the new
behavior where they know it won't cause problems. For example, the tabstrip uses
labels and if labels started consuming touch events you would break touch
handling in the tabstrip."

+
+  // Returns true if the label has a selection.
+  bool HasSelection() const;
+
+  // Selects the entire text. NO-OP if the label is not selectable.
+  void SelectAll();
+
+  // Clears any active selection.
+  void ClearSelection();
+
+  // Selects the given text range. NO-OP if the label is not selectable or the
+  // |range| endpoints don't lie on grapheme boundaries.
+  void SelectRange(const gfx::Range& range);
+
   // View:
   gfx::Insets GetInsets() const override;
   int GetBaseline() const override;
   gfx::Size GetPreferredSize() const override;
   gfx::Size GetMinimumSize() const override;
   int GetHeightForWidth(int w) const override;
   void Layout() override;
   const char* GetClassName() const override;
   View* GetTooltipHandlerForPoint(const gfx::Point& point) override;
   bool CanProcessEventsWithinSubtree() const override;
   void GetAccessibleState(ui::AXViewState* state) override;
   bool GetTooltipText(const gfx::Point& p,
                       base::string16* tooltip) const override;
   void OnEnabledChanged() override;
 
  protected:
   // Create a single RenderText instance to actually be painted.
   virtual std::unique_ptr<gfx::RenderText> CreateRenderText(
       const base::string16& text,
       gfx::HorizontalAlignment alignment,
       gfx::DirectionalityMode directionality,
-      gfx::ElideBehavior elide_behavior);
+      gfx::ElideBehavior elide_behavior) const;
 
   void PaintText(gfx::Canvas* canvas);
 
   SkColor disabled_color() const { return actual_disabled_color_; }
 
+  // Returns true if the label can be made selectable. For example, links do not
+  // support text selection.
+  // Subclasses should override this function in case they want to selectively
+  // support text selection. If a subclass stops supporting text selection, it
+  // should call SetSelectable(false).
+  virtual bool IsSelectionSupported() const;
+
   // View:
   void OnBoundsChanged(const gfx::Rect& previous_bounds) override;
   void VisibilityChanged(View* starting_from, bool is_visible) override;
   void OnPaint(gfx::Canvas* canvas) override;
   void OnDeviceScaleFactorChanged(float device_scale_factor) override;
   void OnNativeThemeChanged(const ui::NativeTheme* theme) override;
+  gfx::NativeCursor GetCursor(const ui::MouseEvent& event) override;
+  void OnFocus() override;
+  void OnBlur() override;
+  bool OnMousePressed(const ui::MouseEvent& event) override;
+  bool OnMouseDragged(const ui::MouseEvent& event) override;
+  void OnMouseReleased(const ui::MouseEvent& event) override;
+  void OnMouseCaptureLost() override;
 
  private:
   FRIEND_TEST_ALL_PREFIXES(LabelTest, ResetRenderTextData);
   FRIEND_TEST_ALL_PREFIXES(LabelTest, MultilineSupportedRenderText);
   FRIEND_TEST_ALL_PREFIXES(LabelTest, TextChangeWithoutLayout);
-  FRIEND_TEST_ALL_PREFIXES(LabelFocusTest, FocusBounds);
-  FRIEND_TEST_ALL_PREFIXES(LabelFocusTest, EmptyLabel);
+  FRIEND_TEST_ALL_PREFIXES(LabelTest, EmptyLabel);
+  FRIEND_TEST_ALL_PREFIXES(LabelTest, FocusBounds);
+  FRIEND_TEST_ALL_PREFIXES(LabelTest, MultiLineSizingWithElide);
+  friend class LabelTest;
+
+  // SelectionControllerDelegate overrides:
+  gfx::RenderText* GetRenderTextForSelectionController() override;
+  bool IsReadOnly() const override;
+  bool SupportsDrag() const override;
+  bool HasTextBeingDragged() const override;
+  void SetTextBeingDragged(bool value) override;
+  int GetViewHeight() const override;
+  int GetViewWidth() const override;
+  int GetDragSelectionDelay() const override;
+  void OnBeforePointerAction() override;
+  void OnAfterPointerAction(bool text_changed, bool selection_changed) override;
+  bool PasteSelectionClipboard() override;
+  void UpdateSelectionClipboard() override;
+
+  const gfx::RenderText* GetRenderTextForSelectionController() const;
 
   void Init(const base::string16& text, const gfx::FontList& font_list);
 
   void ResetLayout();
 
   // Set up |lines_| to actually be painted.
-  void MaybeBuildRenderTextLines();
+  void MaybeBuildRenderTextLines() const;
 
-  gfx::Rect GetFocusBounds();
+  gfx::Rect GetFocusBounds() const;
 
   // Get the text broken into lines as needed to fit the given |width|.
   std::vector<base::string16> GetLinesForWidth(int width) const;
 
   // Get the text size for the current layout.
   gfx::Size GetTextSize() const;
 
   // Updates |actual_{enabled,disabled}_color_| from requested colors.
   void RecalculateColors();
 
   // Applies |actual_{enabled,disabled}_color_| to |lines_|.
-  void ApplyTextColors();
+  void ApplyTextColors() const;
 
   // Updates any colors that have not been explicitly set from the theme.
   void UpdateColorsFromTheme(const ui::NativeTheme* theme);
 
   bool ShouldShowDefaultTooltip() const;
 
+  // Empties |lines_| and updates |stored_selection_range_|.
+  void ClearRenderTextLines() const;
+
   // An un-elided and single-line RenderText object used for preferred sizing.
   std::unique_ptr<gfx::RenderText> render_text_;
 
   // The RenderText instances used to display elided and multi-line text.
-  std::vector<std::unique_ptr<gfx::RenderText>> lines_;
+  mutable std::vector<std::unique_ptr<gfx::RenderText>> lines_;
+
+  // Persists the current selection range between the calls to
+  // ClearRenderTextLines() and MaybeBuildRenderTextLines(). Holds an
+  // InvalidRange when not in use.
+  mutable gfx::Range stored_selection_range_;
 
   SkColor requested_enabled_color_ = SK_ColorRED;
   SkColor actual_enabled_color_ = SK_ColorRED;
   SkColor requested_disabled_color_ = SK_ColorRED;
   SkColor actual_disabled_color_ = SK_ColorRED;
   SkColor background_color_ = SK_ColorRED;
+  SkColor requested_selection_text_color_ = SK_ColorRED;
+  SkColor actual_selection_text_color_ = SK_ColorRED;
+  SkColor selection_background_color_ = SK_ColorRED;
 
   // Set to true once the corresponding setter is invoked.
   bool enabled_color_set_;
   bool disabled_color_set_;
   bool background_color_set_;
+  bool selection_text_color_set_;
+  bool selection_background_color_set_;
 
   gfx::ElideBehavior elide_behavior_;
 
   bool subpixel_rendering_enabled_;
   bool auto_color_readability_;
   // TODO(mukai): remove |multi_line_| when all RenderText can render multiline.
   bool multi_line_;
   base::string16 tooltip_text_;
   bool handles_tooltips_;
   // Whether to collapse the label when it's not visible.
   bool collapse_when_hidden_;
   int fixed_width_;
   int max_width_;
 
   // TODO(ckocagil): Remove is_first_paint_text_ before crbug.com/441028 is
   // closed.
   bool is_first_paint_text_;
 
+  std::unique_ptr<SelectionController> selection_controller_;
+
   DISALLOW_COPY_AND_ASSIGN(Label);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_LABEL_H_