void PageClientImpl::doneWithTouchEvent(const NativeWebTouchEvent& event, bool wasEventHandled) { if (wasEventHandled) return; #if HAVE(GTK_GESTURES) GestureController& gestureController = webkitWebViewBaseGestureController(WEBKIT_WEB_VIEW_BASE(m_viewWidget)); if (gestureController.handleEvent(event.nativeEvent())) return; #endif // Emulate pointer events if unhandled. const GdkEvent* touchEvent = event.nativeEvent(); if (!touchEvent->touch.emulating_pointer) return; GUniquePtr<GdkEvent> pointerEvent; if (touchEvent->type == GDK_TOUCH_UPDATE) { pointerEvent.reset(gdk_event_new(GDK_MOTION_NOTIFY)); pointerEvent->motion.time = touchEvent->touch.time; pointerEvent->motion.x = touchEvent->touch.x; pointerEvent->motion.y = touchEvent->touch.y; pointerEvent->motion.x_root = touchEvent->touch.x_root; pointerEvent->motion.y_root = touchEvent->touch.y_root; pointerEvent->motion.state = touchEvent->touch.state | GDK_BUTTON1_MASK; } else { switch (touchEvent->type) { case GDK_TOUCH_END: pointerEvent.reset(gdk_event_new(GDK_BUTTON_RELEASE)); pointerEvent->button.state = touchEvent->touch.state | GDK_BUTTON1_MASK; break; case GDK_TOUCH_BEGIN: pointerEvent.reset(gdk_event_new(GDK_BUTTON_PRESS)); break; default: ASSERT_NOT_REACHED(); } pointerEvent->button.button = 1; pointerEvent->button.time = touchEvent->touch.time; pointerEvent->button.x = touchEvent->touch.x; pointerEvent->button.y = touchEvent->touch.y; pointerEvent->button.x_root = touchEvent->touch.x_root; pointerEvent->button.y_root = touchEvent->touch.y_root; } gdk_event_set_device(pointerEvent.get(), gdk_event_get_device(touchEvent)); gdk_event_set_source_device(pointerEvent.get(), gdk_event_get_source_device(touchEvent)); pointerEvent->any.window = GDK_WINDOW(g_object_ref(touchEvent->any.window)); pointerEvent->any.send_event = TRUE; gtk_widget_event(m_viewWidget, pointerEvent.get()); }
static void send_event (GdkWindow *window, GdkDevice *device, GdkEvent *event) { GdkDisplay *display; GList *node; gdk_event_set_device (event, device); gdk_event_set_source_device (event, device); gdk_event_set_screen (event, gdk_display_get_screen (gdk_window_get_display (window), 0)); event->any.window = g_object_ref (window); display = gdk_window_get_display (window); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, _gdk_display_get_next_serial (display)); }
gboolean gdk_input_other_event (GdkDisplay *display, GdkEvent *event, MSG *msg, GdkWindow *window) { GdkDeviceManagerWin32 *device_manager; GdkDeviceWintab *source_device = NULL; GdkDeviceGrabInfo *last_grab; GdkEventMask masktest; guint key_state; POINT pt; PACKET packet; gint root_x, root_y; gint num_axes; gint x, y; guint translated_buttons, button_diff, button_mask; /* Translation from tablet button state to GDK button state for * buttons 1-3 - swap button 2 and 3. */ static guint button_map[8] = {0, 1, 4, 5, 2, 3, 6, 7}; if (event->any.window != wintab_window) { g_warning ("gdk_input_other_event: not wintab_window?"); return FALSE; } G_GNUC_BEGIN_IGNORE_DEPRECATIONS; device_manager = GDK_DEVICE_MANAGER_WIN32 (gdk_display_get_device_manager (display)); G_GNUC_END_IGNORE_DEPRECATIONS; window = gdk_device_get_window_at_position (device_manager->core_pointer, &x, &y); if (window == NULL) window = gdk_get_default_root_window (); g_object_ref (window); GDK_NOTE (EVENTS_OR_INPUT, g_print ("gdk_input_other_event: window=%p %+d%+d\n", GDK_WINDOW_HWND (window), x, y)); if (msg->message == WT_PACKET || msg->message == WT_CSRCHANGE) { if (!(*p_WTPacket) ((HCTX) msg->lParam, msg->wParam, &packet)) return FALSE; } switch (msg->message) { case WT_PACKET: /* Don't produce any button or motion events while a window is being * moved or resized, see bug #151090. */ if (_modal_operation_in_progress) { GDK_NOTE (EVENTS_OR_INPUT, g_print ("... ignored when moving/sizing\n")); return FALSE; } if ((source_device = gdk_device_manager_find_wintab_device (device_manager, (HCTX) msg->lParam, packet.pkCursor)) == NULL) return FALSE; if (gdk_device_get_mode (GDK_DEVICE (source_device)) == GDK_MODE_DISABLED) return FALSE; last_grab = _gdk_display_get_last_device_grab (display, GDK_DEVICE (source_device)); if (last_grab && last_grab->window) { g_object_unref (window); window = g_object_ref (last_grab->window); } if (window == gdk_get_default_root_window ()) { GDK_NOTE (EVENTS_OR_INPUT, g_print ("... is root\n")); return FALSE; } num_axes = 0; if (source_device->pktdata & PK_X) source_device->last_axis_data[num_axes++] = packet.pkX; if (source_device->pktdata & PK_Y) source_device->last_axis_data[num_axes++] = packet.pkY; if (source_device->pktdata & PK_NORMAL_PRESSURE) source_device->last_axis_data[num_axes++] = packet.pkNormalPressure; if (source_device->pktdata & PK_ORIENTATION) { decode_tilt (source_device->last_axis_data + num_axes, source_device->orientation_axes, &packet); num_axes += 2; } translated_buttons = button_map[packet.pkButtons & 0x07] | (packet.pkButtons & ~0x07); if (translated_buttons != source_device->button_state) { /* At least one button has changed state so produce a button event * If more than one button has changed state (unlikely), * just care about the first and act on the next the next time * we get a packet */ button_diff = translated_buttons ^ source_device->button_state; /* Gdk buttons are numbered 1.. */ event->button.button = 1; for (button_mask = 1; button_mask != 0x80000000; button_mask <<= 1, event->button.button++) { if (button_diff & button_mask) { /* Found a button that has changed state */ break; } } if (!(translated_buttons & button_mask)) { event->any.type = GDK_BUTTON_RELEASE; masktest = GDK_BUTTON_RELEASE_MASK; } else { event->any.type = GDK_BUTTON_PRESS; masktest = GDK_BUTTON_PRESS_MASK; } source_device->button_state ^= button_mask; } else { event->any.type = GDK_MOTION_NOTIFY; masktest = GDK_POINTER_MOTION_MASK; if (source_device->button_state & (1 << 0)) masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK; if (source_device->button_state & (1 << 1)) masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON2_MOTION_MASK; if (source_device->button_state & (1 << 2)) masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON3_MOTION_MASK; } /* Now we can check if the window wants the event, and * propagate if necessary. */ while ((gdk_window_get_device_events (window, GDK_DEVICE (source_device)) & masktest) == 0 && (gdk_device_get_device_type (GDK_DEVICE (source_device)) == GDK_DEVICE_TYPE_SLAVE && (gdk_window_get_events (window) & masktest) == 0)) { GDK_NOTE (EVENTS_OR_INPUT, g_print ("... not selected\n")); if (window->parent == gdk_get_default_root_window () || window->parent == NULL) return FALSE; pt.x = x; pt.y = y; ClientToScreen (GDK_WINDOW_HWND (window), &pt); g_object_unref (window); window = window->parent; g_object_ref (window); ScreenToClient (GDK_WINDOW_HWND (window), &pt); x = pt.x; y = pt.y; GDK_NOTE (EVENTS_OR_INPUT, g_print ("... propagating to %p %+d%+d\n", GDK_WINDOW_HWND (window), x, y)); } event->any.window = window; key_state = get_modifier_key_state (); if (event->any.type == GDK_BUTTON_PRESS || event->any.type == GDK_BUTTON_RELEASE) { event->button.time = _gdk_win32_get_next_tick (msg->time); if (source_device->sends_core) gdk_event_set_device (event, device_manager->core_pointer); gdk_event_set_source_device (event, GDK_DEVICE (source_device)); gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer)); event->button.axes = g_new (gdouble, num_axes); gdk_window_get_origin (window, &root_x, &root_y); _gdk_device_wintab_translate_axes (source_device, window, event->button.axes, &event->button.x, &event->button.y); event->button.x_root = event->button.x + root_x; event->button.y_root = event->button.y + root_y; event->button.state = key_state | ((source_device->button_state << 8) & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | GDK_BUTTON5_MASK)); GDK_NOTE (EVENTS_OR_INPUT, g_print ("WINTAB button %s:%d %g,%g\n", (event->button.type == GDK_BUTTON_PRESS ? "press" : "release"), event->button.button, event->button.x, event->button.y)); } else { event->motion.time = _gdk_win32_get_next_tick (msg->time); event->motion.is_hint = FALSE; gdk_event_set_device (event, device_manager->core_pointer); gdk_event_set_source_device (event, GDK_DEVICE (source_device)); gdk_event_set_seat (event, gdk_device_get_seat (device_manager->core_pointer)); event->motion.axes = g_new (gdouble, num_axes); gdk_window_get_origin (window, &root_x, &root_y); _gdk_device_wintab_translate_axes (source_device, window, event->motion.axes, &event->motion.x, &event->motion.y); event->motion.x_root = event->motion.x + root_x; event->motion.y_root = event->motion.y + root_y; event->motion.state = key_state | ((source_device->button_state << 8) & (GDK_BUTTON1_MASK | GDK_BUTTON2_MASK | GDK_BUTTON3_MASK | GDK_BUTTON4_MASK | GDK_BUTTON5_MASK)); GDK_NOTE (EVENTS_OR_INPUT, g_print ("WINTAB motion: %g,%g\n", event->motion.x, event->motion.y)); } return TRUE; case WT_CSRCHANGE: if ((source_device = gdk_device_manager_find_wintab_device (device_manager, (HCTX) msg->lParam, packet.pkCursor)) == NULL) return FALSE; if (gdk_device_get_mode (GDK_DEVICE (source_device)) == GDK_MODE_DISABLED) return FALSE; if (source_device->sends_core) { _gdk_device_virtual_set_active (device_manager->core_pointer, GDK_DEVICE (source_device)); _gdk_input_ignore_core = TRUE; } return FALSE; case WT_PROXIMITY: if (LOWORD (msg->lParam) == 0) { _gdk_input_ignore_core = FALSE; _gdk_device_virtual_set_active (device_manager->core_pointer, device_manager->system_pointer); } return FALSE; } return FALSE; }
void _gdk_broadway_events_got_input (BroadwayInputMsg *message) { GdkDisplay *display = gdk_display_get_default (); GdkBroadwayDisplay *display_broadway = GDK_BROADWAY_DISPLAY (display); GdkBroadwayDeviceManager *device_manager; GdkScreen *screen; GdkWindow *window; GdkEvent *event = NULL; GList *node; device_manager = GDK_BROADWAY_DEVICE_MANAGER (gdk_display_get_device_manager (display)); switch (message->base.type) { case BROADWAY_EVENT_ENTER: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id)); if (window) { event = gdk_event_new (GDK_ENTER_NOTIFY); event->crossing.window = g_object_ref (window); event->crossing.time = message->base.time; event->crossing.x = message->pointer.win_x; event->crossing.y = message->pointer.win_y; event->crossing.x_root = message->pointer.root_x; event->crossing.y_root = message->pointer.root_y; event->crossing.state = message->pointer.state; event->crossing.mode = message->crossing.mode; event->crossing.detail = GDK_NOTIFY_ANCESTOR; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_LEAVE: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id)); if (window) { event = gdk_event_new (GDK_LEAVE_NOTIFY); event->crossing.window = g_object_ref (window); event->crossing.time = message->base.time; event->crossing.x = message->pointer.win_x; event->crossing.y = message->pointer.win_y; event->crossing.x_root = message->pointer.root_x; event->crossing.y_root = message->pointer.root_y; event->crossing.state = message->pointer.state; event->crossing.mode = message->crossing.mode; event->crossing.detail = GDK_NOTIFY_ANCESTOR; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_POINTER_MOVE: if (_gdk_broadway_moveresize_handle_event (display, message)) break; window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id)); if (window) { event = gdk_event_new (GDK_MOTION_NOTIFY); event->motion.window = g_object_ref (window); event->motion.time = message->base.time; event->motion.x = message->pointer.win_x; event->motion.y = message->pointer.win_y; event->motion.x_root = message->pointer.root_x; event->motion.y_root = message->pointer.root_y; event->motion.state = message->pointer.state; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_BUTTON_PRESS: case BROADWAY_EVENT_BUTTON_RELEASE: if (message->base.type != 'b' && _gdk_broadway_moveresize_handle_event (display, message)) break; window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id)); if (window) { event = gdk_event_new (message->base.type == 'b' ? GDK_BUTTON_PRESS : GDK_BUTTON_RELEASE); event->button.window = g_object_ref (window); event->button.time = message->base.time; event->button.x = message->pointer.win_x; event->button.y = message->pointer.win_y; event->button.x_root = message->pointer.root_x; event->button.y_root = message->pointer.root_y; event->button.button = message->button.button; event->button.state = message->pointer.state; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_SCROLL: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id)); if (window) { event = gdk_event_new (GDK_SCROLL); event->scroll.window = g_object_ref (window); event->scroll.time = message->base.time; event->scroll.x = message->pointer.win_x; event->scroll.y = message->pointer.win_y; event->scroll.x_root = message->pointer.root_x; event->scroll.y_root = message->pointer.root_y; event->scroll.direction = message->scroll.dir == 0 ? GDK_SCROLL_UP : GDK_SCROLL_DOWN; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_TOUCH: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->touch.event_window_id)); if (window) { GdkEventType event_type = 0; switch (message->touch.touch_type) { case 0: event_type = GDK_TOUCH_BEGIN; break; case 1: event_type = GDK_TOUCH_UPDATE; break; case 2: event_type = GDK_TOUCH_END; break; default: g_printerr ("_gdk_broadway_events_got_input - Unknown touch type %d\n", message->touch.touch_type); } if (event_type != GDK_TOUCH_BEGIN && message->touch.is_emulated && _gdk_broadway_moveresize_handle_event (display, message)) break; event = gdk_event_new (event_type); event->touch.window = g_object_ref (window); event->touch.sequence = GUINT_TO_POINTER(message->touch.sequence_id); event->touch.emulating_pointer = message->touch.is_emulated; event->touch.time = message->base.time; event->touch.x = message->touch.win_x; event->touch.y = message->touch.win_y; event->touch.x_root = message->touch.root_x; event->touch.y_root = message->touch.root_y; event->touch.state = message->touch.state; gdk_event_set_device (event, device_manager->core_pointer); gdk_event_set_source_device (event, device_manager->touchscreen); if (message->touch.is_emulated) _gdk_event_set_pointer_emulated (event, TRUE); if (event_type == GDK_TOUCH_BEGIN || event_type == GDK_TOUCH_UPDATE) event->touch.state |= GDK_BUTTON1_MASK; node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_KEY_PRESS: case BROADWAY_EVENT_KEY_RELEASE: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->key.window_id)); if (window) { event = gdk_event_new (message->base.type == 'k' ? GDK_KEY_PRESS : GDK_KEY_RELEASE); event->key.window = g_object_ref (window); event->key.time = message->base.time; event->key.keyval = message->key.key; event->key.state = message->key.state; event->key.hardware_keycode = message->key.key; event->key.length = 0; gdk_event_set_device (event, device_manager->core_keyboard); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_GRAB_NOTIFY: case BROADWAY_EVENT_UNGRAB_NOTIFY: _gdk_display_device_grab_update (display, display->core_pointer, display->core_pointer, message->base.serial); break; case BROADWAY_EVENT_CONFIGURE_NOTIFY: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->configure_notify.id)); if (window) { window->x = message->configure_notify.x; window->y = message->configure_notify.y; event = gdk_event_new (GDK_CONFIGURE); event->configure.window = g_object_ref (window); event->configure.x = message->configure_notify.x; event->configure.y = message->configure_notify.y; event->configure.width = message->configure_notify.width; event->configure.height = message->configure_notify.height; node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); if (window->resize_count >= 1) { window->resize_count -= 1; if (window->resize_count == 0) _gdk_broadway_moveresize_configure_done (display, window); } } break; case BROADWAY_EVENT_DELETE_NOTIFY: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->delete_notify.id)); if (window) { event = gdk_event_new (GDK_DELETE); event->any.window = g_object_ref (window); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; case BROADWAY_EVENT_SCREEN_SIZE_CHANGED: screen = gdk_display_get_default_screen (display); window = gdk_screen_get_root_window (screen); window->width = message->screen_resize_notify.width; window->height = message->screen_resize_notify.height; _gdk_window_update_size (window); _gdk_broadway_screen_size_changed (screen, &message->screen_resize_notify); break; case BROADWAY_EVENT_FOCUS: window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->focus.old_id)); if (window) { event = gdk_event_new (GDK_FOCUS_CHANGE); event->focus_change.window = g_object_ref (window); event->focus_change.in = FALSE; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->focus.new_id)); if (window) { event = gdk_event_new (GDK_FOCUS_CHANGE); event->focus_change.window = g_object_ref (window); event->focus_change.in = TRUE; gdk_event_set_device (event, display->core_pointer); node = _gdk_event_queue_append (display, event); _gdk_windowing_got_event (display, node, event, message->base.serial); } break; default: g_printerr ("_gdk_broadway_events_got_input - Unknown input command %c\n", message->base.type); break; } }
/* We only care about focus events that indicate that _this_ * window (not a ancestor or child) got or lost the focus */ void _gdk_device_manager_core_handle_focus (GdkWindow *window, Window original, GdkDevice *device, GdkDevice *source_device, gboolean focus_in, int detail, int mode) { GdkToplevelX11 *toplevel; GdkX11Screen *x11_screen; gboolean had_focus; g_return_if_fail (GDK_IS_WINDOW (window)); g_return_if_fail (GDK_IS_DEVICE (device)); g_return_if_fail (source_device == NULL || GDK_IS_DEVICE (source_device)); GDK_NOTE (EVENTS, g_message ("focus out:\t\twindow: %ld, detail: %s, mode: %s", GDK_WINDOW_XID (window), notify_details[detail], notify_modes[mode])); toplevel = _gdk_x11_window_get_toplevel (window); if (!toplevel) return; if (toplevel->focus_window == original) return; had_focus = HAS_FOCUS (toplevel); x11_screen = GDK_X11_SCREEN (gdk_window_get_screen (window)); switch (detail) { case NotifyAncestor: case NotifyVirtual: /* When the focus moves from an ancestor of the window to * the window or a descendent of the window, *and* the * pointer is inside the window, then we were previously * receiving keystroke events in the has_pointer_focus * case and are now receiving them in the * has_focus_window case. */ if (toplevel->has_pointer && !x11_screen->wmspec_check_window && mode != NotifyGrab && #ifdef XINPUT_2 mode != XINotifyPassiveGrab && mode != XINotifyPassiveUngrab && #endif /* XINPUT_2 */ mode != NotifyUngrab) toplevel->has_pointer_focus = (focus_in) ? FALSE : TRUE; /* fall through */ case NotifyNonlinear: case NotifyNonlinearVirtual: if (mode != NotifyGrab && #ifdef XINPUT_2 mode != XINotifyPassiveGrab && mode != XINotifyPassiveUngrab && #endif /* XINPUT_2 */ mode != NotifyUngrab) toplevel->has_focus_window = (focus_in) ? TRUE : FALSE; /* We pretend that the focus moves to the grab * window, so we pay attention to NotifyGrab * NotifyUngrab, and ignore NotifyWhileGrabbed */ if (mode != NotifyWhileGrabbed) toplevel->has_focus = (focus_in) ? TRUE : FALSE; break; case NotifyPointer: /* The X server sends NotifyPointer/NotifyGrab, * but the pointer focus is ignored while a * grab is in effect */ if (!x11_screen->wmspec_check_window && mode != NotifyGrab && #ifdef XINPUT_2 mode != XINotifyPassiveGrab && mode != XINotifyPassiveUngrab && #endif /* XINPUT_2 */ mode != NotifyUngrab) toplevel->has_pointer_focus = (focus_in) ? TRUE : FALSE; break; case NotifyInferior: case NotifyPointerRoot: case NotifyDetailNone: default: break; } if (HAS_FOCUS (toplevel) != had_focus) { GdkEvent *event; event = gdk_event_new (GDK_FOCUS_CHANGE); event->focus_change.window = g_object_ref (window); event->focus_change.send_event = FALSE; event->focus_change.in = focus_in; gdk_event_set_device (event, device); if (source_device) gdk_event_set_source_device (event, source_device); gdk_event_put (event); gdk_event_free (event); } }