DemoApplicationWindow *window = (DemoApplicationWindow *)widget;
GdkSurfaceState new_state;
- new_state = gdk_surface_get_state (gtk_widget_get_window (widget));
+ new_state = gdk_surface_get_state (gtk_widget_get_surface (widget));
window->maximized = (new_state & GDK_SURFACE_STATE_MAXIMIZED) != 0;
window->fullscreen = (new_state & GDK_SURFACE_STATE_FULLSCREEN) != 0;
}
{
GTK_WIDGET_CLASS (demo_application_window_parent_class)->realize (widget);
- g_signal_connect_swapped (gtk_widget_get_window (widget), "notify::state",
+ g_signal_connect_swapped (gtk_widget_get_surface (widget), "notify::state",
G_CALLBACK (surface_state_changed), widget);
}
static void
demo_application_window_unrealize (GtkWidget *widget)
{
- g_signal_handlers_disconnect_by_func (gtk_widget_get_window (widget),
+ g_signal_handlers_disconnect_by_func (gtk_widget_get_surface (widget),
surface_state_changed, widget);
GTK_WIDGET_CLASS (demo_application_window_parent_class)->unrealize (widget);
device = gtk_get_current_event_device ();
if (gdk_seat_grab (gdk_device_get_seat (device),
- gtk_widget_get_window (popup),
+ gtk_widget_get_surface (popup),
GDK_SEAT_CAPABILITY_ALL_POINTING,
FALSE, cursor, NULL, NULL, NULL) == GDK_GRAB_SUCCESS)
{
rect.height = 0;
gtk_menu_popup_at_rect (GTK_MENU (menu),
- gtk_widget_get_window (widget),
+ gtk_widget_get_surface (widget),
&rect,
GDK_GRAVITY_NORTH_WEST,
GDK_GRAVITY_NORTH_WEST,
static void
gtk_font_plane_init (GtkFontPlane *plane)
{
- gtk_widget_set_has_window (GTK_WIDGET (plane), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (plane), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (plane), TRUE);
plane->drag_gesture = gtk_gesture_drag_new (GTK_WIDGET (plane));
static void
gtk_fishbowl_init (GtkFishbowl *fishbowl)
{
- gtk_widget_set_has_window (GTK_WIDGET (fishbowl), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (fishbowl), FALSE);
}
/**
GtkApplication *app = gtk_window_get_application (GTK_WINDOW (window));
gtk_widget_set_sensitive (window, TRUE);
- gdk_surface_set_cursor (gtk_widget_get_window (window), NULL);
+ gdk_surface_set_cursor (gtk_widget_get_surface (window), NULL);
g_application_unmark_busy (G_APPLICATION (app));
return G_SOURCE_REMOVE;
g_application_mark_busy (G_APPLICATION (app));
cursor = gdk_cursor_new_from_name ("wait", NULL);
- gdk_surface_set_cursor (gtk_widget_get_window (window), cursor);
+ gdk_surface_set_cursor (gtk_widget_get_surface (window), cursor);
g_object_unref (cursor);
g_timeout_add (5000, get_idle, window);
A widget that does not have a GdkSurface of its own on which to
draw its contents, but rather shares its <glossterm
linkend="parent">parent's</glossterm>. This can be tested with
- the gtk_widget_get_has_window() function.
+ the gtk_widget_get_has_surface() function.
</para>
</glossdef>
</glossentry>
<para>
Widgets that don't own the GdkSurface on which they draw are
called <glossterm linkend="no-window">no-window widgets</glossterm>.
- This can be tested with the gtk_widget_get_has_window() function. Normally,
+ This can be tested with the gtk_widget_get_has_surface() function. Normally,
these widgets draw on their parent's GdkSurface.
</para>
gtk_widget_get_name
gtk_widget_set_sensitive
gtk_widget_set_parent
-gtk_widget_set_parent_window
-gtk_widget_get_parent_window
+gtk_widget_set_parent_surface
+gtk_widget_get_parent_surface
gtk_widget_get_toplevel
gtk_widget_get_ancestor
gtk_widget_is_ancestor
gtk_widget_get_has_tooltip
gtk_widget_set_has_tooltip
gtk_widget_trigger_tooltip_query
-gtk_widget_get_window
-gtk_widget_register_window
-gtk_widget_unregister_window
+gtk_widget_get_surface
+gtk_widget_register_surface
+gtk_widget_unregister_surface
gtk_widget_get_allocated_width
gtk_widget_get_allocated_height
gtk_widget_get_allocation
gtk_widget_set_can_focus
gtk_widget_get_focus_on_click
gtk_widget_set_focus_on_click
-gtk_widget_get_has_window
-gtk_widget_set_has_window
+gtk_widget_get_has_surface
+gtk_widget_set_has_surface
gtk_widget_get_sensitive
gtk_widget_is_sensitive
gtk_widget_get_visible
gtk_widget_has_grab
gtk_widget_is_drawable
gtk_widget_is_toplevel
-gtk_widget_set_window
+gtk_widget_set_surface
gtk_widget_set_receives_default
gtk_widget_get_receives_default
gtk_widget_set_support_multidevice
a #GdkSurface, which in turn represents a windowing system surface in the
backend. If a widget has grabbed the current input device, or all input
devices, the event is propagated to that #GtkWidget. Otherwise, it is
- propagated to the the #GtkWidget which called gtk_widget_register_window()
+ propagated to the the #GtkWidget which called gtk_widget_register_surface()
on the #GdkSurface receiving the event.
</para>
gtk_main_quit ();
}
- window = gtk_widget_get_window (info->window);
+ window = gtk_widget_get_surface (info->window);
id = gdk_x11_surface_get_xid (window);
if (window_is_csd (window))
decor = (info->include_decorations) ? DECOR_NONE : DECOR_WINDOW_FRAME;
When a widget is added to a container, the container:
- 1) calls gtk_widget_set_parent_window (widget, window) if
+ 1) calls gtk_widget_set_parent_surface (widget, window) if
the widget is being added to something other than container->window
2) calls gtk_widget_set_parent (widget, container)
1) set the realized flag
2) set widget->window
- widget->window = gtk_widget_get_parent_window (widget);
+ widget->window = gtk_widget_get_parent_surface (widget);
g_object_ref (widget->window);
3) attach the widget's style
1) set the REALIZED flag
2) create windows with the parent obtained from
- gtk_widget_get_parent_window (widget);
+ gtk_widget_get_parent_surface (widget);
3) attach the widget's style
4) set the background color for the new window based on the style
surface = NULL;
}
- if (gtk_widget_get_window (widget))
+ if (gtk_widget_get_surface (widget))
{
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (widget),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
CAIRO_CONTENT_COLOR,
gtk_widget_get_width (widget),
gtk_widget_get_height (widget));
* struct wl_surface *surface;
* struct input_panel_surface *ip_surface;
*
- * surface = gtk_widget_get_window (widget);
+ * surface = gtk_widget_get_surface (widget);
* gdk_wayland_surface_set_custom_surface (surface);
*
* surface = gdk_wayland_surface_get_wl_surface (surface);
gtk_entry_get_icon_area (gtk_entry, icon->pos, &icon_area);
event = gdk_event_new (GDK_BUTTON_PRESS);
- event->any.surface = g_object_ref (gtk_widget_get_window (widget));
+ event->any.surface = g_object_ref (gtk_widget_get_surface (widget));
event->button.button = 1;
event->any.send_event = TRUE;
event->button.time = GDK_CURRENT_TIME;
_gtk_widget_get_allocation (widget, &allocation);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_window, &y_window);
*x = x_window + allocation.x + x_layout + char_rect.x;
gtk_entry_get_layout_offsets (entry, &x_layout, &y_layout);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_window, &y_window);
x_local = x - x_layout - x_window;
pango_layout_index_to_pos (gtk_label_get_layout (label), index, &char_rect);
pango_extents_to_pixels (&char_rect, NULL);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_window, &y_window);
*x = x_window + x_layout + char_rect.x;
gtk_label_get_layout_offsets (label, &x_layout, &y_layout);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_window, &y_window);
x_local = x - x_layout - x_window;
{
GdkSurface *window;
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, x_window, y_window);
- window = gdk_surface_get_toplevel (gtk_widget_get_window (widget));
+ window = gdk_surface_get_toplevel (gtk_widget_get_surface (widget));
gdk_surface_get_origin (window, x_toplevel, y_toplevel);
if (GTK_IS_TREE_VIEW (widget))
return -1;
view = GTK_TEXT_VIEW (widget);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_widget, &y_widget);
if (coords == ATK_XY_SCREEN)
gtk_text_buffer_get_iter_at_offset (buffer, &iter, offset);
gtk_text_view_get_iter_location (view, &iter, &rectangle);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
if (window == NULL)
return;
GdkSurface *window;
gint x_toplevel, y_toplevel;
- window = gdk_surface_get_toplevel (gtk_widget_get_window (widget));
+ window = gdk_surface_get_toplevel (gtk_widget_get_surface (widget));
gdk_surface_get_origin (window, &x_toplevel, &y_toplevel);
w_x += x_toplevel;
{
#ifdef GDK_WINDOWING_X11
gtk_window_present_with_time (GTK_WINDOW (toplevel),
- gdk_x11_get_server_time (gtk_widget_get_window (widget)));
+ gdk_x11_get_server_time (gtk_widget_get_surface (widget)));
#else
gtk_window_present (GTK_WINDOW (toplevel));
#endif
{
*x = allocation.x;
*y = allocation.y;
- window = gtk_widget_get_parent_window (widget);
+ window = gtk_widget_get_parent_surface (widget);
}
else
{
*x = 0;
*y = 0;
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
}
gdk_surface_get_origin (window, &x_window, &y_window);
*x += x_window;
if (coord_type == ATK_XY_WINDOW)
{
- window = gdk_surface_get_toplevel (gtk_widget_get_window (widget));
+ window = gdk_surface_get_toplevel (gtk_widget_get_surface (widget));
gdk_surface_get_origin (window, &x_toplevel, &y_toplevel);
*x -= x_toplevel;
{
#ifdef GDK_WINDOWING_X11
gtk_window_present_with_time (GTK_WINDOW (toplevel),
- gdk_x11_get_server_time (gtk_widget_get_window (widget)));
+ gdk_x11_get_server_time (gtk_widget_get_surface (widget)));
#else
gtk_window_present (GTK_WINDOW (toplevel));
#endif
if (coord_type == ATK_XY_WINDOW)
{
gint x_current, y_current;
- GdkSurface *window = gtk_widget_get_window (widget);
+ GdkSurface *window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_current, &y_current);
x_current += x;
if (coord_type == ATK_XY_WINDOW)
{
gint x_current, y_current;
- GdkSurface *window = gtk_widget_get_window (widget);
+ GdkSurface *window = gtk_widget_get_surface (widget);
gdk_surface_get_origin (window, &x_current, &y_current);
x_current += x;
if (gtk_window_is_active (window))
atk_state_set_add_state (state_set, ATK_STATE_ACTIVE);
- gdk_surface = gtk_widget_get_window (widget);
+ gdk_surface = gtk_widget_get_surface (widget);
if (gdk_surface)
{
state = gdk_surface_get_state (gdk_surface);
return;
}
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
if (window == NULL)
return;
return;
}
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
if (window == NULL)
return;
{
GtkAccelLabelPrivate *priv;
- gtk_widget_set_has_window (GTK_WIDGET (accel_label), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (accel_label), FALSE);
accel_label->priv = gtk_accel_label_get_instance_private (accel_label);
priv = accel_label->priv;
GtkWidget *widget = GTK_WIDGET (action_bar);
GtkActionBarPrivate *priv = gtk_action_bar_get_instance_private (action_bar);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
priv->revealer = gtk_revealer_new ();
gtk_widget_set_parent (priv->revealer, widget);
self->priv = gtk_app_chooser_widget_get_instance_private (self);
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
gtk_widget_init_template (GTK_WIDGET (self));
GdkSurface *gdk_surface;
gchar *window_path;
- gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
if (!GDK_IS_WAYLAND_SURFACE (gdk_surface))
return;
GdkSurface *gdk_surface;
gchar *window_path;
- gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
if (!GDK_IS_X11_SURFACE (gdk_surface))
return;
{
GdkSurface *gdk_surface;
- gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
if (GDK_IS_X11_SURFACE (gdk_surface))
return g_variant_new_uint32 (GDK_SURFACE_XID (gdk_surface));
static void
gtk_bin_init (GtkBin *bin)
{
- gtk_widget_set_has_window (GTK_WIDGET (bin), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (bin), FALSE);
}
static GType
{
GtkBoxPrivate *priv = gtk_box_get_instance_private (box);
- gtk_widget_set_has_window (GTK_WIDGET (box), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (box), FALSE);
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
priv->children = NULL;
gtk_widget_set_can_focus (GTK_WIDGET (button), TRUE);
gtk_widget_set_receives_default (GTK_WIDGET (button), TRUE);
- gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (button), FALSE);
priv->in_button = FALSE;
priv->button_down = FALSE;
priv = calendar->priv = gtk_calendar_get_instance_private (calendar);
gtk_widget_set_can_focus (widget, TRUE);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
gtk_style_context_add_class (gtk_widget_get_style_context (GTK_WIDGET (calendar)),
GTK_STYLE_CLASS_VIEW);
if (!is_editable)
return NULL;
- window = gtk_widget_get_window (gtk_widget_get_toplevel (widget));
+ window = gtk_widget_get_surface (gtk_widget_get_toplevel (widget));
if (event)
device = gdk_event_get_device (event);
cellview->priv = gtk_cell_view_get_instance_private (cellview);
cellview->priv->orientation = GTK_ORIENTATION_HORIZONTAL;
- gtk_widget_set_has_window (GTK_WIDGET (cellview), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (cellview), FALSE);
}
static void
static void
gtk_center_box_init (GtkCenterBox *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
self->start_widget = NULL;
self->center_widget = NULL;
GtkStyleContext *context;
GdkContentFormats *targets;
- gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (button), FALSE);
/* Create the widgets */
priv = button->priv = gtk_color_button_get_instance_private (button);
width = gtk_widget_get_width (widget);
height = gtk_widget_get_height (widget);
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (widget),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
CAIRO_CONTENT_COLOR,
width, height);
plane->priv = gtk_color_plane_get_instance_private (plane);
- gtk_widget_set_has_window (GTK_WIDGET (plane), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (plane), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (plane), TRUE);
atk_obj = gtk_widget_get_accessible (GTK_WIDGET (plane));
swatch->priv->has_menu = TRUE;
gtk_widget_set_can_focus (GTK_WIDGET (swatch), TRUE);
- gtk_widget_set_has_window (GTK_WIDGET (swatch), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (swatch), FALSE);
swatch->priv->long_press_gesture = gtk_gesture_long_press_new (GTK_WIDGET (swatch));
gtk_gesture_single_set_touch_only (GTK_GESTURE_SINGLE (swatch->priv->long_press_gesture),
cairo_region_union (region, draw->region);
}
gtk_debug_updates_print (updates, region, "Queued update");
- gdk_surface_invalidate_region (gtk_widget_get_window (widget), region, TRUE);
+ gdk_surface_invalidate_region (gtk_widget_get_surface (widget), region, TRUE);
cairo_region_destroy (region);
/* Then remove all outdated regions */
get_toplevel_nswindow (GtkWidget *widget)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
- GdkSurface *window = gtk_widget_get_window (toplevel);
+ GdkSurface *window = gtk_widget_get_surface (toplevel);
if (gtk_widget_is_toplevel (toplevel) && window)
return [gdk_quartz_surface_get_nsview (window) window];
if (gtk_widget_get_parent (widget))
{
gint tx, ty;
- GdkSurface *window = gtk_widget_get_window (widget);
+ GdkSurface *window = gtk_widget_get_surface (widget);
GdkSurface *parent_window;
GtkAllocation allocation;
- parent_window = gtk_widget_get_window (gtk_widget_get_parent (widget));
+ parent_window = gtk_widget_get_surface (gtk_widget_get_parent (widget));
/* Compute the offset from allocation-relative to
* window-relative coordinates.
allocation_to_window_x = allocation.x;
allocation_to_window_y = allocation.y;
- if (gtk_widget_get_has_window (widget))
+ if (gtk_widget_get_has_surface (widget))
{
/* The allocation is relative to the parent window for
* window widgets, not to widget->window.
}
}
- gdk_surface_get_position (gtk_widget_get_window (toplevel), &tx, &ty);
+ gdk_surface_get_position (gtk_widget_get_surface (toplevel), &tx, &ty);
data.x = event->dnd.x_root - tx;
data.y = event->dnd.y_root - ty;
if (x != -1 && y != -1)
{
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
- window = gtk_widget_get_window (toplevel);
+ window = gtk_widget_get_surface (toplevel);
gtk_widget_translate_coordinates (widget, toplevel, x, y, &x, &y);
- gdk_surface_get_root_coords (gtk_widget_get_window (toplevel), x, y,
+ gdk_surface_get_root_coords (gtk_widget_get_surface (toplevel), x, y,
&x, &y);
dx = (gdouble)x;
dy = (gdouble)y;
{
GtkWidget *widget = tmp_list->data;
- if (gtk_widget_get_window (widget) == gdk_drag_context_get_source_surface (context))
+ if (gtk_widget_get_surface (widget) == gdk_drag_context_get_source_surface (context))
return widget;
tmp_list = tmp_list->next;
}
}
- window = gtk_widget_get_window (toplevel);
+ window = gtk_widget_get_surface (toplevel);
gdk_surface_get_position (window, &tx, &ty);
gdk_event_get_root_coords (event, &x_root, &y_root);
/* Get the widget at the pointer coordinates and travel up
* the widget hierarchy from there.
*/
- widget = _gtk_widget_find_at_coords (gtk_widget_get_window (widget),
+ widget = _gtk_widget_find_at_coords (gtk_widget_get_surface (widget),
x, y, &x, &y);
if (!widget)
return FALSE;
toplevel = gtk_widget_get_toplevel (widget);
gtk_widget_translate_coordinates (widget, toplevel,
x, y, &x, &y);
- gdk_surface_get_device_position (gtk_widget_get_window (toplevel),
+ gdk_surface_get_device_position (gtk_widget_get_surface (toplevel),
device,
&dx, &dy,
NULL);
content->formats = gdk_content_formats_ref (target_list);
content->time = time;
- context = gdk_drag_begin (gtk_widget_get_window (toplevel), device, GDK_CONTENT_PROVIDER (content), actions, dx, dy);
+ context = gdk_drag_begin (gtk_widget_get_surface (toplevel), device, GDK_CONTENT_PROVIDER (content), actions, dx, dy);
if (context == NULL)
{
g_object_unref (content);
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel))
- gdk_surface_register_dnd (gtk_widget_get_window (toplevel));
+ gdk_surface_register_dnd (gtk_widget_get_surface (toplevel));
}
static void
GtkWidget *toplevel = gtk_widget_get_toplevel (widget);
if (gtk_widget_is_toplevel (toplevel) && gtk_widget_get_realized (toplevel))
- gdk_surface_register_dnd (gtk_widget_get_window (toplevel));
+ gdk_surface_register_dnd (gtk_widget_get_surface (toplevel));
}
static void
* {
* GdkModifierType mask;
*
- * gdk_surface_get_pointer (gtk_widget_get_window (widget),
+ * gdk_surface_get_pointer (gtk_widget_get_surface (widget),
* NULL, NULL, &mask);
* if (mask & GDK_CONTROL_MASK)
* gdk_drag_status (context, GDK_ACTION_COPY, time);
static void
gtk_drawing_area_init (GtkDrawingArea *darea)
{
- gtk_widget_set_has_window (GTK_WIDGET (darea), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (darea), FALSE);
}
/**
gint i;
gtk_widget_set_can_focus (GTK_WIDGET (entry), TRUE);
- gtk_widget_set_has_window (GTK_WIDGET (entry), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (entry), FALSE);
priv->editable = TRUE;
priv->visible = TRUE;
GtkTreeViewColumn *action_column;
gint action_height;
- window = gtk_widget_get_window (completion->priv->entry);
+ window = gtk_widget_get_surface (completion->priv->entry);
if (!window)
return;
if (!completion->priv->filter_model)
return;
- gtk_widget_get_window_allocation (completion->priv->entry, &allocation);
+ gtk_widget_get_surface_allocation (completion->priv->entry, &allocation);
gtk_widget_get_preferred_size (completion->priv->entry,
&entry_req, NULL);
{
gtk_grab_add (completion->priv->popup_window);
gdk_seat_grab (gdk_device_get_seat (completion->priv->device),
- gtk_widget_get_window (completion->priv->popup_window),
+ gtk_widget_get_surface (completion->priv->popup_window),
GDK_SEAT_CAPABILITY_POINTER | GDK_SEAT_CAPABILITY_TOUCH,
TRUE, NULL, NULL,
prepare_popup_func, completion);
expander->priv = priv = gtk_expander_get_instance_private (expander);
gtk_widget_set_can_focus (GTK_WIDGET (expander), TRUE);
- gtk_widget_set_has_window (GTK_WIDGET (expander), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (expander), FALSE);
priv->label_widget = NULL;
priv->child = NULL;
GtkWidget *icon;
GdkContentFormats *target_list;
- gtk_widget_set_has_window (GTK_WIDGET (button), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (button), FALSE);
priv = button->priv = gtk_file_chooser_button_get_instance_private (button);
if (transient_for)
{
gtk_widget_realize (GTK_WIDGET (transient_for));
- data->parent = gdk_quartz_surface_get_nswindow (gtk_widget_get_window (GTK_WIDGET (transient_for)));
+ data->parent = gdk_quartz_surface_get_nswindow (gtk_widget_get_surface (GTK_WIDGET (transient_for)));
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
if (transient_for)
{
gtk_widget_realize (GTK_WIDGET (transient_for));
- data->parent = gdk_win32_surface_get_handle (gtk_widget_get_window (GTK_WIDGET (transient_for)));
+ data->parent = gdk_win32_surface_get_handle (gtk_widget_get_surface (GTK_WIDGET (transient_for)));
if (gtk_native_dialog_get_modal (GTK_NATIVE_DIALOG (self)))
data->modal = TRUE;
impl->priv = gtk_file_chooser_widget_get_instance_private (impl);
priv = impl->priv;
- gtk_widget_set_has_window (GTK_WIDGET (impl), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (impl), FALSE);
priv->local_only = FALSE;
priv->preview_widget_active = TRUE;
fixed->priv->children = NULL;
- gtk_widget_set_has_window (GTK_WIDGET (fixed), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (fixed), FALSE);
}
/**
{
GtkFlowBoxPrivate *priv = BOX_PRIV (box);
- gtk_widget_set_has_window (GTK_WIDGET (box), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (box), FALSE);
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
priv->selection_mode = GTK_SELECTION_SINGLE;
font_button->priv = gtk_font_button_get_instance_private (font_button);
priv = font_button->priv;
- gtk_widget_set_has_window (GTK_WIDGET (font_button), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (font_button), FALSE);
priv->button = gtk_button_new ();
g_signal_connect (priv->button, "clicked", G_CALLBACK (gtk_font_button_clicked), font_button);
fontchooser->priv = gtk_font_chooser_widget_get_instance_private (fontchooser);
priv = fontchooser->priv;
- gtk_widget_set_has_window (GTK_WIDGET (fontchooser), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (fontchooser), FALSE);
gtk_widget_init_template (GTK_WIDGET (fontchooser));
GtkWidget *widget;
widget = gtk_event_controller_get_widget (GTK_EVENT_CONTROLLER (gesture));
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
while (window)
{
static void
gtk_gizmo_init (GtkGizmo *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
}
GtkWidget *
GError *error = NULL;
GdkGLContext *context;
- context = gdk_surface_create_gl_context (gtk_widget_get_window (widget), &error);
+ context = gdk_surface_create_gl_context (gtk_widget_get_surface (widget), &error);
if (error != NULL)
{
gtk_gl_area_set_error (area, error);
{
GtkGLAreaPrivate *priv = gtk_gl_area_get_instance_private (area);
- gtk_widget_set_has_window (GTK_WIDGET (area), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (area), FALSE);
priv->auto_render = TRUE;
priv->needs_render = TRUE;
{
GtkGridPrivate *priv = gtk_grid_get_instance_private (grid);
- gtk_widget_set_has_window (GTK_WIDGET (grid), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (grid), FALSE);
priv->children = NULL;
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
G_CALLBACK (_gtk_header_bar_update_window_buttons), widget);
g_signal_connect_swapped (settings, "notify::gtk-decoration-layout",
G_CALLBACK (_gtk_header_bar_update_window_buttons), widget);
- g_signal_connect_swapped (_gtk_widget_get_window (widget), "notify::state",
+ g_signal_connect_swapped (_gtk_widget_get_surface (widget), "notify::state",
G_CALLBACK (surface_state_changed), widget);
_gtk_header_bar_update_window_buttons (GTK_HEADER_BAR (widget));
}
settings = gtk_widget_get_settings (widget);
g_signal_handlers_disconnect_by_func (settings, _gtk_header_bar_update_window_buttons, widget);
- g_signal_handlers_disconnect_by_func (_gtk_widget_get_window (widget), surface_state_changed, widget);
+ g_signal_handlers_disconnect_by_func (_gtk_widget_get_surface (widget), surface_state_changed, widget);
GTK_WIDGET_CLASS (gtk_header_bar_parent_class)->unrealize (widget);
}
GtkHeaderBarPrivate *priv = gtk_header_bar_get_instance_private (bar);
GdkSurfaceState changed, new_state;
- new_state = gdk_surface_get_state (_gtk_widget_get_window (widget));
+ new_state = gdk_surface_get_state (_gtk_widget_get_surface (widget));
changed = new_state ^ priv->state;
priv->state = new_state;
priv = gtk_header_bar_get_instance_private (bar);
- gtk_widget_set_has_window (GTK_WIDGET (bar), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (bar), FALSE);
priv->title = NULL;
priv->subtitle = NULL;
static void
gtk_icon_init (GtkIcon *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
self->image = GTK_CSS_IMAGE_BUILTIN_NONE;
}
icon_view->priv->mouse_x = -1;
icon_view->priv->mouse_y = -1;
- gtk_widget_set_has_window (GTK_WIDGET (icon_view), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (icon_view), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (icon_view), TRUE);
icon_view->priv->item_orientation = GTK_ORIENTATION_VERTICAL;
item->cell_area.height + icon_view->priv->item_padding * 2
};
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (GTK_WIDGET (icon_view)),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (GTK_WIDGET (icon_view)),
CAIRO_CONTENT_COLOR_ALPHA,
rect.width,
rect.height);
GtkCssNode *widget_node;
widget_node = gtk_widget_get_css_node (GTK_WIDGET (image));
- gtk_widget_set_has_window (GTK_WIDGET (image), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (image), FALSE);
priv->icon_helper = gtk_icon_helper_new (widget_node, GTK_WIDGET (image));
priv->keep_aspect_ratio = TRUE;
g_return_if_fail (GTK_IS_IM_CONTEXT_IME (context));
context_ime = GTK_IM_CONTEXT_IME (context);
toplevel = gtk_widget_get_toplevel (widget);
- client_window = gtk_widget_get_window (toplevel);
+ client_window = gtk_widget_get_surface (toplevel);
if (client_window)
{
GTK_NOTE (MISC, g_print ("quartz_set_client_window: %p\n", widget));
- qc->client_window = gtk_widget_get_parent_window (widget);
+ qc->client_window = gtk_widget_get_parent_surface (widget);
}
static void
GdkSurface *surface = NULL;
if (widget != NULL)
- surface = gtk_widget_get_window (gtk_widget_get_toplevel (widget));
+ surface = gtk_widget_get_surface (gtk_widget_get_toplevel (widget));
set_ic_client_window (context_xim, surface);
}
if (status_window->window)
{
- height = DisplayHeight(GDK_SURFACE_XDISPLAY (gtk_widget_get_window (toplevel)), 0);
+ height = DisplayHeight(GDK_SURFACE_XDISPLAY (gtk_widget_get_surface (toplevel)), 0);
- gdk_surface_get_frame_extents (gtk_widget_get_window (toplevel), &rect);
+ gdk_surface_get_frame_extents (gtk_widget_get_surface (toplevel), &rect);
gtk_widget_get_preferred_size ( (status_window->window), &requisition, NULL);
if (rect.y + rect.height + requisition.height < height)
invisible->priv = gtk_invisible_get_instance_private (invisible);
priv = invisible->priv;
- gtk_widget_set_has_window (GTK_WIDGET (invisible), TRUE);
+ gtk_widget_set_has_surface (GTK_WIDGET (invisible), TRUE);
_gtk_widget_set_is_toplevel (GTK_WIDGET (invisible), TRUE);
g_object_ref_sink (invisible);
gtk_widget_set_realized (widget, TRUE);
window = gdk_surface_new_temp (gtk_widget_get_display (widget));
- gtk_widget_set_window (widget, window);
- gtk_widget_register_window (widget, window);
+ gtk_widget_set_surface (widget, window);
+ gtk_widget_register_surface (widget, window);
}
static void
{
GtkLabelPrivate *priv = gtk_label_get_instance_private (label);
- gtk_widget_set_has_window (GTK_WIDGET (label), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (label), FALSE);
priv->width_chars = -1;
priv->max_width_chars = -1;
{
GtkLayoutPrivate *priv;
- gtk_widget_set_has_window (GTK_WIDGET (layout), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (layout), FALSE);
layout->priv = gtk_layout_get_instance_private (layout);
priv = layout->priv;
priv->inverted = FALSE;
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
priv->trough_widget = gtk_gizmo_new ("trough",
gtk_level_bar_measure_trough,
GtkListBoxPrivate *priv = BOX_PRIV (box);
GtkWidget *widget = GTK_WIDGET (box);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
priv->selection_mode = GTK_SELECTION_SINGLE;
priv->activate_single_click = TRUE;
priv = _gtk_magnifier_get_instance_private (magnifier);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
priv->magnification = 1;
priv->resize = FALSE;
}
gdk_event_set_device (event, gdk_event_get_device (source));
gdk_event_set_source_device (event, gdk_event_get_source_device (source));
- event->any.surface = g_object_ref (gtk_widget_get_window (toplevel));
+ event->any.surface = g_object_ref (gtk_widget_get_surface (toplevel));
if (other_widget)
- event->crossing.child_surface = g_object_ref (gtk_widget_get_window (other_widget));
+ event->crossing.child_surface = g_object_ref (gtk_widget_get_surface (other_widget));
if (enter)
gtk_widget_set_state_flags (widget, GTK_STATE_FLAG_PRELIGHT, FALSE);
gtk_media_controls_init (GtkMediaControls *controls)
{
gtk_widget_init_template (GTK_WIDGET (controls));
- gtk_widget_set_has_window (GTK_WIDGET (controls), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (controls), FALSE);
}
/**
GdkSurface *toplevel_window;
GdkSurface *transfer_window;
- toplevel_window = gtk_widget_get_window (priv->toplevel);
+ toplevel_window = gtk_widget_get_surface (priv->toplevel);
transfer_window = g_object_get_data (G_OBJECT (menu), "gtk-menu-transfer-window");
if (toplevel_window == NULL || transfer_window == NULL)
if (xgrab_shell && xgrab_shell != widget)
{
- if (popup_grab_on_window (gtk_widget_get_window (xgrab_shell), pointer))
+ if (popup_grab_on_window (gtk_widget_get_surface (xgrab_shell), pointer))
{
_gtk_menu_shell_set_grab_device (GTK_MENU_SHELL (xgrab_shell), pointer);
GTK_MENU_SHELL (xgrab_shell)->priv->have_xgrab = TRUE;
gtk_widget_show (priv->toplevel);
if (xgrab_shell == widget)
- popup_grab_on_window (gtk_widget_get_window (widget), pointer); /* Should always succeed */
+ popup_grab_on_window (gtk_widget_get_surface (widget), pointer); /* Should always succeed */
gtk_grab_add (GTK_WIDGET (menu));
if (!window)
{
window = gdk_surface_new_temp (gtk_widget_get_display (GTK_WIDGET (menu)));
- gtk_widget_register_window (GTK_WIDGET (menu), window);
+ gtk_widget_register_surface (GTK_WIDGET (menu), window);
gdk_surface_show (window);
{
GdkSurface *widget_window;
- gtk_widget_unregister_window (GTK_WIDGET (menu), window);
+ gtk_widget_unregister_surface (GTK_WIDGET (menu), window);
gdk_surface_destroy (window);
g_object_set_data (G_OBJECT (menu), I_("gtk-menu-transfer-window"), NULL);
- widget_window = gtk_widget_get_window (GTK_WIDGET (menu));
+ widget_window = gtk_widget_get_surface (GTK_WIDGET (menu));
g_object_set_data (G_OBJECT (widget_window), I_("gdk-attached-grab-surface"), window);
}
}
GtkMenuShell *menu_shell;
gint window_x, window_y;
- gdk_surface_get_position (gtk_widget_get_window (priv->toplevel),
+ gdk_surface_get_position (gtk_widget_get_surface (priv->toplevel),
&window_x, &window_y);
gtk_widget_get_allocation (widget, &allocation);
if ((priv->scroll_offset >= 0) && (offset < 0))
offset = 0;
- view_height = gdk_surface_get_height (gtk_widget_get_window (widget));
+ view_height = gdk_surface_get_height (gtk_widget_get_surface (widget));
if (priv->scroll_offset == 0 &&
view_height >= priv->requested_height)
&bottom_arrow_height, NULL,
NULL, NULL);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
width = gdk_surface_get_width (window);
height = gdk_surface_get_height (window);
menu_shell = GTK_MENU_SHELL (menu);
- gdk_surface_get_position (gtk_widget_get_window (priv->toplevel),
+ gdk_surface_get_position (gtk_widget_get_surface (priv->toplevel),
&top_x, &top_y);
x -= top_x;
y -= top_y;
gint window_x, window_y;
gtk_widget_get_allocation (GTK_WIDGET (menu), &allocation);
- gdk_surface_get_position (gtk_widget_get_window (priv->toplevel),
+ gdk_surface_get_position (gtk_widget_get_surface (priv->toplevel),
&window_x, &window_y);
if (x_root >= window_x && x_root < window_x + allocation.width &&
y_diff = y_root - priv->drag_start_y;
offset = priv->initial_drag_offset - y_diff;
- view_height = gdk_surface_get_height (gtk_widget_get_window (widget));
+ view_height = gdk_surface_get_height (gtk_widget_get_surface (widget));
get_arrows_border (menu, &arrow_border);
if (priv->upper_arrow_visible)
}
else if (priv->widget)
{
- rect_window = gtk_widget_get_window (priv->widget);
- gtk_widget_get_window_allocation (priv->widget, &rect);
+ rect_window = gtk_widget_get_surface (priv->widget);
+ gtk_widget_get_surface_allocation (priv->widget, &rect);
text_direction = gtk_widget_get_direction (priv->widget);
}
else if (!priv->position_func)
{
rect = (GdkRectangle) { 0, 0, 1, 1 };
- rect_window = gtk_widget_get_window (attach_widget);
+ rect_window = gtk_widget_get_surface (attach_widget);
gdk_surface_get_device_position (rect_window, grab_device,
&rect.x, &rect.y, NULL);
text_direction = gtk_widget_get_direction (attach_widget);
menu_anchor = get_horizontally_flipped_anchor (menu_anchor);
}
- toplevel = gtk_widget_get_window (priv->toplevel);
+ toplevel = gtk_widget_get_surface (priv->toplevel);
gdk_surface_set_transient_for (toplevel, rect_window);
&child_offset, &child_height, &last_child))
{
y = priv->scroll_offset;
- height = gdk_surface_get_height (gtk_widget_get_window (widget));
+ height = gdk_surface_get_height (gtk_widget_get_surface (widget));
if (child_offset < y)
{
priv = gtk_menu_item_get_instance_private (menu_item);
menu_item->priv = priv;
- gtk_widget_set_has_window (GTK_WIDGET (menu_item), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (menu_item), FALSE);
g_signal_connect (menu_item, "notify::parent", G_CALLBACK (gtk_menu_item_parent_cb), NULL);
/* Position the submenu at the menu item if it is mapped.
* Otherwise, position the submenu at the pointer device.
*/
- if (gtk_widget_get_window (widget))
+ if (gtk_widget_get_surface (widget))
{
switch (priv->submenu_placement)
{
menu_shell->priv = gtk_menu_shell_get_instance_private (menu_shell);
menu_shell->priv->take_focus = TRUE;
- gtk_widget_set_has_window (GTK_WIDGET (menu_shell), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (menu_shell), FALSE);
}
static void
for (list = targets; list; list = list->next)
{
widget = GTK_WIDGET (list->data);
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
if (gtk_widget_is_sensitive (widget) &&
gtk_widget_get_mapped (widget) &&
GdkContentFormats *targets;
gtk_widget_set_can_focus (GTK_WIDGET (notebook), TRUE);
- gtk_widget_set_has_window (GTK_WIDGET (notebook), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (notebook), FALSE);
notebook->priv = gtk_notebook_get_instance_private (notebook);
priv = notebook->priv;
page->mnemonic_activate_signal);
page->mnemonic_activate_signal = 0;
- if (gtk_widget_get_window (page->tab_label) != gtk_widget_get_window (GTK_WIDGET (notebook)) ||
+ if (gtk_widget_get_surface (page->tab_label) != gtk_widget_get_surface (GTK_WIDGET (notebook)) ||
!NOTEBOOK_IS_TAB_LABEL_PARENT (notebook, page))
{
GtkWidget *parent;
static void
gtk_overlay_init (GtkOverlay *overlay)
{
- gtk_widget_set_has_window (GTK_WIDGET (overlay), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (overlay), FALSE);
}
static void
GtkPanedPrivate *priv;
GtkGesture *gesture;
- gtk_widget_set_has_window (GTK_WIDGET (paned), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (paned), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (paned), TRUE);
paned->priv = gtk_paned_get_instance_private (paned);
g_signal_connect_swapped (path_bar->priv->down_slider_button, "clicked",
G_CALLBACK (gtk_path_bar_scroll_down), path_bar);
- gtk_widget_set_has_window (GTK_WIDGET (path_bar), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (path_bar), FALSE);
context = gtk_widget_get_style_context (GTK_WIDGET (path_bar));
gtk_style_context_add_class (context, "path-bar");
GtkStyleContext *context;
widget = GTK_WIDGET (popover);
- gtk_widget_set_has_window (widget, TRUE);
+ gtk_widget_set_has_surface (widget, TRUE);
popover->priv = gtk_popover_get_instance_private (popover);
popover->priv->modal = TRUE;
popover->priv->tick_id = 0;
if (gtk_widget_get_realized (widget))
{
cairo_region_t *region = cairo_region_create ();
- gdk_surface_input_shape_combine_region (gtk_widget_get_window (widget),
+ gdk_surface_input_shape_combine_region (gtk_widget_get_surface (widget),
region, 0, 0);
cairo_region_destroy (region);
}
GtkAllocation allocation;
GdkSurface *window;
- gtk_widget_get_window_allocation (widget, &allocation);
+ gtk_widget_get_surface_allocation (widget, &allocation);
/* We want to use subsurfaces for popovers, so they can extend outside
* the main window, but for that, we first need to have clean subsurface
&allocation);
gdk_surface_set_transient_for (window,
- gtk_widget_get_window (toplevel));
+ gtk_widget_get_surface (toplevel));
}
else
#endif
{
- window = gdk_surface_new_child (gtk_widget_get_parent_window (widget),
+ window = gdk_surface_new_child (gtk_widget_get_parent_surface (widget),
&allocation);
}
- gtk_widget_set_window (widget, window);
- gtk_widget_register_window (widget, window);
+ gtk_widget_set_surface (widget, window);
+ gtk_widget_register_surface (widget, window);
gtk_widget_set_realized (widget, TRUE);
}
GTK_WIDGET_CLASS (gtk_popover_parent_class)->map (widget);
- gdk_surface_show (gtk_widget_get_window (widget));
+ gdk_surface_show (gtk_widget_get_surface (widget));
gtk_popover_update_position (GTK_POPOVER (widget));
gtk_window_set_default (priv->window, priv->default_widget);
priv->button_pressed = FALSE;
- gdk_surface_hide (gtk_widget_get_window (widget));
+ gdk_surface_hide (gtk_widget_get_surface (widget));
GTK_WIDGET_CLASS (gtk_popover_parent_class)->unmap (widget);
if (gtk_window_get_default_widget (priv->window) == priv->default_widget)
gtk_widget_translate_coordinates (priv->widget, GTK_WIDGET (priv->window),
rect.x, rect.y, &rect.x, &rect.y);
- gdk_surface_get_origin (gtk_widget_get_window (GTK_WIDGET (popover)),
+ gdk_surface_get_origin (gtk_widget_get_surface (GTK_WIDGET (popover)),
&win_x, &win_y);
rect.x -= win_x;
rect.y -= win_y;
return;
#endif
- win = gtk_widget_get_window (widget);
+ win = gtk_widget_get_surface (widget);
surface =
gdk_surface_create_similar_surface (win,
CAIRO_CONTENT_COLOR_ALPHA,
gtk_widget_shape_combine_region (widget, region);
cairo_region_destroy (region);
- gdk_surface_set_child_shapes (gtk_widget_get_window (widget));
+ gdk_surface_set_child_shapes (gtk_widget_get_surface (widget));
}
static void
if (gtk_widget_get_realized (widget))
{
GtkAllocation a;
- gtk_widget_get_window_allocation (widget, &a);
- gdk_surface_move_resize (gtk_widget_get_window (widget),
+ gtk_widget_get_surface_allocation (widget, &a);
+ gdk_surface_move_resize (gtk_widget_get_surface (widget),
a.x, a.y, a.width, a.height);
gtk_popover_update_shape (popover);
}
priv->state = STATE_SHOWN;
if (gtk_widget_get_realized (widget))
- gdk_surface_input_shape_combine_region (gtk_widget_get_window (widget),
+ gdk_surface_input_shape_combine_region (gtk_widget_get_surface (widget),
NULL, 0, 0);
}
get_parent_hwnd (GtkWidget *widget)
{
gtk_widget_realize (widget);
- return gdk_win32_surface_get_handle (gtk_widget_get_window (widget));
+ return gdk_win32_surface_get_handle (gtk_widget_get_surface (widget));
}
static void
gboolean was_grabbed,
GtkPrintOperation *op)
{
- EnableWindow (GetAncestor (GDK_SURFACE_HWND (gtk_widget_get_window (widget)), GA_ROOT),
+ EnableWindow (GetAncestor (GDK_SURFACE_HWND (gtk_widget_get_surface (widget)), GA_ROOT),
was_grabbed);
}
gtk_container_add (GTK_CONTAINER (plug), op->priv->custom_widget);
gtk_widget_show (op->priv->custom_widget);
gtk_widget_show (plug);
- gdk_surface_focus (gtk_widget_get_window (plug), GDK_CURRENT_TIME);
+ gdk_surface_focus (gtk_widget_get_surface (plug), GDK_CURRENT_TIME);
/* This dialog is modal, so we grab the embed widget */
gtk_grab_add (plug);
page_name_func, NULL, NULL);
/* Preview drawing area has no window */
- gtk_widget_set_has_window (priv->page_layout_preview, FALSE);
+ gtk_widget_set_has_surface (priv->page_layout_preview, FALSE);
/* Load backends */
load_print_backends (dialog);
priv->text = NULL;
priv->fraction = 0.0;
- gtk_widget_set_has_window (GTK_WIDGET (pbar), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (pbar), FALSE);
_gtk_orientable_set_style_classes (GTK_ORIENTABLE (pbar));
{
GtkRangePrivate *priv = gtk_range_get_instance_private (range);
- gtk_widget_set_has_window (GTK_WIDGET (range), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (range), FALSE);
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
priv->adjustment = NULL;
priv->current_pos = 0.0;
priv->target_pos = 0.0;
- gtk_widget_set_has_window ((GtkWidget*) revealer, FALSE);
+ gtk_widget_set_has_surface ((GtkWidget*) revealer, FALSE);
}
static void
{
GtkScrollbarPrivate *priv = gtk_scrollbar_get_instance_private (self);
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
scrolled_window->priv = priv =
gtk_scrolled_window_get_instance_private (scrolled_window);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
gtk_widget_set_can_focus (widget, TRUE);
/* Instantiated by gtk_scrolled_window_set_[hv]adjustment
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
- gtk_widget_set_has_window (GTK_WIDGET (separator), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (separator), FALSE);
_gtk_orientable_set_style_classes (GTK_ORIENTABLE (separator));
}
priv = separator_item->priv = gtk_separator_tool_item_get_instance_private (separator_item);
priv->draw = TRUE;
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
}
static void
static void
gtk_shortcuts_shortcut_init (GtkShortcutsShortcut *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
self->box = g_object_new (GTK_TYPE_BOX,
"orientation", GTK_ORIENTATION_HORIZONTAL,
{
GtkSpinButtonPrivate *priv = gtk_spin_button_get_instance_private (spin_button);
- gtk_widget_set_has_window (GTK_WIDGET (spin_button), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (spin_button), FALSE);
priv->adjustment = NULL;
priv->timer = 0;
static void
gtk_spinner_init (GtkSpinner *spinner)
{
- gtk_widget_set_has_window (GTK_WIDGET (spinner), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (spinner), FALSE);
}
/**
{
GtkStackPrivate *priv = gtk_stack_get_instance_private (stack);
- gtk_widget_set_has_window (GTK_WIDGET (stack), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (stack), FALSE);
priv->vhomogeneous = TRUE;
priv->hhomogeneous = TRUE;
GtkStyleContext *context;
GtkStackSwitcherPrivate *priv;
- gtk_widget_set_has_window (GTK_WIDGET (switcher), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (switcher), FALSE);
priv = gtk_stack_switcher_get_instance_private (switcher);
{
GtkStatusbarPrivate *priv;
- gtk_widget_set_has_window (GTK_WIDGET (statusbar), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (statusbar), FALSE);
statusbar->priv = gtk_statusbar_get_instance_private (statusbar);
priv = statusbar->priv;
GtkSwitchPrivate *priv = gtk_switch_get_instance_private (self);
GtkGesture *gesture;
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
gtk_widget_set_can_focus (GTK_WIDGET (self), TRUE);
gesture = gtk_gesture_multi_press_new (GTK_WIDGET (self));
pixmap_width = layout_width / PANGO_SCALE;
pixmap_height = layout_height / PANGO_SCALE;
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (widget),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
CAIRO_CONTENT_COLOR_ALPHA,
pixmap_width, pixmap_height);
cr = cairo_create (surface);
layout_width = MIN (layout_width, DRAG_ICON_MAX_WIDTH);
layout_height = MIN (layout_height, DRAG_ICON_MAX_HEIGHT);
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (widget),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
CAIRO_CONTENT_COLOR_ALPHA,
layout_width, layout_height);
text_view->priv = gtk_text_view_get_instance_private (text_view);
priv = text_view->priv;
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
gtk_widget_set_can_focus (widget, TRUE);
context = gtk_widget_get_style_context (GTK_WIDGET (text_view));
&iter_location.y);
gtk_menu_popup_at_rect (GTK_MENU (priv->popup_menu),
- gtk_widget_get_window (GTK_WIDGET (text_view)),
+ gtk_widget_get_surface (GTK_WIDGET (text_view)),
&iter_location,
GDK_GRAVITY_SOUTH_EAST,
GDK_GRAVITY_NORTH_WEST,
priv = toolbar->priv;
gtk_widget_set_can_focus (widget, FALSE);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
priv->orientation = GTK_ORIENTATION_HORIZONTAL;
priv->style = DEFAULT_TOOLBAR_STYLE;
gint x3, y3;
gint x4, y4;
- window = gtk_widget_get_parent_window (widget);
+ window = gtk_widget_get_parent_surface (widget);
if (window == NULL)
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gtk_widget_get_allocation (widget, &allocation);
tooltip->keyboard_widget = g_object_ref (widget);
- gdk_surface_get_device_position (gtk_widget_get_window (widget),
+ gdk_surface_get_device_position (gtk_widget_get_surface (widget),
device, &x, &y, NULL);
return_value = gtk_tooltip_run_requery (&widget, tooltip, &x, &y);
priv->event_last_x = -10000;
priv->event_last_y = -10000;
- gtk_widget_set_has_window (GTK_WIDGET (tree_view), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (tree_view), FALSE);
gtk_tree_view_do_set_vadjustment (tree_view, NULL);
gtk_tree_view_do_set_hadjustment (tree_view, NULL);
if (priv->drag_surface)
{
- gtk_widget_unregister_window (widget, priv->drag_surface);
+ gtk_widget_unregister_surface (widget, priv->drag_surface);
gdk_surface_destroy (priv->drag_surface);
priv->drag_surface = NULL;
}
if (priv->drag_highlight_window)
{
- gtk_widget_unregister_window (widget, priv->drag_highlight_window);
+ gtk_widget_unregister_surface (widget, priv->drag_highlight_window);
gdk_surface_destroy (priv->drag_highlight_window);
priv->drag_highlight_window = NULL;
}
tree_view->priv->cur_reorder->left_column);
}
tree_view->priv->drag_column = NULL;
- gtk_widget_unregister_window (widget, tree_view->priv->drag_surface);
+ gtk_widget_unregister_surface (widget, tree_view->priv->drag_surface);
gdk_surface_destroy (tree_view->priv->drag_surface);
tree_view->priv->drag_surface = NULL;
if (tree_view->priv->drag_highlight_window)
{
- gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
+ gtk_widget_unregister_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
gdk_surface_destroy (tree_view->priv->drag_highlight_window);
}
gtk_widget_get_allocation (button, &drag_allocation);
width = drag_allocation.width;
height = drag_allocation.height;
- tree_view->priv->drag_highlight_window = gdk_surface_new_child (gtk_widget_get_window (widget),
+ tree_view->priv->drag_highlight_window = gdk_surface_new_child (gtk_widget_get_surface (widget),
&(GdkRectangle){
tree_view->priv->drag_column_x,
0,
drag_allocation.width,
drag_allocation.height});
- gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
+ gtk_widget_register_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
tree_view->priv->drag_column_surface_state = DRAG_COLUMN_WINDOW_STATE_ORIGINAL;
}
{
if (tree_view->priv->drag_highlight_window)
{
- gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
+ gtk_widget_unregister_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
gdk_surface_destroy (tree_view->priv->drag_highlight_window);
}
tree_view->priv->drag_highlight_window = gdk_surface_new_popup (gtk_widget_get_display (widget),
&(GdkRectangle) { x, y, width, height });
- gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
+ gtk_widget_register_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
{
if (tree_view->priv->drag_highlight_window)
{
- gtk_widget_unregister_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
+ gtk_widget_unregister_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
gdk_surface_destroy (tree_view->priv->drag_highlight_window);
}
tree_view->priv->drag_highlight_window = gdk_surface_new_popup (gtk_widget_get_display (widget),
&(GdkRectangle) { x, y, width, height });
- gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
+ gtk_widget_register_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_highlight_window);
mask_image = cairo_image_surface_create (CAIRO_FORMAT_A1, width, height);
new_event = gdk_event_copy ((GdkEvent *) event);
g_object_unref (((GdkEventKey *) new_event)->any.surface);
((GdkEventKey *) new_event)->any.surface =
- g_object_ref (gtk_widget_get_window (search_window));
+ g_object_ref (gtk_widget_get_surface (search_window));
gtk_widget_realize (search_window);
popup_menu_id = g_signal_connect (tree_view->priv->search_entry,
gtk_widget_get_allocation (button, &button_allocation);
button_allocation.y = 0;
- tree_view->priv->drag_surface = gdk_surface_new_child (gtk_widget_get_window (GTK_WIDGET (tree_view)),
+ tree_view->priv->drag_surface = gdk_surface_new_child (gtk_widget_get_surface (GTK_WIDGET (tree_view)),
&button_allocation);
- gtk_widget_register_window (GTK_WIDGET (tree_view), tree_view->priv->drag_surface);
+ gtk_widget_register_surface (GTK_WIDGET (tree_view), tree_view->priv->drag_surface);
/* Kids, don't try this at home */
g_object_ref (button);
gtk_container_remove (GTK_CONTAINER (tree_view), button);
- gtk_widget_set_parent_window (button, tree_view->priv->drag_surface);
+ gtk_widget_set_parent_surface (button, tree_view->priv->drag_surface);
gtk_widget_set_parent (button, GTK_WIDGET (tree_view));
g_object_unref (button);
/* Skip non-master keyboards that haven't
* selected for events from this surface
*/
- surface = gtk_widget_get_window (widget);
+ surface = gtk_widget_get_surface (widget);
if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
!gdk_surface_get_device_events (surface, dev))
continue;
bin_window_width = gtk_widget_get_width (GTK_WIDGET (tree_view));
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (GTK_WIDGET (tree_view)),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (GTK_WIDGET (tree_view)),
CAIRO_CONTENT_COLOR,
bin_window_width + 2,
background_area.height + 2);
GdkDisplay *display;
GdkMonitor *monitor;
GdkRectangle workarea;
- GdkSurface *tree_window = gtk_widget_get_window (GTK_WIDGET (tree_view));
+ GdkSurface *tree_window = gtk_widget_get_surface (GTK_WIDGET (tree_view));
GtkRequisition requisition;
gtk_widget_realize (search_window);
GTK_WIDGET_CLASS (gtk_video_parent_class)->realize (widget);
if (self->media_stream)
- gtk_media_stream_realize (self->media_stream, gtk_widget_get_window (GTK_WIDGET (self)));
+ gtk_media_stream_realize (self->media_stream, gtk_widget_get_surface (GTK_WIDGET (self)));
if (self->file)
gtk_media_file_set_file (GTK_MEDIA_FILE (self->media_stream), self->file);
GtkVideo *self = GTK_VIDEO (widget);
if (self->media_stream)
- gtk_media_stream_unrealize (self->media_stream, gtk_widget_get_window (GTK_WIDGET (self)));
+ gtk_media_stream_unrealize (self->media_stream, gtk_widget_get_surface (GTK_WIDGET (self)));
GTK_WIDGET_CLASS (gtk_video_parent_class)->unrealize (widget);
}
gtk_video_init (GtkVideo *self)
{
gtk_widget_init_template (GTK_WIDGET (self));
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
self->motion_controller = gtk_event_controller_motion_new (GTK_WIDGET (self));
g_signal_connect (self->motion_controller, "motion", G_CALLBACK (gtk_video_motion), self);
gtk_video_notify_cb,
self);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
- gtk_media_stream_unrealize (self->media_stream, gtk_widget_get_window (GTK_WIDGET (self)));
+ gtk_media_stream_unrealize (self->media_stream, gtk_widget_get_surface (GTK_WIDGET (self)));
g_object_unref (self->media_stream);
self->media_stream = NULL;
}
{
self->media_stream = g_object_ref (stream);
if (gtk_widget_get_realized (GTK_WIDGET (self)))
- gtk_media_stream_realize (stream, gtk_widget_get_window (GTK_WIDGET (self)));
+ gtk_media_stream_realize (stream, gtk_widget_get_surface (GTK_WIDGET (self)));
g_signal_connect (self->media_stream,
"notify",
G_CALLBACK (gtk_video_notify_cb),
widget = GTK_WIDGET (viewport);
- gtk_widget_set_has_window (widget, FALSE);
+ gtk_widget_set_has_surface (widget, FALSE);
priv->shadow_type = GTK_SHADOW_IN;
priv->hadjustment = NULL;
g_value_set_string (value, g_object_get_qdata (object, quark_tooltip_markup));
break;
case PROP_WINDOW:
- g_value_set_object (value, _gtk_widget_get_window (widget));
+ g_value_set_object (value, _gtk_widget_get_surface (widget));
break;
case PROP_HALIGN:
g_value_set_enum (value, gtk_widget_get_halign (widget));
* an embedded GtkWindow the window will become toplevel again and hierarchy-changed
* will fire again for the new subhierarchy.
*/
- gtk_widget_set_parent_window (widget, NULL);
+ gtk_widget_set_parent_surface (widget, NULL);
g_object_notify_by_pspec (G_OBJECT (widget), widget_props[PROP_PARENT]);
g_object_thaw_notify (G_OBJECT (widget));
update_cursor_on_state_change (widget);
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
gtk_widget_queue_draw (widget);
gtk_widget_pop_verify_invariants (widget);
g_object_ref (widget);
gtk_widget_push_verify_invariants (widget);
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
gtk_widget_queue_draw (widget);
_gtk_tooltip_hide (widget);
gtk_widget_push_verify_invariants (widget);
/*
- if (GTK_IS_CONTAINER (widget) && _gtk_widget_get_has_window (widget))
+ if (GTK_IS_CONTAINER (widget) && _gtk_widget_get_has_surface (widget))
g_message ("gtk_widget_realize(%s)", G_OBJECT_TYPE_NAME (widget));
*/
* for a windowed widget.
*/
void
-gtk_widget_get_window_allocation (GtkWidget *widget,
+gtk_widget_get_surface_allocation (GtkWidget *widget,
GtkAllocation *allocation)
{
GtkWidget *parent;
/* Don't consider the parent == widget case here. */
parent = _gtk_widget_get_parent (widget);
- while (parent && !_gtk_widget_get_has_window (parent))
+ while (parent && !_gtk_widget_get_has_surface (parent))
parent = _gtk_widget_get_parent (parent);
g_assert (GTK_IS_WINDOW (parent) || GTK_IS_POPOVER (parent));
parent = _gtk_widget_get_parent (widget);
rect = &widget->priv->clip;
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
gtk_widget_queue_draw_area (parent ? parent : widget,
rect->x, rect->y, rect->width, rect->height);
else
* reparenting windows and widgets.
*/
GtkWidget *toplevel = _gtk_widget_get_toplevel (widget);
- GdkSurface *window = _gtk_widget_get_window (toplevel);
+ GdkSurface *window = _gtk_widget_get_surface (toplevel);
g_assert (window != NULL);
return gdk_surface_get_frame_clock (window);
if (!_gtk_widget_get_parent (widget))
{
- g_assert (_gtk_widget_get_has_window (widget));
+ g_assert (_gtk_widget_get_has_surface (widget));
region2 = cairo_region_copy (region);
windowed_parent = widget;
goto invalidate;
/* Look for the parent with a window and invalidate @region in there. */
windowed_parent = widget;
- while (windowed_parent != NULL && !_gtk_widget_get_has_window (windowed_parent))
+ while (windowed_parent != NULL && !_gtk_widget_get_has_surface (windowed_parent))
windowed_parent = _gtk_widget_get_parent (windowed_parent);
g_assert (windowed_parent != NULL);
/* At this point, x and y are relative to the windowed parent's origin,
* but the window of the parent spans over its entire allocation, so we need
* to account for border and padding manually. The values returned from
- * gtk_widget_get_window_allocation, which should've been used to size and position
+ * gtk_widget_get_surface_allocation, which should've been used to size and position
* @parent's window, do not include widget margins nor css margins.
*/
parent_style = gtk_css_node_get_style (windowed_parent->priv->cssnode);
invalidate:
gtk_debug_updates_add (windowed_parent, region2);
- gdk_surface_invalidate_region (_gtk_widget_get_window (widget), region2, TRUE);
+ gdk_surface_invalidate_region (_gtk_widget_get_surface (widget), region2, TRUE);
cairo_region_destroy (region2);
real_allocation.height = 0;
}
- if (G_UNLIKELY (_gtk_widget_get_has_window (widget)))
+ if (G_UNLIKELY (_gtk_widget_get_has_surface (widget)))
{
real_allocation.width = MAX (1, real_allocation.width);
real_allocation.height = MAX (1, real_allocation.height);
/* Still have to move the window... */
if (_gtk_widget_get_realized (widget) &&
- _gtk_widget_get_has_window (widget))
+ _gtk_widget_get_has_surface (widget))
{
GtkAllocation window_alloc;
- gtk_widget_get_window_allocation (widget, &window_alloc);
+ gtk_widget_get_surface_allocation (widget, &window_alloc);
gdk_surface_move_resize (priv->window,
window_alloc.x, window_alloc.y,
window_alloc.width, window_alloc.height);
GtkWidgetPrivate *priv = gtk_widget_get_instance_private (widget);
if (_gtk_widget_get_realized (widget) &&
- _gtk_widget_get_has_window (widget))
+ _gtk_widget_get_has_surface (widget))
{
GtkAllocation window_alloc;
- gtk_widget_get_window_allocation (widget, &window_alloc);
+ gtk_widget_get_surface_allocation (widget, &window_alloc);
gdk_surface_move_resize (priv->window,
window_alloc.x, window_alloc.y,
window_alloc.width, window_alloc.height);
return_val = gdk_rectangle_intersect (&priv->allocation, area, dest);
- if (return_val && intersection && _gtk_widget_get_has_window (widget))
+ if (return_val && intersection && _gtk_widget_get_has_surface (widget))
{
intersection->x -= priv->allocation.x;
intersection->y -= priv->allocation.y;
}
/**
- * gtk_widget_set_has_window:
+ * gtk_widget_set_has_surface:
* @widget: a #GtkWidget
* @has_window: whether or not @widget has a window.
*
* Specifies whether @widget has a #GdkSurface of its own. Note that
* all realized widgets have a non-%NULL “window” pointer
- * (gtk_widget_get_window() never returns a %NULL window when a widget
+ * (gtk_widget_get_surface() never returns a %NULL window when a widget
* is realized), but for many of them it’s actually the #GdkSurface of
* one of its parent widgets. Widgets that do not create a %window for
* themselves in #GtkWidget::realize must announce this by
* and they should call it in their init() function.
**/
void
-gtk_widget_set_has_window (GtkWidget *widget,
+gtk_widget_set_has_surface (GtkWidget *widget,
gboolean has_window)
{
g_return_if_fail (GTK_IS_WIDGET (widget));
}
/**
- * gtk_widget_get_has_window:
+ * gtk_widget_get_has_surface:
* @widget: a #GtkWidget
*
* Determines whether @widget has a #GdkSurface of its own. See
- * gtk_widget_set_has_window().
+ * gtk_widget_set_has_surface().
*
* Returns: %TRUE if @widget has a window, %FALSE otherwise
**/
gboolean
-gtk_widget_get_has_window (GtkWidget *widget)
+gtk_widget_get_has_surface (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), FALSE);
}
/**
- * gtk_widget_set_parent_window:
+ * gtk_widget_set_parent_surface:
* @widget: a #GtkWidget.
* @parent_window: the new parent window.
*
* window is realized.
*/
void
-gtk_widget_set_parent_window (GtkWidget *widget,
+gtk_widget_set_parent_surface (GtkWidget *widget,
GdkSurface *parent_window)
{
GdkSurface *old_parent_window;
}
/**
- * gtk_widget_get_parent_window:
+ * gtk_widget_get_parent_surface:
* @widget: a #GtkWidget.
*
* Gets @widget’s parent window, or %NULL if it does not have one.
* if it does not have a parent window.
**/
GdkSurface *
-gtk_widget_get_parent_window (GtkWidget *widget)
+gtk_widget_get_parent_surface (GtkWidget *widget)
{
GtkWidgetPrivate *priv;
GdkSurface *parent_window;
g_return_val_if_fail (GTK_IS_WIDGET (widget), 1);
if (_gtk_widget_get_realized (widget))
- return gdk_surface_get_scale_factor (_gtk_widget_get_window (widget));
+ return gdk_surface_get_scale_factor (_gtk_widget_get_surface (widget));
toplevel = _gtk_widget_get_toplevel (widget);
if (toplevel && toplevel != widget)
if (!widget->priv->no_window_set)
{
- g_warning ("%s does not call gtk_widget_set_has_window() in its init function", G_OBJECT_TYPE_NAME (widget));
+ g_warning ("%s does not call gtk_widget_set_has_surface() in its init function", G_OBJECT_TYPE_NAME (widget));
}
}
GtkWidget *p;
priv->mapped = TRUE;
- if (_gtk_widget_get_has_window (widget))
+ if (_gtk_widget_get_has_surface (widget))
gdk_surface_show (priv->window);
for (p = gtk_widget_get_first_child (widget);
GtkWidget *child;
priv->mapped = FALSE;
- if (_gtk_widget_get_has_window (widget))
+ if (_gtk_widget_get_has_surface (widget))
gdk_surface_hide (priv->window);
for (child = gtk_widget_get_first_child (widget);
{
GtkWidgetPrivate *priv = widget->priv;
- g_assert (!_gtk_widget_get_has_window (widget));
+ g_assert (!_gtk_widget_get_has_surface (widget));
gtk_widget_set_realized (widget, TRUE);
if (priv->parent)
{
- priv->window = gtk_widget_get_parent_window (widget);
+ priv->window = gtk_widget_get_parent_surface (widget);
g_object_ref (priv->window);
}
}
gtk_widget_forall (widget, (GtkCallback)gtk_widget_unrealize, NULL);
- if (_gtk_widget_get_has_window (widget))
+ if (_gtk_widget_get_has_surface (widget))
{
- gtk_widget_unregister_window (widget, priv->window);
+ gtk_widget_unregister_surface (widget, priv->window);
gdk_surface_destroy (priv->window);
priv->window = NULL;
}
g_return_if_fail (GTK_IS_WIDGET (widget));
/* set_shape doesn't work on widgets without GDK surface */
- g_return_if_fail (_gtk_widget_get_has_window (widget));
+ g_return_if_fail (_gtk_widget_get_has_surface (widget));
priv = widget->priv;
{
g_return_if_fail (GTK_IS_WIDGET (widget));
/* set_shape doesn't work on widgets without GDK surface */
- g_return_if_fail (_gtk_widget_get_has_window (widget));
+ g_return_if_fail (_gtk_widget_get_has_surface (widget));
if (region == NULL)
g_object_set_qdata (G_OBJECT (widget), quark_input_shape_info, NULL);
}
/**
- * gtk_widget_set_window:
+ * gtk_widget_set_surface:
* @widget: a #GtkWidget
* @window: (transfer full): a #GdkSurface
*
* widget’s #GtkWidget::realize implementation. The %window passed is
* usually either new window created with gdk_surface_new(), or the
* window of its parent widget as returned by
- * gtk_widget_get_parent_window().
+ * gtk_widget_get_parent_surface().
*
* Widgets must indicate whether they will create their own #GdkSurface
- * by calling gtk_widget_set_has_window(). This is usually done in the
+ * by calling gtk_widget_set_has_surface(). This is usually done in the
* widget’s init() function.
*
* Note that this function does not add any reference to @window.
*/
void
-gtk_widget_set_window (GtkWidget *widget,
+gtk_widget_set_surface (GtkWidget *widget,
GdkSurface *window)
{
GtkWidgetPrivate *priv;
}
/**
- * gtk_widget_register_window:
+ * gtk_widget_register_surface:
* @widget: a #GtkWidget
* @window: a #GdkSurface
*
* Registers a #GdkSurface with the widget and sets it up so that
- * the widget receives events for it. Call gtk_widget_unregister_window()
+ * the widget receives events for it. Call gtk_widget_unregister_surface()
* when destroying the window.
*
* Before 3.8 you needed to call gdk_surface_set_user_data() directly to set
- * this up. This is now deprecated and you should use gtk_widget_register_window()
+ * this up. This is now deprecated and you should use gtk_widget_register_surface()
* instead. Old code will keep working as is, although some new features like
* transparency might not work perfectly.
*/
void
-gtk_widget_register_window (GtkWidget *widget,
+gtk_widget_register_surface (GtkWidget *widget,
GdkSurface *window)
{
GtkWidgetPrivate *priv;
}
/**
- * gtk_widget_unregister_window:
+ * gtk_widget_unregister_surface:
* @widget: a #GtkWidget
* @window: a #GdkSurface
*
* Unregisters a #GdkSurface from the widget that was previously set up with
- * gtk_widget_register_window(). You need to call this when the window is
+ * gtk_widget_register_surface(). You need to call this when the window is
* no longer used by the widget, such as when you destroy it.
*/
void
-gtk_widget_unregister_window (GtkWidget *widget,
+gtk_widget_unregister_surface (GtkWidget *widget,
GdkSurface *window)
{
GtkWidgetPrivate *priv;
}
/**
- * gtk_widget_get_window:
+ * gtk_widget_get_surface:
* @widget: a #GtkWidget
*
* Returns the widget’s window if it is realized, %NULL otherwise
* Returns: (transfer none) (nullable): @widget’s window.
*/
GdkSurface*
-gtk_widget_get_window (GtkWidget *widget)
+gtk_widget_get_surface (GtkWidget *widget)
{
g_return_val_if_fail (GTK_IS_WIDGET (widget), NULL);
*
* fevent->focus_change.type = GDK_FOCUS_CHANGE;
* fevent->focus_change.in = TRUE;
- * fevent->focus_change.window = _gtk_widget_get_window (widget);
+ * fevent->focus_change.window = _gtk_widget_get_surface (widget);
* if (fevent->focus_change.window != NULL)
* g_object_ref (fevent->focus_change.window);
*
gboolean gtk_widget_is_visible (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
-void gtk_widget_set_has_window (GtkWidget *widget,
+void gtk_widget_set_has_surface (GtkWidget *widget,
gboolean has_window);
GDK_AVAILABLE_IN_ALL
-gboolean gtk_widget_get_has_window (GtkWidget *widget);
+gboolean gtk_widget_get_has_surface (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
gboolean gtk_widget_is_toplevel (GtkWidget *widget);
GtkWidget * gtk_widget_get_parent (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
-void gtk_widget_set_parent_window (GtkWidget *widget,
+void gtk_widget_set_parent_surface (GtkWidget *widget,
GdkSurface *parent_window);
GDK_AVAILABLE_IN_ALL
-GdkSurface * gtk_widget_get_parent_window (GtkWidget *widget);
+GdkSurface * gtk_widget_get_parent_surface (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
void gtk_widget_set_child_visible (GtkWidget *widget,
gboolean gtk_widget_get_child_visible (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
-void gtk_widget_set_window (GtkWidget *widget,
+void gtk_widget_set_surface (GtkWidget *widget,
GdkSurface *window);
GDK_AVAILABLE_IN_ALL
-GdkSurface * gtk_widget_get_window (GtkWidget *widget);
+GdkSurface * gtk_widget_get_surface (GtkWidget *widget);
GDK_AVAILABLE_IN_ALL
-void gtk_widget_register_window (GtkWidget *widget,
+void gtk_widget_register_surface (GtkWidget *widget,
GdkSurface *window);
GDK_AVAILABLE_IN_ALL
-void gtk_widget_unregister_window (GtkWidget *widget,
+void gtk_widget_unregister_surface (GtkWidget *widget,
GdkSurface *window);
GDK_AVAILABLE_IN_ALL
}
else
{
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
compare_info.y = allocation.y + allocation.height / 2;
else
compare_info.y = allocation.height / 2;
}
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
compare_info.x = (direction == GTK_DIR_RIGHT) ? allocation.x : allocation.x + allocation.width;
else
compare_info.x = (direction == GTK_DIR_RIGHT) ? 0 : allocation.width;
}
else
{
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
compare_info.x = allocation.x + allocation.width / 2;
else
compare_info.x = allocation.width / 2;
}
- if (!_gtk_widget_get_has_window (widget))
+ if (!_gtk_widget_get_has_surface (widget))
compare_info.y = (direction == GTK_DIR_DOWN) ? allocation.y : allocation.y + allocation.height;
else
compare_info.y = (direction == GTK_DIR_DOWN) ? 0 : + allocation.height;
void gtk_widget_get_own_allocation (GtkWidget *widget,
GtkAllocation *allocation);
-void gtk_widget_get_window_allocation (GtkWidget *widget,
+void gtk_widget_get_surface_allocation (GtkWidget *widget,
GtkAllocation *allocation);
}
static inline gboolean
-_gtk_widget_get_has_window (GtkWidget *widget)
+_gtk_widget_get_has_surface (GtkWidget *widget)
{
return !widget->priv->no_window;
}
}
static inline GdkSurface *
-_gtk_widget_get_window (GtkWidget *widget)
+_gtk_widget_get_surface (GtkWidget *widget)
{
return widget->priv->window;
}
_gtk_window_toggle_maximized (window);
}
else if (g_str_equal (action, "lower"))
- gdk_surface_lower (_gtk_widget_get_window (GTK_WIDGET (window)));
+ gdk_surface_lower (_gtk_widget_get_surface (GTK_WIDGET (window)));
else if (g_str_equal (action, "minimize"))
- gdk_surface_iconify (_gtk_widget_get_window (GTK_WIDGET (window)));
+ gdk_surface_iconify (_gtk_widget_get_surface (GTK_WIDGET (window)));
else if (g_str_equal (action, "menu"))
gtk_window_do_popup (window, (GdkEventButton*) event);
else
event_widget = gtk_get_event_widget ((GdkEvent *) event);
if (region == GTK_WINDOW_REGION_TITLE)
- gdk_surface_raise (_gtk_widget_get_window (widget));
+ gdk_surface_raise (_gtk_widget_get_surface (widget));
switch (region)
{
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
gdk_event_get_root_coords (event, &x_root, &y_root);
- gdk_surface_begin_resize_drag_for_device (_gtk_widget_get_window (widget),
+ gdk_surface_begin_resize_drag_for_device (_gtk_widget_get_surface (widget),
(GdkSurfaceEdge) region,
gdk_event_get_device ((GdkEvent *) event),
GDK_BUTTON_PRIMARY,
gtk_gesture_set_state (GTK_GESTURE (gesture), GTK_EVENT_SEQUENCE_CLAIMED);
gtk_gesture_drag_get_start_point (gesture, &start_x, &start_y);
- gdk_surface_get_root_coords (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_get_root_coords (_gtk_widget_get_surface (GTK_WIDGET (window)),
start_x, start_y, &x_root, &y_root);
- gdk_surface_begin_move_drag_for_device (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_begin_move_drag_for_device (_gtk_widget_get_surface (GTK_WIDGET (window)),
gtk_gesture_get_device (GTK_GESTURE (gesture)),
gtk_gesture_single_get_current_button (GTK_GESTURE_SINGLE (gesture)),
x_root, y_root,
priv->maximized)
return FALSE;
- supports_edge_constraints = gdk_surface_supports_edge_constraints (_gtk_widget_get_window (GTK_WIDGET (window)));
+ supports_edge_constraints = gdk_surface_supports_edge_constraints (_gtk_widget_get_surface (GTK_WIDGET (window)));
constraints = constraints_for_edge (edge);
if (!supports_edge_constraints && priv->tiled)
window->priv = gtk_window_get_instance_private (window);
priv = window->priv;
- gtk_widget_set_has_window (widget, TRUE);
+ gtk_widget_set_has_surface (widget, TRUE);
_gtk_widget_set_is_toplevel (widget, TRUE);
_gtk_widget_set_anchored (widget, TRUE);
priv->title = new_title;
if (_gtk_widget_get_realized (widget))
- gdk_surface_set_title (_gtk_widget_get_window (widget), new_title != NULL ? new_title : "");
+ gdk_surface_set_title (_gtk_widget_get_surface (widget), new_title != NULL ? new_title : "");
if (update_titlebar && GTK_IS_HEADER_BAR (priv->title_box))
gtk_header_bar_set_title (GTK_HEADER_BAR (priv->title_box), new_title != NULL ? new_title : "");
priv->wm_role = new_role;
if (_gtk_widget_get_realized (widget))
- gdk_surface_set_role (_gtk_widget_get_window (widget), priv->wm_role);
+ gdk_surface_set_role (_gtk_widget_get_surface (widget), priv->wm_role);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_ROLE]);
}
GdkSurface *gdk_surface;
guint32 timestamp = extract_time_from_startup_id (priv->startup_id);
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
#ifdef GDK_WINDOWING_X11
if (timestamp != GDK_CURRENT_TIME && GDK_IS_X11_SURFACE(gdk_surface))
/* adjust desired modality state */
if (_gtk_widget_get_realized (widget))
- gdk_surface_set_modal_hint (_gtk_widget_get_window (widget), priv->modal);
+ gdk_surface_set_modal_hint (_gtk_widget_get_surface (widget), priv->modal);
if (gtk_widget_get_visible (widget))
{
GtkWidget *window)
{
if (_gtk_widget_get_realized (window))
- gdk_surface_set_transient_for (_gtk_widget_get_window (window),
- _gtk_widget_get_window (parent));
+ gdk_surface_set_transient_for (_gtk_widget_get_surface (window),
+ _gtk_widget_get_surface (parent));
}
static void
GtkWidget *window)
{
if (_gtk_widget_get_realized (window))
- gdk_surface_set_transient_for (_gtk_widget_get_window (window), NULL);
+ gdk_surface_set_transient_for (_gtk_widget_get_surface (window), NULL);
}
static void
priv->type_hint = hint;
- gdk_surface = _gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = _gtk_widget_get_surface (GTK_WIDGET (window));
if (gdk_surface)
gdk_surface_set_type_hint (gdk_surface, hint);
{
priv->skips_taskbar = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_skip_taskbar_hint (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_set_skip_taskbar_hint (_gtk_widget_get_surface (GTK_WIDGET (window)),
priv->skips_taskbar);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_SKIP_TASKBAR_HINT]);
}
{
priv->skips_pager = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_skip_pager_hint (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_set_skip_pager_hint (_gtk_widget_get_surface (GTK_WIDGET (window)),
priv->skips_pager);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_SKIP_PAGER_HINT]);
}
{
priv->urgent = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_urgency_hint (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_set_urgency_hint (_gtk_widget_get_surface (GTK_WIDGET (window)),
priv->urgent);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_URGENCY_HINT]);
}
{
priv->accept_focus = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_accept_focus (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_set_accept_focus (_gtk_widget_get_surface (GTK_WIDGET (window)),
priv->accept_focus);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_ACCEPT_FOCUS]);
}
{
priv->focus_on_map = setting;
if (_gtk_widget_get_realized (GTK_WIDGET (window)))
- gdk_surface_set_focus_on_map (_gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_surface_set_focus_on_map (_gtk_widget_get_surface (GTK_WIDGET (window)),
priv->focus_on_map);
g_object_notify_by_pspec (G_OBJECT (window), window_props[PROP_FOCUS_ON_MAP]);
}
priv->decorated = setting;
- gdk_surface = _gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = _gtk_widget_get_surface (GTK_WIDGET (window));
if (gdk_surface)
{
if (priv->decorated)
priv->deletable = setting;
- gdk_surface = _gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = _gtk_widget_get_surface (GTK_WIDGET (window));
if (gdk_surface)
{
if (priv->deletable)
GList *icon_list;
widget = GTK_WIDGET (window);
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
g_return_if_fail (gdk_surface != NULL);
if (_gtk_widget_get_mapped (GTK_WIDGET (window)))
{
- w = gdk_surface_get_width (_gtk_widget_get_window (GTK_WIDGET (window)));
- h = gdk_surface_get_height (_gtk_widget_get_window (GTK_WIDGET (window)));
+ w = gdk_surface_get_width (_gtk_widget_get_surface (GTK_WIDGET (window)));
+ h = gdk_surface_get_height (_gtk_widget_get_surface (GTK_WIDGET (window)));
}
else
{
* the same as the position being changed by the window
* manager.
*/
- gdk_surface_move (_gtk_widget_get_window (GTK_WIDGET (window)), x, y);
+ gdk_surface_move (_gtk_widget_get_surface (GTK_WIDGET (window)), x, y);
}
else
{
priv = window->priv;
widget = GTK_WIDGET (window);
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
if (priv->gravity == GDK_GRAVITY_STATIC)
{
gtk_widget_get_child_visible (priv->title_box))
gtk_widget_map (priv->title_box);
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
if (priv->maximize_initially)
gdk_surface_maximize (gdk_surface);
return;
}
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
GTK_WIDGET_CLASS (gtk_window_parent_class)->unmap (widget);
gdk_surface_withdraw (gdk_surface);
while (priv->configure_request_count > 0)
{
priv->configure_request_count--;
- gdk_surface_thaw_toplevel_updates (_gtk_widget_get_window (widget));
+ gdk_surface_thaw_toplevel_updates (_gtk_widget_get_surface (widget));
}
priv->configure_notify_received = FALSE;
widget = GTK_WIDGET (window);
display = gtk_widget_get_display (widget);
- gdkwindow = _gtk_widget_get_window (widget);
+ gdkwindow = _gtk_widget_get_surface (widget);
if (gdkwindow)
monitor = gdk_display_get_monitor_at_surface (display, gdkwindow);
*width = 0;
*height = 0;
- gdk_surface = _gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = _gtk_widget_get_surface (GTK_WIDGET (window));
if (gdk_surface)
{
*width = gdk_surface_get_width (gdk_surface);
{
GdkSurface *gdk_surface;
- gdk_surface = _gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = _gtk_widget_get_surface (GTK_WIDGET (window));
if (gdk_surface)
gdk_surface_set_shadow_width (gdk_surface,
opaque_region = NULL;
}
- gdk_surface_set_opaque_region (_gtk_widget_get_window (widget), opaque_region);
+ gdk_surface_set_opaque_region (_gtk_widget_get_surface (widget), opaque_region);
cairo_region_destroy (opaque_region);
}
}
}
- gtk_widget_set_window (widget, gdk_surface);
+ gtk_widget_set_surface (widget, gdk_surface);
g_signal_connect_swapped (gdk_surface, "notify::state", G_CALLBACK (surface_state_changed), widget);
- gtk_widget_register_window (widget, gdk_surface);
+ gtk_widget_register_surface (widget, gdk_surface);
gtk_widget_set_realized (widget, TRUE);
if (priv->renderer == NULL)
if (priv->transient_parent &&
_gtk_widget_get_realized (GTK_WIDGET (priv->transient_parent)))
gdk_surface_set_transient_for (gdk_surface,
- _gtk_widget_get_window (GTK_WIDGET (priv->transient_parent)));
+ _gtk_widget_get_surface (GTK_WIDGET (priv->transient_parent)));
gdk_surface_set_type_hint (gdk_surface, priv->type_hint);
gsk_renderer_unrealize (priv->renderer);
g_clear_object (&priv->renderer);
- g_signal_handlers_disconnect_by_func (_gtk_widget_get_window (widget),
+ g_signal_handlers_disconnect_by_func (_gtk_widget_get_surface (widget),
G_CALLBACK (surface_state_changed),
widget);
if (!_gtk_widget_is_toplevel (widget) && _gtk_widget_get_realized (widget))
{
- gdk_surface_move_resize (_gtk_widget_get_window (widget),
+ gdk_surface_move_resize (_gtk_widget_get_surface (widget),
allocation->x, allocation->y,
allocation->width, allocation->height);
}
if (!_gtk_widget_is_toplevel (widget))
return FALSE;
- if (_gtk_widget_get_window (widget) != event->any.surface)
+ if (_gtk_widget_get_surface (widget) != event->any.surface)
return TRUE;
/* If this is a gratuitous ConfigureNotify that's already
{
priv->configure_request_count -= 1;
- gdk_surface_thaw_toplevel_updates (_gtk_widget_get_window (widget));
+ gdk_surface_thaw_toplevel_updates (_gtk_widget_get_surface (widget));
}
/*
GdkSurfaceState new_surface_state;
GdkSurfaceState changed_mask;
- new_surface_state = gdk_surface_get_state (_gtk_widget_get_window (widget));
+ new_surface_state = gdk_surface_get_state (_gtk_widget_get_surface (widget));
changed_mask = new_surface_state ^ priv->state;
priv->state = new_surface_state;
* the window being unmapped. more details can be found in:
* http://bugzilla.gnome.org/show_bug.cgi?id=316180
*/
- gdk_surface_hide (_gtk_widget_get_window (widget));
+ gdk_surface_hide (_gtk_widget_get_surface (widget));
}
}
else if (event_type == GDK_CONFIGURE)
/* Skip non-master keyboards that haven't
* selected for events from this window
*/
- window = _gtk_widget_get_window (widget);
+ window = _gtk_widget_get_surface (widget);
if (gdk_device_get_device_type (dev) != GDK_DEVICE_TYPE_MASTER &&
window && !gdk_surface_get_device_events (window, dev))
continue;
GdkDevice *dev = gdk_seat_get_pointer (s->data);
GdkModifierType mask;
- gdk_device_get_state (dev, _gtk_widget_get_window (GTK_WIDGET (window)),
+ gdk_device_get_state (dev, _gtk_widget_get_surface (GTK_WIDGET (window)),
NULL, &mask);
if (window->priv->mnemonic_modifier == (mask & gtk_accelerator_get_default_mod_mask ()))
{
GdkSurfaceState state;
GdkSurface *gdk_surface;
- gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
state = 0;
gtk_window_do_popup (GtkWindow *window,
GdkEventButton *event)
{
- if (!gdk_surface_show_window_menu (_gtk_widget_get_window (GTK_WIDGET (window)),
+ if (!gdk_surface_show_window_menu (_gtk_widget_get_surface (GTK_WIDGET (window)),
(GdkEvent *) event))
gtk_window_do_popup_fallback (window, event);
}
g_assert (_gtk_widget_get_mapped (parent_widget)); /* established earlier */
- gdk_surface = _gtk_widget_get_window (parent_widget);
+ gdk_surface = _gtk_widget_get_surface (parent_widget);
monitor = gdk_display_get_monitor_at_surface (priv->display, gdk_surface);
gdk_surface_get_origin (gdk_surface, &ox, &oy);
widget = GTK_WIDGET (window);
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
info = gtk_window_get_geometry_info (window, TRUE);
configure_request_size_changed = FALSE;
if (gtk_widget_get_visible (widget))
{
- gdk_surface = _gtk_widget_get_window (widget);
+ gdk_surface = _gtk_widget_get_surface (widget);
g_assert (gdk_surface != NULL);
window->priv->iconify_initially = TRUE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_iconify (toplevel);
window->priv->iconify_initially = FALSE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_deiconify (toplevel);
window->priv->stick_initially = TRUE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_stick (toplevel);
window->priv->stick_initially = FALSE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_unstick (toplevel);
window->priv->maximize_initially = TRUE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_maximize (toplevel);
window->priv->maximize_initially = FALSE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_unmaximize (toplevel);
window->priv->fullscreen_initially = TRUE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_fullscreen (toplevel);
priv->fullscreen_initially = TRUE;
- toplevel = _gtk_widget_get_window (widget);
+ toplevel = _gtk_widget_get_surface (widget);
if (toplevel != NULL)
gdk_surface_fullscreen_on_monitor (toplevel, monitor);
unset_fullscreen_monitor (window);
window->priv->fullscreen_initially = FALSE;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_unfullscreen (toplevel);
window->priv->above_initially = setting;
window->priv->below_initially &= !setting;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_set_keep_above (toplevel, setting);
window->priv->below_initially = setting;
window->priv->above_initially &= !setting;
- toplevel = _gtk_widget_get_window (GTK_WIDGET (window));
+ toplevel = _gtk_widget_get_surface (GTK_WIDGET (window));
if (toplevel != NULL)
gdk_surface_set_keep_below (toplevel, setting);
widget = GTK_WIDGET (window);
g_return_if_fail (gtk_widget_get_visible (widget));
- toplevel = _gtk_widget_get_window (widget);
+ toplevel = _gtk_widget_get_surface (widget);
gdk_surface_begin_resize_drag (toplevel,
edge, button,
widget = GTK_WIDGET (window);
g_return_if_fail (gtk_widget_get_visible (widget));
- toplevel = _gtk_widget_get_window (widget);
+ toplevel = _gtk_widget_get_surface (widget);
gdk_surface_begin_move_drag (toplevel,
button,
"gtk-application-prefer-dark-theme", &dark_theme_requested,
NULL);
- gdk_surface = _gtk_widget_get_window (GTK_WIDGET (window));
+ gdk_surface = _gtk_widget_get_surface (GTK_WIDGET (window));
if (GDK_IS_X11_SURFACE (gdk_surface))
gdk_x11_surface_set_theme_variant (gdk_surface,
GdkSurface *window;
gboolean window_focused = TRUE;
- window = _gtk_widget_get_window (widget);
+ window = _gtk_widget_get_surface (widget);
window_focused = gdk_surface_get_state (window) & GDK_SURFACE_STATE_FOCUSED;
#ifdef GDK_WINDOWING_X11
if (GDK_IS_X11_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
- GdkSurface *gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ GdkSurface *gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
char *handle_str;
guint32 xid = (guint32) gdk_x11_surface_get_xid (gdk_surface);
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
- GdkSurface *gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ GdkSurface *gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
WaylandSurfaceHandleExportedData *data;
data = g_new0 (WaylandSurfaceHandleExportedData, 1);
#ifdef GDK_WINDOWING_WAYLAND
if (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))
{
- GdkSurface *gdk_surface = gtk_widget_get_window (GTK_WIDGET (window));
+ GdkSurface *gdk_surface = gtk_widget_get_surface (GTK_WIDGET (window));
gdk_wayland_surface_unexport_handle (gdk_surface);
}
break;
}
- gdk_surface_set_device_cursor (gtk_widget_get_window (GTK_WIDGET (toplevel)),
+ gdk_surface_set_device_cursor (gtk_widget_get_surface (GTK_WIDGET (toplevel)),
device, cursor);
g_list_free (widgets);
}
static void
gtk_stack_combo_init (GtkStackCombo *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
self->stack = NULL;
self->combo = GTK_COMBO_BOX (gtk_combo_box_text_new ());
{
double x, y;
- gdk_surface_get_device_position_double (gtk_widget_get_window (widget),
+ gdk_surface_get_device_position_double (gtk_widget_get_surface (widget),
device, &x, &y, NULL);
widget = inspector_pick (widget, x, y);
{
GtkWidget *widget;
- gdk_surface_raise (gtk_widget_get_window (GTK_WIDGET (iw)));
+ gdk_surface_raise (gtk_widget_get_surface (GTK_WIDGET (iw)));
clear_flash (iw);
cairo_region_destroy (region);
}
else
- gdk_surface_lower (gtk_widget_get_window (window));
+ gdk_surface_lower (gtk_widget_get_surface (window));
}
static void
gtk_widget_input_shape_combine_region (window, NULL);
}
else
- gdk_surface_raise (gtk_widget_get_window (window));
+ gdk_surface_raise (gtk_widget_get_surface (window));
}
static gboolean
display = gdk_display_get_default ();
cursor = gdk_cursor_new_from_name ("crosshair", NULL);
status = gdk_seat_grab (gdk_display_get_default_seat (display),
- gtk_widget_get_window (iw->invisible),
+ gtk_widget_get_surface (iw->invisible),
GDK_SEAT_CAPABILITY_ALL_POINTING, TRUE,
cursor, NULL, prepare_inspect_func, NULL);
g_object_unref (cursor);
static void
gtk_render_node_view_init (GtkRenderNodeView *view)
{
- gtk_widget_set_has_window (GTK_WIDGET (view), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (view), FALSE);
}
GtkWidget *
GdkEvent *event)
{
if (gdk_event_get_event_type (event) == GDK_MOTION_NOTIFY &&
- gdk_event_get_surface (event) == gtk_widget_get_window (window))
+ gdk_event_get_surface (event) == gtk_widget_get_surface (window))
{
gdouble x, y;
float processing_ms = gtk_adjustment_get_value (adjustment);
static void
gtk_node_view_init (GtkNodeView *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
}
static void
GdkFullscreenMode mode = (GdkFullscreenMode) GPOINTER_TO_INT (user_data);
GdkSurface *window;
- window = gtk_widget_get_parent_window (widget);
+ window = gtk_widget_get_parent_surface (widget);
gdk_surface_set_fullscreen_mode (window, mode);
gdk_surface_fullscreen (window);
}
{
GdkSurface *window;
- window = gtk_widget_get_parent_window (widget);
+ window = gtk_widget_get_parent_surface (widget);
gdk_surface_unfullscreen (window);
}
lx = g_object_get_data (G_OBJECT (window), "x");
ly = g_object_get_data (G_OBJECT (window), "y");
- gdk_surface_get_root_origin (gtk_widget_get_window (window),
+ gdk_surface_get_root_origin (gtk_widget_get_surface (window),
&upositionx, &upositiony);
sprintf (buffer, "%d", upositionx);
gtk_label_set_text (lx, buffer);
button = gtk_button_new ();
gtk_box_pack_start (GTK_BOX (box2), button);
- gdk_surface = gtk_widget_get_window (window);
+ gdk_surface = gtk_widget_get_surface (window);
pixbufwid = new_pixbuf ("test.xpm", gdk_surface);
gtk_widget_realize (window);
- gdk_surface = gtk_widget_get_window (window);
+ gdk_surface = gtk_widget_get_surface (window);
pixbuf = gdk_pixbuf_new_from_xpm_data ((const char **) openfile);
surface = gdk_cairo_surface_create_from_pixbuf (pixbuf, 1, NULL);
gtk_box_pack_start (GTK_BOX (hbox), label);
g_object_set_data (G_OBJECT (label), "title", (gpointer)gtk_window_get_title (GTK_WINDOW (window)));
- g_signal_connect (gtk_widget_get_window (window), "notify::state",
+ g_signal_connect (gtk_widget_get_surface (window), "notify::state",
G_CALLBACK (surface_state_callback),
label);
* but within the allocation are not counted. This is consistent
* with the way we highlight drag targets.
*/
- if (gtk_widget_get_has_window (widget))
+ if (gtk_widget_get_has_surface (widget))
{
new_allocation.x = 0;
new_allocation.y = 0;
if (gtk_widget_get_parent (widget) && !data->first)
{
- GdkSurface *window = gtk_widget_get_window (widget);
- while (window != gtk_widget_get_window (gtk_widget_get_parent (widget)))
+ GdkSurface *window = gtk_widget_get_surface (widget);
+ while (window != gtk_widget_get_surface (gtk_widget_get_parent (widget)))
{
gint tx, ty, twidth, theight;
if (widget)
{
- gdk_surface_get_device_position (gtk_widget_get_window (widget),
+ gdk_surface_get_device_position (gtk_widget_get_surface (widget),
device,
&x, &y, NULL);
data->cursor = gdk_cursor_new_from_name ("crosshair", NULL);
gdk_seat_grab (gdk_device_get_seat (device),
- gtk_widget_get_window (widget),
+ gtk_widget_get_surface (widget),
GDK_SEAT_CAPABILITY_ALL_POINTING,
TRUE, data->cursor, NULL, NULL, NULL);
if (!gtk_widget_is_drawable (widget))
return;
- window = gtk_widget_get_window (widget);
+ window = gtk_widget_get_surface (widget);
gdk_surface_scroll (window, 0, dy);
}
surface = NULL;
}
- if (gtk_widget_get_window (widget))
+ if (gtk_widget_get_surface (widget))
{
cairo_t *cr;
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (widget),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
CAIRO_CONTENT_COLOR,
gtk_widget_get_width (widget),
gtk_widget_get_height (widget));
static void
gtk_focus_widget_init (GtkFocusWidget *self)
{
- gtk_widget_set_has_window (GTK_WIDGET (self), FALSE);
+ gtk_widget_set_has_surface (GTK_WIDGET (self), FALSE);
self->child1 = gtk_button_new_with_label ("1");
gtk_widget_set_parent (self->child1, GTK_WIDGET (self));
{
GdkDisplay *display = gtk_widget_get_display (widget);
GdkMonitor *monitor = gdk_display_get_monitor_at_surface (display,
- gtk_widget_get_window (widget));
+ gtk_widget_get_surface (widget));
if (monitor == NULL)
gtk_label_set_markup (GTK_LABEL (user_data),
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_BUTTON_PRESS);
- ev->any.surface = g_object_ref (gtk_widget_get_window (widget));
+ ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
else
{
ev = gdk_event_new (GDK_TOUCH_BEGIN);
- ev->any.surface = g_object_ref (gtk_widget_get_window (widget));
+ ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
if (point == &mouse_state)
{
ev = gdk_event_new (GDK_MOTION_NOTIFY);
- ev->any.surface = g_object_ref (gtk_widget_get_window (widget));
+ ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
ev->button.time = GDK_CURRENT_TIME;
ev->motion.x = x;
ev->motion.y = y;
return;
ev = gdk_event_new (GDK_TOUCH_UPDATE);
- ev->any.surface = g_object_ref (gtk_widget_get_window (widget));
+ ev->any.surface = g_object_ref (gtk_widget_get_surface (widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = x;
ev->touch.y = y;
return;
ev = gdk_event_new (GDK_BUTTON_RELEASE);
- ev->any.surface = g_object_ref (gtk_widget_get_window (point->widget));
+ ev->any.surface = g_object_ref (gtk_widget_get_surface (point->widget));
ev->button.time = GDK_CURRENT_TIME;
ev->button.x = point->x;
ev->button.y = point->y;
else
{
ev = gdk_event_new (GDK_TOUCH_END);
- ev->any.surface = g_object_ref (gtk_widget_get_window (point->widget));
+ ev->any.surface = g_object_ref (gtk_widget_get_surface (point->widget));
ev->touch.time = GDK_CURRENT_TIME;
ev->touch.x = point->x;
ev->touch.y = point->y;
gdk_event_handler_set (check_for_draw, NULL, NULL);
g_main_loop_run (loop);
- surface = gdk_surface_create_similar_surface (gtk_widget_get_window (widget),
+ surface = gdk_surface_create_similar_surface (gtk_widget_get_surface (widget),
CAIRO_CONTENT_COLOR,
gtk_widget_get_allocated_width (widget),
gtk_widget_get_allocated_height (widget));
switch (mode)
{
case SNAPSHOT_WINDOW:
- snapshot_window_native (gtk_widget_get_window (widget), cr);
+ snapshot_window_native (gtk_widget_get_surface (widget), cr);
break;
case SNAPSHOT_DRAW:
gtk_widget_draw (widget, cr);
projects / gtk4.git / commitdiff