Views Textfield: copy-on-select and paste-on-middle-click.

ui/views/controls/textfield/textfield.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/textfield/textfield.h"
 
 #include <string>
 
 #include "base/debug/trace_event.h"
 #include "grit/ui_strings.h"
 #include "ui/base/accessibility/accessible_view_state.h"
+#include "ui/base/clipboard/scoped_clipboard_writer.h"
 #include "ui/base/dragdrop/drag_drop_types.h"
 #include "ui/base/dragdrop/drag_utils.h"
 #include "ui/base/resource/resource_bundle.h"
 #include "ui/base/ui_base_switches_util.h"
 #include "ui/events/event.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/canvas.h"
 #include "ui/gfx/insets.h"
 #include "ui/native_theme/native_theme.h"
 #include "ui/views/background.h"
@@ skipping 122 matching lines @@
   OnCaretBoundsChanged();
   SchedulePaint();
 }
 
 base::i18n::TextDirection Textfield::GetTextDirection() const {
   return GetRenderText()->GetTextDirection();
 }
 
 void Textfield::SelectAll(bool reversed) {
   model_->SelectAll(reversed);
-  OnCaretBoundsChanged();
-  SchedulePaint();
+  UpdateSelectionClipboard();
+  UpdateAfterChange(false, true);
 }
 
 base::string16 Textfield::GetSelectedText() const {
   return model_->GetSelectedText();
 }
 
 void Textfield::ClearSelection() {
   model_->ClearSelection();
-  OnCaretBoundsChanged();
-  SchedulePaint();
+  UpdateAfterChange(false, true);
 }
 
 bool Textfield::HasSelection() const {
   return !GetSelectedRange().is_empty();
 }
 
 SkColor Textfield::GetTextColor() const {
   if (!use_default_text_color_)
     return text_color_;
 
@@ skipping 58 matching lines @@
 bool Textfield::IsIMEComposing() const {
   return model_->HasCompositionText();
 }
 
 const gfx::Range& Textfield::GetSelectedRange() const {
   return GetRenderText()->selection();
 }
 
 void Textfield::SelectRange(const gfx::Range& range) {
   model_->SelectRange(range);
-  OnCaretBoundsChanged();
-  SchedulePaint();
-  NotifyAccessibilityEvent(
-      ui::AccessibilityTypes::EVENT_SELECTION_CHANGED, true);
+  UpdateAfterChange(false, true);
 }
 
 const gfx::SelectionModel& Textfield::GetSelectionModel() const {
   return GetRenderText()->selection_model();
 }
 
 void Textfield::SelectSelectionModel(const gfx::SelectionModel& sel) {
   model_->SelectSelectionModel(sel);
-  OnCaretBoundsChanged();
-  SchedulePaint();
+  UpdateAfterChange(false, true);
 }
 
 size_t Textfield::GetCursorPosition() const {
   return model_->GetCursorPosition();
 }
 
 void Textfield::SetColor(SkColor value) {
   GetRenderText()->SetColor(value);
   SchedulePaint();
 }
@@ skipping 95 matching lines @@
         else if (control && shift && !alt && editable)
           cursor_changed = text_changed = model_->Redo();
         break;
       case ui::VKEY_Y:
         if (control && !alt && editable)
           cursor_changed = text_changed = model_->Redo();
         break;
       case ui::VKEY_A:
         if (control && !alt) {
           model_->SelectAll(false);
+          UpdateSelectionClipboard();
           cursor_changed = true;
         }
         break;
       case ui::VKEY_X:
         if (control && !alt && editable && readable)
           cursor_changed = text_changed = Cut();
         break;
       case ui::VKEY_C:
         if (control && !alt && readable)
           Copy();
         break;
       case ui::VKEY_V:
         if (control && !alt && editable)
           cursor_changed = text_changed = Paste();
         break;
       case ui::VKEY_RIGHT:
       case ui::VKEY_LEFT: {
         // We should ignore the alt-left/right keys because alt key doesn't make
         // any special effects for them and they can be shortcut keys such like
         // forward/back of the browser history.
         if (alt)
           break;
         const gfx::Range selection_range = render_text->selection();
         model_->MoveCursor(
             control ? gfx::WORD_BREAK : gfx::CHARACTER_BREAK,
             (key_code == ui::VKEY_RIGHT) ? gfx::CURSOR_RIGHT : gfx::CURSOR_LEFT,
             shift);
+        UpdateSelectionClipboard();
         cursor_changed = render_text->selection() != selection_range;
         break;
       }
       case ui::VKEY_END:
       case ui::VKEY_HOME:
         if ((key_code == ui::VKEY_HOME) ==
             (render_text->GetTextDirection() == base::i18n::RIGHT_TO_LEFT))
           model_->MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_RIGHT, shift);
         else
           model_->MoveCursor(gfx::LINE_BREAK, gfx::CURSOR_LEFT, shift);
