static void
gdk_broadway_display_init_input (GdkDisplay *display)
{
GdkBroadwayDisplay *broadway_display;
GdkDeviceManager *device_manager;
GdkDevice *device;
GList *list, *l;
broadway_display = GDK_BROADWAY_DISPLAY (display);
device_manager = gdk_display_get_device_manager (display);
/* For backwards compatibility, just add
* floating devices that are not keyboards.
*/
list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_FLOATING);
for (l = list; l; l = l->next)
{
device = l->data;
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
continue;
broadway_display->input_devices = g_list_prepend (broadway_display->input_devices,
g_object_ref (l->data));
}
g_list_free (list);
/* Now set "core" pointer to the first
* master device that is a pointer.
*/
list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
for (l = list; l; l = l->next)
{
device = l->data;
if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
continue;
display->core_pointer = device;
break;
}
/* Add the core pointer to the devices list */
broadway_display->input_devices = g_list_prepend (broadway_display->input_devices,
g_object_ref (display->core_pointer));
g_list_free (list);
}
static GdkGrabStatus
gdk_broadway_device_grab (GdkDevice *device,
GdkWindow *window,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time_)
{
GdkDisplay *display;
GdkBroadwayDisplay *broadway_display;
display = gdk_device_get_display (device);
broadway_display = GDK_BROADWAY_DISPLAY (display);
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
/* Device is a keyboard */
return GDK_GRAB_SUCCESS;
}
else
{
/* Device is a pointer */
return _gdk_broadway_server_grab_pointer (broadway_display->server,
GDK_WINDOW_IMPL_BROADWAY (window->impl)->id,
owner_events,
event_mask,
time_);
}
}
static void
grab_window_toggled (GtkToggleButton *button,
GtkWidget *widget)
{
GdkDevice *device = gtk_get_current_event_device ();
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
if (gtk_toggle_button_get_active (button))
{
int status;
status = gdk_device_grab (device,
gtk_widget_get_window (widget),
GDK_OWNERSHIP_NONE,
FALSE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL,
GDK_CURRENT_TIME);
if (status != GDK_GRAB_SUCCESS)
g_warning ("Could not grab keyboard! (%s)", grab_string (status));
}
else
{
gdk_device_ungrab (device, GDK_CURRENT_TIME);
}
}
static void
gdk_broadway_device_ungrab (GdkDevice *device,
guint32 time_)
{
GdkDisplay *display;
GdkBroadwayDisplay *broadway_display;
GdkDeviceGrabInfo *grab;
guint32 serial;
display = gdk_device_get_display (device);
broadway_display = GDK_BROADWAY_DISPLAY (display);
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
/* Device is a keyboard */
}
else
{
/* Device is a pointer */
if (broadway_display->output)
{
serial = broadway_output_ungrab_pointer (broadway_display->output, time_);
gdk_display_flush (display);
grab = _gdk_display_get_last_device_grab (display, device);
if (grab &&
(time_ == GDK_CURRENT_TIME ||
grab->time == GDK_CURRENT_TIME ||
!TIME_IS_LATER (grab->time, time_)))
grab->serial_end = serial;
}
}
}
void
gimp_device_info_get_time_coords (GimpDeviceInfo *info,
GdkTimeCoord *event,
GimpCoords *coords)
{
*coords = default_coords;
gdk_device_get_axis (info->device, event->axes, GDK_AXIS_X, &coords->x);
gdk_device_get_axis (info->device, event->axes, GDK_AXIS_Y, &coords->y);
/* CLAMP() the return value of each *_get_axis() call to be safe
* against buggy XInput drivers.
*/
if (gdk_device_get_axis (info->device,
event->axes, GDK_AXIS_PRESSURE, &coords->pressure))
{
coords->pressure = gimp_device_info_map_axis (info,
GDK_AXIS_PRESSURE,
coords->pressure);
}
if (gdk_device_get_axis (info->device,
event->axes, GDK_AXIS_XTILT, &coords->xtilt))
{
coords->xtilt = gimp_device_info_map_axis (info,
GDK_AXIS_XTILT,
coords->xtilt);
}
if (gdk_device_get_axis (info->device,
event->axes, GDK_AXIS_YTILT, &coords->ytilt))
{
coords->ytilt = gimp_device_info_map_axis (info,
GDK_AXIS_YTILT,
coords->ytilt);
}
if (gdk_device_get_axis (info->device,
event->axes, GDK_AXIS_WHEEL, &coords->wheel))
{
coords->wheel = gimp_device_info_map_axis (info,
GDK_AXIS_WHEEL,
coords->wheel);
}
if (gimp_device_info_get_mode (info) != GDK_MODE_DISABLED &&
gdk_device_get_source (info->device) != GDK_SOURCE_MOUSE)
{
/* The event was generated by an enabled extended non-mouse device */
coords->extended = TRUE;
}
else
{
/* The event was generated by a not extended enabled device */
coords->extended = FALSE;
}
}
void
gimp_device_info_get_device_coords (GimpDeviceInfo *info,
GdkWindow *window,
GimpCoords *coords)
{
gdouble axes[GDK_AXIS_LAST] = { 0, };
*coords = default_coords;
gdk_device_get_state (info->device, window, axes, NULL);
gdk_device_get_axis (info->device, axes, GDK_AXIS_X, &coords->x);
gdk_device_get_axis (info->device, axes, GDK_AXIS_Y, &coords->y);
if (gdk_device_get_axis (info->device,
axes, GDK_AXIS_PRESSURE, &coords->pressure))
{
coords->pressure = gimp_device_info_map_axis (info,
GDK_AXIS_PRESSURE,
coords->pressure);
}
if (gdk_device_get_axis (info->device,
axes, GDK_AXIS_XTILT, &coords->xtilt))
{
coords->xtilt = gimp_device_info_map_axis (info,
GDK_AXIS_XTILT,
coords->xtilt);
}
if (gdk_device_get_axis (info->device,
axes, GDK_AXIS_YTILT, &coords->ytilt))
{
coords->ytilt = gimp_device_info_map_axis (info,
GDK_AXIS_YTILT,
coords->ytilt);
}
if (gdk_device_get_axis (info->device,
axes, GDK_AXIS_WHEEL, &coords->wheel))
{
coords->wheel = gimp_device_info_map_axis (info,
GDK_AXIS_WHEEL,
coords->wheel);
}
if (gimp_device_info_get_mode (info) != GDK_MODE_DISABLED &&
gdk_device_get_source (info->device) != GDK_SOURCE_MOUSE)
{
/* The event was generated by an enabled extended non-mouse device */
coords->extended = TRUE;
}
else
{
/* The event was generated by a not extended enabled device */
coords->extended = FALSE;
}
}
static gboolean
grab_keyboard (GtkWidget *win, GdkEvent *event, gpointer data)
{
GdkGrabStatus status;
#if GTK_CHECK_VERSION (3,0,0)
GdkDevice *device;
GdkDeviceManager *manager;
GdkDisplay *display;
GList *devices, *l;
guint32 at;
if (grabbed_device || !GRAB_KEYBOARD)
return FALSE;
display = gtk_widget_get_display (win);
manager = gdk_display_get_device_manager (display);
devices = gdk_device_manager_list_devices (manager, GDK_DEVICE_TYPE_MASTER);
for (l = devices; l; l = g_list_next (l)) {
device = l->data;
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
break;
}
g_list_free (devices);
if (!device) {
g_message ("couldn't find device to grab");
return FALSE;
}
at = gdk_event_get_time (event);
status = gdk_device_grab (device, gtk_widget_get_window (win),
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS | GDK_KEY_RELEASE, NULL, at);
if (status == GDK_GRAB_SUCCESS) {
grab_broken_id = g_signal_connect (win, "grab-broken-event",
G_CALLBACK (on_grab_broken), NULL);
gtk_device_grab_add (win, device, TRUE);
grabbed_device = device;
grabbed_at = at;
} else {
g_message ("could not grab keyboard: %d", (int)status);
}
#else
if (!keyboard_grabbed && GRAB_KEYBOARD) {
status = gdk_keyboard_grab (gtk_widget_get_window (win), FALSE, gdk_event_get_time (event));
if (status == GDK_GRAB_SUCCESS) {
keyboard_grabbed = TRUE;
} else {
g_message ("could not grab keyboard: %d", (int)status);
}
}
#endif
/* Always return false, so event is handled elsewhere */
return FALSE;
}
static GdkGrabStatus
gdk_broadway_device_grab (GdkDevice *device,
GdkWindow *window,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time_)
{
GdkDisplay *display;
GdkBroadwayDisplay *broadway_display;
GdkWindowImplBroadway *impl;
guint32 serial;
char *reply;
display = gdk_device_get_display (device);
broadway_display = GDK_BROADWAY_DISPLAY (display);
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
/* Device is a keyboard */
return GDK_GRAB_SUCCESS;
}
else
{
/* Device is a pointer */
if (broadway_display->output)
{
impl = GDK_WINDOW_IMPL_BROADWAY (window->impl);
serial = broadway_output_grab_pointer (broadway_display->output,
impl->id, owner_events, time_);
reply = _gdk_broadway_display_block_for_input (display, 'g', serial, FALSE);
if (reply != NULL)
{
char *p;
char cmd;
guint32 reply_serial;
int res;
p = reply;
cmd = *p++;
reply_serial = (guint32)strtol(p, &p, 10);
p++; /* Skip , */
res = strtol(p, &p, 10);
return res;
}
}
return GDK_GRAB_NOT_VIEWABLE;
}
}
gboolean on_buttonpress (GtkWidget *win,
GdkEventButton *ev,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
gdouble pressure = 0.5;
/* get the data for this device */
GdkDevice *master = ev->device;
GromitDeviceData *masterdata =
g_hash_table_lookup(data->devdatatable, master);
GdkDevice *slave =
gdk_event_get_source_device ((GdkEvent *) ev);
GromitDeviceData *slavedata =
g_hash_table_lookup(data->devdatatable, slave);
if(data->debug)
g_printerr("DEBUG: Device '%s': Button %i Down at (x,y)=(%.2f : %.2f)\n",
gdk_device_get_name(slave), ev->button, ev->x, ev->y);
if (!masterdata->is_grabbed)
return FALSE;
/* See GdkModifierType. Am I fixing a Gtk misbehaviour??? */
ev->state |= 1 << (ev->button + 7);
if (ev->state != masterdata->state ||
ev->state != slavedata->state ||
masterdata->lastslave != slave)
select_tool (data, master, slave, ev->state);
slavedata->lastx = ev->x;
slavedata->lasty = ev->y;
slavedata->motion_time = ev->time;
snap_undo_state (data);
if (gdk_device_get_source(slave) == GDK_SOURCE_MOUSE)
{
data->maxwidth = slavedata->cur_context->width;
}
else
{
gdk_event_get_axis ((GdkEvent *) ev, GDK_AXIS_PRESSURE, &pressure);
data->maxwidth = (CLAMP (pressure + line_thickener, 0, 1) *
(double) (slavedata->cur_context->width -
slavedata->cur_context->minwidth) +
slavedata->cur_context->minwidth);
}
if (ev->button <= 5)
draw_line (data, slave, ev->x, ev->y, ev->x, ev->y);
coord_list_prepend (data, slave, ev->x, ev->y, data->maxwidth);
return TRUE;
}
void
_gtk_tooltip_focus_in (GtkWidget *widget)
{
gint x, y;
gboolean return_value = FALSE;
GdkDisplay *display;
GtkTooltip *tooltip;
GdkDevice *device;
/* Get current tooltip for this display */
display = gtk_widget_get_display (widget);
tooltip = g_object_get_data (G_OBJECT (display),
"gdk-display-current-tooltip");
/* Check if keyboard mode is enabled at this moment */
if (!tooltip || !tooltip->keyboard_mode_enabled)
return;
device = gtk_get_current_event_device ();
if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
/* This function should be called by either a focus in event,
* or a key binding. In either case there should be a device.
*/
if (!device)
return;
if (tooltip->keyboard_widget)
g_object_unref (tooltip->keyboard_widget);
tooltip->keyboard_widget = g_object_ref (widget);
gdk_window_get_device_position (gtk_widget_get_window (widget),
device, &x, &y, NULL);
return_value = gtk_tooltip_run_requery (&widget, tooltip, &x, &y);
if (!return_value)
{
gtk_tooltip_hide_tooltip (tooltip);
return;
}
if (!tooltip->current_window)
{
if (gtk_widget_get_tooltip_window (widget))
tooltip->current_window = gtk_widget_get_tooltip_window (widget);
else
tooltip->current_window = GTK_WINDOW (GTK_TOOLTIP (tooltip)->window);
}
gtk_tooltip_show_tooltip (display);
}
static GdkGrabStatus
gdk_device_win32_grab (GdkDevice *device,
GdkWindow *window,
gboolean owner_events,
GdkEventMask event_mask,
GdkWindow *confine_to,
GdkCursor *cursor,
guint32 time_)
{
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
SetCapture (GDK_WINDOW_HWND (window));
return GDK_GRAB_SUCCESS;
}
static void
gtk_real_button_activate (GtkButton *button)
{
GtkWidget *widget = GTK_WIDGET (button);
GtkButtonPrivate *priv = button->priv;
GdkDevice *device;
device = gtk_get_current_event_device ();
if (device && gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
if (gtk_widget_get_realized (widget) && !priv->activate_timeout)
{
/* bgo#626336 - Only grab if we have a device (from an event), not if we
* were activated programmatically when no event is available.
*/
if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
{
if (gdk_seat_grab (gdk_device_get_seat (device), priv->event_window,
GDK_SEAT_CAPABILITY_KEYBOARD, TRUE,
NULL, NULL, NULL, NULL) == GDK_GRAB_SUCCESS)
{
gtk_device_grab_add (widget, device, TRUE);
priv->grab_keyboard = device;
}
}
priv->activate_timeout = gdk_threads_add_timeout (ACTIVATE_TIMEOUT,
button_activate_timeout,
button);
g_source_set_name_by_id (priv->activate_timeout, "[gtk+] button_activate_timeout");
priv->button_down = TRUE;
gtk_button_update_state (button);
}
}
void on_device_added (GdkDeviceManager *device_manager,
GdkDevice *device,
gpointer user_data)
{
GromitData *data = (GromitData *) user_data;
GdkInputSource hardware_type = gdk_device_get_source(device);
if( hardware_type == GDK_SOURCE_KEYBOARD ||
gdk_device_get_n_axes(device) < 2)
return;
if(data->debug)
g_printerr("DEBUG: device '%s' added\n", gdk_device_get_name(device));
setup_input_devices(data);
}
/* 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);
}
static gboolean
tooltips_enabled (GdkEvent *event)
{
GdkDevice *source_device;
GdkInputSource source;
source_device = gdk_event_get_source_device (event);
if (!source_device)
return FALSE;
source = gdk_device_get_source (source_device);
if (source != GDK_SOURCE_TOUCHSCREEN)
return TRUE;
return FALSE;
}
static void on_pointer_press(GtkWidget *widget, GdkEventButton *event, gpointer data)
{
// Hide the volume scale
hide_volume_scale();
// Find the pointer device, if possible
GdkDevice *device = gtk_get_current_event_device();
if (device && gdk_device_get_source(device) == GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device(device);
if (!device) {
g_printerr("Failed to find the pointer device\n");
return;
}
// Ungrab it
gdk_device_ungrab(device, GDK_CURRENT_TIME);
gdk_flush();
}
static void
gdk_device_win32_ungrab (GdkDevice *device,
guint32 time_)
{
GdkDeviceGrabInfo *info;
GdkDisplay *display;
display = gdk_device_get_display (device);
info = _gdk_display_get_last_device_grab (display, device);
if (info)
info->serial_end = 0;
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
ReleaseCapture ();
_gdk_display_device_grab_update (display, device, NULL, 0);
}
JS_EXPORT_API
void guide_disable_keyboard()
{
// gdk_keyboard_grab(gtk_widget_get_window(get_container()), FALSE, GDK_CURRENT_TIME);
GdkWindow* window = gtk_widget_get_window(get_container());
GdkDisplay* display = gdk_window_get_display(window);
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GList* devices = gdk_device_manager_list_devices(manager, GDK_DEVICE_TYPE_MASTER);
GdkDevice* device = NULL;
for (GList* dev = devices; dev != NULL; dev = dev->next) {
device = GDK_DEVICE(dev->data);
if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD) {
continue;
}
GdkGrabStatus res = gdk_device_grab(device,
window,
GDK_OWNERSHIP_NONE,
FALSE,
GDK_KEY_PRESS_MASK|GDK_KEY_RELEASE_MASK,
NULL,
GDK_CURRENT_TIME
);
switch (res) {
case GDK_GRAB_ALREADY_GRABBED:
g_warning("Grab falied, device %s is already grabbed.", gdk_device_get_name(device));
break;
case GDK_GRAB_INVALID_TIME:
g_warning("Grab failed, the resource is grabbed more recently than the specified time.");
break;
case GDK_GRAB_NOT_VIEWABLE:
g_warning("Grab falied, the window is not viewable.");
break;
case GDK_GRAB_FROZEN:
g_warning("Grab falied, the resources is frozen.");
break;
case GDK_GRAB_SUCCESS:
break;
}
}
g_list_free(devices);
}
void
gimp_device_info_set_default_tool (GimpDeviceInfo *info)
{
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
if (info->device &&
gdk_device_get_source (info->device) == GDK_SOURCE_ERASER)
{
GimpContainer *tools = GIMP_CONTEXT (info)->gimp->tool_info_list;
GimpToolInfo *eraser;
eraser =
GIMP_TOOL_INFO (gimp_container_get_child_by_name (tools,
"gimp-eraser-tool"));
if (eraser)
gimp_context_set_tool (GIMP_CONTEXT (info), eraser);
}
}
static gboolean
photos_preview_nav_buttons_motion_notify (PhotosPreviewNavButtons *self, GdkEventMotion *event)
{
GdkDevice *device;
GdkInputSource input_source;
if (self->motion_id != 0)
return FALSE;
device = gdk_event_get_source_device ((GdkEvent *) event);
input_source = gdk_device_get_source (device);
if (input_source == GDK_SOURCE_TOUCHSCREEN)
return FALSE;
self->motion_id = g_idle_add_full (G_PRIORITY_DEFAULT,
(GSourceFunc) photos_preview_nav_buttons_motion_notify_timeout,
g_object_ref (self),
g_object_unref);
return FALSE;
}
JS_EXPORT_API
void guide_enable_keyboard()
{
// gdk_keyboard_ungrab(GDK_CURRENT_TIME);
GdkWindow* window = gtk_widget_get_window(get_container());
GdkDisplay* display = gdk_window_get_display(window);
GdkDeviceManager* manager = gdk_display_get_device_manager(display);
GList* devices = gdk_device_manager_list_devices(manager, GDK_DEVICE_TYPE_MASTER);
GdkDevice* device = NULL;
for (GList* dev = devices; dev != NULL; dev = dev->next) {
device = GDK_DEVICE(dev->data);
if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD) {
continue;
}
gdk_device_ungrab(device, GDK_CURRENT_TIME);
}
g_list_free(devices);
}
void show_volume_scale(GdkRectangle *rect_or_null)
{
// Actually show the volume scale
do_show_volume_scale(rect_or_null);
// Find the pointer device, if possible
GdkDevice *device = gtk_get_current_event_device();
if (device && gdk_device_get_source(device) == GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device(device);
if (!device) {
g_printerr("Failed to find the pointer device\n");
return;
}
// Grab it so we can hide the scale when the user clicks outside it
g_signal_connect_after(G_OBJECT(window), "button_press_event", G_CALLBACK(on_pointer_press), NULL);
gdk_device_grab(device, gtk_widget_get_window(window), GDK_OWNERSHIP_NONE,
TRUE, GDK_BUTTON_PRESS_MASK, NULL, GDK_CURRENT_TIME);
gdk_flush();
}
/**
* gdk_x11_device_get_id:
* @device: (type GdkX11DeviceCore): a #GdkDevice
*
* Returns the device ID as seen by XInput2.
*
* > If gdk_disable_multidevice() has been called, this function
* > will respectively return 2/3 for the core pointer and keyboard,
* > (matching the IDs for the Virtual Core Pointer and Keyboard in
* > XInput 2), but calling this function on any slave devices (i.e.
* > those managed via XInput 1.x), will return 0.
*
* Returns: the XInput2 device ID.
*
* Since: 3.2
**/
gint
gdk_x11_device_get_id (GdkDevice *device)
{
gint device_id = 0;
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
#ifdef XINPUT_2
if (GDK_IS_X11_DEVICE_XI2 (device))
device_id = _gdk_x11_device_xi2_get_id (GDK_X11_DEVICE_XI2 (device));
else
#endif /* XINPUT_2 */
if (GDK_IS_X11_DEVICE_CORE (device))
{
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
device_id = VIRTUAL_CORE_KEYBOARD_ID;
else
device_id = VIRTUAL_CORE_POINTER_ID;
}
return device_id;
}
static GdkKeymap *
_gdk_wayland_display_get_keymap (GdkDisplay *display)
{
GdkDeviceManager *device_manager;
GList *list, *l;
GdkDevice *core_keyboard = NULL;
static GdkKeymap *tmp_keymap = NULL;
device_manager = gdk_display_get_device_manager (display);
list = gdk_device_manager_list_devices (device_manager, GDK_DEVICE_TYPE_MASTER);
for (l = list; l; l = l->next)
{
GdkDevice *device;
device = l->data;
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD)
continue;
core_keyboard = device;
break;
}
g_list_free (list);
if (core_keyboard && tmp_keymap)
{
g_object_unref (tmp_keymap);
tmp_keymap = NULL;
}
if (core_keyboard)
return _gdk_wayland_device_get_keymap (core_keyboard);
if (!tmp_keymap)
tmp_keymap = _gdk_wayland_keymap_new ();
return tmp_keymap;
}
static void
emoticon_tool_button_popup (EEmoticonToolButton *button)
{
GtkToggleToolButton *tool_button;
GdkWindow *window;
gboolean grab_status;
GdkDevice *device, *mouse, *keyboard;
guint32 activate_time;
device = gtk_get_current_event_device ();
g_return_if_fail (device != NULL);
if (!gtk_widget_get_realized (GTK_WIDGET (button)))
return;
if (button->priv->popup_shown)
return;
activate_time = gtk_get_current_event_time ();
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) {
keyboard = device;
mouse = gdk_device_get_associated_device (device);
} else {
keyboard = gdk_device_get_associated_device (device);
mouse = device;
}
/* Position the window over the button. */
emoticon_tool_button_reposition_window (button);
/* Show the pop-up. */
gtk_widget_show (button->priv->window);
gtk_widget_grab_focus (button->priv->window);
/* Activate the tool button. */
tool_button = GTK_TOGGLE_TOOL_BUTTON (button);
gtk_toggle_tool_button_set_active (tool_button, TRUE);
/* Try to grab the pointer and keyboard. */
window = gtk_widget_get_window (button->priv->window);
grab_status = !keyboard ||
gdk_device_grab (
keyboard, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, activate_time) == GDK_GRAB_SUCCESS;
if (grab_status) {
grab_status = !mouse ||
gdk_device_grab (mouse, window,
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
NULL, activate_time) == GDK_GRAB_SUCCESS;
if (!grab_status && keyboard)
gdk_device_ungrab (keyboard, activate_time);
}
if (grab_status) {
gtk_device_grab_add (button->priv->window, mouse, TRUE);
button->priv->grab_keyboard = keyboard;
button->priv->grab_mouse = mouse;
} else {
gtk_widget_hide (button->priv->window);
}
}
gboolean
gimp_device_info_get_event_coords (GimpDeviceInfo *info,
GdkWindow *window,
const GdkEvent *event,
GimpCoords *coords)
{
gdouble x;
if (gdk_event_get_axis (event, GDK_AXIS_X, &x))
{
*coords = default_coords;
coords->x = x;
gdk_event_get_axis (event, GDK_AXIS_Y, &coords->y);
/* translate event coordinates to window coordinates, only
* happens if we drag a guide from a ruler
*/
if (event->any.window &&
event->any.window != window)
{
GtkWidget *src_widget;
GtkWidget *dest_widget;
src_widget = gtk_get_event_widget ((GdkEvent *) event);
gdk_window_get_user_data (window, (gpointer) &dest_widget);
if (src_widget && dest_widget)
{
gint offset_x;
gint offset_y;
if (gtk_widget_translate_coordinates (src_widget, dest_widget,
0, 0,
&offset_x, &offset_y))
{
coords->x += offset_x;
coords->y += offset_y;
}
}
}
if (gdk_event_get_axis (event, GDK_AXIS_PRESSURE, &coords->pressure))
{
coords->pressure = gimp_device_info_map_axis (info,
GDK_AXIS_PRESSURE,
coords->pressure);
}
if (gdk_event_get_axis (event, GDK_AXIS_XTILT, &coords->xtilt))
{
coords->xtilt = gimp_device_info_map_axis (info,
GDK_AXIS_XTILT,
coords->xtilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_YTILT, &coords->ytilt))
{
coords->ytilt = gimp_device_info_map_axis (info,
GDK_AXIS_YTILT,
coords->ytilt);
}
if (gdk_event_get_axis (event, GDK_AXIS_WHEEL, &coords->wheel))
{
coords->wheel = gimp_device_info_map_axis (info,
GDK_AXIS_WHEEL,
coords->wheel);
}
if (gimp_device_info_get_mode (info) != GDK_MODE_DISABLED &&
gdk_device_get_source (info->device) != GDK_SOURCE_MOUSE)
{
/* The event was generated by an enabled extended non-mouse device */
coords->extended = TRUE;
}
else
{
/* The event was generated by a not extended enabled device */
coords->extended = FALSE;
}
return TRUE;
}
gimp_device_info_get_device_coords (info, window, coords);
return FALSE;
}
static gboolean
gdk_broadway_device_query_state (GdkDevice *device,
GdkWindow *window,
GdkWindow **root_window,
GdkWindow **child_window,
gint *root_x,
gint *root_y,
gint *win_x,
gint *win_y,
GdkModifierType *mask)
{
GdkDisplay *display;
GdkBroadwayDisplay *broadway_display;
GdkWindowImplBroadway *impl;
guint32 serial;
GdkScreen *screen;
char *reply;
gint device_root_x, device_root_y, device_win_x, device_win_y, id;
if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
return FALSE;
display = gdk_device_get_display (device);
broadway_display = GDK_BROADWAY_DISPLAY (display);
if (root_window)
{
screen = gdk_window_get_screen (window);
*root_window = gdk_screen_get_root_window (screen);
}
if (mask)
*mask = 0; /* TODO */
if (broadway_display->output)
{
impl = GDK_WINDOW_IMPL_BROADWAY (window->impl);
serial = broadway_output_query_pointer (broadway_display->output, impl->id);
reply = _gdk_broadway_display_block_for_input (display, 'q', serial, TRUE);
if (reply != NULL)
{
char *p;
char cmd;
guint32 reply_serial;
p = reply;
cmd = *p++;
reply_serial = (guint32)strtol(p, &p, 10);
p++; /* Skip , */
device_root_x = strtol(p, &p, 10);
p++; /* Skip , */
device_root_y = strtol(p, &p, 10);
p++; /* Skip , */
device_win_x = strtol(p, &p, 10);
p++; /* Skip , */
device_win_y = strtol(p, &p, 10);
p++; /* Skip , */
id = strtol(p, &p, 10);
if (root_x)
*root_x = device_root_x;
if (root_y)
*root_y = device_root_y;
if (win_x)
*win_x = device_win_x;
if (win_y)
*win_y = device_win_y;
if (child_window)
{
if (gdk_window_get_window_type (window) == GDK_WINDOW_ROOT)
*child_window = g_hash_table_lookup (broadway_display->id_ht, GINT_TO_POINTER (id));
else
*child_window = window; /* No native children */
}
g_free (reply);
return TRUE;
}
}
/* Fallback when unconnected */
device_root_x = broadway_display->last_x;
device_root_y = broadway_display->last_y;
if (root_x)
*root_x = device_root_x;
if (root_y)
*root_y = device_root_y;
if (win_x)
*win_x = device_root_y - window->x;
if (win_y)
*win_y = device_root_y - window->y;
if (child_window)
{
if (gdk_window_get_window_type (window) == GDK_WINDOW_ROOT)
{
*child_window = broadway_display->mouse_in_toplevel;
if (*child_window == NULL)
*child_window = window;
}
else
{
/* No native children */
*child_window = window;
}
}
return TRUE;
}
static void
gdk_broadway_device_query_state (GdkDevice *device,
GdkWindow *window,
GdkWindow **root_window,
GdkWindow **child_window,
gdouble *root_x,
gdouble *root_y,
gdouble *win_x,
gdouble *win_y,
GdkModifierType *mask)
{
GdkWindow *toplevel;
GdkWindowImplBroadway *impl;
GdkDisplay *display;
GdkBroadwayDisplay *broadway_display;
GdkScreen *screen;
gint32 device_root_x, device_root_y;
guint32 mouse_toplevel_id;
GdkWindow *mouse_toplevel;
guint32 mask32;
if (gdk_device_get_source (device) != GDK_SOURCE_MOUSE)
return;
display = gdk_device_get_display (device);
broadway_display = GDK_BROADWAY_DISPLAY (display);
impl = GDK_WINDOW_IMPL_BROADWAY (window->impl);
toplevel = impl->wrapper;
if (root_window)
{
screen = gdk_window_get_screen (window);
*root_window = gdk_screen_get_root_window (screen);
}
_gdk_broadway_server_query_mouse (broadway_display->server,
&mouse_toplevel_id,
&device_root_x,
&device_root_y,
&mask32);
mouse_toplevel = g_hash_table_lookup (broadway_display->id_ht, GUINT_TO_POINTER (mouse_toplevel_id));
if (root_x)
*root_x = device_root_x;
if (root_y)
*root_y = device_root_y;
if (win_x)
*win_x = device_root_x - toplevel->x;
if (win_y)
*win_y = device_root_y - toplevel->y;
if (mask)
*mask = mask32;
if (child_window)
{
if (gdk_window_get_window_type (toplevel) == GDK_WINDOW_ROOT)
{
*child_window = mouse_toplevel;
if (*child_window == NULL)
*child_window = toplevel;
}
else
{
/* No native children */
*child_window = toplevel;
}
}
return;
}
static void
gtk_popup_button_popup_real (GtkPopupButton *popup_button, GdkDevice *device)
{
GtkPopupButtonPrivate *priv = popup_button->priv;
GtkAllocation button_allocation, dock_allocation;
GdkScreen *screen;
gint monitor_num;
GdkRectangle monitor;
GtkWidget *toplevel;
GdkDevice *keyboard, *pointer;
guint32 time;
gint x, y;
g_return_if_fail (GTK_IS_POPUP_BUTTON (popup_button));
g_return_if_fail (GDK_IS_DEVICE (device));
if (!gtk_widget_get_realized (GTK_WIDGET (popup_button)))
return;
if (gtk_widget_get_mapped (priv->dock))
return;
if (priv->grab_pointer && priv->grab_keyboard)
return;
time = gtk_get_current_event_time ();
if (gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD) {
keyboard = device;
pointer = gdk_device_get_associated_device (device);
} else {
pointer = device;
keyboard = gdk_device_get_associated_device (device);
}
toplevel = gtk_widget_get_toplevel (GTK_WIDGET (popup_button));
if (GTK_IS_WINDOW (toplevel))
gtk_window_group_add_window (gtk_window_get_group (GTK_WINDOW (toplevel)),
GTK_WINDOW (priv->dock));
/* positioning */
gtk_widget_show (priv->dock);
gtk_widget_get_allocation (GTK_WIDGET (popup_button), &button_allocation);
gdk_window_get_root_coords (gtk_widget_get_window (GTK_WIDGET (popup_button)),
button_allocation.x, button_allocation.y, &x, &y);
gtk_widget_get_allocation (GTK_WIDGET (priv->dock), &dock_allocation);
x = (x + button_allocation.width / 2) - (dock_allocation.width / 2);
y = y - dock_allocation.height;
GdkWindow *window = window = gtk_widget_get_window (GTK_WIDGET (popup_button));
screen = gtk_widget_get_screen (GTK_WIDGET (priv->dock));
monitor_num = gdk_screen_get_monitor_at_window (screen, window);
gdk_screen_get_monitor_workarea (screen, monitor_num, &monitor);
if (x < monitor.x)
x = monitor.x;
else if (x + dock_allocation.width > monitor.x + monitor.width)
x = monitor.x + monitor.width - dock_allocation.width;
gtk_window_move (GTK_WINDOW (priv->dock), x, y);
/* grabbing */
gtk_widget_grab_focus (priv->dock);
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (popup_button), TRUE);
if (gdk_device_grab (pointer, gtk_widget_get_window (priv->dock),
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK,
NULL, time) != GDK_GRAB_SUCCESS) {
gtk_device_grab_remove (priv->dock, pointer);
gtk_widget_hide (priv->dock);
return;
}
if (gdk_device_grab (keyboard, gtk_widget_get_window (priv->dock),
GDK_OWNERSHIP_WINDOW, TRUE,
GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK,
NULL, time) != GDK_GRAB_SUCCESS) {
gdk_device_ungrab (pointer, time);
gtk_device_grab_remove (priv->dock, pointer);
gtk_widget_hide (priv->dock);
return;
}
gtk_device_grab_add (priv->dock, pointer, TRUE);
priv->grab_pointer = pointer;
priv->grab_keyboard = keyboard;
}
void setup_input_devices (GromitData *data)
{
/* ungrab all */
release_grab (data, NULL);
/* and clear our own device data list */
GHashTableIter it;
gpointer value;
g_hash_table_iter_init (&it, data->devdatatable);
while (g_hash_table_iter_next (&it, NULL, &value))
g_free(value);
g_hash_table_remove_all(data->devdatatable);
/* get devices */
GdkDeviceManager *device_manager = gdk_display_get_device_manager(data->display);
GList *devices, *d;
int i = 0;
devices = g_list_concat(gdk_device_manager_list_devices
(device_manager, GDK_DEVICE_TYPE_MASTER),
gdk_device_manager_list_devices
(device_manager, GDK_DEVICE_TYPE_SLAVE));
for(d = devices; d; d = d->next)
{
GdkDevice *device = (GdkDevice *) d->data;
/* only enable devices with 2 ore more axes */
if (gdk_device_get_source(device) != GDK_SOURCE_KEYBOARD && gdk_device_get_n_axes(device) >= 2)
{
gdk_device_set_mode (device, GDK_MODE_SCREEN);
GromitDeviceData *devdata;
devdata = g_malloc0(sizeof (GromitDeviceData));
devdata->device = device;
devdata->index = i;
/* get attached keyboard and grab the hotkey */
if (!data->hot_keycode)
{
g_printerr("ERROR: Grabbing hotkey from attached keyboard "
"of '%s' failed, no hotkey defined.\n",
gdk_device_get_name(device));
g_free(devdata);
continue;
}
/* if this is a slave device, we need the master */
GdkDevice *kdevice=device;
if(gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_SLAVE)
kdevice=gdk_device_get_associated_device (device);
gint dev_id = -1;
g_object_get(kdevice, "device-id", &dev_id, NULL);
gint kbd_dev_id = -1;
XIDeviceInfo* devinfo;
int devicecount = 0;
devinfo = XIQueryDevice(GDK_DISPLAY_XDISPLAY(data->display),
dev_id,
&devicecount);
if(devicecount)
kbd_dev_id = devinfo->attachment;
XIFreeDeviceInfo(devinfo);
if(kbd_dev_id != -1)
{
if(data->debug)
g_printerr("DEBUG: Grabbing hotkey from keyboard '%d' .\n", kbd_dev_id);
XIEventMask mask;
unsigned char bits[4] = {0,0,0,0};
mask.mask = bits;
mask.mask_len = sizeof(bits);
XISetMask(bits, XI_KeyPress);
XISetMask(bits, XI_KeyRelease);
XIGrabModifiers modifiers[] = {{XIAnyModifier, 0}};
int nmods = 1;
gdk_error_trap_push ();
XIGrabKeycode( GDK_DISPLAY_XDISPLAY(data->display),
kbd_dev_id,
data->hot_keycode,
GDK_WINDOW_XID(data->root),
GrabModeAsync,
GrabModeAsync,
True,
&mask,
nmods,
modifiers);
XSync(GDK_DISPLAY_XDISPLAY(data->display), False);
if(gdk_error_trap_pop())
{
g_printerr("ERROR: Grabbing hotkey from keyboard device %d failed.\n",
kbd_dev_id);
g_free(devdata);
continue;
}
}
g_hash_table_insert(data->devdatatable, device, devdata);
g_printerr ("Enabled Device %d: \"%s\", (Type: %d)\n",
i++, gdk_device_get_name(device), gdk_device_get_source(device));
}
}
g_printerr ("Now %d enabled devices.\n", g_hash_table_size(data->devdatatable));
}
