mirror of
https://gitlab.gnome.org/GNOME/gtk.git
synced 2024-12-27 06:00:22 +00:00
5731 lines
169 KiB
C
5731 lines
169 KiB
C
/* 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 <http://www.gnu.org/licenses/>.
|
||
*/
|
||
|
||
/*
|
||
* 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 <cairo-gobject.h>
|
||
|
||
#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 <math.h>
|
||
|
||
#include <epoxy/gl.h>
|
||
|
||
/* 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);
|
||
}
|