| /* |
| * Copyright (C) 2006-2009 Google Inc. All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions are |
| * met: |
| * |
| * * Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * * Redistributions in binary form must reproduce the above |
| * copyright notice, this list of conditions and the following disclaimer |
| * in the documentation and/or other materials provided with the |
| * distribution. |
| * * Neither the name of Google Inc. nor the names of its |
| * contributors may be used to endorse or promote products derived from |
| * this software without specific prior written permission. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| * "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| * A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "config.h" |
| #include "WebInputEventFactory.h" |
| |
| #include "core/platform/chromium/KeyCodeConversion.h" |
| #include "platform/KeyboardCodes.h" |
| |
| #include "WebInputEvent.h" |
| |
| #include <gdk/gdk.h> |
| #include <gdk/gdkkeysyms.h> |
| #include <gtk/gtk.h> |
| #include <stdlib.h> |
| |
| #include "wtf/Assertions.h" |
| |
| namespace { |
| |
| // For click count tracking. |
| static int gNumClicks = 0; |
| static GdkWindow* gLastClickEventWindow = 0; |
| static gint gLastClickTime = 0; |
| static gint gLastClickX = 0; |
| static gint gLastClickY = 0; |
| static blink::WebMouseEvent::Button gLastClickButton = blink::WebMouseEvent::ButtonNone; |
| |
| bool shouldForgetPreviousClick(GdkWindow* window, gint time, gint x, gint y) |
| { |
| static GtkSettings* settings = gtk_settings_get_default(); |
| |
| if (window != gLastClickEventWindow) |
| return true; |
| |
| gint doubleClickTime = 250; |
| gint doubleClickDistance = 5; |
| g_object_get(G_OBJECT(settings), |
| "gtk-double-click-time", &doubleClickTime, |
| "gtk-double-click-distance", &doubleClickDistance, NULL); |
| return (time - gLastClickTime) > doubleClickTime |
| || abs(x - gLastClickX) > doubleClickDistance |
| || abs(y - gLastClickY) > doubleClickDistance; |
| } |
| |
| void resetClickCountState() |
| { |
| gNumClicks = 0; |
| gLastClickEventWindow = 0; |
| gLastClickTime = 0; |
| gLastClickX = 0; |
| gLastClickY = 0; |
| gLastClickButton = blink::WebMouseEvent::ButtonNone; |
| } |
| |
| bool isKeyPadKeyval(guint keyval) |
| { |
| // Keypad keyvals all fall into one range. |
| return keyval >= GDK_KP_Space && keyval <= GDK_KP_9; |
| } |
| |
| } // namespace |
| |
| namespace blink { |
| |
| static double gdkEventTimeToWebEventTime(guint32 time) |
| { |
| // Convert from time in ms to time in sec. |
| return time / 1000.0; |
| } |
| |
| static int gdkStateToWebEventModifiers(guint state) |
| { |
| int modifiers = 0; |
| if (state & GDK_SHIFT_MASK) |
| modifiers |= WebInputEvent::ShiftKey; |
| if (state & GDK_CONTROL_MASK) |
| modifiers |= WebInputEvent::ControlKey; |
| if (state & GDK_MOD1_MASK) |
| modifiers |= WebInputEvent::AltKey; |
| if (state & GDK_META_MASK) |
| modifiers |= WebInputEvent::MetaKey; |
| if (state & GDK_BUTTON1_MASK) |
| modifiers |= WebInputEvent::LeftButtonDown; |
| if (state & GDK_BUTTON2_MASK) |
| modifiers |= WebInputEvent::MiddleButtonDown; |
| if (state & GDK_BUTTON3_MASK) |
| modifiers |= WebInputEvent::RightButtonDown; |
| if (state & GDK_LOCK_MASK) |
| modifiers |= WebInputEvent::CapsLockOn; |
| if (state & GDK_MOD2_MASK) |
| modifiers |= WebInputEvent::NumLockOn; |
| return modifiers; |
| } |
| |
| static int gdkEventToWindowsKeyCode(const GdkEventKey* event) |
| { |
| static const unsigned int hardwareCodeToGDKKeyval[] = { |
| 0, // 0x00: |
| 0, // 0x01: |
| 0, // 0x02: |
| 0, // 0x03: |
| 0, // 0x04: |
| 0, // 0x05: |
| 0, // 0x06: |
| 0, // 0x07: |
| 0, // 0x08: |
| 0, // 0x09: GDK_Escape |
| GDK_1, // 0x0A: GDK_1 |
| GDK_2, // 0x0B: GDK_2 |
| GDK_3, // 0x0C: GDK_3 |
| GDK_4, // 0x0D: GDK_4 |
| GDK_5, // 0x0E: GDK_5 |
| GDK_6, // 0x0F: GDK_6 |
| GDK_7, // 0x10: GDK_7 |
| GDK_8, // 0x11: GDK_8 |
| GDK_9, // 0x12: GDK_9 |
| GDK_0, // 0x13: GDK_0 |
| GDK_minus, // 0x14: GDK_minus |
| GDK_equal, // 0x15: GDK_equal |
| 0, // 0x16: GDK_BackSpace |
| 0, // 0x17: GDK_Tab |
| GDK_q, // 0x18: GDK_q |
| GDK_w, // 0x19: GDK_w |
| GDK_e, // 0x1A: GDK_e |
| GDK_r, // 0x1B: GDK_r |
| GDK_t, // 0x1C: GDK_t |
| GDK_y, // 0x1D: GDK_y |
| GDK_u, // 0x1E: GDK_u |
| GDK_i, // 0x1F: GDK_i |
| GDK_o, // 0x20: GDK_o |
| GDK_p, // 0x21: GDK_p |
| GDK_bracketleft, // 0x22: GDK_bracketleft |
| GDK_bracketright, // 0x23: GDK_bracketright |
| 0, // 0x24: GDK_Return |
| 0, // 0x25: GDK_Control_L |
| GDK_a, // 0x26: GDK_a |
| GDK_s, // 0x27: GDK_s |
| GDK_d, // 0x28: GDK_d |
| GDK_f, // 0x29: GDK_f |
| GDK_g, // 0x2A: GDK_g |
| GDK_h, // 0x2B: GDK_h |
| GDK_j, // 0x2C: GDK_j |
| GDK_k, // 0x2D: GDK_k |
| GDK_l, // 0x2E: GDK_l |
| GDK_semicolon, // 0x2F: GDK_semicolon |
| GDK_apostrophe, // 0x30: GDK_apostrophe |
| GDK_grave, // 0x31: GDK_grave |
| 0, // 0x32: GDK_Shift_L |
| GDK_backslash, // 0x33: GDK_backslash |
| GDK_z, // 0x34: GDK_z |
| GDK_x, // 0x35: GDK_x |
| GDK_c, // 0x36: GDK_c |
| GDK_v, // 0x37: GDK_v |
| GDK_b, // 0x38: GDK_b |
| GDK_n, // 0x39: GDK_n |
| GDK_m, // 0x3A: GDK_m |
| GDK_comma, // 0x3B: GDK_comma |
| GDK_period, // 0x3C: GDK_period |
| GDK_slash, // 0x3D: GDK_slash |
| 0, // 0x3E: GDK_Shift_R |
| 0, // 0x3F: |
| 0, // 0x40: |
| 0, // 0x41: |
| 0, // 0x42: |
| 0, // 0x43: |
| 0, // 0x44: |
| 0, // 0x45: |
| 0, // 0x46: |
| 0, // 0x47: |
| 0, // 0x48: |
| 0, // 0x49: |
| 0, // 0x4A: |
| 0, // 0x4B: |
| 0, // 0x4C: |
| 0, // 0x4D: |
| 0, // 0x4E: |
| 0, // 0x4F: |
| 0, // 0x50: |
| 0, // 0x51: |
| 0, // 0x52: |
| 0, // 0x53: |
| 0, // 0x54: |
| 0, // 0x55: |
| 0, // 0x56: |
| 0, // 0x57: |
| 0, // 0x58: |
| 0, // 0x59: |
| 0, // 0x5A: |
| 0, // 0x5B: |
| 0, // 0x5C: |
| 0, // 0x5D: |
| 0, // 0x5E: |
| 0, // 0x5F: |
| 0, // 0x60: |
| 0, // 0x61: |
| 0, // 0x62: |
| 0, // 0x63: |
| 0, // 0x64: |
| 0, // 0x65: |
| 0, // 0x66: |
| 0, // 0x67: |
| 0, // 0x68: |
| 0, // 0x69: |
| 0, // 0x6A: |
| 0, // 0x6B: |
| 0, // 0x6C: |
| 0, // 0x6D: |
| 0, // 0x6E: |
| 0, // 0x6F: |
| 0, // 0x70: |
| 0, // 0x71: |
| 0, // 0x72: |
| GDK_Super_L, // 0x73: GDK_Super_L |
| GDK_Super_R, // 0x74: GDK_Super_R |
| }; |
| |
| // |windowsKeyCode| has to include a valid virtual-key code even when we |
| // use non-US layouts, e.g. even when we type an 'A' key of a US keyboard |
| // on the Hebrew layout, |windowsKeyCode| should be VK_A. |
| // On the other hand, |event->keyval| value depends on the current |
| // GdkKeymap object, i.e. when we type an 'A' key of a US keyboard on |
| // the Hebrew layout, |event->keyval| becomes GDK_hebrew_shin and this |
| // WebCore::windowsKeyCodeForKeyEvent() call returns 0. |
| // To improve compatibilty with Windows, we use |event->hardware_keycode| |
| // for retrieving its Windows key-code for the keys when the |
| // WebCore::windowsKeyCodeForEvent() call returns 0. |
| // We shouldn't use |event->hardware_keycode| for keys that GdkKeymap |
| // objects cannot change because |event->hardware_keycode| doesn't change |
| // even when we change the layout options, e.g. when we swap a control |
| // key and a caps-lock key, GTK doesn't swap their |
| // |event->hardware_keycode| values but swap their |event->keyval| values. |
| int windowsKeyCode = WebCore::windowsKeyCodeForKeyEvent(event->keyval); |
| if (windowsKeyCode) |
| return windowsKeyCode; |
| |
| const int tableSize = sizeof(hardwareCodeToGDKKeyval) / sizeof(hardwareCodeToGDKKeyval[0]); |
| if (event->hardware_keycode < tableSize) { |
| int keyval = hardwareCodeToGDKKeyval[event->hardware_keycode]; |
| if (keyval) |
| return WebCore::windowsKeyCodeForKeyEvent(keyval); |
| } |
| |
| // This key is one that keyboard-layout drivers cannot change. |
| // Use |event->keyval| to retrieve its |windowsKeyCode| value. |
| return WebCore::windowsKeyCodeForKeyEvent(event->keyval); |
| } |
| |
| // Normalizes event->state to make it Windows/Mac compatible. Since the way |
| // of setting modifier mask on X is very different than Windows/Mac as shown |
| // in http://crbug.com/127142#c8, the normalization is necessary. |
| static guint normalizeEventState(const GdkEventKey* event) |
| { |
| guint mask = 0; |
| switch (gdkEventToWindowsKeyCode(event)) { |
| case WebCore::VKEY_CONTROL: |
| case WebCore::VKEY_LCONTROL: |
| case WebCore::VKEY_RCONTROL: |
| mask = GDK_CONTROL_MASK; |
| break; |
| case WebCore::VKEY_SHIFT: |
| case WebCore::VKEY_LSHIFT: |
| case WebCore::VKEY_RSHIFT: |
| mask = GDK_SHIFT_MASK; |
| break; |
| case WebCore::VKEY_MENU: |
| case WebCore::VKEY_LMENU: |
| case WebCore::VKEY_RMENU: |
| mask = GDK_MOD1_MASK; |
| break; |
| case WebCore::VKEY_CAPITAL: |
| mask = GDK_LOCK_MASK; |
| break; |
| default: |
| return event->state; |
| } |
| if (event->type == GDK_KEY_PRESS) |
| return event->state | mask; |
| return event->state & ~mask; |
| } |
| |
| // Gets the corresponding control character of a specified key code. See: |
| // http://en.wikipedia.org/wiki/Control_characters |
| // We emulate Windows behavior here. |
| static WebUChar getControlCharacter(int windowsKeyCode, bool shift) |
| { |
| if (windowsKeyCode >= WebCore::VKEY_A && windowsKeyCode <= WebCore::VKEY_Z) { |
| // ctrl-A ~ ctrl-Z map to \x01 ~ \x1A |
| return windowsKeyCode - WebCore::VKEY_A + 1; |
| } |
| if (shift) { |
| // following graphics chars require shift key to input. |
| switch (windowsKeyCode) { |
| // ctrl-@ maps to \x00 (Null byte) |
| case WebCore::VKEY_2: |
| return 0; |
| // ctrl-^ maps to \x1E (Record separator, Information separator two) |
| case WebCore::VKEY_6: |
| return 0x1E; |
| // ctrl-_ maps to \x1F (Unit separator, Information separator one) |
| case WebCore::VKEY_OEM_MINUS: |
| return 0x1F; |
| // Returns 0 for all other keys to avoid inputting unexpected chars. |
| default: |
| return 0; |
| } |
| } else { |
| switch (windowsKeyCode) { |
| // ctrl-[ maps to \x1B (Escape) |
| case WebCore::VKEY_OEM_4: |
| return 0x1B; |
| // ctrl-\ maps to \x1C (File separator, Information separator four) |
| case WebCore::VKEY_OEM_5: |
| return 0x1C; |
| // ctrl-] maps to \x1D (Group separator, Information separator three) |
| case WebCore::VKEY_OEM_6: |
| return 0x1D; |
| // ctrl-Enter maps to \x0A (Line feed) |
| case WebCore::VKEY_RETURN: |
| return 0x0A; |
| // Returns 0 for all other keys to avoid inputting unexpected chars. |
| default: |
| return 0; |
| } |
| } |
| } |
| |
| // WebKeyboardEvent ----------------------------------------------------------- |
| |
| WebKeyboardEvent WebInputEventFactory::keyboardEvent(const GdkEventKey* event) |
| { |
| WebKeyboardEvent result; |
| |
| result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); |
| result.modifiers = gdkStateToWebEventModifiers(normalizeEventState(event)); |
| |
| switch (event->type) { |
| case GDK_KEY_RELEASE: |
| result.type = WebInputEvent::KeyUp; |
| break; |
| case GDK_KEY_PRESS: |
| result.type = WebInputEvent::RawKeyDown; |
| break; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| |
| result.isSystemKey = WebInputEventFactory::isSystemKeyEvent(result); |
| |
| // The key code tells us which physical key was pressed (for example, the |
| // A key went down or up). It does not determine whether A should be lower |
| // or upper case. This is what text does, which should be the keyval. |
| int windowsKeyCode = gdkEventToWindowsKeyCode(event); |
| result.windowsKeyCode = WebKeyboardEvent::windowsKeyCodeWithoutLocation(windowsKeyCode); |
| result.modifiers |= WebKeyboardEvent::locationModifiersFromWindowsKeyCode(windowsKeyCode); |
| result.nativeKeyCode = event->hardware_keycode; |
| |
| if (result.windowsKeyCode == WebCore::VKEY_RETURN) |
| // We need to treat the enter key as a key press of character \r. This |
| // is apparently just how webkit handles it and what it expects. |
| result.unmodifiedText[0] = '\r'; |
| else |
| // FIXME: fix for non BMP chars |
| result.unmodifiedText[0] = |
| static_cast<WebUChar>(gdk_keyval_to_unicode(event->keyval)); |
| |
| // If ctrl key is pressed down, then control character shall be input. |
| if (result.modifiers & WebInputEvent::ControlKey) |
| result.text[0] = getControlCharacter( |
| result.windowsKeyCode, result.modifiers & WebInputEvent::ShiftKey); |
| else |
| result.text[0] = result.unmodifiedText[0]; |
| |
| result.setKeyIdentifierFromWindowsKeyCode(); |
| |
| // FIXME: Do we need to set IsAutoRepeat? |
| if (isKeyPadKeyval(event->keyval)) |
| result.modifiers |= WebInputEvent::IsKeyPad; |
| |
| return result; |
| } |
| |
| bool WebInputEventFactory::isSystemKeyEvent(const WebKeyboardEvent& event) |
| { |
| // On Windows all keys with Alt modifier will be marked as system key. |
| // We keep the same behavior on Linux and everywhere non-Mac. |
| return event.modifiers & WebInputEvent::AltKey; |
| } |
| |
| WebKeyboardEvent WebInputEventFactory::keyboardEvent(wchar_t character, int state, double timeStampSeconds) |
| { |
| // keyboardEvent(const GdkEventKey*) depends on the GdkEventKey object and |
| // it is hard to use/ it from signal handlers which don't use GdkEventKey |
| // objects (e.g. GtkIMContext signal handlers.) For such handlers, this |
| // function creates a WebInputEvent::Char event without using a |
| // GdkEventKey object. |
| WebKeyboardEvent result; |
| result.type = blink::WebInputEvent::Char; |
| result.timeStampSeconds = timeStampSeconds; |
| result.modifiers = gdkStateToWebEventModifiers(state); |
| result.windowsKeyCode = character; |
| result.nativeKeyCode = character; |
| result.text[0] = character; |
| result.unmodifiedText[0] = character; |
| |
| // According to MSDN: |
| // http://msdn.microsoft.com/en-us/library/ms646286(VS.85).aspx |
| // Key events with Alt modifier and F10 are system key events. |
| // We just emulate this behavior. It's necessary to prevent webkit from |
| // processing keypress event generated by alt-d, etc. |
| // F10 is not special on Linux, so don't treat it as system key. |
| if (result.modifiers & WebInputEvent::AltKey) |
| result.isSystemKey = true; |
| |
| return result; |
| } |
| |
| // WebMouseEvent -------------------------------------------------------------- |
| |
| WebMouseEvent WebInputEventFactory::mouseEvent(const GdkEventButton* event) |
| { |
| WebMouseEvent result; |
| |
| result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); |
| |
| result.modifiers = gdkStateToWebEventModifiers(event->state); |
| result.x = static_cast<int>(event->x); |
| result.y = static_cast<int>(event->y); |
| result.windowX = result.x; |
| result.windowY = result.y; |
| result.globalX = static_cast<int>(event->x_root); |
| result.globalY = static_cast<int>(event->y_root); |
| result.clickCount = 0; |
| |
| switch (event->type) { |
| case GDK_BUTTON_PRESS: |
| result.type = WebInputEvent::MouseDown; |
| break; |
| case GDK_BUTTON_RELEASE: |
| result.type = WebInputEvent::MouseUp; |
| break; |
| case GDK_3BUTTON_PRESS: |
| case GDK_2BUTTON_PRESS: |
| default: |
| ASSERT_NOT_REACHED(); |
| }; |
| |
| result.button = WebMouseEvent::ButtonNone; |
| if (event->button == 1) |
| result.button = WebMouseEvent::ButtonLeft; |
| else if (event->button == 2) |
| result.button = WebMouseEvent::ButtonMiddle; |
| else if (event->button == 3) |
| result.button = WebMouseEvent::ButtonRight; |
| |
| if (result.type == WebInputEvent::MouseDown) { |
| bool forgetPreviousClick = shouldForgetPreviousClick(event->window, event->time, event->x, event->y); |
| |
| if (!forgetPreviousClick && result.button == gLastClickButton) |
| ++gNumClicks; |
| else { |
| gNumClicks = 1; |
| |
| gLastClickEventWindow = event->window; |
| gLastClickX = event->x; |
| gLastClickY = event->y; |
| gLastClickButton = result.button; |
| } |
| gLastClickTime = event->time; |
| } |
| result.clickCount = gNumClicks; |
| |
| return result; |
| } |
| |
| WebMouseEvent WebInputEventFactory::mouseEvent(const GdkEventMotion* event) |
| { |
| WebMouseEvent result; |
| |
| result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); |
| result.modifiers = gdkStateToWebEventModifiers(event->state); |
| result.x = static_cast<int>(event->x); |
| result.y = static_cast<int>(event->y); |
| result.windowX = result.x; |
| result.windowY = result.y; |
| result.globalX = static_cast<int>(event->x_root); |
| result.globalY = static_cast<int>(event->y_root); |
| |
| switch (event->type) { |
| case GDK_MOTION_NOTIFY: |
| result.type = WebInputEvent::MouseMove; |
| break; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| |
| result.button = WebMouseEvent::ButtonNone; |
| if (event->state & GDK_BUTTON1_MASK) |
| result.button = WebMouseEvent::ButtonLeft; |
| else if (event->state & GDK_BUTTON2_MASK) |
| result.button = WebMouseEvent::ButtonMiddle; |
| else if (event->state & GDK_BUTTON3_MASK) |
| result.button = WebMouseEvent::ButtonRight; |
| |
| if (shouldForgetPreviousClick(event->window, event->time, event->x, event->y)) |
| resetClickCountState(); |
| |
| return result; |
| } |
| |
| WebMouseEvent WebInputEventFactory::mouseEvent(const GdkEventCrossing* event) |
| { |
| WebMouseEvent result; |
| |
| result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); |
| result.modifiers = gdkStateToWebEventModifiers(event->state); |
| result.x = static_cast<int>(event->x); |
| result.y = static_cast<int>(event->y); |
| result.windowX = result.x; |
| result.windowY = result.y; |
| result.globalX = static_cast<int>(event->x_root); |
| result.globalY = static_cast<int>(event->y_root); |
| |
| switch (event->type) { |
| case GDK_ENTER_NOTIFY: |
| case GDK_LEAVE_NOTIFY: |
| // Note that if we sent MouseEnter or MouseLeave to WebKit, it |
| // wouldn't work - they don't result in the proper JavaScript events. |
| // MouseMove does the right thing. |
| result.type = WebInputEvent::MouseMove; |
| break; |
| default: |
| ASSERT_NOT_REACHED(); |
| } |
| |
| result.button = WebMouseEvent::ButtonNone; |
| if (event->state & GDK_BUTTON1_MASK) |
| result.button = WebMouseEvent::ButtonLeft; |
| else if (event->state & GDK_BUTTON2_MASK) |
| result.button = WebMouseEvent::ButtonMiddle; |
| else if (event->state & GDK_BUTTON3_MASK) |
| result.button = WebMouseEvent::ButtonRight; |
| |
| if (shouldForgetPreviousClick(event->window, event->time, event->x, event->y)) |
| resetClickCountState(); |
| |
| return result; |
| } |
| |
| // WebMouseWheelEvent --------------------------------------------------------- |
| |
| WebMouseWheelEvent WebInputEventFactory::mouseWheelEvent(const GdkEventScroll* event) |
| { |
| WebMouseWheelEvent result; |
| |
| result.type = WebInputEvent::MouseWheel; |
| result.button = WebMouseEvent::ButtonNone; |
| |
| result.timeStampSeconds = gdkEventTimeToWebEventTime(event->time); |
| result.modifiers = gdkStateToWebEventModifiers(event->state); |
| result.x = static_cast<int>(event->x); |
| result.y = static_cast<int>(event->y); |
| result.windowX = result.x; |
| result.windowY = result.y; |
| result.globalX = static_cast<int>(event->x_root); |
| result.globalY = static_cast<int>(event->y_root); |
| |
| // How much should we scroll per mouse wheel event? |
| // - Windows uses 3 lines by default and obeys a system setting. |
| // - Mozilla has a pref that lets you either use the "system" number of lines |
| // to scroll, or lets the user override it. |
| // For the "system" number of lines, it appears they've hardcoded 3. |
| // See case NS_MOUSE_SCROLL in content/events/src/nsEventStateManager.cpp |
| // and InitMouseScrollEvent in widget/src/gtk2/nsCommonWidget.cpp . |
| // - Gtk makes the scroll amount a function of the size of the scroll bar, |
| // which is not available to us here. |
| // Instead, we pick a number that empirically matches Firefox's behavior. |
| static const float scrollbarPixelsPerTick = 160.0f / 3.0f; |
| |
| switch (event->direction) { |
| case GDK_SCROLL_UP: |
| result.deltaY = scrollbarPixelsPerTick; |
| result.wheelTicksY = 1; |
| break; |
| case GDK_SCROLL_DOWN: |
| result.deltaY = -scrollbarPixelsPerTick; |
| result.wheelTicksY = -1; |
| break; |
| case GDK_SCROLL_LEFT: |
| result.deltaX = scrollbarPixelsPerTick; |
| result.wheelTicksX = 1; |
| break; |
| case GDK_SCROLL_RIGHT: |
| result.deltaX = -scrollbarPixelsPerTick; |
| result.wheelTicksX = -1; |
| break; |
| } |
| |
| return result; |
| } |
| |
| } // namespace blink |