+        UpdateSelectionClipboard();
         cursor_changed = true;
         break;
       case ui::VKEY_BACK:
       case ui::VKEY_DELETE:
         if (!editable)
           break;
         if (!model_->HasSelection()) {
           gfx::VisualCursorDirection direction = (key_code == ui::VKEY_DELETE) ?
               gfx::CURSOR_RIGHT : gfx::CURSOR_LEFT;
           if (shift && control) {
@@ skipping 33 matching lines @@
     // We must have input method in order to support text input.
     DCHECK(GetInputMethod());
     UpdateAfterChange(text_changed, cursor_changed);
     OnAfterUserAction();
     return (text_changed || cursor_changed);
   }
   return false;
 }
 
 bool Textfield::OnMousePressed(const ui::MouseEvent& event) {
-  OnBeforeUserAction();
   TrackMouseClicks(event);
 
   if (!controller_ || !controller_->HandleMouseEvent(this, event)) {
     if (event.IsOnlyLeftMouseButton() || event.IsOnlyRightMouseButton())
       RequestFocus();
 
     if (event.IsOnlyLeftMouseButton()) {
+      OnBeforeUserAction();
       initiating_drag_ = false;
-      bool can_drag = true;
-
       switch (aggregated_clicks_) {
         case 0:
-          if (can_drag &&
-              GetRenderText()->IsPointInSelection(event.location())) {
+          if (GetRenderText()->IsPointInSelection(event.location()))
             initiating_drag_ = true;
-          } else {
+          else
             MoveCursorTo(event.location(), event.IsShiftDown());
-          }
           break;
         case 1:
-          MoveCursorTo(event.location(), false);
+          model_->MoveCursorTo(event.location(), false);
           model_->SelectWord();
+          UpdateAfterChange(false, true);
           double_click_word_ = GetRenderText()->selection();
-          OnCaretBoundsChanged();
           break;
         case 2:
-          model_->SelectAll(false);
-          OnCaretBoundsChanged();
+          SelectAll(false);
           break;
         default:
           NOTREACHED();
       }
+      OnAfterUserAction();
     }
-    SchedulePaint();
+
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+    if (event.IsOnlyMiddleMouseButton()) {
+      if (GetRenderText()->IsPointInSelection(event.location())) {
+        OnBeforeUserAction();
+        ClearSelection();
+        ui::ScopedClipboardWriter(
+            ui::Clipboard::GetForCurrentThread(),
+            ui::CLIPBOARD_TYPE_SELECTION).WriteText(base::string16());
+        OnAfterUserAction();
+      } else if(!read_only()) {
+        PasteSelectionClipboard(event);
+      }
+    }
+#endif
   }
 
-  OnAfterUserAction();
   touch_selection_controller_.reset();
   return true;
 }
 
 bool Textfield::OnMouseDragged(const ui::MouseEvent& event) {
   // Don't adjust the cursor on a potential drag and drop, or if the mouse
   // movement from the last mouse click does not exceed the drag threshold.
   if (initiating_drag_ || !event.IsOnlyLeftMouseButton() ||
       !ExceededDragThreshold(event.location() - last_click_location_)) {
     return true;
   }
 
-  if (!event.IsOnlyRightMouseButton()) {
-    OnBeforeUserAction();
-    MoveCursorTo(event.location(), true);
-    if (aggregated_clicks_ == 1) {
-      model_->SelectWord();
-      // Expand the selection so the initially selected word remains selected.
-      gfx::Range selection = GetRenderText()->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);
-      model_->SelectRange(selection);
-    }
-    SchedulePaint();
-    OnAfterUserAction();
+  OnBeforeUserAction();
+  model_->MoveCursorTo(event.location(), true);
+  if (aggregated_clicks_ == 1) {
+    model_->SelectWord();
+    // Expand the selection so the initially selected word remains selected.
+    gfx::Range selection = GetRenderText()->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);
+    model_->SelectRange(selection);
   }
