Views: Extract text selection code from Textfield.

ui/views/controls/textfield/textfield.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_TEXTFIELD_TEXTFIELD_H_
 #define UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_
 
 #include <stddef.h>
 #include <stdint.h>
 
@@ skipping 11 matching lines @@
 #include "ui/base/models/simple_menu_model.h"
 #include "ui/base/touch/touch_editing_controller.h"
 #include "ui/events/keycodes/keyboard_codes.h"
 #include "ui/gfx/font_list.h"
 #include "ui/gfx/range/range.h"
 #include "ui/gfx/selection_model.h"
 #include "ui/gfx/text_constants.h"
 #include "ui/views/context_menu_controller.h"
 #include "ui/views/controls/textfield/textfield_model.h"
 #include "ui/views/drag_controller.h"
+#include "ui/views/selection_controller.h"
+#include "ui/views/selection_controller_delegate.h"
 #include "ui/views/view.h"
 #include "ui/views/word_lookup_client.h"
 
 namespace views {
 
 class MenuRunner;
 class Painter;
 class TextfieldController;
 
 // A views/skia textfield implementation. No platform-specific code is used.
 class VIEWS_EXPORT Textfield : public View,
                                public TextfieldModel::Delegate,
                                public ContextMenuController,
                                public DragController,
                                public WordLookupClient,
+                               public SelectionControllerDelegate,
                                public ui::TouchEditable,
                                public ui::TextInputClient {
  public:
   // The textfield's class name.
   static const char kViewClassName[];
 
   // The preferred size of the padding to be used around textfield text.
   static const int kTextPadding;
 
   // Returns the text cursor blink time in milliseconds, or 0 for no blinking.
@@ skipping 146 matching lines @@
   // Empty and invalid ranges are ignored.
   void SetStyle(gfx::TextStyle style, bool value);
   void ApplyStyle(gfx::TextStyle style, bool value, const gfx::Range& range);
 
   // Clears Edit history.
   void ClearEditHistory();
 
   // Set the accessible name of the text field.
   void SetAccessibleName(const base::string16& name);
 
-  // Returns whether there is a drag operation originating from the textfield.
-  bool HasTextBeingDragged();
-
   // View overrides:
   gfx::Insets GetInsets() const override;
   int GetBaseline() const override;
   gfx::Size GetPreferredSize() const override;
   const char* GetClassName() const override;
   void SetBorder(std::unique_ptr<Border> b) override;
   gfx::NativeCursor GetCursor(const ui::MouseEvent& event) 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;
   WordLookupClient* GetWordLookupClient() override;
   void OnGestureEvent(ui::GestureEvent* event) override;
   bool AcceleratorPressed(const ui::Accelerator& accelerator) override;
   bool CanHandleAccelerators() const override;
   void AboutToRequestFocusFromTabTraversal(bool reverse) override;
   bool SkipDefaultKeyEventProcessing(const ui::KeyEvent& event) override;
   bool GetDropFormats(
       int* formats,
       std::set<ui::Clipboard::FormatType>* format_types) override;
   bool CanDrop(const ui::OSExchangeData& data) override;
@@ skipping 27 matching lines @@
   int GetDragOperationsForView(View* sender, const gfx::Point& p) override;
   bool CanStartDragForView(View* sender,
                            const gfx::Point& press_pt,
                            const gfx::Point& p) override;
 
   // WordLookupClient overrides:
   bool GetDecoratedWordAtPoint(const gfx::Point& point,
                                gfx::DecoratedText* decorated_word,
                                gfx::Point* baseline_point) override;
 
+  // SelectionControllerDelegate overrides:
+  bool HasTextBeingDragged() const override;
+
   // ui::TouchEditable overrides:
   void SelectRect(const gfx::Point& start, const gfx::Point& end) override;
   void MoveCaretTo(const gfx::Point& point) override;
   void GetSelectionEndPoints(gfx::SelectionBound* anchor,
                              gfx::SelectionBound* focus) override;
   gfx::Rect GetBounds() override;
   gfx::NativeView GetNativeView() const override;
   void ConvertPointToScreen(gfx::Point* point) override;
   void ConvertPointFromScreen(gfx::Point* point) override;
   bool DrawsHandles() override;
@@ skipping 37 matching lines @@
   bool IsTextEditCommandEnabled(ui::TextEditCommand command) const override;
   void SetTextEditCommandForNextKeyEvent(ui::TextEditCommand command) override;
 
  protected:
   // Inserts or appends a character in response to an IME operation.
   virtual void DoInsertChar(base::char16 ch);
 
   // Returns the TextfieldModel's text/cursor/selection rendering model.
   gfx::RenderText* GetRenderText() const;
 
-  gfx::Point last_click_location() const { return last_click_location_; }
+  gfx::Point GetLastClickLocation() const;
 
   // Get the text from the selection clipboard.
   virtual base::string16 GetSelectionClipboardText() const;
 
   // Executes the given |command|.
   virtual void ExecuteTextEditCommand(ui::TextEditCommand command);
 
  private:
   friend class TextfieldTestApi;
 
   // View overrides:
   // Declared final since overriding by subclasses would interfere with the
   // accounting related to the scheduled text edit command. Subclasses should
   // use TextfieldController::HandleKeyEvent, to intercept the key event.
   bool OnKeyPressed(const ui::KeyEvent& event) final;
   bool OnKeyReleased(const ui::KeyEvent& event) final;
 
+  // SelectionControllerDelegate overrides:
+  gfx::RenderText* GetRenderTextForSelectionController() override;
+  bool IsReadOnly() 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;
+  // Callers within Textfield should call UpdateAfterChange depending on the
+  // return value.
+  bool PasteSelectionClipboard() override;
+  void UpdateSelectionClipboard() override;
+
   // Handles a request to change the value of this text field from software
   // using an accessibility API (typically automation software, screen readers
   // don't normally use this). Sets the value and clears the selection.
   void AccessibilitySetValue(const base::string16& new_value);
 
   // Updates the painted background color.
   void UpdateBackgroundColor();
 
   // Updates the border per the state of |invalid_|.
   void UpdateBorder();
 
   // Does necessary updates when the text and/or cursor position changes.
   void UpdateAfterChange(bool text_changed, bool cursor_changed);
 
   // A callback function to periodically update the cursor state.
   void UpdateCursor();
 
   // Repaint the cursor.
   void RepaintCursor();
 
   void PaintTextAndCursor(gfx::Canvas* canvas);
 
   // Helper function to call MoveCursorTo on the TextfieldModel.
   void MoveCursorTo(const gfx::Point& point, bool select);
 
-  // Helper function to update the selection on a mouse drag.
-  void SelectThroughLastDragLocation();
-
   // Convenience method to notify the InputMethod and TouchSelectionController.
   void OnCaretBoundsChanged();
 
   // Convenience method to call TextfieldController::OnBeforeUserAction();
   void OnBeforeUserAction();
 
   // Convenience method to call TextfieldController::OnAfterUserAction();
   void OnAfterUserAction();
 
   // Calls |model_->Cut()| and notifies TextfieldController on success.
   bool Cut();
 
   // Calls |model_->Copy()| and notifies TextfieldController on success.
   bool Copy();
 
   // Calls |model_->Paste()| and calls TextfieldController::ContentsChanged()
   // explicitly if paste succeeded.
   bool Paste();
 
   // Utility function to prepare the context menu.
   void UpdateContextMenu();
 
-  // Tracks the mouse clicks for single/double/triple clicks.
-  void TrackMouseClicks(const ui::MouseEvent& event);
-
   // Returns true if the current text input type allows access by the IME.
   bool ImeEditingAllowed() const;
 
   // Reveals the password character at |index| for a set duration.
   // If |index| is -1, the existing revealed character will be reset.
   void RevealPasswordChar(int index);
 
   void CreateTouchSelectionControllerAndNotifyIt();
 
-  // Updates the selection clipboard to any non-empty text selection for a non-
-  // password textfield.
-  void UpdateSelectionClipboard() const;
-
-  // Pastes the selection clipboard for the specified mouse event.
-  void PasteSelectionClipboard(const ui::MouseEvent& event);
-
   // Called when editing a textfield fails because the textfield is readonly.
   void OnEditFailed();
 
   // Returns true if an insertion cursor should be visible (a vertical bar,
   // placed at the point new text will be inserted).
   bool ShouldShowCursor() const;
 
   // Returns true if an insertion cursor should be visible and blinking.
   bool ShouldBlinkCursor() const;
 
@@ skipping 53 matching lines @@
 
   // The input type of this text field.
   ui::TextInputType text_input_type_;
 
   // The input flags of this text field.
   int text_input_flags_;
 
   // The timer to reveal the last typed password character.
   base::OneShotTimer password_reveal_timer_;
 
-  // Tracks whether a user action is being performed; i.e. OnBeforeUserAction()
-  // has been called, but OnAfterUserAction() has not yet been called.
+  // Tracks whether a user action is being performed which may change the
+  // textfield; i.e. OnBeforeUserAction() has been called, but
+  // OnAfterUserAction() has not yet been called.
   bool performing_user_action_;
 
   // True if InputMethod::CancelComposition() should not be called.
   bool skip_input_method_cancel_composition_;
 
   // Insertion cursor repaint timer and visibility.
   base::RepeatingTimer cursor_blink_timer_;
 
   // The drop cursor is a visual cue for where dragged text will be dropped.
   bool drop_cursor_visible_;
   gfx::SelectionModel drop_cursor_position_;
 
   // Is the user potentially dragging and dropping from this view?
   bool initiating_drag_;
 
-  // A timer and point used to modify the selection when dragging.
-  base::RepeatingTimer drag_selection_timer_;
-  gfx::Point last_drag_location_;
-
-  // State variables used to track double and triple clicks.
-  size_t aggregated_clicks_;
-  base::TimeTicks last_click_time_;
-  gfx::Point last_click_location_;
-  gfx::Range double_click_word_;
-
   std::unique_ptr<ui::TouchEditingControllerDeprecated>
       touch_selection_controller_;
 
+  SelectionController selection_controller_;
+
   // Used to track touch drag starting location and offset to enable touch
   // scrolling.
   gfx::Point drag_start_location_;
   int drag_start_display_offset_;
 
   // Tracks if touch editing handles are hidden because user has started
   // scrolling. If |true|, handles are shown after scrolling ends.
   bool touch_handles_hidden_due_to_scroll_;
 
   // True if this textfield should use a focus ring to indicate focus.
   bool use_focus_ring_;
 
   // Context menu related members.
   std::unique_ptr<ui::SimpleMenuModel> context_menu_contents_;
   std::unique_ptr<views::MenuRunner> context_menu_runner_;
 
   // Used to bind callback functions to this object.
   base::WeakPtrFactory<Textfield> weak_ptr_factory_;
 
   DISALLOW_COPY_AND_ASSIGN(Textfield);
 };
 
 }  // namespace views
 
 #endif  // UI_VIEWS_CONTROLS_TEXTFIELD_TEXTFIELD_H_