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 */ }