Changeset 246496 in webkit


Ignore:
Timestamp:
Jun 17, 2019 8:01:09 AM (5 years ago)
Author:
commit-queue@webkit.org
Message:

[GTK] Stop accessing GdkEvent fields when possible
https://bugs.webkit.org/show_bug.cgi?id=198829

Patch by Ludovico de Nittis <ludovico.denittis@collabora.com> on 2019-06-17
Reviewed by Michael Catanzaro.

Direct access to GdkEvent structs is no longer possible in GTK 4.

Source/WebCore:

No behaviour changes.

  • platform/gtk/PlatformKeyboardEventGtk.cpp:

(WebCore::eventTypeForGdkKeyEvent):
(WebCore::modifiersForGdkKeyEvent):
(WebCore::PlatformKeyboardEvent::PlatformKeyboardEvent):

  • platform/gtk/PlatformMouseEventGtk.cpp:

(WebCore::PlatformMouseEvent::PlatformMouseEvent):

  • platform/gtk/PlatformWheelEventGtk.cpp:

(WebCore::PlatformWheelEvent::PlatformWheelEvent):

Source/WebKit:

  • Shared/gtk/WebEventFactory.cpp:

(WebKit::buttonForEvent):
(WebKit::WebEventFactory::createWebMouseEvent):
(WebKit::WebEventFactory::createWebWheelEvent):
(WebKit::WebEventFactory::createWebKeyboardEvent):
(WebKit::WebEventFactory::createWebTouchEvent):

  • UIProcess/API/gtk/WebKitEmojiChooser.cpp:
  • UIProcess/API/gtk/WebKitScriptDialogImpl.cpp:

(webkitScriptDialogImplKeyPressEvent):

  • UIProcess/API/gtk/WebKitWebViewBase.cpp:

(ClickCounter::currentClickCountForGdkButtonEvent):
(webkitWebViewBaseKeyPressEvent):
(webkitWebViewBaseHandleMouseEvent):
(webkitWebViewBaseCrossingNotifyEvent):
(webkitWebViewBaseGetTouchPointsForEvent):
(webkitWebViewBaseTouchEvent):
(webkitWebViewBaseEvent):

  • UIProcess/gtk/GestureController.cpp:

(WebKit::GestureController::handleEvent):

  • UIProcess/gtk/InputMethodFilter.cpp:

(WebKit::InputMethodFilter::filterKeyEvent):
(WebKit::InputMethodFilter::logHandleKeyboardEventForTesting):
(WebKit::InputMethodFilter::logHandleKeyboardEventWithCompositionResultsForTesting):

  • UIProcess/gtk/KeyBindingTranslator.cpp:

(WebKit::KeyBindingTranslator::commandsForKeyEvent):

  • UIProcess/gtk/ViewGestureControllerGtk.cpp:

(WebKit::isEventStop):
(WebKit::ViewGestureController::PendingSwipeTracker::scrollEventCanInfluenceSwipe):
(WebKit::ViewGestureController::PendingSwipeTracker::scrollEventGetScrollingDeltas):
(WebKit::ViewGestureController::SwipeProgressTracker::handleEvent):

  • UIProcess/gtk/WebPopupMenuProxyGtk.cpp:

(WebKit::WebPopupMenuProxyGtk::treeViewButtonReleaseEventCallback):
(WebKit::WebPopupMenuProxyGtk::keyPressEventCallback):

Location:
trunk/Source
Files:
14 edited

Legend:

