content/browser/renderer_host/input/touch_selection_controller_client_aura.cc

   1 // Copyright 2015 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/renderer_host/input/touch_selection_controller_client_aura.h"
   6
   7 #include "content/browser/renderer_host/render_widget_host_delegate.h"
   8 #include "content/browser/renderer_host/render_widget_host_impl.h"
   9 #include "content/browser/renderer_host/render_widget_host_view_aura.h"
  10 #include "content/common/view_messages.h"
  11 #include "content/public/browser/render_view_host.h"
  12 #include "ui/aura/client/cursor_client.h"
  13 #include "ui/aura/client/screen_position_client.h"
  14 #include "ui/aura/env.h"
  15 #include "ui/aura/window.h"
  16 #include "ui/base/clipboard/clipboard.h"
  17 #include "ui/gfx/geometry/point_conversions.h"
  18 #include "ui/gfx/geometry/size_conversions.h"
  19 #include "ui/strings/grit/ui_strings.h"
  20 #include "ui/touch_selection/touch_handle_drawable_aura.h"
  21 #include "ui/touch_selection/touch_selection_menu_runner.h"
  22
  23 namespace content {
  24 namespace {
  25
  26 // Delay before showing the quick menu, in milliseconds.
  27 const int kQuickMenuDelayInMs = 100;
  28
  29 gfx::Rect ConvertRectToScreen(aura::Window* window, const gfx::RectF& rect) {
  30   gfx::Point origin = gfx::ToRoundedPoint(rect.origin());
  31   gfx::Point bottom_right = gfx::ToRoundedPoint(rect.bottom_right());
  32
  33   aura::Window* root_window = window->GetRootWindow();
  34   if (root_window) {
  35     aura::client::ScreenPositionClient* screen_position_client =
  36         aura::client::GetScreenPositionClient(root_window);
  37     if (screen_position_client) {
  38       screen_position_client->ConvertPointToScreen(window, &origin);
  39       screen_position_client->ConvertPointToScreen(window, &bottom_right);
  40     }
  41   }
  42   return gfx::Rect(origin.x(), origin.y(), bottom_right.x() - origin.x(),
  43                    bottom_right.y() - origin.y());
  44 }
  45
  46 }  // namespace
  47
  48 // A pre-target event handler for aura::Env which deactivates touch selection on
  49 // mouse and keyboard events.
  50 class TouchSelectionControllerClientAura::EnvPreTargetHandler
  51     : public ui::EventHandler {
  52  public:
  53   EnvPreTargetHandler(ui::TouchSelectionController* selection_controller,
  54                       aura::Window* window);
  55   ~EnvPreTargetHandler() override;
  56
  57  private:
  58   // EventHandler:
  59   void OnKeyEvent(ui::KeyEvent* event) override;
  60   void OnMouseEvent(ui::MouseEvent* event) override;
  61   void OnScrollEvent(ui::ScrollEvent* event) override;
  62
  63   ui::TouchSelectionController* selection_controller_;
  64   aura::Window* window_;
  65
  66   DISALLOW_COPY_AND_ASSIGN(EnvPreTargetHandler);
  67 };
  68
  69 TouchSelectionControllerClientAura::EnvPreTargetHandler::EnvPreTargetHandler(
  70     ui::TouchSelectionController* selection_controller,
  71     aura::Window* window)
  72     : selection_controller_(selection_controller), window_(window) {
  73   aura::Env::GetInstance()->AddPreTargetHandler(this);
  74 }
  75
  76 TouchSelectionControllerClientAura::EnvPreTargetHandler::
  77     ~EnvPreTargetHandler() {
  78   aura::Env::GetInstance()->RemovePreTargetHandler(this);
  79 }
  80
  81 void TouchSelectionControllerClientAura::EnvPreTargetHandler::OnKeyEvent(
  82     ui::KeyEvent* event) {
  83   DCHECK_NE(ui::TouchSelectionController::INACTIVE,
  84             selection_controller_->active_status());
  85
  86   selection_controller_->HideAndDisallowShowingAutomatically();
  87 }
  88
  89 void TouchSelectionControllerClientAura::EnvPreTargetHandler::OnMouseEvent(
  90     ui::MouseEvent* event) {
  91   DCHECK_NE(ui::TouchSelectionController::INACTIVE,
  92             selection_controller_->active_status());
  93
  94   // If mouse events are not enabled, this mouse event is synthesized from a
  95   // touch event in which case we don't want to deactivate touch selection.
  96   aura::client::CursorClient* cursor_client =
  97       aura::client::GetCursorClient(window_->GetRootWindow());
  98   if (!cursor_client || cursor_client->IsMouseEventsEnabled())
  99     selection_controller_->HideAndDisallowShowingAutomatically();
 100 }
 101
 102 void TouchSelectionControllerClientAura::EnvPreTargetHandler::OnScrollEvent(
 103     ui::ScrollEvent* event) {
 104   DCHECK_NE(ui::TouchSelectionController::INACTIVE,
 105             selection_controller_->active_status());
 106
 107   selection_controller_->HideAndDisallowShowingAutomatically();
 108 }
 109
 110 TouchSelectionControllerClientAura::TouchSelectionControllerClientAura(
 111     RenderWidgetHostViewAura* rwhva)
 112     : rwhva_(rwhva),
 113       quick_menu_timer_(
 114           FROM_HERE,
 115           base::TimeDelta::FromMilliseconds(kQuickMenuDelayInMs),
 116           base::Bind(&TouchSelectionControllerClientAura::ShowQuickMenu,
 117                      base::Unretained(this)),
 118           false),
 119       touch_down_(false),
 120       scroll_in_progress_(false),
 121       handle_drag_in_progress_(false) {
 122   DCHECK(rwhva_);
 123 }
 124
 125 TouchSelectionControllerClientAura::~TouchSelectionControllerClientAura() {
 126 }
 127
 128 void TouchSelectionControllerClientAura::OnWindowMoved() {
 129   UpdateQuickMenu();
 130 }
 131
 132 void TouchSelectionControllerClientAura::OnTouchDown() {
 133   touch_down_ = true;
 134   UpdateQuickMenu();
 135 }
 136
 137 void TouchSelectionControllerClientAura::OnTouchUp() {
 138   touch_down_ = false;
 139   UpdateQuickMenu();
 140 }
 141
 142 void TouchSelectionControllerClientAura::OnScrollStarted() {
 143   scroll_in_progress_ = true;
 144   rwhva_->selection_controller()->SetTemporarilyHidden(true);
 145   UpdateQuickMenu();
 146 }
 147
 148 void TouchSelectionControllerClientAura::OnScrollCompleted() {
 149   scroll_in_progress_ = false;
 150   rwhva_->selection_controller()->SetTemporarilyHidden(false);
 151   UpdateQuickMenu();
 152 }
 153
 154 bool TouchSelectionControllerClientAura::IsQuickMenuAllowed() const {
 155   return !touch_down_ && !scroll_in_progress_ && !handle_drag_in_progress_;
 156 }
 157
 158 void TouchSelectionControllerClientAura::ShowQuickMenu() {
 159   if (!ui::TouchSelectionMenuRunner::GetInstance())
 160     return;
 161
 162   gfx::RectF rect = rwhva_->selection_controller()->GetRectBetweenBounds();
 163
 164   // Clip rect, which is in |rwhva_|'s window's coordinate space, to client
 165   // bounds.
 166   gfx::PointF origin = rect.origin();
 167   gfx::PointF bottom_right = rect.bottom_right();
 168   gfx::Rect client_bounds = rwhva_->GetNativeView()->bounds();
 169   origin.SetToMax(client_bounds.origin());
 170   bottom_right.SetToMin(client_bounds.bottom_right());
 171   if (origin.x() > bottom_right.x() || origin.y() > bottom_right.y())
 172     return;
 173
 174   gfx::Vector2dF diagonal = bottom_right - origin;
 175   gfx::SizeF size(diagonal.x(), diagonal.y());
 176   gfx::RectF anchor_rect(origin, size);
 177
 178   // Calculate maximum handle image size;
 179   gfx::SizeF max_handle_size =
 180       rwhva_->selection_controller()->GetStartHandleRect().size();
 181   max_handle_size.SetToMax(
 182       rwhva_->selection_controller()->GetEndHandleRect().size());
 183
 184   aura::Window* parent = rwhva_->GetNativeView();
 185   ui::TouchSelectionMenuRunner::GetInstance()->OpenMenu(
 186       this, ConvertRectToScreen(parent, anchor_rect),
 187       gfx::ToRoundedSize(max_handle_size), parent->GetToplevelWindow());
 188 }
 189
 190 void TouchSelectionControllerClientAura::UpdateQuickMenu() {
 191   bool menu_is_showing =
 192       ui::TouchSelectionMenuRunner::GetInstance() &&
 193       ui::TouchSelectionMenuRunner::GetInstance()->IsRunning();
 194   bool menu_should_show = rwhva_->selection_controller()->active_status() !=
 195                               ui::TouchSelectionController::INACTIVE &&
 196                           IsQuickMenuAllowed();
 197
 198   // Hide the quick menu if there is any. This should happen even if the menu
 199   // should be shown again, in order to update its location or content.
 200   if (menu_is_showing)
 201     ui::TouchSelectionMenuRunner::GetInstance()->CloseMenu();
 202   else
 203     quick_menu_timer_.Stop();
 204
 205   // Start timer to show quick menu if necessary.
 206   if (menu_should_show) {
 207     if (show_quick_menu_immediately_for_test_)
 208       ShowQuickMenu();
 209     else
 210       quick_menu_timer_.Reset();
 211   }
 212 }
 213
 214 bool TouchSelectionControllerClientAura::SupportsAnimation() const {
 215   return false;
 216 }
 217
 218 void TouchSelectionControllerClientAura::SetNeedsAnimate() {
 219   NOTREACHED();
 220 }
 221
 222 void TouchSelectionControllerClientAura::MoveCaret(
 223     const gfx::PointF& position) {
 224   RenderWidgetHostImpl* host =
 225       RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost());
 226   host->MoveCaret(gfx::ToRoundedPoint(position));
 227 }
 228
 229 void TouchSelectionControllerClientAura::MoveRangeSelectionExtent(
 230     const gfx::PointF& extent) {
 231   RenderWidgetHostDelegate* host_delegate =
 232       RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost())->delegate();
 233   if (host_delegate)
 234     host_delegate->MoveRangeSelectionExtent(gfx::ToRoundedPoint(extent));
 235 }
 236
 237 void TouchSelectionControllerClientAura::SelectBetweenCoordinates(
 238     const gfx::PointF& base,
 239     const gfx::PointF& extent) {
 240   RenderWidgetHostDelegate* host_delegate =
 241       RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost())->delegate();
 242   if (host_delegate) {
 243     host_delegate->SelectRange(gfx::ToRoundedPoint(base),
 244                                gfx::ToRoundedPoint(extent));
 245   }
 246 }
 247
 248 void TouchSelectionControllerClientAura::OnSelectionEvent(
 249     ui::SelectionEventType event) {
 250   switch (event) {
 251     case ui::SELECTION_HANDLES_SHOWN:
 252     case ui::INSERTION_HANDLE_SHOWN:
 253       UpdateQuickMenu();
 254       env_pre_target_handler_.reset(new EnvPreTargetHandler(
 255           rwhva_->selection_controller(), rwhva_->GetNativeView()));
 256       break;
 257     case ui::SELECTION_HANDLES_CLEARED:
 258     case ui::INSERTION_HANDLE_CLEARED:
 259       env_pre_target_handler_.reset();
 260       UpdateQuickMenu();
 261       break;
 262     case ui::SELECTION_HANDLE_DRAG_STARTED:
 263     case ui::INSERTION_HANDLE_DRAG_STARTED:
 264       handle_drag_in_progress_ = true;
 265       UpdateQuickMenu();
 266       break;
 267     case ui::SELECTION_HANDLE_DRAG_STOPPED:
 268     case ui::INSERTION_HANDLE_DRAG_STOPPED:
 269       handle_drag_in_progress_ = false;
 270       UpdateQuickMenu();
 271       break;
 272     case ui::SELECTION_HANDLES_MOVED:
 273     case ui::INSERTION_HANDLE_MOVED:
 274       UpdateQuickMenu();
 275       break;
 276     case ui::INSERTION_HANDLE_TAPPED:
 277     case ui::SELECTION_ESTABLISHED:
 278     case ui::SELECTION_DISSOLVED:
 279       break;
 280   };
 281 }
 282
 283 scoped_ptr<ui::TouchHandleDrawable>
 284 TouchSelectionControllerClientAura::CreateDrawable() {
 285   return scoped_ptr<ui::TouchHandleDrawable>(
 286       new ui::TouchHandleDrawableAura(rwhva_->GetNativeView()));
 287 }
 288
 289 bool TouchSelectionControllerClientAura::IsCommandIdEnabled(
 290     int command_id) const {
 291   bool editable = rwhva_->GetTextInputType() != ui::TEXT_INPUT_TYPE_NONE;
 292   bool readable = rwhva_->GetTextInputType() != ui::TEXT_INPUT_TYPE_PASSWORD;
 293   gfx::Range selection_range;
 294   rwhva_->GetSelectionRange(&selection_range);
 295   bool has_selection = !selection_range.is_empty();
 296   switch (command_id) {
 297     case IDS_APP_CUT:
 298       return editable && readable && has_selection;
 299     case IDS_APP_COPY:
 300       return readable && has_selection;
 301     case IDS_APP_PASTE: {
 302       base::string16 result;
 303       ui::Clipboard::GetForCurrentThread()->ReadText(
 304           ui::CLIPBOARD_TYPE_COPY_PASTE, &result);
 305       return editable && !result.empty();
 306     }
 307     default:
 308       return false;
 309   }
 310 }
 311
 312 void TouchSelectionControllerClientAura::ExecuteCommand(int command_id,
 313                                                         int event_flags) {
 314   rwhva_->selection_controller()->HideAndDisallowShowingAutomatically();
 315   RenderWidgetHostDelegate* host_delegate =
 316       RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost())->delegate();
 317   if (!host_delegate)
 318     return;
 319
 320   switch (command_id) {
 321     case IDS_APP_CUT:
 322       host_delegate->Cut();
 323       break;
 324     case IDS_APP_COPY:
 325       host_delegate->Copy();
 326       break;
 327     case IDS_APP_PASTE:
 328       host_delegate->Paste();
 329       break;
 330     default:
 331       NOTREACHED();
 332       break;
 333   }
 334 }
 335
 336 void TouchSelectionControllerClientAura::RunContextMenu() {
 337   gfx::RectF anchor_rect =
 338       rwhva_->selection_controller()->GetRectBetweenBounds();
 339   gfx::PointF anchor_point =
 340       gfx::PointF(anchor_rect.CenterPoint().x(), anchor_rect.y());
 341   RenderWidgetHostImpl* host =
 342       RenderWidgetHostImpl::From(rwhva_->GetRenderWidgetHost());
 343   host->Send(new ViewMsg_ShowContextMenu(host->GetRoutingID(),
 344                                          ui::MENU_SOURCE_TOUCH_EDIT_MENU,
 345                                          gfx::ToRoundedPoint(anchor_point)));
 346
 347   // Hide selection handles after getting rect-between-bounds from touch
 348   // selection controller; otherwise, rect would be empty and the above
 349   // calculations would be invalid.
 350   rwhva_->selection_controller()->HideAndDisallowShowingAutomatically();
 351 }
 352
 353 }  // namespace content