+  UpdateAfterChange(false, true);
+  OnAfterUserAction();
   return true;
 }
 
 void Textfield::OnMouseReleased(const ui::MouseEvent& event) {
   OnBeforeUserAction();
   // Cancel suspected drag initiations, the user was clicking in the selection.
-  if (initiating_drag_ && MoveCursorTo(event.location(), false))
-    SchedulePaint();
+  if (initiating_drag_)
+    MoveCursorTo(event.location(), false);
   initiating_drag_ = false;
+  UpdateSelectionClipboard();
   OnAfterUserAction();
 }
 
 void Textfield::OnFocus() {
   GetRenderText()->set_focused(true);
   cursor_visible_ = true;
   SchedulePaint();
   GetInputMethod()->OnFocus();
   OnCaretBoundsChanged();
 
@@ skipping 79 matching lines @@
 #endif
 }
 
 void Textfield::OnGestureEvent(ui::GestureEvent* event) {
   switch (event->type()) {
     case ui::ET_GESTURE_TAP_DOWN:
       OnBeforeUserAction();
       RequestFocus();
       // We don't deselect if the point is in the selection
       // because TAP_DOWN may turn into a LONG_PRESS.
-      if (!GetRenderText()->IsPointInSelection(event->location()) &&
-          MoveCursorTo(event->location(), false))
-        SchedulePaint();
+      if (!GetRenderText()->IsPointInSelection(event->location()))
+        MoveCursorTo(event->location(), false);
       OnAfterUserAction();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_UPDATE:
       OnBeforeUserAction();
-      if (MoveCursorTo(event->location(), true))
-        SchedulePaint();
+      MoveCursorTo(event->location(), true);
       OnAfterUserAction();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_SCROLL_END:
     case ui::ET_SCROLL_FLING_START:
       CreateTouchSelectionControllerAndNotifyIt();
       event->SetHandled();
       break;
     case ui::ET_GESTURE_TAP:
       if (event->details().tap_count() == 1) {
@@ skipping 15 matching lines @@
       // |touch_selection_controller_|, hence we mark the event handled.
       // Otherwise, the regular context menu will be shown by views).
       // If long press happens in selected text and touch drag drop is enabled,
       // we will turn off touch selection (if one exists) and let views do drag
       // drop.
       if (!GetRenderText()->IsPointInSelection(event->location())) {
         OnBeforeUserAction();
         model_->SelectWord();
         touch_selection_controller_.reset(
             ui::TouchSelectionController::create(this));
-        OnCaretBoundsChanged();
-        SchedulePaint();
+        UpdateAfterChange(false, true);
         OnAfterUserAction();
         if (touch_selection_controller_)
           event->SetHandled();
       } else if (switches::IsTouchDragDropEnabled()) {
         initiating_drag_ = true;
         touch_selection_controller_.reset();
       } else {
         if (!touch_selection_controller_)
           CreateTouchSelectionControllerAndNotifyIt();
         if (touch_selection_controller_)
@@ skipping 188 matching lines @@
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   gfx::SelectionModel start_caret = GetRenderText()->FindCursorPosition(start);
   gfx::SelectionModel end_caret = GetRenderText()->FindCursorPosition(end);
   gfx::SelectionModel selection(
       gfx::Range(start_caret.caret_pos(), end_caret.caret_pos()),
       end_caret.caret_affinity());
 
   OnBeforeUserAction();
-  model_->SelectSelectionModel(selection);
-  OnCaretBoundsChanged();
-  SchedulePaint();
+  SelectSelectionModel(selection);
   OnAfterUserAction();
 }
 
 void Textfield::MoveCaretTo(const gfx::Point& point) {
   SelectRect(point, point);
 }
 
 void Textfield::GetSelectionEndPoints(gfx::Rect* p1, gfx::Rect* p2) {
   gfx::RenderText* render_text = GetRenderText();
   const gfx::SelectionModel& sel = render_text->selection_model();
@@ skipping 63 matching lines @@
                                            ui::Accelerator* accelerator) {
   return false;
 }
 
 void Textfield::ExecuteCommand(int command_id, int event_flags) {
   touch_selection_controller_.reset();
   if (!IsCommandIdEnabled(command_id))
     return;
 
   bool text_changed = false;
+  OnBeforeUserAction();
   switch (command_id) {
     case IDS_APP_UNDO:
-      OnBeforeUserAction();
       text_changed = model_->Undo();
-      UpdateAfterChange(text_changed, text_changed);
-      OnAfterUserAction();
       break;
     case IDS_APP_CUT:
-      OnBeforeUserAction();
       text_changed = Cut();
-      UpdateAfterChange(text_changed, text_changed);
-      OnAfterUserAction();
       break;
     case IDS_APP_COPY:
-      OnBeforeUserAction();
       Copy();
-      OnAfterUserAction();
       break;
     case IDS_APP_PASTE:
-      OnBeforeUserAction();
       text_changed = Paste();
-      UpdateAfterChange(text_changed, text_changed);
-      OnAfterUserAction();
       break;
     case IDS_APP_DELETE:
-      OnBeforeUserAction();
       text_changed = model_->Delete();
-      UpdateAfterChange(text_changed, text_changed);
-      OnAfterUserAction();
       break;
     case IDS_APP_SELECT_ALL:
-      OnBeforeUserAction();
       SelectAll(false);
-      UpdateAfterChange(false, true);
-      OnAfterUserAction();
       break;
     default:
       NOTREACHED();
       break;
   }
+  UpdateAfterChange(text_changed, text_changed);
+  OnAfterUserAction();
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 // Textfield, ui::TextInputClient overrides:
 
 void Textfield::SetCompositionText(const ui::CompositionText& composition) {
   if (GetTextInputType() == ui::TEXT_INPUT_TYPE_NONE)
     return;
 
   OnBeforeUserAction();
@@ skipping 155 matching lines @@
 bool Textfield::GetSelectionRange(gfx::Range* range) const {
   if (!ImeEditingAllowed())
     return false;
   *range = GetRenderText()->selection();
   return true;
 }
 
 bool Textfield::SetSelectionRange(const gfx::Range& range) {
   if (!ImeEditingAllowed() || !range.IsValid())
     return false;
-
   OnBeforeUserAction();
   SelectRange(range);
   OnAfterUserAction();
   return true;
 }
 
 bool Textfield::DeleteRange(const gfx::Range& range) {
   if (!ImeEditingAllowed() || range.is_empty())
     return false;
 
@@ skipping 143 matching lines @@
                                   !HasSelection());
   render_text->Draw(canvas);
 
   // Draw the detached drop cursor that marks where the text will be dropped.
   if (drop_cursor_visible_)
     render_text->DrawCursor(canvas, drop_cursor_position_);
 
   canvas->Restore();
 }
 
-bool Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
-  if (!model_->MoveCursorTo(point, select))
-    return false;
-  OnCaretBoundsChanged();
-  return true;
+void Textfield::MoveCursorTo(const gfx::Point& point, bool select) {
+  if (model_->MoveCursorTo(point, select))
+    UpdateAfterChange(false, true);
 }
 
 void Textfield::OnCaretBoundsChanged() {
   if (GetInputMethod())
     GetInputMethod()->OnCaretBoundsChanged(this);
   if (touch_selection_controller_)
     touch_selection_controller_->SelectionChanged();
 }
 
 void Textfield::OnBeforeUserAction() {
@@ skipping 88 matching lines @@
 
 void Textfield::CreateTouchSelectionControllerAndNotifyIt() {
   if (!touch_selection_controller_) {
     touch_selection_controller_.reset(
         ui::TouchSelectionController::create(this));
   }
   if (touch_selection_controller_)
     touch_selection_controller_->SelectionChanged();
 }
 
+void Textfield::UpdateSelectionClipboard() const {
+#if defined(OS_LINUX) && !defined(OS_CHROMEOS)
+  if (HasSelection()) {
+    ui::ScopedClipboardWriter(
+        ui::Clipboard::GetForCurrentThread(),
+        ui::CLIPBOARD_TYPE_SELECTION).WriteText(GetSelectedText());
+  }
+#endif
+}
+
+void Textfield::PasteSelectionClipboard(const ui::MouseEvent& event) {
+  DCHECK(event.IsOnlyMiddleMouseButton());
+  DCHECK(!read_only());
+  base::string16 selection_clipboard_text;
+  ui::Clipboard::GetForCurrentThread()->ReadText(
+      ui::CLIPBOARD_TYPE_SELECTION, &selection_clipboard_text);
+  if (!selection_clipboard_text.empty()) {
+    OnBeforeUserAction();
+    gfx::Range range = GetSelectionModel().selection();
+    gfx::LogicalCursorDirection affinity = GetSelectionModel().caret_affinity();
+    const gfx::SelectionModel mouse =
+        GetRenderText()->FindCursorPosition(event.location());
+    model_->MoveCursorTo(mouse);
+    model_->InsertText(selection_clipboard_text);
+    // Update the new selection range as needed.
+    if (range.GetMin() >= mouse.caret_pos()) {
+      const size_t length = selection_clipboard_text.length();
+      range = gfx::Range(range.start() + length, range.end() + length);
+    }
+    model_->MoveCursorTo(gfx::SelectionModel(range, affinity));
+    UpdateAfterChange(true, true);
+    OnAfterUserAction();
+  }
+}
+
 }  // namespace views