views::Label: Implement context menu, keyboard shortcuts for copy/select all.

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>
@@ skipping 11 matching lines @@
 #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/strings/grit/ui_strings.h"
+#include "ui/views/controls/menu/menu_runner.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()) {
 }
 
-Label::Label(const base::string16& text, const gfx::FontList& font_list) {
+Label::Label(const base::string16& text, const gfx::FontList& font_list)
+    : context_menu_contents_(this) {
   Init(text, font_list);
 }
 
 Label::~Label() {
 }
 
 // static
 const gfx::FontList& Label::GetDefaultFontList() {
   ui::ResourceBundle& rb = ui::ResourceBundle::GetSharedInstance();
   return rb.GetFontListWithDelta(ui::kLabelFontSizeDelta);
 }
 
 void Label::SetFontList(const gfx::FontList& font_list) {
   is_first_paint_text_ = true;
   render_text_->SetFontList(font_list);
   ResetLayout();
 }
 
 void Label::SetText(const base::string16& new_text) {
   if (new_text == text())
     return;
   is_first_paint_text_ = true;
   render_text_->SetText(new_text);
   ResetLayout();
+  stored_selection_range_ = gfx::Range::InvalidRange();
 }
 
 void Label::SetAutoColorReadabilityEnabled(bool enabled) {
   if (auto_color_readability_ == enabled)
     return;
   is_first_paint_text_ = true;
   auto_color_readability_ = enabled;
   RecalculateColors();
 }
 
@@ skipping 92 matching lines @@
   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);
+  if (obscured)
+    SetSelectable(false);
   ResetLayout();
 }
 
 void Label::SetAllowCharacterBreak(bool allow_character_break) {
   const gfx::WordWrapBehavior behavior =
       allow_character_break ? gfx::WRAP_LONG_WORDS : gfx::TRUNCATE_LONG_WORDS;
   if (render_text_->word_wrap_behavior() == behavior)
     return;
   render_text_->SetWordWrapBehavior(behavior);
   if (multi_line()) {
@@ skipping 43 matching lines @@
     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();
+  return !multi_line() && !obscured() && render_text_->IsSelectionSupported();
 }
 
 bool Label::SetSelectable(bool value) {
   if (value == selectable())
     return true;
 
   if (!value) {
     ClearSelection();
+    stored_selection_range_ = gfx::Range::InvalidRange();
     selection_controller_.reset();
     return true;
   }
 
+  DCHECK(!stored_selection_range_.IsValid());
   if (!IsSelectionSupported())
     return false;
 
   selection_controller_ = base::MakeUnique<SelectionController>(this);
   return true;
 }
 
 bool Label::HasSelection() const {
   const gfx::RenderText* render_text = GetRenderTextForSelectionController();
   return render_text ? !render_text->selection().is_empty() : false;
@@ skipping 267 matching lines @@
   selection_controller_->OnMouseReleased(event);
 }
 
 void Label::OnMouseCaptureLost() {
   if (!GetRenderTextForSelectionController())
     return;
 
   selection_controller_->OnMouseCaptureLost();
 }
 
+bool Label::OnKeyPressed(const ui::KeyEvent& event) {
+  if (!GetRenderTextForSelectionController())
+    return false;
+
+  const bool shift = event.IsShiftDown();
+  const bool control = event.IsControlDown();
+  const bool alt = event.IsAltDown() || event.IsAltGrDown();
+
+  switch (event.key_code()) {
+    case ui::VKEY_C:
+      if (control && !alt && HasSelection()) {
+        CopyToClipboard();
+        return true;
+      }
+      break;
+    case ui::VKEY_INSERT:
+      if (control && !shift && HasSelection()) {
+        CopyToClipboard();
+        return true;
+      }
+      break;
+    case ui::VKEY_A:
+      if (control && !alt && !text().empty()) {
+        SelectAll();
+        DCHECK(HasSelection());
+        UpdateSelectionClipboard();
+        return true;
+      }
+      break;
+    default:
+      break;
+  }
+
+  return false;
+}
+
+bool Label::AcceleratorPressed(const ui::Accelerator& accelerator) {
+  // Allow the "Copy" action from the Chrome menu to be invoked. E.g., if a user
+  // selects a Label on a web modal dialog. "Select All" doesn't appear in the
+  // Chrome menu so isn't handled here.
+  if (accelerator.key_code() == ui::VKEY_C && accelerator.IsCtrlDown()) {
+    CopyToClipboard();
+    return true;
+  }
+  return false;
+}
+
+bool Label::CanHandleAccelerators() const {
+  // Focus needs to be checked since the accelerator for the Copy command from
+  // the Chrome menu should only be handled when the current view has focus. See
+  // related comment in BrowserView::CutCopyPaste.
+  return HasFocus() && GetRenderTextForSelectionController() &&
+         View::CanHandleAccelerators();
+}
+
 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)
     ClearRenderTextLines();
 }
 