Unmodified
Added
Removed
  • trunk/Source/WebCore/ChangeLog

    r246494 r246496  
     12019-06-17  Ludovico de Nittis  <ludovico.denittis@collabora.com>
     2
     3        [GTK] Stop accessing GdkEvent fields when possible
     4        https://bugs.webkit.org/show_bug.cgi?id=198829
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        Direct access to GdkEvent structs is no longer possible in GTK 4.
     9
     10        No behaviour changes.
     11
     12        * platform/gtk/PlatformKeyboardEventGtk.cpp:
     13        (WebCore::eventTypeForGdkKeyEvent):
     14        (WebCore::modifiersForGdkKeyEvent):
     15        (WebCore::PlatformKeyboardEvent::PlatformKeyboardEvent):
     16        * platform/gtk/PlatformMouseEventGtk.cpp:
     17        (WebCore::PlatformMouseEvent::PlatformMouseEvent):
     18        * platform/gtk/PlatformWheelEventGtk.cpp:
     19        (WebCore::PlatformWheelEvent::PlatformWheelEvent):
     20
    1212019-06-17  Carlos Garcia Campos  <cgarcia@igalia.com>
    222
  • trunk/Source/WebCore/platform/gtk/PlatformKeyboardEventGtk.cpp

    r246494 r246496  
    13251325static PlatformEvent::Type eventTypeForGdkKeyEvent(GdkEventKey* event)
    13261326{
     1327#if GTK_CHECK_VERSION(3, 10, 0)
     1328    return gdk_event_get_event_type(reinterpret_cast<GdkEvent*>(event)) == GDK_KEY_RELEASE ? PlatformEvent::KeyUp : PlatformEvent::KeyDown;
     1329#else
    13271330    return event->type == GDK_KEY_RELEASE ? PlatformEvent::KeyUp : PlatformEvent::KeyDown;
     1331#endif
    13281332}
    13291333
    13301334static OptionSet<PlatformEvent::Modifier> modifiersForGdkKeyEvent(GdkEventKey* event)
    13311335{
     1336    GdkModifierType state;
     1337    guint keyval;
    13321338    OptionSet<PlatformEvent::Modifier> modifiers;
    1333     if (event->state & GDK_SHIFT_MASK || event->keyval == GDK_KEY_3270_BackTab)
     1339    gdk_event_get_state(reinterpret_cast<GdkEvent*>(event), &state);
     1340#ifndef GTK_API_VERSION_2
     1341    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     1342#else
     1343    keyval = event->keyval;
     1344#endif
     1345    if (state & GDK_SHIFT_MASK || keyval == GDK_KEY_3270_BackTab)
    13341346        modifiers.add(PlatformEvent::Modifier::ShiftKey);
    1335     if (event->state & GDK_CONTROL_MASK)
     1347    if (state & GDK_CONTROL_MASK)
    13361348        modifiers.add(PlatformEvent::Modifier::ControlKey);
    1337     if (event->state & GDK_MOD1_MASK)
     1349    if (state & GDK_MOD1_MASK)
    13381350        modifiers.add(PlatformEvent::Modifier::AltKey);
    1339     if (event->state & GDK_META_MASK)
     1351    if (state & GDK_META_MASK)
    13401352        modifiers.add(PlatformEvent::Modifier::MetaKey);
    1341     if (event->state & GDK_LOCK_MASK)
     1353    if (state & GDK_LOCK_MASK)
    13421354        modifiers.add(PlatformEvent::Modifier::CapsLockKey);
    13431355    return modifiers;
     
    13471359PlatformKeyboardEvent::PlatformKeyboardEvent(GdkEventKey* event, const CompositionResults& compositionResults)
    13481360    : PlatformEvent(eventTypeForGdkKeyEvent(event), modifiersForGdkKeyEvent(event), wallTimeForEvent(event))
    1349     , m_text(compositionResults.simpleString.length() ? compositionResults.simpleString : singleCharacterString(event->keyval))
    1350     , m_unmodifiedText(m_text)
    1351     , m_key(keyValueForGdkKeyCode(event->keyval))
    1352     , m_code(keyCodeForHardwareKeyCode(event->hardware_keycode))
    1353     , m_keyIdentifier(keyIdentifierForGdkKeyCode(event->keyval))
    1354     , m_windowsVirtualKeyCode(windowsKeyCodeForGdkKeyCode(event->keyval))
    13551361    , m_handledByInputMethod(false)
    13561362    , m_autoRepeat(false)
    1357     , m_isKeypad(event->keyval >= GDK_KEY_KP_Space && event->keyval <= GDK_KEY_KP_9)
    13581363    , m_isSystemKey(false)
    13591364    , m_gdkEventKey(event)
    13601365    , m_compositionResults(compositionResults)
    13611366{
     1367    guint keyval;
     1368    guint16 keycode;
     1369#ifndef GTK_API_VERSION_2
     1370    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     1371    gdk_event_get_keycode(reinterpret_cast<GdkEvent*>(event), &keycode);
     1372#else
     1373    keyval = event->keyval;
     1374    keycode = event->hardware_keycode;
     1375#endif
     1376
     1377    m_text = compositionResults.simpleString.length() ? compositionResults.simpleString : singleCharacterString(keyval);
     1378    m_unmodifiedText = m_text;
     1379    m_key = keyValueForGdkKeyCode(keyval);
     1380    m_code = keyCodeForHardwareKeyCode(keycode);
     1381    m_keyIdentifier = keyIdentifierForGdkKeyCode(keyval);
     1382    m_windowsVirtualKeyCode = windowsKeyCodeForGdkKeyCode(keyval);
     1383    m_isKeypad = keyval >= GDK_KEY_KP_Space && keyval <= GDK_KEY_KP_9;
     1384
    13621385    // To match the behavior of IE, we return VK_PROCESSKEY for keys that triggered composition results.
    13631386    if (compositionResults.compositionUpdated())
  • trunk/Source/WebCore/platform/gtk/PlatformMouseEventGtk.cpp

    r246494 r246496  
    4040PlatformMouseEvent::PlatformMouseEvent(GdkEventButton* event)
    4141{
     42    gdouble x, y, rootX, rootY;
     43    GdkModifierType state;
     44    guint button;
     45
     46    gdk_event_get_coords(reinterpret_cast<GdkEvent*>(event), &x, &y);
     47    gdk_event_get_root_coords(reinterpret_cast<GdkEvent*>(event), &rootX, &rootY);
     48    gdk_event_get_state(reinterpret_cast<GdkEvent*>(event), &state);
     49#ifndef GTK_API_VERSION_2
     50    gdk_event_get_button(reinterpret_cast<GdkEvent*>(event), &button);
     51#else
     52    button = event->button;
     53#endif
     54
    4255    m_timestamp = wallTimeForEvent(event);
    43     m_position = IntPoint((int)event->x, (int)event->y);
    44     m_globalPosition = IntPoint((int)event->x_root, (int)event->y_root);
     56    m_position = IntPoint(static_cast<int>(x), static_cast<int>(y));
     57    m_globalPosition = IntPoint(static_cast<int>(rootX), static_cast<int>(rootY));
    4558    m_button = NoButton;
    4659    m_clickCount = 0;
    4760    m_modifierFlags = 0;
    4861
    49     if (event->state & GDK_SHIFT_MASK)
     62    if (state & GDK_SHIFT_MASK)
    5063        m_modifiers.add(PlatformEvent::Modifier::ShiftKey);
    51     if (event->state & GDK_CONTROL_MASK)
     64    if (state & GDK_CONTROL_MASK)
    5265        m_modifiers.add(PlatformEvent::Modifier::ControlKey);
    53     if (event->state & GDK_MOD1_MASK)
     66    if (state & GDK_MOD1_MASK)
    5467        m_modifiers.add(PlatformEvent::Modifier::AltKey);
    55     if (event->state & GDK_META_MASK)
     68    if (state & GDK_META_MASK)
    5669        m_modifiers.add(PlatformEvent::Modifier::MetaKey);
    57     if (PlatformKeyboardEvent::modifiersContainCapsLock(event->state))
     70    if (PlatformKeyboardEvent::modifiersContainCapsLock(state))
    5871        m_modifiers.add(PlatformEvent::Modifier::CapsLockKey);
    5972
    60     switch (event->type) {
     73#if GTK_CHECK_VERSION(3, 10, 0)
     74    GdkEventType type = gdk_event_get_event_type(reinterpret_cast<GdkEvent*>(event));
     75#else
     76    GdkEventType type = event->type;
     77#endif
     78
     79    switch (type) {
    6180    case GDK_BUTTON_PRESS:
    6281    case GDK_2BUTTON_PRESS:
     
    6483    case GDK_BUTTON_RELEASE:
    6584        m_type = PlatformEvent::MousePressed;
    66         if (event->type == GDK_BUTTON_RELEASE) {
     85        if (type == GDK_BUTTON_RELEASE) {
    6786            m_type = PlatformEvent::MouseReleased;
    6887            m_clickCount = 0;
    69         } else if (event->type == GDK_BUTTON_PRESS)
     88        } else if (type == GDK_BUTTON_PRESS)
    7089            m_clickCount = 1;
    71         else if (event->type == GDK_2BUTTON_PRESS)
     90        else if (type == GDK_2BUTTON_PRESS)
    7291            m_clickCount = 2;
    73         else if (event->type == GDK_3BUTTON_PRESS)
     92        else if (type == GDK_3BUTTON_PRESS)
    7493            m_clickCount = 3;
    7594
    76         if (event->button == 1)
     95        if (button == 1)
    7796            m_button = LeftButton;
    78         else if (event->button == 2)
     97        else if (button == 2)
    7998            m_button = MiddleButton;
    80         else if (event->button == 3)
     99        else if (button == 3)
    81100            m_button = RightButton;
    82101        break;
     
    89108PlatformMouseEvent::PlatformMouseEvent(GdkEventMotion* motion)
    90109{
     110    gdouble x, y, rootX, rootY;
     111    GdkModifierType state;
     112    gdk_event_get_coords(reinterpret_cast<GdkEvent*>(motion), &x, &y);
     113    gdk_event_get_root_coords(reinterpret_cast<GdkEvent*>(motion), &rootX, &rootY);
     114    gdk_event_get_state(reinterpret_cast<GdkEvent*>(motion), &state);
     115    m_position = IntPoint(static_cast<int>(x), static_cast<int>(y));
     116    m_globalPosition = IntPoint(static_cast<int>(rootX), static_cast<int>(rootY));
    91117    m_timestamp = wallTimeForEvent(motion);
    92     m_position = IntPoint((int)motion->x, (int)motion->y);
    93     m_globalPosition = IntPoint((int)motion->x_root, (int)motion->y_root);
    94118    m_button = NoButton;
    95119    m_clickCount = 0;
    96120    m_modifierFlags = 0;
    97121
    98     if (motion->state & GDK_SHIFT_MASK)
     122    if (state & GDK_SHIFT_MASK)
    99123        m_modifiers.add(PlatformEvent::Modifier::ShiftKey);
    100     if (motion->state & GDK_CONTROL_MASK)
     124    if (state & GDK_CONTROL_MASK)
    101125        m_modifiers.add(PlatformEvent::Modifier::ControlKey);
    102     if (motion->state & GDK_MOD1_MASK)
     126    if (state & GDK_MOD1_MASK)
    103127        m_modifiers.add(PlatformEvent::Modifier::AltKey);
    104     if (motion->state & GDK_META_MASK)
     128    if (state & GDK_META_MASK)
    105129        m_modifiers.add(PlatformEvent::Modifier::MetaKey);
    106     if (PlatformKeyboardEvent::modifiersContainCapsLock(motion->state))
     130    if (PlatformKeyboardEvent::modifiersContainCapsLock(state))
    107131        m_modifiers.add(PlatformEvent::Modifier::CapsLockKey);
    108132
    109     switch (motion->type) {
     133#if GTK_CHECK_VERSION(3, 10, 0)
     134    GdkEventType type = gdk_event_get_event_type(reinterpret_cast<GdkEvent*>(motion));
     135#else
     136    GdkEventType type = motion->type;
     137#endif
     138
     139    switch (type) {
    110140    case GDK_MOTION_NOTIFY:
    111141        m_type = PlatformEvent::MouseMoved;
     
    117147    };
    118148
    119     if (motion->state & GDK_BUTTON1_MASK)
     149    if (state & GDK_BUTTON1_MASK)
    120150        m_button = LeftButton;
    121     else if (motion->state & GDK_BUTTON2_MASK)
     151    else if (state & GDK_BUTTON2_MASK)
    122152        m_button = MiddleButton;
    123     else if (motion->state & GDK_BUTTON3_MASK)
     153    else if (state & GDK_BUTTON3_MASK)
    124154        m_button = RightButton;
    125155}
  • trunk/Source/WebCore/platform/gtk/PlatformWheelEventGtk.cpp

    r246494 r246496  
    4343{
    4444    static const float delta = 1;
     45    GdkModifierType state;
    4546
    4647    m_type = PlatformEvent::Wheel;
    4748    m_timestamp = wallTimeForEvent(event);
     49    gdk_event_get_state(reinterpret_cast<GdkEvent*>(event), &state);
    4850
    49     if (event->state & GDK_SHIFT_MASK)
     51    if (state & GDK_SHIFT_MASK)
    5052        m_modifiers.add(Modifier::ShiftKey);
    51     if (event->state & GDK_CONTROL_MASK)
     53    if (state & GDK_CONTROL_MASK)
    5254        m_modifiers.add(Modifier::ControlKey);
    53     if (event->state & GDK_MOD1_MASK)
     55    if (state & GDK_MOD1_MASK)
    5456        m_modifiers.add(Modifier::AltKey);
    55     if (event->state & GDK_META_MASK)
     57    if (state & GDK_META_MASK)
    5658        m_modifiers.add(Modifier::MetaKey);
    57     if (PlatformKeyboardEvent::modifiersContainCapsLock(event->state))
     59    if (PlatformKeyboardEvent::modifiersContainCapsLock(state))
    5860        m_modifiers.add(PlatformEvent::Modifier::CapsLockKey);
    5961
    6062    m_deltaX = 0;
    6163    m_deltaY = 0;
     64    GdkScrollDirection direction;
     65#ifndef GTK_API_VERSION_2
     66    if (!gdk_event_get_scroll_direction(reinterpret_cast<GdkEvent*>(event), &direction)) {
     67        gdouble deltaX, deltaY;
     68        if (gdk_event_get_scroll_deltas(reinterpret_cast<GdkEvent*>(event), &deltaX, &deltaY)) {
     69            m_deltaX = -deltaX;
     70            m_deltaY = -deltaY;
     71        }
     72    }
     73#else
     74    direction = event->direction;
     75#endif
    6276
    6377    // Docs say an upwards scroll (away from the user) has a positive delta
    64     switch (event->direction) {
     78    if (!m_deltaX && !m_deltaY) {
     79        switch (direction) {
    6580        case GDK_SCROLL_UP:
    6681            m_deltaY = delta;
     
    7590            m_deltaX = -delta;
    7691            break;
    77 #if GTK_CHECK_VERSION(3, 3, 18)
    78         case GDK_SCROLL_SMOOTH: {
    79                 gdouble deltaX, deltaY;
    80                 gdk_event_get_scroll_deltas(reinterpret_cast<GdkEvent*>(event), &deltaX, &deltaY);
    81                 m_deltaX = -deltaX;
    82                 m_deltaY = -deltaY;
    83             }
    84             break;
    85 #endif
     92        default:
     93            ASSERT_NOT_REACHED();
     94        }
    8695    }
    8796    m_wheelTicksX = m_deltaX;
     
    91100#ifndef GTK_API_VERSION_2
    92101#if GTK_CHECK_VERSION(3, 20, 0)
    93     m_phase = event->is_stop ?
     102    m_phase = gdk_event_is_scroll_stop_event(reinterpret_cast<GdkEvent*>(event)) ?
    94103        PlatformWheelEventPhaseEnded :
    95104        PlatformWheelEventPhaseChanged;
    96105#else
    97     m_phase = event->direction == GDK_SCROLL_SMOOTH && !m_deltaX && !m_deltaY ?
     106    m_phase = direction == GDK_SCROLL_SMOOTH && !m_deltaX && !m_deltaY ?
    98107        PlatformWheelEventPhaseEnded :
    99108        PlatformWheelEventPhaseChanged;
     
    104113#endif // ENABLE(ASYNC_SCROLLING)
    105114
    106     m_position = IntPoint(static_cast<int>(event->x), static_cast<int>(event->y));
    107     m_globalPosition = IntPoint(static_cast<int>(event->x_root), static_cast<int>(event->y_root));
     115    gdouble x, y, rootX, rootY;
     116    gdk_event_get_coords(reinterpret_cast<GdkEvent*>(event), &x, &y);
     117    gdk_event_get_root_coords(reinterpret_cast<GdkEvent*>(event), &rootX, &rootY);
     118
     119    m_position = IntPoint(static_cast<int>(x), static_cast<int>(y));
     120    m_globalPosition = IntPoint(static_cast<int>(rootX), static_cast<int>(rootY));
    108121    m_granularity = ScrollByPixelWheelEvent;
    109122    m_directionInvertedFromDevice = false;
  • trunk/Source/WebKit/ChangeLog

    r246495 r246496  
     12019-06-17  Ludovico de Nittis  <ludovico.denittis@collabora.com>
     2
     3        [GTK] Stop accessing GdkEvent fields when possible
     4        https://bugs.webkit.org/show_bug.cgi?id=198829
     5
     6        Reviewed by Michael Catanzaro.
     7
     8        Direct access to GdkEvent structs is no longer possible in GTK 4.
     9
     10        * Shared/gtk/WebEventFactory.cpp:
     11        (WebKit::buttonForEvent):
     12        (WebKit::WebEventFactory::createWebMouseEvent):
     13        (WebKit::WebEventFactory::createWebWheelEvent):
     14        (WebKit::WebEventFactory::createWebKeyboardEvent):
     15        (WebKit::WebEventFactory::createWebTouchEvent):
     16        * UIProcess/API/gtk/WebKitEmojiChooser.cpp:
     17        * UIProcess/API/gtk/WebKitScriptDialogImpl.cpp:
     18        (webkitScriptDialogImplKeyPressEvent):
     19        * UIProcess/API/gtk/WebKitWebViewBase.cpp:
     20        (ClickCounter::currentClickCountForGdkButtonEvent):
     21        (webkitWebViewBaseKeyPressEvent):
     22        (webkitWebViewBaseHandleMouseEvent):
     23        (webkitWebViewBaseCrossingNotifyEvent):
     24        (webkitWebViewBaseGetTouchPointsForEvent):
     25        (webkitWebViewBaseTouchEvent):
     26        (webkitWebViewBaseEvent):
     27        * UIProcess/gtk/GestureController.cpp:
     28        (WebKit::GestureController::handleEvent):
     29        * UIProcess/gtk/InputMethodFilter.cpp:
     30        (WebKit::InputMethodFilter::filterKeyEvent):
     31        (WebKit::InputMethodFilter::logHandleKeyboardEventForTesting):
     32        (WebKit::InputMethodFilter::logHandleKeyboardEventWithCompositionResultsForTesting):
     33        * UIProcess/gtk/KeyBindingTranslator.cpp:
     34        (WebKit::KeyBindingTranslator::commandsForKeyEvent):
     35        * UIProcess/gtk/ViewGestureControllerGtk.cpp:
     36        (WebKit::isEventStop):
     37        (WebKit::ViewGestureController::PendingSwipeTracker::scrollEventCanInfluenceSwipe):
     38        (WebKit::ViewGestureController::PendingSwipeTracker::scrollEventGetScrollingDeltas):
     39        (WebKit::ViewGestureController::SwipeProgressTracker::handleEvent):
     40        * UIProcess/gtk/WebPopupMenuProxyGtk.cpp:
     41        (WebKit::WebPopupMenuProxyGtk::treeViewButtonReleaseEventCallback):
     42        (WebKit::WebPopupMenuProxyGtk::keyPressEventCallback):
     43
    1442019-06-17  Carlos Garcia Campos  <cgarcia@igalia.com>
    245
  • trunk/Source/WebKit/Shared/gtk/WebEventFactory.cpp

    r246494 r246496  
    7474{
    7575    unsigned button = 0;
    76 
    77     switch (event->type) {
     76#if GTK_CHECK_VERSION(3, 10, 0)
     77    GdkEventType type = gdk_event_get_event_type(event);
     78#else
     79    GdkEventType type = event->type;
     80#endif
     81    switch (type) {
    7882    case GDK_ENTER_NOTIFY:
    7983    case GDK_LEAVE_NOTIFY:
     
    9498    case GDK_3BUTTON_PRESS:
    9599    case GDK_BUTTON_RELEASE:
    96         if (event->button.button == 1)
     100        guint eventButton;
     101#ifndef GTK_API_VERSION_2
     102        gdk_event_get_button(event, &eventButton);
     103#else
     104        eventButton = event->button;
     105#endif
     106        if (eventButton == 1)
    97107            button = WebMouseEvent::LeftButton;
    98         else if (event->button.button == 2)
     108        else if (eventButton == 2)
    99109            button = WebMouseEvent::MiddleButton;
    100         else if (event->button.button == 3)
     110        else if (eventButton == 3)
    101111            button = WebMouseEvent::RightButton;
    102112        break;
     
    142152    gdk_event_get_state(event, &state);
    143153
     154    guint eventButton;
     155#ifndef GTK_API_VERSION_2
     156    gdk_event_get_button(event, &eventButton);
     157#else
     158    eventButton = event->button;
     159#endif
     160
    144161    WebEvent::Type type = static_cast<WebEvent::Type>(0);
    145     switch (event->type) {
     162
     163#if GTK_CHECK_VERSION(3, 10, 0)
     164    GdkEventType eventType = gdk_event_get_event_type(event);
     165#else
     166    GdkEventType eventType = event->type;
     167#endif
     168    switch (eventType) {
    146169    case GDK_MOTION_NOTIFY:
    147170    case GDK_ENTER_NOTIFY:
     
    153176    case GDK_3BUTTON_PRESS: {
    154177        type = WebEvent::MouseDown;
    155         auto modifier = stateModifierForGdkButton(event->button.button);
     178        auto modifier = stateModifierForGdkButton(eventButton);
    156179        state = static_cast<GdkModifierType>(state | modifier);
    157180        break;
     
    159182    case GDK_BUTTON_RELEASE: {
    160183        type = WebEvent::MouseUp;
    161         auto modifier = stateModifierForGdkButton(event->button.button);
     184        auto modifier = stateModifierForGdkButton(eventButton);
    162185        state = static_cast<GdkModifierType>(state & ~modifier);
    163186        break;
     
    204227{
    205228    double x, y, xRoot, yRoot;
     229    GdkScrollDirection direction;
     230    FloatSize wheelTicks = FloatSize(0, 0);
    206231    gdk_event_get_coords(event, &x, &y);
    207232    gdk_event_get_root_coords(event, &xRoot, &yRoot);
    208 
    209     FloatSize wheelTicks;
    210     switch (event->scroll.direction) {
    211     case GDK_SCROLL_UP:
    212         wheelTicks = FloatSize(0, 1);
    213         break;
    214     case GDK_SCROLL_DOWN:
    215         wheelTicks = FloatSize(0, -1);
    216         break;
    217     case GDK_SCROLL_LEFT:
    218         wheelTicks = FloatSize(1, 0);
    219         break;
    220     case GDK_SCROLL_RIGHT:
    221         wheelTicks = FloatSize(-1, 0);
    222         break;
    223 #if GTK_CHECK_VERSION(3, 3, 18)
    224     case GDK_SCROLL_SMOOTH: {
    225             double deltaX, deltaY;
    226             gdk_event_get_scroll_deltas(event, &deltaX, &deltaY);
     233#ifndef GTK_API_VERSION_2
     234    if (!gdk_event_get_scroll_direction(event, &direction)) {
     235        double deltaX, deltaY;
     236        if (gdk_event_get_scroll_deltas(event, &deltaX, &deltaY))
    227237            wheelTicks = FloatSize(-deltaX, -deltaY);
     238    }
     239#else
     240    direction = event->scroll.direction;
     241#endif
     242
     243    if (wheelTicks.isZero()) {
     244        switch (direction) {
     245        case GDK_SCROLL_UP:
     246            wheelTicks = FloatSize(0, 1);
     247            break;
     248        case GDK_SCROLL_DOWN:
     249            wheelTicks = FloatSize(0, -1);
     250            break;
     251        case GDK_SCROLL_LEFT:
     252            wheelTicks = FloatSize(1, 0);
     253            break;
     254        case GDK_SCROLL_RIGHT:
     255            wheelTicks = FloatSize(-1, 0);
     256            break;
     257        default:
     258            ASSERT_NOT_REACHED();
    228259        }
    229         break;
    230 #endif
    231     default:
    232         ASSERT_NOT_REACHED();
    233260    }
    234261
     
    252279WebKeyboardEvent WebEventFactory::createWebKeyboardEvent(const GdkEvent* event, const WebCore::CompositionResults& compositionResults, Vector<String>&& commands)
    253280{
     281    guint keyval;
     282    guint16 keycode;
     283#ifndef GTK_API_VERSION_2
     284    gdk_event_get_keyval(event, &keyval);
     285    gdk_event_get_keycode(event, &keycode);
     286#else
     287    keyval = event->keyval;
     288    keycode = event->hardware_keycode;
     289#endif
     290#if GTK_CHECK_VERSION(3, 10, 0)
     291    GdkEventType type = gdk_event_get_event_type(event);
     292#else
     293    GdkEventType type = event->type;
     294#endif
     295
    254296    return WebKeyboardEvent(
    255         event->type == GDK_KEY_RELEASE ? WebEvent::KeyUp : WebEvent::KeyDown,
    256         compositionResults.simpleString.length() ? compositionResults.simpleString : PlatformKeyboardEvent::singleCharacterString(event->key.keyval),
    257         PlatformKeyboardEvent::keyValueForGdkKeyCode(event->key.keyval),
    258         PlatformKeyboardEvent::keyCodeForHardwareKeyCode(event->key.hardware_keycode),
    259         PlatformKeyboardEvent::keyIdentifierForGdkKeyCode(event->key.keyval),
    260         PlatformKeyboardEvent::windowsKeyCodeForGdkKeyCode(event->key.keyval),
    261         static_cast<int>(event->key.keyval),
     297        type == GDK_KEY_RELEASE ? WebEvent::KeyUp : WebEvent::KeyDown,
     298        compositionResults.simpleString.length() ? compositionResults.simpleString : PlatformKeyboardEvent::singleCharacterString(keyval),
     299        PlatformKeyboardEvent::keyValueForGdkKeyCode(keyval),
     300        PlatformKeyboardEvent::keyCodeForHardwareKeyCode(keycode),
     301        PlatformKeyboardEvent::keyIdentifierForGdkKeyCode(keyval),
     302        PlatformKeyboardEvent::windowsKeyCodeForGdkKeyCode(keyval),
     303        static_cast<int>(keyval),
    262304        compositionResults.compositionUpdated(),
    263305        WTFMove(commands),
    264         isGdkKeyCodeFromKeyPad(event->key.keyval),
     306        isGdkKeyCodeFromKeyPad(keyval),
    265307        modifiersForEvent(event),
    266308        wallTimeForEvent(event));
     
    272314#ifndef GTK_API_VERSION_2
    273315    WebEvent::Type type = WebEvent::NoType;
    274     switch (event->type) {
     316#if GTK_CHECK_VERSION(3, 10, 0)
     317    GdkEventType eventType = gdk_event_get_event_type(event);
     318#else
     319    GdkEventType eventType = event->type;
     320#endif
     321    switch (eventType) {
    275322    case GDK_TOUCH_BEGIN:
    276323        type = WebEvent::TouchStart;
  • trunk/Source/WebKit/UIProcess/API/gtk/WebKitEmojiChooser.cpp

    r246494 r246496  
    9393static void emojiHovered(GtkWidget* widget, GdkEvent* event)
    9494{
    95     if (event->type == GDK_ENTER_NOTIFY)
     95    if (gdk_event_get_event_type(event) == GDK_ENTER_NOTIFY)
    9696        gtk_widget_set_state_flags(widget, GTK_STATE_FLAG_PRELIGHT, FALSE);
    9797    else
  • trunk/Source/WebKit/UIProcess/API/gtk/WebKitScriptDialogImpl.cpp

    r246494 r246496  
    4747static gboolean webkitScriptDialogImplKeyPressEvent(GtkWidget* widget, GdkEventKey* keyEvent)
    4848{
    49     if (keyEvent->keyval == GDK_KEY_Escape) {
     49    guint keyval;
     50    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(keyEvent), &keyval);
     51    if (keyval == GDK_KEY_Escape) {
    5052        webkitScriptDialogImplClose(WEBKIT_SCRIPT_DIALOG_IMPL(widget));
    5153        return GDK_EVENT_STOP;
  • trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebViewBase.cpp

    r246494 r246496  
    119119        }
    120120
    121         if ((event->type == GDK_2BUTTON_PRESS || event->type == GDK_3BUTTON_PRESS)
    122             || ((std::abs(event->button.x - previousClickPoint.x()) < doubleClickDistance)
    123                 && (std::abs(event->button.y - previousClickPoint.y()) < doubleClickDistance)
     121        GdkEventType type;
     122        guint button;
     123        double x, y;
     124        gdk_event_get_coords(event, &x, &y);
     125        gdk_event_get_button(event, &button);
     126#if GTK_CHECK_VERSION(3, 10, 0)
     127        type = gdk_event_get_event_type(event);
     128#else
     129        type = event->type;
     130#endif
     131        if ((type == GDK_2BUTTON_PRESS || type == GDK_3BUTTON_PRESS)
     132            || ((std::abs(x - previousClickPoint.x()) < doubleClickDistance)
     133                && (std::abs(y - previousClickPoint.y()) < doubleClickDistance)
    124134                && (eventTime - previousClickTime < static_cast<unsigned>(doubleClickTime))
    125                 && (event->button.button == previousClickButton)))
     135                && (button == previousClickButton)))
    126136            currentClickCount++;
    127137        else
    128138            currentClickCount = 1;
    129139
    130         double x, y;
    131         gdk_event_get_coords(event, &x, &y);
    132140        previousClickPoint = IntPoint(x, y);
    133         previousClickButton = event->button.button;
     141        previousClickButton = button;
    134142        previousClickTime = eventTime;
    135143
     
    740748    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    741749
     750    GdkModifierType state;
     751    guint keyval;
     752    gdk_event_get_state(reinterpret_cast<GdkEvent*>(keyEvent), &state);
     753    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(keyEvent), &keyval);
     754
    742755#if ENABLE(DEVELOPER_MODE) && OS(LINUX)
    743     if ((keyEvent->state & GDK_CONTROL_MASK) && (keyEvent->state & GDK_SHIFT_MASK) && keyEvent->keyval == GDK_KEY_G) {
     756    if ((state & GDK_CONTROL_MASK) && (state & GDK_SHIFT_MASK) && keyval == GDK_KEY_G) {
    744757        auto& preferences = priv->pageProxy->preferences();
    745758        preferences.setResourceUsageOverlayVisible(!preferences.resourceUsageOverlayVisible());
     
    754767#if ENABLE(FULLSCREEN_API)
    755768    if (priv->fullScreenModeActive) {
    756         switch (keyEvent->keyval) {
     769        switch (keyval) {
    757770        case GDK_KEY_Escape:
    758771        case GDK_KEY_f:
     
    810823
    811824    int clickCount = 0;
    812 
    813     switch (event->type) {
     825#if GTK_CHECK_VERSION(3, 10, 0)
     826    GdkEventType eventType = gdk_event_get_event_type(event);
     827#else
     828    GdkEventType eventType = event->type;
     829#endif
     830    switch (eventType) {
    814831    case GDK_BUTTON_PRESS:
    815832    case GDK_2BUTTON_PRESS:
     
    826843        priv->inputMethodFilter.notifyMouseButtonPress();
    827844
     845        guint button;
     846        gdk_event_get_button(event, &button);
    828847        // If it's a right click event save it as a possible context menu event.
    829         if (event->button.button == GDK_BUTTON_SECONDARY)
     848        if (button == GDK_BUTTON_SECONDARY)
    830849            priv->contextMenuEvent.reset(gdk_event_copy(event));
    831850
     
    976995    GtkAllocation allocation;
    977996    gtk_widget_get_allocation(widget, &allocation);
     997    double xEvent, yEvent;
     998    gdk_event_get_coords(reinterpret_cast<GdkEvent*>(crossingEvent), &xEvent, &yEvent);
    978999    double width = allocation.width;
    9791000    double height = allocation.height;
    980     double x = crossingEvent->x;
    981     double y = crossingEvent->y;
     1001    double x = xEvent;
     1002    double y = yEvent;
    9821003    if (x < 0 && x > -1)
    9831004        x = -1;
     
    9911012    GdkEvent* event = reinterpret_cast<GdkEvent*>(crossingEvent);
    9921013    GUniquePtr<GdkEvent> copiedEvent;
    993     if (x != crossingEvent->x || y != crossingEvent->y) {
     1014    if (x != xEvent || y != yEvent) {
    9941015        copiedEvent.reset(gdk_event_copy(event));
    9951016        copiedEvent->crossing.x = x;
     
    10371058{
    10381059    WebKitWebViewBasePrivate* priv = webViewBase->priv;
    1039     bool touchEnd = (event->type == GDK_TOUCH_END) || (event->type == GDK_TOUCH_CANCEL);
     1060#if GTK_CHECK_VERSION(3, 10, 0)
     1061    GdkEventType type = gdk_event_get_event_type(event);
     1062#else
     1063    GdkEventType type = event->type;
     1064#endif
     1065    bool touchEnd = (type == GDK_TOUCH_END) || (type == GDK_TOUCH_CANCEL);
    10401066    touchPoints.reserveInitialCapacity(touchEnd ? priv->touchEvents.size() + 1 : priv->touchEvents.size());
    10411067
     
    10591085    uint32_t sequence = GPOINTER_TO_UINT(gdk_event_get_event_sequence(touchEvent));
    10601086
    1061     switch (touchEvent->type) {
     1087#if GTK_CHECK_VERSION(3, 10, 0)
     1088    GdkEventType type = gdk_event_get_event_type(touchEvent);
     1089#else
     1090    GdkEventType type = touchEvent->type
     1091#endif
     1092    switch (type) {
    10621093    case GDK_TOUCH_BEGIN: {
    10631094        ASSERT(!priv->touchEvents.contains(sequence));
     
    11781209    void swipe(GdkEventTouch* event, const FloatPoint& velocity) final
    11791210    {
    1180         GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, FloatPoint::narrowPrecision(event->x, event->y), velocity, true);
     1211        double x, y;
     1212        gdk_event_get_coords(reinterpret_cast<GdkEvent*>(event), &x, &y);
     1213        GUniquePtr<GdkEvent> scrollEvent = createScrollEvent(event, FloatPoint::narrowPrecision(x, y), velocity, true);
    11811214        webkitWebViewBaseHandleWheelEvent(m_webView, scrollEvent.get(), WebWheelEvent::Phase::PhaseNone, WebWheelEvent::Phase::PhaseBegan);
    11821215    }
     
    12791312{
    12801313#if HAVE(GTK_GESTURES)
     1314#if GTK_CHECK_VERSION(3, 10, 0)
     1315    if (gdk_event_get_event_type(event) == GDK_TOUCHPAD_PINCH)
     1316#else
    12811317    if (event->type == GDK_TOUCHPAD_PINCH)
     1318#endif // GTK_CHECK_VERSION(3, 10, 0)
    12821319        webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(widget)).handleEvent(event);
    1283 #endif
     1320#endif // HAVE(GTK_GESTURES)
    12841321
    12851322    return GDK_EVENT_PROPAGATE;
  • trunk/Source/WebKit/UIProcess/gtk/GestureController.cpp

    r246494 r246496  
    5454    m_zoomGesture.handleEvent(event);
    5555    m_longpressGesture.handleEvent(event);
     56#if GTK_CHECK_VERSION(3, 10, 0)
     57    touchEnd = (gdk_event_get_event_type(event) == GDK_TOUCH_END) || (gdk_event_get_event_type(event) == GDK_TOUCH_CANCEL);
     58#else
    5659    touchEnd = (event->type == GDK_TOUCH_END) || (event->type == GDK_TOUCH_CANCEL);
     60#endif
    5761    return touchEnd ? wasProcessingGestures : isProcessingGestures();
    5862}
  • trunk/Source/WebKit/UIProcess/gtk/InputMethodFilter.cpp

    r246494 r246496  
    199199    bool justSentFakeKeyUp = m_justSentFakeKeyUp;
    200200    m_justSentFakeKeyUp = false;
    201     if (justSentFakeKeyUp && event->type == GDK_KEY_RELEASE)
     201    guint keyval;
     202    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     203#if GTK_CHECK_VERSION(3, 10, 0)
     204    GdkEventType type = gdk_event_get_event_type(reinterpret_cast<GdkEvent*>(event));
     205#else
     206    GdkEventType type = event->type;
     207#endif
     208    if (justSentFakeKeyUp && type == GDK_KEY_RELEASE)
    202209        return;
    203210
     
    211218    }
    212219
    213     if (filtered && event->type == GDK_KEY_PRESS) {
     220    if (filtered && type == GDK_KEY_PRESS) {
    214221        if (!m_preeditChanged && m_confirmedComposition.isNull()) {
    215222            m_composingTextCurrently = true;
    216             m_lastFilteredKeyPressCodeWithNoResults = event->keyval;
     223            m_lastFilteredKeyPressCodeWithNoResults = keyval;
    217224            return;
    218225        }
     
    228235    // If we previously filtered a key press event and it yielded no results. Suppress
    229236    // the corresponding key release event to avoid confusing the web content.
    230     if (event->type == GDK_KEY_RELEASE && lastFilteredKeyPressCodeWithNoResults == event->keyval)
     237    if (type == GDK_KEY_RELEASE && lastFilteredKeyPressCodeWithNoResults == keyval)
    231238        return;
    232239
     
    444451void InputMethodFilter::logHandleKeyboardEventForTesting(GdkEventKey* event, const String& eventString, EventFakedForComposition faked)
    445452{
     453    guint keyval;
     454    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     455#if GTK_CHECK_VERSION(3, 10, 0)
     456    const char* eventType = gdk_event_get_event_type(reinterpret_cast<GdkEvent*>(event)) == GDK_KEY_RELEASE ? "release" : "press";
     457#else
    446458    const char* eventType = event->type == GDK_KEY_RELEASE ? "release" : "press";
     459#endif
    447460    const char* fakedString = faked == EventFaked ? " (faked)" : "";
    448461    if (!eventString.isNull())
    449         m_events.append(makeString("sendSimpleKeyEvent type=", eventType, " keycode=", hex(event->keyval), " text='", eventString, '\'', fakedString));
     462        m_events.append(makeString("sendSimpleKeyEvent type=", eventType, " keycode=", hex(keyval), " text='", eventString, '\'', fakedString));
    450463    else
    451         m_events.append(makeString("sendSimpleKeyEvent type=", eventType, " keycode=", hex(event->keyval), fakedString));
     464        m_events.append(makeString("sendSimpleKeyEvent type=", eventType, " keycode=", hex(keyval), fakedString));
    452465}
    453466
    454467void InputMethodFilter::logHandleKeyboardEventWithCompositionResultsForTesting(GdkEventKey* event, ResultsToSend resultsToSend, EventFakedForComposition faked)
    455468{
     469    guint keyval;
     470    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     471#if GTK_CHECK_VERSION(3, 10, 0)
     472    const char* eventType = gdk_event_get_event_type(reinterpret_cast<GdkEvent*>(event)) == GDK_KEY_RELEASE ? "release" : "press";
     473#else
    456474    const char* eventType = event->type == GDK_KEY_RELEASE ? "release" : "press";
     475#endif
    457476    const char* fakedString = faked == EventFaked ? " (faked)" : "";
    458     m_events.append(makeString("sendKeyEventWithCompositionResults type=", eventType, " keycode=", hex(event->keyval), fakedString));
     477    m_events.append(makeString("sendKeyEventWithCompositionResults type=", eventType, " keycode=", hex(keyval), fakedString));
    459478
    460479    if (resultsToSend & Composition && !m_confirmedComposition.isNull())
  • trunk/Source/WebKit/UIProcess/gtk/KeyBindingTranslator.cpp

    r246494 r246496  
    206206    ASSERT(m_pendingEditorCommands.isEmpty());
    207207
     208    guint keyval;
     209    GdkModifierType state;
     210    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     211    gdk_event_get_state(reinterpret_cast<GdkEvent*>(event), &state);
     212
    208213    gtk_bindings_activate_event(G_OBJECT(m_nativeWidget.get()), event);
    209214    if (!m_pendingEditorCommands.isEmpty())
     
    211216
    212217    // Special-case enter keys for we want them to work regardless of modifier.
    213     if ((event->keyval == GDK_KEY_Return || event->keyval == GDK_KEY_KP_Enter || event->keyval == GDK_KEY_ISO_Enter))
     218    if ((keyval == GDK_KEY_Return || keyval == GDK_KEY_KP_Enter || keyval == GDK_KEY_ISO_Enter))
    214219        return { "InsertNewLine" };
    215220
    216221    // For keypress events, we want charCode(), but keyCode() does that.
    217     unsigned mapKey = event->state << 16 | event->keyval;
     222    unsigned mapKey = state << 16 | keyval;
    218223    if (!mapKey)
    219224        return { };
  • trunk/Source/WebKit/UIProcess/gtk/ViewGestureControllerGtk.cpp

    r246494 r246496  
    5656{
    5757#if GTK_CHECK_VERSION(3, 20, 0)
    58     return event->is_stop;
     58    return gdk_event_is_scroll_stop_event(reinterpret_cast<GdkEvent*>(event));
    5959#else
    6060    return !event->delta_x && !event->delta_y;
     
    8787    // FIXME: Should it maybe be allowed on mice/trackpoints as well? The GDK_SCROLL_SMOOTH
    8888    // requirement already filters out most mice, and it works pretty well on a trackpoint
    89     return event->direction == GDK_SCROLL_SMOOTH && (source == GDK_SOURCE_TOUCHPAD || source == GDK_SOURCE_TOUCHSCREEN);
     89    return gdk_event_get_scroll_deltas(reinterpret_cast<GdkEvent*>(event), nullptr, nullptr) && (source == GDK_SOURCE_TOUCHPAD || source == GDK_SOURCE_TOUCHSCREEN);
    9090}
    9191
     
    101101{
    102102    double multiplier = isTouchEvent(event) ? Scrollbar::pixelsPerLineStep() : gtkScrollDeltaMultiplier;
     103    double xDelta, yDelta;
     104    gdk_event_get_scroll_deltas(reinterpret_cast<GdkEvent*>(event), &xDelta, &yDelta);
    103105
    104106    // GdkEventScroll deltas are inverted compared to NSEvent, so invert them again
    105     return -FloatSize(event->delta_x, event->delta_y) * multiplier;
     107    return -FloatSize(xDelta, yDelta) * multiplier;
    106108}
    107109
     
    184186    }
    185187
    186     double deltaX = -event->delta_x;
     188    uint32_t eventTime = gdk_event_get_time(reinterpret_cast<GdkEvent*>(event));
     189    double eventDeltaX;
     190    gdk_event_get_scroll_deltas(reinterpret_cast<GdkEvent*>(event), &eventDeltaX, nullptr);
     191
     192    double deltaX = -eventDeltaX;
    187193    if (isTouchEvent(event))
    188194        deltaX *= (double) Scrollbar::pixelsPerLineStep() / m_webPageProxy.viewSize().width();
     
    190196        deltaX *= gtkScrollDeltaMultiplier / swipeTouchpadBaseWidth;
    191197
    192     Seconds time = Seconds::fromMilliseconds(event->time);
     198    Seconds time = Seconds::fromMilliseconds(eventTime);
    193199    if (time != m_prevTime)
    194200        m_velocity = deltaX / (time - m_prevTime).milliseconds();
  • trunk/Source/WebKit/UIProcess/gtk/WebPopupMenuProxyGtk.cpp

    r246494 r246496  
    9696gboolean WebPopupMenuProxyGtk::treeViewButtonReleaseEventCallback(GtkWidget* treeView, GdkEventButton* event, WebPopupMenuProxyGtk* popupMenu)
    9797{
    98     if (event->button != GDK_BUTTON_PRIMARY)
     98    guint button;
     99    gdk_event_get_button(reinterpret_cast<GdkEvent*>(event), &button);
     100    if (button != GDK_BUTTON_PRIMARY)
    99101        return FALSE;
    100102
     103    double x, y;
     104    gdk_event_get_coords(reinterpret_cast<GdkEvent*>(event), &x, &y);
    101105    GUniqueOutPtr<GtkTreePath> path;
    102     if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeView), event->x, event->y, &path.outPtr(), nullptr, nullptr, nullptr))
     106    if (!gtk_tree_view_get_path_at_pos(GTK_TREE_VIEW(treeView), x, y, &path.outPtr(), nullptr, nullptr, nullptr))
    103107        return FALSE;
    104108
     
    120124        return FALSE;
    121125
    122     if (event->keyval == GDK_KEY_Escape) {
     126    guint keyval;
     127    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     128    if (keyval == GDK_KEY_Escape) {
    123129        popupMenu->hidePopupMenu();
    124130        return TRUE;
     
    371377Optional<unsigned> WebPopupMenuProxyGtk::typeAheadFindIndex(GdkEventKey* event)
    372378{
    373     gunichar keychar = gdk_keyval_to_unicode(event->keyval);
     379    guint keyval;
     380    gdk_event_get_keyval(reinterpret_cast<GdkEvent*>(event), &keyval);
     381    gunichar keychar = gdk_keyval_to_unicode(keyval);
    374382    if (!g_unichar_isprint(keychar))
    375383        return WTF::nullopt;
    376384
    377     if (event->time < m_previousKeyEventTime)
     385    uint32_t time = gdk_event_get_time(reinterpret_cast<GdkEvent*>(event));
     386    if (time < m_previousKeyEventTime)
    378387        return WTF::nullopt;
    379388
    380389    static const uint32_t typeaheadTimeoutMs = 1000;
    381     if (event->time - m_previousKeyEventTime > typeaheadTimeoutMs) {
     390    if (time - m_previousKeyEventTime > typeaheadTimeoutMs) {
    382391        if (m_currentSearchString)
    383392            g_string_truncate(m_currentSearchString, 0);
    384393    }
    385     m_previousKeyEventTime = event->time;
     394    m_previousKeyEventTime = time;
    386395
    387396    if (!m_currentSearchString)
Note: See TracChangeset for help on using the changeset viewer.