void EventSenderProxy::mouseScrollBy(int horizontal, int vertical)
{
GdkEvent* event = gdk_event_new(GDK_SCROLL);
event->scroll.x = m_position.x;
event->scroll.y = m_position.y;
event->scroll.time = GDK_CURRENT_TIME;
event->scroll.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView()));
g_object_ref(event->scroll.window);
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(event->scroll.window))));
// For more than one tick in a scroll, we need smooth scroll event
if ((horizontal && vertical) || horizontal > 1 || horizontal < -1 || vertical > 1 || vertical < -1) {
event->scroll.direction = GDK_SCROLL_SMOOTH;
event->scroll.delta_x = -horizontal;
event->scroll.delta_y = -vertical;
sendOrQueueEvent(event);
return;
}
if (horizontal < 0)
event->scroll.direction = GDK_SCROLL_RIGHT;
else if (horizontal > 0)
event->scroll.direction = GDK_SCROLL_LEFT;
else if (vertical < 0)
event->scroll.direction = GDK_SCROLL_DOWN;
else if (vertical > 0)
event->scroll.direction = GDK_SCROLL_UP;
else
g_assert_not_reached();
sendOrQueueEvent(event);
}
void WebViewTest::keyStroke(unsigned keyVal, unsigned keyModifiers)
{
g_assert(m_parentWindow);
GtkWidget* viewWidget = GTK_WIDGET(m_webView);
g_assert(gtk_widget_get_realized(viewWidget));
GOwnPtr<GdkEvent> event(gdk_event_new(GDK_KEY_PRESS));
event->key.keyval = keyVal;
event->key.time = GDK_CURRENT_TIME;
event->key.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->key.window);
gdk_event_set_device(event.get(), gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget))));
event->key.state = keyModifiers;
// When synthesizing an event, an invalid hardware_keycode value can cause it to be badly processed by GTK+.
GOwnPtr<GdkKeymapKey> keys;
int keysCount;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyVal, &keys.outPtr(), &keysCount))
event->key.hardware_keycode = keys.get()[0].keycode;
gtk_main_do_event(event.get());
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event.get());
}
static gboolean emitKeyStroke(WebKitWebView* webView)
{
GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS);
pressEvent->key.keyval = GDK_KEY_f;
GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(webView));
pressEvent->key.window = window;
g_object_ref(pressEvent->key.window);
#ifndef GTK_API_VERSION_2
GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(window));
gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(manager));
#endif
// When synthesizing an event, an invalid hardware_keycode value
// can cause it to be badly processed by Gtk+.
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), GDK_KEY_f, &keys, &n_keys)) {
pressEvent->key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
GdkEvent* releaseEvent = gdk_event_copy(pressEvent);
gtk_main_do_event(pressEvent);
gdk_event_free(pressEvent);
releaseEvent->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(releaseEvent);
gdk_event_free(releaseEvent);
return FALSE;
}
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
point_release (PointState *point,
guint button)
{
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
GdkEvent *ev;
if (point->widget == NULL)
return;
display = gtk_widget_get_display (point->widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
if (!point->widget)
return;
if (point == &mouse_state)
{
if ((point->state & (GDK_BUTTON1_MASK << (button - 1))) == 0)
return;
ev = gdk_event_new (GDK_BUTTON_RELEASE);
ev->any.window = g_object_ref (gtk_widget_get_window (point->widget));
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
ev->button.state = point->state;
point->state &= ~(GDK_BUTTON1_MASK << (button - 1));
}
else
{
ev = gdk_event_new (GDK_TOUCH_END);
ev->any.window = g_object_ref (gtk_widget_get_window (point->widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
ev->touch.sequence = EVENT_SEQUENCE (point);
ev->touch.state = point->state;
if (point == &touch_state[0])
ev->touch.emulating_pointer = TRUE;
}
gdk_event_set_device (ev, device);
gtk_main_do_event (ev);
gdk_event_free (ev);
}
GdkEventKey *
ide_gdk_synthesize_event_keyval (GdkWindow *window,
guint keyval)
{
GdkDisplay *display;
GdkDeviceManager *device_manager;
GdkDevice *client_pointer;
GdkEvent *ev;
GdkKeymapKey *keys = NULL;
gint n_keys = 0;
gchar str[8] = { 0 };
gunichar ch;
g_assert (window != NULL);
g_assert (GDK_IS_WINDOW (window));
ch = gdk_keyval_to_unicode (keyval);
g_unichar_to_utf8 (ch, str);
ev = gdk_event_new (GDK_KEY_PRESS);
ev->key.window = g_object_ref (window);
ev->key.send_event = TRUE;
ev->key.time = gtk_get_current_event_time ();
ev->key.state = 0;
ev->key.hardware_keycode = 0;
ev->key.group = 0;
ev->key.is_modifier = 0;
ev->key.keyval = keyval;
ev->key.string = g_strdup (str);
ev->key.length = strlen (str);
gdk_keymap_get_entries_for_keyval (gdk_keymap_get_default (),
ev->key.keyval,
&keys,
&n_keys);
if (n_keys > 0)
{
ev->key.hardware_keycode = keys [0].keycode;
ev->key.group = keys [0].group;
if (keys [0].level == 1)
ev->key.state |= GDK_SHIFT_MASK;
g_free (keys);
}
display = gdk_window_get_display (ev->any.window);
device_manager = gdk_display_get_device_manager (display);
client_pointer = gdk_device_manager_get_client_pointer (device_manager);
gdk_event_set_device (ev, gdk_device_get_associated_device (client_pointer));
return &ev->key;
}
static void
translate_key_event (GdkDisplay *display,
GdkX11DeviceManagerCore *device_manager,
GdkEvent *event,
XEvent *xevent)
{
GdkKeymap *keymap = gdk_keymap_get_for_display (display);
GdkModifierType consumed, state;
event->key.type = xevent->xany.type == KeyPress ? GDK_KEY_PRESS : GDK_KEY_RELEASE;
event->key.time = xevent->xkey.time;
gdk_event_set_device (event, device_manager->core_keyboard);
event->key.state = (GdkModifierType) xevent->xkey.state;
event->key.group = _gdk_x11_get_group_for_state (display, xevent->xkey.state);
event->key.hardware_keycode = xevent->xkey.keycode;
event->key.keyval = GDK_KEY_VoidSymbol;
gdk_keymap_translate_keyboard_state (keymap,
event->key.hardware_keycode,
event->key.state,
event->key.group,
&event->key.keyval,
NULL, NULL, &consumed);
state = event->key.state & ~consumed;
_gdk_x11_keymap_add_virt_mods (keymap, &state);
event->key.state |= state;
event->key.is_modifier = _gdk_x11_keymap_key_is_modifier (keymap, event->key.hardware_keycode);
_gdk_x11_event_translate_keyboard_string (&event->key);
#ifdef G_ENABLE_DEBUG
if (_gdk_debug_flags & GDK_DEBUG_EVENTS)
{
g_message ("%s:\t\twindow: %ld key: %12s %d",
event->type == GDK_KEY_PRESS ? "key press " : "key release",
xevent->xkey.window,
event->key.keyval ? gdk_keyval_name (event->key.keyval) : "(none)",
event->key.keyval);
if (event->key.length > 0)
g_message ("\t\tlength: %4d string: \"%s\"",
event->key.length, event->key.string);
}
#endif /* G_ENABLE_DEBUG */
return;
}
static void
point_update (PointState *point,
GtkWidget *widget,
gdouble x,
gdouble y)
{
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
GdkEvent *ev;
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
point->x = x;
point->y = y;
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_MOTION_NOTIFY);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->button.time = GDK_CURRENT_TIME;
ev->motion.x = x;
ev->motion.y = y;
ev->motion.state = point->state;
}
else
{
if (!point->widget || widget != point->widget)
return;
ev = gdk_event_new (GDK_TOUCH_UPDATE);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = x;
ev->touch.y = y;
ev->touch.sequence = EVENT_SEQUENCE (point);
ev->touch.state = 0;
if (point == &touch_state[0])
ev->touch.emulating_pointer = TRUE;
}
gdk_event_set_device (ev, device);
gtk_main_do_event (ev);
gdk_event_free (ev);
}
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));
}
static void
generate_focus_event (GdkX11DeviceManagerCore *device_manager,
GdkWindow *window,
gboolean in)
{
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 = in;
gdk_event_set_device (event, device_manager->core_keyboard);
gdk_event_put (event);
gdk_event_free (event);
}
static void
point_press (PointState *point,
GtkWidget *widget,
guint button)
{
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
GdkEvent *ev;
display = gtk_widget_get_display (widget);
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_BUTTON_PRESS);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
ev->button.button = button;
ev->button.state = point->state;
point->state |= GDK_BUTTON1_MASK << (button - 1);
}
else
{
ev = gdk_event_new (GDK_TOUCH_BEGIN);
ev->any.window = g_object_ref (gtk_widget_get_window (widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
ev->touch.sequence = EVENT_SEQUENCE (point);
if (point == &touch_state[0])
ev->touch.emulating_pointer = TRUE;
}
gdk_event_set_device (ev, device);
gtk_main_do_event (ev);
gdk_event_free (ev);
point->widget = widget;
}
/* taken from gtk/gtktreeview.c */
static void
send_focus_change (GtkWidget *widget,
GdkDevice *device,
gboolean in)
{
GdkDeviceManager *device_manager;
GList *devices, *d;
device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
devices = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_SLAVE));
devices = g_list_concat (devices, gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING));
for (d = devices; d; d = d->next)
{
GdkDevice *dev = d->data;
GdkEvent *fevent;
GdkWindow *window;
if (gdk_device_get_source (dev) != GDK_SOURCE_KEYBOARD)
continue;
window = gtk_widget_get_window (widget);
/* Skip non-master keyboards that haven't
* selected for events from this window
*/
if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
!gdk_window_get_device_events (window, dev))
continue;
fevent = gdk_event_new (GDK_FOCUS_CHANGE);
fevent->focus_change.type = GDK_FOCUS_CHANGE;
fevent->focus_change.window = g_object_ref (window);
fevent->focus_change.in = in;
gdk_event_set_device (fevent, device);
gtk_widget_send_focus_change (widget, fevent);
gdk_event_free (fevent);
}
g_list_free (devices);
}
void sendKeyEventToFilter(unsigned gdkKeyValue, GdkEventType type, unsigned modifiers = 0)
{
GdkEvent* event = gdk_event_new(type);
event->key.keyval = gdkKeyValue;
event->key.state = modifiers;
event->key.window = gtk_widget_get_window(m_testWindow);
event->key.time = GDK_CURRENT_TIME;
g_object_ref(event->key.window);
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_display_get_default())));
GUniqueOutPtr<GdkKeymapKey> keys;
gint nKeys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), gdkKeyValue, &keys.outPtr(), &nKeys))
event->key.hardware_keycode = keys.get()[0].keycode;
filterKeyEvent(&event->key);
gdk_event_free(event);
}
void EventSenderProxy::continuousMouseScrollBy(int horizontal, int vertical, bool paged)
{
// Gtk+ does not support paged scroll events.
g_return_if_fail(!paged);
GdkEvent* event = gdk_event_new(GDK_SCROLL);
event->scroll.x = m_position.x;
event->scroll.y = m_position.y;
event->scroll.time = GDK_CURRENT_TIME;
event->scroll.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView()));
g_object_ref(event->scroll.window);
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(event->scroll.window))));
event->scroll.direction = GDK_SCROLL_SMOOTH;
event->scroll.delta_x = -horizontal / pixelsPerScrollTick;
event->scroll.delta_y = -vertical / pixelsPerScrollTick;
sendOrQueueEvent(event);
}
static JSValueRef runPasteTestCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
gtk_widget_grab_focus(GTK_WIDGET(currentFixture->webView));
// Simulate a paste keyboard sequence.
GdkEvent* event = gdk_event_new(GDK_KEY_PRESS);
event->key.keyval = gdk_unicode_to_keyval('v');
event->key.state = GDK_CONTROL_MASK;
event->key.window = gtk_widget_get_window(GTK_WIDGET(currentFixture->webView));
g_object_ref(event->key.window);
#ifndef GTK_API_VERSION_2
GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(event->key.window));
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(manager));
#endif
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), event->key.keyval, &keys, &n_keys)) {
event->key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
gtk_main_do_event(event);
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event);
gdk_event_free(event);
JSStringRef scriptString = JSStringCreateWithUTF8CString("document.body.innerHTML;");
JSValueRef value = JSEvaluateScript(context, scriptString, 0, 0, 0, 0);
JSStringRelease(scriptString);
g_assert(JSValueIsString(context, value));
JSStringRef actual = JSValueToStringCopy(context, value, exception);
g_assert(!exception || !*exception);
g_assert(currentFixture->info->expectedContent);
JSStringRef expected = JSStringCreateWithUTF8CString(currentFixture->info->expectedContent);
g_assert(JSStringIsEqual(expected, actual));
JSStringRelease(expected);
JSStringRelease(actual);
g_main_loop_quit(currentFixture->loop);
return JSValueMakeUndefined(context);
}
static void doKeyStroke(GtkWidget* viewWidget, unsigned int keyVal)
{
GUniquePtr<GdkEvent> event(gdk_event_new(GDK_KEY_PRESS));
event->key.keyval = keyVal;
event->key.time = GDK_CURRENT_TIME;
event->key.state = 0;
event->key.window = gtk_widget_get_window(viewWidget);
g_object_ref(event->key.window);
gdk_event_set_device(event.get(), gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget))));
// When synthesizing an event, an invalid hardware_keycode value can cause it to be badly processed by GTK+.
GOwnPtr<GdkKeymapKey> keys;
int keysCount;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyVal, &keys.outPtr(), &keysCount))
event->key.hardware_keycode = keys.get()[0].keycode;
gtk_main_do_event(event.get());
event->key.type = GDK_KEY_RELEASE;
gtk_main_do_event(event.get());
}
GdkEvent* EventSenderProxy::createMouseButtonEvent(GdkEventType eventType, unsigned button, WKEventModifiers modifiers)
{
GdkEvent* mouseEvent = gdk_event_new(eventType);
mouseEvent->button.button = eventSenderButtonToGDKButton(button);
mouseEvent->button.x = m_position.x;
mouseEvent->button.y = m_position.y;
mouseEvent->button.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView()));
g_object_ref(mouseEvent->button.window);
gdk_event_set_device(mouseEvent, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(mouseEvent->button.window))));
mouseEvent->button.state = modifiers | getMouseButtonModifiers(mouseEvent->button.button);
mouseEvent->button.time = GDK_CURRENT_TIME;
mouseEvent->button.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(mouseEvent->button.window, m_position.x, m_position.y, &xRoot, &yRoot);
mouseEvent->button.x_root = xRoot;
mouseEvent->button.y_root = yRoot;
return mouseEvent;
}
static void
handle_focus_change (GdkEventCrossing *event)
{
GdkToplevelX11 *toplevel;
GdkX11Screen *x11_screen;
gboolean focus_in, had_focus;
toplevel = _gdk_x11_window_get_toplevel (event->window);
x11_screen = GDK_X11_SCREEN (gdk_window_get_screen (event->window));
focus_in = (event->type == GDK_ENTER_NOTIFY);
if (x11_screen->wmspec_check_window)
return;
if (!toplevel || event->detail == GDK_NOTIFY_INFERIOR)
return;
toplevel->has_pointer = focus_in;
if (!event->focus || toplevel->has_focus_window)
return;
had_focus = HAS_FOCUS (toplevel);
toplevel->has_pointer_focus = focus_in;
if (HAS_FOCUS (toplevel) != had_focus)
{
GdkEvent *focus_event;
focus_event = gdk_event_new (GDK_FOCUS_CHANGE);
focus_event->focus_change.window = g_object_ref (event->window);
focus_event->focus_change.send_event = FALSE;
focus_event->focus_change.in = focus_in;
gdk_event_set_device (focus_event, gdk_event_get_device ((GdkEvent *) event));
gdk_event_put (focus_event);
gdk_event_free (focus_event);
}
}
void EventSenderProxy::keyDown(WKStringRef keyRef, WKEventModifiers wkModifiers, unsigned location)
{
guint modifiers = webkitModifiersToGDKModifiers(wkModifiers);
int gdkKeySym = getGDKKeySymForKeyRef(keyRef, location, &modifiers);
GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS);
pressEvent->key.keyval = gdkKeySym;
pressEvent->key.state = modifiers;
pressEvent->key.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformWindow()));
g_object_ref(pressEvent->key.window);
gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(pressEvent->key.window))));
GOwnPtr<GdkKeymapKey> keys;
gint nKeys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), gdkKeySym, &keys.outPtr(), &nKeys))
pressEvent->key.hardware_keycode = keys.get()[0].keycode;
GdkEvent* releaseEvent = gdk_event_copy(pressEvent);
dispatchEvent(pressEvent);
releaseEvent->key.type = GDK_KEY_RELEASE;
dispatchEvent(releaseEvent);
}
void EventSenderProxy::mouseMoveTo(double x, double y)
{
m_position.x = x;
m_position.y = y;
GdkEvent* event = gdk_event_new(GDK_MOTION_NOTIFY);
event->motion.x = m_position.x;
event->motion.y = m_position.y;
event->motion.time = GDK_CURRENT_TIME;
event->motion.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView()));
g_object_ref(event->motion.window);
gdk_event_set_device(event, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(event->motion.window))));
event->motion.state = 0 | getMouseButtonModifiers(m_mouseButtonCurrentlyDown);
event->motion.axes = 0;
int xRoot, yRoot;
gdk_window_get_root_coords(gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView())), m_position.x, m_position.y , &xRoot, &yRoot);
event->motion.x_root = xRoot;
event->motion.y_root = yRoot;
sendOrQueueEvent(event);
}
void
_gdk_broadway_events_got_input (GdkDisplay *display,
BroadwayInputMsg *message)
{
GdkBroadwayDisplay *display_broadway = GDK_BROADWAY_DISPLAY (display);
GdkScreen *screen;
GdkWindow *window;
GdkEvent *event = NULL;
GList *node;
switch (message->base.type) {
case 'e': /* Enter */
display_broadway->last_x = message->pointer.root_x;
display_broadway->last_y = message->pointer.root_y;
display_broadway->last_state = message->pointer.state;
display_broadway->real_mouse_in_toplevel =
g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.mouse_window_id));
window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
/* TODO: Unset when it dies */
display_broadway->mouse_in_toplevel = window;
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);
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;
case 'l': /* Leave */
display_broadway->last_x = message->pointer.root_x;
display_broadway->last_y = message->pointer.root_y;
display_broadway->last_state = message->pointer.state;
display_broadway->real_mouse_in_toplevel =
g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.mouse_window_id));
window = g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.event_window_id));
display_broadway->mouse_in_toplevel = NULL;
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);
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);
}
break;
case 'm': /* Mouse move */
display_broadway->last_x = message->pointer.root_x;
display_broadway->last_y = message->pointer.root_y;
display_broadway->last_state = message->pointer.state;
display_broadway->real_mouse_in_toplevel =
g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.mouse_window_id));
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 'b':
case 'B':
display_broadway->last_x = message->pointer.root_x;
display_broadway->last_y = message->pointer.root_y;
display_broadway->last_state = message->pointer.state;
display_broadway->real_mouse_in_toplevel =
g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.mouse_window_id));
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 's':
display_broadway->last_x = message->pointer.root_x;
display_broadway->last_y = message->pointer.root_y;
display_broadway->last_state = message->pointer.state;
display_broadway->real_mouse_in_toplevel =
g_hash_table_lookup (display_broadway->id_ht, GINT_TO_POINTER (message->pointer.mouse_window_id));
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 'k':
case 'K':
window = display_broadway->mouse_in_toplevel;
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, display->core_pointer);
display_broadway->last_state = message->key.state;
node = _gdk_event_queue_append (display, event);
_gdk_windowing_got_event (display, node, event, message->base.serial);
}
break;
case 'g':
case 'u':
_gdk_display_device_grab_update (display, display->core_pointer, NULL, message->base.serial);
break;
case 'w':
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;
window->width = message->configure_notify.width;
window->height = message->configure_notify.height;
_gdk_window_update_size (window);
_gdk_broadway_window_resize_surface (window);
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 'W':
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 'd':
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;
default:
g_printerr ("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);
}
}
static JSValueRef keyDownCallback(JSContextRef context, JSObjectRef function, JSObjectRef thisObject, size_t argumentCount, const JSValueRef arguments[], JSValueRef* exception)
{
if (argumentCount < 1)
return JSValueMakeUndefined(context);
static const JSStringRef lengthProperty = JSStringCreateWithUTF8CString("length");
webkit_web_frame_layout(mainFrame);
// handle modifier keys.
int state = 0;
if (argumentCount > 1) {
JSObjectRef modifiersArray = JSValueToObject(context, arguments[1], exception);
if (modifiersArray) {
for (int i = 0; i < JSValueToNumber(context, JSObjectGetProperty(context, modifiersArray, lengthProperty, 0), 0); ++i) {
JSValueRef value = JSObjectGetPropertyAtIndex(context, modifiersArray, i, 0);
JSStringRef string = JSValueToStringCopy(context, value, 0);
if (JSStringIsEqualToUTF8CString(string, "ctrlKey"))
state |= GDK_CONTROL_MASK;
else if (JSStringIsEqualToUTF8CString(string, "shiftKey"))
state |= GDK_SHIFT_MASK;
else if (JSStringIsEqualToUTF8CString(string, "altKey"))
state |= GDK_MOD1_MASK;
JSStringRelease(string);
}
}
}
// handle location argument.
int location = DOM_KEY_LOCATION_STANDARD;
if (argumentCount > 2)
location = (int)JSValueToNumber(context, arguments[2], exception);
JSStringRef character = JSValueToStringCopy(context, arguments[0], exception);
g_return_val_if_fail((!exception || !*exception), JSValueMakeUndefined(context));
int gdkKeySym = GDK_VoidSymbol;
if (location == DOM_KEY_LOCATION_NUMPAD) {
if (JSStringIsEqualToUTF8CString(character, "leftArrow"))
gdkKeySym = GDK_KP_Left;
else if (JSStringIsEqualToUTF8CString(character, "rightArrow"))
gdkKeySym = GDK_KP_Right;
else if (JSStringIsEqualToUTF8CString(character, "upArrow"))
gdkKeySym = GDK_KP_Up;
else if (JSStringIsEqualToUTF8CString(character, "downArrow"))
gdkKeySym = GDK_KP_Down;
else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
gdkKeySym = GDK_KP_Page_Up;
else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
gdkKeySym = GDK_KP_Page_Down;
else if (JSStringIsEqualToUTF8CString(character, "home"))
gdkKeySym = GDK_KP_Home;
else if (JSStringIsEqualToUTF8CString(character, "end"))
gdkKeySym = GDK_KP_End;
else if (JSStringIsEqualToUTF8CString(character, "insert"))
gdkKeySym = GDK_KP_Insert;
else if (JSStringIsEqualToUTF8CString(character, "delete"))
gdkKeySym = GDK_KP_Delete;
else
// If we get some other key specified with the numpad location,
// crash here, so we add it sooner rather than later.
g_assert_not_reached();
} else {
if (JSStringIsEqualToUTF8CString(character, "leftArrow"))
gdkKeySym = GDK_Left;
else if (JSStringIsEqualToUTF8CString(character, "rightArrow"))
gdkKeySym = GDK_Right;
else if (JSStringIsEqualToUTF8CString(character, "upArrow"))
gdkKeySym = GDK_Up;
else if (JSStringIsEqualToUTF8CString(character, "downArrow"))
gdkKeySym = GDK_Down;
else if (JSStringIsEqualToUTF8CString(character, "pageUp"))
gdkKeySym = GDK_Page_Up;
else if (JSStringIsEqualToUTF8CString(character, "pageDown"))
gdkKeySym = GDK_Page_Down;
else if (JSStringIsEqualToUTF8CString(character, "home"))
gdkKeySym = GDK_Home;
else if (JSStringIsEqualToUTF8CString(character, "end"))
gdkKeySym = GDK_End;
else if (JSStringIsEqualToUTF8CString(character, "insert"))
gdkKeySym = GDK_Insert;
else if (JSStringIsEqualToUTF8CString(character, "delete"))
gdkKeySym = GDK_Delete;
else if (JSStringIsEqualToUTF8CString(character, "printScreen"))
gdkKeySym = GDK_Print;
else if (JSStringIsEqualToUTF8CString(character, "F1"))
gdkKeySym = GDK_F1;
else if (JSStringIsEqualToUTF8CString(character, "F2"))
gdkKeySym = GDK_F2;
else if (JSStringIsEqualToUTF8CString(character, "F3"))
gdkKeySym = GDK_F3;
else if (JSStringIsEqualToUTF8CString(character, "F4"))
gdkKeySym = GDK_F4;
else if (JSStringIsEqualToUTF8CString(character, "F5"))
gdkKeySym = GDK_F5;
else if (JSStringIsEqualToUTF8CString(character, "F6"))
gdkKeySym = GDK_F6;
else if (JSStringIsEqualToUTF8CString(character, "F7"))
gdkKeySym = GDK_F7;
else if (JSStringIsEqualToUTF8CString(character, "F8"))
gdkKeySym = GDK_F8;
else if (JSStringIsEqualToUTF8CString(character, "F9"))
gdkKeySym = GDK_F9;
else if (JSStringIsEqualToUTF8CString(character, "F10"))
gdkKeySym = GDK_F10;
else if (JSStringIsEqualToUTF8CString(character, "F11"))
gdkKeySym = GDK_F11;
else if (JSStringIsEqualToUTF8CString(character, "F12"))
gdkKeySym = GDK_F12;
else {
int charCode = JSStringGetCharactersPtr(character)[0];
if (charCode == '\n' || charCode == '\r')
gdkKeySym = GDK_Return;
else if (charCode == '\t')
gdkKeySym = GDK_Tab;
else if (charCode == '\x8')
gdkKeySym = GDK_BackSpace;
else {
gdkKeySym = gdk_unicode_to_keyval(charCode);
if (WTF::isASCIIUpper(charCode))
state |= GDK_SHIFT_MASK;
}
}
}
JSStringRelease(character);
WebKitWebView* view = webkit_web_frame_get_web_view(mainFrame);
if (!view)
return JSValueMakeUndefined(context);
// create and send the event
GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS);
pressEvent->key.keyval = gdkKeySym;
pressEvent->key.state = state;
pressEvent->key.window = gtk_widget_get_window(GTK_WIDGET(view));
g_object_ref(pressEvent->key.window);
#ifndef GTK_API_VERSION_2
gdk_event_set_device(pressEvent, getDefaultGDKPointerDevice(pressEvent->key.window));
#endif
// When synthesizing an event, an invalid hardware_keycode value
// can cause it to be badly processed by Gtk+.
GdkKeymapKey* keys;
gint n_keys;
if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), gdkKeySym, &keys, &n_keys)) {
pressEvent->key.hardware_keycode = keys[0].keycode;
g_free(keys);
}
GdkEvent* releaseEvent = gdk_event_copy(pressEvent);
dispatchEvent(pressEvent);
releaseEvent->key.type = GDK_KEY_RELEASE;
dispatchEvent(releaseEvent);
return JSValueMakeUndefined(context);
}
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;
}
}
static gboolean
gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
GdkDisplay *display,
GdkEvent *event,
XEvent *xevent)
{
GdkX11DeviceManagerCore *device_manager;
GdkWindow *window;
gboolean return_val;
GdkToplevelX11 *toplevel = NULL;
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
device_manager = GDK_X11_DEVICE_MANAGER_CORE (translator);
return_val = FALSE;
window = get_event_window (translator, xevent);
if (window)
{
if (GDK_WINDOW_DESTROYED (window) || !GDK_IS_WINDOW (window))
return FALSE;
toplevel = _gdk_x11_window_get_toplevel (window);
g_object_ref (window);
}
event->any.window = window;
event->any.send_event = xevent->xany.send_event ? TRUE : FALSE;
if (window && GDK_WINDOW_DESTROYED (window))
{
if (xevent->type != DestroyNotify)
{
return_val = FALSE;
goto done;
}
}
if (window &&
(xevent->type == MotionNotify ||
xevent->type == ButtonRelease))
{
if (_gdk_x11_moveresize_handle_event (xevent))
{
return_val = FALSE;
goto done;
}
}
/* We do a "manual" conversion of the XEvent to a
* GdkEvent. The structures are mostly the same so
* the conversion is fairly straightforward. We also
* optionally print debugging info regarding events
* received.
*/
return_val = TRUE;
switch (xevent->type)
{
case KeyPress:
if (window == NULL)
{
return_val = FALSE;
break;
}
translate_key_event (display, device_manager, event, xevent);
set_user_time (window, event);
break;
case KeyRelease:
if (window == NULL)
{
return_val = FALSE;
break;
}
/* Emulate detectable auto-repeat by checking to see
* if the next event is a key press with the same
* keycode and timestamp, and if so, ignoring the event.
*/
if (!display_x11->have_xkb_autorepeat && XPending (xevent->xkey.display))
{
XEvent next_event;
XPeekEvent (xevent->xkey.display, &next_event);
if (next_event.type == KeyPress &&
next_event.xkey.keycode == xevent->xkey.keycode &&
next_event.xkey.time == xevent->xkey.time)
{
return_val = FALSE;
break;
}
}
translate_key_event (display, device_manager, event, xevent);
break;
case ButtonPress:
GDK_NOTE (EVENTS,
g_message ("button press:\t\twindow: %ld x,y: %d %d button: %d",
xevent->xbutton.window,
xevent->xbutton.x, xevent->xbutton.y,
xevent->xbutton.button));
if (window == NULL)
{
return_val = FALSE;
break;
}
/* If we get a ButtonPress event where the button is 4 or 5,
it's a Scroll event */
switch (xevent->xbutton.button)
{
case 4: /* up */
case 5: /* down */
case 6: /* left */
case 7: /* right */
event->scroll.type = GDK_SCROLL;
if (xevent->xbutton.button == 4)
event->scroll.direction = GDK_SCROLL_UP;
else if (xevent->xbutton.button == 5)
event->scroll.direction = GDK_SCROLL_DOWN;
else if (xevent->xbutton.button == 6)
event->scroll.direction = GDK_SCROLL_LEFT;
else
event->scroll.direction = GDK_SCROLL_RIGHT;
event->scroll.window = window;
event->scroll.time = xevent->xbutton.time;
event->scroll.x = (gdouble) xevent->xbutton.x;
event->scroll.y = (gdouble) xevent->xbutton.y;
event->scroll.x_root = (gdouble) xevent->xbutton.x_root;
event->scroll.y_root = (gdouble) xevent->xbutton.y_root;
event->scroll.state = (GdkModifierType) xevent->xbutton.state;
event->scroll.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
break;
default:
event->button.type = GDK_BUTTON_PRESS;
event->button.window = window;
event->button.time = xevent->xbutton.time;
event->button.x = (gdouble) xevent->xbutton.x;
event->button.y = (gdouble) xevent->xbutton.y;
event->button.x_root = (gdouble) xevent->xbutton.x_root;
event->button.y_root = (gdouble) xevent->xbutton.y_root;
event->button.axes = NULL;
event->button.state = (GdkModifierType) xevent->xbutton.state;
event->button.button = xevent->xbutton.button;
event->button.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
return_val = FALSE;
break;
}
set_user_time (window, event);
break;
case ButtonRelease:
GDK_NOTE (EVENTS,
g_message ("button release:\twindow: %ld x,y: %d %d button: %d",
xevent->xbutton.window,
xevent->xbutton.x, xevent->xbutton.y,
xevent->xbutton.button));
if (window == NULL)
{
return_val = FALSE;
break;
}
/* We treat button presses as scroll wheel events, so ignore the release */
if (xevent->xbutton.button == 4 || xevent->xbutton.button == 5 ||
xevent->xbutton.button == 6 || xevent->xbutton.button == 7)
{
return_val = FALSE;
break;
}
event->button.type = GDK_BUTTON_RELEASE;
event->button.window = window;
event->button.time = xevent->xbutton.time;
event->button.x = (gdouble) xevent->xbutton.x;
event->button.y = (gdouble) xevent->xbutton.y;
event->button.x_root = (gdouble) xevent->xbutton.x_root;
event->button.y_root = (gdouble) xevent->xbutton.y_root;
event->button.axes = NULL;
event->button.state = (GdkModifierType) xevent->xbutton.state;
event->button.button = xevent->xbutton.button;
event->button.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
return_val = FALSE;
break;
case MotionNotify:
GDK_NOTE (EVENTS,
g_message ("motion notify:\t\twindow: %ld x,y: %d %d hint: %s",
xevent->xmotion.window,
xevent->xmotion.x, xevent->xmotion.y,
(xevent->xmotion.is_hint) ? "true" : "false"));
if (window == NULL)
{
return_val = FALSE;
break;
}
event->motion.type = GDK_MOTION_NOTIFY;
event->motion.window = window;
event->motion.time = xevent->xmotion.time;
event->motion.x = (gdouble) xevent->xmotion.x;
event->motion.y = (gdouble) xevent->xmotion.y;
event->motion.x_root = (gdouble) xevent->xmotion.x_root;
event->motion.y_root = (gdouble) xevent->xmotion.y_root;
event->motion.axes = NULL;
event->motion.state = (GdkModifierType) xevent->xmotion.state;
event->motion.is_hint = xevent->xmotion.is_hint;
event->motion.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
break;
case EnterNotify:
GDK_NOTE (EVENTS,
g_message ("enter notify:\t\twindow: %ld detail: %d subwin: %ld",
xevent->xcrossing.window,
xevent->xcrossing.detail,
xevent->xcrossing.subwindow));
if (window == NULL)
{
return_val = FALSE;
break;
}
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
event->crossing.type = GDK_ENTER_NOTIFY;
event->crossing.window = window;
gdk_event_set_device (event, device_manager->core_pointer);
/* If the subwindow field of the XEvent is non-NULL, then
* lookup the corresponding GdkWindow.
*/
if (xevent->xcrossing.subwindow != None)
event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
else
event->crossing.subwindow = NULL;
event->crossing.time = xevent->xcrossing.time;
event->crossing.x = (gdouble) xevent->xcrossing.x;
event->crossing.y = (gdouble) xevent->xcrossing.y;
event->crossing.x_root = (gdouble) xevent->xcrossing.x_root;
event->crossing.y_root = (gdouble) xevent->xcrossing.y_root;
event->crossing.mode = translate_crossing_mode (xevent->xcrossing.mode);
event->crossing.detail = translate_notify_type (xevent->xcrossing.detail);
event->crossing.focus = xevent->xcrossing.focus;
event->crossing.state = xevent->xcrossing.state;
break;
case LeaveNotify:
GDK_NOTE (EVENTS,
g_message ("leave notify:\t\twindow: %ld detail: %d subwin: %ld",
xevent->xcrossing.window,
xevent->xcrossing.detail, xevent->xcrossing.subwindow));
if (window == NULL)
{
return_val = FALSE;
break;
}
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
event->crossing.type = GDK_LEAVE_NOTIFY;
event->crossing.window = window;
gdk_event_set_device (event, device_manager->core_pointer);
/* If the subwindow field of the XEvent is non-NULL, then
* lookup the corresponding GdkWindow.
*/
if (xevent->xcrossing.subwindow != None)
event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
else
event->crossing.subwindow = NULL;
event->crossing.time = xevent->xcrossing.time;
event->crossing.x = (gdouble) xevent->xcrossing.x;
event->crossing.y = (gdouble) xevent->xcrossing.y;
event->crossing.x_root = (gdouble) xevent->xcrossing.x_root;
event->crossing.y_root = (gdouble) xevent->xcrossing.y_root;
event->crossing.mode = translate_crossing_mode (xevent->xcrossing.mode);
event->crossing.detail = translate_notify_type (xevent->xcrossing.detail);
event->crossing.focus = xevent->xcrossing.focus;
event->crossing.state = xevent->xcrossing.state;
break;
/* We only care about focus events that indicate that _this_
* window (not a ancestor or child) got or lost the focus
*/
case FocusIn:
GDK_NOTE (EVENTS,
g_message ("focus in:\t\twindow: %ld, detail: %s, mode: %s",
xevent->xfocus.window,
notify_details[xevent->xfocus.detail],
notify_modes[xevent->xfocus.mode]));
if (toplevel)
{
gboolean had_focus = HAS_FOCUS (toplevel);
switch (xevent->xfocus.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 &&
xevent->xfocus.mode != NotifyGrab &&
xevent->xfocus.mode != NotifyUngrab)
toplevel->has_pointer_focus = FALSE;
/* fall through */
case NotifyNonlinear:
case NotifyNonlinearVirtual:
if (xevent->xfocus.mode != NotifyGrab &&
xevent->xfocus.mode != NotifyUngrab)
toplevel->has_focus_window = TRUE;
/* We pretend that the focus moves to the grab
* window, so we pay attention to NotifyGrab
* NotifyUngrab, and ignore NotifyWhileGrabbed
*/
if (xevent->xfocus.mode != NotifyWhileGrabbed)
toplevel->has_focus = TRUE;
break;
case NotifyPointer:
/* The X server sends NotifyPointer/NotifyGrab,
* but the pointer focus is ignored while a
* grab is in effect
*/
if (xevent->xfocus.mode != NotifyGrab &&
xevent->xfocus.mode != NotifyUngrab)
toplevel->has_pointer_focus = TRUE;
break;
case NotifyInferior:
case NotifyPointerRoot:
case NotifyDetailNone:
break;
}
if (HAS_FOCUS (toplevel) != had_focus)
generate_focus_event (device_manager, window, TRUE);
}
break;
case FocusOut:
GDK_NOTE (EVENTS,
g_message ("focus out:\t\twindow: %ld, detail: %s, mode: %s",
xevent->xfocus.window,
notify_details[xevent->xfocus.detail],
notify_modes[xevent->xfocus.mode]));
if (toplevel)
{
gboolean had_focus = HAS_FOCUS (toplevel);
switch (xevent->xfocus.detail)
{
case NotifyAncestor:
case NotifyVirtual:
/* When the focus moves from the window or a descendent
* of the window to an ancestor of the window, *and* the
* pointer is inside the window, then we were previously
* receiving keystroke events in the has_focus_window
* case and are now receiving them in the
* has_pointer_focus case.
*/
if (toplevel->has_pointer &&
xevent->xfocus.mode != NotifyGrab &&
xevent->xfocus.mode != NotifyUngrab)
toplevel->has_pointer_focus = TRUE;
/* fall through */
case NotifyNonlinear:
case NotifyNonlinearVirtual:
if (xevent->xfocus.mode != NotifyGrab &&
xevent->xfocus.mode != NotifyUngrab)
toplevel->has_focus_window = FALSE;
if (xevent->xfocus.mode != NotifyWhileGrabbed)
toplevel->has_focus = FALSE;
break;
case NotifyPointer:
if (xevent->xfocus.mode != NotifyGrab &&
xevent->xfocus.mode != NotifyUngrab)
toplevel->has_pointer_focus = FALSE;
break;
case NotifyInferior:
case NotifyPointerRoot:
case NotifyDetailNone:
break;
}
if (HAS_FOCUS (toplevel) != had_focus)
generate_focus_event (device_manager, window, FALSE);
}
break;
default:
return_val = FALSE;
}
done:
if (return_val)
{
if (event->any.window)
g_object_ref (event->any.window);
if (((event->any.type == GDK_ENTER_NOTIFY) ||
(event->any.type == GDK_LEAVE_NOTIFY)) &&
(event->crossing.subwindow != NULL))
g_object_ref (event->crossing.subwindow);
}
else
{
/* Mark this event as having no resources to be freed */
event->any.window = NULL;
event->any.type = GDK_NOTHING;
}
if (window)
g_object_unref (window);
return return_val;
}
static gboolean
maybe_redirect_mouse_event (XEvent *xevent)
{
GdkDisplay *gdisplay;
GdkDeviceManager *gmanager;
GdkDevice *gdevice;
MetaUI *ui;
GdkEvent *gevent;
GdkWindow *gdk_window;
Window window;
XIEvent *xev;
XIDeviceEvent *xev_d = NULL;
XIEnterEvent *xev_e = NULL;
if (!is_input_event (xevent))
return FALSE;
xev = (XIEvent *) xevent->xcookie.data;
switch (xev->evtype)
{
case XI_TouchBegin:
case XI_ButtonPress:
case XI_ButtonRelease:
case XI_Motion:
xev_d = (XIDeviceEvent *) xev;
window = xev_d->event;
break;
case XI_Enter:
case XI_Leave:
xev_e = (XIEnterEvent *) xev;
window = xev_e->event;
break;
default:
return FALSE;
}
gdisplay = gdk_x11_lookup_xdisplay (xev->display);
ui = g_object_get_data (G_OBJECT (gdisplay), "meta-ui");
if (!ui)
return FALSE;
gdk_window = gdk_x11_window_lookup_for_display (gdisplay, window);
if (gdk_window == NULL)
return FALSE;
gmanager = gdk_display_get_device_manager (gdisplay);
gdevice = gdk_x11_device_manager_lookup (gmanager, META_VIRTUAL_CORE_POINTER_ID);
/* If GDK already thinks it has a grab, we better let it see events; this
* is the menu-navigation case and events need to get sent to the appropriate
* (client-side) subwindow for individual menu items.
*/
if (gdk_display_device_is_grabbed (gdisplay, gdevice))
return FALSE;
switch (xev->evtype)
{
case XI_TouchBegin:
case XI_ButtonPress:
case XI_ButtonRelease:
if (xev_d->evtype == XI_ButtonPress || xev_d->evtype == XI_TouchBegin)
{
GtkSettings *settings = gtk_settings_get_default ();
int double_click_time;
int double_click_distance;
int button;
g_object_get (settings,
"gtk-double-click-time", &double_click_time,
"gtk-double-click-distance", &double_click_distance,
NULL);
if (xev->evtype == XI_TouchBegin)
button = 1;
else
button = xev_d->detail;
if (button == ui->button_click_number &&
xev_d->event == ui->button_click_window &&
xev_d->time < ui->button_click_time + double_click_time &&
ABS (xev_d->event_x - ui->button_click_x) <= double_click_distance &&
ABS (xev_d->event_y - ui->button_click_y) <= double_click_distance)
{
gevent = gdk_event_new (GDK_2BUTTON_PRESS);
ui->button_click_number = 0;
}
else
{
gevent = gdk_event_new (GDK_BUTTON_PRESS);
ui->button_click_number = button;
ui->button_click_window = xev_d->event;
ui->button_click_time = xev_d->time;
ui->button_click_x = xev_d->event_x;
ui->button_click_y = xev_d->event_y;
}
gevent->button.button = button;
}
else
{
gevent = gdk_event_new (GDK_BUTTON_RELEASE);
gevent->button.button = xev_d->detail;
}
gevent->button.window = g_object_ref (gdk_window);
gevent->button.time = xev_d->time;
gevent->button.x = xev_d->event_x;
gevent->button.y = xev_d->event_y;
gevent->button.x_root = xev_d->root_x;
gevent->button.y_root = xev_d->root_y;
break;
case XI_Motion:
gevent = gdk_event_new (GDK_MOTION_NOTIFY);
gevent->motion.type = GDK_MOTION_NOTIFY;
gevent->motion.window = g_object_ref (gdk_window);
break;
case XI_Enter:
case XI_Leave:
gevent = gdk_event_new (xev_e->evtype == XI_Enter ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
gevent->crossing.window = g_object_ref (gdk_window);
gevent->crossing.x = xev_e->event_x;
gevent->crossing.y = xev_e->event_y;
break;
default:
g_assert_not_reached ();
break;
}
/* If we've gotten here, we've created the gdk_event and should send it on */
gdk_event_set_device (gevent, gdevice);
gtk_main_do_event (gevent);
gdk_event_free (gevent);
return TRUE;
}
static gboolean
maybe_redirect_mouse_event (XEvent *xevent)
{
GdkDisplay *gdisplay;
MetaUI *ui;
#if GTK_CHECK_VERSION (3, 0, 0)
GdkDeviceManager *gmanager;
GdkDevice *gdevice;
GdkEvent *gevent;
#else
GdkEvent gevent;
#endif
GdkWindow *gdk_window;
Window window;
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
window = xevent->xbutton.window;
break;
case MotionNotify:
window = xevent->xmotion.window;
break;
case EnterNotify:
case LeaveNotify:
window = xevent->xcrossing.window;
break;
default:
return FALSE;
}
gdisplay = gdk_x11_lookup_xdisplay (xevent->xany.display);
ui = g_object_get_data (G_OBJECT (gdisplay), "meta-ui");
if (!ui)
return FALSE;
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_window = gdk_x11_window_lookup_for_display (gdisplay, window);
#else
gdk_window = gdk_window_lookup_for_display (gdisplay, window);
#endif
if (gdk_window == NULL)
return FALSE;
#if GTK_CHECK_VERSION (3, 0, 0)
gmanager = gdk_display_get_device_manager (gdisplay);
gdevice = gdk_device_manager_get_client_pointer (gmanager);
#endif
/* If GDK already thinks it has a grab, we better let it see events; this
* is the menu-navigation case and events need to get sent to the appropriate
* (client-side) subwindow for individual menu items.
*/
#if GTK_CHECK_VERSION (3, 0, 0)
if (gdk_display_device_is_grabbed (gdisplay, gdevice))
#else
if (gdk_display_pointer_is_grabbed (gdisplay))
#endif
return FALSE;
#if !GTK_CHECK_VERSION (3, 0, 0)
memset (&gevent, 0, sizeof (gevent));
#endif
switch (xevent->type)
{
case ButtonPress:
case ButtonRelease:
if (xevent->type == ButtonPress)
{
GtkSettings *settings = gtk_settings_get_default ();
int double_click_time;
int double_click_distance;
g_object_get (settings,
"gtk-double-click-time", &double_click_time,
"gtk-double-click-distance", &double_click_distance,
NULL);
if (xevent->xbutton.button == ui->button_click_number &&
xevent->xbutton.window == ui->button_click_window &&
xevent->xbutton.time < ui->button_click_time + double_click_time &&
ABS (xevent->xbutton.x - ui->button_click_x) <= double_click_distance &&
ABS (xevent->xbutton.y - ui->button_click_y) <= double_click_distance)
{
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_2BUTTON_PRESS);
#else
gevent.button.type = GDK_2BUTTON_PRESS;
#endif
ui->button_click_number = 0;
}
else
{
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_BUTTON_PRESS);
#else
gevent.button.type = GDK_BUTTON_PRESS;
#endif
ui->button_click_number = xevent->xbutton.button;
ui->button_click_window = xevent->xbutton.window;
ui->button_click_time = xevent->xbutton.time;
ui->button_click_x = xevent->xbutton.x;
ui->button_click_y = xevent->xbutton.y;
}
}
else
{
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_BUTTON_RELEASE);
#else
gevent.button.type = GDK_BUTTON_RELEASE;
#endif
}
#if GTK_CHECK_VERSION (3, 0, 0)
gevent->button.window = g_object_ref (gdk_window);
gevent->button.button = xevent->xbutton.button;
gevent->button.time = xevent->xbutton.time;
gevent->button.x = xevent->xbutton.x;
gevent->button.y = xevent->xbutton.y;
gevent->button.x_root = xevent->xbutton.x_root;
gevent->button.y_root = xevent->xbutton.y_root;
#else
gevent.button.window = gdk_window;
gevent.button.button = xevent->xbutton.button;
gevent.button.time = xevent->xbutton.time;
gevent.button.x = xevent->xbutton.x;
gevent.button.y = xevent->xbutton.y;
gevent.button.x_root = xevent->xbutton.x_root;
gevent.button.y_root = xevent->xbutton.y_root;
#endif
break;
case MotionNotify:
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (GDK_MOTION_NOTIFY);
gevent->motion.type = GDK_MOTION_NOTIFY;
gevent->motion.window = g_object_ref (gdk_window);
#else
gevent.motion.type = GDK_MOTION_NOTIFY;
gevent.motion.window = gdk_window;
#endif
break;
case EnterNotify:
case LeaveNotify:
#if GTK_CHECK_VERSION (3, 0, 0)
gevent = gdk_event_new (xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY);
gevent->crossing.window = g_object_ref (gdk_window);
gevent->crossing.x = xevent->xcrossing.x;
gevent->crossing.y = xevent->xcrossing.y;
#else
gevent.crossing.type = xevent->type == EnterNotify ? GDK_ENTER_NOTIFY : GDK_LEAVE_NOTIFY;
gevent.crossing.window = gdk_window;
gevent.crossing.x = xevent->xcrossing.x;
gevent.crossing.y = xevent->xcrossing.y;
#endif
break;
default:
g_assert_not_reached ();
break;
}
/* If we've gotten here, we've filled in the gdk_event and should send it on */
#if GTK_CHECK_VERSION (3, 0, 0)
gdk_event_set_device (gevent, gdevice);
gtk_main_do_event (gevent);
gdk_event_free (gevent);
#else
gtk_main_do_event (&gevent);
#endif
return TRUE;
}
static gboolean
gdk_x11_device_manager_core_translate_event (GdkEventTranslator *translator,
GdkDisplay *display,
GdkEvent *event,
XEvent *xevent)
{
GdkWindowImplX11 *impl;
GdkX11DeviceManagerCore *device_manager;
GdkWindow *window;
gboolean return_val;
int scale;
GdkX11Display *display_x11 = GDK_X11_DISPLAY (display);
device_manager = GDK_X11_DEVICE_MANAGER_CORE (translator);
window = get_event_window (translator, xevent);
scale = 1;
if (window)
{
if (GDK_WINDOW_DESTROYED (window) || !GDK_IS_WINDOW (window))
return FALSE;
g_object_ref (window);
impl = GDK_WINDOW_IMPL_X11 (window->impl);
scale = impl->window_scale;
}
event->any.window = window;
event->any.send_event = xevent->xany.send_event ? TRUE : FALSE;
if (window && GDK_WINDOW_DESTROYED (window))
{
if (xevent->type != DestroyNotify)
{
return_val = FALSE;
goto done;
}
}
if (window &&
(xevent->type == MotionNotify ||
xevent->type == ButtonRelease))
{
if (_gdk_x11_moveresize_handle_event (xevent))
{
return_val = FALSE;
goto done;
}
}
/* We do a "manual" conversion of the XEvent to a
* GdkEvent. The structures are mostly the same so
* the conversion is fairly straightforward. We also
* optionally print debugging info regarding events
* received.
*/
return_val = TRUE;
switch (xevent->type)
{
case KeyPress:
if (window == NULL)
{
return_val = FALSE;
break;
}
translate_key_event (display, device_manager, event, xevent);
set_user_time (window, event);
break;
case KeyRelease:
if (window == NULL)
{
return_val = FALSE;
break;
}
/* Emulate detectable auto-repeat by checking to see
* if the next event is a key press with the same
* keycode and timestamp, and if so, ignoring the event.
*/
if (!display_x11->have_xkb_autorepeat && XPending (xevent->xkey.display))
{
XEvent next_event;
XPeekEvent (xevent->xkey.display, &next_event);
if (next_event.type == KeyPress &&
next_event.xkey.keycode == xevent->xkey.keycode &&
next_event.xkey.time == xevent->xkey.time)
{
return_val = FALSE;
break;
}
}
translate_key_event (display, device_manager, event, xevent);
break;
case ButtonPress:
GDK_NOTE (EVENTS,
g_message ("button press:\t\twindow: %ld x,y: %d %d button: %d",
xevent->xbutton.window,
xevent->xbutton.x, xevent->xbutton.y,
xevent->xbutton.button));
if (window == NULL)
{
return_val = FALSE;
break;
}
/* If we get a ButtonPress event where the button is 4 or 5,
it's a Scroll event */
switch (xevent->xbutton.button)
{
case 4: /* up */
case 5: /* down */
case 6: /* left */
case 7: /* right */
event->scroll.type = GDK_SCROLL;
if (xevent->xbutton.button == 4)
event->scroll.direction = GDK_SCROLL_UP;
else if (xevent->xbutton.button == 5)
event->scroll.direction = GDK_SCROLL_DOWN;
else if (xevent->xbutton.button == 6)
event->scroll.direction = GDK_SCROLL_LEFT;
else
event->scroll.direction = GDK_SCROLL_RIGHT;
event->scroll.window = window;
event->scroll.time = xevent->xbutton.time;
event->scroll.x = (gdouble) xevent->xbutton.x / scale;
event->scroll.y = (gdouble) xevent->xbutton.y / scale;
event->scroll.x_root = (gdouble) xevent->xbutton.x_root / scale;
event->scroll.y_root = (gdouble) xevent->xbutton.y_root / scale;
event->scroll.state = (GdkModifierType) xevent->xbutton.state;
event->scroll.device = device_manager->core_pointer;
event->scroll.delta_x = 0;
event->scroll.delta_y = 0;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
break;
default:
event->button.type = GDK_BUTTON_PRESS;
event->button.window = window;
event->button.time = xevent->xbutton.time;
event->button.x = (gdouble) xevent->xbutton.x / scale;
event->button.y = (gdouble) xevent->xbutton.y / scale;
event->button.x_root = (gdouble) xevent->xbutton.x_root / scale;
event->button.y_root = (gdouble) xevent->xbutton.y_root / scale;
event->button.axes = NULL;
event->button.state = (GdkModifierType) xevent->xbutton.state;
event->button.button = xevent->xbutton.button;
event->button.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
return_val = FALSE;
break;
}
set_user_time (window, event);
break;
case ButtonRelease:
GDK_NOTE (EVENTS,
g_message ("button release:\twindow: %ld x,y: %d %d button: %d",
xevent->xbutton.window,
xevent->xbutton.x, xevent->xbutton.y,
xevent->xbutton.button));
if (window == NULL)
{
return_val = FALSE;
break;
}
/* We treat button presses as scroll wheel events, so ignore the release */
if (xevent->xbutton.button == 4 || xevent->xbutton.button == 5 ||
xevent->xbutton.button == 6 || xevent->xbutton.button == 7)
{
return_val = FALSE;
break;
}
event->button.type = GDK_BUTTON_RELEASE;
event->button.window = window;
event->button.time = xevent->xbutton.time;
event->button.x = (gdouble) xevent->xbutton.x / scale;
event->button.y = (gdouble) xevent->xbutton.y / scale;
event->button.x_root = (gdouble) xevent->xbutton.x_root / scale;
event->button.y_root = (gdouble) xevent->xbutton.y_root / scale;
event->button.axes = NULL;
event->button.state = (GdkModifierType) xevent->xbutton.state;
event->button.button = xevent->xbutton.button;
event->button.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
return_val = FALSE;
break;
case MotionNotify:
GDK_NOTE (EVENTS,
g_message ("motion notify:\t\twindow: %ld x,y: %d %d hint: %s",
xevent->xmotion.window,
xevent->xmotion.x, xevent->xmotion.y,
(xevent->xmotion.is_hint) ? "true" : "false"));
if (window == NULL)
{
return_val = FALSE;
break;
}
event->motion.type = GDK_MOTION_NOTIFY;
event->motion.window = window;
event->motion.time = xevent->xmotion.time;
event->motion.x = (gdouble) xevent->xmotion.x / scale;
event->motion.y = (gdouble) xevent->xmotion.y / scale;
event->motion.x_root = (gdouble) xevent->xmotion.x_root / scale;
event->motion.y_root = (gdouble) xevent->xmotion.y_root / scale;
event->motion.axes = NULL;
event->motion.state = (GdkModifierType) xevent->xmotion.state;
event->motion.is_hint = xevent->xmotion.is_hint;
event->motion.device = device_manager->core_pointer;
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
break;
case EnterNotify:
GDK_NOTE (EVENTS,
g_message ("enter notify:\t\twindow: %ld detail: %d subwin: %ld",
xevent->xcrossing.window,
xevent->xcrossing.detail,
xevent->xcrossing.subwindow));
if (window == NULL)
{
return_val = FALSE;
break;
}
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
event->crossing.type = GDK_ENTER_NOTIFY;
event->crossing.window = window;
gdk_event_set_device (event, device_manager->core_pointer);
/* If the subwindow field of the XEvent is non-NULL, then
* lookup the corresponding GdkWindow.
*/
if (xevent->xcrossing.subwindow != None)
event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
else
event->crossing.subwindow = NULL;
event->crossing.time = xevent->xcrossing.time;
event->crossing.x = (gdouble) xevent->xcrossing.x / scale;
event->crossing.y = (gdouble) xevent->xcrossing.y / scale;
event->crossing.x_root = (gdouble) xevent->xcrossing.x_root / scale;
event->crossing.y_root = (gdouble) xevent->xcrossing.y_root / scale;
event->crossing.mode = translate_crossing_mode (xevent->xcrossing.mode);
event->crossing.detail = translate_notify_type (xevent->xcrossing.detail);
event->crossing.focus = xevent->xcrossing.focus;
event->crossing.state = xevent->xcrossing.state;
break;
case LeaveNotify:
GDK_NOTE (EVENTS,
g_message ("leave notify:\t\twindow: %ld detail: %d subwin: %ld",
xevent->xcrossing.window,
xevent->xcrossing.detail, xevent->xcrossing.subwindow));
if (window == NULL)
{
return_val = FALSE;
break;
}
if (!set_screen_from_root (display, event, xevent->xbutton.root))
{
return_val = FALSE;
break;
}
event->crossing.type = GDK_LEAVE_NOTIFY;
event->crossing.window = window;
gdk_event_set_device (event, device_manager->core_pointer);
/* If the subwindow field of the XEvent is non-NULL, then
* lookup the corresponding GdkWindow.
*/
if (xevent->xcrossing.subwindow != None)
event->crossing.subwindow = gdk_x11_window_lookup_for_display (display, xevent->xcrossing.subwindow);
else
event->crossing.subwindow = NULL;
event->crossing.time = xevent->xcrossing.time;
event->crossing.x = (gdouble) xevent->xcrossing.x / scale;
event->crossing.y = (gdouble) xevent->xcrossing.y / scale;
event->crossing.x_root = (gdouble) xevent->xcrossing.x_root / scale;
event->crossing.y_root = (gdouble) xevent->xcrossing.y_root / scale;
event->crossing.mode = translate_crossing_mode (xevent->xcrossing.mode);
event->crossing.detail = translate_notify_type (xevent->xcrossing.detail);
event->crossing.focus = xevent->xcrossing.focus;
event->crossing.state = xevent->xcrossing.state;
break;
case FocusIn:
case FocusOut:
if (window)
_gdk_device_manager_core_handle_focus (window,
xevent->xfocus.window,
device_manager->core_keyboard,
NULL,
xevent->type == FocusIn,
xevent->xfocus.detail,
xevent->xfocus.mode);
return_val = FALSE;
break;
default:
return_val = FALSE;
}
done:
if (return_val)
{
if (event->any.window)
g_object_ref (event->any.window);
if (((event->any.type == GDK_ENTER_NOTIFY) ||
(event->any.type == GDK_LEAVE_NOTIFY)) &&
(event->crossing.subwindow != NULL))
g_object_ref (event->crossing.subwindow);
}
else
{
/* Mark this event as having no resources to be freed */
event->any.window = NULL;
event->any.type = GDK_NOTHING;
}
if (window)
g_object_unref (window);
return return_val;
}
gboolean
_gdk_input_other_event (GdkEvent *event,
MSG *msg,
GdkWindow *window)
{
GdkDisplay *display;
GdkDeviceWintab *device = NULL;
GdkDeviceGrabInfo *last_grab;
GdkEventMask masktest;
guint key_state;
POINT pt;
PACKET packet;
gdouble 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;
}
window = gdk_window_at_pointer (&x, &y);
if (window == NULL)
window = _gdk_root;
g_object_ref (window);
display = gdk_window_get_display (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)
{
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 ((device = _gdk_device_manager_find_wintab_device ((HCTX) msg->lParam,
packet.pkCursor)) == NULL)
return FALSE;
if (gdk_device_get_mode (GDK_DEVICE (device)) == GDK_MODE_DISABLED)
return FALSE;
last_grab = _gdk_display_get_last_device_grab (_gdk_display, GDK_DEVICE (device));
if (last_grab && last_grab->window)
{
g_object_unref (window);
window = g_object_ref (last_grab->window);
}
if (window == _gdk_root)
{
GDK_NOTE (EVENTS_OR_INPUT, g_print ("... is root\n"));
return FALSE;
}
num_axes = 0;
if (device->pktdata & PK_X)
device->last_axis_data[num_axes++] = packet.pkX;
if (device->pktdata & PK_Y)
device->last_axis_data[num_axes++] = packet.pkY;
if (device->pktdata & PK_NORMAL_PRESSURE)
device->last_axis_data[num_axes++] = packet.pkNormalPressure;
if (device->pktdata & PK_ORIENTATION)
{
decode_tilt (device->last_axis_data + num_axes,
device->orientation_axes, &packet);
num_axes += 2;
}
translated_buttons = button_map[packet.pkButtons & 0x07] | (packet.pkButtons & ~0x07);
if (translated_buttons != 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 ^ 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;
}
device->button_state ^= button_mask;
}
else
{
event->any.type = GDK_MOTION_NOTIFY;
masktest = GDK_POINTER_MOTION_MASK;
if (device->button_state & (1 << 0))
masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON1_MOTION_MASK;
if (device->button_state & (1 << 1))
masktest |= GDK_BUTTON_MOTION_MASK | GDK_BUTTON2_MOTION_MASK;
if (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 (device)) == 0)
{
GDK_NOTE (EVENTS_OR_INPUT, g_print ("... not selected\n"));
if (window->parent == GDK_WINDOW (_gdk_root))
return FALSE;
/* It is not good to propagate the extended events up to the parent
* if this window wants normal (not extended) motion/button events */
if (window->event_mask & masktest)
{
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("... wants ordinary event, ignoring this\n"));
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));
}
if (gdk_window_get_device_events (window, GDK_DEVICE (device)) == 0)
return FALSE;
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);
gdk_event_set_device (event, GDK_DEVICE (device));
event->button.axes = g_new (gdouble, num_axes);
_gdk_device_wintab_get_window_coords (window, &root_x, &root_y);
_gdk_device_wintab_translate_axes (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 | ((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, GDK_DEVICE (device));
event->motion.axes = g_new (gdouble, num_axes);
_gdk_device_wintab_get_window_coords (window, &root_x, &root_y);
_gdk_device_wintab_translate_axes (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 | ((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_PROXIMITY:
if (LOWORD (msg->lParam) == 0)
{
event->proximity.type = GDK_PROXIMITY_OUT;
set_ignore_core (FALSE);
}
else
{
event->proximity.type = GDK_PROXIMITY_IN;
set_ignore_core (TRUE);
}
event->proximity.time = _gdk_win32_get_next_tick (msg->time);
gdk_event_set_device (event, GDK_DEVICE (device));
GDK_NOTE (EVENTS_OR_INPUT,
g_print ("WINTAB proximity %s\n",
(event->proximity.type == GDK_PROXIMITY_IN ?
"in" : "out")));
return TRUE;
}
return FALSE;
}
