Home | History | Annotate | Download | only in win 
      1 /*
      2  * Copyright (C) 2006-2009 Google Inc. All rights reserved.
      3  *
      4  * Redistribution and use in source and binary forms, with or without
      5  * modification, are permitted provided that the following conditions are
      6  * met:
      7  *
      8  *     * Redistributions of source code must retain the above copyright
      9  * notice, this list of conditions and the following disclaimer.
     10  *     * Redistributions in binary form must reproduce the above
     11  * copyright notice, this list of conditions and the following disclaimer
     12  * in the documentation and/or other materials provided with the
     13  * distribution.
     14  *     * Neither the name of Google Inc. nor the names of its
     15  * contributors may be used to endorse or promote products derived from
     16  * this software without specific prior written permission.
     17  *
     18  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
     19  * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
     20  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
     21  * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
     22  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
     23  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
     24  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
     25  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
     26  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
     27  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
     28  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     29  */
     30 
     31 #include "config.h"
     32 #include "WebInputEventFactory.h"
     33 
     34 #include "WebInputEvent.h"
     35 
     36 #include <wtf/Assertions.h>
     37 
     38 namespace WebKit {
     39 
     40 static const unsigned long defaultScrollLinesPerWheelDelta = 3;
     41 static const unsigned long defaultScrollCharsPerWheelDelta = 1;
     42 
     43 // WebKeyboardEvent -----------------------------------------------------------
     44 
     45 static bool isKeyPad(WPARAM wparam, LPARAM lparam)
     46 {
     47     bool keypad = false;
     48     switch (wparam) {
     49     case VK_RETURN:
     50         keypad = (lparam >> 16) & KF_EXTENDED;
     51         break;
     52     case VK_INSERT:
     53     case VK_DELETE:
     54     case VK_HOME:
     55     case VK_END:
     56     case VK_PRIOR:
     57     case VK_NEXT:
     58     case VK_UP:
     59     case VK_DOWN:
     60     case VK_LEFT:
     61     case VK_RIGHT:
     62         keypad = !((lparam >> 16) & KF_EXTENDED);
     63         break;
     64     case VK_NUMLOCK:
     65     case VK_NUMPAD0:
     66     case VK_NUMPAD1:
     67     case VK_NUMPAD2:
     68     case VK_NUMPAD3:
     69     case VK_NUMPAD4:
     70     case VK_NUMPAD5:
     71     case VK_NUMPAD6:
     72     case VK_NUMPAD7:
     73     case VK_NUMPAD8:
     74     case VK_NUMPAD9:
     75     case VK_DIVIDE:
     76     case VK_MULTIPLY:
     77     case VK_SUBTRACT:
     78     case VK_ADD:
     79     case VK_DECIMAL:
     80     case VK_CLEAR:
     81         keypad = true;
     82         break;
     83     default:
     84         keypad = false;
     85     }
     86     return keypad;
     87 }
     88 
     89 WebKeyboardEvent WebInputEventFactory::keyboardEvent(HWND hwnd, UINT message,
     90                                                      WPARAM wparam, LPARAM lparam)
     91 {
     92     WebKeyboardEvent result;
     93 
     94     // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that
     95     // GetMessageTime() refers to is the same one that we're passed in? Perhaps
     96     // one of the construction parameters should be the time passed by the
     97     // caller, who would know for sure.
     98     result.timeStampSeconds = GetMessageTime() / 1000.0;
     99 
    100     result.windowsKeyCode = result.nativeKeyCode = static_cast<int>(wparam);
    101 
    102     switch (message) {
    103     case WM_SYSKEYDOWN:
    104         result.isSystemKey = true;
    105     case WM_KEYDOWN:
    106         result.type = WebInputEvent::RawKeyDown;
    107         break;
    108     case WM_SYSKEYUP:
    109         result.isSystemKey = true;
    110     case WM_KEYUP:
    111         result.type = WebInputEvent::KeyUp;
    112         break;
    113     case WM_IME_CHAR:
    114         result.type = WebInputEvent::Char;
    115         break;
    116     case WM_SYSCHAR:
    117         result.isSystemKey = true;
    118         result.type = WebInputEvent::Char;
    119     case WM_CHAR:
    120         result.type = WebInputEvent::Char;
    121         break;
    122     default:
    123         ASSERT_NOT_REACHED();
    124     }
    125 
    126     if (result.type == WebInputEvent::Char || result.type == WebInputEvent::RawKeyDown) {
    127         result.text[0] = result.windowsKeyCode;
    128         result.unmodifiedText[0] = result.windowsKeyCode;
    129     }
    130     if (result.type != WebInputEvent::Char)
    131         result.setKeyIdentifierFromWindowsKeyCode();
    132 
    133     if (GetKeyState(VK_SHIFT) & 0x8000)
    134         result.modifiers |= WebInputEvent::ShiftKey;
    135     if (GetKeyState(VK_CONTROL) & 0x8000)
    136         result.modifiers |= WebInputEvent::ControlKey;
    137     if (GetKeyState(VK_MENU) & 0x8000)
    138         result.modifiers |= WebInputEvent::AltKey;
    139     // NOTE: There doesn't seem to be a way to query the mouse button state in
    140     // this case.
    141 
    142     if (LOWORD(lparam) > 1)
    143         result.modifiers |= WebInputEvent::IsAutoRepeat;
    144     if (isKeyPad(wparam, lparam))
    145         result.modifiers |= WebInputEvent::IsKeyPad;
    146 
    147     return result;
    148 }
    149 
    150 // WebMouseEvent --------------------------------------------------------------
    151 
    152 static int gLastClickCount;
    153 static double gLastClickTime;
    154 
    155 static LPARAM GetRelativeCursorPos(HWND hwnd)
    156 {
    157     POINT pos = {-1, -1};
    158     GetCursorPos(&pos);
    159     ScreenToClient(hwnd, &pos);
    160     return MAKELPARAM(pos.x, pos.y);
    161 }
    162 
    163 void WebInputEventFactory::resetLastClickState()
    164 {
    165     gLastClickTime = gLastClickCount = 0;
    166 }
    167 
    168 WebMouseEvent WebInputEventFactory::mouseEvent(HWND hwnd, UINT message,
    169                                                WPARAM wparam, LPARAM lparam)
    170 {
    171     WebMouseEvent result; //(WebInputEvent::Uninitialized());
    172 
    173     switch (message) {
    174     case WM_MOUSEMOVE:
    175         result.type = WebInputEvent::MouseMove;
    176         if (wparam & MK_LBUTTON)
    177             result.button = WebMouseEvent::ButtonLeft;
    178         else if (wparam & MK_MBUTTON)
    179             result.button = WebMouseEvent::ButtonMiddle;
    180         else if (wparam & MK_RBUTTON)
    181             result.button = WebMouseEvent::ButtonRight;
    182         else
    183             result.button = WebMouseEvent::ButtonNone;
    184         break;
    185     case WM_MOUSELEAVE:
    186         result.type = WebInputEvent::MouseLeave;
    187         result.button = WebMouseEvent::ButtonNone;
    188         // set the current mouse position (relative to the client area of the
    189         // current window) since none is specified for this event
    190         lparam = GetRelativeCursorPos(hwnd);
    191         break;
    192     case WM_LBUTTONDOWN:
    193     case WM_LBUTTONDBLCLK:
    194         result.type = WebInputEvent::MouseDown;
    195         result.button = WebMouseEvent::ButtonLeft;
    196         break;
    197     case WM_MBUTTONDOWN:
    198     case WM_MBUTTONDBLCLK:
    199         result.type = WebInputEvent::MouseDown;
    200         result.button = WebMouseEvent::ButtonMiddle;
    201         break;
    202     case WM_RBUTTONDOWN:
    203     case WM_RBUTTONDBLCLK:
    204         result.type = WebInputEvent::MouseDown;
    205         result.button = WebMouseEvent::ButtonRight;
    206         break;
    207     case WM_LBUTTONUP:
    208         result.type = WebInputEvent::MouseUp;
    209         result.button = WebMouseEvent::ButtonLeft;
    210         break;
    211     case WM_MBUTTONUP:
    212         result.type = WebInputEvent::MouseUp;
    213         result.button = WebMouseEvent::ButtonMiddle;
    214         break;
    215     case WM_RBUTTONUP:
    216         result.type = WebInputEvent::MouseUp;
    217         result.button = WebMouseEvent::ButtonRight;
    218         break;
    219     default:
    220         ASSERT_NOT_REACHED();
    221     }
    222 
    223     // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that
    224     // GetMessageTime() refers to is the same one that we're passed in? Perhaps
    225     // one of the construction parameters should be the time passed by the
    226     // caller, who would know for sure.
    227     result.timeStampSeconds = GetMessageTime() / 1000.0;
    228 
    229     // set position fields:
    230 
    231     result.x = static_cast<short>(LOWORD(lparam));
    232     result.y = static_cast<short>(HIWORD(lparam));
    233     result.windowX = result.x;
    234     result.windowY = result.y;
    235 
    236     POINT globalPoint = { result.x, result.y };
    237     ClientToScreen(hwnd, &globalPoint);
    238 
    239     result.globalX = globalPoint.x;
    240     result.globalY = globalPoint.y;
    241 
    242     // calculate number of clicks:
    243 
    244     // This differs slightly from the WebKit code in WebKit/win/WebView.cpp
    245     // where their original code looks buggy.
    246     static int lastClickPositionX;
    247     static int lastClickPositionY;
    248     static WebMouseEvent::Button lastClickButton = WebMouseEvent::ButtonLeft;
    249 
    250     double currentTime = result.timeStampSeconds;
    251     bool cancelPreviousClick =
    252         (abs(lastClickPositionX - result.x) > (GetSystemMetrics(SM_CXDOUBLECLK) / 2))
    253         || (abs(lastClickPositionY - result.y) > (GetSystemMetrics(SM_CYDOUBLECLK) / 2))
    254         || ((currentTime - gLastClickTime) * 1000.0 > GetDoubleClickTime());
    255 
    256     if (result.type == WebInputEvent::MouseDown) {
    257         if (!cancelPreviousClick && (result.button == lastClickButton))
    258             ++gLastClickCount;
    259         else {
    260             gLastClickCount = 1;
    261             lastClickPositionX = result.x;
    262             lastClickPositionY = result.y;
    263         }
    264         gLastClickTime = currentTime;
    265         lastClickButton = result.button;
    266     } else if (result.type == WebInputEvent::MouseMove
    267                || result.type == WebInputEvent::MouseLeave) {
    268         if (cancelPreviousClick) {
    269             gLastClickCount = 0;
    270             lastClickPositionX = 0;
    271             lastClickPositionY = 0;
    272             gLastClickTime = 0;
    273         }
    274     }
    275     result.clickCount = gLastClickCount;
    276 
    277     // set modifiers:
    278 
    279     if (wparam & MK_CONTROL)
    280         result.modifiers |= WebInputEvent::ControlKey;
    281     if (wparam & MK_SHIFT)
    282         result.modifiers |= WebInputEvent::ShiftKey;
    283     if (GetKeyState(VK_MENU) & 0x8000)
    284         result.modifiers |= WebInputEvent::AltKey;
    285     if (wparam & MK_LBUTTON)
    286         result.modifiers |= WebInputEvent::LeftButtonDown;
    287     if (wparam & MK_MBUTTON)
    288         result.modifiers |= WebInputEvent::MiddleButtonDown;
    289     if (wparam & MK_RBUTTON)
    290         result.modifiers |= WebInputEvent::RightButtonDown;
    291 
    292     return result;
    293 }
    294 
    295 // WebMouseWheelEvent ---------------------------------------------------------
    296 
    297 WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(HWND hwnd, UINT message,
    298                                                          WPARAM wparam, LPARAM lparam)
    299 {
    300     WebMouseWheelEvent result; //(WebInputEvent::Uninitialized());
    301 
    302     result.type = WebInputEvent::MouseWheel;
    303 
    304     // TODO(pkasting): http://b/1117926 Are we guaranteed that the message that
    305     // GetMessageTime() refers to is the same one that we're passed in? Perhaps
    306     // one of the construction parameters should be the time passed by the
    307     // caller, who would know for sure.
    308     result.timeStampSeconds = GetMessageTime() / 1000.0;
    309 
    310     result.button = WebMouseEvent::ButtonNone;
    311 
    312     // Get key state, coordinates, and wheel delta from event.
    313     typedef SHORT (WINAPI *GetKeyStateFunction)(int key);
    314     GetKeyStateFunction getKeyState;
    315     UINT keyState;
    316     float wheelDelta;
    317     bool horizontalScroll = false;
    318     if ((message == WM_VSCROLL) || (message == WM_HSCROLL)) {
    319         // Synthesize mousewheel event from a scroll event.  This is needed to
    320         // simulate middle mouse scrolling in some laptops.  Use GetAsyncKeyState
    321         // for key state since we are synthesizing the input event.
    322         getKeyState = GetAsyncKeyState;
    323         keyState = 0;
    324         if (getKeyState(VK_SHIFT))
    325             keyState |= MK_SHIFT;
    326         if (getKeyState(VK_CONTROL))
    327             keyState |= MK_CONTROL;
    328         // NOTE: There doesn't seem to be a way to query the mouse button state
    329         // in this case.
    330 
    331         POINT cursorPosition = {0};
    332         GetCursorPos(&cursorPosition);
    333         result.globalX = cursorPosition.x;
    334         result.globalY = cursorPosition.y;
    335 
    336         switch (LOWORD(wparam)) {
    337         case SB_LINEUP:    // == SB_LINELEFT
    338             wheelDelta = WHEEL_DELTA;
    339             break;
    340         case SB_LINEDOWN:  // == SB_LINERIGHT
    341             wheelDelta = -WHEEL_DELTA;
    342             break;
    343         case SB_PAGEUP:
    344             wheelDelta = 1;
    345             result.scrollByPage = true;
    346             break;
    347         case SB_PAGEDOWN:
    348             wheelDelta = -1;
    349             result.scrollByPage = true;
    350             break;
    351         default:  // We don't supoprt SB_THUMBPOSITION or SB_THUMBTRACK here.
    352             wheelDelta = 0;
    353             break;
    354         }
    355 
    356         if (message == WM_HSCROLL)
    357             horizontalScroll = true;
    358     } else {
    359         // Non-synthesized event; we can just read data off the event.
    360         getKeyState = GetKeyState;
    361         keyState = GET_KEYSTATE_WPARAM(wparam);
    362 
    363         result.globalX = static_cast<short>(LOWORD(lparam));
    364         result.globalY = static_cast<short>(HIWORD(lparam));
    365 
    366         wheelDelta = static_cast<float>(GET_WHEEL_DELTA_WPARAM(wparam));
    367         if (message == WM_MOUSEHWHEEL) {
    368             horizontalScroll = true;
    369             wheelDelta = -wheelDelta;  // Windows is <- -/+ ->, WebKit <- +/- ->.
    370         }
    371     }
    372     if (keyState & MK_SHIFT)
    373         horizontalScroll = true;
    374 
    375     // Set modifiers based on key state.
    376     if (keyState & MK_SHIFT)
    377         result.modifiers |= WebInputEvent::ShiftKey;
    378     if (keyState & MK_CONTROL)
    379         result.modifiers |= WebInputEvent::ControlKey;
    380     if (getKeyState(VK_MENU) & 0x8000)
    381         result.modifiers |= WebInputEvent::AltKey;
    382     if (keyState & MK_LBUTTON)
    383         result.modifiers |= WebInputEvent::LeftButtonDown;
    384     if (keyState & MK_MBUTTON)
    385         result.modifiers |= WebInputEvent::MiddleButtonDown;
    386     if (keyState & MK_RBUTTON)
    387         result.modifiers |= WebInputEvent::RightButtonDown;
    388 
    389     // Set coordinates by translating event coordinates from screen to client.
    390     POINT clientPoint = { result.globalX, result.globalY };
    391     MapWindowPoints(0, hwnd, &clientPoint, 1);
    392     result.x = clientPoint.x;
    393     result.y = clientPoint.y;
    394     result.windowX = result.x;
    395     result.windowY = result.y;
    396 
    397     // Convert wheel delta amount to a number of pixels to scroll.
    398     //
    399     // How many pixels should we scroll per line?  Gecko uses the height of the
    400     // current line, which means scroll distance changes as you go through the
    401     // page or go to different pages.  IE 7 is ~50 px/line, although the value
    402     // seems to vary slightly by page and zoom level.  Since IE 7 has a smoothing
    403     // algorithm on scrolling, it can get away with slightly larger scroll values
    404     // without feeling jerky.  Here we use 100 px per three lines (the default
    405     // scroll amount is three lines per wheel tick).
    406     static const float scrollbarPixelsPerLine = 100.0f / 3.0f;
    407     wheelDelta /= WHEEL_DELTA;
    408     float scrollDelta = wheelDelta;
    409     if (horizontalScroll) {
    410         unsigned long scrollChars = defaultScrollCharsPerWheelDelta;
    411         SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scrollChars, 0);
    412         // TODO(pkasting): Should probably have a different multiplier
    413         // scrollbarPixelsPerChar here.
    414         scrollDelta *= static_cast<float>(scrollChars) * scrollbarPixelsPerLine;
    415     } else {
    416         unsigned long scrollLines = defaultScrollLinesPerWheelDelta;
    417         SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0);
    418         if (scrollLines == WHEEL_PAGESCROLL)
    419             result.scrollByPage = true;
    420         if (!result.scrollByPage)
    421             scrollDelta *= static_cast<float>(scrollLines) * scrollbarPixelsPerLine;
    422     }
    423 
    424     // Set scroll amount based on above calculations.  WebKit expects positive
    425     // deltaY to mean "scroll up" and positive deltaX to mean "scroll left".
    426     if (horizontalScroll) {
    427         result.deltaX = scrollDelta;
    428         result.wheelTicksX = wheelDelta;
    429     } else {
    430         result.deltaY = scrollDelta;
    431         result.wheelTicksY = wheelDelta;
    432     }
    433 
    434     return result;
    435 }
    436 
    437 } // namespace WebKit
    438