src/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/ui_events_helper.h"
   8 #include "ui/aura/window.h"
   9 #include "ui/events/event.h"
  10 #include "ui/events/event_utils.h"
  11
  12 #if defined(USE_OZONE)
  13 #include "ui/events/keycodes/keyboard_code_conversion.h"
  14 #endif
  15
  16 namespace content {
  17
  18 #if defined(USE_X11) || defined(USE_OZONE)
  19 // From third_party/WebKit/Source/web/gtk/WebInputEventFactory.cpp:
  20 blink::WebUChar GetControlCharacter(int windows_key_code, bool shift) {
  21   if (windows_key_code >= ui::VKEY_A &&
  22     windows_key_code <= ui::VKEY_Z) {
  23     // ctrl-A ~ ctrl-Z map to \x01 ~ \x1A
  24     return windows_key_code - ui::VKEY_A + 1;
  25   }
  26   if (shift) {
  27     // following graphics chars require shift key to input.
  28     switch (windows_key_code) {
  29       // ctrl-@ maps to \x00 (Null byte)
  30       case ui::VKEY_2:
  31         return 0;
  32       // ctrl-^ maps to \x1E (Record separator, Information separator two)
  33       case ui::VKEY_6:
  34         return 0x1E;
  35       // ctrl-_ maps to \x1F (Unit separator, Information separator one)
  36       case ui::VKEY_OEM_MINUS:
  37         return 0x1F;
  38       // Returns 0 for all other keys to avoid inputting unexpected chars.
  39       default:
  40         break;
  41     }
  42   } else {
  43     switch (windows_key_code) {
  44       // ctrl-[ maps to \x1B (Escape)
  45       case ui::VKEY_OEM_4:
  46         return 0x1B;
  47       // ctrl-\ maps to \x1C (File separator, Information separator four)
  48       case ui::VKEY_OEM_5:
  49         return 0x1C;
  50       // ctrl-] maps to \x1D (Group separator, Information separator three)
  51       case ui::VKEY_OEM_6:
  52         return 0x1D;
  53       // ctrl-Enter maps to \x0A (Line feed)
  54       case ui::VKEY_RETURN:
  55         return 0x0A;
  56       // Returns 0 for all other keys to avoid inputting unexpected chars.
  57       default:
  58         break;
  59     }
  60   }
  61   return 0;
  62 }
  63 #endif
  64 #if defined(OS_WIN)
  65 blink::WebMouseEvent MakeUntranslatedWebMouseEventFromNativeEvent(
  66     base::NativeEvent native_event);
  67 blink::WebMouseWheelEvent MakeUntranslatedWebMouseWheelEventFromNativeEvent(
  68     base::NativeEvent native_event);
  69 blink::WebKeyboardEvent MakeWebKeyboardEventFromNativeEvent(
  70     base::NativeEvent native_event);
  71 blink::WebGestureEvent MakeWebGestureEventFromNativeEvent(
  72     base::NativeEvent native_event);
  73 #elif defined(USE_X11)
  74 blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent(
  75     ui::KeyEvent* event);
  76 #elif defined(USE_OZONE)
  77 blink::WebKeyboardEvent MakeWebKeyboardEventFromAuraEvent(
  78     ui::KeyEvent* event) {
  79   const base::NativeEvent& native_event = event->native_event();
  80   ui::EventType type = ui::EventTypeFromNative(native_event);
  81   blink::WebKeyboardEvent webkit_event;
  82
  83   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
  84   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
  85
  86   switch (type) {
  87     case ui::ET_KEY_PRESSED:
  88       webkit_event.type = event->is_char() ? blink::WebInputEvent::Char :
  89           blink::WebInputEvent::RawKeyDown;
  90       break;
  91     case ui::ET_KEY_RELEASED:
  92       webkit_event.type = blink::WebInputEvent::KeyUp;
  93       break;
  94     default:
  95       NOTREACHED();
  96   }
  97
  98   if (webkit_event.modifiers & blink::WebInputEvent::AltKey)
  99     webkit_event.isSystemKey = true;
 100
 101   wchar_t character = ui::KeyboardCodeFromNative(native_event);
 102   webkit_event.windowsKeyCode = character;
 103   webkit_event.nativeKeyCode = character;
 104
 105   if (webkit_event.windowsKeyCode == ui::VKEY_RETURN)
 106     webkit_event.unmodifiedText[0] = '\r';
 107   else
 108     webkit_event.unmodifiedText[0] = ui::GetCharacterFromKeyCode(
 109         ui::KeyboardCodeFromNative(native_event),
 110         ui::EventFlagsFromNative(native_event));
 111
 112   if (webkit_event.modifiers & blink::WebInputEvent::ControlKey) {
 113     webkit_event.text[0] =
 114         GetControlCharacter(
 115             webkit_event.windowsKeyCode,
 116             webkit_event.modifiers & blink::WebInputEvent::ShiftKey);
 117   } else {
 118     webkit_event.text[0] = webkit_event.unmodifiedText[0];
 119   }
 120
 121   webkit_event.setKeyIdentifierFromWindowsKeyCode();
 122
 123   return webkit_event;
 124 }
 125 #endif
 126 #if defined(USE_X11) || defined(USE_OZONE)
 127 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
 128     ui::ScrollEvent* event) {
 129   blink::WebMouseWheelEvent webkit_event;
 130
 131   webkit_event.type = blink::WebInputEvent::MouseWheel;
 132   webkit_event.button = blink::WebMouseEvent::ButtonNone;
 133   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
 134   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
 135   webkit_event.hasPreciseScrollingDeltas = true;
 136   webkit_event.deltaX = event->x_offset();
 137   if (event->x_offset_ordinal() != 0.f && event->x_offset() != 0.f) {
 138     webkit_event.accelerationRatioX =
 139         event->x_offset_ordinal() / event->x_offset();
 140   }
 141   webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
 142   webkit_event.deltaY = event->y_offset();
 143   webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
 144   if (event->y_offset_ordinal() != 0.f && event->y_offset() != 0.f) {
 145     webkit_event.accelerationRatioY =
 146         event->y_offset_ordinal() / event->y_offset();
 147   }
 148   return webkit_event;
 149 }
 150
 151 blink::WebGestureEvent MakeWebGestureEventFromAuraEvent(
 152     ui::ScrollEvent* event) {
 153   blink::WebGestureEvent webkit_event;
 154
 155   switch (event->type()) {
 156     case ui::ET_SCROLL_FLING_START:
 157       webkit_event.type = blink::WebInputEvent::GestureFlingStart;
 158       webkit_event.data.flingStart.velocityX = event->x_offset();
 159       webkit_event.data.flingStart.velocityY = event->y_offset();
 160       break;
 161     case ui::ET_SCROLL_FLING_CANCEL:
 162       webkit_event.type = blink::WebInputEvent::GestureFlingCancel;
 163       break;
 164     case ui::ET_SCROLL:
 165       NOTREACHED() << "Invalid gesture type: " << event->type();
 166       break;
 167     default:
 168       NOTREACHED() << "Unknown gesture type: " << event->type();
 169   }
 170
 171   webkit_event.sourceDevice = blink::WebGestureEvent::Touchpad;
 172   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
 173   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
 174   return webkit_event;
 175 }
 176
 177 #endif
 178
 179 blink::WebMouseEvent MakeWebMouseEventFromAuraEvent(
 180     ui::MouseEvent* event);
 181 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
 182     ui::MouseWheelEvent* event);
 183
 184 // General approach:
 185 //
 186 // ui::Event only carries a subset of possible event data provided to Aura by
 187 // the host platform. WebKit utilizes a larger subset of that information than
 188 // Aura itself. WebKit includes some built in cracking functionality that we
 189 // rely on to obtain this information cleanly and consistently.
 190 //
 191 // The only place where an ui::Event's data differs from what the underlying
 192 // base::NativeEvent would provide is position data, since we would like to
 193 // provide coordinates relative to the aura::Window that is hosting the
 194 // renderer, not the top level platform window.
 195 //
 196 // The approach is to fully construct a blink::WebInputEvent from the
 197 // ui::Event's base::NativeEvent, and then replace the coordinate fields with
 198 // the translated values from the ui::Event.
 199 //
 200 // The exception is mouse events on linux. The ui::MouseEvent contains enough
 201 // necessary information to construct a WebMouseEvent. So instead of extracting
 202 // the information from the XEvent, which can be tricky when supporting both
 203 // XInput2 and XInput, the WebMouseEvent is constructed from the
 204 // ui::MouseEvent. This will not be necessary once only XInput2 is supported.
 205 //
 206
 207 blink::WebMouseEvent MakeWebMouseEvent(ui::MouseEvent* event) {
 208   // Construct an untranslated event from the platform event data.
 209   blink::WebMouseEvent webkit_event =
 210 #if defined(OS_WIN)
 211   // On Windows we have WM_ events comming from desktop and pure aura
 212   // events comming from metro mode.
 213   event->native_event().message ?
 214       MakeUntranslatedWebMouseEventFromNativeEvent(event->native_event()) :
 215       MakeWebMouseEventFromAuraEvent(event);
 216 #else
 217   MakeWebMouseEventFromAuraEvent(event);
 218 #endif
 219   // Replace the event's coordinate fields with translated position data from
 220   // |event|.
 221   webkit_event.windowX = webkit_event.x = event->x();
 222   webkit_event.windowY = webkit_event.y = event->y();
 223
 224 #if defined(OS_WIN)
 225   if (event->native_event().message)
 226     return webkit_event;
 227 #endif
 228   const gfx::Point root_point = event->root_location();
 229   webkit_event.globalX = root_point.x();
 230   webkit_event.globalY = root_point.y();
 231
 232   return webkit_event;
 233 }
 234
 235 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::MouseWheelEvent* event) {
 236 #if defined(OS_WIN)
 237   // Construct an untranslated event from the platform event data.
 238   blink::WebMouseWheelEvent webkit_event = event->native_event().message ?
 239       MakeUntranslatedWebMouseWheelEventFromNativeEvent(event->native_event()) :
 240       MakeWebMouseWheelEventFromAuraEvent(event);
 241 #else
 242   blink::WebMouseWheelEvent webkit_event =
 243       MakeWebMouseWheelEventFromAuraEvent(event);
 244 #endif
 245
 246   // Replace the event's coordinate fields with translated position data from
 247   // |event|.
 248   webkit_event.windowX = webkit_event.x = event->x();
 249   webkit_event.windowY = webkit_event.y = event->y();
 250
 251   const gfx::Point root_point = event->root_location();
 252   webkit_event.globalX = root_point.x();
 253   webkit_event.globalY = root_point.y();
 254
 255   return webkit_event;
 256 }
 257
 258 blink::WebMouseWheelEvent MakeWebMouseWheelEvent(ui::ScrollEvent* event) {
 259 #if defined(OS_WIN)
 260   // Construct an untranslated event from the platform event data.
 261   blink::WebMouseWheelEvent webkit_event =
 262       MakeUntranslatedWebMouseWheelEventFromNativeEvent(event->native_event());
 263 #else
 264   blink::WebMouseWheelEvent webkit_event =
 265       MakeWebMouseWheelEventFromAuraEvent(event);
 266 #endif
 267
 268   // Replace the event's coordinate fields with translated position data from
 269   // |event|.
 270   webkit_event.windowX = webkit_event.x = event->x();
 271   webkit_event.windowY = webkit_event.y = event->y();
 272
 273   const gfx::Point root_point = event->root_location();
 274   webkit_event.globalX = root_point.x();
 275   webkit_event.globalY = root_point.y();
 276
 277   return webkit_event;
 278 }
 279
 280 blink::WebKeyboardEvent MakeWebKeyboardEvent(ui::KeyEvent* event) {
 281   if (!event->HasNativeEvent())
 282     return blink::WebKeyboardEvent();
 283
 284   // Windows can figure out whether or not to construct a RawKeyDown or a Char
 285   // WebInputEvent based on the type of message carried in
 286   // event->native_event(). X11 is not so fortunate, there is no separate
 287   // translated event type, so DesktopHostLinux sends an extra KeyEvent with
 288   // is_char() == true. We need to pass the ui::KeyEvent to the X11 function
 289   // to detect this case so the right event type can be constructed.
 290 #if defined(OS_WIN)
 291   // Key events require no translation by the aura system.
 292   return MakeWebKeyboardEventFromNativeEvent(event->native_event());
 293 #else
 294   return MakeWebKeyboardEventFromAuraEvent(event);
 295 #endif
 296 }
 297
 298 blink::WebGestureEvent MakeWebGestureEvent(ui::GestureEvent* event) {
 299   blink::WebGestureEvent gesture_event;
 300 #if defined(OS_WIN)
 301   if (event->HasNativeEvent())
 302     gesture_event = MakeWebGestureEventFromNativeEvent(event->native_event());
 303   else
 304     gesture_event = MakeWebGestureEventFromUIEvent(*event);
 305 #else
 306   gesture_event = MakeWebGestureEventFromUIEvent(*event);
 307 #endif
 308
 309   gesture_event.x = event->x();
 310   gesture_event.y = event->y();
 311
 312   const gfx::Point root_point = event->root_location();
 313   gesture_event.globalX = root_point.x();
 314   gesture_event.globalY = root_point.y();
 315
 316   return gesture_event;
 317 }
 318
 319 blink::WebGestureEvent MakeWebGestureEvent(ui::ScrollEvent* event) {
 320   blink::WebGestureEvent gesture_event;
 321
 322 #if defined(OS_WIN)
 323   gesture_event = MakeWebGestureEventFromNativeEvent(event->native_event());
 324 #else
 325   gesture_event = MakeWebGestureEventFromAuraEvent(event);
 326 #endif
 327
 328   gesture_event.x = event->x();
 329   gesture_event.y = event->y();
 330
 331   const gfx::Point root_point = event->root_location();
 332   gesture_event.globalX = root_point.x();
 333   gesture_event.globalY = root_point.y();
 334
 335   return gesture_event;
 336 }
 337
 338 blink::WebGestureEvent MakeWebGestureEventFlingCancel() {
 339   blink::WebGestureEvent gesture_event;
 340
 341   // All other fields are ignored on a GestureFlingCancel event.
 342   gesture_event.type = blink::WebInputEvent::GestureFlingCancel;
 343   gesture_event.sourceDevice = blink::WebGestureEvent::Touchpad;
 344   return gesture_event;
 345 }
 346
 347 blink::WebMouseEvent MakeWebMouseEventFromAuraEvent(ui::MouseEvent* event) {
 348   blink::WebMouseEvent webkit_event;
 349
 350   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
 351   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
 352
 353   webkit_event.button = blink::WebMouseEvent::ButtonNone;
 354   if (event->flags() & ui::EF_LEFT_MOUSE_BUTTON)
 355     webkit_event.button = blink::WebMouseEvent::ButtonLeft;
 356   if (event->flags() & ui::EF_MIDDLE_MOUSE_BUTTON)
 357     webkit_event.button = blink::WebMouseEvent::ButtonMiddle;
 358   if (event->flags() & ui::EF_RIGHT_MOUSE_BUTTON)
 359     webkit_event.button = blink::WebMouseEvent::ButtonRight;
 360
 361   switch (event->type()) {
 362     case ui::ET_MOUSE_PRESSED:
 363       webkit_event.type = blink::WebInputEvent::MouseDown;
 364       webkit_event.clickCount = event->GetClickCount();
 365       break;
 366     case ui::ET_MOUSE_RELEASED:
 367       webkit_event.type = blink::WebInputEvent::MouseUp;
 368       webkit_event.clickCount = event->GetClickCount();
 369       break;
 370     case ui::ET_MOUSE_ENTERED:
 371     case ui::ET_MOUSE_EXITED:
 372     case ui::ET_MOUSE_MOVED:
 373     case ui::ET_MOUSE_DRAGGED:
 374       webkit_event.type = blink::WebInputEvent::MouseMove;
 375       break;
 376     default:
 377       NOTIMPLEMENTED() << "Received unexpected event: " << event->type();
 378       break;
 379   }
 380
 381   return webkit_event;
 382 }
 383
 384 blink::WebMouseWheelEvent MakeWebMouseWheelEventFromAuraEvent(
 385     ui::MouseWheelEvent* event) {
 386   blink::WebMouseWheelEvent webkit_event;
 387
 388   webkit_event.type = blink::WebInputEvent::MouseWheel;
 389   webkit_event.button = blink::WebMouseEvent::ButtonNone;
 390   webkit_event.modifiers = EventFlagsToWebEventModifiers(event->flags());
 391   webkit_event.timeStampSeconds = event->time_stamp().InSecondsF();
 392   webkit_event.deltaX = event->x_offset();
 393   webkit_event.deltaY = event->y_offset();
 394   webkit_event.wheelTicksX = webkit_event.deltaX / kPixelsPerTick;
 395   webkit_event.wheelTicksY = webkit_event.deltaY / kPixelsPerTick;
 396
 397   return webkit_event;
 398 }
 399
 400 }  // namespace content