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 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 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 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 gboolean
pointer_on_link (TTXWindow *self, GtkWidget *w, GdkEvent *event,
unsigned *page, unsigned *subpage)
{
GSList *cur;
GdkWindow *win;
GdkDevice *dev;
guint x, y;
dev = gdk_event_get_device (event);
win = gtk_widget_get_window (w);
gdk_window_get_device_position (win, dev, (int*)&x, (int*)&y, NULL);
for (cur = self->priv->links; cur; cur = g_slist_next (cur)) {
TTXLink *link;
link = (TTXLink*)cur->data;
if (link->left <= x && x <= link->right &&
link->top <= y && y <= link-> bottom) {
*page = link->page;
*subpage = link->subpage;
return TRUE;
}
}
return FALSE;
}
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;
}
static void
gcal_event_widget_drag_begin (GtkWidget *widget,
GdkDragContext *context)
{
GcalEventWidget *self;
cairo_surface_t *surface;
GdkWindow *window;
GdkDevice *device;
gint x, y;
GtkAllocation allocation;
self = GCAL_EVENT_WIDGET (widget);
window = gtk_widget_get_window (widget);
device = gdk_drag_context_get_device (context);
if (self->read_only)
{
gtk_drag_cancel (context);
return;
}
/* Setup the drag n' drop icon */
surface = get_dnd_icon (widget);
gtk_drag_set_icon_surface (context, surface);
/* reposition drag surface to the point the GCalEvent was */
gtk_widget_get_allocation (widget, &allocation);
gdk_window_get_device_position (window, device, &x, &y, NULL);
gdk_drag_context_set_hotspot (context, x - allocation.x, y - allocation.y);
g_clear_pointer (&surface, cairo_surface_destroy);
}
void
gw_spellcheck_record_mouse_cordinates (GwSpellcheck *spellcheck,
GdkEvent *event)
{
GwSpellcheckPrivate *priv;
GtkWidget *toplevel;
gint toplevel_x, toplevel_y;
priv = spellcheck->priv;
toplevel = GTK_WIDGET (gtk_widget_get_ancestor (GTK_WIDGET (priv->entry), GTK_TYPE_WINDOW));
gdk_window_get_device_position (
gtk_widget_get_window (GTK_WIDGET (priv->entry)),
gdk_event_get_device (event),
&toplevel_x,
&toplevel_y,
NULL
);
gtk_widget_translate_coordinates (
toplevel,
GTK_WIDGET (priv->entry),
toplevel_x,
toplevel_y,
&priv->x,
&priv->y
);
}
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 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
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
scribble_motion_notify_event (GtkWidget *widget,
GdkEventMotion *event,
gpointer data)
{
int x, y;
GdkModifierType state;
if (surface == NULL)
return FALSE; /* paranoia check, in case we haven't gotten a configure event */
/* This call is very important; it requests the next motion event.
* If you don't call gdk_window_get_pointer() you'll only get
* a single motion event. The reason is that we specified
* GDK_POINTER_MOTION_HINT_MASK to gtk_widget_set_events().
* If we hadn't specified that, we could just use event->x, event->y
* as the pointer location. But we'd also get deluged in events.
* By requesting the next event as we handle the current one,
* we avoid getting a huge number of events faster than we
* can cope.
*/
gdk_window_get_device_position (event->window, event->device, &x, &y, &state);
if (state & GDK_BUTTON1_MASK)
draw_brush (widget, x, y);
/* We've handled it, stop processing */
return TRUE;
}
/**
* 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;
}
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);
}
}
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;
}
static gboolean
gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
{
if (gdk_event->window != gtk_widget_get_window(widget))
return false;
if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE;
int x = int(gdk_event->x);
int y = int(gdk_event->y);
if (gdk_event->is_hint)
{
#ifdef __WXGTK3__
gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL);
#else
gdk_window_get_pointer(gdk_event->window, &x, &y, NULL);
#endif
}
if (!win->m_isDragging)
{
if (win->GetWindowStyle() & wxRESIZE_BORDER)
{
GdkCursor* cursor = NULL;
GdkWindow* window = gtk_widget_get_window(widget);
if ((x > win->m_width-14) && (y > win->m_height-14))
{
GdkDisplay* display = gdk_window_get_display(window);
cursor = gdk_cursor_new_for_display(display, GDK_BOTTOM_RIGHT_CORNER);
}
gdk_window_set_cursor(window, cursor);
if (cursor)
{
#ifdef __WXGTK3__
g_object_unref(cursor);
#else
gdk_cursor_unref(cursor);
#endif
}
}
return TRUE;
}
win->m_oldX = x - win->m_diffX;
win->m_oldY = y - win->m_diffY;
int org_x = 0;
int org_y = 0;
gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
x += org_x - win->m_diffX;
y += org_y - win->m_diffY;
gtk_window_move( GTK_WINDOW(win->m_widget), x, y );
return TRUE;
}
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;
}
G_MODULE_EXPORT
gboolean chart_da_motion_notify_event (GtkWidget *widget, GdkEventMotion *event, gpointer data)
{
gint x, y;
gdk_window_get_device_position (event->window, event->device, &x, &y, NULL);
if (chart_set_end_scale (x, y))
gtk_widget_queue_draw (chart_da);
return TRUE;
}
void
_gtk_tooltip_focus_in (GtkWidget *widget)
{
gint x, y;
gboolean return_value = FALSE;
GdkDisplay *display;
GtkTooltip *tooltip;
GdkDevice *device;
/* Get current tooltip for this display */
display = gtk_widget_get_display (widget);
tooltip = g_object_get_data (G_OBJECT (display),
"gdk-display-current-tooltip");
/* Check if keyboard mode is enabled at this moment */
if (!tooltip || !tooltip->keyboard_mode_enabled)
return;
device = gtk_get_current_event_device ();
if (device && gdk_device_get_source (device) == GDK_SOURCE_KEYBOARD)
device = gdk_device_get_associated_device (device);
/* This function should be called by either a focus in event,
* or a key binding. In either case there should be a device.
*/
if (!device)
return;
if (tooltip->keyboard_widget)
g_object_unref (tooltip->keyboard_widget);
tooltip->keyboard_widget = g_object_ref (widget);
gdk_window_get_device_position (gtk_widget_get_window (widget),
device, &x, &y, NULL);
return_value = gtk_tooltip_run_requery (&widget, tooltip, &x, &y);
if (!return_value)
{
gtk_tooltip_hide_tooltip (tooltip);
return;
}
if (!tooltip->current_window)
{
if (gtk_widget_get_tooltip_window (widget))
tooltip->current_window = gtk_widget_get_tooltip_window (widget);
else
tooltip->current_window = GTK_WINDOW (GTK_TOOLTIP (tooltip)->window);
}
gtk_tooltip_show_tooltip (display);
}
static gboolean _lib_ratings_motion_notify_callback(GtkWidget *widget, GdkEventMotion *event,
gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
dt_lib_ratings_t *d = (dt_lib_ratings_t *)self->data;
gdk_window_get_device_position(event->window,
gdk_device_manager_get_client_pointer(
gdk_display_get_device_manager(gdk_window_get_display(event->window))),
&d->pointerx, &d->pointery, NULL);
gtk_widget_queue_draw(self->widget);
return TRUE;
}
static gboolean
chat_text_view_event_cb (EmpathyChatTextView *view,
GdkEventMotion *event,
GtkTextTag *tag)
{
static GdkCursor *hand = NULL;
static GdkCursor *beam = NULL;
GtkTextWindowType type;
GtkTextIter iter;
GdkWindow *win;
gint x, y, buf_x, buf_y;
type = gtk_text_view_get_window_type (GTK_TEXT_VIEW (view),
event->window);
if (type != GTK_TEXT_WINDOW_TEXT) {
return FALSE;
}
/* Get where the pointer really is. */
win = gtk_text_view_get_window (GTK_TEXT_VIEW (view), type);
if (!win) {
return FALSE;
}
gdk_window_get_device_position (win, event->device, &x, &y, NULL);
/* Get the iter where the cursor is at */
gtk_text_view_window_to_buffer_coords (GTK_TEXT_VIEW (view), type,
x, y,
&buf_x, &buf_y);
gtk_text_view_get_iter_at_location (GTK_TEXT_VIEW (view),
&iter,
buf_x, buf_y);
if (gtk_text_iter_has_tag (&iter, tag)) {
if (!hand) {
hand = gdk_cursor_new (GDK_HAND2);
beam = gdk_cursor_new (GDK_XTERM);
}
gdk_window_set_cursor (win, hand);
} else {
if (!beam) {
beam = gdk_cursor_new (GDK_XTERM);
}
gdk_window_set_cursor (win, beam);
}
return FALSE;
}
void
sheet_get_pointer (Sheet *sheet, gdouble *x, gdouble *y)
{
GtkWidget *widget;
GtkAdjustment *hadjustment;
GtkAdjustment *vadjustment;
gdouble value, x1, y1;
gint _x, _y;
GdkDeviceManager *device_manager;
GdkDevice *device_pointer;
GdkRectangle allocation;
// gtk_widget_get_pointer (GTK_WIDGET (sheet), &_x, &_y);
// replaced by a code copied from evince
if (!gtk_widget_get_realized (GTK_WIDGET (sheet)))
return;
device_manager = gdk_display_get_device_manager (
gtk_widget_get_display (GTK_WIDGET (sheet)));
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (sheet)),
device_pointer,
&_x, &_y, NULL);
if (!gtk_widget_get_has_window (GTK_WIDGET (sheet)))
return;
gtk_widget_get_allocation (GTK_WIDGET (sheet), &allocation);
_x -= allocation.x;
_y -= allocation.y;
x1 = (gdouble) _x;
y1 = (gdouble) _y;
widget = gtk_widget_get_parent (GTK_WIDGET (sheet));
hadjustment = gtk_scrolled_window_get_hadjustment (
GTK_SCROLLED_WINDOW (widget));
value = gtk_adjustment_get_value (hadjustment);
x1 += value;
vadjustment = gtk_scrolled_window_get_vadjustment (
GTK_SCROLLED_WINDOW (widget));
value = gtk_adjustment_get_value (vadjustment);
y1 += value;
*x = x1;
*y = y1;
goo_canvas_convert_from_pixels (GOO_CANVAS (sheet), x, y);
snap_to_grid (sheet->grid, x, y);
}
/*
* 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!)
* x : horizontal, left to right
* y : vertical, top to bottom
* returns wether the position could be detected properly
*/
gboolean
sheet_get_pointer_pixel (Sheet *sheet, gdouble *x, gdouble *y)
{
GtkAdjustment *hadj, *vadj;
gdouble x1, y1;
gint _x, _y;
GdkDeviceManager *device_manager;
GdkDevice *device_pointer;
GdkRectangle allocation;
// 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 not realized");
return FALSE;
}
device_manager = gdk_display_get_device_manager (
gtk_widget_get_display (GTK_WIDGET (sheet)));
device_pointer = gdk_device_manager_get_client_pointer (device_manager);
//FIXME add another check based on the following functions return val
//FIXME gtkdoc says this shall not be used in event handlers
gdk_window_get_device_position (gtk_widget_get_window (GTK_WIDGET (sheet)),
device_pointer,
&_x, &_y, NULL);
if (!gtk_widget_get_has_window (GTK_WIDGET (sheet))) {
NG_DEBUG ("some weird gtk window shit failed");
return FALSE;
}
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;
}
static gboolean _lib_navigation_motion_notify_callback(GtkWidget *widget, GdkEventMotion *event,
gpointer user_data)
{
dt_lib_module_t *self = (dt_lib_module_t *)user_data;
GtkAllocation allocation;
gtk_widget_get_allocation(widget, &allocation);
_lib_navigation_set_position(self, event->x, event->y, allocation.width, allocation.height);
gint x, y; // notify gtk for motion_hint.
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;
}
static gboolean on_motion_notify_event (GtkWidget *widget, GdkEventMotion *event, struct UgtkScheduleForm* sform)
{
gint x, y;
gchar* string;
cairo_t* cr;
GdkWindow* gdkwin;
GdkModifierType mod;
UgtkScheduleState state;
gdkwin = gtk_widget_get_window (widget);
gdk_window_get_device_position (gdkwin, event->device, &x, &y, &mod);
x -= sform->drawing_offset;
x /= GRID_WIDTH_LINE;
y /= GRID_HEIGHT_LINE;
if (x < 0 || y < 0 || x >= 24 || y >= 7) {
// clear time_tips
gtk_label_set_text (sform->time_tips, "");
return FALSE;
}
// update time_tips
string = g_strdup_printf ("%s, %.2d:00 - %.2d:59",
gettext (week_days[y]), x, x);
gtk_label_set_text (sform->time_tips, string);
g_free (string);
// if no button press
if ((mod & GDK_BUTTON1_MASK) == 0)
return FALSE;
state = sform->last_state;
sform->state[y][x] = state;
// cairo
cr = gdk_cairo_create (gdkwin);
cairo_rectangle (cr,
sform->drawing_offset, 0,
GRID_WIDTH_ALL, GRID_HEIGHT_ALL);
cairo_clip (cr);
cairo_set_source_rgb (cr,
colors [state][0],
colors [state][1],
colors [state][2]);
cairo_rectangle (cr,
(gdouble)x * GRID_WIDTH_LINE + 1.0 + 0.5 + sform->drawing_offset,
(gdouble)y * GRID_HEIGHT_LINE + 1.0 + 0.5,
GRID_WIDTH - 0.5,
GRID_HEIGHT - 0.5);
cairo_fill (cr);
cairo_destroy (cr);
return TRUE;
}
static gboolean
gtk_window_motion_notify_callback( GtkWidget *widget, GdkEventMotion *gdk_event, wxMiniFrame *win )
{
if (gdk_event->window != gtk_widget_get_window(widget))
return false;
if (g_blockEventsOnDrag) return TRUE;
if (g_blockEventsOnScroll) return TRUE;
int x = int(gdk_event->x);
int y = int(gdk_event->y);
if (gdk_event->is_hint)
{
#ifdef __WXGTK3__
gdk_window_get_device_position(gdk_event->window, gdk_event->device, &x, &y, NULL);
#else
gdk_window_get_pointer(gdk_event->window, &x, &y, NULL);
#endif
}
if (!win->m_isDragging)
{
#ifndef __WXGTK3__
if (win->GetWindowStyle() & wxRESIZE_BORDER)
{
if ((x > win->m_width-14) && (y > win->m_height-14))
gdk_window_set_cursor(gtk_widget_get_window(widget), gdk_cursor_new(GDK_BOTTOM_RIGHT_CORNER));
else
gdk_window_set_cursor(gtk_widget_get_window(widget), NULL);
win->GTKUpdateCursor(false);
}
#endif
return TRUE;
}
win->m_oldX = x - win->m_diffX;
win->m_oldY = y - win->m_diffY;
int org_x = 0;
int org_y = 0;
gdk_window_get_origin(gtk_widget_get_window(widget), &org_x, &org_y);
x += org_x - win->m_diffX;
y += org_y - win->m_diffY;
win->m_x = x;
win->m_y = y;
gtk_window_move( GTK_WINDOW(win->m_widget), x, y );
return TRUE;
}
static gboolean
on_widget_motion_notify (GtkWidget *widget,
GdkEventMotion *event,
char *item_id)
{
GdkDevice *device = gdk_event_get_device ((GdkEvent*) event);
g_print ("%s received 'motion-notify' signal (window: %p)\n", item_id,
event->window);
if (event->is_hint && device)
gdk_window_get_device_position (event->window, device, NULL, NULL, NULL);
return TRUE;
}
static void
gdk_device_win32_get_state (GdkDevice *device,
GdkWindow *window,
gdouble *axes,
GdkModifierType *mask)
{
gint x_int, y_int;
gdk_window_get_device_position (window, device, &x_int, &y_int, mask);
if (axes)
{
axes[0] = x_int;
axes[1] = y_int;
}
}
static Bool
motion_notify_event(GtkWidget *widget, GdkEventMotion *event) {
GdkModifierType state;
if (event->is_hint) {
gdk_window_get_device_position (event->window, event->device, &VGUI.lastx, &VGUI.lasty, &state);
} else {
VGUI.lastx = event->x;
VGUI.lasty = event->y;
state = event->state;
}
notify_input();
//printf("motion_notify_event: %d %d %d\n", VGUI.lastbutton, VGUI.lastx, VGUI.lasty);
return FALSE;
}
