content/browser/renderer_host/input/web_input_event_builders_win.cc

   1 // Copyright 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/renderer_host/input/web_input_event_builders_win.h"
   6
   7 #include "base/logging.h"
   8 #include "content/browser/renderer_host/input/web_input_event_util.h"
   9 #include "ui/gfx/win/dpi.h"
  10
  11 using blink::WebInputEvent;
  12 using blink::WebKeyboardEvent;
  13 using blink::WebMouseEvent;
  14 using blink::WebMouseWheelEvent;
  15
  16 namespace content {
  17
  18 static const unsigned long kDefaultScrollLinesPerWheelDelta = 3;
  19 static const unsigned long kDefaultScrollCharsPerWheelDelta = 1;
  20
  21 static bool IsKeyDown(WPARAM wparam) {
  22   return (GetKeyState(wparam) & 0x8000) != 0;
  23 }
  24
  25 static int GetLocationModifier(WPARAM wparam, LPARAM lparam) {
  26   int modifier = 0;
  27   switch (wparam) {
  28   case VK_RETURN:
  29     if ((lparam >> 16) & KF_EXTENDED)
  30       modifier = WebInputEvent::IsKeyPad;
  31     break;
  32   case VK_INSERT:
  33   case VK_DELETE:
  34   case VK_HOME:
  35   case VK_END:
  36   case VK_PRIOR:
  37   case VK_NEXT:
  38   case VK_UP:
  39   case VK_DOWN:
  40   case VK_LEFT:
  41   case VK_RIGHT:
  42     if (!((lparam >> 16) & KF_EXTENDED))
  43       modifier = WebInputEvent::IsKeyPad;
  44     break;
  45   case VK_NUMLOCK:
  46   case VK_NUMPAD0:
  47   case VK_NUMPAD1:
  48   case VK_NUMPAD2:
  49   case VK_NUMPAD3:
  50   case VK_NUMPAD4:
  51   case VK_NUMPAD5:
  52   case VK_NUMPAD6:
  53   case VK_NUMPAD7:
  54   case VK_NUMPAD8:
  55   case VK_NUMPAD9:
  56   case VK_DIVIDE:
  57   case VK_MULTIPLY:
  58   case VK_SUBTRACT:
  59   case VK_ADD:
  60   case VK_DECIMAL:
  61   case VK_CLEAR:
  62     modifier = WebInputEvent::IsKeyPad;
  63     break;
  64   case VK_SHIFT:
  65     if (IsKeyDown(VK_LSHIFT))
  66       modifier = WebInputEvent::IsLeft;
  67     else if (IsKeyDown(VK_RSHIFT))
  68       modifier = WebInputEvent::IsRight;
  69     break;
  70   case VK_CONTROL:
  71     if (IsKeyDown(VK_LCONTROL))
  72       modifier = WebInputEvent::IsLeft;
  73     else if (IsKeyDown(VK_RCONTROL))
  74       modifier = WebInputEvent::IsRight;
  75     break;
  76   case VK_MENU:
  77     if (IsKeyDown(VK_LMENU))
  78       modifier = WebInputEvent::IsLeft;
  79     else if (IsKeyDown(VK_RMENU))
  80       modifier = WebInputEvent::IsRight;
  81     break;
  82   case VK_LWIN:
  83     modifier = WebInputEvent::IsLeft;
  84     break;
  85   case VK_RWIN:
  86     modifier = WebInputEvent::IsRight;
  87     break;
  88   }
  89
  90   DCHECK(!modifier
  91          || modifier == WebInputEvent::IsKeyPad
  92          || modifier == WebInputEvent::IsLeft
  93          || modifier == WebInputEvent::IsRight);
  94   return modifier;
  95 }
  96
  97 // Loads the state for toggle keys into the event.
  98 static void SetToggleKeyState(WebInputEvent* event) {
  99   // Low bit set from GetKeyState indicates "toggled".
 100   if (::GetKeyState(VK_NUMLOCK) & 1)
 101     event->modifiers |= WebInputEvent::NumLockOn;
 102   if (::GetKeyState(VK_CAPITAL) & 1)
 103     event->modifiers |= WebInputEvent::CapsLockOn;
 104 }
 105
 106 WebKeyboardEvent WebKeyboardEventBuilder::Build(HWND hwnd,
 107                                                 UINT message,
 108                                                 WPARAM wparam,
 109                                                 LPARAM lparam,
 110                                                 DWORD time_ms) {
 111   WebKeyboardEvent result;
 112
 113   result.timeStampSeconds = time_ms / 1000.0;
 114
 115   result.windowsKeyCode = static_cast<int>(wparam);
 116   // Record the scan code (along with other context bits) for this key event.
 117   result.nativeKeyCode = static_cast<int>(lparam);
 118
 119   switch (message) {
 120   case WM_SYSKEYDOWN:
 121     result.isSystemKey = true;
 122   case WM_KEYDOWN:
 123     result.type = WebInputEvent::RawKeyDown;
 124     break;
 125   case WM_SYSKEYUP:
 126     result.isSystemKey = true;
 127   case WM_KEYUP:
 128     result.type = WebInputEvent::KeyUp;
 129     break;
 130   case WM_IME_CHAR:
 131     result.type = WebInputEvent::Char;
 132     break;
 133   case WM_SYSCHAR:
 134     result.isSystemKey = true;
 135     result.type = WebInputEvent::Char;
 136   case WM_CHAR:
 137     result.type = WebInputEvent::Char;
 138     break;
 139   default:
 140     NOTREACHED();
 141   }
 142
 143   if (result.type == WebInputEvent::Char
 144    || result.type == WebInputEvent::RawKeyDown) {
 145     result.text[0] = result.windowsKeyCode;
 146     result.unmodifiedText[0] = result.windowsKeyCode;
 147   }
 148   if (result.type != WebInputEvent::Char) {
 149     UpdateWindowsKeyCodeAndKeyIdentifier(
 150         &result,
 151         static_cast<ui::KeyboardCode>(result.windowsKeyCode));
 152   }
 153
 154   if (::GetKeyState(VK_SHIFT) & 0x8000)
 155     result.modifiers |= WebInputEvent::ShiftKey;
 156   if (::GetKeyState(VK_CONTROL) & 0x8000)
 157     result.modifiers |= WebInputEvent::ControlKey;
 158   if (::GetKeyState(VK_MENU) & 0x8000)
 159     result.modifiers |= WebInputEvent::AltKey;
 160   // NOTE: There doesn't seem to be a way to query the mouse button state in
 161   // this case.
 162
 163   // Bit 30 of lParam represents the "previous key state". If set, the key was
 164   // already down, therefore this is an auto-repeat. Only apply this to key
 165   // down events, to match DOM semantics.
 166   if ((result.type == WebInputEvent::RawKeyDown) && (lparam & 0x40000000))
 167     result.modifiers |= WebInputEvent::IsAutoRepeat;
 168
 169   result.modifiers |= GetLocationModifier(wparam, lparam);
 170
 171   SetToggleKeyState(&result);
 172   return result;
 173 }
 174
 175 // WebMouseEvent --------------------------------------------------------------
 176
 177 static int g_last_click_count = 0;
 178 static double g_last_click_time = 0;
 179
 180 static LPARAM GetRelativeCursorPos(HWND hwnd) {
 181   POINT pos = {-1, -1};
 182   GetCursorPos(&pos);
 183   ScreenToClient(hwnd, &pos);
 184   return MAKELPARAM(pos.x, pos.y);
 185 }
 186
 187 WebMouseEvent WebMouseEventBuilder::Build(HWND hwnd,
 188                                           UINT message,
 189                                           WPARAM wparam,
 190                                           LPARAM lparam,
 191                                           DWORD time_ms) {
 192   WebMouseEvent result;
 193
 194   switch (message) {
 195   case WM_MOUSEMOVE:
 196     result.type = WebInputEvent::MouseMove;
 197     if (wparam & MK_LBUTTON)
 198       result.button = WebMouseEvent::ButtonLeft;
 199     else if (wparam & MK_MBUTTON)
 200       result.button = WebMouseEvent::ButtonMiddle;
 201     else if (wparam & MK_RBUTTON)
 202       result.button = WebMouseEvent::ButtonRight;
 203     else
 204       result.button = WebMouseEvent::ButtonNone;
 205     break;
 206   case WM_MOUSELEAVE:
 207     // TODO(rbyers): This should be MouseLeave but is disabled temporarily.
 208     // See http://crbug.com/450631
 209     result.type = WebInputEvent::MouseMove;
 210     result.button = WebMouseEvent::ButtonNone;
 211     // set the current mouse position (relative to the client area of the
 212     // current window) since none is specified for this event
 213     lparam = GetRelativeCursorPos(hwnd);
 214     break;
 215   case WM_LBUTTONDOWN:
 216   case WM_LBUTTONDBLCLK:
 217     result.type = WebInputEvent::MouseDown;
 218     result.button = WebMouseEvent::ButtonLeft;
 219     break;
 220   case WM_MBUTTONDOWN:
 221   case WM_MBUTTONDBLCLK:
 222     result.type = WebInputEvent::MouseDown;
 223     result.button = WebMouseEvent::ButtonMiddle;
 224     break;
 225   case WM_RBUTTONDOWN:
 226   case WM_RBUTTONDBLCLK:
 227     result.type = WebInputEvent::MouseDown;
 228     result.button = WebMouseEvent::ButtonRight;
 229     break;
 230   case WM_LBUTTONUP:
 231     result.type = WebInputEvent::MouseUp;
 232     result.button = WebMouseEvent::ButtonLeft;
 233     break;
 234   case WM_MBUTTONUP:
 235     result.type = WebInputEvent::MouseUp;
 236     result.button = WebMouseEvent::ButtonMiddle;
 237     break;
 238   case WM_RBUTTONUP:
 239     result.type = WebInputEvent::MouseUp;
 240     result.button = WebMouseEvent::ButtonRight;
 241     break;
 242   default:
 243     NOTREACHED();
 244   }
 245
 246   result.timeStampSeconds = time_ms / 1000.0;
 247
 248   // set position fields:
 249
 250   result.x = static_cast<short>(LOWORD(lparam));
 251   result.y = static_cast<short>(HIWORD(lparam));
 252   result.windowX = result.x;
 253   result.windowY = result.y;
 254
 255   POINT global_point = { result.x, result.y };
 256   ClientToScreen(hwnd, &global_point);
 257
 258   // We need to convert the global point back to DIP before using it.
 259   gfx::Point dip_global_point = gfx::win::ScreenToDIPPoint(
 260       gfx::Point(global_point.x, global_point.y));
 261
 262   result.globalX = dip_global_point.x();
 263   result.globalY = dip_global_point.y();
 264
 265   // calculate number of clicks:
 266
 267   // This differs slightly from the WebKit code in WebKit/win/WebView.cpp
 268   // where their original code looks buggy.
 269   static int last_click_position_x;
 270   static int last_click_position_y;
 271   static WebMouseEvent::Button last_click_button = WebMouseEvent::ButtonLeft;
 272
 273   double current_time = result.timeStampSeconds;
 274   bool cancel_previous_click =
 275       (abs(last_click_position_x - result.x) >
 276           (::GetSystemMetrics(SM_CXDOUBLECLK) / 2))
 277       || (abs(last_click_position_y - result.y) >
 278           (::GetSystemMetrics(SM_CYDOUBLECLK) / 2))
 279       || ((current_time - g_last_click_time) * 1000.0 > ::GetDoubleClickTime());
 280
 281   if (result.type == WebInputEvent::MouseDown) {
 282     if (!cancel_previous_click && (result.button == last_click_button)) {
 283       ++g_last_click_count;
 284     } else {
 285       g_last_click_count = 1;
 286       last_click_position_x = result.x;
 287       last_click_position_y = result.y;
 288     }
 289     g_last_click_time = current_time;
 290     last_click_button = result.button;
 291   } else if (result.type == WebInputEvent::MouseMove
 292           || result.type == WebInputEvent::MouseLeave) {
 293     if (cancel_previous_click) {
 294       g_last_click_count = 0;
 295       last_click_position_x = 0;
 296       last_click_position_y = 0;
 297       g_last_click_time = 0;
 298     }
 299   }
 300   result.clickCount = g_last_click_count;
 301
 302   // set modifiers:
 303
 304   if (wparam & MK_CONTROL)
 305     result.modifiers |= WebInputEvent::ControlKey;
 306   if (wparam & MK_SHIFT)
 307     result.modifiers |= WebInputEvent::ShiftKey;
 308   if (::GetKeyState(VK_MENU) & 0x8000)
 309     result.modifiers |= WebInputEvent::AltKey;
 310   if (wparam & MK_LBUTTON)
 311     result.modifiers |= WebInputEvent::LeftButtonDown;
 312   if (wparam & MK_MBUTTON)
 313     result.modifiers |= WebInputEvent::MiddleButtonDown;
 314   if (wparam & MK_RBUTTON)
 315     result.modifiers |= WebInputEvent::RightButtonDown;
 316
 317   SetToggleKeyState(&result);
 318   return result;
 319 }
 320
 321 // WebMouseWheelEvent ---------------------------------------------------------
 322
 323 WebMouseWheelEvent WebMouseWheelEventBuilder::Build(HWND hwnd,
 324                                                     UINT message,
 325                                                     WPARAM wparam,
 326                                                     LPARAM lparam,
 327                                                     DWORD time_ms) {
 328   WebMouseWheelEvent result;
 329
 330   result.type = WebInputEvent::MouseWheel;
 331
 332   result.timeStampSeconds = time_ms / 1000.0;
 333
 334   result.button = WebMouseEvent::ButtonNone;
 335
 336   // Get key state, coordinates, and wheel delta from event.
 337   typedef SHORT (WINAPI *GetKeyStateFunction)(int key);
 338   GetKeyStateFunction get_key_state_func;
 339   UINT key_state;
 340   float wheel_delta;
 341   bool horizontal_scroll = false;
 342   if ((message == WM_VSCROLL) || (message == WM_HSCROLL)) {
 343     // Synthesize mousewheel event from a scroll event.  This is needed to
 344     // simulate middle mouse scrolling in some laptops.  Use GetAsyncKeyState
 345     // for key state since we are synthesizing the input event.
 346     get_key_state_func = GetAsyncKeyState;
 347     key_state = 0;
 348     if (get_key_state_func(VK_SHIFT) & 0x8000)
 349       key_state |= MK_SHIFT;
 350     if (get_key_state_func(VK_CONTROL) & 0x8000)
 351       key_state |= MK_CONTROL;
 352     // NOTE: There doesn't seem to be a way to query the mouse button state
 353     // in this case.
 354
 355     POINT cursor_position = {0};
 356     GetCursorPos(&cursor_position);
 357     result.globalX = cursor_position.x;
 358     result.globalY = cursor_position.y;
 359
 360     switch (LOWORD(wparam)) {
 361       case SB_LINEUP:    // == SB_LINELEFT
 362         wheel_delta = WHEEL_DELTA;
 363         break;
 364       case SB_LINEDOWN:  // == SB_LINERIGHT
 365         wheel_delta = -WHEEL_DELTA;
 366         break;
 367       case SB_PAGEUP:
 368         wheel_delta = 1;
 369         result.scrollByPage = true;
 370         break;
 371       case SB_PAGEDOWN:
 372         wheel_delta = -1;
 373         result.scrollByPage = true;
 374         break;
 375       default:  // We don't supoprt SB_THUMBPOSITION or SB_THUMBTRACK here.
 376         wheel_delta = 0;
 377         break;
 378     }
 379
 380     if (message == WM_HSCROLL)
 381       horizontal_scroll = true;
 382   } else {
 383     // Non-synthesized event; we can just read data off the event.
 384     get_key_state_func = ::GetKeyState;
 385     key_state = GET_KEYSTATE_WPARAM(wparam);
 386
 387     result.globalX = static_cast<short>(LOWORD(lparam));
 388     result.globalY = static_cast<short>(HIWORD(lparam));
 389
 390     wheel_delta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wparam));
 391     if (message == WM_MOUSEHWHEEL) {
 392       horizontal_scroll = true;
 393       wheel_delta = -wheel_delta;  // Windows is <- -/+ ->, WebKit <- +/- ->.
 394     }
 395   }
 396   if (key_state & MK_SHIFT)
 397     horizontal_scroll = true;
 398
 399   // Set modifiers based on key state.
 400   if (key_state & MK_SHIFT)
 401     result.modifiers |= WebInputEvent::ShiftKey;
 402   if (key_state & MK_CONTROL)
 403     result.modifiers |= WebInputEvent::ControlKey;
 404   if (get_key_state_func(VK_MENU) & 0x8000)
 405     result.modifiers |= WebInputEvent::AltKey;
 406   if (key_state & MK_LBUTTON)
 407     result.modifiers |= WebInputEvent::LeftButtonDown;
 408   if (key_state & MK_MBUTTON)
 409     result.modifiers |= WebInputEvent::MiddleButtonDown;
 410   if (key_state & MK_RBUTTON)
 411     result.modifiers |= WebInputEvent::RightButtonDown;
 412
 413   SetToggleKeyState(&result);
 414
 415   // Set coordinates by translating event coordinates from screen to client.
 416   POINT client_point = { result.globalX, result.globalY };
 417   MapWindowPoints(0, hwnd, &client_point, 1);
 418   result.x = client_point.x;
 419   result.y = client_point.y;
 420   result.windowX = result.x;
 421   result.windowY = result.y;
 422
 423   // Convert wheel delta amount to a number of pixels to scroll.
 424   //
 425   // How many pixels should we scroll per line?  Gecko uses the height of the
 426   // current line, which means scroll distance changes as you go through the
 427   // page or go to different pages.  IE 8 is ~60 px/line, although the value
 428   // seems to vary slightly by page and zoom level.  Also, IE defaults to
 429   // smooth scrolling while Firefox doesn't, so it can get away with somewhat
 430   // larger scroll values without feeling as jerky.  Here we use 100 px per
 431   // three lines (the default scroll amount is three lines per wheel tick).
 432   // Even though we have smooth scrolling, we don't make this as large as IE
 433   // because subjectively IE feels like it scrolls farther than you want while
 434   // reading articles.
 435   static const float kScrollbarPixelsPerLine = 100.0f / 3.0f;
 436   wheel_delta /= WHEEL_DELTA;
 437   float scroll_delta = wheel_delta;
 438   if (horizontal_scroll) {
 439     unsigned long scroll_chars = kDefaultScrollCharsPerWheelDelta;
 440     SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scroll_chars, 0);
 441     // TODO(pkasting): Should probably have a different multiplier
 442     // scrollbarPixelsPerChar here.
 443     scroll_delta *= static_cast<float>(scroll_chars) * kScrollbarPixelsPerLine;
 444   } else {
 445     unsigned long scroll_lines = kDefaultScrollLinesPerWheelDelta;
 446     SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scroll_lines, 0);
 447     if (scroll_lines == WHEEL_PAGESCROLL)
 448       result.scrollByPage = true;
 449     if (!result.scrollByPage) {
 450       scroll_delta *=
 451           static_cast<float>(scroll_lines) * kScrollbarPixelsPerLine;
 452     }
 453   }
 454
 455   // Set scroll amount based on above calculations.  WebKit expects positive
 456   // deltaY to mean "scroll up" and positive deltaX to mean "scroll left".
 457   if (horizontal_scroll) {
 458     result.deltaX = scroll_delta;
 459     result.wheelTicksX = wheel_delta;
 460   } else {
 461     result.deltaY = scroll_delta;
 462     result.wheelTicksY = wheel_delta;
 463   }
 464
 465   return result;
 466 }
 467
 468 }  // namespace content