static gboolean
manager_maybe_grab_window (GSManager *manager,
GSWindow *window)
{
GdkDisplay *display;
GdkDevice *device;
GdkMonitor *monitor;
int x, y;
gboolean grabbed;
display = gdk_display_get_default ();
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_device_get_position (device, NULL, &x, &y);
monitor = gdk_display_get_monitor_at_point (display, x, y);
gdk_display_flush (display);
grabbed = FALSE;
if (gs_window_get_display (window) == display &&
gs_window_get_monitor (window) == monitor)
{
gs_debug ("Initiate grab move to %p", window);
gs_grab_move_to_window (manager->priv->grab,
gs_window_get_gdk_window (window),
gs_window_get_display (window),
FALSE, FALSE);
grabbed = TRUE;
}
return grabbed;
}
/**
* gtk_tooltip_trigger_tooltip_query:
* @display: a #GdkDisplay
*
* Triggers a new tooltip query on @display, in order to update the current
* visible tooltip, or to show/hide the current tooltip. This function is
* useful to call when, for example, the state of the widget changed by a
* key press.
*
* Since: 2.12
*/
void
gtk_tooltip_trigger_tooltip_query (GdkDisplay *display)
{
gint x, y;
GdkWindow *window;
GdkEvent event;
GdkDevice *device;
/* Trigger logic as if the mouse moved */
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
window = gdk_device_get_window_at_position (device, &x, &y);
if (!window)
return;
event.type = GDK_MOTION_NOTIFY;
event.motion.window = window;
event.motion.x = x;
event.motion.y = y;
event.motion.is_hint = FALSE;
gdk_window_get_root_coords (window, x, y, &x, &y);
event.motion.x_root = x;
event.motion.y_root = y;
_gtk_tooltip_handle_event (&event);
}
static void
window_grab_broken_cb (GSWindow *window,
GdkEventGrabBroken *event,
GSManager *manager)
{
GdkDisplay *display;
GdkSeat *seat;
GdkDevice *device;
display = gdk_window_get_display (gs_window_get_gdk_window (window));
seat = gdk_display_get_default_seat (display);
if (event->keyboard)
{
gs_debug ("KEYBOARD GRAB BROKEN!");
device = gdk_seat_get_pointer (seat);
if (!gdk_display_device_is_grabbed (display, device))
gs_grab_reset (manager->priv->grab);
}
else
{
gs_debug ("POINTER GRAB BROKEN!");
device = gdk_seat_get_keyboard (seat);
if (!gdk_display_device_is_grabbed (display, device))
gs_grab_reset (manager->priv->grab);
}
}
void
gdk_wayland_selection_unset_data_source (GdkDisplay *display,
GdkAtom selection)
{
GdkWaylandSelection *wayland_selection = gdk_wayland_display_get_selection (display);
if (selection == atoms[ATOM_CLIPBOARD])
{
GdkDevice *device;
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_wayland_device_set_selection (device, NULL);
if (wayland_selection->clipboard_source)
{
wl_data_source_destroy (wayland_selection->clipboard_source);
wayland_selection->clipboard_source = NULL;
}
}
else if (selection == atoms[ATOM_DND])
{
wayland_selection->dnd_source = NULL;
}
}
static gboolean _lib_filmstrip_size_handle_motion_notify_callback(GtkWidget *w, GdkEventButton *e,
gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *d = (dt_lib_filmstrip_t *)self->data;
if(d->size_handle_is_dragging)
{
gint x, y, sx, sy;
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(e->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(
gdk_window_get_display(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&x, &y, 0);
#else
gdk_window_get_device_position(
gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui)),
gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(
gdk_window_get_display(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&x, &y, NULL);
#endif
gtk_widget_get_size_request(d->filmstrip, &sx, &sy);
sy = CLAMP(d->size_handle_height + (d->size_handle_y - y), DT_PIXEL_APPLY_DPI(64),
DT_PIXEL_APPLY_DPI(400));
dt_conf_set_int("plugins/lighttable/filmstrip/height", sy);
gtk_widget_set_size_request(d->filmstrip, -1, sy);
return TRUE;
}
return FALSE;
}
static gboolean _lib_filmstrip_size_handle_button_callback(GtkWidget *w, GdkEventButton *e, gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_filmstrip_t *d = (dt_lib_filmstrip_t *)self->data;
if(e->button == 1)
{
if(e->type == GDK_BUTTON_PRESS)
{
/* store current mousepointer position */
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(e->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(gdk_window_get_display(
gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&d->size_handle_x, &d->size_handle_y, 0);
#else
gdk_window_get_device_position(
gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui)),
gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(
gdk_window_get_display(gtk_widget_get_window(dt_ui_main_window(darktable.gui->ui))))),
&d->size_handle_x, &d->size_handle_y, NULL);
#endif
gtk_widget_get_size_request(d->filmstrip, NULL, &d->size_handle_height);
d->size_handle_is_dragging = TRUE;
}
else if(e->type == GDK_BUTTON_RELEASE)
d->size_handle_is_dragging = FALSE;
}
return TRUE;
}
static gboolean dt_iop_monochrome_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_monochrome_gui_data_t *g = (dt_iop_monochrome_gui_data_t *)self->gui_data;
dt_iop_monochrome_params_t *p = (dt_iop_monochrome_params_t *)self->params;
if(g->dragging)
{
const int inset = DT_COLORCORRECTION_INSET;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int width = allocation.width - 2 * inset, height = allocation.height - 2 * inset;
const float mouse_x = CLAMP(event->x - inset, 0, width);
const float mouse_y = CLAMP(height - 1 - event->y + inset, 0, height);
p->a = PANEL_WIDTH * (mouse_x - width * 0.5f) / (float)width;
p->b = PANEL_WIDTH * (mouse_y - height * 0.5f) / (float)height;
gtk_widget_queue_draw(self->widget);
}
gint x, y;
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(event->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(gtk_widget_get_display(widget))),
&x, &y, 0);
#else
gdk_window_get_device_position(event->window,
gdk_device_manager_get_client_pointer(
gdk_display_get_device_manager(gdk_window_get_display(event->window))),
&x, &y, NULL);
#endif
return TRUE;
}
static void
menu_loaded_cb (GtkWidget *widget,
PanelWidget *panel_widget)
{
GdkWindow *window;
GdkRectangle rect;
GdkDisplay *display;
GdkSeat *seat;
GdkDevice *device;
g_signal_connect (widget, "destroy", G_CALLBACK (menu_destroy_cb), panel_widget);
panel_toplevel_push_autohide_disabler (panel_widget->toplevel);
window = gtk_widget_get_window (GTK_WIDGET (panel_widget));
rect.x = 0;
rect.y = 0;
rect.width = 1;
rect.height = 1;
display = gdk_display_get_default ();
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
gdk_window_get_device_position (window, device,
&rect.x, &rect.y,
NULL);
gtk_menu_popup_at_rect (GTK_MENU (widget), window, &rect,
GDK_GRAVITY_SOUTH_EAST,
GDK_GRAVITY_NORTH_WEST,
NULL);
}
static gboolean dt_iop_levels_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data)
{
dt_iop_module_t *self = (dt_iop_module_t *)user_data;
dt_iop_levels_gui_data_t *c = (dt_iop_levels_gui_data_t *)self->gui_data;
dt_iop_levels_params_t *p = (dt_iop_levels_params_t *)self->params;
const int inset = DT_GUI_CURVE_EDITOR_INSET;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
int height = allocation.height - 2 * inset, width = allocation.width - 2 * inset;
if(!c->dragging)
{
c->mouse_x = CLAMP(event->x - inset, 0, width);
c->drag_start_percentage = (p->levels[1] - p->levels[0]) / (p->levels[2] - p->levels[0]);
}
c->mouse_y = CLAMP(event->y - inset, 0, height);
if(c->dragging)
{
if(c->handle_move >= 0 && c->handle_move < 3)
{
const float mx = (CLAMP(event->x - inset, 0, width)) / (float)width;
dt_iop_levels_move_handle(self, c->handle_move, mx, p->levels, c->drag_start_percentage);
}
dt_dev_add_history_item(darktable.develop, self, TRUE);
}
else
{
c->handle_move = 0;
const float mx = CLAMP(event->x - inset, 0, width) / (float)width;
float dist = fabsf(p->levels[0] - mx);
for(int k = 1; k < 3; k++)
{
float d2 = fabsf(p->levels[k] - mx);
if(d2 < dist)
{
c->handle_move = k;
dist = d2;
}
}
}
gtk_widget_queue_draw(widget);
gint x, y;
#if GTK_CHECK_VERSION(3, 20, 0)
gdk_window_get_device_position(event->window,
gdk_seat_get_pointer(gdk_display_get_default_seat(gtk_widget_get_display(widget))),
&x, &y, 0);
#else
gdk_window_get_device_position(event->window,
gdk_device_manager_get_client_pointer(
gdk_display_get_device_manager(gdk_window_get_display(event->window))),
&x, &y, NULL);
#endif
return TRUE;
}
static void
gdk_input_init (GdkDisplay *display)
{
GdkWaylandDisplay *display_wayland;
display_wayland = GDK_WAYLAND_DISPLAY (display);
display->core_pointer = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
/* Add the core pointer to the devices list */
display_wayland->input_devices = g_list_prepend (display_wayland->input_devices, display->core_pointer);
}
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);
}
static void
gstyle_eyedropper_event_get_root_coords (GstyleEyedropper *self,
GdkEvent *event,
gint *x_root,
gint *y_root)
{
GdkSeat *seat;
GdkDevice *pointer;
seat = gdk_event_get_seat (event);
pointer = gdk_seat_get_pointer (seat);
gdk_device_get_position (pointer, NULL, x_root, y_root);
}
static GdkDevice *
get_pointer (GdkWindow *window)
{
GdkDisplay *display;
GdkSeat *seat;
GdkDevice *pointer;
display = gdk_window_get_display (window);
seat = gdk_display_get_default_seat (display);
pointer = gdk_seat_get_pointer (seat);
return pointer;
}
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);
}
GdkMonitor *
gimp_get_monitor_at_pointer (void)
{
GdkDisplay *display;
GdkSeat *seat;
gint x, y;
display = gdk_display_get_default ();
seat = gdk_display_get_default_seat (display);
gdk_device_get_position (gdk_seat_get_pointer (seat),
NULL, &x, &y);
return gdk_display_get_monitor_at_point (display, x, y);
}
void
gtk_inspector_window_select_widget_under_pointer (GtkInspectorWindow *iw)
{
GdkDisplay *display;
GdkDevice *device;
GtkWidget *widget;
display = gdk_display_get_default ();
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
widget = find_widget_at_pointer (device);
if (widget)
select_widget (iw, widget);
}
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;
}
void
gdk_wayland_selection_add_targets (GdkWindow *window,
GdkAtom selection,
guint ntargets,
GdkAtom *targets)
{
GdkDisplay *display = gdk_window_get_display (window);
GdkWaylandSelection *wayland_selection = gdk_wayland_display_get_selection (display);
gpointer data_source;
guint i;
g_return_if_fail (GDK_IS_WINDOW (window));
data_source = gdk_wayland_selection_get_data_source (window, selection);
if (!data_source)
return;
g_array_append_vals (wayland_selection->source_targets, targets, ntargets);
for (i = 0; i < ntargets; i++)
{
gchar *mimetype = gdk_atom_name (targets[i]);
wl_data_source_offer (data_source, mimetype);
g_free (mimetype);
}
if (selection == atoms[ATOM_CLIPBOARD])
{
GdkDisplay *display;
GdkDevice *device;
display = gdk_window_get_display (window);
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_wayland_device_set_selection (device, data_source);
}
else if (selection == atoms[ATOM_PRIMARY])
{
GdkSeat *seat;
seat = gdk_display_get_default_seat (display);
gdk_wayland_seat_set_primary (seat, data_source);
}
}
static void
gstyle_eyedropper_screen_size_changed_cb (GstyleEyedropper *self,
GdkScreen *screen)
{
GdkDevice *pointer;
gint x;
gint y;
g_assert (GSTYLE_IS_EYEDROPPER (self));
g_assert (GDK_IS_SCREEN (screen));
self->screen_width = gdk_screen_get_width (screen);
self->screen_height = gdk_screen_get_height (screen);
pointer = gdk_seat_get_pointer (self->seat);
gdk_device_get_position (pointer, NULL, &x, &y);
gstyle_eyedropper_draw_zoom_area (self, x, y);
}
static void
get_pointer_position_gdk (int *x,
int *y,
int *mods)
{
GdkSeat *gseat;
GdkDevice *gdevice;
GdkScreen *gscreen;
gseat = gdk_display_get_default_seat (gdk_display_get_default ());
gdevice = gdk_seat_get_pointer (gseat);
gdk_device_get_position (gdevice, &gscreen, x, y);
if (mods)
gdk_device_get_state (gdevice,
gdk_screen_get_root_window (gscreen),
NULL, (GdkModifierType*)mods);
}
static gint
timer_cb (EyesApplet *eyes_applet)
{
GdkDisplay *display;
#if GTK_CHECK_VERSION (3, 20, 0)
GdkSeat *seat;
#else
GdkDeviceManager *device_manager;
GdkDevice *device;
#endif
gint x, y;
gint pupil_x, pupil_y;
gint i;
display = gtk_widget_get_display (GTK_WIDGET (eyes_applet->applet));
#if GTK_CHECK_VERSION (3, 20, 0)
seat = gdk_display_get_default_seat (display);
#else
device_manager = gdk_display_get_device_manager (display);
device = gdk_device_manager_get_client_pointer (device_manager);
#endif
for (i = 0; i < eyes_applet->num_eyes; i++) {
if (gtk_widget_get_realized (eyes_applet->eyes[i])) {
#if GTK_CHECK_VERSION (3, 20, 0)
gdk_window_get_device_position (gtk_widget_get_window (eyes_applet->eyes[i]),
gdk_seat_get_pointer (seat),
&x, &y, NULL);
#else
gdk_window_get_device_position (gtk_widget_get_window (eyes_applet->eyes[i]), device, &x, &y, NULL);
#endif
if ((x != eyes_applet->pointer_last_x[i]) || (y != eyes_applet->pointer_last_y[i])) {
calculate_pupil_xy (eyes_applet, x, y, &pupil_x, &pupil_y, eyes_applet->eyes[i]);
draw_eye (eyes_applet, i, pupil_x, pupil_y);
eyes_applet->pointer_last_x[i] = x;
eyes_applet->pointer_last_y[i] = y;
}
}
}
return TRUE;
}
XfwmDevices *
xfwm_devices_new (GdkDisplay *display)
{
XfwmDevices *devices;
#ifdef HAVE_XI2
GdkSeat *seat;
GdkDevice *pointer_device;
GdkDevice *keyboard_device;
gint firstevent, firsterror;
#endif
devices = g_new0 (XfwmDevices, 1);
devices->xi2_available = FALSE;
devices->xi2_opcode = 0;
devices->pointer.keyboard = FALSE;
devices->pointer.xi2_device = None;
devices->keyboard.keyboard = TRUE;
devices->keyboard.xi2_device = None;
#ifdef HAVE_XI2
seat = gdk_display_get_default_seat (display);
pointer_device = gdk_seat_get_pointer (seat);
keyboard_device = gdk_seat_get_keyboard (seat);
if (GDK_IS_X11_DEVICE_XI2 (pointer_device) || GDK_IS_X11_DEVICE_XI2 (keyboard_device))
{
/* GDK uses XI2, let's use it too */
/* Obtain XI2 opcode */
if (XQueryExtension (gdk_x11_display_get_xdisplay (display), "XInputExtension",
&devices->xi2_opcode, &firstevent, &firsterror))
{
devices->xi2_available = TRUE;
devices->pointer.xi2_device = gdk_x11_device_get_id (pointer_device);
devices->keyboard.xi2_device = gdk_x11_device_get_id (keyboard_device);
}
}
#endif
return devices;
}
static GSWindow *
find_window_at_pointer (GSManager *manager)
{
GdkDisplay *display;
GdkDevice *device;
GdkMonitor *monitor;
int x, y;
GSWindow *window;
GSList *l;
display = gdk_display_get_default ();
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_device_get_position (device, NULL, &x, &y);
monitor = gdk_display_get_monitor_at_point (display, x, y);
/* Find the gs-window that is on that monitor */
window = NULL;
for (l = manager->priv->windows; l; l = l->next)
{
GSWindow *win = GS_WINDOW (l->data);
if (gs_window_get_display (win) == display &&
gs_window_get_monitor (win) == monitor)
{
window = win;
}
}
if (window == NULL)
{
gs_debug ("WARNING: Could not find the GSWindow for display %s",
gdk_display_get_name (display));
/* take the first one */
window = manager->priv->windows->data;
}
else
{
gs_debug ("Requesting unlock for display %s",
gdk_display_get_name (display));
}
return window;
}
void
ev_document_misc_get_pointer_position (GtkWidget *widget,
gint *x,
gint *y)
{
#if GTK_CHECK_VERSION (3, 20, 0)
GdkSeat *seat;
#else
GdkDeviceManager *device_manager;
#endif
GdkDevice *device_pointer;
GdkRectangle allocation;
if (x)
*x = -1;
if (y)
*y = -1;
if (!gtk_widget_get_realized (widget))
return;
#if GTK_CHECK_VERSION(3, 20, 0)
seat = gdk_display_get_default_seat (gtk_widget_get_display (widget));
device_pointer = gdk_seat_get_pointer (seat);
#else
device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget));
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
#endif
gdk_window_get_device_position (gtk_widget_get_window (widget),
device_pointer,
x, y, NULL);
if (gtk_widget_get_has_window (widget))
return;
gtk_widget_get_allocation (widget, &allocation);
if (x)
*x -= allocation.x;
if (y)
*y -= allocation.y;
}
static void
data_offer_action (void *data,
struct wl_data_offer *wl_data_offer,
uint32_t action)
{
GdkDragContext *drop_context;
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
display = gdk_display_get_default ();
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
drop_context = gdk_wayland_device_get_drop_context (device);
drop_context->action = _wl_to_gdk_actions (action);
if (gdk_drag_context_get_dest_window (drop_context))
_gdk_wayland_drag_context_emit_event (drop_context, GDK_DRAG_MOTION,
GDK_CURRENT_TIME);
}
static void
draw_zoom_area_cursor (GstyleEyedropper *self,
cairo_t *cr)
{
GdkDevice *pointer;
gint x;
gint y;
g_assert (GSTYLE_IS_EYEDROPPER (self));
pointer = gdk_seat_get_pointer (self->seat);
gdk_device_get_position (pointer, NULL, &x, &y);
cairo_set_source_rgb(cr, 0, 0, 0);
cairo_set_line_width(cr, 1.0);
cairo_arc (cr, self->offset_x, self->offset_y, RETICLE_DIAMETER, 0, 2 * M_PI);
cairo_stroke (cr);
cairo_set_source_rgb(cr, 1.0, 1.0, 1.0);
cairo_arc (cr, self->offset_x, self->offset_y, RETICLE_DIAMETER - 1, 0, 2 * M_PI);
cairo_stroke (cr);
}
static void
gnc_date_edit_popdown(GNCDateEdit *gde)
{
#if GTK_CHECK_VERSION(3,20,0)
GdkSeat *seat;
#else
GdkDeviceManager *device_manager;
#endif
GdkDevice *pointer;
g_return_if_fail (GNC_IS_DATE_EDIT (gde));
ENTER("gde %p", gde);
#if GTK_CHECK_VERSION(3,20,0)
seat = gdk_display_get_default_seat (gdk_display_get_default());
pointer = gdk_seat_get_pointer (seat);
#else
device_manager = gdk_display_get_device_manager (gdk_display_get_default());
pointer = gdk_device_manager_get_client_pointer (device_manager);
#endif
gtk_grab_remove (gde->cal_popup);
gtk_widget_hide (gde->cal_popup);
if (pointer)
#if GTK_CHECK_VERSION(3,20,0)
gdk_seat_ungrab (seat);
#else
gdk_device_ungrab (pointer, GDK_CURRENT_TIME);
#endif
gtk_toggle_button_set_active (GTK_TOGGLE_BUTTON (gde->date_button),
FALSE);
LEAVE(" ");
}
static void
data_offer_source_actions (void *data,
struct wl_data_offer *wl_data_offer,
uint32_t source_actions)
{
GdkDragContext *drop_context;
GdkDisplay *display;
GdkDevice *device;
GdkSeat *seat;
display = gdk_display_get_default ();
seat = gdk_display_get_default_seat (display);
device = gdk_seat_get_pointer (seat);
drop_context = gdk_wayland_device_get_drop_context (device);
drop_context->actions = _wl_to_gdk_actions (source_actions);
GDK_NOTE (EVENTS,
g_message ("data offer source actions, offer %p, actions %d", wl_data_offer, source_actions));
if (gdk_drag_context_get_dest_window (drop_context))
_gdk_wayland_drag_context_emit_event (drop_context, GDK_DRAG_MOTION,
GDK_CURRENT_TIME);
}
/* Timeout callback to check for activation or suspend via hot corner */
static gboolean _xfdashboard_hot_corner_check_hot_corner(gpointer inUserData)
{
XfdashboardHotCorner *self;
XfdashboardHotCornerPrivate *priv;
XfdashboardWindowTrackerWindow *activeWindow;
GdkDevice *pointerDevice;
gint pointerX, pointerY;
XfdashboardWindowTrackerMonitor *primaryMonitor;
XfdashboardHotCornerBox monitorRect;
XfdashboardHotCornerBox hotCornerRect;
GDateTime *currentTime;
GTimeSpan timeDiff;
XfdashboardHotCornerSettingsActivationCorner activationCorner;
gint activationRadius;
gint64 activationDuration;
g_return_val_if_fail(XFDASHBOARD_IS_HOT_CORNER(inUserData), G_SOURCE_CONTINUE);
self=XFDASHBOARD_HOT_CORNER(inUserData);
priv=self->priv;
/* Get all settings now which are used within this function */
activationCorner=xfdashboard_hot_corner_settings_get_activation_corner(priv->settings);
activationRadius=xfdashboard_hot_corner_settings_get_activation_radius(priv->settings);
activationDuration=xfdashboard_hot_corner_settings_get_activation_duration(priv->settings);
/* Do nothing if current window is fullscreen but not this application */
activeWindow=xfdashboard_window_tracker_get_active_window(priv->windowTracker);
if(activeWindow &&
xfdashboard_window_tracker_window_is_fullscreen(activeWindow) &&
!xfdashboard_window_tracker_window_is_stage(activeWindow))
{
return(G_SOURCE_CONTINUE);
}
/* Get current position of pointer */
#if GTK_CHECK_VERSION(3, 20, 0)
pointerDevice=gdk_seat_get_pointer(priv->seat);
#else
pointerDevice=gdk_device_manager_get_client_pointer(priv->deviceManager);
#endif
if(!pointerDevice)
{
g_critical(_("Could not get pointer to determine pointer position"));
return(G_SOURCE_CONTINUE);
}
gdk_window_get_device_position(priv->rootWindow, pointerDevice, &pointerX, &pointerY, NULL);
/* Get position and size of primary monitor */
primaryMonitor=xfdashboard_window_tracker_get_primary_monitor(priv->windowTracker);
if(primaryMonitor)
{
gint w, h;
xfdashboard_window_tracker_monitor_get_geometry(primaryMonitor,
&monitorRect.x1,
&monitorRect.y1,
&w,
&h);
monitorRect.x2=monitorRect.x1+w;
monitorRect.y2=monitorRect.y1+h;
}
else
{
/* Set position to 0,0 and size to screen size */
monitorRect.x1=monitorRect.y1=0;
monitorRect.x2=xfdashboard_window_tracker_get_screen_width(priv->windowTracker);
monitorRect.y2=xfdashboard_window_tracker_get_screen_height(priv->windowTracker);
}
/* Get rectangle where pointer must be inside to activate hot corner */
switch(activationCorner)
{
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_TOP_RIGHT:
hotCornerRect.x2=monitorRect.x2;
hotCornerRect.x1=MAX(monitorRect.x2-activationRadius, monitorRect.x1);
hotCornerRect.y1=monitorRect.y1;
hotCornerRect.y2=MIN(monitorRect.y1+activationRadius, monitorRect.y2);
break;
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_BOTTOM_LEFT:
hotCornerRect.x1=monitorRect.x1;
hotCornerRect.x2=MIN(monitorRect.x1+activationRadius, monitorRect.x2);
hotCornerRect.y2=monitorRect.y2;
hotCornerRect.y1=MAX(monitorRect.y2-activationRadius, monitorRect.y1);
break;
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_BOTTOM_RIGHT:
hotCornerRect.x2=monitorRect.x2;
hotCornerRect.x1=MAX(monitorRect.x2-activationRadius, monitorRect.x1);
hotCornerRect.y2=monitorRect.y2;
hotCornerRect.y1=MAX(monitorRect.y2-activationRadius, monitorRect.y1);
break;
case XFDASHBOARD_HOT_CORNER_ACTIVATION_CORNER_TOP_LEFT:
default:
hotCornerRect.x1=monitorRect.x1;
hotCornerRect.x2=MIN(monitorRect.x1+activationRadius, monitorRect.x2);
hotCornerRect.y1=monitorRect.y1;
hotCornerRect.y2=MIN(monitorRect.y1+activationRadius, monitorRect.y2);
break;
}
/* Check if pointer is in configured hot corner for a configured interval.
* If it is not reset entered time and return immediately without doing anything.
*/
if(pointerX<hotCornerRect.x1 || pointerX>=hotCornerRect.x2 ||
pointerY<hotCornerRect.y1 || pointerY>=hotCornerRect.y2)
{
/* Reset entered time */
if(priv->enteredTime)
{
g_date_time_unref(priv->enteredTime);
priv->enteredTime=NULL;
}
/* Return without doing anything */
return(G_SOURCE_CONTINUE);
}
/* If no entered time was registered yet we assume the pointer is in hot corner
* for the first time. So remember entered time for next polling interval.
*/
if(!priv->enteredTime)
{
/* Remember entered time */
priv->enteredTime=g_date_time_new_now_local();
/* Reset handled flag to get duration checked next time */
priv->wasHandledRecently=FALSE;
/* Return without doing anything */
return(G_SOURCE_CONTINUE);
}
/* If handled flag is set then do nothing to avoid flapping between activation
* and suspending application once the activation duration was reached.
*/
if(priv->wasHandledRecently) return(G_SOURCE_CONTINUE);
/* We know the time the pointer entered hot corner. Check if pointer have stayed
* in hot corner for the duration to activate/suspend application. If duration
* was not reached yet, just return immediately.
*/
currentTime=g_date_time_new_now_local();
timeDiff=g_date_time_difference(currentTime, priv->enteredTime);
g_date_time_unref(currentTime);
if(timeDiff<(activationDuration*G_TIME_SPAN_MILLISECOND)) return(G_SOURCE_CONTINUE);
/* Activation duration reached so activate application if suspended or suspend it
* if active currently.
*/
if(!xfdashboard_application_is_suspended(priv->application))
{
xfdashboard_application_suspend_or_quit(priv->application);
}
else
{
g_application_activate(G_APPLICATION(priv->application));
}
/* Set flag that activation was handled recently */
priv->wasHandledRecently=TRUE;
return(G_SOURCE_CONTINUE);
}
static gint
target_event_cb(GtkWidget *widget, GdkEvent *event, gpointer data)
{
BalloonEval *beval = (BalloonEval *)data;
switch (event->type)
{
case GDK_ENTER_NOTIFY:
pointer_event(beval, (int)event->crossing.x,
(int)event->crossing.y,
event->crossing.state);
break;
case GDK_MOTION_NOTIFY:
if (event->motion.is_hint)
{
int x;
int y;
GdkModifierType state;
/*
* GDK_POINTER_MOTION_HINT_MASK is set, thus we cannot obtain
* the coordinates from the GdkEventMotion struct directly.
*/
# if GTK_CHECK_VERSION(3,0,0)
{
GdkWindow * const win = gtk_widget_get_window(widget);
GdkDisplay * const dpy = gdk_window_get_display(win);
# if GTK_CHECK_VERSION(3,20,0)
GdkSeat * const seat = gdk_display_get_default_seat(dpy);
GdkDevice * const dev = gdk_seat_get_pointer(seat);
# else
GdkDeviceManager * const mngr = gdk_display_get_device_manager(dpy);
GdkDevice * const dev = gdk_device_manager_get_client_pointer(mngr);
# endif
gdk_window_get_device_position(win, dev , &x, &y, &state);
}
# else
gdk_window_get_pointer(widget->window, &x, &y, &state);
# endif
pointer_event(beval, x, y, (unsigned int)state);
}
else
{
pointer_event(beval, (int)event->motion.x,
(int)event->motion.y,
event->motion.state);
}
break;
case GDK_LEAVE_NOTIFY:
/*
* Ignore LeaveNotify events that are not "normal".
* Apparently we also get it when somebody else grabs focus.
*/
if (event->crossing.mode == GDK_CROSSING_NORMAL)
cancelBalloon(beval);
break;
case GDK_BUTTON_PRESS:
case GDK_SCROLL:
cancelBalloon(beval);
break;
case GDK_KEY_PRESS:
key_event(beval, event->key.keyval, TRUE);
break;
case GDK_KEY_RELEASE:
key_event(beval, event->key.keyval, FALSE);
break;
default:
break;
}
return FALSE; /* continue emission */
}
