content/browser/renderer_host/web_input_event_aura.cc

   1 // Copyright (c) 2012 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/web_input_event_aura.h"
   6
   7 #include "content/browser/renderer_host/input/web_input_event_util.h"
   8 #include "content/browser/renderer_host/ui_events_helper.h"
   9 #include "ui/aura/client/screen_position_client.h"
  10 #include "ui/aura/window.h"
  11 #include "ui/events/blink/blink_event_util.h"
  12 #include "ui/events/event.h"
  13 #include "ui/events/event_utils.h"
  14 #include "ui/events/keycodes/dom/keycode_converter.h"
  15
  16 namespace content {
  17
  18 namespace {
  19
  20 gfx::Point GetScreenLocationFromEvent(const ui::LocatedEvent& event) {
  21   if (!event.target())
  22     return event.root_location();
  23
  24   aura::Window* root =
  25       static_cast<aura::Window*>(event.target())->GetRootWindow();
  26   aura::client::ScreenPositionClient* spc =
  27       aura::client::GetScreenPositionClient(root);
  28   if (!spc)
  29     return event.root_location();
  30
  31   gfx::Point screen_location(event.root_location());
  32   spc->ConvertPointToScreen(root, &screen_location);
  33   return screen_location;
  34 }
  35
  36 blink::WebPointerProperties::PointerType EventPointerTypeToWebPointerType(
  37     ui::EventPointerType pointer_type) {
  38   switch (pointer_type) {
  39     case ui::EventPointerType::POINTER_TYPE_UNKNOWN:
  40       return blink::WebPointerProperties::PointerType::PointerTypeUnknown;
  41     case ui::EventPointerType::POINTER_TYPE_MOUSE:
  42       return blink::WebPointerProperties::PointerType::PointerTypeMouse;
  43     case ui::EventPointerType::POINTER_TYPE_PEN:
  44       return blink::WebPointerProperties::PointerType::PointerTypePen;
  45     case ui::EventPointerType::POINTER_TYPE_TOUCH:
  46       return blink::WebPointerProperties::PointerType::PointerTypeTouch;
  47   }
  48   NOTREACHED() << "Unexpected EventPointerType";
  49   return blink::WebPointerProperties::PointerType::PointerTypeUnknown;
  50 }
  51
  52 }  // namespace
  53
  54 #if defined(OS_WIN)
  55 blink::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent(
  56     const base::NativeEvent& native_event);
  57 blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent(
  58     const base::NativeEvent& native_event);
  59 blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent(
  60     const base::NativeEvent& native_event);
  61 blink::WebGestureEvent MakeWebGestureEventFromNativeEvent(
  62     const base::NativeEvent& native_event);
  63 #endif
  64
  65 blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent(
  66     const ui::KeyEvent& event) {
  67   blink::WebKeyboardEvent webkit_event;
  68
  69   webkit_event.timeStampSeconds = event.time_stamp().InSecondsF();
  70   webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags()) |
  71                            DomCodeToWebInputEventModifiers(event.code());
  72
  73   switch (event.type()) {
  74     case ui::ET_KEY_PRESSED:
  75       webkit_event.type = event.is_char() ? blink::WebInputEvent::Char :
  76           blink::WebInputEvent::RawKeyDown;
  77       break;
  78     case ui::ET_KEY_RELEASED:
  79       webkit_event.type = blink::WebInputEvent::KeyUp;
  80       break;
  81     default:
  82       NOTREACHED();
  83   }
  84
  85   if (webkit_event.modifiers & blink::WebInputEvent::AltKey)
  86     webkit_event.isSystemKey = true;
  87
  88   webkit_event.windowsKeyCode = event.key_code();
  89   webkit_event.nativeKeyCode =
  90     ui::KeycodeConverter::DomCodeToNativeKeycode(event.code());
  91   webkit_event.domCode = static_cast<int>(event.code());
  92   webkit_event.domKey = static_cast<int>(event.GetDomKey());
  93   webkit_event.unmodifiedText[0] = event.GetUnmodifiedText();
  94   webkit_event.text[0] = event.GetText();
  95
  96   webkit_event.setKeyIdentifierFromWindowsKeyCode();
  97
  98   return webkit_event;
  99 }
 100
 101 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
 102     const ui::ScrollEvent& event) {
 103   blink::WebMouseWheelEvent webkit_event;
 104
 105   webkit_event.type = blink::WebInputEvent::MouseWheel;
 106   webkit_event.button = blink::WebMouseEvent::ButtonNone;
 107   webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags());
 108   webkit_event.timeStampSeconds = event.time_stamp().InSecondsF();
 109   webkit_event.hasPreciseScrollingDeltas = true;
 110
 111   float offset_ordinal_x = 0.f;
 112   float offset_ordinal_y = 0.f;
 113   if ((event.flags() & ui::EF_SHIFT_DOWN) != 0 && event.x_offset() == 0) {
 114     webkit_event.deltaX = event.y_offset();
 115     webkit_event.deltaY = 0;
 116     offset_ordinal_x = event.y_offset_ordinal();
 117     offset_ordinal_y = event.x_offset_ordinal();
 118   } else {
 119     webkit_event.deltaX = event.x_offset();
 120     webkit_event.deltaY = event.y_offset();
 121     offset_ordinal_x = event.x_offset_ordinal();
 122     offset_ordinal_y = event.y_offset_ordinal();
 123   }
 124
 125   if (offset_ordinal_x != 0.f && webkit_event.deltaX != 0.f)
 126     webkit_event.accelerationRatioX = offset_ordinal_x / webkit_event.deltaX;
 127   webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
 128   webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
 129   if (offset_ordinal_y != 0.f && webkit_event.deltaY != 0.f)
 130     webkit_event.accelerationRatioY = offset_ordinal_y / webkit_event.deltaY;
 131   return webkit_event;
 132 }
 133
 134 blink::WebGestureEvent MakeWebGestureEventFromAuraEvent(
 135     const ui::ScrollEvent& event) {
 136   blink::WebGestureEvent webkit_event;
 137
 138   switch (event.type()) {
 139     case ui::ET_SCROLL_FLING_START:
 140       webkit_event.type = blink::WebInputEvent::GestureFlingStart;
 141       webkit_event.data.flingStart.velocityX = event.x_offset();
 142       webkit_event.data.flingStart.velocityY = event.y_offset();
 143       break;
 144     case ui::ET_SCROLL_FLING_CANCEL:
 145       webkit_event.type = blink::WebInputEvent::GestureFlingCancel;
 146       break;
 147     case ui::ET_SCROLL:
 148       NOTREACHED() << "Invalid gesture type: " << event.type();
 149       break;
 150     default:
 151       NOTREACHED() << "Unknown gesture type: " << event.type();
 152   }
 153
 154   webkit_event.sourceDevice = blink::WebGestureDeviceTouchpad;
 155   webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags());
 156   webkit_event.timeStampSeconds = event.time_stamp().InSecondsF();
 157   return webkit_event;
 158 }
 159
 160 blink::WebMouseEvent MakeWebMouseEventFromAuraEvent(
 161     const ui::MouseEvent& event);
 162 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
 163     const ui::MouseWheelEvent& event);
 164
 165 // General approach:
 166 //
 167 // ui::Event only carries a subset of possible event data provided to Aura by
 168 // the host platform. WebKit utilizes a larger subset of that information than
 169 // Aura itself. WebKit includes some built in cracking functionality that we
 170 // rely on to obtain this information cleanly and consistently.
 171 //
 172 // The only place where an ui::Event's data differs from what the underlying
 173 // base::NativeEvent would provide is position data, since we would like to
 174 // provide coordinates relative to the aura::Window that is hosting the
 175 // renderer, not the top level platform window.
 176 //
 177 // The approach is to fully construct a blink::WebInputEvent from the
 178 // ui::Event's base::NativeEvent, and then replace the coordinate fields with
 179 // the translated values from the ui::Event.
 180 //
 181 // The exception is mouse events on linux. The ui::MouseEvent contains enough
 182 // necessary information to construct a WebMouseEvent. So instead of extracting
 183 // the information from the XEvent, which can be tricky when supporting both
 184 // XInput2 and XInput, the WebMouseEvent is constructed from the
 185 // ui::MouseEvent. This will not be necessary once only XInput2 is supported.
 186 //
 187
 188 blink::WebMouseEvent MakeWebMouseEvent(const ui::MouseEvent& event) {
 189   // Construct an untranslated event from the platform event data.
 190   blink::WebMouseEvent webkit_event =
 191 #if defined(OS_WIN)
 192   // On Windows we have WM_ events comming from desktop and pure aura
 193   // events comming from metro mode.
 194   event.native_event().message && (event.type() != ui::ET_MOUSE_EXITED) ?
 195       MakeUntranslatedWebMouseEventFromNativeEvent(event.native_event()) :
 196       MakeWebMouseEventFromAuraEvent(event);
 197 #else
 198   MakeWebMouseEventFromAuraEvent(event);
 199 #endif
 200   // Replace the event's coordinate fields with translated position data from
 201   // |event|.
 202   webkit_event.windowX = webkit_event.x = event.x();
 203   webkit_event.windowY = webkit_event.y = event.y();
 204
 205 #if defined(OS_WIN)
 206   if (event.native_event().message)
 207     return webkit_event;
 208 #endif
 209   const gfx::Point screen_point = GetScreenLocationFromEvent(event);
 210   webkit_event.globalX = screen_point.x();
 211   webkit_event.globalY = screen_point.y();
 212
 213   return webkit_event;
 214 }
 215
 216 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(
 217     const ui::MouseWheelEvent& event) {
 218 #if defined(OS_WIN)
 219   // Construct an untranslated event from the platform event data.
 220   blink::WebMouseWheelEvent webkit_event = event.native_event().message ?
 221       MakeUntranslatedWebMouseWheelEventFromNativeEvent(event.native_event()) :
 222       MakeWebMouseWheelEventFromAuraEvent(event);
 223 #else
 224   blink::WebMouseWheelEvent webkit_event =
 225       MakeWebMouseWheelEventFromAuraEvent(event);
 226 #endif
 227
 228   // Replace the event's coordinate fields with translated position data from
 229   // |event|.
 230   webkit_event.windowX = webkit_event.x = event.x();
 231   webkit_event.windowY = webkit_event.y = event.y();
 232
 233   const gfx::Point screen_point = GetScreenLocationFromEvent(event);
 234   webkit_event.globalX = screen_point.x();
 235   webkit_event.globalY = screen_point.y();
 236
 237   // Scroll events generated from the mouse wheel when the control key is held
 238   // don't trigger scrolling. Instead, they may cause zooming.
 239   bool from_mouse_wheel = !webkit_event.hasPreciseScrollingDeltas;
 240   if ((webkit_event.modifiers & blink::WebInputEvent::ControlKey) &&
 241       from_mouse_wheel) {
 242     webkit_event.canScroll = false;
 243   }
 244
 245   return webkit_event;
 246 }
 247
 248 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(const ui::ScrollEvent& event) {
 249 #if defined(OS_WIN)
 250   // Construct an untranslated event from the platform event data.
 251   blink::WebMouseWheelEvent webkit_event = event.native_event().message ?
 252       MakeUntranslatedWebMouseWheelEventFromNativeEvent(event.native_event()) :
 253       MakeWebMouseWheelEventFromAuraEvent(event);
 254 #else
 255   blink::WebMouseWheelEvent webkit_event =
 256       MakeWebMouseWheelEventFromAuraEvent(event);
 257 #endif
 258
 259   // Replace the event's coordinate fields with translated position data from
 260   // |event|.
 261   webkit_event.windowX = webkit_event.x = event.x();
 262   webkit_event.windowY = webkit_event.y = event.y();
 263
 264   const gfx::Point screen_point = GetScreenLocationFromEvent(event);
 265   webkit_event.globalX = screen_point.x();
 266   webkit_event.globalY = screen_point.y();
 267
 268   return webkit_event;
 269 }
 270
 271 blink::WebKeyboardEvent MakeWebKeyboardEvent(const ui::KeyEvent& event) {
 272   // Windows can figure out whether or not to construct a RawKeyDown or a Char
 273   // WebInputEvent based on the type of message carried in
 274   // event.native_event(). X11 is not so fortunate, there is no separate
 275   // translated event type, so DesktopHostLinux sends an extra KeyEvent with
 276   // is_char() == true. We need to pass the ui::KeyEvent to the X11 function
 277   // to detect this case so the right event type can be constructed.
 278 #if defined(OS_WIN)
 279   if (event.HasNativeEvent()) {
 280     // Key events require no translation by the aura system.
 281     blink::WebKeyboardEvent webkit_event(
 282         MakeWebKeyboardEventFromNativeEvent(event.native_event()));
 283     webkit_event.modifiers |= DomCodeToWebInputEventModifiers(event.code());
 284     webkit_event.domCode = static_cast<int>(event.code());
 285     webkit_event.domKey = static_cast<int>(event.GetDomKey());
 286     return webkit_event;
 287   }
 288 #endif
 289   return MakeWebKeyboardEventFromAuraEvent(event);
 290 }
 291
 292 blink::WebGestureEvent MakeWebGestureEvent(const ui::GestureEvent& event) {
 293   blink::WebGestureEvent gesture_event;
 294 #if defined(OS_WIN)
 295   if (event.HasNativeEvent())
 296     gesture_event = MakeWebGestureEventFromNativeEvent(event.native_event());
 297   else
 298     gesture_event = MakeWebGestureEventFromUIEvent(event);
 299 #else
 300   gesture_event = MakeWebGestureEventFromUIEvent(event);
 301 #endif
 302
 303   gesture_event.x = event.x();
 304   gesture_event.y = event.y();
 305
 306   const gfx::Point screen_point = GetScreenLocationFromEvent(event);
 307   gesture_event.globalX = screen_point.x();
 308   gesture_event.globalY = screen_point.y();
 309
 310   return gesture_event;
 311 }
 312
 313 blink::WebGestureEvent MakeWebGestureEvent(const ui::ScrollEvent& event) {
 314   blink::WebGestureEvent gesture_event;
 315
 316 #if defined(OS_WIN)
 317   gesture_event = MakeWebGestureEventFromNativeEvent(event.native_event());
 318 #else
 319   gesture_event = MakeWebGestureEventFromAuraEvent(event);
 320 #endif
 321
 322   gesture_event.x = event.x();
 323   gesture_event.y = event.y();
 324
 325   const gfx::Point screen_point = GetScreenLocationFromEvent(event);
 326   gesture_event.globalX = screen_point.x();
 327   gesture_event.globalY = screen_point.y();
 328
 329   return gesture_event;
 330 }
 331
 332 blink::WebGestureEvent MakeWebGestureEventFlingCancel() {
 333   blink::WebGestureEvent gesture_event;
 334
 335   // All other fields are ignored on a GestureFlingCancel event.
 336   gesture_event.type = blink::WebInputEvent::GestureFlingCancel;
 337   gesture_event.sourceDevice = blink::WebGestureDeviceTouchpad;
 338   return gesture_event;
 339 }
 340
 341 blink::WebMouseEvent MakeWebMouseEventFromAuraEvent(
 342     const ui::MouseEvent& event) {
 343   blink::WebMouseEvent webkit_event;
 344
 345   webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags());
 346   webkit_event.timeStampSeconds = event.time_stamp().InSecondsF();
 347
 348   webkit_event.button = blink::WebMouseEvent::ButtonNone;
 349   int button_flags = event.flags();
 350   if (event.type() == ui::ET_MOUSE_PRESSED ||
 351       event.type() == ui::ET_MOUSE_RELEASED) {
 352     // We want to use changed_button_flags() for mouse pressed & released.
 353     // These flags can be used only if they are set which is not always the case
 354     // (see e.g. GetChangedMouseButtonFlagsFromNative() in events_win.cc).
 355     if (event.changed_button_flags())
 356       button_flags = event.changed_button_flags();
 357   }
 358   if (button_flags & ui::EF_LEFT_MOUSE_BUTTON)
 359     webkit_event.button = blink::WebMouseEvent::ButtonLeft;
 360   if (button_flags & ui::EF_MIDDLE_MOUSE_BUTTON)
 361     webkit_event.button = blink::WebMouseEvent::ButtonMiddle;
 362   if (button_flags & ui::EF_RIGHT_MOUSE_BUTTON)
 363     webkit_event.button = blink::WebMouseEvent::ButtonRight;
 364
 365   switch (event.type()) {
 366     case ui::ET_MOUSE_PRESSED:
 367       webkit_event.type = blink::WebInputEvent::MouseDown;
 368       webkit_event.clickCount = event.GetClickCount();
 369       break;
 370     case ui::ET_MOUSE_RELEASED:
 371       webkit_event.type = blink::WebInputEvent::MouseUp;
 372       webkit_event.clickCount = event.GetClickCount();
 373       break;
 374     case ui::ET_MOUSE_ENTERED:
 375     case ui::ET_MOUSE_EXITED:
 376     case ui::ET_MOUSE_MOVED:
 377     case ui::ET_MOUSE_DRAGGED:
 378       webkit_event.type = blink::WebInputEvent::MouseMove;
 379       break;
 380     default:
 381       NOTIMPLEMENTED() << "Received unexpected event: " << event.type();
 382       break;
 383   }
 384
 385   webkit_event.tiltX = roundf(event.pointer_details().tilt_x());
 386   webkit_event.tiltY = roundf(event.pointer_details().tilt_y());
 387   webkit_event.force = event.pointer_details().force();
 388   webkit_event.pointerType =
 389       EventPointerTypeToWebPointerType(event.pointer_details().pointer_type());
 390
 391   return webkit_event;
 392 }
 393
 394 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
 395     const ui::MouseWheelEvent& event) {
 396   blink::WebMouseWheelEvent webkit_event;
 397
 398   webkit_event.type = blink::WebInputEvent::MouseWheel;
 399   webkit_event.button = blink::WebMouseEvent::ButtonNone;
 400   webkit_event.modifiers = ui::EventFlagsToWebEventModifiers(event.flags());
 401   webkit_event.timeStampSeconds = event.time_stamp().InSecondsF();
 402
 403   if ((event.flags() & ui::EF_SHIFT_DOWN) != 0 && event.x_offset() == 0) {
 404     webkit_event.deltaX = event.y_offset();
 405     webkit_event.deltaY = 0;
 406   } else {
 407     webkit_event.deltaX = event.x_offset();
 408     webkit_event.deltaY = event.y_offset();
 409   }
 410
 411   webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
 412   webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
 413
 414   webkit_event.tiltX = roundf(event.pointer_details().tilt_x());
 415   webkit_event.tiltY = roundf(event.pointer_details().tilt_y());
 416   webkit_event.force = event.pointer_details().force();
 417   webkit_event.pointerType =
 418       EventPointerTypeToWebPointerType(event.pointer_details().pointer_type());
 419
 420   return webkit_event;
 421 }
 422
 423 }  // namespace content