/* 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 "gdkprivate.h" #include "gdkcairoprivate.h" #include "gdkcontentprovider.h" #include "gdkdeviceprivate.h" #include "gdkdisplayprivate.h" #include "gdkdragsurfaceprivate.h" #include "gdkeventsprivate.h" #include "gdkframeclockidleprivate.h" #include "gdkglcontextprivate.h" #include <glib/gi18n-lib.h>#include "gdkmarshalers.h" #include "gdkpopupprivate.h" #include "gdkprofilerprivate.h" #include "gdkrectangleprivate.h" #include "gdktoplevelprivate.h" #include "gdkvulkancontext.h" #include "gdksubsurfaceprivate.h" #include "gdkseatprivate.h" #include "gsk/gskrectprivate.h" #include <math.h>#ifdef HAVE_EGL#include <epoxy/egl.h>#endif /** * GdkSurface : * * Represents a rectangular region on the screen . * * It ’ s a low - level object , used to implement high - level objects * such as [ GtkWindow ] ( . . / gtk4 / class . Window . html ) . * * The surfaces you see in practice are either [ iface @ Gdk . Toplevel ] or * [ iface @ Gdk . Popup ] , and those interfaces provide much of the required * API to interact with these surfaces . Other , more specialized surface * types exist , but you will rarely interact with them directly . typedef struct _GdkSurfacePrivate GdkSurfacePrivate;struct _GdkSurfacePrivate/* This is different from the region */ enum {enum {/* Global info */ static void gdk_surface_finalize (GObject *object);static void gdk_surface_set_property (GObject *object,const GValue *value,static void gdk_surface_get_property (GObject *object,static void update_cursor (GdkDisplay *display,static void gdk_surface_queue_set_is_mapped (GdkSurface *surface,static guint signals[LAST_SIGNAL] = { 0 };static GParamSpec *properties[LAST_PROP] = { NULL, };static gbooleanreturn FALSE ;static GdkDisplay *if (display)return display;if (display)return display;"no display for surface, using default" );return gdk_display_get_default ();static GdkMonitor *const GdkRectangle *rect,void (*get_bounds) (GdkMonitor *monitor,int biggest_area = G_MININT;for (i = 0 ; i < g_list_model_get_n_items (monitors); i++)if (gdk_rectangle_intersect (&workarea, rect, &intersection))if (intersection.width * intersection.height > biggest_area)return best_monitor;static int switch (anchor)case GDK_GRAVITY_STATIC:case GDK_GRAVITY_NORTH_WEST:case GDK_GRAVITY_WEST:case GDK_GRAVITY_SOUTH_WEST:return -1 ;default :case GDK_GRAVITY_NORTH:case GDK_GRAVITY_CENTER:case GDK_GRAVITY_SOUTH:return 0 ;case GDK_GRAVITY_NORTH_EAST:case GDK_GRAVITY_EAST:case GDK_GRAVITY_SOUTH_EAST:return 1 ;static int switch (anchor)case GDK_GRAVITY_STATIC:case GDK_GRAVITY_NORTH_WEST:case GDK_GRAVITY_NORTH:case GDK_GRAVITY_NORTH_EAST:return -1 ;default :case GDK_GRAVITY_WEST:case GDK_GRAVITY_CENTER:case GDK_GRAVITY_EAST:return 0 ;case GDK_GRAVITY_SOUTH_WEST:case GDK_GRAVITY_SOUTH:case GDK_GRAVITY_SOUTH_EAST:return 1 ;static int int bounds_pos,int bounds_size,int rect_pos,int rect_size,int surface_size,int rect_sign,int surface_sign,int offset,int primary;int secondary;int badness = 0 ;int limit;/* Try to fit without flipping */ FALSE ;1 + rect_sign) * rect_size / 2 + offset - (1 + surface_sign) * surface_size / 2 if (!flip)return primary;/* If the position gets larger than this limit, * the other ( right / bottom ) edge is not going to fit . if (primary < bounds_pos)if (primary > limit)/* If it fit, we're done */ if (badness == 0 )return primary;/* See if flipping helps */ 1 - rect_sign) * rect_size / 2 - offset - (1 - surface_sign) * surface_size / 2 ;if (secondary < bounds_pos && bounds_pos - secondary > badness)return primary;else if (secondary > limit && secondary - limit > badness)return primary;/* It does help */ TRUE ;return secondary;void (*get_bounds) (GdkMonitor *monitor,1 , root_rect.width);1 , root_rect.height);return get_monitor_for_rect (display, &root_rect, get_bounds);void int width,int height,int shadow_left,int shadow_right,int shadow_top,int shadow_bottom,int rect_anchor_dx;int rect_anchor_dy;if (anchor_hints & GDK_ANCHOR_SLIDE_X)if (final_rect.x + final_rect.width > bounds->x + bounds->width)if (final_rect.x < bounds->x)if (anchor_hints & GDK_ANCHOR_SLIDE_Y)if (final_rect.y + final_rect.height > bounds->y + bounds->height)if (final_rect.y < bounds->y)if (anchor_hints & GDK_ANCHOR_RESIZE_X)if (final_rect.x < bounds->x)if (final_rect.x + final_rect.width > bounds->x + bounds->width)if (anchor_hints & GDK_ANCHOR_RESIZE_Y)if (final_rect.y < bounds->y)if (final_rect.y + final_rect.height > bounds->y + bounds->height)if ((flags & GDK_SURFACE_LAYOUT_POPUP_HELPER_ROOT_OUT) == 0 )int x, y;if (flipped_x)if (flipped_y)/* Since GdkEvent is a GTypeInstance, GValue can only store it as a pointer, * and GClosure does not know how to handle its memory management . To avoid * the event going away in the middle of the signal emission , we provide a * marshaller that keeps the event alive for the duration of the closure . static void const GValue *param_values,1 ]);static void int n_params,static void /* 0-initialization is good for all other fields. */ 0 ;1 ;1 ;255 ;static double return 1 .0 ;static void double scale = gdk_surface_get_scale (surface);static GdkSubsurface *"Subsurfaces not supported for %s" , G_OBJECT_TYPE_NAME (surface));return NULL;static void static void static void /** * GdkSurface : cursor : * * The mouse pointer for the ` GdkSurface ` . "cursor" , NULL, NULL,/** * GdkSurface : display : * * The ` GdkDisplay ` connection of the surface . "display" , NULL, NULL,/** * GdkSurface : frame - clock : * * The ` GdkFrameClock ` of the surface . "frame-clock" , NULL, NULL,/** * GdkSurface : mapped : * * Whether the surface is mapped . "mapped" , NULL, NULL,FALSE ,/** * GdkSurface : width : * * The width of the surface in pixels . "width" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GdkSurface : height : * * The height of the surface , in pixels . "height" , NULL, NULL,0 , G_MAXINT, 0 ,/** * GdkSurface : scale - factor : * * The scale factor of the surface . * * The scale factor is the next larger integer , * compared to [ property @ Gdk . Surface : scale ] . "scale-factor" , NULL, NULL,1 , G_MAXINT, 1 ,/** * GdkSurface : scale : * * The scale of the surface . * * Since : 4 . 12 "scale" , NULL, NULL,1 ., G_MAXDOUBLE, 1 .,/** * GdkSurface : : layout : * @ surface : the ` GdkSurface ` * @ width : the current width * @ height : the current height * * Emitted when the size of @ surface is changed , or when relayout should * be performed . * * Surface size is reported in ” application pixels ” , not * ” device pixels ” ( see gdk_surface_get_scale_factor ( ) ) . "layout" ),0 ,2 ,/** * GdkSurface : : render : * @ surface : the ` GdkSurface ` * @ region : the region that needs to be redrawn * * Emitted when part of the surface needs to be redrawn . * * Returns : % TRUE to indicate that the signal has been handled "render" ),0 ,1 ,/** * GdkSurface : : event : * @ surface : the ` GdkSurface ` * @ event : ( type Gdk . Event ) : an input event * * Emitted when GDK receives an input event for @ surface . * * Returns : % TRUE to indicate that the event has been handled "event" ),0 ,1 ,/** * GdkSurface : : enter - monitor : * @ surface : the ` GdkSurface ` * @ monitor : the monitor * * Emitted when @ surface starts being present on the monitor . "enter-monitor" ),0 ,1 ,/** * GdkSurface : : leave - monitor : * @ surface : the ` GdkSurface ` * @ monitor : the monitor * * Emitted when @ surface stops being present on the monitor . "leave-monitor" ),0 ,1 ,static void static void if (!GDK_SURFACE_DESTROYED (surface))"losing last reference to undestroyed surface" );FALSE );if (surface->parent)0 );static void const GValue *value,switch (prop_id)case PROP_CURSOR:break ;case PROP_DISPLAY:"seat-removed" ,break ;case PROP_FRAME_CLOCK:break ;default :break ;static void switch (prop_id)case PROP_CURSOR:break ;case PROP_DISPLAY:break ;case PROP_FRAME_CLOCK:break ;case PROP_MAPPED:break ;case PROP_WIDTH:break ;case PROP_HEIGHT:break ;case PROP_SCALE_FACTOR:break ;case PROP_SCALE:break ;default :break ;void if (priv->attached_context)/** * gdk_surface_new_toplevel : ( constructor ) * @ display : the display to create the surface on * * Creates a new toplevel surface . * * Returns : ( transfer full ) : the new ` GdkSurface ` return g_object_new (GDK_DISPLAY_GET_CLASS (display)->toplevel_type,"display" , display,/** * gdk_surface_new_popup : ( constructor ) * @ parent : the parent surface to attach the surface to * @ autohide : whether to hide the surface on outside clicks * * Create a new popup surface . * * The surface will be attached to @ parent and can be positioned * relative to it using [ method @ Gdk . Popup . present ] . * * Returns : ( transfer full ) : a new ` GdkSurface ` "display" , display,"parent" , parent,return surface;static void if (pointer_info->surface_under_pointer == surface)static void /** * _ gdk_surface_destroy_hierarchy : * @ surface : a ` GdkSurface ` * @ 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 if (GDK_SURFACE_DESTROYED (surface))return ;if (priv->attached_context)FALSE ;FALSE ;TRUE ;// Gtk.Window wants to disconnect from the frame clock, so notify before destroying it. if (surface->gl_paint_context)/* Make sure to destroy if current */ if (surface->frame_clock)if (surface->parent == NULL)/** * _ 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 : * @ 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 FALSE );void return priv->widget;/** * gdk_surface_get_display : * @ surface : a ` GdkSurface ` * * Gets the ` GdkDisplay ` associated with a ` GdkSurface ` . * * Returns : ( transfer none ) : the ` GdkDisplay ` associated with @ surface 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 return GDK_SURFACE_DESTROYED (surface);/** * gdk_surface_get_mapped : * @ surface : a ` GdkSurface ` * * Checks whether the surface has been mapped . * * A surface is mapped with [ method @ Gdk . Toplevel . present ] * or [ method @ Gdk . Popup . present ] . * * Returns : % TRUE if the surface is mapped FALSE );return GDK_SURFACE_IS_MAPPED (surface);return self->is_srgb;if (!gdk_display_prepare_gl (surface->display, error))return NULL;if (surface->gl_paint_context == NULL)if (surface->gl_paint_context == NULL)return NULL;if (!gdk_gl_context_realize (surface->gl_paint_context, error))return NULL;return surface->gl_paint_context;/** * gdk_surface_create_gl_context : * @ surface : a ` GdkSurface ` * @ error : return location for an error * * Creates a new ` GdkGLContext ` for 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 [ method @ Gdk . GLContext . make_current ] or [ method @ Gdk . GLContext . realize ] . * * Returns : ( transfer full ) : the newly created ` GdkGLContext ` if (!gdk_display_prepare_gl (surface->display, error))return NULL;return gdk_gl_context_new (surface->display, surface, FALSE );/** * gdk_surface_create_cairo_context : * @ surface : a ` GdkSurface ` * * Creates a new ` GdkCairoContext ` for rendering on @ surface . * * Returns : ( transfer full ) : the newly created ` GdkCairoContext ` * * Deprecated : 4 . 18 : Drawing content with Cairo should be done via * Cairo rendernodes , not by using the Cairo renderer . return g_object_new (GDK_DISPLAY_GET_CLASS (display)->cairo_context_type,"surface" , surface,/** * gdk_surface_create_vulkan_context : * @ surface : a ` GdkSurface ` * @ error : return location for an error * * Sets an error and returns % NULL . * * Returns : ( transfer full ) : % NULL * * Deprecated : 4 . 14 : GTK does not expose any Vulkan internals . This * function is a leftover that was accidentally exposed . "GTK does not expose Vulkan internals." );return FALSE ;static void if (surface->update_freeze_count)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 . if (frame_clock)static void void *data)class ;if (GDK_SURFACE_DESTROYED (surface))return ;if (!GDK_SURFACE_IS_MAPPED (surface))return ;class = GDK_SURFACE_GET_CLASS (surface);if (class ->compute_size)if (class ->compute_size (surface))return ;0 , surface->width, surface->height);/** * gdk_surface_request_layout : * @ surface : a ` GdkSurface ` * * Request a layout phase from the surface ' s frame clock . * * See [ method @ Gdk . FrameClock . request_phase ] . void class ;class = GDK_SURFACE_GET_CLASS (surface);if (class ->request_layout)class ->request_layout (surface);static void void *data)if (GDK_SURFACE_DESTROYED (surface) ||return ;if (GDK_SURFACE_IS_MAPPED (surface))0 , expose_region, &handled);/* * gdk_surface_invalidate_rect : * @ surface : a ` GdkSurface ` * @ rect : ( nullable ) : rectangle to invalidate or % NULL to * invalidate the whole surface * * Invalidate a rectangular region of @ surface . * * This is a convenience wrapper around * [ method @ Gdk . Surface . invalidate_region ] . void const GdkRectangle *rect)if (!GDK_SURFACE_IS_MAPPED (surface))return ;if (!rect)0 ;0 ;static void if (impl_surface->update_area)else /** * gdk_surface_queue_render : * @ surface : a ` GdkSurface ` * * Forces a [ signal @ Gdk . Surface : : render ] signal emission for @ surface * to be scheduled . * * This function is useful for implementations that track invalid * regions on their own . void /* * 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 . void const cairo_region_t *region)if (!GDK_SURFACE_IS_MAPPED (surface))return ;if (cairo_region_is_empty (region))return ;0 ;0 ;/* * _ 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 if (surface->update_area)/* * 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 if (GDK_DEBUG_CHECK (NO_VSYNC))return ;if (surface->update_freeze_count == 1 )static gbooleanvoid *data)if (clock)0 ;return G_SOURCE_REMOVE;/* * gdk_surface_thaw_updates : * @ surface : a ` GdkSurface ` * * Thaws a surface frozen with gdk_surface_freeze_updates ( ) . Note that this * will not necessarily schedule updates if the surface freeze count reaches * zero . void if (GDK_DEBUG_CHECK (NO_VSYNC))return ;0 );if (--surface->update_freeze_count == 0 )if (surface->pending_phases)if (surface->request_motion && surface->request_motion_id == 0 )20 , request_motion_cb, surface, NULL);"[gtk] request_motion_cb" );/* * 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 int width,int height,int *new_width,int *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 int min_width = 0 ;int min_height = 0 ;int max_width = G_MAXINT;int max_height = G_MAXINT;if (flags & GDK_HINT_MIN_SIZE)if (flags & GDK_HINT_MAX_SIZE)/* clamp width and height to min and max values /** * gdk_surface_get_device_position : * @ surface : a ` GdkSurface ` * @ device : pointer ` GdkDevice ` to query to * @ x : ( out ) ( optional ) : return location for the X coordinate of @ device * @ y : ( out ) ( optional ) : return location for the Y coordinate of @ device * @ mask : ( out ) ( optional ) : return location for the modifier mask * * Obtains the current device position and modifier state . * * The position is given in coordinates relative to the upper * left corner of @ surface . * * Return : % TRUE if the device is over the surface double *x,double *y,double tmp_x, tmp_y;FALSE );FALSE );FALSE );0 ;0 ;0 ;if (x)if (y)if (mask)return ret;/** * gdk_surface_hide : * @ surface : a ` GdkSurface ` * * Hide the surface . * * 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 ( ) ] ( . . / gtk4 / method . Widget . hide . html ) . void if (surface->destroyed)return ;FALSE );0 ;0 ;0 ;0 ;static void if (GDK_SURFACE_DESTROYED (surface))return ;if (surface == pointer_info->surface_under_pointer)/** * gdk_surface_get_cursor : * @ surface : a ` GdkSurface ` * * Retrieves a ` GdkCursor ` pointer for the cursor currently set on the * ` GdkSurface ` . * * If the return value is % NULL then there is no custom cursor set on * the surface , and it is using the cursor for its parent surface . * * Use [ method @ Gdk . Surface . set_cursor ] to unset the cursor of the surface . * * Returns : ( nullable ) ( transfer none ) : a ` GdkCursor ` return surface->cursor;/** * gdk_surface_set_cursor : * @ surface : a ` GdkSurface ` * @ cursor : ( nullable ) : a ` GdkCursor ` * * Sets the default mouse pointer for a ` GdkSurface ` . * * Passing % NULL for the @ cursor argument means that @ surface will use * the cursor of its parent surface . Most surfaces should use this default . * Note that @ cursor must be for the same display as @ surface . * * Use [ ctor @ Gdk . Cursor . new_from_name ] or [ ctor @ Gdk . Cursor . new_from_texture ] * to create the cursor . To make the cursor invisible , use % GDK_BLANK_CURSOR . void if (!GDK_SURFACE_DESTROYED (surface))if (cursor)for (s = seats; s; s = s->next)for (d = devices; d; d = d->next)/** * gdk_surface_get_device_cursor : * @ surface : a ` GdkSurface ` * @ device : a pointer ` GdkDevice ` * * Retrieves a ` GdkCursor ` pointer for the @ device currently set on the * specified ` GdkSurface ` . * * 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 . * * Use [ method @ Gdk . Surface . set_cursor ] to unset the cursor of the surface . * * Returns : ( nullable ) ( transfer none ) : a ` GdkCursor ` return g_hash_table_lookup (surface->device_cursor, device);/** * gdk_surface_set_device_cursor : * @ surface : a ` GdkSurface ` * @ device : a pointer ` GdkDevice ` * @ cursor : a ` GdkCursor ` * * Sets a specific ` GdkCursor ` for a given device when it gets inside @ surface . * * Passing % NULL for the @ cursor argument means that @ surface will use the * cursor of its parent surface . Most surfaces should use this default . * * Use [ ctor @ Gdk . Cursor . new_from_name ] or [ ctor @ Gdk . Cursor . new_from_texture ] * to create the cursor . To make the cursor invisible , use % GDK_BLANK_CURSOR . void if (!cursor)else /* * gdk_surface_get_geometry : * @ surface : a ` GdkSurface ` * @ x : ( out ) ( optional ) : return location for X coordinate of surface ( relative to its parent ) * @ y : ( out ) ( optional ) : return location for Y coordinate of surface ( relative to its parent ) * @ width : ( out ) ( optional ) : return location for width of surface * @ height : ( out ) ( optional ) : return location for height of surface * * Get the geometry of the surface . * * 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 ` . [ method @ Gdk . Surface . get_position ] in contrast gets * the position from the most recent configure event . * * Any of the return location arguments to this function may be % NULL , * if you aren ’ t interested in getting the value of that field . * * Note : If @ surface is not a toplevel , it is much better to call * [ method @ Gdk . Surface . get_position ] , [ method @ Gdk . Surface . get_width ] and * [ method @ 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 int *x,int *y,int *width,int *height)if (GDK_SURFACE_DESTROYED (surface))return ;/** * gdk_surface_get_width : * @ surface : a ` GdkSurface ` * * Returns the width of the given @ surface . * * Surface size is reported in ” application pixels ” , not * ” device pixels ” ( see [ method @ Gdk . Surface . get_scale_factor ] ) . * * Returns : The width of @ surface int 0 );return surface->width;/** * gdk_surface_get_height : * @ surface : a ` GdkSurface ` * * Returns the height of the given @ surface . * * Surface size is reported in ” application pixels ” , not * ” device pixels ” ( see [ method @ Gdk . Surface . get_scale_factor ] ) . * * Returns : The height of @ surface int 0 );return surface->height;/* * gdk_surface_get_origin : * @ surface : a ` GdkSurface ` * @ x : ( out ) : return location for X coordinate * @ y : ( out ) : 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 . ) void int *x,int *y)0 , 0 , x, y);/* * 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 int x,int y,int *root_x,int *root_y)if (GDK_SURFACE_DESTROYED (surface))0 ;0 ;return ;/** * gdk_surface_set_input_region : * @ surface : a ` GdkSurface ` * @ region : ( nullable ) : region of surface to be reactive , * or % NULL to make the entire surface reactive * * Apply the region to the surface for the purpose of 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 region 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 region * controls where the surface is “ clickable ” . * * Use [ method @ Gdk . Display . supports_input_shapes ] to find out if * a particular backend supports input regions . void if (GDK_SURFACE_DESTROYED (surface))return ;if (cairo_region_equal (surface->input_region, region))return ;if (surface->input_region)if (region)else static void if (!cursor_surface)if (!cursor)/** * gdk_surface_beep : * @ surface : a toplevel ` GdkSurface ` * * Emits a short beep associated to @ surface . * * If the display of @ surface does not support per - surface beeps , * emits a short beep on the display just as [ method @ Gdk . Display . beep ] . void if (GDK_SURFACE_DESTROYED (surface))return ;if (GDK_SURFACE_GET_CLASS (surface)->beep (surface))return ;void if (device_info->surface_under_pointer)if (surface)void FALSE ;if (device)if (timestamp != GDK_CURRENT_TIME)if (gdk_device_get_source (device) != GDK_SOURCE_KEYBOARD &&if (!event_surface)goto out;if (type == GDK_ENTER_NOTIFY)else if (type == GDK_LEAVE_NOTIFY)if (unlink_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 . if (event_surface)if (clock) /* might be NULL if surface was destroyed */ /** * 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 Cairo 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 . ) * * 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 . * * Returns : a pointer to the newly allocated surface . The caller * owns the surface and should call cairo_surface_destroy ( ) when done * with it . * * Deprecated : 4 . 12 : Create a suitable cairo image surface yourself int width,int height)int scale;,return similar_surface;/* This function is called when the XWindow is really gone. void /** * 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 . After this call , you * probably want to set up the drag icon using the surface returned * by [ method @ Gdk . Drag . get_drag_surface ] . * * This function returns a reference to the [ class @ Gdk . Drag ] object , * but GTK keeps its own reference as well , as long as the DND operation * is going on . * * Note : if @ actions include % GDK_ACTION_MOVE , you need to listen for * the [ signal @ Gdk . Drag : : dnd - finished ] signal and delete the data at * the source if [ method @ Gdk . Drag . get_selected_action ] returns * % GDK_ACTION_MOVE . * * Returns : ( transfer full ) ( nullable ) : a newly created ` GdkDrag ` double dx,double dy)return GDK_SURFACE_GET_CLASS (surface)->drag_begin (surface, device, content, actions, dx, dy);static void double x, y;if (!surface->request_motion)return ;FALSE ;if (!seat)return ;if (!gdk_surface_get_device_position (surface, device, &x, &y, &state))return ;if (grab_surface && surface != grab_surface)return ;static void void *data)TRUE ;static void void *data)if (surface->frame_clock_events_paused)FALSE ;void if (clock == surface->frame_clock)return ;if (clock)"flush-events" ,"resume-events" ,"layout" ,"paint" ,if (surface->update_freeze_count == 0 )if (surface->frame_clock)if (surface->frame_clock_events_paused)if (surface->update_freeze_count == 0 )/** * 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 return surface->frame_clock;/** * gdk_surface_get_scale_factor : * @ surface : surface to get scale factor for * * Returns the internal scale factor that maps from surface coordinates * 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 factor may change during the lifetime of the surface . * * Returns : the scale factor int 1 );return (int ) ceil (gdk_surface_get_scale (surface));/** * gdk_surface_get_scale : * @ surface : surface to get scale for * * Returns the internal scale that maps from surface coordinates * to the actual device pixels . * * When the scale is bigger than 1 , the windowing system prefers to get * buffers with a resolution that is bigger than the surface size ( e . g . * to show the surface on a high - resolution display , or in a magnifier ) . * * Compare with [ method @ Gdk . Surface . get_scale_factor ] , which returns the * next larger integer . * * The scale may change during the lifetime of the surface . * * Returns : the scale * * Since : 4 . 12 double 1 .);if (GDK_SURFACE_DESTROYED (surface))return 1 .;return GDK_SURFACE_GET_CLASS (surface)->get_scale (surface);static void if (priv->opaque_region == NULL)if (priv->opaque_rect.width <= 0 )else else if (priv->opaque_rect.width <= 0 )else /** * gdk_surface_set_opaque_region : * @ surface : a top - level ` GdkSurface ` * @ region : ( nullable ) : a region , or % NULL to make the entire * surface opaque * * Marks a region of the ` GdkSurface ` as opaque . * * 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 * [ GtkWidgetClass . css_changed ] ( . . / gtk4 / vfunc . Widget . css_changed . html ) handler . * * Deprecated : 4 . 16 : GDK can figure out the opaque parts of a window itself * by inspecting the contents that are drawn . void if (cairo_region_equal (priv->opaque_region, region))return ;if (region != NULL)/* Sets the opaque rect from the rendernode via end_frame() */ void const graphene_rect_t *rect)if (rect == NULL || !gsk_rect_to_cairo_shrink (rect, &opaque))0 , 0 , 0 , 0 };if (gdk_rectangle_equal (&priv->opaque_rect, &opaque))return ;/* * gdk_surface_is_opaque : * @ self : a surface * * Checks if the whole surface is known to be opaque . * This allows using an RGBx buffer instead of RGBA . * * This function works for the currently rendered frame inside * begin_frame ( ) implementations . * * Returns : % TRUE if the whole surface is provably opaque 0 , 0 , self->width, self->height };if (gdk_rectangle_contains (&priv->opaque_rect, &whole))return TRUE ;if (priv->opaque_region &&N)return TRUE ;return FALSE ;static void 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 . if (GDK_IS_TOPLEVEL (surface))/* gobject-linter-ignore-next-line: use_g_object_notify_by_pspec */ "state" );void void if (!frame_clock || gdk_frame_clock_is_stopped (frame_clock))void if (!surface->pending_unset_flags && !surface->pending_set_flags)return ;0 ;0 ;static gboolean0 ;if (surface->is_mapped)return G_SOURCE_REMOVE;void if (surface->pending_is_mapped != surface->is_mapped)if (surface->is_mapped)if (was_mapped != is_mapped)static void if (surface->pending_is_mapped == is_mapped)return ;if (surface->is_mapped == surface->pending_is_mapped)else 10 , set_is_mapped_idle, surface, NULL);"[gtk] set_is_mapped_idle" );static gbooleanswitch ((guint) evtype)case GDK_BUTTON_PRESS:#if 0 // FIXME: we need to ignore the release that is paired // with the press starting the grab - due to implicit // grabs, it will be delivered to the same place as the // press, and will cause the auto dismissal to be triggered. case GDK_BUTTON_RELEASE:case GDK_TOUCH_END:case GDK_TOUCH_CANCEL:#endif case GDK_TOUCH_BEGIN:case GDK_TOUCHPAD_SWIPE:case GDK_TOUCHPAD_PINCH:if (grab_surface)if (event_surface->autohide &&if (grab_surface->autohide &&do while (surface->autohide && surface != event_surface);return TRUE ;break ;case GDK_ENTER_NOTIFY:case GDK_LEAVE_NOTIFY:if (event_surface->autohide &&break ;default :;return FALSE ;static inline void #ifdef HAVE_SYSPROFchar *message = NULL;const char *kind;class ;class = g_type_class_ref (GDK_TYPE_EVENT_TYPE);class , event_type);class );"Event" ;switch ((int ) event_type)case GDK_MOTION_NOTIFY:double x, y;"%s {x=%lf, y=%lf, state=0x%x}" ,break ;case GDK_BUTTON_PRESS:case GDK_BUTTON_RELEASE:double x, y;"%s {button=%u, x=%lf, y=%lf, state=0x%x}" ,break ;case GDK_KEY_PRESS:case GDK_KEY_RELEASE:"%s {keyval=%u, state=0x%x, keycode=%u layout=%u level=%u is_modifier=%u}" ,break ;case GDK_ENTER_NOTIFY:case GDK_LEAVE_NOTIFY:case GDK_TOUCHPAD_SWIPE:case GDK_TOUCHPAD_PINCH:case GDK_SCROLL:case GDK_DRAG_ENTER:case GDK_DRAG_LEAVE:case GDK_DRAG_MOTION:case GDK_DROP_START:case GDK_TOUCH_BEGIN:case GDK_TOUCH_UPDATE:case GDK_TOUCH_END:case GDK_TOUCH_CANCEL:case GDK_PAD_BUTTON_PRESS:case GDK_PAD_BUTTON_RELEASE:case GDK_PAD_RING:case GDK_PAD_STRIP:case GDK_PAD_DIAL:case GDK_PAD_GROUP_MODE:case GDK_GRAB_BROKEN:case GDK_DELETE:case GDK_FOCUS_CHANGE:case GDK_PROXIMITY_IN:case GDK_PROXIMITY_OUT:case GDK_EVENT_LAST:default :break ;"Event" , message ? message : kind);#endif FALSE ;if (!GDK_SURFACE_IS_MAPPED (surface) &&return FALSE ;if (check_autohide (event))return TRUE ;if (evtype == GDK_MOTION_NOTIFY)FALSE ;0 , event, &handled);if (GDK_PROFILER_IS_RUNNING)return handled;/* * gdk_surface_request_motion : * @ surface : a ` GdkSurface ` * * Request that the next frame cycle should deliver a motion * event for @ surface . * * The motion event will be delivered if the pointer is over the * surface , regardless whether the pointer has moved or not . This * is used by GTK after moving widgets around . void TRUE ;/** * gdk_surface_translate_coordinates : * @ from : the origin surface * @ to : the target surface * @ x : ( inout ) : coordinates to translate * @ y : ( inout ) : coordinates to translate * * Translates coordinates between two surfaces . * * Note that this only works if @ to and @ from are popups or * transient - for to the same toplevel ( directly or indirectly ) . * * Returns : % TRUE if the coordinates were successfully translated double *x,double *y)double in_x, in_y, out_x, out_y;int x1, y1, x2, y2;FALSE );FALSE );FALSE );FALSE );0 ;0 ;while (f->parent)0 ;0 ;while (t->parent)if (f != t)return FALSE ;return TRUE ;if (event)if (seat)return seat;return gdk_display_get_default_seat (surface->display);void 0 , monitor);void 0 , monitor);if (subsurface)return subsurface;return surface->subsurfaces->len;return g_ptr_array_index (surface->subsurfaces, idx);return priv->color_state;void if (gdk_color_state_equal (priv->color_state, color_state))return ;/*<private> * gdk_surface_set_attached_context : * @ self : the surface * @ context : ( nullable ) : the context to attach * * This function is an implementation detail for GdkDrawContext . * * Use draw context functions like gdk_draw_context_attach ( ) or * gdk_draw_context_detach ( ) . void return priv->attached_context;
Messung V0.5 in Prozent C=98 H=96 G=96
¤ Dauer der Verarbeitung: 0.83 Sekunden
(vorverarbeitet am 2026-07-03)
¤ *© Formatika GbR, Deutschland
