GimpDeviceInfo *
gimp_device_info_get_by_device (GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
return g_object_get_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY);
}
GdkAxisUse
gdk_device_get_axis_use (GdkDevice *device,
guint index)
{
g_return_val_if_fail (GDK_IS_DEVICE (device), GDK_AXIS_IGNORE);
g_return_val_if_fail (index < device->num_axes, GDK_AXIS_IGNORE);
return device->axes[index].use;
}
static void
gimp_device_info_constructed (GObject *object)
{
GimpDeviceInfo *info = GIMP_DEVICE_INFO (object);
Gimp *gimp;
G_OBJECT_CLASS (parent_class)->constructed (object);
g_assert ((info->device == NULL && info->display == NULL) ||
(GDK_IS_DEVICE (info->device) && GDK_IS_DISPLAY (info->display)));
gimp = GIMP_CONTEXT (object)->gimp;
if (info->device)
{
g_object_set_data (G_OBJECT (info->device), GIMP_DEVICE_INFO_DATA_KEY,
info);
gimp_object_set_name (GIMP_OBJECT (info), info->device->name);
info->mode = info->device->mode;
info->n_axes = info->device->num_axes;
info->n_keys = info->device->num_keys;
}
gimp_context_define_properties (GIMP_CONTEXT (object),
GIMP_DEVICE_INFO_CONTEXT_MASK,
FALSE);
gimp_context_copy_properties (gimp_get_user_context (gimp),
GIMP_CONTEXT (object),
GIMP_DEVICE_INFO_CONTEXT_MASK);
gimp_context_set_serialize_properties (GIMP_CONTEXT (object),
GIMP_DEVICE_INFO_CONTEXT_MASK);
/* FIXME: this is ugly and needs to be done via "notify" once
* the contexts' properties are dynamic.
*/
g_signal_connect (object, "foreground-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "background-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "tool-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "brush-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "pattern-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
g_signal_connect (object, "gradient-changed",
G_CALLBACK (gimp_device_info_changed),
NULL);
}
/*
* gtk_bubble_window_grab:
* @window: a #GtkBubbleWindow
* @device: a master #GdkDevice
* @activate_time: timestamp to perform the grab
*
* This function performs GDK and GTK+ grabs on @device and
* its paired #GdkDevice. After this call all pointer/keyboard
* events will be handled by @window.
*
* Calling this also brings in a #GtkMenu alike behavior, clicking
* outside the #GtkBubbleWindow or pressing the Escape key will
* popdown the menu by default.
*
* <note>
* If there was a previous grab, it will be undone before doing
* the requested grab.
* </note>
*
* Returns: %TRUE if the grab was successful
*
* Since: 3.8
*/
gboolean
_gtk_bubble_window_grab (GtkBubbleWindow *window,
GdkDevice *device,
guint32 activate_time)
{
GtkBubbleWindowPrivate *priv;
GdkDevice *other_device;
GdkWindow *grab_window;
GdkGrabStatus status;
g_return_val_if_fail (GTK_IS_BUBBLE_WINDOW (window), FALSE);
g_return_val_if_fail (GDK_IS_DEVICE (device), FALSE);
g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, FALSE);
priv = window->priv;
if (!priv->has_pointing_to ||
gdk_window_is_destroyed (priv->relative_to))
return FALSE;
if (priv->device)
_gtk_bubble_window_ungrab (window);
gtk_widget_realize (GTK_WIDGET (window));
grab_window = gtk_widget_get_window (GTK_WIDGET (window));
other_device = gdk_device_get_associated_device (device);
status = gdk_device_grab (device, grab_window,
GDK_OWNERSHIP_WINDOW, TRUE, GRAB_EVENT_MASK,
NULL, activate_time);
if (status == GDK_GRAB_SUCCESS)
{
status = gdk_device_grab (other_device, grab_window,
GDK_OWNERSHIP_WINDOW, TRUE, GRAB_EVENT_MASK,
NULL, activate_time);
/* Ungrab the first device on error */
if (status != GDK_GRAB_SUCCESS)
gdk_device_ungrab (device, activate_time);
}
if (status == GDK_GRAB_SUCCESS)
{
gtk_device_grab_add (GTK_WIDGET (window), device, TRUE);
priv->device = device;
}
return status == GDK_GRAB_SUCCESS;
}
/**
* gdk_drag_context_set_device:
* @context: a #GdkDragContext
* @device: a #GdkDevice
*
* Associates a #GdkDevice to @context, so all Drag and Drop events
* for @context are emitted as if they came from this device.
*/
void
gdk_drag_context_set_device (GdkDragContext *context,
GdkDevice *device)
{
g_return_if_fail (GDK_IS_DRAG_CONTEXT (context));
g_return_if_fail (GDK_IS_DEVICE (device));
if (context->device)
g_object_unref (context->device);
context->device = device;
if (context->device)
g_object_ref (context->device);
}
GimpDeviceInfo *
gimp_device_info_new (Gimp *gimp,
GdkDevice *device,
GdkDisplay *display)
{
g_return_val_if_fail (GIMP_IS_GIMP (gimp), NULL);
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
return g_object_new (GIMP_TYPE_DEVICE_INFO,
"gimp", gimp,
"device", device,
"display", display,
NULL);
}
void
gdk_device_get_key (GdkDevice *device,
guint index,
guint *keyval,
GdkModifierType *modifiers)
{
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (index < device->num_keys);
if (!device->keys[index].keyval &&
!device->keys[index].modifiers)
return;
if (keyval)
*keyval = device->keys[index].keyval;
if (modifiers)
*modifiers = device->keys[index].modifiers;
}
static void
get_rgba_at_cursor (GstyleEyedropper *self,
GdkScreen *screen,
GdkDevice *device,
gint x,
gint y,
GdkRGBA *rgba)
{
GdkWindow *window;
GdkPixbuf *pixbuf;
guchar *pixels;
g_assert (GSTYLE_IS_EYEDROPPER (self));
g_assert (GDK_IS_SCREEN (screen));
g_assert (GDK_IS_DEVICE (device));
window = gdk_screen_get_root_window (screen);
pixbuf = gdk_pixbuf_get_from_window (window, x, y, 1, 1);
if (!pixbuf)
{
window = gdk_device_get_window_at_position (device, &x, &y);
if (!window)
return;
pixbuf = gdk_pixbuf_get_from_window (window, x, y, 1, 1);
if (!pixbuf)
return;
}
g_assert (gdk_pixbuf_get_colorspace (pixbuf) == GDK_COLORSPACE_RGB);
g_assert (gdk_pixbuf_get_bits_per_sample (pixbuf) == 8);
pixels = gdk_pixbuf_get_pixels (pixbuf);
rgba->red = pixels[0] / 255.0;
rgba->green = pixels[1] / 255.0;
rgba->blue = pixels[2] /255.0;
rgba->alpha = 1.0;
g_object_unref (pixbuf);
}
/**
* 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 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
gimp_device_info_set_device (GimpDeviceInfo *info,
GdkDevice *device,
GdkDisplay *display)
{
gint i;
g_return_if_fail (GIMP_IS_DEVICE_INFO (info));
g_return_if_fail ((device == NULL && display == NULL) ||
(GDK_IS_DEVICE (device) && GDK_IS_DISPLAY (display)));
g_return_if_fail ((info->device == NULL && GDK_IS_DEVICE (device)) ||
(GDK_IS_DEVICE (info->device) && device == NULL));
g_return_if_fail (device == NULL ||
strcmp (device->name,
gimp_object_get_name (info)) == 0);
if (device)
{
info->device = device;
info->display = display;
g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, info);
gimp_device_info_set_mode (info, info->mode);
if (info->n_axes != device->num_axes)
g_printerr ("%s: stored 'num-axes' for device '%s' doesn't match "
"number of axes present in device\n",
G_STRFUNC, device->name);
for (i = 0; i < MIN (info->n_axes, device->num_axes); i++)
gimp_device_info_set_axis_use (info, i,
info->axes[i]);
if (info->n_keys != device->num_keys)
g_printerr ("%s: stored 'num-keys' for device '%s' doesn't match "
"number of keys present in device\n",
G_STRFUNC, device->name);
for (i = 0; i < MIN (info->n_keys, device->num_keys); i++)
gimp_device_info_set_key (info, i,
info->keys[i].keyval,
info->keys[i].modifiers);
}
else
{
device = info->device;
display = info->display;
info->device = NULL;
info->display = NULL;
g_object_set_data (G_OBJECT (device), GIMP_DEVICE_INFO_DATA_KEY, NULL);
gimp_device_info_set_mode (info, device->mode);
info->n_axes = device->num_axes;
info->axes = g_renew (GdkAxisUse, info->axes, info->n_axes);
memset (info->axes, 0, info->n_axes * sizeof (GdkAxisUse));
for (i = 0; i < device->num_axes; i++)
gimp_device_info_set_axis_use (info, i,
device->axes[i].use);
info->n_keys = device->num_keys;
info->keys = g_renew (GdkDeviceKey, info->keys, info->n_keys);
memset (info->keys, 0, info->n_keys * sizeof (GdkDeviceKey));
for (i = 0; i < MIN (info->n_keys, device->num_keys); i++)
gimp_device_info_set_key (info, i,
device->keys[i].keyval,
device->keys[i].modifiers);
}
/* sort order depends on device presence */
gimp_object_name_changed (GIMP_OBJECT (info));
g_object_notify (G_OBJECT (info), "device");
gimp_device_info_changed (info);
}
/* 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);
}
}
