content/browser/web_contents/touch_editable_impl_aura.cc

   1 // Copyright (c) 2013 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 #include "content/browser/web_contents/touch_editable_impl_aura.h"
   6
   7 #include "content/browser/renderer_host/render_widget_host_impl.h"
   8 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
   9 #include "content/browser/web_contents/web_contents_impl.h"
  10 #include "content/common/view_messages.h"
  11 #include "content/public/browser/render_view_host.h"
  12 #include "content/public/browser/render_widget_host.h"
  13 #include "ui/aura/client/screen_position_client.h"
  14 #include "ui/aura/window.h"
  15 #include "ui/aura/window_tree_host.h"
  16 #include "ui/base/clipboard/clipboard.h"
  17 #include "ui/base/touch/selection_bound.h"
  18 #include "ui/base/ui_base_switches_util.h"
  19 #include "ui/gfx/range/range.h"
  20 #include "ui/strings/grit/ui_strings.h"
  21 #include "ui/wm/public/activation_client.h"
  22
  23 namespace content {
  24
  25 ////////////////////////////////////////////////////////////////////////////////
  26 // TouchEditableImplAura, public:
  27
  28 TouchEditableImplAura::~TouchEditableImplAura() {
  29   Cleanup();
  30 }
  31
  32 // static
  33 TouchEditableImplAura* TouchEditableImplAura::Create() {
  34   if (switches::IsTouchEditingEnabled())
  35     return new TouchEditableImplAura();
  36   return NULL;
  37 }
  38
  39 void TouchEditableImplAura::AttachToView(RenderWidgetHostViewAura* view) {
  40   if (rwhva_ == view)
  41     return;
  42
  43   Cleanup();
  44   if (!view)
  45     return;
  46
  47   rwhva_ = view;
  48   rwhva_->set_touch_editing_client(this);
  49 }
  50
  51 void TouchEditableImplAura::UpdateEditingController() {
  52   if (!rwhva_ || !rwhva_->HasFocus())
  53     return;
  54
  55   if (text_input_type_ != ui::TEXT_INPUT_TYPE_NONE ||
  56       selection_anchor_ != selection_focus_) {
  57     if (touch_selection_controller_)
  58       touch_selection_controller_->SelectionChanged();
  59   } else {
  60     EndTouchEditing(false);
  61   }
  62 }
  63
  64 void TouchEditableImplAura::OverscrollStarted() {
  65   overscroll_in_progress_ = true;
  66 }
  67
  68 void TouchEditableImplAura::OverscrollCompleted() {
  69   overscroll_in_progress_ = false;
  70   StartTouchEditingIfNecessary();
  71 }
  72
  73 ////////////////////////////////////////////////////////////////////////////////
  74 // TouchEditableImplAura, RenderWidgetHostViewAura::TouchEditingClient
  75 // implementation:
  76
  77 void TouchEditableImplAura::StartTouchEditing() {
  78   if (!rwhva_ || !rwhva_->HasFocus())
  79     return;
  80
  81   if (!touch_selection_controller_) {
  82     touch_selection_controller_.reset(
  83         ui::TouchEditingControllerDeprecated::Create(this));
  84   }
  85   if (touch_selection_controller_)
  86     touch_selection_controller_->SelectionChanged();
  87 }
  88
  89 void TouchEditableImplAura::EndTouchEditing(bool quick) {
  90   if (touch_selection_controller_) {
  91     if (touch_selection_controller_->IsHandleDragInProgress()) {
  92       touch_selection_controller_->SelectionChanged();
  93     } else {
  94       selection_gesture_in_process_ = false;
  95       touch_selection_controller_->HideHandles(quick);
  96       touch_selection_controller_.reset();
  97     }
  98   }
  99 }
 100
 101 void TouchEditableImplAura::OnSelectionOrCursorChanged(
 102     const ui::SelectionBound& anchor,
 103     const ui::SelectionBound& focus) {
 104   selection_anchor_ = anchor;
 105   selection_focus_ = focus;
 106
 107   // If touch editing handles were not visible, we bring them up only if the
 108   // current event is a gesture event, no scroll/fling/overscoll is in progress,
 109   // and there is non-zero selection on the page
 110   if (selection_gesture_in_process_ && !scroll_in_progress_ &&
 111       !overscroll_in_progress_ && selection_anchor_ != selection_focus_) {
 112     StartTouchEditing();
 113     selection_gesture_in_process_ = false;
 114   }
 115
 116   UpdateEditingController();
 117 }
 118
 119 void TouchEditableImplAura::OnTextInputTypeChanged(ui::TextInputType type) {
 120   text_input_type_ = type;
 121 }
 122
 123 bool TouchEditableImplAura::HandleInputEvent(const ui::Event* event) {
 124   DCHECK(rwhva_);
 125   if (!event->IsGestureEvent()) {
 126     // Ignore all non-gesture events. Non-gesture events that can deactivate
 127     // touch editing are handled in TouchSelectionControllerImpl.
 128     return false;
 129   }
 130
 131   const ui::GestureEvent* gesture_event =
 132       static_cast<const ui::GestureEvent*>(event);
 133   switch (event->type()) {
 134     case ui::ET_GESTURE_TAP:
 135       // When the user taps, we want to show touch editing handles if user
 136       // tapped on selected text.
 137       if (gesture_event->details().tap_count() == 1 &&
 138           selection_anchor_ != selection_focus_) {
 139         gfx::Rect selection_rect =
 140             ui::RectBetweenSelectionBounds(selection_anchor_, selection_focus_);
 141         // When tap is on selection, show handles and mark event as handled only
 142         // if handles are not present or text is not editable. Otherwise, do not
 143         // set event as handles so that event is forwarded to the renderer to
 144         // update selection/cursor.
 145         if (selection_rect.Contains(gesture_event->location()) &&
 146             (text_input_type_ == ui::TEXT_INPUT_TYPE_NONE ||
 147                 !touch_selection_controller_)) {
 148           StartTouchEditing();
 149           return true;
 150         }
 151       }
 152       // For single taps, not inside selected region, we want to show handles
 153       // only when the tap is on an already focused textfield.
 154       textfield_was_focused_on_tap_ =
 155           gesture_event->details().tap_count() == 1 &&
 156           text_input_type_ != ui::TEXT_INPUT_TYPE_NONE;
 157       break;
 158     case ui::ET_GESTURE_LONG_PRESS:
 159       selection_gesture_in_process_ = true;
 160       break;
 161     case ui::ET_GESTURE_SCROLL_BEGIN:
 162       scroll_in_progress_ = true;;
 163       // We need to hide selection handles during scroll (including fling and
 164       // overscroll), but they should be re-activated after scrolling if:
 165       //  - an existing scroll decided that handles should be shown after
 166       //    scrolling; or
 167       //  - the gesture in progress is going to end in selection; or
 168       //  - selection handles are currently active.
 169       handles_hidden_due_to_scroll_ = handles_hidden_due_to_scroll_ ||
 170                                       selection_gesture_in_process_ ||
 171                                       touch_selection_controller_ != NULL;
 172       selection_gesture_in_process_ = false;
 173       EndTouchEditing(true);
 174       break;
 175     case ui::ET_GESTURE_SCROLL_END:
 176       scroll_in_progress_ = false;
 177       StartTouchEditingIfNecessary();
 178       break;
 179     default:
 180       break;
 181   }
 182   return false;
 183 }
 184
 185 void TouchEditableImplAura::GestureEventAck(int gesture_event_type) {
 186   DCHECK(rwhva_);
 187   if (gesture_event_type == blink::WebInputEvent::GestureTap &&
 188       text_input_type_ != ui::TEXT_INPUT_TYPE_NONE &&
 189       textfield_was_focused_on_tap_) {
 190     StartTouchEditing();
 191     UpdateEditingController();
 192   }
 193 }
 194
 195 void TouchEditableImplAura::DidStopFlinging() {
 196   scroll_in_progress_ = false;
 197   StartTouchEditingIfNecessary();
 198 }
 199
 200 void TouchEditableImplAura::OnViewDestroyed() {
 201   Cleanup();
 202 }
 203
 204 ////////////////////////////////////////////////////////////////////////////////
 205 // TouchEditableImplAura, ui::TouchEditable implementation:
 206
 207 void TouchEditableImplAura::SelectRect(const gfx::Point& start,
 208                                        const gfx::Point& end) {
 209   RenderWidgetHost* host = rwhva_->GetRenderWidgetHost();
 210   RenderViewHost* rvh = RenderViewHost::From(host);
 211   WebContentsImpl* wc =
 212       static_cast<WebContentsImpl*>(WebContents::FromRenderViewHost(rvh));
 213   wc->SelectRange(start, end);
 214 }
 215
 216 void TouchEditableImplAura::MoveCaretTo(const gfx::Point& point) {
 217   if (!rwhva_)
 218     return;
 219
 220   RenderWidgetHostImpl* host = RenderWidgetHostImpl::From(
 221       rwhva_->GetRenderWidgetHost());
 222   host->MoveCaret(point);
 223 }
 224
 225 void TouchEditableImplAura::GetSelectionEndPoints(ui::SelectionBound* anchor,
 226                                                   ui::SelectionBound* focus) {
 227   *anchor = selection_anchor_;
 228   *focus = selection_focus_;
 229 }
 230
 231 gfx::Rect TouchEditableImplAura::GetBounds() {
 232   return rwhva_ ? gfx::Rect(rwhva_->GetNativeView()->bounds().size()) :
 233       gfx::Rect();
 234 }
 235
 236 gfx::NativeView TouchEditableImplAura::GetNativeView() const {
 237   return rwhva_ ? rwhva_->GetNativeView()->GetToplevelWindow() : NULL;
 238 }
 239
 240 void TouchEditableImplAura::ConvertPointToScreen(gfx::Point* point) {
 241   if (!rwhva_)
 242     return;
 243   aura::Window* window = rwhva_->GetNativeView();
 244   aura::client::ScreenPositionClient* screen_position_client =
 245       aura::client::GetScreenPositionClient(window->GetRootWindow());
 246   if (screen_position_client)
 247     screen_position_client->ConvertPointToScreen(window, point);
 248 }
 249
 250 void TouchEditableImplAura::ConvertPointFromScreen(gfx::Point* point) {
 251   if (!rwhva_)
 252     return;
 253   aura::Window* window = rwhva_->GetNativeView();
 254   aura::client::ScreenPositionClient* screen_position_client =
 255       aura::client::GetScreenPositionClient(window->GetRootWindow());
 256   if (screen_position_client)
 257     screen_position_client->ConvertPointFromScreen(window, point);
 258 }
 259
 260 bool TouchEditableImplAura::DrawsHandles() {
 261   return false;
 262 }
 263
 264 void TouchEditableImplAura::OpenContextMenu(const gfx::Point& anchor) {
 265   if (!rwhva_)
 266     return;
 267   gfx::Point point = anchor;
 268   ConvertPointFromScreen(&point);
 269   RenderWidgetHost* host = rwhva_->GetRenderWidgetHost();
 270   host->Send(new ViewMsg_ShowContextMenu(
 271       host->GetRoutingID(), ui::MENU_SOURCE_TOUCH_EDIT_MENU, point));
 272   EndTouchEditing(false);
 273 }
 274
 275 bool TouchEditableImplAura::IsCommandIdChecked(int command_id) const {
 276   NOTREACHED();
 277   return false;
 278 }
 279
 280 bool TouchEditableImplAura::IsCommandIdEnabled(int command_id) const {
 281   if (!rwhva_)
 282     return false;
 283   bool editable = rwhva_->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE;
 284   bool readable = rwhva_->GetTextInputType() != ui::TEXT_INPUT_TYPE_PASSWORD;
 285   gfx::Range selection_range;
 286   rwhva_->GetSelectionRange(&selection_range);
 287   bool has_selection = !selection_range.is_empty();
 288   switch (command_id) {
 289     case IDS_APP_CUT:
 290       return editable && readable && has_selection;
 291     case IDS_APP_COPY:
 292       return readable && has_selection;
 293     case IDS_APP_PASTE: {
 294       base::string16 result;
 295       ui::Clipboard::GetForCurrentThread()->ReadText(
 296           ui::CLIPBOARD_TYPE_COPY_PASTE, &result);
 297       return editable && !result.empty();
 298     }
 299     case IDS_APP_DELETE:
 300       return editable && has_selection;
 301     case IDS_APP_SELECT_ALL:
 302       return true;
 303     default:
 304       return false;
 305   }
 306 }
 307
 308 bool TouchEditableImplAura::GetAcceleratorForCommandId(
 309     int command_id,
 310     ui::Accelerator* accelerator) {
 311   return false;
 312 }
 313
 314 void TouchEditableImplAura::ExecuteCommand(int command_id, int event_flags) {
 315   RenderWidgetHost* host = rwhva_->GetRenderWidgetHost();
 316   RenderViewHost* rvh = RenderViewHost::From(host);
 317   WebContents* wc = WebContents::FromRenderViewHost(rvh);
 318
 319   switch (command_id) {
 320     case IDS_APP_CUT:
 321       wc->Cut();
 322       break;
 323     case IDS_APP_COPY:
 324       wc->Copy();
 325       break;
 326     case IDS_APP_PASTE:
 327       wc->Paste();
 328       break;
 329     case IDS_APP_DELETE:
 330       wc->Delete();
 331       break;
 332     case IDS_APP_SELECT_ALL:
 333       wc->SelectAll();
 334       break;
 335     default:
 336       NOTREACHED();
 337       break;
 338   }
 339   EndTouchEditing(false);
 340 }
 341
 342 void TouchEditableImplAura::DestroyTouchSelection() {
 343   EndTouchEditing(false);
 344 }
 345
 346 ////////////////////////////////////////////////////////////////////////////////
 347 // TouchEditableImplAura, private:
 348
 349 TouchEditableImplAura::TouchEditableImplAura()
 350     : text_input_type_(ui::TEXT_INPUT_TYPE_NONE),
 351       rwhva_(NULL),
 352       selection_gesture_in_process_(false),
 353       handles_hidden_due_to_scroll_(false),
 354       scroll_in_progress_(false),
 355       overscroll_in_progress_(false),
 356       textfield_was_focused_on_tap_(false) {
 357 }
 358
 359 void TouchEditableImplAura::StartTouchEditingIfNecessary() {
 360   // If there is no scrolling left in progress, show selection handles if they
 361   // were hidden due to scroll and there is a selection.
 362   if (!scroll_in_progress_ && !overscroll_in_progress_ &&
 363       handles_hidden_due_to_scroll_ &&
 364       (selection_anchor_ != selection_focus_ ||
 365           text_input_type_ != ui::TEXT_INPUT_TYPE_NONE)) {
 366     StartTouchEditing();
 367     UpdateEditingController();
 368     handles_hidden_due_to_scroll_ = false;
 369   }
 370 }
 371
 372 void TouchEditableImplAura::Cleanup() {
 373   if (rwhva_) {
 374     rwhva_->set_touch_editing_client(NULL);
 375     rwhva_ = NULL;
 376   }
 377   text_input_type_ = ui::TEXT_INPUT_TYPE_NONE;
 378   EndTouchEditing(true);
 379   selection_gesture_in_process_ = false;
 380   handles_hidden_due_to_scroll_ = false;
 381   scroll_in_progress_ = false;
 382   overscroll_in_progress_ = false;
 383 }
 384
 385 }  // namespace content