EXPORT void audgui_get_mouse_coords (GtkWidget * widget, int * x, int * y) { if (widget) { int xwin, ywin; GdkRectangle alloc; GdkWindow * window = gtk_widget_get_window (widget); GdkDisplay * display = gdk_window_get_display (window); GdkDeviceManager * manager = gdk_display_get_device_manager (display); GdkDevice * device = gdk_device_manager_get_client_pointer (manager); gdk_window_get_device_position (window, device, & xwin, & ywin, NULL); gtk_widget_get_allocation (widget, & alloc); * x = xwin - alloc.x; * y = ywin - alloc.y; } else { GdkDisplay * display = gdk_display_get_default (); GdkDeviceManager * manager = gdk_display_get_device_manager (display); GdkDevice * device = gdk_device_manager_get_client_pointer (manager); gdk_device_get_position (device, NULL, x, y); } }
void ev_document_misc_get_pointer_position (GtkWidget *widget, gint *x, gint *y) { GdkDeviceManager *device_manager; GdkDevice *device_pointer; GdkRectangle allocation; if (x) *x = -1; if (y) *y = -1; if (!gtk_widget_get_realized (widget)) return; device_manager = gdk_display_get_device_manager (gtk_widget_get_display (widget)); device_pointer = gdk_device_manager_get_client_pointer (device_manager); 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; }
void XAP_gdk_pointer_ungrab(guint32 t) { GdkDeviceManager *manager = gdk_display_get_device_manager(gdk_display_get_default()); GdkDevice *device = gdk_device_manager_get_client_pointer (manager); gdk_device_ungrab (device, t); }
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; }
GdkWindow * do_find_current_window (void) { GdkWindow *current_window; GdkDeviceManager *manager; GdkDevice *device; current_window = screenshot_find_active_window (); manager = gdk_display_get_device_manager (gdk_display_get_default ()); device = gdk_device_manager_get_client_pointer (manager); /* If there's no active window, we fall back to returning the * window that the cursor is in. */ if (!current_window) current_window = gdk_device_get_window_at_position (device, NULL, NULL); if (current_window) { if (screenshot_window_is_desktop (current_window)) /* if the current window is the desktop (e.g. nautilus), we * return NULL, as getting the whole screen makes more sense. */ return NULL; /* Once we have a window, we take the toplevel ancestor. */ current_window = gdk_window_get_toplevel (current_window); } return current_window; }
static void tooltip_trigger(void) { GdkDisplay *display = gdk_display_get_default(); #if GTK_CHECK_VERSION(3, 0, 0) GdkDeviceManager *manager = gdk_display_get_device_manager(display); GdkDevice *device = gdk_device_manager_get_client_pointer(manager); GdkWindow *window = gdk_device_get_window_at_position(device, NULL, NULL); #else GdkWindow *window = gdk_display_get_window_at_pointer(display, NULL, NULL); #endif GeanyDocument *doc = document_get_current(); if (doc && window) { GtkWidget *event_widget; gdk_window_get_user_data(window, (void **) &event_widget); /* if you know a better working way, do not hesistate to tell me */ if (event_widget && gtk_widget_is_ancestor(event_widget, GTK_WIDGET(doc->editor->sci))) { gtk_tooltip_trigger_tooltip_query(display); } } }
/* FIXME remove when gtknotebook's func for this becomes public, bug #.... */ static NautilusNotebook * find_notebook_at_pointer (gint abs_x, gint abs_y) { GdkDeviceManager *manager; GdkDevice *pointer; GdkWindow *win_at_pointer, *toplevel_win; gpointer toplevel = NULL; gint x, y; /* FIXME multi-head */ manager = gdk_display_get_device_manager (gdk_display_get_default ()); pointer = gdk_device_manager_get_client_pointer (manager); win_at_pointer = gdk_device_get_window_at_position (pointer, &x, &y); if (win_at_pointer == NULL) { /* We are outside all windows containing a notebook */ return NULL; } toplevel_win = gdk_window_get_toplevel (win_at_pointer); /* get the GtkWidget which owns the toplevel GdkWindow */ gdk_window_get_user_data (toplevel_win, &toplevel); /* toplevel should be an NautilusWindow */ if (toplevel != NULL && NAUTILUS_IS_WINDOW (toplevel)) { return NAUTILUS_NOTEBOOK (NAUTILUS_WINDOW (toplevel)->details->notebook); } return NULL; }
/** * 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_device_manager_get_client_pointer (gdk_display_get_device_manager (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 cairo_region_t * byzanz_layer_cursor_snapshot (ByzanzLayer *layer) { ByzanzLayerCursor *clayer = BYZANZ_LAYER_CURSOR (layer); cairo_region_t *region, *area; int x, y; GdkDevice *device; GdkDeviceManager *device_manager; GdkDisplay *display; GdkWindow *window; window = layer->recorder->window; display = gdk_window_get_display (window); device_manager = gdk_display_get_device_manager (display); device = gdk_device_manager_get_client_pointer (device_manager); gdk_window_get_device_position (window, device, &x, &y, NULL); if (x == clayer->cursor_x && y == clayer->cursor_y && clayer->cursor_next == clayer->cursor) return NULL; region = cairo_region_create (); byzanz_recorder_invalidate_cursor (region, clayer->cursor, clayer->cursor_x, clayer->cursor_y); byzanz_recorder_invalidate_cursor (region, clayer->cursor_next, x, y); area = cairo_region_create_rectangle (&layer->recorder->area); cairo_region_intersect (region, area); cairo_region_destroy (area); clayer->cursor = clayer->cursor_next; clayer->cursor_x = x; clayer->cursor_y = y; byzanz_layer_cursor_setup_poll (clayer); return region; }
static void remove_popup (GtkWidget *popup) { GdkWindow *root; #if GTK_CHECK_VERSION (3, 0, 0) GdkDisplay *display; GdkDevice *pointer; GdkDevice *keyboard; GdkDeviceManager *device_manager; #endif root = gdk_screen_get_root_window ( gtk_window_get_screen (GTK_WINDOW (popup))); gdk_window_remove_filter (root, (GdkFilterFunc) popup_filter, popup); gtk_widget_destroy (popup); #if GTK_CHECK_VERSION (3, 0, 0) display = gdk_window_get_display (root); device_manager = gdk_display_get_device_manager (display); pointer = gdk_device_manager_get_client_pointer (device_manager); keyboard = gdk_device_get_associated_device (pointer); gdk_device_ungrab (pointer, GDK_CURRENT_TIME); gdk_device_ungrab (keyboard, GDK_CURRENT_TIME); #else gdk_pointer_ungrab (GDK_CURRENT_TIME); gdk_keyboard_ungrab (GDK_CURRENT_TIME); #endif }
static gboolean popup_grab_on_window (GtkWidget *widget, guint32 activate_time) { GdkDeviceManager *manager; GdkDevice *pointer; GdkWindow *window; window = gtk_widget_get_window (widget); manager = gdk_display_get_device_manager (gtk_widget_get_display (widget)); pointer = gdk_device_manager_get_client_pointer (manager); if (gdk_device_grab (pointer, window, GDK_OWNERSHIP_WINDOW, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, activate_time) == GDK_GRAB_SUCCESS) { GdkDevice *keyb; keyb = gdk_device_get_associated_device (pointer); if (gdk_device_grab (keyb, window, GDK_OWNERSHIP_WINDOW, TRUE, GDK_KEY_PRESS_MASK | GDK_KEY_RELEASE_MASK, NULL, activate_time) == GDK_GRAB_SUCCESS) return TRUE; else { gdk_device_ungrab (pointer, activate_time); return FALSE; } } return FALSE; }
void doMouseButtonEvent(GtkWidget* widget, GdkEventType eventType, int x, int y, unsigned int button, unsigned int modifiers) { g_assert(gtk_widget_get_realized(widget)); GdkEvent* event = gdk_event_new(eventType); event->button.window = gtk_widget_get_window(widget); g_object_ref(event->button.window); event->button.time = GDK_CURRENT_TIME; event->button.x = x; event->button.y = y; event->button.axes = 0; event->button.state = modifiers; event->button.button = button; #ifndef GTK_API_VERSION_2 event->button.device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(widget))); #endif int xRoot, yRoot; gdk_window_get_root_coords(gtk_widget_get_window(widget), x, y, &xRoot, &yRoot); event->button.x_root = xRoot; event->button.y_root = yRoot; gtk_main_do_event(event); }
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]) { GdkDeviceManager *device_manager; GdkDevice *device; device_manager = gdk_display_get_device_manager (display); device = gdk_device_manager_get_client_pointer (device_manager); gdk_wayland_device_set_selection (device, NULL); wayland_selection->clipboard_owner = 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_owner = NULL; wayland_selection->dnd_source = NULL; } }
void WebViewTest::doMouseButtonEvent(GdkEventType eventType, int x, int y, unsigned button, unsigned mouseModifiers) { g_assert(m_parentWindow); GtkWidget* viewWidget = GTK_WIDGET(m_webView); g_assert(gtk_widget_get_realized(viewWidget)); GOwnPtr<GdkEvent> event(gdk_event_new(eventType)); event->button.window = gtk_widget_get_window(viewWidget); g_object_ref(event->button.window); event->button.time = GDK_CURRENT_TIME; event->button.x = x; event->button.y = y; event->button.axes = 0; event->button.state = mouseModifiers; event->button.button = button; event->button.device = gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget))); int xRoot, yRoot; gdk_window_get_root_coords(gtk_widget_get_window(viewWidget), x, y, &xRoot, &yRoot); event->button.x_root = xRoot; event->button.y_root = yRoot; gtk_main_do_event(event.get()); }
void gdk_wayland_selection_add_targets (GdkWindow *window, GdkAtom selection, guint ntargets, GdkAtom *targets) { struct wl_data_source *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; for (i = 0; i < ntargets; i++) wl_data_source_offer (data_source, gdk_atom_name (targets[i])); if (selection == atoms[ATOM_CLIPBOARD]) { GdkDeviceManager *device_manager; GdkDisplay *display; GdkDevice *device; display = gdk_window_get_display (window); device_manager = gdk_display_get_device_manager (display); device = gdk_device_manager_get_client_pointer (device_manager); gdk_wayland_device_set_selection (device, data_source); } }
static void moveBeamerToMouseMonitor(void) { GdkDisplay *dpy = NULL; GdkScreen *scr = NULL; GdkDeviceManager *dma = NULL; GdkDevice *cpo = NULL; GdkRectangle rect; int mx = -1, my = -1, mon = -1; /* Open default display. Then get the current position of the mouse * cursor and the screen that cursor is on. */ dpy = gdk_display_get_default(); if (dpy == NULL) { /* Actually, this should not happen because we are already able * to create windows on the default screen. */ fprintf(stderr, "Could not get default display.\n"); return; } dma = gdk_display_get_device_manager(dpy); cpo = gdk_device_manager_get_client_pointer(dma); gdk_device_get_position(cpo, &scr, &mx, &my); /* Get the number of the monitor at the current mouse position, as * well as the geometry (offset, size) of that monitor. */ mon = gdk_screen_get_monitor_at_point(scr, mx, my); gdk_screen_get_monitor_geometry(scr, mon, &rect); /* Move the beamer window to the upper left corner of the current * monitor. */ gtk_window_move(GTK_WINDOW(win_beamer), rect.x, rect.y); }
void WebViewTest::keyStroke(unsigned keyVal, unsigned keyModifiers) { g_assert(m_parentWindow); GtkWidget* viewWidget = GTK_WIDGET(m_webView); g_assert(gtk_widget_get_realized(viewWidget)); GOwnPtr<GdkEvent> event(gdk_event_new(GDK_KEY_PRESS)); event->key.keyval = keyVal; event->key.time = GDK_CURRENT_TIME; event->key.window = gtk_widget_get_window(viewWidget); g_object_ref(event->key.window); gdk_event_set_device(event.get(), gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gtk_widget_get_display(viewWidget)))); event->key.state = keyModifiers; // When synthesizing an event, an invalid hardware_keycode value can cause it to be badly processed by GTK+. GOwnPtr<GdkKeymapKey> keys; int keysCount; if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), keyVal, &keys.outPtr(), &keysCount)) event->key.hardware_keycode = keys.get()[0].keycode; gtk_main_do_event(event.get()); event->key.type = GDK_KEY_RELEASE; gtk_main_do_event(event.get()); }
void EventSenderProxy::mouseScrollBy(int horizontal, int vertical) { GdkEvent* event = gdk_event_new(GDK_SCROLL); event->scroll.x = m_position.x; event->scroll.y = m_position.y; event->scroll.time = GDK_CURRENT_TIME; event->scroll.window = gtk_widget_get_window(GTK_WIDGET(m_testController->mainWebView()->platformView())); g_object_ref(event->scroll.window); gdk_event_set_device(event, gdk_device_manager_get_client_pointer(gdk_display_get_device_manager(gdk_window_get_display(event->scroll.window)))); // For more than one tick in a scroll, we need smooth scroll event if ((horizontal && vertical) || horizontal > 1 || horizontal < -1 || vertical > 1 || vertical < -1) { event->scroll.direction = GDK_SCROLL_SMOOTH; event->scroll.delta_x = -horizontal; event->scroll.delta_y = -vertical; sendOrQueueEvent(event); return; } if (horizontal < 0) event->scroll.direction = GDK_SCROLL_RIGHT; else if (horizontal > 0) event->scroll.direction = GDK_SCROLL_LEFT; else if (vertical < 0) event->scroll.direction = GDK_SCROLL_DOWN; else if (vertical > 0) event->scroll.direction = GDK_SCROLL_UP; else g_assert_not_reached(); sendOrQueueEvent(event); }
void populate_popup_cb(WebKitWebView *v, GtkMenu *m, void *c) { (void) c; gint context; if(!uzbl.gui.menu_items) return; /* check context */ if((context = get_click_context()) == -1) return; WebKitHitTestResult *hit_test_result; GdkEventButton ev; gint x, y; #if GTK_CHECK_VERSION (3, 0, 0) gdk_window_get_device_position (gtk_widget_get_window(GTK_WIDGET(v)), gdk_device_manager_get_client_pointer ( gdk_display_get_device_manager ( gtk_widget_get_display (GTK_WIDGET (v)))), &x, &y, NULL); #else gdk_window_get_pointer(gtk_widget_get_window(GTK_WIDGET(v)), &x, &y, NULL); #endif ev.x = x; ev.y = y; hit_test_result = webkit_web_view_get_hit_test_result(v, &ev); populate_context_menu(m, hit_test_result, context); g_object_unref(hit_test_result); }
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 _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 manager_maybe_grab_window (GSManager *manager, GSWindow *window) { GdkDisplay *display; GdkScreen *screen; int monitor; int x, y; gboolean grabbed; display = gdk_display_get_default (); #if GTK_CHECK_VERSION(3, 0, 0) GdkDeviceManager *device_manager = gdk_display_get_device_manager (display); GdkDevice *pointer = gdk_device_manager_get_client_pointer (device_manager); gdk_device_get_position (pointer, &screen, &x, &y); #else gdk_display_get_pointer (display, &screen, &x, &y, NULL); #endif monitor = gdk_screen_get_monitor_at_point (screen, x, y); gdk_flush (); grabbed = FALSE; if (gs_window_get_screen (window) == screen && gs_window_get_monitor (window) == monitor) { gs_debug ("Moving grab to %p", window); gs_grab_move_to_window (manager->priv->grab, gs_window_get_gdk_window (window), gs_window_get_screen (window), TRUE); grabbed = TRUE; } return grabbed; }
static gboolean emitKeyStroke(WebKitWebView* webView) { GdkEvent* pressEvent = gdk_event_new(GDK_KEY_PRESS); pressEvent->key.keyval = GDK_KEY_f; GdkWindow* window = gtk_widget_get_window(GTK_WIDGET(webView)); pressEvent->key.window = window; g_object_ref(pressEvent->key.window); #ifndef GTK_API_VERSION_2 GdkDeviceManager* manager = gdk_display_get_device_manager(gdk_window_get_display(window)); gdk_event_set_device(pressEvent, gdk_device_manager_get_client_pointer(manager)); #endif // When synthesizing an event, an invalid hardware_keycode value // can cause it to be badly processed by Gtk+. GdkKeymapKey* keys; gint n_keys; if (gdk_keymap_get_entries_for_keyval(gdk_keymap_get_default(), GDK_KEY_f, &keys, &n_keys)) { pressEvent->key.hardware_keycode = keys[0].keycode; g_free(keys); } GdkEvent* releaseEvent = gdk_event_copy(pressEvent); gtk_main_do_event(pressEvent); gdk_event_free(pressEvent); releaseEvent->key.type = GDK_KEY_RELEASE; gtk_main_do_event(releaseEvent); gdk_event_free(releaseEvent); return FALSE; }
static void move_locate_pointer_window (GsdLocatePointerData *data, GdkScreen *screen) { cairo_region_t *region; gint cursor_x, cursor_y; // // gdk_window_get_pointer (gdk_screen_get_root_window (screen), // &cursor_x, &cursor_y, NULL); // use gdk_device_get_position instead of gdk_window_get_device_position // 'coz we use root window here. GdkDisplay *display; GdkDeviceManager * device_manager; GdkDevice* pointer_device; display = gdk_window_get_display (data->window); device_manager = gdk_display_get_device_manager (display); pointer_device = gdk_device_manager_get_client_pointer (device_manager); gdk_device_get_position (pointer_device, NULL, &cursor_x, &cursor_y); // gdk_window_move_resize (data->window, cursor_x - WINDOW_SIZE / 2, cursor_y - WINDOW_SIZE / 2, WINDOW_SIZE, WINDOW_SIZE); /* allow events to happen through the window */ region = cairo_region_create (); gdk_window_input_shape_combine_region (data->window, region, 0, 0); cairo_region_destroy (region); }
static gint timer_cb (EyesApplet *eyes_applet) { GdkDisplay *display; GdkDeviceManager *device_manager; GdkDevice *device; gint x, y; gint pupil_x, pupil_y; gint i; display = gtk_widget_get_display (GTK_WIDGET (eyes_applet->applet)); device_manager = gdk_display_get_device_manager (display); device = gdk_device_manager_get_client_pointer (device_manager); for (i = 0; i < eyes_applet->num_eyes; i++) { if (gtk_widget_get_realized (eyes_applet->eyes[i])) { gdk_window_get_device_position (gtk_widget_get_window (eyes_applet->eyes[i]), device, &x, &y, NULL); 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; }
void ygtk_popup_window_popup (GtkWidget *widget, gint x, gint y, guint activate_time) { ygtk_popup_window_frame_position (widget, &x, &y); gtk_grab_add (widget); gtk_window_move (GTK_WINDOW (widget), x, y); gtk_widget_grab_focus (widget); gtk_widget_show (widget); GdkWindow *window = gtk_widget_get_window (widget); GdkDisplay *display = gdk_window_get_display (window); GdkDeviceManager *device_manager = gdk_display_get_device_manager (display); GdkDevice *pointer = gdk_device_manager_get_client_pointer (device_manager); // grab this with your teeth if (gdk_device_grab (pointer, window, GDK_OWNERSHIP_NONE, TRUE, GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK | GDK_POINTER_MOTION_MASK, NULL, activate_time) == 0) { GdkDevice *keyboard; keyboard = gdk_device_get_associated_device (pointer); if (gdk_device_grab (keyboard, window, GDK_OWNERSHIP_NONE, TRUE, GDK_KEY_PRESS | GDK_KEY_RELEASE, NULL, activate_time) != 0) gdk_device_ungrab (pointer, activate_time); } }
/** * position within the sheet in pixel coordinates * * coordinates are clamped to grid if grid is enabled * see snap_to_grid * zero point : top left corner of the window (not widget!) * * @param x horizontal, left to right * @param y vertical, top to bottom * @returns wether the position could be detected properly * * @attention never call in event handlers! */ gboolean sheet_get_pointer_pixel (Sheet *sheet, gdouble *x, gdouble *y) { GtkAdjustment *hadj = NULL, *vadj = NULL; gdouble x1, y1; gint _x, _y; GdkDeviceManager *device_manager; GdkDevice *device_pointer; GdkRectangle allocation; GdkDisplay *display; GdkWindow *window; // deprecated gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y); // replaced by a code copied from evince if (G_UNLIKELY (!sheet || !gtk_widget_get_realized (GTK_WIDGET (sheet)))) { NG_DEBUG ("Widget is not realized."); return FALSE; } display = gtk_widget_get_display (GTK_WIDGET (sheet)); device_manager = gdk_display_get_device_manager (display); // gdk_device_manager_get_client_pointer // shall not be used within events device_pointer = gdk_device_manager_get_client_pointer (device_manager); window = gtk_widget_get_window (GTK_WIDGET (sheet)); if (!window) { NG_DEBUG ("Window is not realized."); return FALSE; } // even though above is all defined the below will always return NUL for // unknown reason and _x and _y are populated as expected gdk_window_get_device_position (window, device_pointer, &_x, &_y, NULL); #if 0 if (!window) { //fails always NG_DEBUG ("Window does not seem to be realized yet?"); return FALSE; } #else NG_DEBUG ("\n%p %p %p %p %i %i\n\n", display, device_manager, device_pointer, window, _x, _y); #endif gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation); _x -= allocation.x; _y -= allocation.y; x1 = (gdouble)_x; y1 = (gdouble)_y; if (!sheet_get_adjustments (sheet, &hadj, &vadj)) return FALSE; x1 += gtk_adjustment_get_value (hadj); y1 += gtk_adjustment_get_value (vadj); *x = x1; *y = y1; return TRUE; }
// http://permalink.gmane.org/gmane.comp.gnome.svn/520942 void XAP_gdk_keyboard_ungrab(guint32 t) { GdkDeviceManager *manager = gdk_display_get_device_manager(gdk_display_get_default()); GdkDevice *device = gdk_device_manager_get_client_pointer (manager); gdk_device_ungrab (gdk_device_get_associated_device(device), t); }
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 gboolean lowlight_motion_notify(GtkWidget *widget, GdkEventMotion *event, gpointer user_data) { dt_iop_module_t *self = (dt_iop_module_t *)user_data; dt_iop_lowlight_gui_data_t *c = (dt_iop_lowlight_gui_data_t *)self->gui_data; dt_iop_lowlight_params_t *p = (dt_iop_lowlight_params_t *)self->params; const int inset = DT_IOP_LOWLIGHT_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) / (float)width; c->mouse_y = 1.0 - CLAMP(event->y - inset, 0, height) / (float)height; if(c->dragging) { *p = c->drag_params; if(c->x_move >= 0) { const float mx = CLAMP(event->x - inset, 0, width) / (float)width; if(c->x_move > 0 && c->x_move < DT_IOP_LOWLIGHT_BANDS - 1) { const float minx = p->transition_x[c->x_move - 1] + 0.001f; const float maxx = p->transition_x[c->x_move + 1] - 0.001f; p->transition_x[c->x_move] = fminf(maxx, fmaxf(minx, mx)); } } else { dt_iop_lowlight_get_params(p, c->mouse_x, c->mouse_y + c->mouse_pick, c->mouse_radius); } dt_dev_add_history_item(darktable.develop, self, TRUE); } else if(event->y > height) { c->x_move = 0; float dist = fabs(p->transition_x[0] - c->mouse_x); for(int k = 1; k < DT_IOP_LOWLIGHT_BANDS; k++) { float d2 = fabs(p->transition_x[k] - c->mouse_x); if(d2 < dist) { c->x_move = k; dist = d2; } } } else { c->x_move = -1; } gtk_widget_queue_draw(widget); gint x, y; 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); return TRUE; }