/* GDK - The GIMP Drawing Kit
* Copyright (C) 1995-2007 Peter Mattis, Spencer Kimball,
* Josh MacDonald, Ryan Lortie
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library. If not, see .
*/
/*
* Modified by the GTK+ Team and others 1997-2000. See the AUTHORS
* file for a list of people on the GTK+ Team. See the ChangeLog
* files for a list of changes. These files are distributed with
* GTK+ at ftp://ftp.gtk.org/pub/gtk/.
*/
#include "config.h"
#include
#include "gdksurface.h"
#include "gdkrectangle.h"
#include "gdkinternals.h"
#include "gdkintl.h"
#include "gdkdisplayprivate.h"
#include "gdkdeviceprivate.h"
#include "gdkframeclockidleprivate.h"
#include "gdkmarshalers.h"
#include "gdksurfaceimpl.h"
#include "gdkglcontextprivate.h"
#include "gdk-private.h"
#include
#include
/* for the use of round() */
#include "fallback-c89.c"
#ifdef GDK_WINDOWING_WAYLAND
#include "wayland/gdkwayland.h"
#endif
#undef DEBUG_SURFACE_PRINTING
/**
* SECTION:gdksurface
* @Short_description: Onscreen display areas in the target window system
* @Title: Surfaces
*
* A #GdkSurface is a (usually) rectangular region on the screen.
* It’s a low-level object, used to implement high-level objects such as
* #GtkWidget and #GtkWindow on the GTK+ level. A #GtkWindow is a toplevel
* surface, the thing a user might think of as a “window” with a titlebar
* and so on; a #GtkWindow may contain many sub-GdkSurfaces.
*/
/**
* GdkSurface:
*
* The GdkSurface struct contains only private fields and
* should not be accessed directly.
*/
/* Historically a GdkSurface always matches a platform native window,
* be it a toplevel window or a child window. In this setup the
* GdkSurface (and other GdkDrawables) were platform independent classes,
* and the actual platform specific implementation was in a delegate
* object available as “impl” in the surface object.
*
* With the addition of client side windows this changes a bit. The
* application-visible GdkSurface object behaves as it did before, but
* such surfaces now don't a corresponding native window. Instead subwindows
* surfaces are “client side”, i.e. emulated by the gdk code such
* that clipping, drawing, moving, events etc work as expected.
*
* GdkSurfaces have a pointer to the “impl surface” they are in, i.e.
* the topmost GdkSurface which have the same “impl” value. This is stored
* in impl_surface, which is different from the surface itself only for client
* side surfaces.
* All GdkSurfaces (native or not) track the position of the surface in the parent
* (x, y), the size of the surface (width, height), the position of the surface
* with respect to the impl surface (abs_x, abs_y). We also track the clip
* region of the surface wrt parent surfaces, in surface-relative coordinates (clip_region).
*/
enum {
MOVED_TO_RECT,
LAST_SIGNAL
};
enum {
PROP_0,
PROP_CURSOR,
PROP_DISPLAY,
PROP_STATE,
LAST_PROP
};
/* Global info */
static void gdk_surface_finalize (GObject *object);
static void gdk_surface_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec);
static void gdk_surface_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec);
static void recompute_visible_regions (GdkSurface *private,
gboolean recalculate_children);
static void gdk_surface_invalidate_in_parent (GdkSurface *private);
static void update_cursor (GdkDisplay *display,
GdkDevice *device);
static void gdk_surface_set_frame_clock (GdkSurface *surface,
GdkFrameClock *clock);
static guint signals[LAST_SIGNAL] = { 0 };
static GParamSpec *properties[LAST_PROP] = { NULL, };
G_DEFINE_ABSTRACT_TYPE (GdkSurface, gdk_surface, G_TYPE_OBJECT)
#ifdef DEBUG_SURFACE_PRINTING
char *
print_region (cairo_region_t *region)
{
GString *s = g_string_new ("{");
if (cairo_region_is_empty (region))
{
g_string_append (s, "empty");
}
else
{
int num = cairo_region_num_rectangles (region);
cairo_rectangle_int_t r;
if (num == 1)
{
cairo_region_get_rectangle (region, 0, &r);
g_string_append_printf (s, "%dx%d @%d,%d", r.width, r.height, r.x, r.y);
}
else
{
int i;
cairo_region_get_extents (region, &r);
g_string_append_printf (s, "extent: %dx%d @%d,%d, details: ", r.width, r.height, r.x, r.y);
for (i = 0; i < num; i++)
{
cairo_region_get_rectangle (region, i, &r);
g_string_append_printf (s, "[%dx%d @%d,%d]", r.width, r.height, r.x, r.y);
if (i != num -1)
g_string_append (s, ", ");
}
}
}
g_string_append (s, "}");
return g_string_free (s, FALSE);
}
#endif
static GList *
list_insert_link_before (GList *list,
GList *sibling,
GList *link)
{
if (list == NULL || sibling == list)
{
link->prev = NULL;
link->next = list;
if (list)
list->prev = link;
return link;
}
else if (sibling == NULL)
{
GList *last = g_list_last (list);
last->next = link;
link->prev = last;
link->next = NULL;
return list;
}
else
{
link->next = sibling;
link->prev = sibling->prev;
sibling->prev = link;
if (link->prev)
link->prev->next = link;
return list;
}
}
static void
gdk_surface_init (GdkSurface *surface)
{
/* 0-initialization is good for all other fields. */
surface->surface_type = GDK_SURFACE_CHILD;
surface->state = GDK_SURFACE_STATE_WITHDRAWN;
surface->fullscreen_mode = GDK_FULLSCREEN_ON_CURRENT_MONITOR;
surface->width = 1;
surface->height = 1;
surface->children_list_node.data = surface;
surface->device_cursor = g_hash_table_new_full (NULL, NULL,
NULL, g_object_unref);
}
static void
gdk_surface_class_init (GdkSurfaceClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS (klass);
object_class->finalize = gdk_surface_finalize;
object_class->set_property = gdk_surface_set_property;
object_class->get_property = gdk_surface_get_property;
/* Properties */
/**
* GdkSurface:cursor:
*
* The mouse pointer for a #GdkSurface. See gdk_surface_set_cursor() and
* gdk_surface_get_cursor() for details.
*/
properties[PROP_CURSOR] =
g_param_spec_object ("cursor",
P_("Cursor"),
P_("Cursor"),
GDK_TYPE_CURSOR,
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
/**
* GdkSurface:display:
*
* The #GdkDisplay connection of the surface. See gdk_surface_get_display()
* for details.
*/
properties[PROP_DISPLAY] =
g_param_spec_object ("display",
P_("Display"),
P_("Display"),
GDK_TYPE_DISPLAY,
G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
properties[PROP_STATE] =
g_param_spec_flags ("state",
P_("State"),
P_("State"),
GDK_TYPE_SURFACE_STATE, GDK_SURFACE_STATE_WITHDRAWN,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties (object_class, LAST_PROP, properties);
/**
* GdkSurface::moved-to-rect:
* @surface: the #GdkSurface that moved
* @flipped_rect: (nullable): the position of @surface after any possible
* flipping or %NULL if the backend can't obtain it
* @final_rect: (nullable): the final position of @surface or %NULL if the
* backend can't obtain it
* @flipped_x: %TRUE if the anchors were flipped horizontally
* @flipped_y: %TRUE if the anchors were flipped vertically
*
* Emitted when the position of @surface is finalized after being moved to a
* destination rectangle.
*
* @surface might be flipped over the destination rectangle in order to keep
* it on-screen, in which case @flipped_x and @flipped_y will be set to %TRUE
* accordingly.
*
* @flipped_rect is the ideal position of @surface after any possible
* flipping, but before any possible sliding. @final_rect is @flipped_rect,
* but possibly translated in the case that flipping is still ineffective in
* keeping @surface on-screen.
* Stability: Private
*/
signals[MOVED_TO_RECT] =
g_signal_new (g_intern_static_string ("moved-to-rect"),
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
_gdk_marshal_VOID__POINTER_POINTER_BOOLEAN_BOOLEAN,
G_TYPE_NONE,
4,
G_TYPE_POINTER,
G_TYPE_POINTER,
G_TYPE_BOOLEAN,
G_TYPE_BOOLEAN);
}
static void
seat_removed_cb (GdkDisplay *display,
GdkSeat *seat,
GdkSurface *surface)
{
GdkDevice *device = gdk_seat_get_pointer (seat);
surface->devices_inside = g_list_remove (surface->devices_inside, device);
g_hash_table_remove (surface->device_cursor, device);
if (surface->device_events)
g_hash_table_remove (surface->device_events, device);
}
static void
gdk_surface_finalize (GObject *object)
{
GdkSurface *surface = GDK_SURFACE (object);
g_signal_handlers_disconnect_by_func (gdk_surface_get_display (surface),
seat_removed_cb, surface);
if (!GDK_SURFACE_DESTROYED (surface))
{
if (GDK_SURFACE_TYPE (surface) != GDK_SURFACE_FOREIGN)
{
g_warning ("losing last reference to undestroyed surface");
_gdk_surface_destroy (surface, FALSE);
}
else
/* We use TRUE here, to keep us from actually calling
* XDestroyWindow() on the window
*/
_gdk_surface_destroy (surface, TRUE);
}
if (surface->impl)
{
g_object_unref (surface->impl);
surface->impl = NULL;
}
if (surface->impl_surface != surface)
{
g_object_unref (surface->impl_surface);
surface->impl_surface = NULL;
}
if (surface->input_shape)
cairo_region_destroy (surface->input_shape);
if (surface->cursor)
g_object_unref (surface->cursor);
if (surface->device_cursor)
g_hash_table_destroy (surface->device_cursor);
if (surface->device_events)
g_hash_table_destroy (surface->device_events);
if (surface->devices_inside)
g_list_free (surface->devices_inside);
g_clear_object (&surface->display);
if (surface->opaque_region)
cairo_region_destroy (surface->opaque_region);
G_OBJECT_CLASS (gdk_surface_parent_class)->finalize (object);
}
static void
gdk_surface_set_property (GObject *object,
guint prop_id,
const GValue *value,
GParamSpec *pspec)
{
GdkSurface *surface = GDK_SURFACE (object);
switch (prop_id)
{
case PROP_CURSOR:
gdk_surface_set_cursor (surface, g_value_get_object (value));
break;
case PROP_DISPLAY:
surface->display = g_value_dup_object (value);
g_assert (surface->display != NULL);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
gdk_surface_get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
GdkSurface *surface = GDK_SURFACE (object);
switch (prop_id)
{
case PROP_CURSOR:
g_value_set_object (value, gdk_surface_get_cursor (surface));
break;
case PROP_DISPLAY:
g_value_set_object (value, surface->display);
break;
case PROP_STATE:
g_value_set_flags (value, surface->state);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static gboolean
gdk_surface_is_subsurface (GdkSurface *surface)
{
return surface->surface_type == GDK_SURFACE_SUBSURFACE;
}
static GdkSurface *
gdk_surface_get_impl_surface (GdkSurface *surface)
{
return surface->impl_surface;
}
GdkSurface *
_gdk_surface_get_impl_surface (GdkSurface *surface)
{
return gdk_surface_get_impl_surface (surface);
}
static gboolean
gdk_surface_has_impl (GdkSurface *surface)
{
return surface->impl_surface == surface;
}
static gboolean
gdk_surface_is_toplevel (GdkSurface *surface)
{
return surface->parent == NULL;
}
gboolean
_gdk_surface_has_impl (GdkSurface *surface)
{
return gdk_surface_has_impl (surface);
}
static void
remove_child_area (GdkSurface *surface,
gboolean for_input,
cairo_region_t *region)
{
GdkSurface *child;
cairo_region_t *child_region;
GdkRectangle r;
GList *l;
for (l = surface->children; l; l = l->next)
{
child = l->data;
/* If region is empty already, no need to do
anything potentially costly */
if (cairo_region_is_empty (region))
break;
if (!GDK_SURFACE_IS_MAPPED (child) || child->input_only)
continue;
r.x = child->x;
r.y = child->y;
r.width = child->width;
r.height = child->height;
/* Bail early if child totally outside region */
if (cairo_region_contains_rectangle (region, &r) == CAIRO_REGION_OVERLAP_OUT)
continue;
child_region = cairo_region_create_rectangle (&r);
if (for_input)
{
if (child->input_shape)
cairo_region_intersect (child_region, child->input_shape);
}
cairo_region_subtract (region, child_region);
cairo_region_destroy (child_region);
}
}
static void
recompute_visible_regions_internal (GdkSurface *private,
gboolean recalculate_clip,
gboolean recalculate_children)
{
GList *l;
GdkSurface *child;
gboolean abs_pos_changed;
int old_abs_x, old_abs_y;
old_abs_x = private->abs_x;
old_abs_y = private->abs_y;
/* Update absolute position */
if ((gdk_surface_has_impl (private) &&
private->surface_type != GDK_SURFACE_SUBSURFACE) ||
(gdk_surface_is_toplevel (private) &&
private->surface_type == GDK_SURFACE_SUBSURFACE))
{
/* Native surfaces and toplevel subsurfaces start here */
private->abs_x = 0;
private->abs_y = 0;
}
else
{
private->abs_x = private->parent->abs_x + private->x;
private->abs_y = private->parent->abs_y + private->y;
}
abs_pos_changed =
private->abs_x != old_abs_x ||
private->abs_y != old_abs_y;
/* Update all children, recursively */
if ((abs_pos_changed || recalculate_children))
{
for (l = private->children; l; l = l->next)
{
child = l->data;
/* Only recalculate clip if the the clip region changed, otherwise
* there is no way the child clip region could change (its has not e.g. moved)
* Except if recalculate_children is set to force child updates
*/
recompute_visible_regions_internal (child,
recalculate_clip && recalculate_children,
FALSE);
}
}
}
/* Call this when private has changed in one or more of these ways:
* size changed
* surface moved
* new surface added
* stacking order of surface changed
* child deleted
*
* It will recalculate abs_x/y and the clip regions
*
* Unless the surface didn’t change stacking order or size/pos, pass in TRUE
* for recalculate_siblings. (Mostly used internally for the recursion)
*
* If a child surface was removed (and you can’t use that child for
* recompute_visible_regions), pass in TRUE for recalculate_children on the parent
*/
static void
recompute_visible_regions (GdkSurface *private,
gboolean recalculate_children)
{
recompute_visible_regions_internal (private,
TRUE,
recalculate_children);
}
void
_gdk_surface_update_size (GdkSurface *surface)
{
GSList *l;
for (l = surface->draw_contexts; l; l = l->next)
gdk_draw_context_surface_resized (l->data);
recompute_visible_regions (surface, FALSE);
}
static GdkEventMask
get_native_device_event_mask (GdkSurface *private,
GdkDevice *device)
{
GdkEventMask event_mask;
if (device)
event_mask = GPOINTER_TO_INT (g_hash_table_lookup (private->device_events, device));
else
event_mask = private->event_mask;
if (private->surface_type == GDK_SURFACE_FOREIGN)
return event_mask;
else
{
GdkEventMask mask;
mask = private->event_mask;
/* We need thse for all native surfaces so we can
emulate events on children: */
mask |=
GDK_EXPOSURE_MASK |
GDK_ENTER_NOTIFY_MASK | GDK_LEAVE_NOTIFY_MASK |
GDK_TOUCH_MASK |
GDK_POINTER_MOTION_MASK |
GDK_BUTTON_PRESS_MASK | GDK_BUTTON_RELEASE_MASK |
GDK_SCROLL_MASK;
return mask;
}
}
static GdkEventMask
get_native_event_mask (GdkSurface *private)
{
return get_native_device_event_mask (private, NULL);
}
GdkSurface*
gdk_surface_new (GdkDisplay *display,
GdkSurface *parent,
GdkSurfaceAttr *attributes)
{
GdkSurface *surface;
gboolean native;
GdkEventMask event_mask;
g_return_val_if_fail (attributes != NULL, NULL);
if (parent != NULL && GDK_SURFACE_DESTROYED (parent))
{
g_warning ("gdk_surface_new(): parent is destroyed");
return NULL;
}
surface = _gdk_display_create_surface (display);
surface->parent = parent;
surface->accept_focus = TRUE;
surface->focus_on_map = TRUE;
surface->x = attributes->x;
surface->y = attributes->y;
surface->width = (attributes->width > 1) ? (attributes->width) : (1);
surface->height = (attributes->height > 1) ? (attributes->height) : (1);
surface->alpha = 255;
if (attributes->wclass == GDK_INPUT_ONLY)
{
/* Backwards compatiblity - we've always ignored
* attributes->surface_type for input-only surfaces
* before
*/
if (parent == NULL)
surface->surface_type = GDK_SURFACE_TEMP;
else
surface->surface_type = GDK_SURFACE_CHILD;
}
else
surface->surface_type = attributes->surface_type;
/* Sanity checks */
switch (surface->surface_type)
{
case GDK_SURFACE_TOPLEVEL:
case GDK_SURFACE_TEMP:
if (parent != NULL)
g_warning (G_STRLOC "Toplevel surfaces must be created without a parent");
break;
case GDK_SURFACE_SUBSURFACE:
#ifdef GDK_WINDOWING_WAYLAND
if (!GDK_IS_WAYLAND_DISPLAY (display))
{
g_warning (G_STRLOC "Subsurface surfaces can only be used on Wayland");
return NULL;
}
#endif
break;
case GDK_SURFACE_CHILD:
if (GDK_SURFACE_TYPE (parent) == GDK_SURFACE_FOREIGN)
{
g_warning (G_STRLOC "Child surfaces must not be created as children of\n"
"a surface of type GDK_SURFACE_FOREIGN");
return NULL;
}
break;
default:
g_warning (G_STRLOC "cannot make surfaces of type %d", surface->surface_type);
return NULL;
}
surface->event_mask = GDK_ALL_EVENTS_MASK;
if (attributes->wclass == GDK_INPUT_OUTPUT)
{
surface->input_only = FALSE;
}
else
{
surface->input_only = TRUE;
}
native = FALSE;
if (surface->parent != NULL)
surface->parent->children = g_list_concat (&surface->children_list_node, surface->parent->children);
else
{
GdkFrameClock *frame_clock = g_object_new (GDK_TYPE_FRAME_CLOCK_IDLE, NULL);
gdk_surface_set_frame_clock (surface, frame_clock);
g_object_unref (frame_clock);
native = TRUE; /* Always use native surfaces for toplevels */
}
#ifdef GDK_WINDOWING_WAYLAND
if (surface->surface_type == GDK_SURFACE_SUBSURFACE)
native = TRUE; /* Always use native windows for subsurfaces as well */
#endif
if (native)
{
event_mask = get_native_event_mask (surface);
/* Create the impl */
_gdk_display_create_surface_impl (display, surface, parent, event_mask, attributes);
surface->impl_surface = surface;
}
else
{
surface->impl_surface = g_object_ref (surface->parent->impl_surface);
surface->impl = g_object_ref (surface->impl_surface->impl);
}
recompute_visible_regions (surface, FALSE);
g_signal_connect (display, "seat-removed", G_CALLBACK (seat_removed_cb), surface);
return surface;
}
/**
* gdk_surface_new_toplevel: (constructor)
* @display: the display to create the surface on
* @width: width of new surface
* @height: height of new surface
*
* Creates a new toplevel surface. The surface will be managed by the surface
* manager.
*
* Returns: (transfer full): the new #GdkSurface
**/
GdkSurface *
gdk_surface_new_toplevel (GdkDisplay *display,
gint width,
gint height)
{
GdkSurfaceAttr attr;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
attr.wclass = GDK_INPUT_OUTPUT;
attr.x = 0;
attr.y = 0;
attr.width = width;
attr.height = height;
attr.surface_type = GDK_SURFACE_TOPLEVEL;
return gdk_surface_new (display, NULL, &attr);
}
/**
* gdk_surface_new_popup: (constructor)
* @display: the display to create the surface on
* @position: position of the surface on screen
*
* Creates a new toplevel popup surface. The surface will bypass surface
* management.
*
* Returns: (transfer full): the new #GdkSurface
**/
GdkSurface *
gdk_surface_new_popup (GdkDisplay *display,
const GdkRectangle *position)
{
GdkSurfaceAttr attr;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
g_return_val_if_fail (position != NULL, NULL);
attr.wclass = GDK_INPUT_OUTPUT;
attr.x = position->x;
attr.y = position->y;
attr.width = position->width;
attr.height = position->height;
attr.surface_type = GDK_SURFACE_TEMP;
return gdk_surface_new (display, NULL, &attr);
}
/**
* gdk_surface_new_temp: (constructor)
* @display: the display to create the surface on
*
* Creates a new toplevel temporary surface. The surface will be
* situated off-screen and not handle output.
*
* You most likely do not want to use this function.
*
* Returns: (transfer full): the new #GdkSurface
**/
GdkSurface *
gdk_surface_new_temp (GdkDisplay *display)
{
GdkSurfaceAttr attr;
g_return_val_if_fail (GDK_IS_DISPLAY (display), NULL);
attr.wclass = GDK_INPUT_ONLY;
attr.x = -100;
attr.y = -100;
attr.width = 10;
attr.height = 10;
attr.surface_type = GDK_SURFACE_TEMP;
return gdk_surface_new (display, NULL, &attr);
}
/**
* gdk_surface_new_child: (constructor)
* @parent: the parent surface
* @position: placement of the surface inside @parent
*
* Creates a new client-side child surface.
*
* Returns: (transfer full): the new #GdkSurface
**/
GdkSurface *
gdk_surface_new_child (GdkSurface *parent,
const GdkRectangle *position)
{
GdkSurfaceAttr attr;
g_return_val_if_fail (GDK_IS_SURFACE (parent), NULL);
attr.wclass = GDK_INPUT_OUTPUT;
attr.x = position->x;
attr.y = position->y;
attr.width = position->width;
attr.height = position->height;
attr.surface_type = GDK_SURFACE_CHILD;
return gdk_surface_new (gdk_surface_get_display (parent), parent, &attr);
}
static void
update_pointer_info_foreach (GdkDisplay *display,
GdkDevice *device,
GdkPointerSurfaceInfo *pointer_info,
gpointer user_data)
{
GdkSurface *surface = user_data;
if (pointer_info->surface_under_pointer == surface)
{
g_object_unref (pointer_info->surface_under_pointer);
pointer_info->surface_under_pointer = NULL;
}
}
static void
surface_remove_from_pointer_info (GdkSurface *surface,
GdkDisplay *display)
{
_gdk_display_pointer_info_foreach (display,
update_pointer_info_foreach,
surface);
}
/**
* _gdk_surface_destroy_hierarchy:
* @surface: a #GdkSurface
* @recursing: If %TRUE, then this is being called because a parent
* was destroyed.
* @recursing_native: If %TRUE, then this is being called because a native parent
* was destroyed. This generally means that the call to the
* windowing system to destroy the surface can be omitted, since
* it will be destroyed as a result of the parent being destroyed.
* Unless @foreign_destroy.
* @foreign_destroy: If %TRUE, the surface or a parent was destroyed by some
* external agency. The surface has already been destroyed and no
* windowing system calls should be made. (This may never happen
* for some windowing systems.)
*
* Internal function to destroy a surface. Like gdk_surface_destroy(),
* but does not drop the reference count created by gdk_surface_new().
**/
static void
_gdk_surface_destroy_hierarchy (GdkSurface *surface,
gboolean recursing,
gboolean recursing_native,
gboolean foreign_destroy)
{
GdkSurfaceImplClass *impl_class;
GdkSurface *temp_surface;
GdkDisplay *display;
GList *tmp;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
return;
display = gdk_surface_get_display (surface);
switch (surface->surface_type)
{
default:
g_assert_not_reached ();
break;
case GDK_SURFACE_TOPLEVEL:
case GDK_SURFACE_CHILD:
case GDK_SURFACE_TEMP:
case GDK_SURFACE_FOREIGN:
case GDK_SURFACE_SUBSURFACE:
if (surface->surface_type == GDK_SURFACE_FOREIGN && !foreign_destroy)
{
}
else
{
if (surface->parent)
{
if (surface->parent->children)
surface->parent->children = g_list_remove_link (surface->parent->children, &surface->children_list_node);
if (!recursing &&
GDK_SURFACE_IS_MAPPED (surface))
{
recompute_visible_regions (surface, FALSE);
gdk_surface_invalidate_in_parent (surface);
}
}
if (surface->gl_paint_context)
{
/* Make sure to destroy if current */
g_object_run_dispose (G_OBJECT (surface->gl_paint_context));
g_object_unref (surface->gl_paint_context);
surface->gl_paint_context = NULL;
}
if (surface->frame_clock)
{
g_object_run_dispose (G_OBJECT (surface->frame_clock));
gdk_surface_set_frame_clock (surface, NULL);
}
if (surface->surface_type == GDK_SURFACE_FOREIGN)
g_assert (surface->children == NULL);
else
{
tmp = surface->children;
surface->children = NULL;
/* No need to free children list, its all made up of in-struct nodes */
while (tmp)
{
temp_surface = tmp->data;
tmp = tmp->next;
if (temp_surface)
_gdk_surface_destroy_hierarchy (temp_surface,
TRUE,
recursing_native || gdk_surface_has_impl (surface),
foreign_destroy);
}
}
_gdk_surface_clear_update_area (surface);
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (gdk_surface_has_impl (surface))
impl_class->destroy (surface, recursing_native, foreign_destroy);
else
{
/* hide to make sure we repaint and break grabs */
gdk_surface_hide (surface);
}
surface->state |= GDK_SURFACE_STATE_WITHDRAWN;
surface->parent = NULL;
surface->destroyed = TRUE;
surface_remove_from_pointer_info (surface, display);
g_object_notify_by_pspec (G_OBJECT (surface), properties[PROP_STATE]);
}
break;
}
}
/**
* _gdk_surface_destroy:
* @surface: a #GdkSurface
* @foreign_destroy: If %TRUE, the surface or a parent was destroyed by some
* external agency. The surface has already been destroyed and no
* windowing system calls should be made. (This may never happen
* for some windowing systems.)
*
* Internal function to destroy a surface. Like gdk_surface_destroy(),
* but does not drop the reference count created by gdk_surface_new().
**/
void
_gdk_surface_destroy (GdkSurface *surface,
gboolean foreign_destroy)
{
_gdk_surface_destroy_hierarchy (surface, FALSE, FALSE, foreign_destroy);
}
/**
* gdk_surface_destroy:
* @surface: a #GdkSurface
*
* Destroys the window system resources associated with @surface and decrements @surface's
* reference count. The window system resources for all children of @surface are also
* destroyed, but the children’s reference counts are not decremented.
*
* Note that a surface will not be destroyed automatically when its reference count
* reaches zero. You must call this function yourself before that happens.
*
**/
void
gdk_surface_destroy (GdkSurface *surface)
{
_gdk_surface_destroy_hierarchy (surface, FALSE, FALSE, FALSE);
g_object_unref (surface);
}
/**
* gdk_surface_set_user_data:
* @surface: a #GdkSurface
* @user_data: (allow-none) (type GObject.Object): user data
*
* For most purposes this function is deprecated in favor of
* g_object_set_data(). However, for historical reasons GTK+ stores
* the #GtkWidget that owns a #GdkSurface as user data on the
* #GdkSurface. So, custom widget implementations should use
* this function for that. If GTK+ receives an event for a #GdkSurface,
* and the user data for the surface is non-%NULL, GTK+ will assume the
* user data is a #GtkWidget, and forward the event to that widget.
*
**/
void
gdk_surface_set_user_data (GdkSurface *surface,
gpointer user_data)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
surface->user_data = user_data;
}
/**
* gdk_surface_get_user_data:
* @surface: a #GdkSurface
* @data: (out): return location for user data
*
* Retrieves the user data for @surface, which is normally the widget
* that @surface belongs to. See gdk_surface_set_user_data().
*
**/
void
gdk_surface_get_user_data (GdkSurface *surface,
gpointer *data)
{
*data = surface->user_data;
}
/**
* gdk_surface_get_surface_type:
* @surface: a #GdkSurface
*
* Gets the type of the surface. See #GdkSurfaceType.
*
* Returns: type of surface
**/
GdkSurfaceType
gdk_surface_get_surface_type (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), (GdkSurfaceType) -1);
return GDK_SURFACE_TYPE (surface);
}
/**
* gdk_surface_get_display:
* @surface: a #GdkSurface
*
* Gets the #GdkDisplay associated with a #GdkSurface.
*
* Returns: (transfer none): the #GdkDisplay associated with @surface
**/
GdkDisplay *
gdk_surface_get_display (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
return surface->display;
}
/**
* gdk_surface_is_destroyed:
* @surface: a #GdkSurface
*
* Check to see if a surface is destroyed..
*
* Returns: %TRUE if the surface is destroyed
**/
gboolean
gdk_surface_is_destroyed (GdkSurface *surface)
{
return GDK_SURFACE_DESTROYED (surface);
}
/**
* gdk_surface_has_native:
* @surface: a #GdkSurface
*
* Checks whether the surface has a native surface or not.
*
* Returns: %TRUE if the @surface has a native surface, %FALSE otherwise.
*/
gboolean
gdk_surface_has_native (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->parent == NULL || surface->parent->impl != surface->impl;
}
/**
* gdk_surface_get_position:
* @surface: a #GdkSurface
* @x: (out) (allow-none): X coordinate of surface
* @y: (out) (allow-none): Y coordinate of surface
*
* Obtains the position of the surface as reported in the
* most-recently-processed #GdkEventConfigure. Contrast with
* gdk_surface_get_geometry() which queries the X server for the
* current surface position, regardless of which events have been
* received or processed.
*
* The position coordinates are relative to the surface’s parent surface.
*
**/
void
gdk_surface_get_position (GdkSurface *surface,
gint *x,
gint *y)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (x)
*x = surface->x;
if (y)
*y = surface->y;
}
/**
* gdk_surface_get_parent:
* @surface: a #GdkSurface
*
* Obtains the parent of @surface, as known to GDK. Does not query the
* X server; thus this returns the parent as passed to gdk_surface_new(),
* not the actual parent. This should never matter unless you’re using
* Xlib calls mixed with GDK calls on the X11 platform. It may also
* matter for toplevel windows, because the window manager may choose
* to reparent them.
*
* Returns: (transfer none): parent of @surface
**/
GdkSurface*
gdk_surface_get_parent (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
if (gdk_surface_is_subsurface (surface))
return surface->transient_for;
else
return surface->parent;
}
/**
* gdk_surface_get_toplevel:
* @surface: a #GdkSurface
*
* Gets the toplevel surface that’s an ancestor of @surface.
*
* Any surface type but %GDK_SURFACE_CHILD is considered a
* toplevel surface, as is a %GDK_SURFACE_CHILD surface that
* has a root surface as parent.
*
* Returns: (transfer none): the toplevel surface containing @surface
**/
GdkSurface *
gdk_surface_get_toplevel (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
while (surface->surface_type == GDK_SURFACE_CHILD ||
surface->surface_type == GDK_SURFACE_SUBSURFACE)
{
if (gdk_surface_is_toplevel (surface))
break;
surface = surface->parent;
}
return surface;
}
/**
* gdk_surface_get_children:
* @surface: a #GdkSurface
*
* Gets the list of children of @surface known to GDK.
* This function only returns children created via GDK,
* so for example it’s useless when used with the root window;
* it only returns surfaces an application created itself.
*
* The returned list must be freed, but the elements in the
* list need not be.
*
* Returns: (transfer container) (element-type GdkSurface):
* list of child surfaces inside @surface
**/
GList*
gdk_surface_get_children (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
if (GDK_SURFACE_DESTROYED (surface))
return NULL;
return g_list_copy (surface->children);
}
/**
* gdk_surface_peek_children:
* @surface: a #GdkSurface
*
* Like gdk_surface_get_children(), but does not copy the list of
* children, so the list does not need to be freed.
*
* Returns: (transfer none) (element-type GdkSurface):
* a reference to the list of child surfaces in @surface
**/
GList *
gdk_surface_peek_children (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
if (GDK_SURFACE_DESTROYED (surface))
return NULL;
return surface->children;
}
/**
* gdk_surface_get_children_with_user_data:
* @surface: a #GdkSurface
* @user_data: user data to look for
*
* Gets the list of children of @surface known to GDK with a
* particular @user_data set on it.
*
* The returned list must be freed, but the elements in the
* list need not be.
*
* The list is returned in (relative) stacking order, i.e. the
* lowest surface is first.
*
* Returns: (transfer container) (element-type GdkSurface):
* list of child surfaces inside @surface
**/
GList *
gdk_surface_get_children_with_user_data (GdkSurface *surface,
gpointer user_data)
{
GdkSurface *child;
GList *res, *l;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
if (GDK_SURFACE_DESTROYED (surface))
return NULL;
res = NULL;
for (l = surface->children; l != NULL; l = l->next)
{
child = l->data;
if (child->user_data == user_data)
res = g_list_prepend (res, child);
}
return res;
}
/**
* gdk_surface_is_visible:
* @surface: a #GdkSurface
*
* Checks whether the surface has been mapped (with gdk_surface_show() or
* gdk_surface_show_unraised()).
*
* Returns: %TRUE if the surface is mapped
**/
gboolean
gdk_surface_is_visible (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return GDK_SURFACE_IS_MAPPED (surface);
}
/**
* gdk_surface_is_viewable:
* @surface: a #GdkSurface
*
* Check if the surface and all ancestors of the surface are
* mapped. (This is not necessarily "viewable" in the X sense, since
* we only check as far as we have GDK surface parents, not to the root
* surface.)
*
* Returns: %TRUE if the surface is viewable
**/
gboolean
gdk_surface_is_viewable (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
if (surface->destroyed)
return FALSE;
return surface->viewable;
}
/**
* gdk_surface_get_state:
* @surface: a #GdkSurface
*
* Gets the bitwise OR of the currently active surface state flags,
* from the #GdkSurfaceState enumeration.
*
* Returns: surface state bitfield
**/
GdkSurfaceState
gdk_surface_get_state (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->state;
}
GdkGLContext *
gdk_surface_get_paint_gl_context (GdkSurface *surface,
GError **error)
{
GError *internal_error = NULL;
if (GDK_DISPLAY_DEBUG_CHECK (surface->display, GL_DISABLE))
{
g_set_error_literal (error, GDK_GL_ERROR,
GDK_GL_ERROR_NOT_AVAILABLE,
_("GL support disabled via GDK_DEBUG"));
return NULL;
}
if (surface->impl_surface->gl_paint_context == NULL)
{
GdkSurfaceImplClass *impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->create_gl_context == NULL)
{
g_set_error_literal (error, GDK_GL_ERROR, GDK_GL_ERROR_NOT_AVAILABLE,
_("The current backend does not support OpenGL"));
return NULL;
}
surface->impl_surface->gl_paint_context =
impl_class->create_gl_context (surface->impl_surface,
TRUE,
NULL,
&internal_error);
}
if (internal_error != NULL)
{
g_propagate_error (error, internal_error);
g_clear_object (&(surface->impl_surface->gl_paint_context));
return NULL;
}
gdk_gl_context_realize (surface->impl_surface->gl_paint_context, &internal_error);
if (internal_error != NULL)
{
g_propagate_error (error, internal_error);
g_clear_object (&(surface->impl_surface->gl_paint_context));
return NULL;
}
return surface->impl_surface->gl_paint_context;
}
/**
* gdk_surface_create_gl_context:
* @surface: a #GdkSurface
* @error: return location for an error
*
* Creates a new #GdkGLContext matching the
* framebuffer format to the visual of the #GdkSurface. The context
* is disconnected from any particular surface or surface.
*
* If the creation of the #GdkGLContext failed, @error will be set.
*
* Before using the returned #GdkGLContext, you will need to
* call gdk_gl_context_make_current() or gdk_gl_context_realize().
*
* Returns: (transfer full): the newly created #GdkGLContext, or
* %NULL on error
**/
GdkGLContext *
gdk_surface_create_gl_context (GdkSurface *surface,
GError **error)
{
GdkGLContext *paint_context;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
paint_context = gdk_surface_get_paint_gl_context (surface, error);
if (paint_context == NULL)
return NULL;
return GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->create_gl_context (surface->impl_surface,
FALSE,
paint_context,
error);
}
/**
* gdk_surface_create_cairo_context:
* @surface: a #GdkSurface
*
* Creates a new #GdkCairoContext for rendering on @surface.
*
* Returns: (transfer full): the newly created #GdkCairoContext
**/
GdkCairoContext *
gdk_surface_create_cairo_context (GdkSurface *surface)
{
GdkDisplay *display;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
display = gdk_surface_get_display (surface);
return g_object_new (GDK_DISPLAY_GET_CLASS (display)->cairo_context_type,
"surface", surface,
NULL);
}
/**
* gdk_surface_create_vulkan_context:
* @surface: a #GdkSurface
* @error: return location for an error
*
* Creates a new #GdkVulkanContext for rendering on @surface.
*
* If the creation of the #GdkVulkanContext failed, @error will be set.
*
* Returns: (transfer full): the newly created #GdkVulkanContext, or
* %NULL on error
**/
GdkVulkanContext *
gdk_surface_create_vulkan_context (GdkSurface *surface,
GError **error)
{
GdkDisplay *display;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
g_return_val_if_fail (error == NULL || *error == NULL, NULL);
if (GDK_DISPLAY_DEBUG_CHECK (surface->display, VULKAN_DISABLE))
{
g_set_error_literal (error, GDK_VULKAN_ERROR, GDK_VULKAN_ERROR_NOT_AVAILABLE,
_("Vulkan support disabled via GDK_DEBUG"));
return NULL;
}
display = gdk_surface_get_display (surface);
if (GDK_DISPLAY_GET_CLASS (display)->vk_extension_name == NULL)
{
g_set_error (error, GDK_VULKAN_ERROR, GDK_VULKAN_ERROR_UNSUPPORTED,
"The %s backend has no Vulkan support.", G_OBJECT_TYPE_NAME (display));
return FALSE;
}
return g_initable_new (GDK_DISPLAY_GET_CLASS (display)->vk_context_type,
NULL,
error,
"surface", surface,
NULL);
}
/* Code for dirty-region queueing
*/
static GSList *update_surfaces = NULL;
static inline gboolean
gdk_surface_is_ancestor (GdkSurface *surface,
GdkSurface *ancestor)
{
while (surface)
{
GdkSurface *parent = surface->parent;
if (parent == ancestor)
return TRUE;
surface = parent;
}
return FALSE;
}
static void
gdk_surface_add_update_surface (GdkSurface *surface)
{
GSList *tmp;
GSList *prev = NULL;
gboolean has_ancestor_in_list = FALSE;
/* Check whether "surface" is already in "update_surfaces" list.
* It could be added during execution of gtk_widget_destroy() when
* setting focus widget to NULL and redrawing old focus widget.
* See bug 711552.
*/
tmp = g_slist_find (update_surfaces, surface);
if (tmp != NULL)
return;
for (tmp = update_surfaces; tmp; tmp = tmp->next)
{
GdkSurface *parent = surface->parent;
/* check if tmp is an ancestor of "surface"; if it is, set a
* flag indicating that all following surfaces are either
* children of "surface" or from a differen hierarchy
*/
if (!has_ancestor_in_list && gdk_surface_is_ancestor (surface, tmp->data))
has_ancestor_in_list = TRUE;
/* insert in reverse stacking order when adding around siblings,
* so processing updates properly paints over lower stacked surfaces
*/
if (parent == GDK_SURFACE (tmp->data)->parent)
{
if (parent != NULL)
{
gint index = g_list_index (parent->children, surface);
for (; tmp && parent == GDK_SURFACE (tmp->data)->parent; tmp = tmp->next)
{
gint sibling_index = g_list_index (parent->children, tmp->data);
if (index > sibling_index)
break;
prev = tmp;
}
}
/* here, tmp got advanced past all lower stacked siblings */
tmp = g_slist_prepend (tmp, g_object_ref (surface));
if (prev)
prev->next = tmp;
else
update_surfaces = tmp;
return;
}
/* if "surface" has an ancestor in the list and tmp is one of
* "surface's" children, insert "surface" before tmp
*/
if (has_ancestor_in_list && gdk_surface_is_ancestor (tmp->data, surface))
{
tmp = g_slist_prepend (tmp, g_object_ref (surface));
if (prev)
prev->next = tmp;
else
update_surfaces = tmp;
return;
}
/* if we're at the end of the list and had an ancestor it it,
* append to the list
*/
if (! tmp->next && has_ancestor_in_list)
{
tmp = g_slist_append (tmp, g_object_ref (surface));
return;
}
prev = tmp;
}
/* if all above checks failed ("surface" is from a different
* hierarchy than what is already in the list) or the list is
* empty, prepend
*/
update_surfaces = g_slist_prepend (update_surfaces, g_object_ref (surface));
}
static void
gdk_surface_remove_update_surface (GdkSurface *surface)
{
GSList *link;
link = g_slist_find (update_surfaces, surface);
if (link != NULL)
{
update_surfaces = g_slist_delete_link (update_surfaces, link);
g_object_unref (surface);
}
}
static gboolean
gdk_surface_is_toplevel_frozen (GdkSurface *surface)
{
GdkSurface *toplevel;
toplevel = gdk_surface_get_toplevel (surface);
return toplevel->update_and_descendants_freeze_count > 0;
}
static void
gdk_surface_schedule_update (GdkSurface *surface)
{
GdkFrameClock *frame_clock;
if (surface &&
(surface->update_freeze_count ||
gdk_surface_is_toplevel_frozen (surface)))
return;
/* If there's no frame clock (a foreign surface), then the invalid
* region will just stick around unless gdk_surface_process_updates()
* is called. */
frame_clock = gdk_surface_get_frame_clock (surface);
if (frame_clock)
gdk_frame_clock_request_phase (gdk_surface_get_frame_clock (surface),
GDK_FRAME_CLOCK_PHASE_PAINT);
}
static void
gdk_surface_process_updates_recurse (GdkSurface *surface,
cairo_region_t *expose_region)
{
GdkEvent *event;
if (surface->destroyed)
return;
/* Paint the surface before the children, clipped to the surface region */
event = gdk_event_new (GDK_EXPOSE);
event->any.surface = g_object_ref (surface);
event->any.send_event = FALSE;
event->expose.region = cairo_region_reference (expose_region);
_gdk_event_emit (event);
gdk_event_free (event);
}
/* Process and remove any invalid area on the native surface by creating
* expose events for the surface and all non-native descendants.
*/
static void
gdk_surface_process_updates_internal (GdkSurface *surface)
{
/* Ensure the surface lives while updating it */
g_object_ref (surface);
surface->in_update = TRUE;
/* If an update got queued during update processing, we can get a
* surface in the update queue that has an empty update_area.
* just ignore it.
*/
if (surface->update_area)
{
g_assert (surface->active_update_area == NULL); /* No reentrancy */
surface->active_update_area = surface->update_area;
surface->update_area = NULL;
if (gdk_surface_is_viewable (surface))
{
cairo_region_t *expose_region;
expose_region = cairo_region_copy (surface->active_update_area);
gdk_surface_process_updates_recurse (surface, expose_region);
cairo_region_destroy (expose_region);
}
cairo_region_destroy (surface->active_update_area);
surface->active_update_area = NULL;
}
surface->in_update = FALSE;
g_object_unref (surface);
}
static void
gdk_surface_paint_on_clock (GdkFrameClock *clock,
void *data)
{
GdkSurface *surface;
surface = GDK_SURFACE (data);
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (surface->impl_surface == surface);
if (GDK_SURFACE_DESTROYED (surface))
return;
g_object_ref (surface);
if (surface->update_area &&
!surface->update_freeze_count &&
!gdk_surface_is_toplevel_frozen (surface) &&
/* Don't recurse into process_updates_internal, we'll
* do the update later when idle instead. */
!surface->in_update)
{
gdk_surface_process_updates_internal (surface);
gdk_surface_remove_update_surface (surface);
}
g_object_unref (surface);
}
/**
* gdk_surface_invalidate_rect:
* @surface: a #GdkSurface
* @rect: (allow-none): rectangle to invalidate or %NULL to invalidate the whole
* surface
*
* A convenience wrapper around gdk_surface_invalidate_region() which
* invalidates a rectangular region. See
* gdk_surface_invalidate_region() for details.
**/
void
gdk_surface_invalidate_rect (GdkSurface *surface,
const GdkRectangle *rect)
{
GdkRectangle surface_rect;
cairo_region_t *region;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
return;
if (surface->input_only || !surface->viewable)
return;
if (!rect)
{
surface_rect.x = 0;
surface_rect.y = 0;
surface_rect.width = surface->width;
surface_rect.height = surface->height;
rect = &surface_rect;
}
region = cairo_region_create_rectangle (rect);
gdk_surface_invalidate_region (surface, region);
cairo_region_destroy (region);
}
static void
impl_surface_add_update_area (GdkSurface *impl_surface,
cairo_region_t *region)
{
if (impl_surface->update_area)
cairo_region_union (impl_surface->update_area, region);
else
{
gdk_surface_add_update_surface (impl_surface);
impl_surface->update_area = cairo_region_copy (region);
gdk_surface_schedule_update (impl_surface);
}
}
/**
* gdk_surface_queue_expose:
* @surface: a #GdkSurface
*
* Forces an expose event for @surface to be scheduled.
*
* If the invalid area of @surface is empty, an expose event will
* still be emitted. Its invalid region will be empty.
*
* This function is useful for implementations that track invalid
* regions on their own.
**/
void
gdk_surface_queue_expose (GdkSurface *surface)
{
cairo_region_t *region;
g_return_if_fail (GDK_IS_SURFACE (surface));
while (!gdk_surface_has_impl (surface))
surface = surface->parent;
region = cairo_region_create ();
impl_surface_add_update_area (surface, region);
cairo_region_destroy (region);
}
/**
* gdk_surface_invalidate_region:
* @surface: a #GdkSurface
* @region: a #cairo_region_t
*
* Adds @region to the update area for @surface. The update area is the
* region that needs to be redrawn, or “dirty region.”
*
* GDK will process all updates whenever the frame clock schedules a redraw,
* so there’s no need to do forces redraws manually, you just need to
* invalidate regions that you know should be redrawn.
*
* The @invalidate_children parameter controls whether the region of
* each child surface that intersects @region will also be invalidated.
* If %FALSE, then the update area for child surfaces will remain
* unaffected.
**/
void
gdk_surface_invalidate_region (GdkSurface *surface,
const cairo_region_t *region)
{
cairo_region_t *visible_region;
cairo_rectangle_int_t r;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
return;
if (surface->input_only ||
!surface->viewable ||
cairo_region_is_empty (region))
return;
r.x = 0;
r.y = 0;
visible_region = cairo_region_copy (region);
while (surface != NULL &&
!cairo_region_is_empty (visible_region))
{
r.width = surface->width;
r.height = surface->height;
cairo_region_intersect_rectangle (visible_region, &r);
if (gdk_surface_has_impl (surface))
{
impl_surface_add_update_area (surface, visible_region);
break;
}
else
{
cairo_region_translate (visible_region,
surface->x, surface->y);
surface = surface->parent;
}
}
cairo_region_destroy (visible_region);
}
/**
* _gdk_surface_clear_update_area:
* @surface: a #GdkSurface.
*
* Internal function to clear the update area for a surface. This
* is called when the surface is hidden or destroyed.
**/
void
_gdk_surface_clear_update_area (GdkSurface *surface)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->update_area)
{
gdk_surface_remove_update_surface (surface);
cairo_region_destroy (surface->update_area);
surface->update_area = NULL;
}
}
/**
* gdk_surface_freeze_updates:
* @surface: a #GdkSurface
*
* Temporarily freezes a surface such that it won’t receive expose
* events. The surface will begin receiving expose events again when
* gdk_surface_thaw_updates() is called. If gdk_surface_freeze_updates()
* has been called more than once, gdk_surface_thaw_updates() must be called
* an equal number of times to begin processing exposes.
**/
void
gdk_surface_freeze_updates (GdkSurface *surface)
{
GdkSurface *impl_surface;
g_return_if_fail (GDK_IS_SURFACE (surface));
impl_surface = gdk_surface_get_impl_surface (surface);
impl_surface->update_freeze_count++;
}
/**
* gdk_surface_thaw_updates:
* @surface: a #GdkSurface
*
* Thaws a surface frozen with gdk_surface_freeze_updates().
**/
void
gdk_surface_thaw_updates (GdkSurface *surface)
{
GdkSurface *impl_surface;
g_return_if_fail (GDK_IS_SURFACE (surface));
impl_surface = gdk_surface_get_impl_surface (surface);
g_return_if_fail (impl_surface->update_freeze_count > 0);
if (--impl_surface->update_freeze_count == 0)
gdk_surface_schedule_update (GDK_SURFACE (impl_surface));
}
void
gdk_surface_freeze_toplevel_updates (GdkSurface *surface)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (surface->surface_type != GDK_SURFACE_CHILD);
surface->update_and_descendants_freeze_count++;
_gdk_frame_clock_freeze (gdk_surface_get_frame_clock (surface));
}
void
gdk_surface_thaw_toplevel_updates (GdkSurface *surface)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (surface->surface_type != GDK_SURFACE_CHILD);
g_return_if_fail (surface->update_and_descendants_freeze_count > 0);
surface->update_and_descendants_freeze_count--;
_gdk_frame_clock_thaw (gdk_surface_get_frame_clock (surface));
gdk_surface_schedule_update (surface);
}
/**
* gdk_surface_constrain_size:
* @geometry: a #GdkGeometry structure
* @flags: a mask indicating what portions of @geometry are set
* @width: desired width of surface
* @height: desired height of the surface
* @new_width: (out): location to store resulting width
* @new_height: (out): location to store resulting height
*
* Constrains a desired width and height according to a
* set of geometry hints (such as minimum and maximum size).
*/
void
gdk_surface_constrain_size (GdkGeometry *geometry,
GdkSurfaceHints flags,
gint width,
gint height,
gint *new_width,
gint *new_height)
{
/* This routine is partially borrowed from fvwm.
*
* Copyright 1993, Robert Nation
* You may use this code for any purpose, as long as the original
* copyright remains in the source code and all documentation
*
* which in turn borrows parts of the algorithm from uwm
*/
gint min_width = 0;
gint min_height = 0;
gint base_width = 0;
gint base_height = 0;
gint xinc = 1;
gint yinc = 1;
gint max_width = G_MAXINT;
gint max_height = G_MAXINT;
#define FLOOR(value, base) ( ((gint) ((value) / (base))) * (base) )
if ((flags & GDK_HINT_BASE_SIZE) && (flags & GDK_HINT_MIN_SIZE))
{
base_width = geometry->base_width;
base_height = geometry->base_height;
min_width = geometry->min_width;
min_height = geometry->min_height;
}
else if (flags & GDK_HINT_BASE_SIZE)
{
base_width = geometry->base_width;
base_height = geometry->base_height;
min_width = geometry->base_width;
min_height = geometry->base_height;
}
else if (flags & GDK_HINT_MIN_SIZE)
{
base_width = geometry->min_width;
base_height = geometry->min_height;
min_width = geometry->min_width;
min_height = geometry->min_height;
}
if (flags & GDK_HINT_MAX_SIZE)
{
max_width = geometry->max_width ;
max_height = geometry->max_height;
}
if (flags & GDK_HINT_RESIZE_INC)
{
xinc = MAX (xinc, geometry->width_inc);
yinc = MAX (yinc, geometry->height_inc);
}
/* clamp width and height to min and max values
*/
width = CLAMP (width, min_width, max_width);
height = CLAMP (height, min_height, max_height);
/* shrink to base + N * inc
*/
width = base_width + FLOOR (width - base_width, xinc);
height = base_height + FLOOR (height - base_height, yinc);
/* constrain aspect ratio, according to:
*
* width
* min_aspect <= -------- <= max_aspect
* height
*/
if (flags & GDK_HINT_ASPECT &&
geometry->min_aspect > 0 &&
geometry->max_aspect > 0)
{
gint delta;
if (geometry->min_aspect * height > width)
{
delta = FLOOR (height - width / geometry->min_aspect, yinc);
if (height - delta >= min_height)
height -= delta;
else
{
delta = FLOOR (height * geometry->min_aspect - width, xinc);
if (width + delta <= max_width)
width += delta;
}
}
if (geometry->max_aspect * height < width)
{
delta = FLOOR (width - height * geometry->max_aspect, xinc);
if (width - delta >= min_width)
width -= delta;
else
{
delta = FLOOR (width / geometry->max_aspect - height, yinc);
if (height + delta <= max_height)
height += delta;
}
}
}
#undef FLOOR
*new_width = width;
*new_height = height;
}
/**
* gdk_surface_get_device_position_double:
* @surface: a #GdkSurface.
* @device: pointer #GdkDevice to query to.
* @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
* @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
* @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
*
* Obtains the current device position in doubles and modifier state.
* The position is given in coordinates relative to the upper left
* corner of @surface.
*
* Returns: (nullable) (transfer none): The surface underneath @device
* (as with gdk_device_get_surface_at_position()), or %NULL if the
* surface is not known to GDK.
**/
GdkSurface *
gdk_surface_get_device_position_double (GdkSurface *surface,
GdkDevice *device,
double *x,
double *y,
GdkModifierType *mask)
{
gdouble tmp_x, tmp_y;
GdkModifierType tmp_mask;
gboolean normal_child;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
tmp_x = tmp_y = 0;
tmp_mask = 0;
normal_child = GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->get_device_state (surface,
device,
&tmp_x, &tmp_y,
&tmp_mask);
/* We got the coords on the impl, convert to the surface */
tmp_x -= surface->abs_x;
tmp_y -= surface->abs_y;
if (x)
*x = tmp_x;
if (y)
*y = tmp_y;
if (mask)
*mask = tmp_mask;
if (normal_child)
return _gdk_surface_find_child_at (surface, tmp_x, tmp_y);
return NULL;
}
/**
* gdk_surface_get_device_position:
* @surface: a #GdkSurface.
* @device: pointer #GdkDevice to query to.
* @x: (out) (allow-none): return location for the X coordinate of @device, or %NULL.
* @y: (out) (allow-none): return location for the Y coordinate of @device, or %NULL.
* @mask: (out) (allow-none): return location for the modifier mask, or %NULL.
*
* Obtains the current device position and modifier state.
* The position is given in coordinates relative to the upper left
* corner of @surface.
*
* Use gdk_surface_get_device_position_double() if you need subpixel precision.
*
* Returns: (nullable) (transfer none): The surface underneath @device
* (as with gdk_device_get_surface_at_position()), or %NULL if the
* surface is not known to GDK.
**/
GdkSurface *
gdk_surface_get_device_position (GdkSurface *surface,
GdkDevice *device,
gint *x,
gint *y,
GdkModifierType *mask)
{
gdouble tmp_x, tmp_y;
surface = gdk_surface_get_device_position_double (surface, device,
&tmp_x, &tmp_y, mask);
if (x)
*x = round (tmp_x);
if (y)
*y = round (tmp_y);
return surface;
}
static gboolean
gdk_surface_raise_internal (GdkSurface *surface)
{
GdkSurface *parent = surface->parent;
GdkSurfaceImplClass *impl_class;
gboolean did_raise = FALSE;
if (parent && parent->children->data != surface)
{
parent->children = g_list_remove_link (parent->children, &surface->children_list_node);
parent->children = g_list_concat (&surface->children_list_node, parent->children);
did_raise = TRUE;
}
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
/* Just do native raise for toplevels */
if (gdk_surface_has_impl (surface))
impl_class->raise (surface);
return did_raise;
}
/* Returns TRUE If the native surface was mapped or unmapped */
static gboolean
set_viewable (GdkSurface *w,
gboolean val)
{
GdkSurface *child;
GList *l;
if (w->viewable == val)
return FALSE;
w->viewable = val;
if (val)
recompute_visible_regions (w, FALSE);
for (l = w->children; l != NULL; l = l->next)
{
child = l->data;
if (GDK_SURFACE_IS_MAPPED (child))
set_viewable (child, val);
}
return FALSE;
}
/* Returns TRUE If the native surface was mapped or unmapped */
gboolean
_gdk_surface_update_viewable (GdkSurface *surface)
{
gboolean viewable;
if (surface->surface_type == GDK_SURFACE_FOREIGN)
viewable = TRUE;
else if (gdk_surface_is_toplevel (surface) ||
surface->parent->viewable)
viewable = GDK_SURFACE_IS_MAPPED (surface);
else
viewable = FALSE;
return set_viewable (surface, viewable);
}
static void
gdk_surface_show_internal (GdkSurface *surface, gboolean raise)
{
GdkSurfaceImplClass *impl_class;
gboolean was_mapped, was_viewable;
gboolean did_show, did_raise = FALSE;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
was_mapped = GDK_SURFACE_IS_MAPPED (surface);
was_viewable = surface->viewable;
if (raise)
{
/* Keep children in (reverse) stacking order */
did_raise = gdk_surface_raise_internal (surface);
}
if (gdk_surface_has_impl (surface))
{
if (!was_mapped)
gdk_synthesize_surface_state (surface,
GDK_SURFACE_STATE_WITHDRAWN,
0);
}
else
{
surface->state = 0;
g_object_notify_by_pspec (G_OBJECT (surface), properties[PROP_STATE]);
}
did_show = _gdk_surface_update_viewable (surface);
/* If it was already viewable the backend show op won't be called, call it
again to ensure things happen right if the mapped tracking was not right
for e.g. a foreign surface.
Dunno if this is strictly needed but its what happened pre-csw.
Also show if not done by gdk_surface_update_viewable. */
if (gdk_surface_has_impl (surface) && (was_viewable || !did_show))
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->show (surface, !did_show ? was_mapped : TRUE);
}
if (!was_mapped && !gdk_surface_has_impl (surface))
{
if (surface->event_mask & GDK_STRUCTURE_MASK)
_gdk_make_event (surface, GDK_MAP, NULL, FALSE);
if (surface->parent && surface->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
_gdk_make_event (surface, GDK_MAP, NULL, FALSE);
}
if (!was_mapped || did_raise)
{
recompute_visible_regions (surface, FALSE);
if (gdk_surface_is_viewable (surface))
gdk_surface_invalidate_rect (surface, NULL);
}
}
/**
* gdk_surface_show_unraised:
* @surface: a #GdkSurface
*
* Shows a #GdkSurface onscreen, but does not modify its stacking
* order. In contrast, gdk_surface_show() will raise the surface
* to the top of the surface stack.
*
* On the X11 platform, in Xlib terms, this function calls
* XMapWindow() (it also updates some internal GDK state, which means
* that you can’t really use XMapWindow() directly on a GDK surface).
*/
void
gdk_surface_show_unraised (GdkSurface *surface)
{
gdk_surface_show_internal (surface, FALSE);
}
/**
* gdk_surface_raise:
* @surface: a #GdkSurface
*
* Raises @surface to the top of the Z-order (stacking order), so that
* other surfaces with the same parent surface appear below @surface.
* This is true whether or not the surfaces are visible.
*
* If @surface is a toplevel, the surface manager may choose to deny the
* request to move the surface in the Z-order, gdk_surface_raise() only
* requests the restack, does not guarantee it.
*/
void
gdk_surface_raise (GdkSurface *surface)
{
gboolean did_raise;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
/* Keep children in (reverse) stacking order */
did_raise = gdk_surface_raise_internal (surface);
if (did_raise &&
!gdk_surface_is_toplevel (surface) &&
gdk_surface_is_viewable (surface) &&
!surface->input_only)
gdk_surface_invalidate_rect (surface, NULL);
}
static void
gdk_surface_lower_internal (GdkSurface *surface)
{
GdkSurface *parent = surface->parent;
GdkSurfaceImplClass *impl_class;
if (parent)
{
parent->children = g_list_remove_link (parent->children, &surface->children_list_node);
parent->children = g_list_concat (parent->children, &surface->children_list_node);
}
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
/* Just do native lower for toplevels */
if (gdk_surface_has_impl (surface))
impl_class->lower (surface);
}
static void
gdk_surface_invalidate_in_parent (GdkSurface *private)
{
GdkRectangle r, child;
if (gdk_surface_is_toplevel (private))
return;
/* get the visible rectangle of the parent */
r.x = r.y = 0;
r.width = private->parent->width;
r.height = private->parent->height;
child.x = private->x;
child.y = private->y;
child.width = private->width;
child.height = private->height;
gdk_rectangle_intersect (&r, &child, &r);
gdk_surface_invalidate_rect (private->parent, &r);
}
/**
* gdk_surface_lower:
* @surface: a #GdkSurface
*
* Lowers @surface to the bottom of the Z-order (stacking order), so that
* other surfaces with the same parent surface appear above @surface.
* This is true whether or not the other surfaces are visible.
*
* If @surface is a toplevel, the window manager may choose to deny the
* request to move the surface in the Z-order, gdk_surface_lower() only
* requests the restack, does not guarantee it.
*
* Note that gdk_surface_show() raises the surface again, so don’t call this
* function before gdk_surface_show(). (Try gdk_surface_show_unraised().)
*/
void
gdk_surface_lower (GdkSurface *surface)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
/* Keep children in (reverse) stacking order */
gdk_surface_lower_internal (surface);
gdk_surface_invalidate_in_parent (surface);
}
/**
* gdk_surface_restack:
* @surface: a #GdkSurface
* @sibling: (allow-none): a #GdkSurface that is a sibling of @surface, or %NULL
* @above: a boolean
*
* Changes the position of @surface in the Z-order (stacking order), so that
* it is above @sibling (if @above is %TRUE) or below @sibling (if @above is
* %FALSE).
*
* If @sibling is %NULL, then this either raises (if @above is %TRUE) or
* lowers the surface.
*
* If @surface is a toplevel, the window manager may choose to deny the
* request to move the surface in the Z-order, gdk_surface_restack() only
* requests the restack, does not guarantee it.
*/
void
gdk_surface_restack (GdkSurface *surface,
GdkSurface *sibling,
gboolean above)
{
GdkSurfaceImplClass *impl_class;
GdkSurface *parent;
GList *sibling_link;
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (sibling == NULL || GDK_IS_SURFACE (sibling));
if (surface->destroyed)
return;
if (sibling == NULL)
{
if (above)
gdk_surface_raise (surface);
else
gdk_surface_lower (surface);
return;
}
if (gdk_surface_is_toplevel (surface))
{
g_return_if_fail (gdk_surface_is_toplevel (sibling));
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->restack_toplevel (surface, sibling, above);
return;
}
parent = surface->parent;
if (parent)
{
sibling_link = g_list_find (parent->children, sibling);
g_return_if_fail (sibling_link != NULL);
if (sibling_link == NULL)
return;
parent->children = g_list_remove_link (parent->children, &surface->children_list_node);
if (above)
parent->children = list_insert_link_before (parent->children,
sibling_link,
&surface->children_list_node);
else
parent->children = list_insert_link_before (parent->children,
sibling_link->next,
&surface->children_list_node);
}
gdk_surface_invalidate_in_parent (surface);
}
/**
* gdk_surface_show:
* @surface: a #GdkSurface
*
* Like gdk_surface_show_unraised(), but also raises the surface to the
* top of the surface stack (moves the surface to the front of the
* Z-order).
*
* This function maps a surface so it’s visible onscreen. Its opposite
* is gdk_surface_hide().
*
* When implementing a #GtkWidget, you should call this function on the widget's
* #GdkSurface as part of the “map” method.
*/
void
gdk_surface_show (GdkSurface *surface)
{
gdk_surface_show_internal (surface, TRUE);
}
/**
* gdk_surface_hide:
* @surface: a #GdkSurface
*
* For toplevel surfaces, withdraws them, so they will no longer be
* known to the window manager; for all surfaces, unmaps them, so
* they won’t be displayed. Normally done automatically as
* part of gtk_widget_hide().
*/
void
gdk_surface_hide (GdkSurface *surface)
{
GdkSurfaceImplClass *impl_class;
gboolean was_mapped, did_hide;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
was_mapped = GDK_SURFACE_IS_MAPPED (surface);
if (gdk_surface_has_impl (surface))
{
if (GDK_SURFACE_IS_MAPPED (surface))
gdk_synthesize_surface_state (surface,
0,
GDK_SURFACE_STATE_WITHDRAWN);
}
else if (was_mapped)
{
surface->state = GDK_SURFACE_STATE_WITHDRAWN;
g_object_notify_by_pspec (G_OBJECT (surface), properties[PROP_STATE]);
}
if (was_mapped)
{
GdkDisplay *display;
GdkSeat *seat;
GList *devices, *d;
/* May need to break grabs on children */
display = gdk_surface_get_display (surface);
seat = gdk_display_get_default_seat (display);
devices = gdk_seat_get_slaves (seat, GDK_SEAT_CAPABILITY_ALL);
devices = g_list_prepend (devices, gdk_seat_get_keyboard (seat));
devices = g_list_prepend (devices, gdk_seat_get_pointer (seat));
for (d = devices; d; d = d->next)
{
GdkDevice *device = d->data;
if (_gdk_display_end_device_grab (display,
device,
_gdk_display_get_next_serial (display),
surface,
TRUE))
{
G_GNUC_BEGIN_IGNORE_DEPRECATIONS
gdk_device_ungrab (device, GDK_CURRENT_TIME);
G_GNUC_END_IGNORE_DEPRECATIONS
}
}
g_list_free (devices);
}
did_hide = _gdk_surface_update_viewable (surface);
/* Hide foreign surface as those are not handled by update_viewable. */
if (gdk_surface_has_impl (surface) && (!did_hide))
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->hide (surface);
}
recompute_visible_regions (surface, FALSE);
if (was_mapped && !gdk_surface_has_impl (surface))
{
if (surface->event_mask & GDK_STRUCTURE_MASK)
_gdk_make_event (surface, GDK_UNMAP, NULL, FALSE);
if (surface->parent && surface->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
_gdk_make_event (surface, GDK_UNMAP, NULL, FALSE);
}
/* Invalidate the rect */
if (was_mapped)
gdk_surface_invalidate_in_parent (surface);
}
/**
* gdk_surface_withdraw:
* @surface: a toplevel #GdkSurface
*
* Withdraws a surface (unmaps it and asks the surface manager to forget about it).
* This function is not really useful as gdk_surface_hide() automatically
* withdraws toplevel surfaces before hiding them.
**/
void
gdk_surface_withdraw (GdkSurface *surface)
{
GdkSurfaceImplClass *impl_class;
gboolean was_mapped;
GdkGLContext *current_context;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
was_mapped = GDK_SURFACE_IS_MAPPED (surface);
if (gdk_surface_has_impl (surface))
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->withdraw (surface);
if (was_mapped)
{
if (surface->event_mask & GDK_STRUCTURE_MASK)
_gdk_make_event (surface, GDK_UNMAP, NULL, FALSE);
if (surface->parent && surface->parent->event_mask & GDK_SUBSTRUCTURE_MASK)
_gdk_make_event (surface, GDK_UNMAP, NULL, FALSE);
}
current_context = gdk_gl_context_get_current ();
if (current_context != NULL && gdk_gl_context_get_surface (current_context) == surface)
gdk_gl_context_clear_current ();
recompute_visible_regions (surface, FALSE);
}
}
/**
* gdk_surface_set_events:
* @surface: a #GdkSurface
* @event_mask: event mask for @surface
*
* The event mask for a surface determines which events will be reported
* for that surface from all master input devices. For example, an event mask
* including #GDK_BUTTON_PRESS_MASK means the surface should report button
* press events. The event mask is the bitwise OR of values from the
* #GdkEventMask enumeration.
*
* See the [input handling overview][event-masks] for details.
**/
void
gdk_surface_set_events (GdkSurface *surface,
GdkEventMask event_mask)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
surface->event_mask = event_mask;
if (gdk_surface_has_impl (surface))
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->set_events (surface,
get_native_event_mask (surface));
}
}
/**
* gdk_surface_get_events:
* @surface: a #GdkSurface
*
* Gets the event mask for @surface for all master input devices. See
* gdk_surface_set_events().
*
* Returns: event mask for @surface
**/
GdkEventMask
gdk_surface_get_events (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), 0);
if (surface->destroyed)
return 0;
return surface->event_mask;
}
/**
* gdk_surface_set_device_events:
* @surface: a #GdkSurface
* @device: #GdkDevice to enable events for.
* @event_mask: event mask for @surface
*
* Sets the event mask for a given device (Normally a floating device, not
* attached to any visible pointer) to @surface. For example, an event mask
* including #GDK_BUTTON_PRESS_MASK means the surface should report button
* press events. The event mask is the bitwise OR of values from the
* #GdkEventMask enumeration.
*
* See the [input handling overview][event-masks] for details.
**/
void
gdk_surface_set_device_events (GdkSurface *surface,
GdkDevice *device,
GdkEventMask event_mask)
{
GdkEventMask device_mask;
GdkSurface *native;
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (GDK_IS_DEVICE (device));
if (GDK_SURFACE_DESTROYED (surface))
return;
if (G_UNLIKELY (!surface->device_events))
surface->device_events = g_hash_table_new (NULL, NULL);
if (event_mask == 0)
{
/* FIXME: unsetting events on a master device
* would restore surface->event_mask
*/
g_hash_table_remove (surface->device_events, device);
}
else
g_hash_table_insert (surface->device_events, device,
GINT_TO_POINTER (event_mask));
native = gdk_surface_get_toplevel (surface);
device_mask = get_native_device_event_mask (surface, device);
GDK_DEVICE_GET_CLASS (device)->select_surface_events (device, native, device_mask);
}
/**
* gdk_surface_get_device_events:
* @surface: a #GdkSurface.
* @device: a #GdkDevice.
*
* Returns the event mask for @surface corresponding to an specific device.
*
* Returns: device event mask for @surface
**/
GdkEventMask
gdk_surface_get_device_events (GdkSurface *surface,
GdkDevice *device)
{
GdkEventMask mask;
g_return_val_if_fail (GDK_IS_SURFACE (surface), 0);
g_return_val_if_fail (GDK_IS_DEVICE (device), 0);
if (GDK_SURFACE_DESTROYED (surface))
return 0;
if (!surface->device_events)
return 0;
mask = GPOINTER_TO_INT (g_hash_table_lookup (surface->device_events, device));
/* FIXME: device could be controlled by surface->event_mask */
return mask;
}
static void
gdk_surface_move_resize_toplevel (GdkSurface *surface,
gboolean with_move,
gint x,
gint y,
gint width,
gint height)
{
GdkSurfaceImplClass *impl_class;
gboolean is_resize;
is_resize = (width != -1) || (height != -1);
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->move_resize (surface, with_move, x, y, width, height);
/* Avoid recomputing for pure toplevel moves, for performance reasons */
if (is_resize)
recompute_visible_regions (surface, FALSE);
}
static void
gdk_surface_move_resize_internal (GdkSurface *surface,
gboolean with_move,
gint x,
gint y,
gint width,
gint height)
{
cairo_region_t *old_region, *new_region;
gboolean expose;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->destroyed)
return;
if (gdk_surface_is_toplevel (surface))
{
gdk_surface_move_resize_toplevel (surface, with_move, x, y, width, height);
return;
}
if (width == 0)
width = 1;
if (height == 0)
height = 1;
/* Bail early if no change */
if (surface->width == width &&
surface->height == height &&
(!with_move ||
(surface->x == x &&
surface->y == y)))
return;
/* Handle child surfaces */
expose = FALSE;
old_region = NULL;
if (gdk_surface_is_viewable (surface) &&
!surface->input_only)
{
GdkRectangle r;
expose = TRUE;
r.x = surface->x;
r.y = surface->y;
r.width = surface->width;
r.height = surface->height;
old_region = cairo_region_create_rectangle (&r);
}
/* Set the new position and size */
if (with_move)
{
surface->x = x;
surface->y = y;
}
if (!(width < 0 && height < 0))
{
surface->width = width;
surface->height = height;
}
recompute_visible_regions (surface, FALSE);
if (expose)
{
GdkRectangle r;
r.x = surface->x;
r.y = surface->y;
r.width = surface->width;
r.height = surface->height;
new_region = cairo_region_create_rectangle (&r);
cairo_region_union (new_region, old_region);
gdk_surface_invalidate_region (surface->parent, new_region);
cairo_region_destroy (old_region);
cairo_region_destroy (new_region);
}
}
/**
* gdk_surface_move:
* @surface: a #GdkSurface
* @x: X coordinate relative to surface’s parent
* @y: Y coordinate relative to surface’s parent
*
* Repositions a surface relative to its parent surface.
* For toplevel surfaces, window managers may ignore or modify the move;
* you should probably use gtk_window_move() on a #GtkWindow widget
* anyway, instead of using GDK functions. For child surfaces,
* the move will reliably succeed.
*
* If you’re also planning to resize the surface, use gdk_surface_move_resize()
* to both move and resize simultaneously, for a nicer visual effect.
**/
void
gdk_surface_move (GdkSurface *surface,
gint x,
gint y)
{
gdk_surface_move_resize_internal (surface, TRUE, x, y, -1, -1);
}
/**
* gdk_surface_resize:
* @surface: a #GdkSurface
* @width: new width of the surface
* @height: new height of the surface
*
* Resizes @surface; for toplevel surfaces, asks the window manager to resize
* the surface. The window manager may not allow the resize. When using GTK+,
* use gtk_window_resize() instead of this low-level GDK function.
*
* Surfaces may not be resized below 1x1.
*
* If you’re also planning to move the surface, use gdk_surface_move_resize()
* to both move and resize simultaneously, for a nicer visual effect.
**/
void
gdk_surface_resize (GdkSurface *surface,
gint width,
gint height)
{
gdk_surface_move_resize_internal (surface, FALSE, 0, 0, width, height);
}
/**
* gdk_surface_move_resize:
* @surface: a #GdkSurface
* @x: new X position relative to surface’s parent
* @y: new Y position relative to surface’s parent
* @width: new width
* @height: new height
*
* Equivalent to calling gdk_surface_move() and gdk_surface_resize(),
* except that both operations are performed at once, avoiding strange
* visual effects. (i.e. the user may be able to see the surface first
* move, then resize, if you don’t use gdk_surface_move_resize().)
**/
void
gdk_surface_move_resize (GdkSurface *surface,
gint x,
gint y,
gint width,
gint height)
{
gdk_surface_move_resize_internal (surface, TRUE, x, y, width, height);
}
/**
* gdk_surface_move_to_rect:
* @surface: the #GdkSurface to move
* @rect: (not nullable): the destination #GdkRectangle to align @surface with
* @rect_anchor: the point on @rect to align with @surface's anchor point
* @surface_anchor: the point on @surface to align with @rect's anchor point
* @anchor_hints: positioning hints to use when limited on space
* @rect_anchor_dx: horizontal offset to shift @surface, i.e. @rect's anchor
* point
* @rect_anchor_dy: vertical offset to shift @surface, i.e. @rect's anchor point
*
* Moves @surface to @rect, aligning their anchor points.
*
* @rect is relative to the top-left corner of the surface that @surface is
* transient for. @rect_anchor and @surface_anchor determine anchor points on
* @rect and @surface to pin together. @rect's anchor point can optionally be
* offset by @rect_anchor_dx and @rect_anchor_dy, which is equivalent to
* offsetting the position of @surface.
*
* @anchor_hints determines how @surface will be moved if the anchor points cause
* it to move off-screen. For example, %GDK_ANCHOR_FLIP_X will replace
* %GDK_GRAVITY_NORTH_WEST with %GDK_GRAVITY_NORTH_EAST and vice versa if
* @surface extends beyond the left or right edges of the monitor.
*
* Connect to the #GdkSurface::moved-to-rect signal to find out how it was
* actually positioned.
*
* Stability: Private
*/
void
gdk_surface_move_to_rect (GdkSurface *surface,
const GdkRectangle *rect,
GdkGravity rect_anchor,
GdkGravity surface_anchor,
GdkAnchorHints anchor_hints,
gint rect_anchor_dx,
gint rect_anchor_dy)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (surface->transient_for);
g_return_if_fail (rect);
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->move_to_rect (surface,
rect,
rect_anchor,
surface_anchor,
anchor_hints,
rect_anchor_dx,
rect_anchor_dy);
}
static void
gdk_surface_set_cursor_internal (GdkSurface *surface,
GdkDevice *device,
GdkCursor *cursor)
{
if (GDK_SURFACE_DESTROYED (surface))
return;
g_assert (gdk_surface_get_display (surface) == gdk_device_get_display (device));
if (surface->surface_type == GDK_SURFACE_FOREIGN)
GDK_DEVICE_GET_CLASS (device)->set_surface_cursor (device, surface, cursor);
else
{
GdkPointerSurfaceInfo *pointer_info;
GdkDisplay *display;
display = gdk_surface_get_display (surface);
pointer_info = _gdk_display_get_pointer_info (display, device);
if (_gdk_surface_event_parent_of (surface, pointer_info->surface_under_pointer))
update_cursor (display, device);
}
}
/**
* gdk_surface_get_cursor:
* @surface: a #GdkSurface
*
* Retrieves a #GdkCursor pointer for the cursor currently set on the
* specified #GdkSurface, or %NULL. If the return value is %NULL then
* there is no custom cursor set on the specified surface, and it is
* using the cursor for its parent surface.
*
* Returns: (nullable) (transfer none): a #GdkCursor, or %NULL. The
* returned object is owned by the #GdkSurface and should not be
* unreferenced directly. Use gdk_surface_set_cursor() to unset the
* cursor of the surface
*/
GdkCursor *
gdk_surface_get_cursor (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
return surface->cursor;
}
/**
* gdk_surface_set_cursor:
* @surface: a #GdkSurface
* @cursor: (allow-none): a cursor
*
* Sets the default mouse pointer for a #GdkSurface.
*
* Note that @cursor must be for the same display as @surface.
*
* Use gdk_cursor_new_for_display() or gdk_cursor_new_from_texture() to
* create the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR.
* Passing %NULL for the @cursor argument to gdk_surface_set_cursor() means
* that @surface will use the cursor of its parent surface. Most surfaces
* should use this default.
*/
void
gdk_surface_set_cursor (GdkSurface *surface,
GdkCursor *cursor)
{
GdkDisplay *display;
g_return_if_fail (GDK_IS_SURFACE (surface));
display = gdk_surface_get_display (surface);
if (surface->cursor)
{
g_object_unref (surface->cursor);
surface->cursor = NULL;
}
if (!GDK_SURFACE_DESTROYED (surface))
{
GdkDevice *device;
GList *seats, *s;
if (cursor)
surface->cursor = g_object_ref (cursor);
seats = gdk_display_list_seats (display);
for (s = seats; s; s = s->next)
{
GList *devices, *d;
device = gdk_seat_get_pointer (s->data);
gdk_surface_set_cursor_internal (surface, device, surface->cursor);
devices = gdk_seat_get_slaves (s->data, GDK_SEAT_CAPABILITY_TABLET_STYLUS);
for (d = devices; d; d = d->next)
{
device = gdk_device_get_associated_device (d->data);
gdk_surface_set_cursor_internal (surface, device, surface->cursor);
}
g_list_free (devices);
}
g_list_free (seats);
g_object_notify_by_pspec (G_OBJECT (surface), properties[PROP_CURSOR]);
}
}
/**
* gdk_surface_get_device_cursor:
* @surface: a #GdkSurface.
* @device: a master, pointer #GdkDevice.
*
* Retrieves a #GdkCursor pointer for the @device currently set on the
* specified #GdkSurface, or %NULL. If the return value is %NULL then
* there is no custom cursor set on the specified surface, and it is
* using the cursor for its parent surface.
*
* Returns: (nullable) (transfer none): a #GdkCursor, or %NULL. The
* returned object is owned by the #GdkSurface and should not be
* unreferenced directly. Use gdk_surface_set_cursor() to unset the
* cursor of the surface
**/
GdkCursor *
gdk_surface_get_device_cursor (GdkSurface *surface,
GdkDevice *device)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
g_return_val_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD, NULL);
g_return_val_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER, NULL);
return g_hash_table_lookup (surface->device_cursor, device);
}
/**
* gdk_surface_set_device_cursor:
* @surface: a #GdkSurface
* @device: a master, pointer #GdkDevice
* @cursor: a #GdkCursor
*
* Sets a specific #GdkCursor for a given device when it gets inside @surface.
* Use gdk_cursor_new_for_display() or gdk_cursor_new_from_texture() to create
* the cursor. To make the cursor invisible, use %GDK_BLANK_CURSOR. Passing
* %NULL for the @cursor argument to gdk_surface_set_cursor() means that
* @surface will use the cursor of its parent surface. Most surfaces should
* use this default.
**/
void
gdk_surface_set_device_cursor (GdkSurface *surface,
GdkDevice *device,
GdkCursor *cursor)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (GDK_IS_DEVICE (device));
g_return_if_fail (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD);
g_return_if_fail (gdk_device_get_device_type (device) == GDK_DEVICE_TYPE_MASTER);
if (!cursor)
g_hash_table_remove (surface->device_cursor, device);
else
g_hash_table_replace (surface->device_cursor, device, g_object_ref (cursor));
gdk_surface_set_cursor_internal (surface, device, cursor);
}
/**
* gdk_surface_get_geometry:
* @surface: a #GdkSurface
* @x: (out) (allow-none): return location for X coordinate of surface (relative to its parent)
* @y: (out) (allow-none): return location for Y coordinate of surface (relative to its parent)
* @width: (out) (allow-none): return location for width of surface
* @height: (out) (allow-none): return location for height of surface
*
* Any of the return location arguments to this function may be %NULL,
* if you aren’t interested in getting the value of that field.
*
* The X and Y coordinates returned are relative to the parent surface
* of @surface, which for toplevels usually means relative to the
* surface decorations (titlebar, etc.) rather than relative to the
* root window (screen-size background window).
*
* On the X11 platform, the geometry is obtained from the X server,
* so reflects the latest position of @surface; this may be out-of-sync
* with the position of @surface delivered in the most-recently-processed
* #GdkEventConfigure. gdk_surface_get_position() in contrast gets the
* position from the most recent configure event.
*
* Note: If @surface is not a toplevel, it is much better
* to call gdk_surface_get_position(), gdk_surface_get_width() and
* gdk_surface_get_height() instead, because it avoids the roundtrip to
* the X server and because these functions support the full 32-bit
* coordinate space, whereas gdk_surface_get_geometry() is restricted to
* the 16-bit coordinates of X11.
*/
void
gdk_surface_get_geometry (GdkSurface *surface,
gint *x,
gint *y,
gint *width,
gint *height)
{
GdkSurface *parent;
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (!GDK_SURFACE_DESTROYED (surface))
{
if (gdk_surface_has_impl (surface))
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->get_geometry (surface, x, y,
width, height);
/* This reports the position wrt to the native parent, we need to convert
it to be relative to the client side parent */
parent = surface->parent;
if (parent && !gdk_surface_has_impl (parent))
{
if (x)
*x -= parent->abs_x;
if (y)
*y -= parent->abs_y;
}
}
else
{
if (x)
*x = surface->x;
if (y)
*y = surface->y;
if (width)
*width = surface->width;
if (height)
*height = surface->height;
}
}
}
/**
* gdk_surface_get_width:
* @surface: a #GdkSurface
*
* Returns the width of the given @surface.
*
* On the X11 platform the returned size is the size reported in the
* most-recently-processed configure event, rather than the current
* size on the X server.
*
* Returns: The width of @surface
*/
int
gdk_surface_get_width (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), 0);
return surface->width;
}
/**
* gdk_surface_get_height:
* @surface: a #GdkSurface
*
* Returns the height of the given @surface.
*
* On the X11 platform the returned size is the size reported in the
* most-recently-processed configure event, rather than the current
* size on the X server.
*
* Returns: The height of @surface
*/
int
gdk_surface_get_height (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), 0);
return surface->height;
}
/**
* gdk_surface_get_origin:
* @surface: a #GdkSurface
* @x: (out) (allow-none): return location for X coordinate
* @y: (out) (allow-none): return location for Y coordinate
*
* Obtains the position of a surface in root window coordinates.
* (Compare with gdk_surface_get_position() and
* gdk_surface_get_geometry() which return the position of a surface
* relative to its parent surface.)
*
* Returns: not meaningful, ignore
*/
gint
gdk_surface_get_origin (GdkSurface *surface,
gint *x,
gint *y)
{
gint dummy_x, dummy_y;
g_return_val_if_fail (GDK_IS_SURFACE (surface), 0);
gdk_surface_get_root_coords (surface,
0, 0,
x ? x : &dummy_x,
y ? y : &dummy_y);
return TRUE;
}
/**
* gdk_surface_get_root_coords:
* @surface: a #GdkSurface
* @x: X coordinate in surface
* @y: Y coordinate in surface
* @root_x: (out): return location for X coordinate
* @root_y: (out): return location for Y coordinate
*
* Obtains the position of a surface position in root
* window coordinates. This is similar to
* gdk_surface_get_origin() but allows you to pass
* in any position in the surface, not just the origin.
*/
void
gdk_surface_get_root_coords (GdkSurface *surface,
gint x,
gint y,
gint *root_x,
gint *root_y)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
{
*root_x = 0;
*root_y = 0;
return;
}
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->get_root_coords (surface->impl_surface,
x + surface->abs_x,
y + surface->abs_y,
root_x, root_y);
}
/**
* gdk_surface_coords_to_parent:
* @surface: a child surface
* @x: X coordinate in child’s coordinate system
* @y: Y coordinate in child’s coordinate system
* @parent_x: (out) (allow-none): return location for X coordinate
* in parent’s coordinate system, or %NULL
* @parent_y: (out) (allow-none): return location for Y coordinate
* in parent’s coordinate system, or %NULL
*
* Transforms surface coordinates from a child surface to its parent
* surface. Calling this function is equivalent to adding the return
* values of gdk_surface_get_position() to the child coordinates.
*
* See also: gdk_surface_coords_from_parent()
**/
void
gdk_surface_coords_to_parent (GdkSurface *surface,
gdouble x,
gdouble y,
gdouble *parent_x,
gdouble *parent_y)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (parent_x)
*parent_x = x + surface->x;
if (parent_y)
*parent_y = y + surface->y;
}
/**
* gdk_surface_coords_from_parent:
* @surface: a child surface
* @parent_x: X coordinate in parent’s coordinate system
* @parent_y: Y coordinate in parent’s coordinate system
* @x: (out) (allow-none): return location for X coordinate in child’s coordinate system
* @y: (out) (allow-none): return location for Y coordinate in child’s coordinate system
*
* Transforms surface coordinates from a parent surface to a child
* surface.
*
* Calling this function is equivalent to subtracting the return
* values of gdk_surface_get_position() from the parent coordinates.
*
* See also: gdk_surface_coords_to_parent()
**/
void
gdk_surface_coords_from_parent (GdkSurface *surface,
gdouble parent_x,
gdouble parent_y,
gdouble *x,
gdouble *y)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (x)
*x = parent_x - surface->x;
if (y)
*y = parent_y - surface->y;
}
/**
* gdk_surface_input_shape_combine_region:
* @surface: a #GdkSurface
* @shape_region: region of surface to be non-transparent
* @offset_x: X position of @shape_region in @surface coordinates
* @offset_y: Y position of @shape_region in @surface coordinates
*
* Like gdk_surface_shape_combine_region(), but the shape applies
* only to event handling. Mouse events which happen while
* the pointer position corresponds to an unset bit in the
* mask will be passed on the surface below @surface.
*
* An input shape is typically used with RGBA surfaces.
* The alpha channel of the surface defines which pixels are
* invisible and allows for nicely antialiased borders,
* and the input shape controls where the surface is
* “clickable”.
*
* On the X11 platform, this requires version 1.1 of the
* shape extension.
*
* On the Win32 platform, this functionality is not present and the
* function does nothing.
*/
void
gdk_surface_input_shape_combine_region (GdkSurface *surface,
const cairo_region_t *shape_region,
gint offset_x,
gint offset_y)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
return;
if (surface->input_shape)
cairo_region_destroy (surface->input_shape);
if (shape_region)
{
surface->input_shape = cairo_region_copy (shape_region);
cairo_region_translate (surface->input_shape, offset_x, offset_y);
}
else
surface->input_shape = NULL;
if (gdk_surface_has_impl (surface))
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
impl_class->input_shape_combine_region (surface, surface->input_shape, 0, 0);
}
}
static void
do_child_input_shapes (GdkSurface *surface,
gboolean merge)
{
GdkRectangle r;
cairo_region_t *region;
r.x = 0;
r.y = 0;
r.width = surface->width;
r.height = surface->height;
region = cairo_region_create_rectangle (&r);
remove_child_area (surface, TRUE, region);
if (merge && surface->input_shape)
cairo_region_subtract (region, surface->input_shape);
cairo_region_xor_rectangle (region, &r);
gdk_surface_input_shape_combine_region (surface, region, 0, 0);
}
/**
* gdk_surface_set_child_input_shapes:
* @surface: a #GdkSurface
*
* Sets the input shape mask of @surface to the union of input shape masks
* for all children of @surface, ignoring the input shape mask of @surface
* itself. Contrast with gdk_surface_merge_child_input_shapes() which includes
* the input shape mask of @surface in the masks to be merged.
**/
void
gdk_surface_set_child_input_shapes (GdkSurface *surface)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
do_child_input_shapes (surface, FALSE);
}
/**
* gdk_surface_set_pass_through:
* @surface: a #GdkSurface
* @pass_through: a boolean
*
* Sets whether input to the surface is passed through to the surface
* below.
*
* The default value of this is %FALSE, which means that pointer
* events that happen inside the surface are send first to the surface,
* but if the event is not selected by the event mask then the event
* is sent to the parent surface, and so on up the hierarchy.
*
* If @pass_through is %TRUE then such pointer events happen as if the
* surface wasn't there at all, and thus will be sent first to any
* surfaces below @surface. This is useful if the surface is used in a
* transparent fashion. In the terminology of the web this would be called
* "pointer-events: none".
*
* Note that a surface with @pass_through %TRUE can still have a subsurface
* without pass through, so you can get events on a subset of a surface. And in
* that cases you would get the in-between related events such as the pointer
* enter/leave events on its way to the destination surface.
**/
void
gdk_surface_set_pass_through (GdkSurface *surface,
gboolean pass_through)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
surface->pass_through = !!pass_through;
}
/**
* gdk_surface_get_pass_through:
* @surface: a #GdkSurface
*
* Returns whether input to the surface is passed through to the surface
* below.
*
* See gdk_surface_set_pass_through() for details
**/
gboolean
gdk_surface_get_pass_through (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->pass_through;
}
/**
* gdk_surface_merge_child_input_shapes:
* @surface: a #GdkSurface
*
* Merges the input shape masks for any child surfaces into the
* input shape mask for @surface. i.e. the union of all input masks
* for @surface and its children will become the new input mask
* for @surface. See gdk_surface_input_shape_combine_region().
*
* This function is distinct from gdk_surface_set_child_input_shapes()
* because it includes @surface’s input shape mask in the set of
* shapes to be merged.
**/
void
gdk_surface_merge_child_input_shapes (GdkSurface *surface)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
do_child_input_shapes (surface, TRUE);
}
/**
* gdk_surface_get_modal_hint:
* @surface: A toplevel #GdkSurface.
*
* Determines whether or not the surface manager is hinted that @surface
* has modal behaviour.
*
* Returns: whether or not the surface has the modal hint set.
*/
gboolean
gdk_surface_get_modal_hint (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->modal_hint;
}
/**
* gdk_surface_get_accept_focus:
* @surface: a toplevel #GdkSurface.
*
* Determines whether or not the desktop environment shuld be hinted that
* the surface does not want to receive input focus.
*
* Returns: whether or not the surface should receive input focus.
*/
gboolean
gdk_surface_get_accept_focus (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->accept_focus;
}
/**
* gdk_surface_get_focus_on_map:
* @surface: a toplevel #GdkSurface.
*
* Determines whether or not the desktop environment should be hinted that the
* surface does not want to receive input focus when it is mapped.
*
* Returns: whether or not the surface wants to receive input focus when
* it is mapped.
*/
gboolean
gdk_surface_get_focus_on_map (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->focus_on_map;
}
/**
* gdk_surface_is_input_only:
* @surface: a toplevel #GdkSurface
*
* Determines whether or not the surface is an input only surface.
*
* Returns: %TRUE if @surface is input only
*/
gboolean
gdk_surface_is_input_only (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
return surface->input_only;
}
/* Gets the toplevel for a surface as used for events,
i.e. including offscreen parents going up to the native
toplevel */
static GdkSurface *
get_event_toplevel (GdkSurface *surface)
{
GdkSurface *parent;
while ((parent = surface->parent) != NULL)
surface = parent;
return surface;
}
gboolean
_gdk_surface_event_parent_of (GdkSurface *parent,
GdkSurface *child)
{
GdkSurface *w;
w = child;
while (w != NULL)
{
if (w == parent)
return TRUE;
w = w->parent;
}
return FALSE;
}
static void
update_cursor (GdkDisplay *display,
GdkDevice *device)
{
GdkSurface *cursor_surface, *parent, *toplevel;
GdkSurface *pointer_surface;
GdkPointerSurfaceInfo *pointer_info;
GdkDeviceGrabInfo *grab;
GdkCursor *cursor;
pointer_info = _gdk_display_get_pointer_info (display, device);
pointer_surface = pointer_info->surface_under_pointer;
/* We ignore the serials here and just pick the last grab
we've sent, as that would shortly be used anyway. */
grab = _gdk_display_get_last_device_grab (display, device);
if (/* have grab */
grab != NULL &&
/* the pointer is not in a descendant of the grab surface */
!_gdk_surface_event_parent_of (grab->surface, pointer_surface))
{
/* use the cursor from the grab surface */
cursor_surface = grab->surface;
}
else
{
/* otherwise use the cursor from the pointer surface */
cursor_surface = pointer_surface;
}
/* Find the first surface with the cursor actually set, as
the cursor is inherited from the parent */
while (cursor_surface->cursor == NULL &&
!g_hash_table_contains (cursor_surface->device_cursor, device) &&
(parent = cursor_surface->parent) != NULL)
cursor_surface = parent;
cursor = g_hash_table_lookup (cursor_surface->device_cursor, device);
if (!cursor)
cursor = cursor_surface->cursor;
/* Set all cursors on toplevel, otherwise its tricky to keep track of
* which native surface has what cursor set. */
toplevel = get_event_toplevel (pointer_surface);
GDK_DEVICE_GET_CLASS (device)->set_surface_cursor (device, toplevel, cursor);
}
static gboolean
point_in_surface (GdkSurface *surface,
gdouble x,
gdouble y)
{
return
x >= 0 && x < surface->width &&
y >= 0 && y < surface->height &&
(surface->input_shape == NULL ||
cairo_region_contains_point (surface->input_shape,
x, y));
}
/* Same as point_in_surface, except it also takes pass_through and its
interaction with child surfaces into account */
static gboolean
point_in_input_surface (GdkSurface *surface,
gdouble x,
gdouble y,
GdkSurface **input_surface,
gdouble *input_surface_x,
gdouble *input_surface_y)
{
GdkSurface *sub;
double child_x, child_y;
GList *l;
if (!point_in_surface (surface, x, y))
return FALSE;
if (!surface->pass_through)
{
if (input_surface)
{
*input_surface = surface;
*input_surface_x = x;
*input_surface_y = y;
}
return TRUE;
}
/* For pass-through, must be over a child input surface */
/* Children is ordered in reverse stack order, i.e. first is topmost */
for (l = surface->children; l != NULL; l = l->next)
{
sub = l->data;
if (!GDK_SURFACE_IS_MAPPED (sub))
continue;
gdk_surface_coords_from_parent ((GdkSurface *)sub,
x, y,
&child_x, &child_y);
if (point_in_input_surface (sub, child_x, child_y,
input_surface, input_surface_x, input_surface_y))
{
if (input_surface)
gdk_surface_coords_to_parent (sub,
*input_surface_x,
*input_surface_y,
input_surface_x,
input_surface_y);
return TRUE;
}
}
return FALSE;
}
GdkSurface *
_gdk_surface_find_child_at (GdkSurface *surface,
double x,
double y)
{
GdkSurface *sub;
double child_x, child_y;
GList *l;
if (point_in_surface (surface, x, y))
{
/* Children is ordered in reverse stack order, i.e. first is topmost */
for (l = surface->children; l != NULL; l = l->next)
{
sub = l->data;
if (!GDK_SURFACE_IS_MAPPED (sub))
continue;
gdk_surface_coords_from_parent ((GdkSurface *)sub,
x, y,
&child_x, &child_y);
if (point_in_input_surface (sub, child_x, child_y,
NULL, NULL, NULL))
return (GdkSurface *)sub;
}
}
return NULL;
}
GdkSurface *
_gdk_surface_find_descendant_at (GdkSurface *surface,
gdouble x,
gdouble y,
gdouble *found_x,
gdouble *found_y)
{
GdkSurface *sub, *input_surface;
gdouble child_x, child_y;
GList *l;
gboolean found;
if (point_in_surface (surface, x, y))
{
do
{
found = FALSE;
/* Children is ordered in reverse stack order, i.e. first is topmost */
for (l = surface->children; l != NULL; l = l->next)
{
sub = l->data;
if (!GDK_SURFACE_IS_MAPPED (sub))
continue;
gdk_surface_coords_from_parent ((GdkSurface *)sub,
x, y,
&child_x, &child_y);
if (point_in_input_surface (sub, child_x, child_y,
&input_surface, &child_x, &child_y))
{
x = child_x;
y = child_y;
surface = input_surface;
found = TRUE;
break;
}
}
}
while (found);
}
else
{
/* Not in surface at all */
surface = NULL;
}
if (found_x)
*found_x = x;
if (found_y)
*found_y = y;
return surface;
}
/**
* gdk_surface_beep:
* @surface: a toplevel #GdkSurface
*
* Emits a short beep associated to @surface in the appropriate
* display, if supported. Otherwise, emits a short beep on
* the display just as gdk_display_beep().
**/
void
gdk_surface_beep (GdkSurface *surface)
{
GdkDisplay *display;
GdkSurface *toplevel;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
return;
toplevel = get_event_toplevel (surface);
display = gdk_surface_get_display (surface);
if (toplevel)
{
if (GDK_SURFACE_IMPL_GET_CLASS (toplevel->impl)->beep (toplevel))
return;
}
/* If surfaces fail to beep, we beep the display. */
gdk_display_beep (display);
}
/**
* gdk_surface_set_support_multidevice:
* @surface: a #GdkSurface.
* @support_multidevice: %TRUE to enable multidevice support in @surface.
*
* This function will enable multidevice features in @surface.
*
* Multidevice aware surfaces will need to handle properly multiple,
* per device enter/leave events, device grabs and grab ownerships.
**/
void
gdk_surface_set_support_multidevice (GdkSurface *surface,
gboolean support_multidevice)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (GDK_SURFACE_DESTROYED (surface))
return;
if (surface->support_multidevice == support_multidevice)
return;
surface->support_multidevice = support_multidevice;
/* FIXME: What to do if called when some pointers are inside the surface ? */
}
/**
* gdk_surface_get_support_multidevice:
* @surface: a #GdkSurface.
*
* Returns %TRUE if the surface is aware of the existence of multiple
* devices.
*
* Returns: %TRUE if the surface handles multidevice features.
**/
gboolean
gdk_surface_get_support_multidevice (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
if (GDK_SURFACE_DESTROYED (surface))
return FALSE;
return surface->support_multidevice;
}
/* send motion events if the right buttons are down */
GdkEvent *
_gdk_make_event (GdkSurface *surface,
GdkEventType type,
GdkEvent *event_in_queue,
gboolean before_event)
{
GdkEvent *event = gdk_event_new (type);
guint32 the_time;
GdkModifierType the_state;
the_time = gdk_event_get_time (event_in_queue);
gdk_event_get_state (event_in_queue, &the_state);
event->any.surface = g_object_ref (surface);
event->any.send_event = FALSE;
if (event_in_queue && event_in_queue->any.send_event)
event->any.send_event = TRUE;
switch ((guint) type)
{
case GDK_MOTION_NOTIFY:
event->motion.time = the_time;
event->motion.axes = NULL;
event->motion.state = the_state;
break;
case GDK_BUTTON_PRESS:
case GDK_BUTTON_RELEASE:
event->button.time = the_time;
event->button.axes = NULL;
event->button.state = the_state;
break;
case GDK_TOUCH_BEGIN:
case GDK_TOUCH_UPDATE:
case GDK_TOUCH_END:
case GDK_TOUCH_CANCEL:
event->touch.time = the_time;
event->touch.axes = NULL;
event->touch.state = the_state;
break;
case GDK_SCROLL:
event->scroll.time = the_time;
event->scroll.state = the_state;
break;
case GDK_KEY_PRESS:
case GDK_KEY_RELEASE:
event->key.time = the_time;
event->key.state = the_state;
break;
case GDK_ENTER_NOTIFY:
case GDK_LEAVE_NOTIFY:
event->crossing.time = the_time;
event->crossing.state = the_state;
break;
case GDK_PROXIMITY_IN:
case GDK_PROXIMITY_OUT:
event->proximity.time = the_time;
break;
case GDK_DRAG_ENTER:
case GDK_DRAG_LEAVE:
case GDK_DRAG_MOTION:
case GDK_DROP_START:
event->dnd.time = the_time;
break;
case GDK_TOUCHPAD_SWIPE:
event->touchpad_swipe.time = the_time;
event->touchpad_swipe.state = the_state;
break;
case GDK_TOUCHPAD_PINCH:
event->touchpad_pinch.time = the_time;
event->touchpad_pinch.state = the_state;
break;
case GDK_FOCUS_CHANGE:
case GDK_CONFIGURE:
case GDK_MAP:
case GDK_UNMAP:
case GDK_DELETE:
case GDK_DESTROY:
case GDK_EXPOSE:
default:
break;
}
if (event_in_queue)
{
if (before_event)
_gdk_event_queue_insert_before (gdk_surface_get_display (surface), event_in_queue, event);
else
_gdk_event_queue_insert_after (gdk_surface_get_display (surface), event_in_queue, event);
}
else
_gdk_event_queue_append (gdk_surface_get_display (surface), event);
return event;
}
void
_gdk_display_set_surface_under_pointer (GdkDisplay *display,
GdkDevice *device,
GdkSurface *surface)
{
GdkPointerSurfaceInfo *device_info;
device_info = _gdk_display_get_pointer_info (display, device);
if (device_info->surface_under_pointer)
g_object_unref (device_info->surface_under_pointer);
device_info->surface_under_pointer = surface;
if (surface)
{
g_object_ref (surface);
update_cursor (display, device);
}
}
#define GDK_ANY_BUTTON_MASK (GDK_BUTTON1_MASK | \
GDK_BUTTON2_MASK | \
GDK_BUTTON3_MASK | \
GDK_BUTTON4_MASK | \
GDK_BUTTON5_MASK)
#ifdef DEBUG_SURFACE_PRINTING
#ifdef GDK_WINDOWING_X11
#include "x11/gdkx.h"
#endif
static void
gdk_surface_print (GdkSurface *surface,
int indent)
{
char *s;
const char *surface_types[] = {
"root",
"toplevel",
"child",
"dialog",
"temp",
"foreign",
"subsurface"
};
g_print ("%*s%p: [%s] %d,%d %dx%d", indent, "", surface,
surface->user_data ? g_type_name_from_instance (surface->user_data) : "no widget",
surface->x, surface->y,
surface->width, surface->height
);
if (gdk_surface_has_impl (surface))
{
#ifdef GDK_WINDOWING_X11
g_print (" impl(0x%lx)", gdk_x11_surface_get_xid (window));
#endif
}
if (surface->surface_type != GDK_SURFACE_CHILD)
g_print (" %s", surface_types[surface->surface_type]);
if (surface->input_only)
g_print (" input-only");
if (!gdk_surface_is_visible ((GdkSurface *)surface))
g_print (" hidden");
g_print (" abs[%d,%d]",
surface->abs_x, surface->abs_y);
if (surface->alpha != 255)
g_print (" alpha[%d]",
surface->alpha);
s = print_region (surface->clip_region);
g_print (" clipbox[%s]", s);
g_print ("\n");
}
static void
gdk_surface_print_tree (GdkSurface *surface,
int indent,
gboolean include_input_only)
{
GList *l;
if (surface->input_only && !include_input_only)
return;
gdk_surface_print (surface, indent);
for (l = surface->children; l != NULL; l = l->next)
gdk_surface_print_tree (l->data, indent + 4, include_input_only);
}
#endif /* DEBUG_SURFACE_PRINTING */
void
_gdk_windowing_got_event (GdkDisplay *display,
GList *event_link,
GdkEvent *event,
gulong serial)
{
GdkSurface *event_surface;
gboolean unlink_event = FALSE;
GdkDeviceGrabInfo *button_release_grab;
GdkPointerSurfaceInfo *pointer_info = NULL;
GdkDevice *device, *source_device;
_gdk_display_update_last_event (display, event);
device = gdk_event_get_device (event);
source_device = gdk_event_get_source_device (event);
if (device)
{
if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD &&
gdk_device_get_source (device) != GDK_SOURCE_TABLET_PAD)
{
pointer_info = _gdk_display_get_pointer_info (display, device);
if (source_device != pointer_info->last_slave &&
gdk_device_get_device_type (source_device) == GDK_DEVICE_TYPE_SLAVE)
pointer_info->last_slave = source_device;
else if (pointer_info->last_slave)
source_device = pointer_info->last_slave;
}
_gdk_display_device_grab_update (display, device, source_device, serial);
if (gdk_device_get_input_mode (device) == GDK_MODE_DISABLED ||
!_gdk_display_check_grab_ownership (display, device, serial))
{
/* Device events are blocked by another
* device grab, or the device is disabled
*/
unlink_event = TRUE;
goto out;
}
}
event_surface = event->any.surface;
if (!event_surface)
goto out;
#ifdef DEBUG_SURFACE_PRINTING
if (event->any.type == GDK_KEY_PRESS &&
(event->key.keyval == 0xa7 ||
event->key.keyval == 0xbd))
{
gdk_surface_print_tree (event_surface, 0, event->key.keyval == 0xbd);
}
#endif
if (event->any.type == GDK_ENTER_NOTIFY)
_gdk_display_set_surface_under_pointer (display, device, event_surface);
else if (event->any.type == GDK_LEAVE_NOTIFY)
_gdk_display_set_surface_under_pointer (display, device, NULL);
if ((event->any.type == GDK_BUTTON_RELEASE ||
event->any.type == GDK_TOUCH_CANCEL ||
event->any.type == GDK_TOUCH_END) &&
!event->any.send_event)
{
if (event->any.type == GDK_BUTTON_RELEASE ||
gdk_event_get_pointer_emulated (event))
{
button_release_grab =
_gdk_display_has_device_grab (display, device, serial);
if (button_release_grab &&
button_release_grab->implicit &&
(event->button.state & GDK_ANY_BUTTON_MASK & ~(GDK_BUTTON1_MASK << (event->button.button - 1))) == 0)
{
button_release_grab->serial_end = serial;
button_release_grab->implicit_ungrab = FALSE;
_gdk_display_device_grab_update (display, device, source_device, serial);
}
}
}
out:
if (unlink_event)
{
_gdk_event_queue_remove_link (display, event_link);
g_list_free_1 (event_link);
gdk_event_free (event);
}
/* This does two things - first it sees if there are motions at the
* end of the queue that can be compressed. Second, if there is just
* a single motion that won't be dispatched because it is a compression
* candidate it queues up flushing the event queue.
*/
_gdk_event_queue_handle_motion_compression (display);
}
/**
* gdk_surface_create_similar_surface:
* @surface: surface to make new surface similar to
* @content: the content for the new surface
* @width: width of the new surface
* @height: height of the new surface
*
* Create a new surface that is as compatible as possible with the
* given @surface. For example the new surface will have the same
* fallback resolution and font options as @surface. Generally, the new
* surface will also use the same backend as @surface, unless that is
* not possible for some reason. The type of the returned surface may
* be examined with cairo_surface_get_type().
*
* Initially the surface contents are all 0 (transparent if contents
* have transparency, black otherwise.)
*
* Returns: a pointer to the newly allocated surface. The caller
* owns the surface and should call cairo_surface_destroy() when done
* with it.
*
* This function always returns a valid pointer, but it will return a
* pointer to a “nil” surface if @other is already in an error state
* or any other error occurs.
**/
cairo_surface_t *
gdk_surface_create_similar_surface (GdkSurface * surface,
cairo_content_t content,
int width,
int height)
{
cairo_surface_t *similar_surface;
int scale;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
scale = gdk_surface_get_scale_factor (surface);
similar_surface = cairo_image_surface_create (content == CAIRO_CONTENT_COLOR ? CAIRO_FORMAT_RGB24 :
content == CAIRO_CONTENT_ALPHA ? CAIRO_FORMAT_A8 : CAIRO_FORMAT_ARGB32,
width * scale, height * scale);
cairo_surface_set_device_scale (similar_surface, scale, scale);
return similar_surface;
}
/**
* gdk_surface_focus:
* @surface: a #GdkSurface
* @timestamp: timestamp of the event triggering the surface focus
*
* Sets keyboard focus to @surface. In most cases, gtk_window_present()
* should be used on a #GtkWindow, rather than calling this function.
*
**/
void
gdk_surface_focus (GdkSurface *surface,
guint32 timestamp)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->focus (surface, timestamp);
}
/**
* gdk_surface_set_type_hint:
* @surface: A toplevel #GdkSurface
* @hint: A hint of the function this surface will have
*
* The application can use this call to provide a hint to the surface
* manager about the functionality of a surface. The window manager
* can use this information when determining the decoration and behaviour
* of the surface.
*
* The hint must be set before the surface is mapped.
**/
void
gdk_surface_set_type_hint (GdkSurface *surface,
GdkSurfaceTypeHint hint)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_type_hint (surface, hint);
}
/**
* gdk_surface_get_type_hint:
* @surface: A toplevel #GdkSurface
*
* This function returns the type hint set for a surface.
*
* Returns: The type hint set for @surface
**/
GdkSurfaceTypeHint
gdk_surface_get_type_hint (GdkSurface *surface)
{
return GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->get_type_hint (surface);
}
/**
* gdk_surface_set_modal_hint:
* @surface: A toplevel #GdkSurface
* @modal: %TRUE if the surface is modal, %FALSE otherwise.
*
* The application can use this hint to tell the window manager
* that a certain surface has modal behaviour. The window manager
* can use this information to handle modal surfaces in a special
* way.
*
* You should only use this on surfaces for which you have
* previously called gdk_surface_set_transient_for()
**/
void
gdk_surface_set_modal_hint (GdkSurface *surface,
gboolean modal)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_modal_hint (surface, modal);
}
/**
* gdk_surface_set_skip_taskbar_hint:
* @surface: a toplevel #GdkSurface
* @skips_taskbar: %TRUE to skip the taskbar
*
* Toggles whether a surface should appear in a task list or surface
* list. If a surface’s semantic type as specified with
* gdk_surface_set_type_hint() already fully describes the surface, this
* function should not be called in addition,
* instead you should allow the surface to be treated according to
* standard policy for its semantic type.
**/
void
gdk_surface_set_skip_taskbar_hint (GdkSurface *surface,
gboolean skips_taskbar)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_skip_taskbar_hint (surface, skips_taskbar);
}
/**
* gdk_surface_set_skip_pager_hint:
* @surface: a toplevel #GdkSurface
* @skips_pager: %TRUE to skip the pager
*
* Toggles whether a surface should appear in a pager (workspace
* switcher, or other desktop utility program that displays a small
* thumbnail representation of the surfaces on the desktop). If a
* surface’s semantic type as specified with gdk_surface_set_type_hint()
* already fully describes the surface, this function should
* not be called in addition, instead you should
* allow the surface to be treated according to standard policy for
* its semantic type.
**/
void
gdk_surface_set_skip_pager_hint (GdkSurface *surface,
gboolean skips_pager)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_skip_pager_hint (surface, skips_pager);
}
/**
* gdk_surface_set_urgency_hint:
* @surface: a toplevel #GdkSurface
* @urgent: %TRUE if the surface is urgent
*
* Toggles whether a surface needs the user's
* urgent attention.
**/
void
gdk_surface_set_urgency_hint (GdkSurface *surface,
gboolean urgent)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_urgency_hint (surface, urgent);
}
/**
* gdk_surface_set_geometry_hints:
* @surface: a toplevel #GdkSurface
* @geometry: geometry hints
* @geom_mask: bitmask indicating fields of @geometry to pay attention to
*
* Sets the geometry hints for @surface. Hints flagged in @geom_mask
* are set, hints not flagged in @geom_mask are unset.
* To unset all hints, use a @geom_mask of 0 and a @geometry of %NULL.
*
* This function provides hints to the surfaceing system about
* acceptable sizes for a toplevel surface. The purpose of
* this is to constrain user resizing, but the windowing system
* will typically (but is not required to) also constrain the
* current size of the surface to the provided values and
* constrain programatic resizing via gdk_surface_resize() or
* gdk_surface_move_resize().
*
* Note that on X11, this effect has no effect on surfaces
* of type %GDK_SURFACE_TEMP since these surfaces are not resizable
* by the user.
*
* Since you can’t count on the windowing system doing the
* constraints for programmatic resizes, you should generally
* call gdk_surface_constrain_size() yourself to determine
* appropriate sizes.
*
**/
void
gdk_surface_set_geometry_hints (GdkSurface *surface,
const GdkGeometry *geometry,
GdkSurfaceHints geom_mask)
{
g_return_if_fail (geometry != NULL || geom_mask == 0);
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_geometry_hints (surface, geometry, geom_mask);
}
/**
* gdk_surface_set_title:
* @surface: a toplevel #GdkSurface
* @title: title of @surface
*
* Sets the title of a toplevel surface, to be displayed in the titlebar.
* If you haven’t explicitly set the icon name for the surface
* (using gdk_surface_set_icon_name()), the icon name will be set to
* @title as well. @title must be in UTF-8 encoding (as with all
* user-readable strings in GDK/GTK+). @title may not be %NULL.
**/
void
gdk_surface_set_title (GdkSurface *surface,
const gchar *title)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_title (surface, title);
}
/**
* gdk_surface_set_role:
* @surface: a toplevel #GdkSurface
* @role: a string indicating its role
*
* When using GTK+, typically you should use gtk_window_set_role() instead
* of this low-level function.
*
* The window manager and session manager use a surface’s role to
* distinguish it from other kinds of surface in the same application.
* When an application is restarted after being saved in a previous
* session, all surfaces with the same title and role are treated as
* interchangeable. So if you have two surfaces with the same title
* that should be distinguished for session management purposes, you
* should set the role on those surfaces. It doesn’t matter what string
* you use for the role, as long as you have a different role for each
* non-interchangeable kind of surface.
*
**/
void
gdk_surface_set_role (GdkSurface *surface,
const gchar *role)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_role (surface, role);
}
/**
* gdk_surface_set_startup_id:
* @surface: a toplevel #GdkSurface
* @startup_id: a string with startup-notification identifier
*
* When using GTK+, typically you should use gtk_window_set_startup_id()
* instead of this low-level function.
**/
void
gdk_surface_set_startup_id (GdkSurface *surface,
const gchar *startup_id)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_startup_id (surface, startup_id);
}
/**
* gdk_surface_set_transient_for:
* @surface: a toplevel #GdkSurface
* @parent: another toplevel #GdkSurface
*
* Indicates to the window manager that @surface is a transient dialog
* associated with the application surface @parent. This allows the
* window manager to do things like center @surface on @parent and
* keep @surface above @parent.
*
* See gtk_window_set_transient_for() if you’re using #GtkWindow or
* #GtkDialog.
**/
void
gdk_surface_set_transient_for (GdkSurface *surface,
GdkSurface *parent)
{
surface->transient_for = parent;
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_transient_for (surface, parent);
}
/**
* gdk_surface_get_root_origin:
* @surface: a toplevel #GdkSurface
* @x: (out): return location for X position of surface frame
* @y: (out): return location for Y position of surface frame
*
* Obtains the top-left corner of the surface manager frame in root
* surface coordinates.
*
**/
void
gdk_surface_get_root_origin (GdkSurface *surface,
gint *x,
gint *y)
{
GdkRectangle rect;
gdk_surface_get_frame_extents (surface, &rect);
if (x)
*x = rect.x;
if (y)
*y = rect.y;
}
/**
* gdk_surface_get_frame_extents:
* @surface: a toplevel #GdkSurface
* @rect: (out): rectangle to fill with bounding box of the surface frame
*
* Obtains the bounding box of the surface, including window manager
* titlebar/borders if any. The frame position is given in root window
* coordinates. To get the position of the surface itself (rather than
* the frame) in root window coordinates, use gdk_surface_get_origin().
*
**/
void
gdk_surface_get_frame_extents (GdkSurface *surface,
GdkRectangle *rect)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->get_frame_extents (surface, rect);
}
/**
* gdk_surface_set_accept_focus:
* @surface: a toplevel #GdkSurface
* @accept_focus: %TRUE if the surface should receive input focus
*
* Setting @accept_focus to %FALSE hints the desktop environment that the
* surface doesn’t want to receive input focus.
*
* On X, it is the responsibility of the window manager to interpret this
* hint. ICCCM-compliant window manager usually respect it.
**/
void
gdk_surface_set_accept_focus (GdkSurface *surface,
gboolean accept_focus)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_accept_focus (surface, accept_focus);
}
/**
* gdk_surface_set_focus_on_map:
* @surface: a toplevel #GdkSurface
* @focus_on_map: %TRUE if the surface should receive input focus when mapped
*
* Setting @focus_on_map to %FALSE hints the desktop environment that the
* surface doesn’t want to receive input focus when it is mapped.
* focus_on_map should be turned off for surfaces that aren’t triggered
* interactively (such as popups from network activity).
*
* On X, it is the responsibility of the window manager to interpret
* this hint. Window managers following the freedesktop.org window
* manager extension specification should respect it.
**/
void
gdk_surface_set_focus_on_map (GdkSurface *surface,
gboolean focus_on_map)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_focus_on_map (surface, focus_on_map);
}
/**
* gdk_surface_set_icon_list:
* @surface: The #GdkSurface toplevel surface to set the icon of.
* @surfaces: (transfer none) (element-type GdkTexture):
* A list of image surfaces, of different sizes.
*
* Sets a list of icons for the surface. One of these will be used
* to represent the surface when it has been iconified. The icon is
* usually shown in an icon box or some sort of task bar. Which icon
* size is shown depends on the window manager. The window manager
* can scale the icon but setting several size icons can give better
* image quality since the window manager may only need to scale the
* icon by a small amount or not at all.
*
* Note that some platforms don't support surface icons.
*/
void
gdk_surface_set_icon_list (GdkSurface *surface,
GList *textures)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_icon_list (surface, textures);
}
/**
* gdk_surface_set_icon_name:
* @surface: a toplevel #GdkSurface
* @name: (allow-none): name of surface while iconified (minimized)
*
* Surfaces may have a name used while minimized, distinct from the
* name they display in their titlebar. Most of the time this is a bad
* idea from a user interface standpoint. But you can set such a name
* with this function, if you like.
*
* After calling this with a non-%NULL @name, calls to gdk_surface_set_title()
* will not update the icon title.
*
* Using %NULL for @name unsets the icon title; further calls to
* gdk_surface_set_title() will again update the icon title as well.
*
* Note that some platforms don't support surface icons.
**/
void
gdk_surface_set_icon_name (GdkSurface *surface,
const gchar *name)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_icon_name (surface, name);
}
/**
* gdk_surface_iconify:
* @surface: a toplevel #GdkSurface
*
* Asks to iconify (minimize) @surface. The window manager may choose
* to ignore the request, but normally will honor it. Using
* gtk_window_iconify() is preferred, if you have a #GtkWindow widget.
*
* This function only makes sense when @surface is a toplevel surface.
*
**/
void
gdk_surface_iconify (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->iconify (surface);
}
/**
* gdk_surface_deiconify:
* @surface: a toplevel #GdkSurface
*
* Attempt to deiconify (unminimize) @surface. On X11 the window manager may
* choose to ignore the request to deiconify. When using GTK+,
* use gtk_window_deiconify() instead of the #GdkSurface variant. Or better yet,
* you probably want to use gtk_window_present(), which raises the surface, focuses it,
* unminimizes it, and puts it on the current desktop.
*
**/
void
gdk_surface_deiconify (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->deiconify (surface);
}
/**
* gdk_surface_stick:
* @surface: a toplevel #GdkSurface
*
* “Pins” a surface such that it’s on all workspaces and does not scroll
* with viewports, for window managers that have scrollable viewports.
* (When using #GtkWindow, gtk_window_stick() may be more useful.)
*
* On the X11 platform, this function depends on window manager
* support, so may have no effect with many window managers. However,
* GDK will do the best it can to convince the window manager to stick
* the surface. For window managers that don’t support this operation,
* there’s nothing you can do to force it to happen.
*
**/
void
gdk_surface_stick (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->stick (surface);
}
/**
* gdk_surface_unstick:
* @surface: a toplevel #GdkSurface
*
* Reverse operation for gdk_surface_stick(); see gdk_surface_stick(),
* and gtk_window_unstick().
*
**/
void
gdk_surface_unstick (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->unstick (surface);
}
/**
* gdk_surface_maximize:
* @surface: a toplevel #GdkSurface
*
* Maximizes the surface. If the surface was already maximized, then
* this function does nothing.
*
* On X11, asks the window manager to maximize @surface, if the window
* manager supports this operation. Not all window managers support
* this, and some deliberately ignore it or don’t have a concept of
* “maximized”; so you can’t rely on the maximization actually
* happening. But it will happen with most standard window managers,
* and GDK makes a best effort to get it to happen.
*
* On Windows, reliably maximizes the surface.
*
**/
void
gdk_surface_maximize (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->maximize (surface);
}
/**
* gdk_surface_unmaximize:
* @surface: a toplevel #GdkSurface
*
* Unmaximizes the surface. If the surface wasn’t maximized, then this
* function does nothing.
*
* On X11, asks the window manager to unmaximize @surface, if the
* window manager supports this operation. Not all window managers
* support this, and some deliberately ignore it or don’t have a
* concept of “maximized”; so you can’t rely on the unmaximization
* actually happening. But it will happen with most standard window
* managers, and GDK makes a best effort to get it to happen.
*
* On Windows, reliably unmaximizes the surface.
*
**/
void
gdk_surface_unmaximize (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->unmaximize (surface);
}
/**
* gdk_surface_fullscreen:
* @surface: a toplevel #GdkSurface
*
* Moves the surface into fullscreen mode. This means the
* surface covers the entire screen and is above any panels
* or task bars.
*
* If the surface was already fullscreen, then this function does nothing.
*
* On X11, asks the window manager to put @surface in a fullscreen
* state, if the window manager supports this operation. Not all
* window managers support this, and some deliberately ignore it or
* don’t have a concept of “fullscreen”; so you can’t rely on the
* fullscreenification actually happening. But it will happen with
* most standard window managers, and GDK makes a best effort to get
* it to happen.
**/
void
gdk_surface_fullscreen (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->fullscreen (surface);
}
/**
* gdk_surface_fullscreen_on_monitor:
* @surface: a toplevel #GdkSurface
* @monitor: Which monitor to display fullscreen on.
*
* Moves the surface into fullscreen mode on the given monitor. This means
* the surface covers the entire screen and is above any panels or task bars.
*
* If the surface was already fullscreen, then this function does nothing.
**/
void
gdk_surface_fullscreen_on_monitor (GdkSurface *surface,
GdkMonitor *monitor)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (GDK_IS_MONITOR (monitor));
g_return_if_fail (gdk_monitor_get_display (monitor) == gdk_surface_get_display (surface));
g_return_if_fail (gdk_monitor_is_valid (monitor));
if (GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->fullscreen_on_monitor != NULL)
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->fullscreen_on_monitor (surface, monitor);
else
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->fullscreen (surface);
}
/**
* gdk_surface_set_fullscreen_mode:
* @surface: a toplevel #GdkSurface
* @mode: fullscreen mode
*
* Specifies whether the @surface should span over all monitors (in a multi-head
* setup) or only the current monitor when in fullscreen mode.
*
* The @mode argument is from the #GdkFullscreenMode enumeration.
* If #GDK_FULLSCREEN_ON_ALL_MONITORS is specified, the fullscreen @surface will
* span over all monitors of the display.
*
* On X11, searches through the list of monitors display the ones
* which delimit the 4 edges of the entire display and will ask the window
* manager to span the @surface over these monitors.
*
* If the XINERAMA extension is not available or not usable, this function
* has no effect.
*
* Not all window managers support this, so you can’t rely on the fullscreen
* surface to span over the multiple monitors when #GDK_FULLSCREEN_ON_ALL_MONITORS
* is specified.
**/
void
gdk_surface_set_fullscreen_mode (GdkSurface *surface,
GdkFullscreenMode mode)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->fullscreen_mode != mode)
{
surface->fullscreen_mode = mode;
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->apply_fullscreen_mode != NULL)
impl_class->apply_fullscreen_mode (surface);
}
}
/**
* gdk_surface_get_fullscreen_mode:
* @surface: a toplevel #GdkSurface
*
* Obtains the #GdkFullscreenMode of the @surface.
*
* Returns: The #GdkFullscreenMode applied to the surface when fullscreen.
**/
GdkFullscreenMode
gdk_surface_get_fullscreen_mode (GdkSurface *surface)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), GDK_FULLSCREEN_ON_CURRENT_MONITOR);
return surface->fullscreen_mode;
}
/**
* gdk_surface_unfullscreen:
* @surface: a toplevel #GdkSurface
*
* Moves the surface out of fullscreen mode. If the surface was not
* fullscreen, does nothing.
*
* On X11, asks the window manager to move @surface out of the fullscreen
* state, if the window manager supports this operation. Not all
* window managers support this, and some deliberately ignore it or
* don’t have a concept of “fullscreen”; so you can’t rely on the
* unfullscreenification actually happening. But it will happen with
* most standard window managers, and GDK makes a best effort to get
* it to happen.
**/
void
gdk_surface_unfullscreen (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->unfullscreen (surface);
}
/**
* gdk_surface_set_keep_above:
* @surface: a toplevel #GdkSurface
* @setting: whether to keep @surface above other surfaces
*
* Set if @surface must be kept above other surfaces. If the
* surface was already above, then this function does nothing.
*
* On X11, asks the window manager to keep @surface above, if the window
* manager supports this operation. Not all window managers support
* this, and some deliberately ignore it or don’t have a concept of
* “keep above”; so you can’t rely on the surface being kept above.
* But it will happen with most standard window managers,
* and GDK makes a best effort to get it to happen.
**/
void
gdk_surface_set_keep_above (GdkSurface *surface,
gboolean setting)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_keep_above (surface, setting);
}
/**
* gdk_surface_set_keep_below:
* @surface: a toplevel #GdkSurface
* @setting: whether to keep @surface below other surfaces
*
* Set if @surface must be kept below other surfaces. If the
* surface was already below, then this function does nothing.
*
* On X11, asks the window manager to keep @surface below, if the window
* manager supports this operation. Not all window managers support
* this, and some deliberately ignore it or don’t have a concept of
* “keep below”; so you can’t rely on the surface being kept below.
* But it will happen with most standard window managers,
* and GDK makes a best effort to get it to happen.
**/
void
gdk_surface_set_keep_below (GdkSurface *surface,
gboolean setting)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_keep_below (surface, setting);
}
/**
* gdk_surface_get_group:
* @surface: a toplevel #GdkSurface
*
* Returns the group leader surface for @surface. See gdk_surface_set_group().
*
* Returns: (transfer none): the group leader surface for @surface
**/
GdkSurface *
gdk_surface_get_group (GdkSurface *surface)
{
return GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->get_group (surface);
}
/**
* gdk_surface_set_group:
* @surface: a toplevel #GdkSurface
* @leader: (allow-none): group leader surface, or %NULL to restore the default group leader surface
*
* Sets the group leader surface for @surface. By default,
* GDK sets the group leader for all toplevel surfaces
* to a global surface implicitly created by GDK. With this function
* you can override this default.
*
* The group leader surface allows the window manager to distinguish
* all surfaces that belong to a single application. It may for example
* allow users to minimize/unminimize all surfaces belonging to an
* application at once. You should only set a non-default group surface
* if your application pretends to be multiple applications.
**/
void
gdk_surface_set_group (GdkSurface *surface,
GdkSurface *leader)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_group (surface, leader);
}
/**
* gdk_surface_set_decorations:
* @surface: a toplevel #GdkSurface
* @decorations: decoration hint mask
*
* “Decorations” are the features the window manager adds to a toplevel #GdkSurface.
* This function sets the traditional Motif window manager hints that tell the
* window manager which decorations you would like your surface to have.
* Usually you should use gtk_window_set_decorated() on a #GtkWindow instead of
* using the GDK function directly.
*
* The @decorations argument is the logical OR of the fields in
* the #GdkWMDecoration enumeration. If #GDK_DECOR_ALL is included in the
* mask, the other bits indicate which decorations should be turned off.
* If #GDK_DECOR_ALL is not included, then the other bits indicate
* which decorations should be turned on.
*
* Most window managers honor a decorations hint of 0 to disable all decorations,
* but very few honor all possible combinations of bits.
*
**/
void
gdk_surface_set_decorations (GdkSurface *surface,
GdkWMDecoration decorations)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_decorations (surface, decorations);
}
/**
* gdk_surface_get_decorations:
* @surface: The toplevel #GdkSurface to get the decorations from
* @decorations: (out): The surface decorations will be written here
*
* Returns the decorations set on the GdkSurface with
* gdk_surface_set_decorations().
*
* Returns: %TRUE if the surface has decorations set, %FALSE otherwise.
**/
gboolean
gdk_surface_get_decorations (GdkSurface *surface,
GdkWMDecoration *decorations)
{
return GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->get_decorations (surface, decorations);
}
/**
* gdk_surface_set_functions:
* @surface: a toplevel #GdkSurface
* @functions: bitmask of operations to allow on @surface
*
* Sets hints about the window management functions to make available
* via buttons on the window frame.
*
* On the X backend, this function sets the traditional Motif window
* manager hint for this purpose. However, few window managers do
* anything reliable or interesting with this hint. Many ignore it
* entirely.
*
* The @functions argument is the logical OR of values from the
* #GdkWMFunction enumeration. If the bitmask includes #GDK_FUNC_ALL,
* then the other bits indicate which functions to disable; if
* it doesn’t include #GDK_FUNC_ALL, it indicates which functions to
* enable.
*
**/
void
gdk_surface_set_functions (GdkSurface *surface,
GdkWMFunction functions)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_functions (surface, functions);
}
/**
* gdk_surface_begin_resize_drag_for_device:
* @surface: a toplevel #GdkSurface
* @edge: the edge or corner from which the drag is started
* @device: the device used for the operation
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
*
* Begins a surface resize operation (for a toplevel surface).
* You might use this function to implement a “window resize grip,” for
* example; in fact #GtkStatusbar uses it. The function works best
* with window managers that support the
* [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
* but has a fallback implementation for other window managers.
*/
void
gdk_surface_begin_resize_drag_for_device (GdkSurface *surface,
GdkSurfaceEdge edge,
GdkDevice *device,
gint button,
gint root_x,
gint root_y,
guint32 timestamp)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->begin_resize_drag (surface, edge, device, button, root_x, root_y, timestamp);
}
/**
* gdk_surface_begin_resize_drag:
* @surface: a toplevel #GdkSurface
* @edge: the edge or corner from which the drag is started
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag (use gdk_event_get_time())
*
* Begins a surface resize operation (for a toplevel surface).
*
* This function assumes that the drag is controlled by the
* client pointer device, use gdk_surface_begin_resize_drag_for_device()
* to begin a drag with a different device.
*/
void
gdk_surface_begin_resize_drag (GdkSurface *surface,
GdkSurfaceEdge edge,
gint button,
gint root_x,
gint root_y,
guint32 timestamp)
{
GdkDisplay *display;
GdkDevice *device;
display = gdk_surface_get_display (surface);
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_surface_begin_resize_drag_for_device (surface, edge,
device, button, root_x, root_y, timestamp);
}
/**
* gdk_surface_begin_move_drag_for_device:
* @surface: a toplevel #GdkSurface
* @device: the device used for the operation
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag
*
* Begins a surface move operation (for a toplevel surface).
* You might use this function to implement a “window move grip,” for
* example. The function works best with window managers that support the
* [Extended Window Manager Hints](http://www.freedesktop.org/Standards/wm-spec)
* but has a fallback implementation for other window managers.
*/
void
gdk_surface_begin_move_drag_for_device (GdkSurface *surface,
GdkDevice *device,
gint button,
gint root_x,
gint root_y,
guint32 timestamp)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->begin_move_drag (surface,
device, button, root_x, root_y, timestamp);
}
/**
* gdk_surface_begin_move_drag:
* @surface: a toplevel #GdkSurface
* @button: the button being used to drag, or 0 for a keyboard-initiated drag
* @root_x: root window X coordinate of mouse click that began the drag
* @root_y: root window Y coordinate of mouse click that began the drag
* @timestamp: timestamp of mouse click that began the drag
*
* Begins a surface move operation (for a toplevel surface).
*
* This function assumes that the drag is controlled by the
* client pointer device, use gdk_surface_begin_move_drag_for_device()
* to begin a drag with a different device.
*/
void
gdk_surface_begin_move_drag (GdkSurface *surface,
gint button,
gint root_x,
gint root_y,
guint32 timestamp)
{
GdkDisplay *display;
GdkDevice *device;
display = gdk_surface_get_display (surface);
device = gdk_seat_get_pointer (gdk_display_get_default_seat (display));
gdk_surface_begin_move_drag_for_device (surface, device, button, root_x, root_y, timestamp);
}
/**
* gdk_surface_set_opacity:
* @surface: a top-level or non-native #GdkSurface
* @opacity: opacity
*
* Set @surface to render as partially transparent,
* with opacity 0 being fully transparent and 1 fully opaque. (Values
* of the opacity parameter are clamped to the [0,1] range.)
*
* For toplevel surfaces this depends on support from the windowing system
* that may not always be there. For instance, On X11, this works only on
* X screens with a compositing manager running. On Wayland, there is no
* per-surface opacity value that the compositor would apply. Instead, use
* `gdk_surface_set_opaque_region (surface, NULL)` to tell the compositor
* that the entire surface is (potentially) non-opaque, and draw your content
* with alpha, or use gtk_widget_set_opacity() to set an overall opacity
* for your widgets.
*
* Support for non-toplevel surfaces was added in 3.8.
*/
void
gdk_surface_set_opacity (GdkSurface *surface,
gdouble opacity)
{
if (opacity < 0)
opacity = 0;
else if (opacity > 1)
opacity = 1;
surface->alpha = round (opacity * 255);
if (surface->destroyed)
return;
if (gdk_surface_has_impl (surface))
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->set_opacity (surface, opacity);
else
{
recompute_visible_regions (surface, FALSE);
gdk_surface_invalidate_rect (surface, NULL);
}
}
/* This function is called when the XWindow is really gone.
*/
void
gdk_surface_destroy_notify (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->destroy_notify (surface);
}
/**
* gdk_surface_register_dnd:
* @surface: a #GdkSurface.
*
* Registers a surface as a potential drop destination.
*/
void
gdk_surface_register_dnd (GdkSurface *surface)
{
GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->register_dnd (surface);
}
/**
* gdk_drag_begin:
* @surface: the source surface for this drag
* @device: the device that controls this drag
* @content: (transfer none): the offered content
* @actions: the actions supported by this drag
* @dx: the x offset to @device's position where the drag nominally started
* @dy: the y offset to @device's position where the drag nominally started
*
* Starts a drag and creates a new drag context for it.
*
* This function is called by the drag source.
*
* Returns: (transfer full) (nullable): a newly created #GdkDragContext or
* %NULL on error.
*/
GdkDragContext *
gdk_drag_begin (GdkSurface *surface,
GdkDevice *device,
GdkContentProvider *content,
GdkDragAction actions,
gint dx,
gint dy)
{
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
g_return_val_if_fail (GDK_IS_DEVICE (device), NULL);
g_return_val_if_fail (gdk_surface_get_display (surface) == gdk_device_get_display (device), NULL);
g_return_val_if_fail (GDK_IS_CONTENT_PROVIDER (content), NULL);
return GDK_SURFACE_IMPL_GET_CLASS (surface->impl)->drag_begin (surface, device, content, actions, dx, dy);
}
static void
gdk_surface_flush_events (GdkFrameClock *clock,
void *data)
{
GdkSurface *surface;
GdkDisplay *display;
surface = GDK_SURFACE (data);
display = gdk_surface_get_display (surface);
_gdk_event_queue_flush (display);
_gdk_display_pause_events (display);
gdk_frame_clock_request_phase (clock, GDK_FRAME_CLOCK_PHASE_RESUME_EVENTS);
surface->frame_clock_events_paused = TRUE;
}
static void
gdk_surface_resume_events (GdkFrameClock *clock,
void *data)
{
GdkSurface *surface;
GdkDisplay *display;
surface = GDK_SURFACE (data);
display = gdk_surface_get_display (surface);
_gdk_display_unpause_events (display);
surface->frame_clock_events_paused = FALSE;
}
static void
gdk_surface_set_frame_clock (GdkSurface *surface,
GdkFrameClock *clock)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (clock == NULL || GDK_IS_FRAME_CLOCK (clock));
g_return_if_fail (clock == NULL || gdk_surface_is_toplevel (surface));
if (clock == surface->frame_clock)
return;
if (clock)
{
g_object_ref (clock);
g_signal_connect (G_OBJECT (clock),
"flush-events",
G_CALLBACK (gdk_surface_flush_events),
surface);
g_signal_connect (G_OBJECT (clock),
"paint",
G_CALLBACK (gdk_surface_paint_on_clock),
surface);
g_signal_connect (G_OBJECT (clock),
"resume-events",
G_CALLBACK (gdk_surface_resume_events),
surface);
}
if (surface->frame_clock)
{
if (surface->frame_clock_events_paused)
gdk_surface_resume_events (surface->frame_clock, G_OBJECT (surface));
g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
G_CALLBACK (gdk_surface_flush_events),
surface);
g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
G_CALLBACK (gdk_surface_paint_on_clock),
surface);
g_signal_handlers_disconnect_by_func (G_OBJECT (surface->frame_clock),
G_CALLBACK (gdk_surface_resume_events),
surface);
g_object_unref (surface->frame_clock);
}
surface->frame_clock = clock;
}
/**
* gdk_surface_get_frame_clock:
* @surface: surface to get frame clock for
*
* Gets the frame clock for the surface. The frame clock for a surface
* never changes unless the surface is reparented to a new toplevel
* surface.
*
* Returns: (transfer none): the frame clock
*/
GdkFrameClock*
gdk_surface_get_frame_clock (GdkSurface *surface)
{
GdkSurface *toplevel;
g_return_val_if_fail (GDK_IS_SURFACE (surface), NULL);
toplevel = gdk_surface_get_toplevel (surface);
return toplevel->frame_clock;
}
/**
* gdk_surface_get_scale_factor:
* @surface: surface to get scale factor for
*
* Returns the internal scale factor that maps from surface coordiantes
* to the actual device pixels. On traditional systems this is 1, but
* on very high density outputs this can be a higher value (often 2).
*
* A higher value means that drawing is automatically scaled up to
* a higher resolution, so any code doing drawing will automatically look
* nicer. However, if you are supplying pixel-based data the scale
* value can be used to determine whether to use a pixel resource
* with higher resolution data.
*
* The scale of a surface may change during runtime, if this happens
* a configure event will be sent to the toplevel surface.
*
* Returns: the scale factor
*/
gint
gdk_surface_get_scale_factor (GdkSurface *surface)
{
GdkSurfaceImplClass *impl_class;
g_return_val_if_fail (GDK_IS_SURFACE (surface), 1);
if (GDK_SURFACE_DESTROYED (surface))
return 1;
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->get_scale_factor)
return impl_class->get_scale_factor (surface);
return 1;
}
/* Returns the *real* unscaled size, which may be a fractional size
in surface scale coordinates. We need this to properly handle GL
coordinates which are y-flipped in the real coordinates. */
void
gdk_surface_get_unscaled_size (GdkSurface *surface,
int *unscaled_width,
int *unscaled_height)
{
GdkSurfaceImplClass *impl_class;
gint scale;
g_return_if_fail (GDK_IS_SURFACE (surface));
if (surface->impl_surface == surface)
{
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->get_unscaled_size)
{
impl_class->get_unscaled_size (surface, unscaled_width, unscaled_height);
return;
}
}
scale = gdk_surface_get_scale_factor (surface);
if (unscaled_width)
*unscaled_width = surface->width * scale;
if (unscaled_height)
*unscaled_height = surface->height * scale;
}
/**
* gdk_surface_set_opaque_region:
* @surface: a top-level or non-native #GdkSurface
* @region: (allow-none): a region, or %NULL
*
* For optimisation purposes, compositing window managers may
* like to not draw obscured regions of surfaces, or turn off blending
* during for these regions. With RGB windows with no transparency,
* this is just the shape of the window, but with ARGB32 windows, the
* compositor does not know what regions of the window are transparent
* or not.
*
* This function only works for toplevel surfaces.
*
* GTK+ will update this property automatically if
* the @surface background is opaque, as we know where the opaque regions
* are. If your surface background is not opaque, please update this
* property in your #GtkWidget::style-updated handler.
*/
void
gdk_surface_set_opaque_region (GdkSurface *surface,
cairo_region_t *region)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (!GDK_SURFACE_DESTROYED (surface));
if (cairo_region_equal (surface->opaque_region, region))
return;
g_clear_pointer (&surface->opaque_region, cairo_region_destroy);
if (region != NULL)
surface->opaque_region = cairo_region_reference (region);
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->set_opaque_region)
impl_class->set_opaque_region (surface, region);
}
/**
* gdk_surface_set_shadow_width:
* @surface: a #GdkSurface
* @left: The left extent
* @right: The right extent
* @top: The top extent
* @bottom: The bottom extent
*
* Newer GTK+ windows using client-side decorations use extra geometry
* around their frames for effects like shadows and invisible borders.
* Window managers that want to maximize windows or snap to edges need
* to know where the extents of the actual frame lie, so that users
* don’t feel like windows are snapping against random invisible edges.
*
* Note that this property is automatically updated by GTK+, so this
* function should only be used by applications which do not use GTK+
* to create toplevel surfaces.
*/
void
gdk_surface_set_shadow_width (GdkSurface *surface,
gint left,
gint right,
gint top,
gint bottom)
{
GdkSurfaceImplClass *impl_class;
g_return_if_fail (GDK_IS_SURFACE (surface));
g_return_if_fail (!GDK_SURFACE_DESTROYED (surface));
g_return_if_fail (left >= 0 && right >= 0 && top >= 0 && bottom >= 0);
surface->shadow_top = top;
surface->shadow_left = left;
surface->shadow_right = right;
surface->shadow_bottom = bottom;
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->set_shadow_width)
impl_class->set_shadow_width (surface, left, right, top, bottom);
}
/**
* gdk_surface_show_window_menu:
* @surface: a #GdkSurface
* @event: a #GdkEvent to show the menu for
*
* Asks the windowing system to show the window menu. The window menu
* is the menu shown when right-clicking the titlebar on traditional
* windows managed by the window manager. This is useful for windows
* using client-side decorations, activating it with a right-click
* on the window decorations.
*
* Returns: %TRUE if the window menu was shown and %FALSE otherwise.
*/
gboolean
gdk_surface_show_window_menu (GdkSurface *surface,
GdkEvent *event)
{
GdkSurfaceImplClass *impl_class;
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
g_return_val_if_fail (!GDK_SURFACE_DESTROYED (surface), FALSE);
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->show_window_menu)
return impl_class->show_window_menu (surface, event);
else
return FALSE;
}
gboolean
gdk_surface_supports_edge_constraints (GdkSurface *surface)
{
GdkSurfaceImplClass *impl_class;
g_return_val_if_fail (GDK_IS_SURFACE (surface), FALSE);
g_return_val_if_fail (!GDK_SURFACE_DESTROYED (surface), FALSE);
impl_class = GDK_SURFACE_IMPL_GET_CLASS (surface->impl);
if (impl_class->supports_edge_constraints)
return impl_class->supports_edge_constraints (surface);
else
return FALSE;
}
void
gdk_surface_set_state (GdkSurface *surface,
GdkSurfaceState new_state)
{
g_return_if_fail (GDK_IS_SURFACE (surface));
if (new_state == surface->state)
return; /* No actual work to do, nothing changed. */
/* Actually update the field in GdkSurface, this is sort of an odd
* place to do it, but seems like the safest since it ensures we expose no
* inconsistent state to the user.
*/
surface->state = new_state;
_gdk_surface_update_viewable (surface);
/* We only really send the event to toplevels, since
* all the surface states don't apply to non-toplevels.
* Non-toplevels do use the GDK_SURFACE_STATE_WITHDRAWN flag
* internally so we needed to update surface->state.
*/
switch (surface->surface_type)
{
case GDK_SURFACE_TOPLEVEL:
case GDK_SURFACE_TEMP: /* ? */
g_object_notify (G_OBJECT (surface), "state");
break;
case GDK_SURFACE_FOREIGN:
case GDK_SURFACE_CHILD:
default:
break;
}
}
void
gdk_synthesize_surface_state (GdkSurface *surface,
GdkSurfaceState unset_flags,
GdkSurfaceState set_flags)
{
gdk_surface_set_state (surface, (surface->state | set_flags) & ~unset_flags);
}