GtkCellRenderer *focus_renderer;
GdkRectangle alloc_area;
double event_x, event_y;
- int x, y;
+ double x, y;
GtkNative *native;
/* We may need some semantics to tell us the offset of the event
GtkRequisition req;
GtkAllocation alloc;
gint s, e;
+ double x, y;
gtk_widget_get_preferred_size (widget, &req, NULL);
gtk_widget_translate_coordinates (editor->sv_plane,
gtk_widget_get_parent (editor->grid),
0, -6,
- &allocation->x, &allocation->y);
+ &x, &y);
if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL)
- allocation->x = 0;
+ x = 0;
else
- allocation->x = gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width;
+ x = gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width;
}
else if (widget == editor->h_popup)
{
gtk_widget_translate_coordinates (editor->h_slider,
gtk_widget_get_parent (editor->grid),
- req.width - 6, editor->popup_position - req.height / 2,
- &allocation->x, &allocation->y);
+ &x, &y);
else
gtk_widget_translate_coordinates (editor->h_slider,
gtk_widget_get_parent (editor->grid),
alloc.width + 6, editor->popup_position - req.height / 2,
- &allocation->x, &allocation->y);
+ &x, &y);
}
else if (widget == editor->a_popup)
{
gtk_widget_translate_coordinates (editor->a_slider,
gtk_widget_get_parent (editor->grid),
editor->popup_position - req.width / 2, - req.height - 6,
- &allocation->x, &allocation->y);
+ &x, &y);
}
else
return FALSE;
- allocation->x = CLAMP (allocation->x, 0, gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width);
- allocation->y = CLAMP (allocation->y, 0, gtk_widget_get_height (GTK_WIDGET (overlay)) - req.height);
+ allocation->x = CLAMP (x, 0, gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width);
+ allocation->y = CLAMP (y, 0, gtk_widget_get_height (GTK_WIDGET (overlay)) - req.height);
return TRUE;
}
static void
gtk_drag_icon_native_get_surface_transform (GtkNative *native,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
GtkCssBoxes css_boxes;
const graphene_rect_t *margin_rect;
{
GtkWidget *widget;
GdkDevice *device;
- int x, y;
+ double x, y;
GtkNative *native;
GdkSurface *surface;
double px, py;
gtk_widget_translate_coordinates (widget, GTK_WIDGET (native), source->start_x, source->start_y, &x, &y);
gdk_surface_get_device_position (surface, device, &px, &py, NULL);
- dx = round (px) - x;
- dy = round (py) - y;
+ dx = round (px - x);
+ dy = round (py - y);
g_signal_emit (source, signals[PREPARE], 0, source->start_x, source->start_y, &content);
if (!content)
GtkEmojiChooser *chooser;
GtkAdjustment *adj;
GtkAllocation alloc;
- int pos;
+ double pos;
double value;
double page_size;
for (i = 0; i < MAX_ICONS; i++)
{
EntryIconInfo *icon_info = priv->icons[i];
- int icon_x, icon_y;
+ double icon_x, icon_y;
if (icon_info == NULL)
continue;
GtkFileChooserWidget *impl = data;
GdkRectangle rect;
gchar *filename;
+ double x, y;
gtk_tree_model_get (model, iter,
MODEL_COL_FILE, &impl->rename_file_source_file,
gtk_widget_translate_coordinates (impl->browse_files_tree_view,
GTK_WIDGET (impl),
rect.x, rect.y,
- &rect.x, &rect.y);
+ &x, &y);
+ rect.x = x;
+ rect.y = y;
filename = g_file_get_basename (impl->rename_file_source_file);
gtk_editable_set_text (GTK_EDITABLE (impl->rename_file_name_entry), filename);
gtk_widget_translate_coordinates (impl->browse_files_tree_view,
GTK_WIDGET (impl),
rect.x, rect.y,
- &rect.x, &rect.y);
+ &x, &y);
rect.x = CLAMP (x - 20, 0, bounds.size.width - 40);
+ rect.y = y;
rect.width = 40;
g_list_free_full (list, (GDestroyNotify) gtk_tree_path_free);
GtkFileChooserWidget *impl)
{
PopoverData *pd;
- int xx, yy;
pd = g_new (PopoverData, 1);
pd->impl = impl;
gtk_widget_translate_coordinates (impl->browse_files_tree_view,
GTK_WIDGET (impl),
- x, y, &xx, &yy);
- pd->x = xx;
- pd->y = yy;
+ x, y, &x, &y);
+ pd->x = x;
+ pd->y = y;
g_idle_add (file_list_show_popover_in_idle, pd);
}
{
GtkIMContextWaylandGlobal *global;
cairo_rectangle_int_t rect;
+ double x, y;
global = gtk_im_context_wayland_get_global (context);
if (global == NULL)
gtk_widget_translate_coordinates (context->widget,
GTK_WIDGET (gtk_widget_get_root (context->widget)),
rect.x, rect.y,
- &rect.x, &rect.y);
+ &x, &y);
+ rect.x = x;
+ rect.y = y;
zwp_text_input_v3_set_cursor_rectangle (global->text_input,
rect.x, rect.y,
rect.width, rect.height);
GtkNative *native;
graphene_point_t p;
double event_x, event_y;
- int native_x, native_y;
+ double native_x, native_y;
*x = *y = 0;
GtkWidget *old_target = NULL;
GdkEventSequence *sequence;
GdkDevice *device;
- gdouble x, y;
- int nx, ny;
+ double x, y;
+ double nx, ny;
device = gdk_event_get_device (event);
sequence = gdk_event_get_event_sequence (event);
GdkEventSequence *sequence;
GdkDevice *device;
double x, y;
- int native_x, native_y;
+ double native_x, native_y;
GtkWidget *native;
GdkEventType type;
static void
gtk_native_default_get_surface_transform (GtkNative *self,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
*x = 0;
*y = 0;
*/
void
gtk_native_get_surface_transform (GtkNative *self,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
g_return_if_fail (GTK_IS_NATIVE (self));
g_return_if_fail (x != NULL);
GskRenderer * (* get_renderer) (GtkNative *self);
void (* get_surface_transform) (GtkNative *self,
- int *x,
- int *y);
+ double *x,
+ double *y);
void (* check_resize) (GtkNative *self);
};
GDK_AVAILABLE_IN_ALL
void gtk_native_get_surface_transform (GtkNative *self,
- int *x,
- int *y);
+ double *x,
+ double *y);
G_END_DECLS
if (row != NULL)
{
- gint dest_y, dest_x;
-
g_object_get (row, "order-index", &row_index, NULL);
g_object_get (sidebar->row_placeholder, "order-index", &row_placeholder_index, NULL);
/* We order the bookmarks sections based on the bookmark index that we
row_placeholder_index = row_index;
gtk_widget_translate_coordinates (GTK_WIDGET (sidebar), GTK_WIDGET (row),
x, y,
- &dest_x, &dest_y);
+ &x, &y);
- if (dest_y > sidebar->drag_row_height / 2 && row_index > 0)
+ if (y > sidebar->drag_row_height / 2 && row_index > 0)
row_placeholder_index++;
}
else
if (gtk_drag_check_threshold (GTK_WIDGET (row), 0, 0, x, y))
{
- gdouble start_x, start_y;
- gint drag_x, drag_y;
+ double start_x, start_y;
+ double drag_x, drag_y;
GdkContentProvider *content;
GdkSurface *surface;
GdkDevice *device;
GtkEntry *entry)
{
GdkRectangle rect;
+ double x, y;
/* Setup the auxiliary popover's rectangle */
gtk_entry_get_icon_area (GTK_ENTRY (view->address_entry),
GTK_ENTRY_ICON_SECONDARY,
&rect);
gtk_widget_translate_coordinates (view->address_entry, GTK_WIDGET (view),
- rect.x, rect.y, &rect.x, &rect.y);
+ rect.x, rect.y, &x, &y);
+ rect.x = x;
+ rect.y = y;
gtk_popover_set_pointing_to (GTK_POPOVER (view->server_adresses_popover), &rect);
gtk_widget_set_visible (view->server_adresses_popover, TRUE);
}
static void
gtk_popover_native_get_surface_transform (GtkNative *native,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
GtkCssBoxes css_boxes;
const graphene_rect_t *margin_rect;
cairo_surface_t *cairo_surface;
cairo_region_t *region;
cairo_t *cr;
- int x, y;
- int native_x, native_y;
+ double x, y;
+ double native_x, native_y;
gtk_native_get_surface_transform (GTK_NATIVE (popover), &native_x, &native_y);
gtk_css_boxes_init (&content_css_boxes, priv->contents_widget);
double y)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
- int trough_x, trough_y;
gtk_widget_translate_coordinates (GTK_WIDGET (range), priv->trough_widget,
- x, y, &trough_x, &trough_y);
+ x, y, &x, &y);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
priv->slide_initial_slider_position = MAX (0, priv->slider_x);
- priv->slide_initial_coordinate_delta = trough_x - priv->slide_initial_slider_position;
+ priv->slide_initial_coordinate_delta = x - priv->slide_initial_slider_position;
}
else
{
priv->slide_initial_slider_position = MAX (0, priv->slider_y);
- priv->slide_initial_coordinate_delta = trough_y - priv->slide_initial_slider_position;
+ priv->slide_initial_coordinate_delta = y - priv->slide_initial_slider_position;
}
}
(!primary_warps && shift_pressed && button == GDK_BUTTON_PRIMARY) ||
(!primary_warps && button == GDK_BUTTON_MIDDLE)))
{
- int slider_range_x, slider_range_y;
+ double slider_range_x, slider_range_y;
graphene_rect_t slider_bounds;
gtk_widget_translate_coordinates (priv->trough_widget, widget,
gdouble mark_delta;
gdouble zoom;
gint i;
+ double x, y;
gtk_widget_translate_coordinates (GTK_WIDGET (range), priv->trough_widget,
- mouse_x, mouse_y, &mouse_x, &mouse_y);
+ mouse_x, mouse_y, &x, &y);
if (priv->zoom &&
gtk_widget_compute_bounds (priv->trough_widget, priv->trough_widget, &trough_bounds))
zoom_divisor = zoom - 1.0;
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
- priv->slide_initial_slider_position = (zoom * (mouse_y - priv->slide_initial_coordinate_delta) - slider_bounds.origin.y) / zoom_divisor;
+ priv->slide_initial_slider_position = (zoom * (y - priv->slide_initial_coordinate_delta) - slider_bounds.origin.y) / zoom_divisor;
else
- priv->slide_initial_slider_position = (zoom * (mouse_x - priv->slide_initial_coordinate_delta) - slider_bounds.origin.x) / zoom_divisor;
+ priv->slide_initial_slider_position = (zoom * (x - priv->slide_initial_coordinate_delta) - slider_bounds.origin.x) / zoom_divisor;
}
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
- delta = mouse_y - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
+ delta = y - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
else
- delta = mouse_x - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
+ delta = x - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
c = priv->slide_initial_slider_position + zoom * delta;
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
GdkRectangle slider;
+ double x, y;
gint i;
for (i = 0; i < priv->n_marks; i++)
{
gtk_range_compute_slider_position (range, priv->marks[i], &slider);
gtk_widget_translate_coordinates (priv->trough_widget, GTK_WIDGET (range),
- slider.x, slider.y, &slider.x, &slider.y);
+ slider.x, slider.y, &x, &y);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
- priv->mark_pos[i] = slider.x + slider.width / 2;
+ priv->mark_pos[i] = x + slider.width / 2;
else
- priv->mark_pos[i] = slider.y + slider.height / 2;
+ priv->mark_pos[i] = y + slider.height / 2;
}
}
static void
gtk_text_handle_native_get_surface_transform (GtkNative *native,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
GtkCssBoxes css_boxes;
const graphene_rect_t *margin_rect;
GdkPopupLayout *layout;
GdkRectangle rect;
GtkRequisition req;
+ double x, y;
gtk_widget_get_preferred_size (widget, NULL, &req);
gtk_text_handle_get_padding (handle, &handle->border);
gtk_widget_translate_coordinates (gtk_widget_get_parent (widget),
gtk_widget_get_ancestor (widget, GTK_TYPE_WINDOW),
- rect.x, rect.y, &rect.x, &rect.y);
+ rect.x, rect.y, &x, &y);
+ rect.x = x;
+ rect.y = y;
if (handle->role == GTK_TEXT_HANDLE_ROLE_CURSOR)
rect.x -= rect.width / 2;
GtkNative *native;
GdkSurface *surface;
double px, py;
- int nx, ny;
+ double nx, ny;
native = gtk_widget_get_native (GTK_WIDGET (text_view));
surface = gtk_native_get_surface (native);
gdk_surface_get_device_position (surface, device, &px, &py, NULL);
gtk_native_get_surface_transform (native, &nx, &ny);
- rect.x = round (px) - nx;
- rect.y = round (py) - ny;
gtk_widget_translate_coordinates (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (text_view))),
GTK_WIDGET (text_view),
- rect.x, rect.y,
- &rect.x, &rect.y);
+ px - nx, py - ny,
+ &px, &py);
+ rect.x = px;
+ rect.y = py;
}
gtk_popover_set_pointing_to (GTK_POPOVER (priv->popup_menu), &rect);
GdkSurface *surface;
double x, y;
GtkWidget *toplevel;
- int dx, dy;
g_return_if_fail (GTK_IS_WIDGET (widget));
if (gtk_native_get_surface (GTK_NATIVE (toplevel)) != surface)
return;
- gtk_widget_translate_coordinates (toplevel, widget, round (x), round (y), &dx, &dy);
+ gtk_widget_translate_coordinates (toplevel, widget, x, y, &x, &y);
- gtk_tooltip_handle_event_internal (GDK_MOTION_NOTIFY, surface, widget, dx, dy);
+ gtk_tooltip_handle_event_internal (GDK_MOTION_NOTIFY, surface, widget, x, y);
}
static void
{
GtkWidget *event_widget;
GtkWidget *picked_widget;
- int native_x, native_y;
+ double x, y;
+ double native_x, native_y;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
return NULL;
gtk_native_get_surface_transform (GTK_NATIVE (event_widget), &native_x, &native_y);
- surface_x -= native_x;
- surface_y -= native_y;
+ x = surface_x - native_x;
+ y = surface_y - native_y;
- picked_widget = gtk_widget_pick (event_widget, surface_x, surface_y, GTK_PICK_INSENSITIVE);
+ picked_widget = gtk_widget_pick (event_widget, x, y, GTK_PICK_INSENSITIVE);
if (picked_widget != NULL)
- gtk_widget_translate_coordinates (event_widget, picked_widget, surface_x, surface_y, widget_x, widget_y);
+ gtk_widget_translate_coordinates (event_widget, picked_widget, x, y, &x, &y);
+
+ *widget_x = x;
+ *widget_y = y;
return picked_widget;
}
if (!return_value)
{
- GtkWidget *parent = gtk_widget_get_parent (*widget);
+ GtkWidget *parent = gtk_widget_get_parent (*widget);
+
+ if (parent)
+ {
+ double xx = *x;
+ double yy = *y;
+
+ gtk_widget_translate_coordinates (*widget, parent, xx, yy, &xx, &yy);
- if (parent)
- gtk_widget_translate_coordinates (*widget, parent, *x, *y, x, y);
+ *x = xx;
+ *y = yy;
+ }
- *widget = parent;
- }
+ *widget = parent;
+ }
else
- break;
+ break;
}
while (*widget);
int rect_anchor_dx = 0;
int cursor_size;
int anchor_rect_padding;
- int native_x, native_y;
+ double native_x, native_y;
gtk_widget_realize (GTK_WIDGET (tooltip->window));
GdkEventType event_type;
GdkSurface *surface;
double x, y;
- int native_x, native_y;
- int tx, ty;
+ double nx, ny;
GtkWidget *native;
if (!tooltips_enabled (event))
gdk_event_get_position (event, &x, &y);
native = GTK_WIDGET (gtk_widget_get_native (target));
- gtk_native_get_surface_transform (GTK_NATIVE (native), &native_x, &native_y);
- gtk_widget_translate_coordinates (native, target,
- x - native_x,
- y - native_y,
- &tx, &ty);
-
- gtk_tooltip_handle_event_internal (event_type, surface, target, tx, ty);
+ gtk_native_get_surface_transform (GTK_NATIVE (native), &nx, &ny);
+ gtk_widget_translate_coordinates (native, target, x - nx, y - ny, &x, &y);
+ gtk_tooltip_handle_event_internal (event_type, surface, target, x, y);
}
/* dx/dy must be in @target_widget's coordinates */
gtk_tooltip_handle_event_internal (GdkEventType event_type,
GdkSurface *surface,
GtkWidget *target_widget,
- gdouble dx,
- gdouble dy)
+ double dx,
+ double dy)
{
int x = dx, y = dy;
GdkDisplay *display;
static void
gtk_tooltip_window_native_get_surface_transform (GtkNative *native,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
GtkCssBoxes css_boxes;
const graphene_rect_t *margin_rect;
GtkRoot *root;
GtkWidget *focus_widget;
graphene_rect_t rect;
- int x, y;
+ double x, y;
if ((gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_FOCUS_WITHIN) == 0)
return;
return;
gtk_widget_translate_coordinates (viewport->child, widget,
- (int)rect.origin.x,
- (int)rect.origin.y,
+ rect.origin.x,
+ rect.origin.y,
&x, &y);
scroll_to_view (viewport->hadjustment, x, rect.size.width);
{
GtkWidget *parent;
graphene_rect_t bounds;
- int nx, ny;
+ double nx, ny;
/* Don't consider the parent == widget case here. */
parent = _gtk_widget_get_parent (widget);
gboolean
gtk_widget_translate_coordinates (GtkWidget *src_widget,
GtkWidget *dest_widget,
- gint src_x,
- gint src_y,
- gint *dest_x,
- gint *dest_y)
+ double src_x,
+ double src_y,
+ double *dest_x,
+ double *dest_y)
{
graphene_point_t p;
graphene_point_t p;
double event_x, event_y;
GtkNative *native;
- int nx, ny;
+ double nx, ny;
*x = *y = 0;
GtkSnapshot *snapshot;
GskRenderer *renderer;
GskRenderNode *root;
- int x, y;
+ double x, y;
gint64 before_snapshot = g_get_monotonic_time ();
gint64 before_render = 0;
GDK_AVAILABLE_IN_ALL
gboolean gtk_widget_translate_coordinates (GtkWidget *src_widget,
GtkWidget *dest_widget,
- gint src_x,
- gint src_y,
- gint *dest_x,
- gint *dest_y);
+ double src_x,
+ double src_y,
+ double *dest_x,
+ double *dest_y);
GDK_AVAILABLE_IN_ALL
gboolean gtk_widget_contains (GtkWidget *widget,
static void
gtk_window_native_get_surface_transform (GtkNative *native,
- int *x,
- int *y)
+ double *x,
+ double *y)
{
const graphene_rect_t *margin_rect;
GtkCssBoxes boxes;
GtkNative *native;
GdkSurface *surface;
double px, py;
- int nx, ny;
+ double nx, ny;
native = gtk_widget_get_native (GTK_WIDGET (self));
surface = gtk_native_get_surface (native);
gdk_surface_get_device_position (surface, device, &px, &py, NULL);
gtk_native_get_surface_transform (native, &nx, &ny);
- rect.x = round (px) - nx;
- rect.y = round (py) - ny;
gtk_widget_translate_coordinates (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (self))),
GTK_WIDGET (self),
- rect.x, rect.y,
- &rect.x, &rect.y);
+ px - nx, py - ny,
+ &px, &py);
+ rect.x = px;
+ rect.y = py;
}
gtk_popover_set_pointing_to (GTK_POPOVER (self->fallback_menu), &rect);
{
GdkEventSequence *sequence;
double start_x, start_y;
- int native_x, native_y;
- int window_x, window_y;
+ double native_x, native_y;
+ double window_x, window_y;
GtkNative *native;
GdkSurface *surface;
GtkFocusOverlay *self = GTK_FOCUS_OVERLAY (overlay);
GtkWidget *focus;
graphene_rect_t bounds;
- int nx, ny;
+ double nx, ny;
if (!GTK_IS_NATIVE (widget))
return;
if (widget)
{
double x, y;
- int nx, ny;
+ double nx, ny;
gdk_surface_get_device_position (gtk_native_get_surface (GTK_NATIVE (widget)),
device, &x, &y, NULL);
GskRenderNode *node,
GtkWidget *widget)
{
- int nx, ny;
+ double nx, ny;
gtk_native_get_surface_transform (GTK_NATIVE (widget), &nx, &ny);
gtk_snapshot_save (snapshot);
GtkAllocation label_allocation;
GtkRequisition minimum_size, natural_size;
GtkWidget *label = data;
- gint x, y;
+ double x, y;
cairo_translate (cr, -0.5, -0.5);
cairo_set_line_width (cr, 1);
GtkWidget *row;
GtkAllocation alloc;
GdkPaintable *paintable;
- int x, y;
+ double x, y;
row = gtk_widget_get_ancestor (widget, GTK_TYPE_LIST_BOX_ROW);
gtk_widget_get_allocation (row, &alloc);
GtkRequisition req;
GtkWidget *child;
GtkAllocation main_alloc;
- gint x, y;
+ double x, y;
child = gtk_overlay_get_child (GTK_OVERLAY (overlay));
for (x = 0; x < G_N_ELEMENTS (points); x ++)
{
- int px, py;
+ double px, py;
gtk_widget_translate_coordinates (self->test_widget, widget,
points[x].coords.x, points[x].coords.y,
GdkEvent *event;
guint button;
guint32 timestamp;
- int xx = x;
- int yy = y;
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
surface = gtk_native_get_surface (gtk_widget_get_native (widget));
event = gtk_event_controller_get_current_event (GTK_EVENT_CONTROLLER (gesture));
if (gdk_event_get_event_type (event) == GDK_BUTTON_PRESS)
- button = gdk_button_event_get_button (event);
+ button = gdk_button_event_get_button (event);
else
button = 0;
timestamp = gdk_event_get_time (event);
gtk_widget_translate_coordinates (widget, GTK_WIDGET (gtk_widget_get_root (widget)),
- xx, yy, &xx, &yy);
- gdk_toplevel_begin_resize (GDK_TOPLEVEL (surface), edge, gdk_event_get_device (event), button, xx, yy, timestamp);
+ x, y, &x, &y);
+ gdk_toplevel_begin_resize (GDK_TOPLEVEL (surface), edge, gdk_event_get_device (event), button, x, y, timestamp);
gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
}
GdkEvent *event;
guint button;
guint32 timestamp;
- int xx = x;
- int yy = y;
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
surface = gtk_native_get_surface (gtk_widget_get_native (widget));
event = gtk_event_controller_get_current_event (GTK_EVENT_CONTROLLER (gesture));
if (gdk_event_get_event_type (event) == GDK_BUTTON_PRESS)
- button = gdk_button_event_get_button (event);
+ button = gdk_button_event_get_button (event);
else
button = 0;
timestamp = gdk_event_get_time (event);
gtk_widget_translate_coordinates (widget, GTK_WIDGET (gtk_widget_get_root (widget)),
- xx, yy, &xx, &yy);
- gdk_toplevel_begin_move (GDK_TOPLEVEL (surface), gdk_event_get_device (event), button, xx, yy, timestamp);
+ x, y, &x, &y);
+ gdk_toplevel_begin_move (GDK_TOPLEVEL (surface), gdk_event_get_device (event), button, x, y, timestamp);
gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
}
projects / gtk4.git / commitdiff