GtkWidget *canvas = gtk_widget_get_parent (GTK_WIDGET (item));
GtkWidget *entry;
GtkWidget *scale;
- double x, y;
+ graphene_point_t p;
if (item->editor)
return;
gtk_box_append (GTK_BOX (item->editor), scale);
- gtk_widget_translate_coordinates (GTK_WIDGET (item), canvas, 0, 0, &x, &y);
- gtk_fixed_put (GTK_FIXED (canvas), item->editor, x, y + 2 * item->r);
+ if (!gtk_widget_compute_point (GTK_WIDGET (item), canvas, &GRAPHENE_POINT_INIT (0, 0), &p))
+ graphene_point_init (&p, 0, 0);
+ gtk_fixed_put (GTK_FIXED (canvas), item->editor, p.x, p.y + 2 * item->r);
gtk_widget_grab_focus (entry);
}
GtkWidget *canvas;
GtkWidget *item;
Hotspot *hotspot;
+ graphene_point_t p;
canvas = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (source));
item = gtk_widget_pick (canvas, x, y, GTK_PICK_DEFAULT);
g_object_set_data (G_OBJECT (canvas), "dragged-item", item);
hotspot = g_new (Hotspot, 1);
- gtk_widget_translate_coordinates (canvas, item, x, y, &hotspot->x, &hotspot->y);
+ if (!gtk_widget_compute_point (canvas, item, &GRAPHENE_POINT_INIT (x, y), &p))
+ graphene_point_init (&p, x, y);
+ hotspot->x = p.x;
+ hotspot->y = p.y;
g_object_set_data_full (G_OBJECT (canvas), "hotspot", hotspot, g_free);
return gdk_content_provider_new_typed (GTK_TYPE_WIDGET, item);
int *xo,
int *yo)
{
- double x = xi;
- double y = yi;
+ graphene_point_t p;
+ GtkWidget *source;
switch (coordtype)
{
case ATSPI_COORD_TYPE_SCREEN:
g_warning ("Screen coordinates not supported, reported positions will be wrong");
- G_GNUC_FALLTHROUGH;
+ return;
case ATSPI_COORD_TYPE_WINDOW:
- gtk_widget_translate_coordinates (GTK_WIDGET (gtk_widget_get_root (widget)),
- widget,
- x, y,
- &x, &y);
+ source = GTK_WIDGET (gtk_widget_get_root (widget));
break;
case ATSPI_COORD_TYPE_PARENT:
- gtk_widget_translate_coordinates (gtk_widget_get_parent (widget),
- widget,
- x, y,
- &x, &y);
+ source = gtk_widget_get_parent (widget);
break;
default:
g_assert_not_reached ();
}
- *xo = (int)x;
- *yo = (int)y;
+ if (!gtk_widget_compute_point (source, widget, &GRAPHENE_POINT_INIT (xi, yi), &p))
+ graphene_point_init (&p, xi, yi);
+
+ *xo = (int)p.x;
+ *yo = (int)p.y;
}
static void
int *xo,
int *yo)
{
- double x = xi;
- double y = yi;
+ graphene_point_t p;
+ GtkWidget *target;
switch (coordtype)
{
case ATSPI_COORD_TYPE_SCREEN:
g_warning ("Screen coordinates not supported, reported positions will be wrong");
- G_GNUC_FALLTHROUGH;
+ return;
case ATSPI_COORD_TYPE_WINDOW:
- gtk_widget_translate_coordinates (widget,
- GTK_WIDGET (gtk_widget_get_root (widget)),
- x, y,
- &x, &y);
+ target = GTK_WIDGET (gtk_widget_get_root (widget));
break;
case ATSPI_COORD_TYPE_PARENT:
- gtk_widget_translate_coordinates (widget,
- gtk_widget_get_parent (widget),
- x, y,
- &x, &y);
+ target = gtk_widget_get_parent (widget);
break;
default:
g_assert_not_reached ();
}
- *xo = (int)x;
- *yo = (int)y;
+ if (!gtk_widget_compute_point (widget, target, &GRAPHENE_POINT_INIT (xi, yi), &p))
+ graphene_point_init (&p, xi, yi);
+
+ *xo = (int)p.x;
+ *yo = (int)p.y;
}
static void
rect.x, rect.y,
&x, &y);
- double dx, dy;
- gtk_widget_translate_coordinates (widget,
- GTK_WIDGET (gtk_widget_get_native (widget)),
- (double) x, (double) y, &dx, &dy);
- x = floor (dx);
- y = floor (dy);
+ graphene_point_t p;
+ if (!gtk_widget_compute_point (widget, GTK_WIDGET (gtk_widget_get_native (widget)),
+ &GRAPHENE_POINT_INIT (x, y), &p))
+ graphene_point_init (&p, x, y);
+ x = floor (p.x);
+ y = floor (p.y);
g_dbus_method_invocation_return_value (invocation,
g_variant_new ("(iiii)",
GtkRequisition req;
GtkAllocation alloc;
int s, e;
- double x, y;
+ graphene_point_t p;
gtk_widget_get_preferred_size (widget, &req, NULL);
if (widget == editor->sv_popup)
{
- gtk_widget_translate_coordinates (editor->sv_plane,
- gtk_widget_get_parent (editor->grid),
- 0, -6,
- &x, &y);
+ if (!gtk_widget_compute_point (editor->sv_plane,
+ gtk_widget_get_parent (editor->grid),
+ &GRAPHENE_POINT_INIT (0, -6),
+ &p))
+ return FALSE;
if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL)
- x = 0;
+ p.x = 0;
else
- x = gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width;
+ p.x = gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width;
}
else if (widget == editor->h_popup)
{
gtk_widget_get_allocation (editor->h_slider, &alloc);
gtk_range_get_slider_range (GTK_RANGE (editor->h_slider), &s, &e);
- if (gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL)
- gtk_widget_translate_coordinates (editor->h_slider,
- gtk_widget_get_parent (editor->grid),
- - req.width - 6, editor->popup_position - req.height / 2,
- &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,
- &x, &y);
+ if (!gtk_widget_compute_point (editor->h_slider,
+ gtk_widget_get_parent (editor->grid),
+ gtk_widget_get_direction (GTK_WIDGET (overlay)) == GTK_TEXT_DIR_RTL
+ ? &GRAPHENE_POINT_INIT (- req.width - 6, editor->popup_position - req.height / 2)
+ : &GRAPHENE_POINT_INIT (alloc.width + 6, editor->popup_position - req.height / 2),
+ &p))
+ return FALSE;
}
else if (widget == editor->a_popup)
{
gtk_widget_get_allocation (editor->a_slider, &alloc);
gtk_range_get_slider_range (GTK_RANGE (editor->a_slider), &s, &e);
- gtk_widget_translate_coordinates (editor->a_slider,
- gtk_widget_get_parent (editor->grid),
- editor->popup_position - req.width / 2, - req.height - 6,
- &x, &y);
+ if (!gtk_widget_compute_point (editor->a_slider,
+ gtk_widget_get_parent (editor->grid),
+ &GRAPHENE_POINT_INIT (editor->popup_position - req.width / 2, - req.height - 6),
+ &p))
+ return FALSE;
}
else
return FALSE;
- 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);
+ allocation->x = CLAMP (p.x, 0, gtk_widget_get_width (GTK_WIDGET (overlay)) - req.width);
+ allocation->y = CLAMP (p.y, 0, gtk_widget_get_height (GTK_WIDGET (overlay)) - req.height);
return TRUE;
}
{
double width;
double delta;
- double vx, vy;
+ graphene_point_t v;
/* x is in header coordinates */
- gtk_widget_translate_coordinates (self->header, GTK_WIDGET (self), x, 0, &vx, &vy);
+ if (!gtk_widget_compute_point (self->header, GTK_WIDGET (self),
+ &GRAPHENE_POINT_INIT (x, 0),
+ &v))
+ graphene_point_init (&v, 0, 0);
width = gtk_widget_get_width (GTK_WIDGET (self));
- if (vx < SCROLL_EDGE_SIZE)
- delta = - (SCROLL_EDGE_SIZE - vx)/3.0;
- else if (width - vx < SCROLL_EDGE_SIZE)
- delta = (SCROLL_EDGE_SIZE - (width - vx))/3.0;
+ if (v.x < SCROLL_EDGE_SIZE)
+ delta = - (SCROLL_EDGE_SIZE - v.x)/3.0;
+ else if (width - v.x < SCROLL_EDGE_SIZE)
+ delta = (SCROLL_EDGE_SIZE - (width - v.x))/3.0;
else
delta = 0;
{
GtkWidget *widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (motion));
GtkColumnView *self = GTK_COLUMN_VIEW (widget);
- double hx, hy;
+ graphene_point_t h;
- gtk_widget_translate_coordinates (widget, self->header, x, 0, &hx, &hy);
- update_autoscroll (GTK_COLUMN_VIEW (widget), hx);
+ if (!gtk_widget_compute_point (widget, self->header,
+ &GRAPHENE_POINT_INIT (x, 0), &h))
+ graphene_point_init (&h, 0, 0);
+ update_autoscroll (GTK_COLUMN_VIEW (widget), h.x);
}
static void
GtkWidget *widget;
GdkDevice *device, *pointer;
GdkSeat *seat;
- double x, y;
+ graphene_point_t p;
GtkNative *native;
GdkSurface *surface;
double px, py;
native = gtk_widget_get_native (widget);
surface = gtk_native_get_surface (native);
- gtk_widget_translate_coordinates (widget, GTK_WIDGET (native), source->start_x, source->start_y, &x, &y);
+ if (!gtk_widget_compute_point (widget, GTK_WIDGET (native),
+ &GRAPHENE_POINT_INIT (source->start_x, source->start_y),
+ &p))
+ return;
+
gdk_surface_get_device_position (surface, pointer, &px, &py, NULL);
- dx = round (px - x);
- dy = round (py - y);
+ dx = round (px - p.x);
+ dy = round (py - p.y);
g_signal_emit (source, signals[PREPARE], 0, source->start_x, source->start_y, &content);
if (!content)
GtkEmojiChooser *chooser;
GtkAdjustment *adj;
GtkAllocation alloc;
- double pos;
+ graphene_point_t p;
double value;
double page_size;
value = gtk_adjustment_get_value (adj);
page_size = gtk_adjustment_get_page_size (adj);
- gtk_widget_translate_coordinates (child, gtk_widget_get_parent (chooser->recent.box), 0, 0, NULL, &pos);
+ if (!gtk_widget_compute_point (child, gtk_widget_get_parent (chooser->recent.box),
+ &GRAPHENE_POINT_INIT (0, 0), &p))
+ return;
- if (pos < value)
- gtk_adjustment_animate_to_value (adj, pos);
- else if (pos + alloc.height >= value + page_size)
- gtk_adjustment_animate_to_value (adj, value + ((pos + alloc.height) - (value + page_size)));
+ if (p.y < value)
+ gtk_adjustment_animate_to_value (adj, p.y);
+ else if (p.y + alloc.height >= value + page_size)
+ gtk_adjustment_animate_to_value (adj, value + ((p.y + alloc.height) - (value + page_size)));
}
static void
for (i = 0; i < MAX_ICONS; i++)
{
EntryIconInfo *icon_info = priv->icons[i];
- double icon_x, icon_y;
+ graphene_point_t p;
if (icon_info == NULL)
continue;
- gtk_widget_translate_coordinates (GTK_WIDGET (entry), icon_info->widget,
- x, y, &icon_x, &icon_y);
+ if (!gtk_widget_compute_point (GTK_WIDGET (entry), icon_info->widget,
+ &GRAPHENE_POINT_INIT (x, y), &p))
+ continue;
- if (gtk_widget_contains (icon_info->widget, icon_x, icon_y))
+ if (gtk_widget_contains (icon_info->widget, p.x, p.y))
return i;
}
GtkWidget *widget = GTK_WIDGET (self);
GtkSelectionModel *model;
GtkWidget *impl;
- double xx, yy;
+ graphene_point_t p;
impl = gtk_widget_get_ancestor (widget, GTK_TYPE_FILE_CHOOSER_WIDGET);
model = gtk_file_chooser_widget_get_selection_model (GTK_FILE_CHOOSER_WIDGET (impl));
gtk_selection_model_select_item (model, self->position, TRUE);
- gtk_widget_translate_coordinates (widget, GTK_WIDGET (impl),
- x, y, &xx, &yy);
+ if (!gtk_widget_compute_point (widget, GTK_WIDGET (impl),
+ &GRAPHENE_POINT_INIT (x, y), &p))
+ return;
gtk_widget_activate_action (widget, "item.popup-file-list-menu",
- "(udd)", self->position, xx, yy);
+ "(udd)", self->position, p.x, p.y);
}
static void
double *x,
double *y)
{
+ graphene_point_t p;
+
g_return_if_fail (GTK_IS_FIXED (fixed));
g_return_if_fail (GTK_IS_WIDGET (widget));
g_return_if_fail (x != NULL);
g_return_if_fail (y != NULL);
g_return_if_fail (gtk_widget_get_parent (widget) == GTK_WIDGET (fixed));
- gtk_widget_translate_coordinates (widget, GTK_WIDGET (fixed), 0, 0, x, y);
+
+ if (!gtk_widget_compute_point (widget, GTK_WIDGET (fixed),
+ &GRAPHENE_POINT_INIT (0, 0), &p))
+ graphene_point_init (&p, 0, 0);
+
+ *x = p.x;
+ *y = p.y;
}
/**
GtkNative *native = gtk_native_get_for_surface (context_ime->client_surface);
if G_LIKELY (native)
{
- double x = 0.0;
- double y = 0.0;
+ graphene_point_t p;
double decor_x = 0.0;
double decor_y = 0.0;
- gtk_widget_translate_coordinates (context_ime->client_widget,
- GTK_WIDGET (native),
- 0.0, 0.0, &x, &y);
+ if (!gtk_widget_compute_point (context_ime->client_widget,
+ GTK_WIDGET (native),
+ &GRAPHENE_POINT_INIT (0, 0), &p))
+ graphene_point_init (&p, 0, 0);
gtk_native_get_surface_transform (native, &decor_x, &decor_y);
- x += decor_x;
- y += decor_y;
+ p.x += decor_x;
+ p.y += decor_y;
- wx = (int) x;
- wy = (int) y;
+ wx = (int) p.x;
+ wy = (int) p.y;
}
scale = gtk_widget_get_scale_factor (context_ime->client_widget);
GtkIMContextQuartz *qc = GTK_IM_CONTEXT_QUARTZ (context);
GtkWidget* surface_widget;
int sx, sy;
- double wx, wy;
+ graphene_point_t p;
GTK_DEBUG (MODULES, "quartz_set_cursor_location");
return;
gdk_surface_get_origin (qc->client_surface, &sx, &sy);
- gtk_widget_translate_coordinates(qc->client_widget, surface_widget,
- area->x, area->y, &wx, &wy);
+ if (!gtk_widget_compute_point (qc->client_widget, surface_widget,
+ &GRAPHENE_POINT_INIT (area->x, area->y), &p))
+ graphene_point_init (&p, area->x, area->y);
- qc->cursor_rect->x = sx + (int) wx;
- qc->cursor_rect->y = sy + (int) wy;
+ qc->cursor_rect->x = sx + (int) p.x;
+ qc->cursor_rect->y = sy + (int) p.y;
qc->cursor_rect->width = area->width;
qc->cursor_rect->height = area->height;
{
GtkIMContextWaylandGlobal *global;
cairo_rectangle_int_t rect;
- double x, y, sx, sy;
+ double nx, ny;
+ graphene_point_t p;
global = gtk_im_context_wayland_get_global (context);
if (global == NULL)
return;
rect = context->cursor_rect;
- gtk_widget_translate_coordinates (context->widget,
- GTK_WIDGET (gtk_widget_get_root (context->widget)),
- rect.x, rect.y,
- &x, &y);
+ if (!gtk_widget_compute_point (context->widget,
+ GTK_WIDGET (gtk_widget_get_root (context->widget)),
+ &GRAPHENE_POINT_INIT (rect.x, rect.y),
+ &p))
+ graphene_point_init (&p, rect.x, rect.y);
- gtk_native_get_surface_transform (gtk_widget_get_native (context->widget),
- &sx, &sy);
+ gtk_native_get_surface_transform (gtk_widget_get_native (context->widget), &nx, &ny);
- rect.x = x + sx;
- rect.y = y + sy;
+ rect.x = p.x + nx;
+ rect.y = p.y + ny;
zwp_text_input_v3_set_cursor_rectangle (global->text_input,
rect.x, rect.y,
rect.width, rect.height);
if (contents != GTK_WIDGET (native))
{
- double contents_x, contents_y;
+ graphene_point_t p;
- gtk_widget_translate_coordinates (contents, GTK_WIDGET (native), 0, 0, &contents_x, &contents_y);
- rect.x += contents_x;
- rect.y += contents_y;
+ if (!gtk_widget_compute_point (contents, GTK_WIDGET (native),
+ &GRAPHENE_POINT_INIT (0, 0), &p))
+ graphene_point_init (&p, 0, 0);
+ rect.x += p.x;
+ rect.y += p.y;
}
opaque_region = cairo_region_create_rectangle (&rect);
if (row != NULL)
{
+ graphene_point_t p;
+
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
* of the row, we need to increase the order-index.
*/
row_placeholder_index = row_index;
- gtk_widget_translate_coordinates (GTK_WIDGET (sidebar), GTK_WIDGET (row),
- x, y,
- &x, &y);
+ if (!gtk_widget_compute_point (GTK_WIDGET (sidebar), GTK_WIDGET (row),
+ &GRAPHENE_POINT_INIT (x, y), &p))
+ graphene_point_init (&p, x, y);
+ x = p.x;
+ y = p.y;
if (y > sidebar->drag_row_height / 2 && row_index > 0)
row_placeholder_index++;
GtkWidget *target)
{
GtkWidget *parent;
+ graphene_point_t p;
double x, y, w, h;
parent = gtk_widget_get_parent (GTK_WIDGET (popover));
- if (!gtk_widget_translate_coordinates (target, parent, 0, 0, &x, &y))
+ if (!gtk_widget_compute_point (target, parent, &GRAPHENE_POINT_INIT (0, 0), &p))
return;
+ x = p.x;
+ y = p.y;
w = gtk_widget_get_allocated_width (GTK_WIDGET (target));
h = gtk_widget_get_allocated_height (GTK_WIDGET (target));
if (gtk_drag_check_threshold_double (GTK_WIDGET (row), 0, 0, x, y))
{
double start_x, start_y;
- double drag_x, drag_y;
+ graphene_point_t p;
GdkContentProvider *content;
GdkSurface *surface;
GdkDevice *device;
GdkDrag *drag;
gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
- gtk_widget_translate_coordinates (GTK_WIDGET (row),
- GTK_WIDGET (sidebar),
- start_x, start_y,
- &drag_x, &drag_y);
+ if (!gtk_widget_compute_point (GTK_WIDGET (row),
+ GTK_WIDGET (sidebar),
+ &GRAPHENE_POINT_INIT (start_x, start_y),
+ &p))
+ graphene_point_init (&p, start_x, start_y);
sidebar->dragging_over = TRUE;
surface = gtk_native_get_surface (gtk_widget_get_native (GTK_WIDGET (sidebar)));
device = gtk_gesture_get_device (GTK_GESTURE (gesture));
- drag = gdk_drag_begin (surface, device, content, GDK_ACTION_MOVE, drag_x, drag_y);
+ drag = gdk_drag_begin (surface, device, content, GDK_ACTION_MOVE, p.x, p.y);
g_object_unref (content);
GtkWidget *target)
{
GtkWidget *parent;
+ graphene_point_t p;
double x, y, w, h;
parent = gtk_widget_get_parent (GTK_WIDGET (popover));
- if (!gtk_widget_translate_coordinates (target, parent, 0, 0, &x, &y))
+ if (!gtk_widget_compute_point (target, parent, &GRAPHENE_POINT_INIT (0, 0), &p))
return;
+ x = p.x;
+ y = p.y;
w = gtk_widget_get_allocated_width (GTK_WIDGET (target));
h = gtk_widget_get_allocated_height (GTK_WIDGET (target));
GMount *mount;
GFile *file;
gboolean is_network;
- double x_in_view, y_in_view;
view = GTK_PLACES_VIEW (gtk_widget_get_ancestor (GTK_WIDGET (row), GTK_TYPE_PLACES_VIEW));
_popover_set_pointing_to_widget (GTK_POPOVER (view->popup_menu), GTK_WIDGET (row));
else
{
- gtk_widget_translate_coordinates (widget, GTK_WIDGET (view),
- x, y, &x_in_view, &y_in_view);
+ graphene_point_t p;
+ if (!gtk_widget_compute_point (widget, GTK_WIDGET (view),
+ &GRAPHENE_POINT_INIT (x, y),
+ &p))
+ graphene_point_init (&p, x, y);
gtk_popover_set_pointing_to (GTK_POPOVER (view->popup_menu),
- &(GdkRectangle){x_in_view, y_in_view, 0, 0});
+ &(GdkRectangle){p.x, p.y, 0, 0});
}
view->row_for_action = row;
GtkEntry *entry)
{
GdkRectangle rect;
- double x, y;
+ graphene_point_t p;
/* 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, &x, &y);
+ if (!gtk_widget_compute_point (view->address_entry, GTK_WIDGET (view),
+ &GRAPHENE_POINT_INIT (rect.x, rect.y), &p))
+ graphene_point_init (&p, rect.x, rect.y);
- rect.x = x;
- rect.y = y;
+ rect.x = p.x;
+ rect.y = p.y;
gtk_popover_set_pointing_to (GTK_POPOVER (view->server_adresses_popover), &rect);
gtk_widget_set_visible (view->server_adresses_popover, TRUE);
}
cairo_surface_t *cairo_surface;
cairo_region_t *region;
cairo_t *cr;
- double x, y;
+ graphene_point_t p;
double native_x, native_y;
gtk_native_get_surface_transform (GTK_NATIVE (popover), &native_x, &native_y);
cairo_fill (cr);
box = gtk_css_boxes_get_border_box (&content_css_boxes);
- gtk_widget_translate_coordinates (priv->contents_widget, GTK_WIDGET (popover),
- 0, 0,
- &x, &y);
- cairo_translate (cr, x, y);
+ if (!gtk_widget_compute_point (priv->contents_widget, GTK_WIDGET (popover),
+ &GRAPHENE_POINT_INIT (0, 0), &p))
+ graphene_point_init (&p, 0, 0);
+
+ cairo_translate (cr, p.x, p.y);
gsk_rounded_rect_path (box, cr);
cairo_fill (cr);
cairo_destroy (cr);
double y)
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
+ graphene_point_t p;
- gtk_widget_translate_coordinates (GTK_WIDGET (range), priv->trough_widget,
- x, y, &x, &y);
+ if (!gtk_widget_compute_point (GTK_WIDGET (range), priv->trough_widget,
+ &GRAPHENE_POINT_INIT (x, y), &p))
+ graphene_point_init (&p, x, y);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
{
priv->slide_initial_slider_position = MAX (0, priv->slider_x);
- priv->slide_initial_coordinate_delta = x - priv->slide_initial_slider_position;
+ priv->slide_initial_coordinate_delta = p.x - priv->slide_initial_slider_position;
}
else
{
priv->slide_initial_slider_position = MAX (0, priv->slider_y);
- priv->slide_initial_coordinate_delta = y - priv->slide_initial_slider_position;
+ priv->slide_initial_coordinate_delta = p.y - priv->slide_initial_slider_position;
}
}
(!primary_warps && shift_pressed && button == GDK_BUTTON_PRIMARY) ||
(!primary_warps && button == GDK_BUTTON_MIDDLE)))
{
- double slider_range_x, slider_range_y;
+ graphene_point_t p;
graphene_rect_t slider_bounds;
- gtk_widget_translate_coordinates (priv->trough_widget, widget,
- priv->slider_x, priv->slider_y,
- &slider_range_x, &slider_range_y);
+ if (!gtk_widget_compute_point (priv->trough_widget, widget,
+ &GRAPHENE_POINT_INIT (priv->slider_x, priv->slider_y),
+ &p))
+ graphene_point_init (&p, priv->slider_x, priv->slider_y);
/* If we aren't fixed, center on the slider. I.e. if this is not a scale... */
if (!priv->slider_size_fixed &&
gtk_widget_compute_bounds (priv->slider_widget, priv->slider_widget, &slider_bounds))
{
- slider_range_x += (slider_bounds.size.width / 2);
- slider_range_y += (slider_bounds.size.height / 2);
+ p.x += (slider_bounds.size.width / 2);
+ p.y += (slider_bounds.size.height / 2);
}
- update_initial_slider_position (range, slider_range_x, slider_range_y);
+ update_initial_slider_position (range, p.x, p.y);
range_grab_add (range, priv->slider_widget);
double mark_delta;
double zoom;
int i;
- double x, y;
+ graphene_point_t p;
- gtk_widget_translate_coordinates (GTK_WIDGET (range), priv->trough_widget,
- mouse_x, mouse_y, &x, &y);
+ if (!gtk_widget_compute_point(GTK_WIDGET (range), priv->trough_widget,
+ &GRAPHENE_POINT_INIT (mouse_x, mouse_y), &p))
+ graphene_point_init (&p, mouse_x, mouse_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 * (y - priv->slide_initial_coordinate_delta) - slider_bounds.origin.y) / zoom_divisor;
+ priv->slide_initial_slider_position = (zoom * (p.y - priv->slide_initial_coordinate_delta) - slider_bounds.origin.y) / zoom_divisor;
else
- priv->slide_initial_slider_position = (zoom * (x - priv->slide_initial_coordinate_delta) - slider_bounds.origin.x) / zoom_divisor;
+ priv->slide_initial_slider_position = (zoom * (p.x - priv->slide_initial_coordinate_delta) - slider_bounds.origin.x) / zoom_divisor;
}
if (priv->orientation == GTK_ORIENTATION_VERTICAL)
- delta = y - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
+ delta = p.y - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
else
- delta = x - (priv->slide_initial_coordinate_delta + priv->slide_initial_slider_position);
+ delta = p.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;
+ graphene_point_t p;
int 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, &x, &y);
+ if (!gtk_widget_compute_point (priv->trough_widget, GTK_WIDGET (range),
+ &GRAPHENE_POINT_INIT (slider.x, slider.y), &p))
+ graphene_point_init (&p, slider.x, slider.y);
if (priv->orientation == GTK_ORIENTATION_HORIZONTAL)
- priv->mark_pos[i] = x + slider.width / 2;
+ priv->mark_pos[i] = p.x + slider.width / 2;
else
- priv->mark_pos[i] = y + slider.height / 2;
+ priv->mark_pos[i] = p.y + slider.height / 2;
}
}
GtkTextHandle *handle)
{
GtkBorder input_extents;
- double widget_x, widget_y;
+ graphene_point_t p;
x -= handle->pointing_to.x;
y -= handle->pointing_to.y;
* are relative to the parent widget.
*/
handle_get_input_extents (handle, &input_extents);
- gtk_widget_translate_coordinates (handle->controller_widget,
- gtk_widget_get_parent (GTK_WIDGET (handle)),
- x, y, &widget_x, &widget_y);
-
- if (widget_x < input_extents.left || widget_x >= input_extents.right ||
- widget_y < input_extents.top || widget_y >= input_extents.bottom)
+ if (!gtk_widget_compute_point (handle->controller_widget,
+ gtk_widget_get_parent (GTK_WIDGET (handle)),
+ &GRAPHENE_POINT_INIT (x, y),
+ &p))
+ graphene_point_init (&p, x, y);
+
+ if (p.x < input_extents.left || p.x >= input_extents.right ||
+ p.y < input_extents.top || p.y >= input_extents.bottom)
{
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_DENIED);
return;
GdkSurface *surface;
double px, py;
double nx, ny;
+ graphene_point_t p;
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);
- gtk_widget_translate_coordinates (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (text_view))),
- GTK_WIDGET (text_view),
- px - nx, py - ny,
- &px, &py);
- rect.x = px;
- rect.y = py;
+ if (!gtk_widget_compute_point (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (text_view))),
+ GTK_WIDGET (text_view),
+ &GRAPHENE_POINT_INIT (px - nx, py - ny),
+ &p))
+ graphene_point_init (&p, px - nx, px - nx);
+ rect.x = p.x;
+ rect.y = p.y;
}
gtk_popover_set_pointing_to (GTK_POPOVER (priv->popup_menu), &rect);
GdkDevice *device;
GdkSurface *surface;
double x, y;
+ graphene_point_t p;
GtkWidget *toplevel;
g_return_if_fail (GTK_IS_WIDGET (widget));
if (gtk_native_get_surface (GTK_NATIVE (toplevel)) != surface)
return;
- gtk_widget_translate_coordinates (toplevel, widget, x, y, &x, &y);
+ if (!gtk_widget_compute_point (toplevel, widget, &GRAPHENE_POINT_INIT (x, y), &p))
+ graphene_point_init (&p, x, y);
- gtk_tooltip_handle_event_internal (GDK_MOTION_NOTIFY, surface, widget, x, y);
+ gtk_tooltip_handle_event_internal (GDK_MOTION_NOTIFY, surface, widget, p.x, p.y);
}
static void
picked_widget = gtk_widget_pick (event_widget, x, y, GTK_PICK_INSENSITIVE);
if (picked_widget != NULL)
- gtk_widget_translate_coordinates (event_widget, picked_widget, x, y, &x, &y);
+ {
+ graphene_point_t p;
+
+ if (!gtk_widget_compute_point (event_widget, picked_widget,
+ &GRAPHENE_POINT_INIT (x, y), &p))
+ graphene_point_init (&p, x, y);
+ x = p.x;
+ y = p.y;
+ }
*widget_x = x;
*widget_y = y;
if (parent)
{
- double xx = *x;
- double yy = *y;
+ graphene_point_t r = GRAPHENE_POINT_INIT (*x, *y);
+ graphene_point_t p;
- if (gtk_widget_get_native (parent) != gtk_widget_get_native (*widget))
+ if (!gtk_widget_compute_point (*widget, parent, &r, &p))
break;
- gtk_widget_translate_coordinates (*widget, parent, xx, yy, &xx, &yy);
-
- *x = xx;
- *y = yy;
+ *x = p.x;
+ *y = p.y;
}
*widget = parent;
surface = gdk_event_get_surface (event);
if (gdk_event_get_position (event, &x, &y))
{
+ graphene_point_t p;
gtk_native_get_surface_transform (native, &nx, &ny);
- gtk_widget_translate_coordinates (GTK_WIDGET (native), target, x - nx, y - ny, &x, &y);
+ if (!gtk_widget_compute_point (GTK_WIDGET (native), target,
+ &GRAPHENE_POINT_INIT (x - nx, y - ny), &p))
+ graphene_point_init (&p, x - nx, y - ny);
+ x = p.x;
+ y = p.y;
}
gtk_tooltip_handle_event_internal (event_type, surface, target, x, y);
}
GtkRoot *root;
GtkWidget *focus_widget;
graphene_rect_t rect;
- double x, y;
+ graphene_point_t p;
if ((gtk_widget_get_state_flags (widget) & GTK_STATE_FLAG_FOCUS_WITHIN) == 0)
return;
if (!gtk_widget_compute_bounds (focus_widget, viewport->child, &rect))
return;
- gtk_widget_translate_coordinates (viewport->child, widget,
- rect.origin.x,
- rect.origin.y,
- &x, &y);
+ if (!gtk_widget_compute_point (viewport->child, widget,
+ &GRAPHENE_POINT_INIT (rect.origin.x, rect.origin.y),
+ &p))
+ return;
- scroll_to_view (viewport->adjustment[GTK_ORIENTATION_HORIZONTAL], x, rect.size.width);
- scroll_to_view (viewport->adjustment[GTK_ORIENTATION_VERTICAL], y, rect.size.height);
+ scroll_to_view (viewport->adjustment[GTK_ORIENTATION_HORIZONTAL], p.x, rect.size.width);
+ scroll_to_view (viewport->adjustment[GTK_ORIENTATION_VERTICAL], p.y, rect.size.height);
}
static void
* Returns: %FALSE if @src_widget and @dest_widget have no common
* ancestor. In this case, 0 is stored in *@dest_x and *@dest_y.
* Otherwise %TRUE.
+ *
+ * Deprecated: 4.12: Use gtk_widget_compute_point() instead
*/
gboolean
gtk_widget_translate_coordinates (GtkWidget *src_widget,
GtkWidget *widget;
GtkWidget *parent;
GtkWidget *bounds_relative_to;
- double translated_x, translated_y;
graphene_rect_t bounds = GRAPHENE_RECT_INIT_ZERO;
widget = GTK_WIDGET (self);
parent = gtk_widget_get_parent (widget);
if (parent != NULL)
{
- gtk_widget_translate_coordinates (widget, parent, 0., 0., &translated_x, &translated_y);
- *x = floorf (translated_x);
- *y = floorf (translated_y);
+ graphene_point_t p;
+ if (!gtk_widget_compute_point (widget, parent, &GRAPHENE_POINT_INIT (0, 0), &p))
+ graphene_point_init (&p, 0, 0);
+ *x = floorf (p.x);
+ *y = floorf (p.y);
bounds_relative_to = parent;
}
else
gboolean gtk_widget_is_ancestor (GtkWidget *widget,
GtkWidget *ancestor);
-GDK_AVAILABLE_IN_ALL
+GDK_DEPRECATED_IN_4_12_FOR(gtk_widget_compute_point)
gboolean gtk_widget_translate_coordinates (GtkWidget *src_widget,
GtkWidget *dest_widget,
double src_x,
GdkSurface *surface;
double px, py;
double nx, ny;
+ graphene_point_t p;
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);
- gtk_widget_translate_coordinates (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (self))),
- GTK_WIDGET (self),
- px - nx, py - ny,
- &px, &py);
- rect.x = px;
- rect.y = py;
+ if (!gtk_widget_compute_point (GTK_WIDGET (gtk_widget_get_native (GTK_WIDGET (self))),
+ GTK_WIDGET (self),
+ &GRAPHENE_POINT_INIT (px - nx, py - ny),
+ &p))
+ graphene_point_init (&p, 0, 0);
+
+ rect.x = p.x;
+ rect.y = p.y;
}
gtk_popover_set_pointing_to (GTK_POPOVER (self->fallback_menu), &rect);
{
double start_x, start_y;
double native_x, native_y;
- double window_x, window_y;
+ graphene_point_t p;
GtkNative *native;
GdkSurface *surface;
native = gtk_widget_get_native (GTK_WIDGET (self));
- gtk_widget_translate_coordinates (GTK_WIDGET (self),
- GTK_WIDGET (native),
- start_x, start_y,
- &window_x, &window_y);
+ if (!gtk_widget_compute_point (GTK_WIDGET (self),
+ GTK_WIDGET (native),
+ &GRAPHENE_POINT_INIT (start_x, start_y),
+ &p))
+ graphene_point_init (&p, start_x, start_y);
gtk_native_get_surface_transform (native, &native_x, &native_y);
- window_x += native_x;
- window_y += native_y;
+ p.x += native_x;
+ p.y += native_y;
surface = gtk_native_get_surface (native);
if (GDK_IS_TOPLEVEL (surface))
gdk_toplevel_begin_move (GDK_TOPLEVEL (surface),
gtk_gesture_get_device (GTK_GESTURE (gesture)),
gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)),
- window_x, window_y,
+ p.x, p.y,
gtk_event_controller_get_current_event_time (GTK_EVENT_CONTROLLER (gesture)));
gtk_event_controller_reset (GTK_EVENT_CONTROLLER (gesture));
#include <string.h>
#include <gtk/gtk.h>
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
static const char *css =
".overlay-green {"
" background-image: none;"
#include <gtk/gtk.h>
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
static const char *css =
"test>button {"
" all: unset; "
#include <gtk/gtk.h>
+G_GNUC_BEGIN_IGNORE_DEPRECATIONS
+
static void
start_resize (GtkGestureClick *gesture,
int n_press,
projects / gtk4.git / commitdiff