+void Label::ShowContextMenuForView(View* source,
+                                   const gfx::Point& point,
+                                   ui::MenuSourceType source_type) {
+  if (!GetRenderTextForSelectionController())
+    return;
+
+  context_menu_runner_.reset(
+      new MenuRunner(&context_menu_contents_, MenuRunner::HAS_MNEMONICS |
+                                                  MenuRunner::CONTEXT_MENU |
+                                                  MenuRunner::ASYNC));
+  ignore_result(context_menu_runner_->RunMenuAt(
+      GetWidget(), nullptr, gfx::Rect(point, gfx::Size()), MENU_ANCHOR_TOPLEFT,
+      source_type));
+}
+
 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 {
@@ skipping 34 matching lines @@
 }
 
 bool Label::PasteSelectionClipboard() {
   NOTREACHED();
   return false;
 }
 
 void Label::UpdateSelectionClipboard() {
 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
   if (!obscured()) {
-    const gfx::RenderText* render_text = GetRenderTextForSelectionController();
-    DCHECK(render_text);
-    const base::string16 selected_text =
-        render_text->GetTextFromRange(render_text->selection());
     ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_SELECTION)
-        .WriteText(selected_text);
+        .WriteText(GetSelectedText());
   }
 #endif
 }
 
+bool Label::IsCommandIdChecked(int command_id) const {
+  return true;
+}
+
+bool Label::IsCommandIdEnabled(int command_id) const {
+  switch (command_id) {
+    case IDS_APP_COPY:
+      return HasSelection() && !obscured();
+    case IDS_APP_SELECT_ALL:
+      return GetRenderTextForSelectionController() && !text().empty();
+  }
+  return false;
+}
+
+void Label::ExecuteCommand(int command_id, int event_flags) {
+  switch (command_id) {
+    case IDS_APP_COPY:
+      CopyToClipboard();
+      break;
+    case IDS_APP_SELECT_ALL:
+      SelectAll();
+      DCHECK(HasSelection());
+      UpdateSelectionClipboard();
+      break;
+    default:
+      NOTREACHED();
+  }
+}
+
+bool Label::GetAcceleratorForCommandId(int command_id,
+                                       ui::Accelerator* accelerator) const {
+  switch (command_id) {
+    case IDS_APP_COPY:
+      *accelerator = ui::Accelerator(ui::VKEY_C, ui::EF_CONTROL_DOWN);
+      return true;
+
+    case IDS_APP_SELECT_ALL:
+      *accelerator = ui::Accelerator(ui::VKEY_A, ui::EF_CONTROL_DOWN);
+      return true;
+
+    default:
+      return false;
+  }
+}
+
 const gfx::RenderText* Label::GetRenderTextForSelectionController() const {
   if (!selectable())
     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());
@@ skipping 18 matching lines @@
   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);
+
+  // Only selectable labels will get requests to show the context menu, due to
+  // CanProcessEventsWithinSubtree().
+  BuildContextMenuContents();
+  set_context_menu_controller(this);
+
+  // This allows the BrowserView to pass the copy command from the Chrome menu
+  // to the Label.
+  AddAccelerator(ui::Accelerator(ui::VKEY_C, ui::EF_CONTROL_DOWN));
 }
 
 void Label::ResetLayout() {
   InvalidateLayout();
   PreferredSizeChanged();
   SchedulePaint();
   ClearRenderTextLines();
 }
 
 void Label::MaybeBuildRenderTextLines() const {
@@ skipping 183 matching lines @@
 }
 
 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 {
+  // The HasSelection() call below will build |lines_| in case it is empty.
+  // Return early to avoid this.
+  if (lines_.empty())
+    return;
+
   // Persist the selection range if there is an active selection.
   if (HasSelection()) {
     stored_selection_range_ =
         GetRenderTextForSelectionController()->selection();
   }
   lines_.clear();
 }
 
+base::string16 Label::GetSelectedText() const {
+  const gfx::RenderText* render_text = GetRenderTextForSelectionController();
+  return render_text ? render_text->GetTextFromRange(render_text->selection())
+                     : base::string16();
+}
+
+void Label::CopyToClipboard() {
+  if (!HasSelection() || obscured())
+    return;
+  ui::ScopedClipboardWriter(ui::CLIPBOARD_TYPE_COPY_PASTE)
+      .WriteText(GetSelectedText());
+}
+
+void Label::BuildContextMenuContents() {
+  context_menu_contents_.AddItemWithStringId(IDS_APP_COPY, IDS_APP_COPY);
+  context_menu_contents_.AddItemWithStringId(IDS_APP_SELECT_ALL,
+                                             IDS_APP_SELECT_ALL);
+}
+
 }  // namespace views