Impressum gtkwindow.c
Sprache: C
/* GTK - The GIMP Toolkit * Copyright ( C ) 1995 - 1997 Peter Mattis , Spencer Kimball and Josh MacDonald * * 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 "gtkwindowprivate.h" #include "gtkaccessibleprivate.h" #include "gtkapplicationprivate.h" #include "gtkbox.h" #include "gtkbuildable.h" #include "gtkbuilderprivate.h" #include "gtkcheckbutton.h" #include "gtkcssshadowvalueprivate.h" #include "gtkdroptargetasync.h" #include "gtkeventcontrollerlegacy.h" #include "gtkeventcontrollerkey.h" #include "gtkeventcontrollermotion.h" #include "gtkgestureclick.h" #include "gtkheaderbar.h" #include "gtkicontheme.h" #include <glib/gi18n-lib.h>#include "gtkmain.h" #include "gtkmarshalers.h" #include "deprecated/gtkmessagedialog.h" #include "gtkpointerfocusprivate.h" #include "gtkprivate.h" #include "gtkroot.h" #include "gtknativeprivate.h" #include "gtksettings.h" #include "gtkshortcut.h" #include "gtkshortcutcontrollerprivate.h" #include "gtkshortcutmanager.h" #include "gtkshortcuttrigger.h" #include "gtksizerequest.h" #include "gtksnapshot.h" #include "gtktypebuiltins.h" #include "gtkwidgetprivate.h" #include "gtkwindowgroup.h" #include "gtkpopovermenubarprivate.h" #include "gtkcssboxesimplprivate.h" #include "gtktooltipprivate.h" #include "gtkmenubutton.h" #include "inspector/window.h" #include "gdk/gdkprofilerprivate.h" #include "gdk/gdksurfaceprivate.h" #include "gdk/gdktextureprivate.h" #include "gdk/gdktoplevelprivate.h" #include "gsk/gskrendererprivate.h" #include "gsk/gskroundedrectprivate.h" #include <cairo-gobject.h>#include <errno.h>#include <graphene.h>#include <limits.h>#include <string.h>#include <stdlib.h>#ifdef GDK_WINDOWING_X11#include "x11/gdkx.h" #endif #ifdef GDK_WINDOWING_WIN32#include "win32/gdkwin32.h" #endif #ifdef GDK_WINDOWING_WAYLAND#include "wayland/gdkwayland.h" #include "wayland/gdkdisplay-wayland.h" #endif #ifdef GDK_WINDOWING_MACOS#include "macos/gdkmacos.h" #endif #ifdef GDK_WINDOWING_BROADWAY#include "broadway/gdkbroadway.h" #endif #define GDK_ARRAY_ELEMENT_TYPE GtkWidget *#define GDK_ARRAY_TYPE_NAME GtkWidgetStack#define GDK_ARRAY_NAME gtk_widget_stack#define GDK_ARRAY_FREE_FUNC g_object_unref#define GDK_ARRAY_PREALLOC 16 #include "gdk/gdkarrayimpl.c" /** * GtkWindow : * * A toplevel window which can contain other widgets . * * < picture > * < source srcset = " window - dark . png " media = " ( prefers - color - scheme : dark ) " > * < img alt = " An example GtkWindow " src = " window . png " > * < / picture > * * Windows normally have decorations that are under the control * of the windowing system and allow the user to manipulate the window * ( resize it , move it , close it , . . . ) . * * # GtkWindow as GtkBuildable * * The ` GtkWindow ` implementation of the [ iface @ Gtk . Buildable ] interface supports * setting a child as the titlebar by specifying “ titlebar ” as the “ type ” * attribute of a ` < child > ` element . * * # Shortcuts and Gestures * * ` GtkWindow ` supports the following keyboard shortcuts : * * - < kbd > F10 < / kbd > activates the menubar , if present . * - < kbd > Alt < / kbd > makes the mnemonics visible while pressed . * * The following signals have default keybindings : * * - [ signal @ Gtk . Window : : activate - default ] * - [ signal @ Gtk . Window : : activate - focus ] * - [ signal @ Gtk . Window : : enable - debugging ] * * # Actions * * ` GtkWindow ` defines a set of built - in actions : * * - ` default . activate ` activates the default widget . * - ` window . minimize ` minimizes the window . * - ` window . toggle - maximized ` maximizes or restores the window . * - ` window . close ` closes the window . * * # CSS nodes * * ` ` ` * window . background [ . csd / . solid - csd / . ssd ] [ . maximized / . fullscreen / . tiled ] * ├ ─ ─ < child > * ╰ ─ ─ < titlebar child > . titlebar [ . default - decoration ] * ` ` ` * * ` GtkWindow ` has a main CSS node with name window and style class . background . * * Style classes that are typically used with the main CSS node are . csd ( when * client - side decorations are in use ) , . solid - csd ( for client - side decorations * without invisible borders ) , . ssd ( used by mutter when rendering server - side * decorations ) . GtkWindow also represents window states with the following * style classes on the main node : . maximized , . fullscreen , . tiled ( when supported , * also . tiled - top , . tiled - left , . tiled - right , . tiled - bottom ) . * * ` GtkWindow ` subclasses often add their own discriminating style classes , * such as . dialog , . popup or . tooltip . * * Generally , some CSS properties don ' t make sense on the toplevel window node , * such as margins or padding . When client - side decorations without invisible * borders are in use ( i . e . the . solid - csd style class is added to the * main window node ) , the CSS border of the toplevel window is used for * resize drags . In the . csd case , the shadow area outside of the window * can be used to resize it . * * ` GtkWindow ` adds the . titlebar and . default - decoration style classes to the * widget that is added as a titlebar child . * * # Accessibility * * ` GtkWindow ` uses the [ enum @ Gtk . AccessibleRole . window ] role . * * From GTK 4 . 12 to 4 . 18 , it used the [ enum @ Gtk . AccessibleRole . application ] role . #define MENU_BAR_ACCEL GDK_KEY_F10#define RESIZE_HANDLE_SIZE 12 /* Width of resize borders */ #define RESIZE_HANDLE_CORNER_SIZE 24 /* How resize corners extend */ #define MNEMONICS_DELAY 300 /* ms */ #define NO_CONTENT_CHILD_NAT 200 /* ms */ #define VISIBLE_FOCUS_DURATION 3 /* s */ /* In case the content (excluding header bar and shadows) of the window * would be empty , either because there is no visible child widget or only an * empty container widget , we use NO_CONTENT_CHILD_NAT as natural width / height * instead . typedef struct _GtkWindowGeometryInfo GtkWindowGeometryInfo;typedef struct int default_width;int default_height;char *startup_id;char *title;int scale;int title_height;/* The following flags are initially TRUE (before a window is mapped). * They cause us to compute a configure request that involves * default - only parameters . Once mapped , we set them to FALSE . * Then we set them to TRUE again on unmap ( for position ) * and on unrealize ( for size ) . 1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ; /* Decorations drawn client-side */ 1 ; /* Decorations use client-side shadows */ 1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;1 ;int surface_width;int surface_height;enum {enum {/* Normal Props */ /* Readonly properties */ /* Writeonly properties */ static GParamSpec *window_props[N_PROPS] = { NULL, };/* Must be kept in sync with GdkSurfaceEdge ! */ typedef enum typedef struct char *icon_name;1 ;1 ;1 ;typedef struct {/* Last set of geometry hints we set */ struct _GtkWindowGeometryInfostatic void gtk_window_constructed (GObject *object);static void gtk_window_dispose (GObject *object);static void gtk_window_finalize (GObject *object);static void gtk_window_show (GtkWidget *widget);static void gtk_window_hide (GtkWidget *widget);static void gtk_window_map (GtkWidget *widget);static void gtk_window_unmap (GtkWidget *widget);static void gtk_window_realize (GtkWidget *widget);static void gtk_window_unrealize (GtkWidget *widget);static void gtk_window_size_allocate (GtkWidget *widget,int width,int height,int baseline);static gboolean gtk_window_close_request (GtkWindow *window);static void gtk_window_force_close (GtkWindow *window);static gboolean gtk_window_handle_focus (GtkWidget *widget,double x,double y);static gboolean gtk_window_key_pressed (GtkWidget *widget,static gboolean gtk_window_key_released (GtkWidget *widget,static void surface_state_changed (GtkWidget *widget);static void surface_size_changed (GtkWidget *widget,int width,int height);static gboolean surface_event (GdkSurface *surface,static void after_paint (GdkFrameClock *clock,static gboolean gtk_window_focus (GtkWidget *widget,static void gtk_window_move_focus (GtkWidget *widget,static void gtk_window_real_activate_default (GtkWindow *window);static void gtk_window_real_activate_focus (GtkWindow *window);static void gtk_window_keys_changed (GtkWindow *window);static gboolean gtk_window_enable_debugging (GtkWindow *window,static void gtk_window_unset_transient_for (GtkWindow *window);static void gtk_window_transient_parent_realized (GtkWidget *parent,static void gtk_window_transient_parent_unrealized (GtkWidget *parent,static GtkWindowGeometryInfo* gtk_window_get_geometry_info (GtkWindow *window,static void gtk_window_set_default_size_internal (GtkWindow *window,int width,int height);static void update_themed_icon (GtkWindow *window);static GList *icon_list_from_theme (GtkWindow *window,const char *name);static void gtk_window_realize_icon (GtkWindow *window);static void gtk_window_unrealize_icon (GtkWindow *window);static void update_window_actions (GtkWindow *window);static void get_shadow_width (GtkWindow *window,static gboolean gtk_window_activate_menubar (GtkWidget *widget,#ifdef GDK_WINDOWING_X11static void gtk_window_on_theme_variant_changed (GtkSettings *settings,#endif static void gtk_window_set_theme_variant (GtkWindow *window);static void gtk_window_activate_default_activate (GtkWidget *widget,const char *action_name,static void gtk_window_activate_minimize (GtkWidget *widget,const char *action_name,static void gtk_window_activate_toggle_maximized (GtkWidget *widget,const char *name,static void gtk_window_activate_close (GtkWidget *widget,const char *action_name,static void _gtk_window_set_is_active (GtkWindow *window,static void gtk_window_present_toplevel (GtkWindow *window);static void gtk_window_update_toplevel (GtkWindow *window,static void gtk_window_release_application (GtkWindow *window);static GListStore *toplevel_list = NULL;static guint window_signals[LAST_SIGNAL] = { 0 };static char *default_icon_name = NULL;static gboolean disable_startup_notification = FALSE ;static GQuark quark_gtk_window_icon_info = 0 ;static GtkBuildableIface *parent_buildable_iface;static void gtk_window_set_property (GObject *object,const GValue *value,static void gtk_window_get_property (GObject *object,/* GtkBuildable */ static void gtk_window_buildable_interface_init (GtkBuildableIface *iface);static void gtk_window_buildable_add_child (GtkBuildable *buildable,const char *type);static void gtk_window_shortcut_manager_interface_init (GtkShortcutManagerInterface *iface);/* GtkRoot */ static void gtk_window_root_interface_init (GtkRootInterface *iface);static void gtk_window_native_interface_init (GtkNativeInterface *iface);static void gtk_window_accessible_interface_init (GtkAccessibleInterface *iface);static void ensure_state_flag_backdrop (GtkWidget *widget);static void unset_titlebar (GtkWindow *window);#define INCLUDE_CSD_SIZE 1 #define EXCLUDE_CSD_SIZE -1 static void int *width,int *height,int apply);static void unset_fullscreen_monitor (GtkWindow *window);static GtkAccessibleInterface *parent_accessible_iface;static gbooleanswitch (state)case GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSABLE:case GTK_ACCESSIBLE_PLATFORM_STATE_FOCUSED:return parent_accessible_iface->get_platform_state (self, state);case GTK_ACCESSIBLE_PLATFORM_STATE_ACTIVE:return gtk_window_is_active (GTK_WINDOW (self));default :static void static void "move-focus" ,"(i)" , direction);static void "move-focus" ,"(i)" ,"move-focus" ,"(i)" ,static guint32const char * startup_id)char *timestr = g_strrstr (startup_id, "_TIME" );if (timestr)char *end;/* Skip past the "_TIME" part */ 5 ;0 ;0 );if (errno == 0 && end != timestr)return retval;static gbooleanconst char * startup_id)return strncmp (startup_id, "_TIME" , 5 ) == 0 ;static void int for_size,int *minimum,int *natural,int *minimum_baseline,int *natural_baseline)int title_for_size = for_size;int title_min_size = 0 ;int title_nat_size = 0 ;int child_for_size = for_size;int child_min_size = 0 ;int child_nat_size = 0 ;if (priv->decorated && !priv->fullscreen)if (priv->title_box != NULL &&if (orientation == GTK_ORIENTATION_HORIZONTAL && for_size >= 0 &&2 ];1 ,0 ].minimum_size, &sizes[0 ].natural_size,1 ,1 ].minimum_size, &sizes[1 ].natural_size,0 ].minimum_size + sizes[1 ].minimum_size;2 , sizes);0 ].minimum_size;1 ].minimum_size + for_size;if (child != NULL && gtk_widget_get_visible (child))if (child_nat_size == 0 && !has_size_request)else if (!has_size_request)if (orientation == GTK_ORIENTATION_HORIZONTAL)else static void if (priv->child)else FALSE ;FALSE ;static GtkSizeRequestModeif (priv->child)return gtk_widget_get_request_mode (priv->child);else return GTK_SIZE_REQUEST_CONSTANT_SIZE;static GdkGravityswitch (priv->gravity)case GTK_WINDOW_GRAVITY_TOP_LEFT:return GDK_GRAVITY_NORTH_WEST;case GTK_WINDOW_GRAVITY_TOP:return GDK_GRAVITY_NORTH;case GTK_WINDOW_GRAVITY_TOP_RIGHT:return GDK_GRAVITY_NORTH_EAST;case GTK_WINDOW_GRAVITY_LEFT:return GDK_GRAVITY_WEST;case GTK_WINDOW_GRAVITY_CENTER:return GDK_GRAVITY_CENTER;case GTK_WINDOW_GRAVITY_RIGHT:return GDK_GRAVITY_EAST;case GTK_WINDOW_GRAVITY_BOTTOM_LEFT:return GDK_GRAVITY_SOUTH_WEST;case GTK_WINDOW_GRAVITY_BOTTOM:return GDK_GRAVITY_SOUTH;case GTK_WINDOW_GRAVITY_BOTTOM_RIGHT:return GDK_GRAVITY_SOUTH_EAST;case GTK_WINDOW_GRAVITY_TOP_START:if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)return GDK_GRAVITY_NORTH_EAST;else return GDK_GRAVITY_NORTH_WEST;case GTK_WINDOW_GRAVITY_TOP_END:if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)return GDK_GRAVITY_NORTH_WEST;else return GDK_GRAVITY_NORTH_EAST;case GTK_WINDOW_GRAVITY_START:if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)return GDK_GRAVITY_EAST;else return GDK_GRAVITY_WEST;case GTK_WINDOW_GRAVITY_END:if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)return GDK_GRAVITY_WEST;else return GDK_GRAVITY_EAST;case GTK_WINDOW_GRAVITY_BOTTOM_START:if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)return GDK_GRAVITY_SOUTH_EAST;else return GDK_GRAVITY_SOUTH_WEST;case GTK_WINDOW_GRAVITY_BOTTOM_END:if (gtk_widget_get_direction (GTK_WIDGET (window)) == GTK_TEXT_DIR_RTL)return GDK_GRAVITY_SOUTH_WEST;else return GDK_GRAVITY_SOUTH_EAST;default :static void if (priv->surface)static void "gtk-window-icon-info" );if (toplevel_list == NULL)/** * GtkWindow : title : * * The title of the window . "title" , NULL, NULL,/** * GtkWindow : startup - id : * * A write - only property for setting window ' s startup notification identifier . "startup-id" , NULL, NULL,/** * GtkWindow : resizable : * * If true , users can resize the window . "resizable" , NULL, NULL,TRUE ,/** * GtkWindow : modal : * * If true , the window is modal . "modal" , NULL, NULL,FALSE ,/** * GtkWindow : default - width : * * The default width of the window . "default-width" , NULL, NULL,1 , G_MAXINT,0 ,/** * GtkWindow : default - height : * * The default height of the window . "default-height" , NULL, NULL,1 , G_MAXINT,0 ,/** * GtkWindow : destroy - with - parent : * * If this window should be destroyed when the parent is destroyed . "destroy-with-parent" , NULL, NULL,FALSE ,/** * GtkWindow : hide - on - close : * * If this window should be hidden instead of destroyed when the user clicks * the close button . "hide-on-close" , NULL, NULL,FALSE ,/** * GtkWindow : mnemonics - visible : * * Whether mnemonics are currently visible in this window . * * This property is maintained by GTK based on user input , * and should not be set by applications . "mnemonics-visible" , NULL, NULL,FALSE ,/** * GtkWindow : focus - visible : * * Whether ' focus rectangles ' are currently visible in this window . * * This property is maintained by GTK based on user input * and should not be set by applications . "focus-visible" , NULL, NULL,TRUE ,/** * GtkWindow : icon - name : * * Specifies the name of the themed icon to use as the window icon . * * See [ class @ Gtk . IconTheme ] for more details . "icon-name" , NULL, NULL,/** * GtkWindow : display : * * The display that will display this window . "display" , NULL, NULL,/** * GtkWindow : is - active : * * Whether the toplevel is the currently active window . "is-active" , NULL, NULL,FALSE ,/** * GtkWindow : decorated : * * Whether the window should have a frame ( also known as * decorations * ) . "decorated" , NULL, NULL,TRUE ,/** * GtkWindow : deletable : * * Whether the window frame should have a close button . "deletable" , NULL, NULL,TRUE ,/** * GtkWindow : transient - for : * * The transient parent of the window . "transient-for" , NULL, NULL,;/** * GtkWindow : maximized : ( getter is_maximized ) * * Whether the window is maximized . * * Setting this property is the equivalent of calling * [ method @ Gtk . Window . maximize ] or [ method @ Gtk . Window . unmaximize ] ; * either operation is asynchronous , which means you will need to * connect to the : : notify signal in order to know whether the * operation was successful . "maximized" , NULL, NULL,FALSE ,/** * GtkWindow : fullscreened : ( getter is_fullscreen ) * * Whether the window is fullscreen . * * Setting this property is the equivalent of calling * [ method @ Gtk . Window . fullscreen ] or [ method @ Gtk . Window . unfullscreen ] ; * either operation is asynchronous , which means you will need to * connect to the : : notify signal in order to know whether the * operation was successful . "fullscreened" , NULL, NULL,FALSE ,/** * GtkWindow : suspended : ( getter is_suspended ) * * Whether the window is suspended . * * See [ method @ Gtk . Window . is_suspended ] for details about what suspended means . * * Since : 4 . 12 "suspended" , NULL, NULL,FALSE ,/** * GtkWindow : application : * * The ` GtkApplication ` associated with the window . * * The application will be kept alive for at least as long as it * has any windows associated with it ( see g_application_hold ( ) * for a way to keep it alive without windows ) . * * Normally , the connection between the application and the window * will remain until the window is destroyed , but you can explicitly * remove it by setting the this property to ` NULL ` . "application" , NULL, NULL,/** * GtkWindow : default - widget : * * The default widget . "default-widget" , NULL, NULL,/** * GtkWindow : focus - widget : ( getter get_focus ) ( setter set_focus ) * * The focus widget . "focus-widget" , NULL, NULL,/** * GtkWindow : child : * * The child widget . "child" , NULL, NULL,/** * GtkWindow : titlebar : * * The titlebar widget . * * Since : 4 . 6 "titlebar" , NULL, NULL,/** * GtkWindow : handle - menubar - accel : * * Whether the window frame should handle < kbd > F10 < / kbd > for activating * menubars . * * Since : 4 . 2 "handle-menubar-accel" , NULL, NULL,TRUE ,/** * GtkWindow : gravity : * * The gravity to use when resizing the window programmatically . * * Gravity describes which point of the window we want to keep * fixed ( meaning that the window will grow in the opposite direction ) . * For example , a gravity of ` GTK_WINDOW_GRAVITY_TOP_RIGHT ` means that we * want the to fix top right corner of the window . * * Since : 4 . 20 "gravity" , NULL, NULL,/** * GtkWindow : : activate - focus : * @ window : the window which emitted the signal * * Emitted when the user activates the currently focused * widget of @ window . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default binding for this signal is < kbd > ␣ < / kbd > . "activate-focus" ),0 );/** * GtkWindow : : activate - default : * @ window : the window which emitted the signal * * Emitted when the user activates the default widget . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * The keybindings for this signal are all forms of the < kbd > Enter < / kbd > key . "activate-default" ),0 );/** * GtkWindow : : keys - changed : * @ window : the window which emitted the signal * * Emitted when the set of accelerators or mnemonics that * are associated with the window changes . * * Deprecated : 4 . 10 : Use [ class @ Gtk . Shortcut ] and [ class @ Gtk . EventController ] * to implement keyboard shortcuts "keys-changed" ),0 );/** * GtkWindow : : enable - debugging : * @ window : the window which emitted the signal * @ toggle : toggle the debugger * * Emitted when the user enables or disables interactive debugging . * * When @ toggle is true , interactive debugging is toggled on or off , * when it is false , the debugger will be pointed at the widget * under the pointer . * * This is a [ keybinding signal ] ( class . SignalAction . html ) . * * The default bindings for this signal are * < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > I < / kbd > and * < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > D < / kbd > . * * Return : true if the key binding was handled "enable-debugging" ),1 , G_TYPE_BOOLEAN);/** * GtkWindow : : close - request : * @ window : the window which emitted the signal * * Emitted when the user clicks on the close button of the window . * * Return : true to stop other handlers from being invoked for the signal "close-request" ),0 );/** * GtkWindow : : force - close : * @ window : the window which emitted the signal * * Emitted when the compositor has decided to eliminate a window . * * @ window * has * to be in a hidden state after this signal was handled . * * Since : 4 . 24 "force-close" ),0 );/* * Key bindings /** * GtkWindow | default . activate : * * Activate the default widget . "default.activate" , NULL,/** * GtkWindow | window . minimize : * * Minimize the window . "window.minimize" , NULL,/** * GtkWindow | window . toggle - maximized : * * Maximize or restore the window . "window.toggle-maximized" , NULL,/** * GtkWindow | window . close : * * Close the window . "window.close" , NULL,ASK,"activate-focus" , NULL);MASK,"activate-default" , NULL);SHIFT_MASK,"enable-debugging" , "(b)" , FALSE );SHIFT_MASK,"enable-debugging" , "(b)" , TRUE );0 , GTK_DIR_TAB_FORWARD);RD);"window" ));/** * gtk_window_is_maximized : ( get - property maximized ) * @ window : a window * * Retrieves the current maximized state of the window . * * Note that since maximization is ultimately handled by the window * manager and happens asynchronously to an application request , you * shouldn ’ t assume the return value of this function changing * immediately ( or at all ) , as an effect of calling * [ method @ Gtk . Window . maximize ] or [ method @ Gtk . Window . unmaximize ] . * * If the window isn ' t yet mapped , the value returned will whether the * initial requested state is maximized . * * Returns : whether the window is maximized FALSE );return priv->maximized;/** * gtk_window_is_fullscreen : ( get - property fullscreened ) * @ window : a window * * Retrieves the current fullscreen state of the window . * * Note that since fullscreening is ultimately handled by the window * manager and happens asynchronously to an application request , you * shouldn ’ t assume the return value of this function changing * immediately ( or at all ) , as an effect of calling * [ method @ Gtk . Window . fullscreen ] or [ method @ Gtk . Window . unfullscreen ] . * * If the window isn ' t yet mapped , the value returned will whether the * initial requested state is fullscreen . * * Returns : whether the window is fullscreen FALSE );return priv->fullscreen;/** * gtk_window_is_suspended : ( get - property suspended ) * @ window : a window * * Retrieves the current suspended state of the window . * * A window being suspended means it ' s currently not visible * to the user , for example by being on a inactive workspace , * minimized , obstructed . * * Returns : whether the window is suspended * * Since : 4 . 12 FALSE );return priv->suspended;void if (priv->maximized)else /** * gtk_window_close : * @ window : a window * * Requests that the window is closed . * * This is similar to what happens when a window manager * close button is clicked . * * This function can be used with close buttons in custom * titlebars . void if (!_gtk_widget_get_realized (GTK_WIDGET (window)))return ;if (priv->in_emit_close_request)return ;if (!gtk_window_emit_close_request (window))static guintswitch (edge)case GDK_SURFACE_EDGE_NORTH_WEST:return GDK_TOPLEVEL_STATE_LEFT_RESIZABLE | GDK_TOPLEVEL_STATE_TOP_RESIZABLE;case GDK_SURFACE_EDGE_NORTH:return GDK_TOPLEVEL_STATE_TOP_RESIZABLE;case GDK_SURFACE_EDGE_NORTH_EAST:return GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE | GDK_TOPLEVEL_STATE_TOP_RESIZABLE;case GDK_SURFACE_EDGE_WEST:return GDK_TOPLEVEL_STATE_LEFT_RESIZABLE;case GDK_SURFACE_EDGE_EAST:return GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE;case GDK_SURFACE_EDGE_SOUTH_WEST:return GDK_TOPLEVEL_STATE_LEFT_RESIZABLE | GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;case GDK_SURFACE_EDGE_SOUTH:return GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;case GDK_SURFACE_EDGE_SOUTH_EAST:return GDK_TOPLEVEL_STATE_RIGHT_RESIZABLE | GDK_TOPLEVEL_STATE_BOTTOM_RESIZABLE;default :return 0 ;static int double d = gtk_css_number_value_get (value, 100 );if (d < 1 )return ceil (d);else return floor (d);static void ng_top);ding_left);->padding_bottom);adding_right);static int double x,double y)const graphene_rect_t *border_rect;float left, top;const GskRoundedRect *border;int resize_handle_size;#define edge_or_minus_one(edge) ((supports_edge_constraints && (priv->edge_constraints & constraints_for_edge (edge)) != constraints_for_edge (edge)) ? -1 : edge)if (!priv->client_decorated ||return -1 ;iv->surface));if (!supports_edge_constraints && priv->tiled)return -1 ;for (int i = 0 ; i < 4 ; i++))),if (priv->use_client_shadow)/* We use a maximum of RESIZE_HANDLE_SIZE pixels for the handle size */ /* This logic is duplicated in update_realized_window_properties() */ if (x < left && x >= left - handle_size.left)if (y < top + resize_handle_size && y >= top - handle_size.top)return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH_WEST);if (y > top + border_rect->size.height - resize_handle_size &&return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH_WEST);return edge_or_minus_one (GDK_SURFACE_EDGE_WEST);else if (x > left + border_rect->size.width &&if (y < top + resize_handle_size && y >= top - handle_size.top)return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH_EAST);if (y > top + border_rect->size.height - resize_handle_size &&return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH_EAST);return edge_or_minus_one (GDK_SURFACE_EDGE_EAST);else if (y < top && y >= top - handle_size.top)if (x < left + resize_handle_size && x >= left - handle_size.left)return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH_WEST);if (x > left + border_rect->size.width - resize_handle_size &&return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH_EAST);return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH);else if (y > top + border_rect->size.height &&if (x < left + resize_handle_size && x >= left - handle_size.left)return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH_WEST);if (x > left + border_rect->size.width - resize_handle_size &&return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH_EAST);return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH);if (!gsk_rounded_rect_contains_point (border, &p))if (gsk_rounded_rect_corner_box_contains_point (border, GSK_CORNER_TOP_LEFT, &p))return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH_WEST);if (gsk_rounded_rect_corner_box_contains_point (border, GSK_CORNER_TOP_RIGHT, &p))return edge_or_minus_one (GDK_SURFACE_EDGE_NORTH_EAST);if (gsk_rounded_rect_corner_box_contains_point (border, GSK_CORNER_BOTTOM_RIGHT, &p))return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH_EAST);if (gsk_rounded_rect_corner_box_contains_point (border, GSK_CORNER_BOTTOM_LEFT, &p))return edge_or_minus_one (GDK_SURFACE_EDGE_SOUTH_WEST);return -1 ;static void int n_press,double x,double y,double tx, ty;int edge;if (!event)return ;if (button != GDK_BUTTON_PRIMARY)return ;if (priv->maximized)return ;if (gdk_display_device_is_grabbed (gtk_widget_get_display (GTK_WIDGET (window)), device))return ;if (!priv->client_decorated)return ;if (edge == -1 )return ;static void while (l)if (focus->device == device)static void double x,double y)const char *cursor_names[8 ] = {"nw-resize" , "n-resize" , "ne-resize" ,"w-resize" , "e-resize" ,"sw-resize" , "s-resize" , "se-resize" int edge;if (edge != -1 &&0 )return ;if (edge != -1 )static void static void const char *name,static void const char *name,static void const char *name,static void const char *name,static gbooleandouble x,double y,return TRUE ;static void TRUE ;TRUE ;FALSE ;TRUE ;0 ;TRUE ;FALSE ;TRUE ;#ifdef GDK_WINDOWING_X11"notify::gtk-interface-color-scheme" ,#endif "background" );const char *[1 ]) { "application/x-rootwindow-drop" }, 1 ),"gtk-window-rootwindow-drop" );"drop" , G_CALLBACK (gtk_window_accept_rootwindow_drop), NULL);if (seat)"device-removed" ,"gtk-window-resize-cursor" );"enter" ,"motion" ,"leave" ,"gtk-window-visible-focus" );"key-pressed" ,"key-released" ,"gtk-window-toplevel-focus" );"event" ,0 ),t);"gtk-window-menubar-accel" );static void "gtk-window-resize" );0 );re),"pressed" ,ture));TRUE ,1 );static void const GValue *value,switch (prop_id)case PROP_TITLE:break ;case PROP_STARTUP_ID:break ;case PROP_RESIZABLE:break ;case PROP_MODAL:break ;case PROP_DEFAULT_WIDTH:TRUE , g_value_get_int (value),FALSE , -1 );break ;case PROP_DEFAULT_HEIGHT:FALSE , -1 ,TRUE , g_value_get_int (value));break ;case PROP_DESTROY_WITH_PARENT:break ;case PROP_HIDE_ON_CLOSE:break ;case PROP_ICON_NAME:break ;case PROP_DISPLAY:break ;case PROP_DECORATED:break ;case PROP_DELETABLE:break ;case PROP_TRANSIENT_FOR:break ;case PROP_APPLICATION:break ;case PROP_DEFAULT_WIDGET:break ;case PROP_MNEMONICS_VISIBLE:break ;case PROP_FOCUS_VISIBLE:break ;case PROP_MAXIMIZED:if (g_value_get_boolean (value))else break ;case PROP_FULLSCREENED:if (g_value_get_boolean (value))else break ;case PROP_FOCUS_WIDGET:break ;case PROP_CHILD:break ;case PROP_TITLEBAR:break ;case PROP_HANDLE_MENUBAR_ACCEL:break ;case PROP_GRAVITY:break ;default :break ;static void switch (prop_id)case PROP_TITLE:break ;case PROP_RESIZABLE:break ;case PROP_MODAL:break ;case PROP_DEFAULT_WIDTH:break ;case PROP_DEFAULT_HEIGHT:break ;case PROP_DESTROY_WITH_PARENT:break ;case PROP_HIDE_ON_CLOSE:break ;case PROP_ICON_NAME:break ;case PROP_DISPLAY:break ;case PROP_IS_ACTIVE:break ;case PROP_DECORATED:break ;case PROP_DELETABLE:break ;case PROP_TRANSIENT_FOR:break ;case PROP_APPLICATION:break ;case PROP_DEFAULT_WIDGET:break ;case PROP_MNEMONICS_VISIBLE:break ;case PROP_FOCUS_VISIBLE:break ;case PROP_MAXIMIZED:break ;case PROP_FULLSCREENED:break ;case PROP_SUSPENDED:break ;case PROP_FOCUS_WIDGET:break ;case PROP_CHILD:break ;case PROP_TITLEBAR:break ;case PROP_HANDLE_MENUBAR_ACCEL:break ;case PROP_GRAVITY:break ;default :break ;static void static void const char *type)if (type && strcmp (type, "titlebar" ) == 0 )"titlebar" , "titlebar" );else if (GTK_IS_WIDGET (child))"child" );else static void static GdkDisplay *return priv->display;static GdkSurface *return priv->surface;static GskRenderer *return priv->renderer;static GtkConstraintSolver *if (!priv->constraint_solver)/* Shared constraint solver */ return priv->constraint_solver;static GtkWidget *return priv->focus_widget;static void synthesize_focus_change_events (GtkWindow *window,static void if (focus && !gtk_widget_is_sensitive (focus))return ;if (focus == priv->focus_widget)if (priv->move_focus &&FALSE ;return ;if (priv->focus_widget)if (old_focus)FALSE );if (focus)if (priv->move_focus &&FALSE ;static void double *x,double *y)const graphene_rect_t *margin_rect;static void int width,int height)if (priv->surface_width != width || priv->surface_height != height)/* This fake motion event is needed for getting up to date pointer focus * and coordinates when tho pointer didn ' t move but the layout changed * within the window . if (gtk_widget_needs_allocate (widget))if (seat)if (focus)if (surface)if (gtk_widget_needs_allocate (widget))1 , NULL);else static void static void /** * gtk_window_new : * * Creates a new ` GtkWindow ` . * * To get an undecorated window ( without window borders ) , * use [ method @ Gtk . Window . set_decorated ] . * * All top - level windows created by this function are stored * in an internal top - level window list . This list can be obtained * from [ func @ Gtk . Window . list_toplevels ] . Due to GTK keeping a * reference to the window internally , this function does not * return a reference to the caller . * * To delete a ` GtkWindow ` , call [ method @ Gtk . Window . destroy ] . * * Returns : a new ` GtkWindow ` void )return g_object_new (GTK_TYPE_WINDOW, NULL);/** * gtk_window_set_title : * @ window : a window * @ title : ( nullable ) : title of the window * * Sets the title of the window . * * The title of a window will be displayed in its title bar ; on the * X Window System , the title bar is rendered by the window manager * so exactly how the title appears to users may vary according to a * user ’ s exact configuration . The title should help a user distinguish * this window from other windows they may have open . A good title might * include the application name and current document filename , for example . * * Passing ` NULL ` does the same as setting the title to an empty string . void const char *title)char *new_title;if (_gtk_widget_get_realized (GTK_WIDGET (window)))"" );1 );/** * gtk_window_get_title : * @ window : a window * * Retrieves the title of the window . * * Returns : ( nullable ) : the title const char *return priv->title;/** * gtk_window_set_default_widget : * @ window : a window * @ default_widget : ( nullable ) : widget to be the default * * Sets the default widget . * * The default widget is the widget that is activated * when the user presses < kbd > Enter < / kbd > in a dialog * ( for example ) . void if (priv->default_widget != default_widget)if (default_widget)if (priv->default_widget)if (priv->focus_widget != priv->default_widget ||FALSE );FALSE ;if (priv->default_widget)if (priv->focus_widget == NULL ||TRUE );if (default_widget)/** * gtk_window_get_default_widget : * @ window : a window * * Returns the default widget for @ window . * * Returns : ( nullable ) ( transfer none ) : the default widget return priv->default_widget;static gbooleanif (priv->application_shortcut_controller)hortcut_controller));0 );return G_SOURCE_REMOVE;void if (!priv->keys_changed_handler)"[gtk] handle_keys_changed" );/** * gtk_window_get_focus : ( get - property focus - widget ) * @ window : a window * * Retrieves the current focused widget within the window . * * Note that this is the widget that would have the focus * if the toplevel window focused ; if the toplevel window * is not focused then ` gtk_widget_has_focus ( widget ) ` will * not be false for the widget . * * Returns : ( nullable ) ( transfer none ) : the currently focused widget return priv->focus_widget;static void if (priv->default_widget && gtk_widget_is_sensitive (priv->default_widget) &&else if (priv->focus_widget && gtk_widget_is_sensitive (priv->focus_widget))/** * gtk_window_set_modal : * @ window : a window * @ modal : whether the window is modal * * Sets a window modal or non - modal . * * Modal windows prevent interaction with other windows in the same * application . To keep modal dialogs on top of main application windows , * use [ method @ Gtk . Window . set_transient_for ] to make the dialog transient * for the parent ; most window managers will then disallow lowering the * dialog below the parent . void FALSE ;if (priv->modal == modal)return ;if (_gtk_widget_get_realized (widget))if (gtk_widget_get_visible (widget))if (priv->modal)else 1 );/** * gtk_window_get_modal : * @ window : a window * * Returns whether the window is modal . * * Returns : true if the window is set to be modal and * establishes a grab when shown FALSE );return priv->modal;/** * gtk_window_get_toplevels : * * Returns the list of all existing toplevel windows . * * If you want to iterate through the list and perform actions involving * callbacks that might destroy the widgets or add new ones , be aware that * the list of toplevels will change and emit the " items - changed " signal . * * Returns : ( transfer none ) ( attributes element - type = GtkWindow ) : the list * of toplevel widgets void )if (toplevel_list == NULL)return G_LIST_MODEL (toplevel_list);/** * gtk_window_list_toplevels : * * Returns the list of all existing toplevel windows . * * The widgets in the list are not individually referenced . * If you want to iterate through the list and perform actions * involving callbacks that might destroy the widgets , you must * call ` g_list_foreach ( result , ( GFunc ) g_object_ref , NULL ) ` first , * and then unref all the widgets afterwards . * * Returns : ( element - type GtkWidget ) ( transfer container ) : list of * toplevel widgets void )for (i = 0 ; i < g_list_model_get_n_items (toplevels); i++)return list;static void if (priv->transient_parent)if (priv->group)static void if (priv->destroy_with_parent)static void ;if (_gtk_widget_get_realized (window))static void if (_gtk_widget_get_realized (window))static void static void if (priv->transient_parent)if (priv->transient_parent_group)FALSE ;/** * gtk_window_set_transient_for : * @ window : a window * @ parent : ( nullable ) : parent window * * Sets a transient parent for the window . * * Dialog windows should be set transient for the main application * window they were spawned from . This allows window managers to e . g . * keep the dialog on top of the main window , or center the dialog * over the main window . [ ctor @ Gtk . Dialog . new_with_buttons ] and other * convenience functions in GTK will sometimes call this function on * your behalf . * * Passing ` NULL ` for @ parent unsets the current transient window . * * On Windows , this function puts the child window on top of the parent , * much as the window manager would have done on X . void if (priv->transient_parent)if (_gtk_widget_get_realized (GTK_WIDGET (window)) &&if (parent)"realize" ,"unrealize" ,"notify::display" ,"destroy" ,if (_gtk_widget_get_realized (GTK_WIDGET (window)) &&if (parent_priv->group)TRUE ;/** * gtk_window_get_transient_for : * @ window : a window * * Fetches the transient parent for this window . * * Returns : ( nullable ) ( transfer none ) : the transient parent return priv->transient_parent;/** * gtk_window_get_application : * @ window : a window * * Gets the application object associated with the window . * * Returns : ( nullable ) ( transfer none ) : the application return priv->application;static void if (priv->application)/* steal reference into temp variable */ /** * gtk_window_set_application : * @ window : a window * @ application : ( nullable ) : a ` GtkApplication ` * * Sets or unsets the application object associated with the window . * * The application will be kept alive for at least as long as it has * any windows associated with it ( see [ method @ Gio . Application . hold ] * for a way to keep it alive without windows ) . * * Normally , the connection between the application and the window will * remain until the window is destroyed , but you can explicitly remove * it by setting the @ application to % NULL . * * This is equivalent to calling [ method @ Gtk . Application . remove_window ] * and / or [ method @ Gtk . Application . add_window ] on the old / new applications * as relevant . void if (priv->application != application)if (priv->application != NULL)pplication_accels_get_shortcuts (app_accels));"gtk-application-shortcuts" );GTK_PHASE_CAPTURE);cut_controller), GTK_SHORTCUT_SCOPE_GLOBAL);r);/** * gtk_window_set_destroy_with_parent : * @ window : a window * @ setting : whether to destroy the window with its transient parent * * Sets whether to destroy the window when the transient parent is destroyed . * * This is useful for dialogs that shouldn ’ t persist beyond the lifetime * of the main window they are associated with , for example . void if (priv->destroy_with_parent == (setting != FALSE ))return ;);/** * gtk_window_get_destroy_with_parent : * @ window : a window * * Returns whether the window will be destroyed with its transient parent . * * Returns : true if the window will be destroyed with its transient parent FALSE );return priv->destroy_with_parent;/** * gtk_window_set_hide_on_close : * @ window : a window * @ setting : whether to hide the window when it is closed * * Sets whether clicking the close button will hide the window instead * of destroying it . void if (priv->hide_on_close == setting)return ;/** * gtk_window_get_hide_on_close : * @ window : a window * * Returns whether the window will be hidden instead of destroyed when the close * button is clicked . * * Returns : true if the window will be hidden FALSE );return priv->hide_on_close;static GtkWindowGeometryInfo*if (!info && create)1 );0 ;0 ;1 ;1 ;return info;static void if (priv->title_box != NULL)static gbooleanreturn gdk_display_is_rgba (display) && gdk_display_is_composited (display);static gbooleanreturn gdk_display_supports_shadow_width (display);static void /* We need a visual with alpha for rounded corners */ if (gtk_window_is_composited (window))"csd" );else "solid-csd" );TRUE ;/** * gtk_window_set_titlebar : * @ window : a window * @ titlebar : ( nullable ) : the widget to use as titlebar * * Sets a custom titlebar for the window . * * A typical widget used here is [ class @ Gtk . HeaderBar ] , as it * provides various features expected of a titlebar while allowing * the addition of child widgets to it . * * If you set a custom titlebar , GTK will do its best to convince * the window manager not to put its own titlebar on the window . * Depending on the system , this function may not work for a window * that is already visible , so you set the titlebar before calling * [ method @ Gtk . Widget . show ] . void if (priv->titlebar == titlebar)return ;if ((!priv->title_box && titlebar) || (priv->title_box && !titlebar))if (_gtk_widget_get_realized (widget))"gtk_window_set_titlebar() called on a realized window" );else FALSE ;if (titlebar == NULL)/* these are updated in realize() */ FALSE ;"csd" );"solid-csd" );else "titlebar" );if (was_mapped)/** * gtk_window_get_titlebar : * @ window : a window * * Returns the titlebar that has been set with * [ method @ Gtk . Window . set_titlebar ] . * * Returns : ( nullable ) ( transfer none ) : the titlebar return priv->titlebar;/** * gtk_window_set_decorated : * @ window : a window * @ setting : true to decorate the window * * Sets whether the window should be decorated . * * By default , windows are decorated with a title bar , resize * controls , etc . Some window managers allow GTK to disable these * decorations , creating a borderless window . If you set the decorated * property to false using this function , GTK will do its best to * convince the window manager not to decorate the window . Depending on * the system , this function may not have any effect when called on a * window that is already visible , so you should call it before calling * [ method @ Gtk . Widget . show ] . * * On Windows , this function always works , since there ’ s no window manager * policy involved . void FALSE ;if (setting == priv->decorated)return ;if (priv->surface)_decorated);/** * gtk_window_get_decorated : * @ window : a window * * Returns whether the window has been set to have decorations . * * Returns : true if the window has been set to have decorations TRUE );return priv->decorated;/** * gtk_window_set_deletable : * @ window : a window * @ setting : true to decorate the window as deletable * * Sets whether the window should be deletable . * * By default , windows have a close button in the window frame . * Some window managers allow GTK to disable this button . If you * set the deletable property to false using this function , GTK * will do its best to convince the window manager not to show a * close button . Depending on the system , this function may not * have any effect when called on a window that is already visible , * so you should call it before calling [ method @ Gtk . Widget . show ] . * * On Windows , this function always works , since there ’ s no window * manager policy involved . void FALSE ;if (setting == priv->deletable)return ;if (priv->surface)/** * gtk_window_get_deletable : * @ window : a window * * Returns whether the window has been set to have a close button . * * Returns : true if the window has been set to have a close button TRUE );return priv->deletable;static GtkWindowIconInfo*return g_object_get_qdata (G_OBJECT (window), quark_gtk_window_icon_info);static void static GtkWindowIconInfo*if (info == NULL)1 );return info;static int int area_a, area_b;return area_a - area_b;static GdkTexture *int width, height;return texture;static GList *const char *name)int *sizes;int i;int scale;for (i = 0 ; sizes[i]; i++)/* FIXME * We need an EWMH extension to handle scalable icons * by passing their name to the WM . For now just use a * fixed size of 48 . if (sizes[i] == -1 )48 , scale,else return list;static void if (info->realized)return ;FALSE ;FALSE ;/* Look up themed icon */ if (icon_list == NULL && info->icon_name)if (icon_list)TRUE ;/* Look up themed icon */ if (icon_list == NULL && default_icon_name)TRUE ;TRUE ;TRUE ;if (info->using_themed_icon)int size)const char *name;int scale;if (!name)if (!name)return NULL;splay (GTK_WIDGET (window))),if (info == NULL)return NULL;return GDK_PAINTABLE (info);static void if (info == NULL)return ;/* We don't clear the properties on the window, just figure the * window is going away . FALSE ;static void if (_gtk_widget_get_realized (GTK_WIDGET (window)))/** * gtk_window_set_icon_name : * @ window : a window * @ name : ( nullable ) : the name of the themed icon * * Sets the icon for the window from a named themed icon . * * See the docs for [ class @ Gtk . IconTheme ] for more details . * On some platforms , the window icon is not used at all . * * Note that this has nothing to do with the WM_ICON_NAME * property which is mentioned in the ICCCM . void const char *name)char *tmp;if (g_strcmp0 (info->icon_name, name) == 0 )return ;/** * gtk_window_get_icon_name : * @ window : a window * * Returns the name of the themed icon for the window . * * Returns : ( nullable ) : the icon name const char *return info->icon_name;/** * gtk_window_set_default_icon_name : * @ name : the name of the themed icon * * Sets an icon to be used as fallback . * * The fallback icon is used for windows that * haven ' t had [ method @ Gtk . Window . set_icon_name ] * called on them . void const char *name)/* Update all toplevels */ while (tmp_list != NULL)if (info && info->using_default_icon && info->using_themed_icon)if (_gtk_widget_get_realized (GTK_WIDGET (w)))/** * gtk_window_get_default_icon_name : * * Returns the fallback icon name for windows . * * The returned string is owned by GTK and should not * be modified . It is only valid until the next call to * [ func @ Gtk . Window . set_default_icon_name ] . * * Returns : ( nullable ) : the fallback icon name for windows const char *void )return default_icon_name;static void int *width,int *height,int apply)0 };int w, h;if (!priv->decorated ||return ;/* Make sure the size remains acceptable */ if (w < 1 )1 ;if (h < 1 )1 ;/* Only update given size if not negative */ if (*width > -1 )if (*height > -1 )static void int width,int height)FALSE || width >= -1 );FALSE || height >= -1 );if (change_width)if (priv->default_width != width)if (change_height)if (priv->default_height != height)/** * gtk_window_set_default_size : * @ window : a window * @ width : width in pixels , or - 1 to unset the default width * @ height : height in pixels , or - 1 to unset the default height * * Sets the default size of a window . * * The default size of a window is the size that will be used * if no other constraints apply . * * The default size will be updated whenever the window is resized * to reflect the new size , unless the window is forced to a size , * like when it is maximized or fullscreened . * * If the window ’ s minimum size request is larger than * the default , the default will be ignored . * * Setting the default size to a value < = 0 will cause it to be * ignored and the natural size request will be used instead . It * is possible to do this while the window is showing to " reset " * it to its initial size . * * Unlike [ method @ Gtk . Widget . set_size_request ] , which sets a size * request for a widget and thus would keep users from shrinking * the window , this function only sets the initial size , just as * if the user had resized the window themselves . Users can still * shrink the window again as they normally would . Setting a default * size of - 1 means to use the “ natural ” default size ( the size request * of the window ) . * * If you use this function to reestablish a previously saved window size , * note that the appropriate size to save is the one returned by * [ method @ Gtk . Window . get_default_size ] . Using the window allocation * directly will not work in all circumstances and can lead to growing * or shrinking windows . void int width,int height)1 );1 );TRUE , width, TRUE , height);/** * gtk_window_get_default_size : * @ window : a window * @ width : ( out ) ( optional ) : location to store the default width * @ height : ( out ) ( optional ) : location to store the default height * * Gets the default size of the window . * * A value of 0 for the width or height indicates that a default * size has not been explicitly set for that dimension , so the * “ natural ” size of the window will be used . * * This function is the recommended way for [ saving window state * across restarts of applications ] ( https : //developer.gnome.org/documentation/tutorials/save-state.html). void int *width,int *height)if (width != NULL)if (height != NULL)static gbooleanif (priv->hide_on_close)FALSE );return TRUE ;return FALSE ;/* Avoid re-entrancy issues when calling gtk_window_close from a if (priv->in_emit_close_request)return TRUE ;TRUE ;0 , &handled);FALSE ;return handled;static void if (priv->hide_on_close)FALSE );else static void /* Avoid re-entrancy issues when calling gtk_window_close from a if (priv->in_emit_force_close)return ;TRUE ;0 );FALSE ;if (gtk_widget_is_visible (GTK_WIDGET (window)))"Gtk.Window::force-close did not leave window in a hidden state" );static void if (priv->geometry_info)if (seat)#ifdef GDK_WINDOWING_X11#endif static gbooleanif (priv->title_box == NULL)return FALSE ;return visible;static void if (priv->surface)else "window.minimize" ,"window.toggle-maximized" ,IMIZE));"window.close" ,static gbooleanconst char *csd_env;if (!priv->decorated)return FALSE ;"GTK_CSD" );#ifdef GDK_WINDOWING_BROADWAYif (GDK_IS_BROADWAY_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))return TRUE ;#endif #ifdef GDK_WINDOWING_WAYLANDif (GDK_IS_WAYLAND_DISPLAY (gtk_widget_get_display (GTK_WIDGET (window))))return !gdk_wayland_display_prefers_ssd (gdk_display);#endif #ifdef GDK_WINDOWING_WIN32if (g_strcmp0 (csd_env, "0" ) != 0 &&return TRUE ;#endif return (g_strcmp0 (csd_env, "1" ) == 0 );static void if (!g_list_store_find (toplevel_list, window, NULL))"A window is shown after it has been destroyed. This will leave the window in an inconsistent state." );TRUE );if (!priv->focus_widget)if (priv->modal)static void FALSE );if (priv->modal)static GdkToplevelLayout *return layout;static void if (priv->is_set_maximized)if (priv->is_set_fullscreen)static void if (_gtk_widget_get_mapped (GTK_WIDGET (window)))static void if (!disable_startup_notification)/* Do we have a custom startup-notification id? */ if (priv->startup_id != NULL)/* Make sure we have a "real" id */ if (!startup_id_is_fake (priv->startup_id))else static void if (child != NULL && gtk_widget_get_visible (child))if (priv->title_box != NULL &&if (priv->minimize_initially)if (!priv->in_present)/* inherit from transient parent, so that a dialog that is * opened via keynav shows focus initially if (priv->transient_parent)parent));else FALSE );if (priv->application)static void FALSE );TRUE ,1 );if (priv->title_box != NULL)if (child != NULL)static void if (!priv->decorated)goto out;if (!priv->client_decorated ||goto out;if (priv->maximized ||goto out;/* Calculate the size of the drop shadows ... */ return ;0 , 0 , 0 , 0 };static void const graphene_rect_t *border_rect;double native_x, native_y;if (!priv->client_decorated || !priv->use_client_shadow)return ;/* update the input shape, which makes it so that clicks /* This logic is duplicated in get_edge_for_coordinates() */ 2 * RESIZE_HANDLE_SIZE;2 * RESIZE_HANDLE_SIZE;if (rect.width > 0 && rect.height > 0 )/* NB: When orientation is VERTICAL, width/height are flipped. * The code uses the terms nonetheless to make it more intuitive * to understand . static void int current_width,int current_height,int *min_width,int *min_height)double current_ratio = (double ) current_width / current_height;int start_width, end_width, start_height, end_height;/* * We ' d want to do * gtk_widget_measure ( window , orientation , current_height , * & start_width , NULL , NULL , NULL ) ; * to find the smallest acceptable width for the ' start_width ' bound * here ; but it could be expensive to measure the whole window against * its preferred mode . Instead , since we ' re doing a binary search * anyway , start with the overall minimum width , and reject widths * that would require a larger height in the loop below . 1 , &start_width, NULL, NULL, NULL);if (end_height == current_height)/* The current height is the minimum height for this width. Don't return ;/* The width we're looking for is always between start_width and * end_width , inclusive . We stop the search either when we discover * equal heights at both ends , or when there are just two options left * on either sides of the current ratio . while (start_height > end_height && start_width + 1 < end_width)int mid_width, mid_height;double mid_ratio;2 ;double ) mid_width / mid_height;if (mid_ratio == current_ratio)return ;else if (mid_ratio < current_ratio)/* This includes the case where mid_height > current_height */ else /* Between the 'start' and 'end' points, whose widths could either be * the same or differ by one , pick ' end ' because it ' s guaranteed * to be < = ' current ' for both width and height , while ' start ' may * have a larger height . if (start_height > end_height)/* Must have broken out of the loop because we saw start_width and * end_width differ by exactly one . This means end_width must be * the minimum width for end_height , so no need to measure the * widget here again , against its preferred size request mode . 1 == end_width);else static void int cur_width,int cur_height,int max_width,int max_height,int *min_width,int *min_height,int *width,int *height)if (request_mode == GTK_SIZE_REQUEST_WIDTH_FOR_HEIGHT)int minimum, natural;1 ,if (cur_height <= 0 )if (cur_width <= 0 )else /* GTK_SIZE_REQUEST_HEIGHT_FOR_WIDTH or CONSTANT_SIZE */ int minimum, natural;1 ,if (cur_width <= 0 )if (cur_height <= 0 )if (request_mode != GTK_SIZE_REQUEST_CONSTANT_SIZE)static gbooleanif (!priv->resizable)return FALSE ;return !(priv->state & (GDK_TOPLEVEL_STATE_FULLSCREEN |static void int width, height;int bounds_width, bounds_height;int min_width, min_height;if (width < min_width)if (height < min_height)if (should_remember_size (window))TRUE , width, TRUE , height);if (priv->use_client_shadow)static void int old_scale;/* Create default title bar */ if (!priv->client_decorated && gtk_window_should_use_csd (window))if (gtk_window_is_composited (window))if (priv->title_box == NULL)"titlebar" );"default-decoration" );else FALSE ;else // unrealize() always sets use_client_shadow to FALSE, thus restore it here ndow);if (priv->renderer == NULL)TRUE );"notify::state" , G_CALLBACK (surface_state_changed), widget);"notify::mapped" , G_CALLBACK (surface_state_changed), widget);"notify::capabilities" , G_CALLBACK (update_window_actions), widget);"event" , G_CALLBACK (surface_event), widget);"compute-size" , G_CALLBACK (toplevel_compute_size), widget);"after-paint" , G_CALLBACK (after_paint), widget);if (priv->transient_parent &&nt);if (priv->title)rated);#ifdef GDK_WINDOWING_X11if (priv->startup_id)if (GDK_IS_X11_SURFACE (surface))if (timestamp != GDK_CURRENT_TIME)if (priv->initial_timestamp != GDK_CURRENT_TIME)if (GDK_IS_X11_SURFACE (surface))#endif if (priv->application)if (old_scale != gtk_widget_get_scale_factor (widget))static void /* On unrealize, we reset the size of the window such * that we will re - apply the default sizing stuff * next time we show the window . * * Default positioning is reset on unmap , instead of unrealize . TRUE ;FALSE );if (info)0 ;0 ;1 ;1 ;/* be sure we reset geom hints on re-realize */ 0 ;/* Icons */ if (priv->title_box)if (priv->child)FALSE ;static inline void const char *class )if (add)class );else class );static void if (!constraints)"tiled-top" );"tiled-right" );"tiled-bottom" );"tiled-left" );"tiled" );else "tiled" );"tiled-top" );"tiled-right" );"tiled-bottom" );"tiled-left" );"resizable-top" );"resizable-right" );"resizable-bottom" );"resizable-left" );"maximized" );"fullscreen" );/* _gtk_window_set_allocation: * @ window : a ` GtkWindow ` * @ width : the original width for the window * @ height : the original height for the window * @ allocation_out : ( out ) : @ allocation taking decorations * into consideration * * This function is like gtk_widget_set_allocation ( ) * but does the necessary extra work to update * the resize grip positioning , etc . * * Call this instead of gtk_widget_set_allocation ( ) * when overriding : : size_allocate in a GtkWindow * subclass without chaining up . * * The @ allocation parameter will be adjusted to * reflect any internal decorations that the window * may have . That revised allocation will then be * returned in the @ allocation_out parameter . void int width,int height,0 ;0 ;if (_gtk_widget_get_realized (widget))0 ;if (priv->title_box != NULL &&0 ;0 ;1 );if (priv->decorated &&static void int width,int height,int baseline)if (child && gtk_widget_get_visible (child))1 );static void 1 : 0 ;static void if (changed_mask & GDK_TOPLEVEL_STATE_FOCUSED)if (!focused)FALSE );if (changed_mask & GDK_TOPLEVEL_STATE_FULLSCREEN)TRUE : FALSE ;if (changed_mask & GDK_TOPLEVEL_STATE_MAXIMIZED)TRUE : FALSE ;if (changed_mask & GDK_TOPLEVEL_STATE_SUSPENDED)TRUE : FALSE ;if (changed_mask & (GDK_TOPLEVEL_STATE_FULLSCREEN |if (priv->surface->destroyed)"Unrealizing window %p as its surface (%p) got destroyed" , widget, priv->surface);static void int width,int height)if (should_remember_size (window))int width_to_remember;int height_to_remember;TRUE , width_to_remember,TRUE , height_to_remember);static void if (priv->move_focus)while (parent)if (_gtk_widget_get_visible (parent))if (gtk_widget_grab_focus (parent))break ;if (!parent)FALSE ;if (priv->unset_default)static void static gbooleanreturn gtk_main_do_event (event);static void if (priv->focus_widget && gtk_widget_is_sensitive (priv->focus_widget))static gbooleanFALSE ;for (s = seats; s; s = s->next)if ((mask & gtk_accelerator_get_default_mod_mask ()) == GDK_ALT_MASK)TRUE ;break ;return retval;static gbooleandouble x,double y)if (gdk_event_get_event_type (event) != GDK_FOCUS_CHANGE)return FALSE ;if (gdk_focus_event_get_in (event))TRUE );if (gtk_window_has_mnemonic_modifier_pressed (window))else FALSE );FALSE );return TRUE ;static void if ((keyval == GDK_KEY_Alt_L || keyval == GDK_KEY_Alt_R) &&0 ))if (visible)else FALSE );void if (visible)if (priv->focus_visible)else if ((keyval == GDK_KEY_Alt_L || keyval == GDK_KEY_Alt_R) &&0 ))TRUE );else if (priv->key_press_focus == priv->focus_widget)FALSE );else TRUE );static gbooleanTRUE );TRUE );return FALSE ;static gbooleanFALSE );FALSE );return FALSE ;static gboolean/* We need a special implementation here to deal properly with wrapping * around in the tab chain without the danger of going into an * infinite loop . if (old_focus_child)if (gtk_widget_child_focus (old_focus_child, direction))return TRUE ;if (priv->focus_widget)if (direction == GTK_DIR_LEFT ||return FALSE ;/* Wrapped off the end, clear the focus setting for the toplpevel */ while (parent)/* Now try to focus the first widget in the window, * taking care to hook titlebar widgets into the * focus chain . if (priv->title_box != NULL &&else if (child)if (gtk_widget_child_focus (child, direction))return TRUE ;else if (priv->title_box != NULL &&return TRUE ;else if (priv->title_box == child &&return TRUE ;return FALSE ;static void if (!gtk_widget_get_focus_child (widget))void #ifdef G_ENABLE_DEBUGif (crossing->old_target == NULL)else if (crossing->old_descendent == NULL)t, widget));else ossing->old_target, crossing->old_descendent));if (crossing->new_target == NULL)else if (crossing->new_descendent == NULL)t, widget));else ossing->new_target, crossing->new_descendent));#endif static void int i;if (old_focus == new_focus)return ;if (old_focus && new_focus)else if (gtk_window_get_focus_visible (GTK_WINDOW (window)))FALSE ;while (widget)if (seen_ancestor)else if (widget == ancestor)for (w = new_focus; w != ancestor; w = gtk_widget_get_parent (w))TRUE ;else 0 , 0 );if (gtk_window_get_focus_visible (GTK_WINDOW (window)))for (widget = new_focus; widget; widget = _gtk_widget_get_parent (widget))FALSE ;for (i = gtk_widget_stack_get_size (&focus_array) - 1 ; i >= 0 ; i--)if (i > 0 )1 );else if (seen_ancestor)else if (widget == ancestor)for (w = old_focus; w != ancestor; w = gtk_widget_get_parent (w))TRUE ;else 0 , 0 );if (i == 0 )FALSE );/** * gtk_window_set_focus : ( set - property focus - widget ) * @ window : a window * @ focus : ( nullable ) : the new focus widget * * Sets the focus widget . * * If @ focus is not the current focus widget , and is focusable , * sets it as the focus widget for the window . If @ focus is % NULL , * unsets the focus widget for this window . To set the focus to a * particular widget in the toplevel , it is usually more convenient * to use [ method @ Gtk . Widget . grab_focus ] instead of this function . void if (focus)else /* * _ gtk_window_unset_focus_and_default : * @ window : a window * @ widget : a widget inside of @ window * * Checks whether the focus and default widgets of @ window are * @ widget or a descendent of @ widget , and if so , unset them . void if (child && (child == widget || gtk_widget_is_ancestor (child, widget)))TRUE ;if (child && (child == widget || gtk_widget_is_ancestor (child, widget)))TRUE ;if ((priv->move_focus || priv->unset_default) &&#undef INCLUDE_CSD_SIZE#undef EXCLUDE_CSD_SIZEstatic void if (gtk_widget_get_visible (widget))/* Translate a timestamp of GDK_CURRENT_TIME appropriately */ if (timestamp == GDK_CURRENT_TIME)#ifdef GDK_WINDOWING_X11if (GDK_IS_X11_SURFACE (priv->surface))else #endif else TRUE ;TRUE );FALSE ;/** * gtk_window_set_startup_id : * @ window : a window * @ startup_id : a string with startup - notification identifier * * Sets the startup notification ID . * * Startup notification identifiers are used by desktop environment * to track application startup , to provide user feedback and other * features . This function changes the corresponding property on the * underlying ` GdkSurface ` . * * Normally , startup identifier is managed automatically and you should * only use this function in special cases like transferring focus from * other processes . You should use this function before calling * [ method @ Gtk . Window . present ] or any equivalent function generating * a window map event . * * This function is only useful on Wayland or X11 , not with other GDK * backends . void const char *startup_id)if (_gtk_widget_get_realized (widget))#ifdef GDK_WINDOWING_X11if (timestamp != GDK_CURRENT_TIME && GDK_IS_X11_SURFACE (priv->surface))#endif /* Here we differentiate real and "fake" startup notification IDs, * constructed on purpose just to pass interaction timestamp if (startup_id_is_fake (priv->startup_id))else /* If window is mapped, terminate the startup-notification */ if (_gtk_widget_get_mapped (widget) && !disable_startup_notification)/** * gtk_window_present : * @ window : a window * * Presents a window to the user . * * This may mean raising the window in the stacking order , * unminimizing it , moving it to the current desktop and / or * giving it the keyboard focus ( possibly dependent on the user ’ s * platform , window manager and preferences ) . * * If @ window is hidden , this function also makes it visible . void /** * gtk_window_present_with_time : * @ window : a window * @ timestamp : the timestamp of the user interaction ( typically a * button or key press event ) which triggered this call * * Presents a window to the user in response to an user interaction . * * See [ method @ Gtk . Window . present ] for more details . * * The timestamp should be gathered when the window was requested * to be shown ( when clicking a link for example ) , rather than once * the window is ready to be shown . * * Deprecated : 4 . 14 : Use [ method @ Gtk . Window . present ] void /** * gtk_window_minimize : * @ window : a window * * Asks to minimize the window . * * Note that you shouldn ’ t assume the window is definitely minimized * afterward , because the windowing system might not support this * functionality ; other entities ( e . g . the user or the window manager ) * could unminimize it again , or there may not be a window manager in * which case minimization isn ’ t possible , etc . * * It ’ s permitted to call this function before showing a window , * in which case the window will be minimized before it ever appears * onscreen . * * You can track result of this operation via the * [ property @ Gdk . Toplevel : state ] property . void TRUE ;if (priv->surface)/** * gtk_window_unminimize : * @ window : a window * * Asks to unminimize the window . * * Note that you shouldn ’ t assume the window is definitely unminimized * afterward , because the windowing system might not support this * functionality ; other entities ( e . g . the user or the window manager ) * could minimize it again , or there may not be a window manager in * which case minimization isn ’ t possible , etc . * * You can track result of this operation via the * [ property @ Gdk . Toplevel : state ] property . void FALSE ;/** * gtk_window_maximize : * @ window : a window * * Asks to maximize the window , so that it fills the screen . * * Note that you shouldn ’ t assume the window is definitely maximized * afterward , because other entities ( e . g . the user or window manager ) * could unmaximize it again , and not all window managers support * maximization . * * It ’ s permitted to call this function before showing a window , * in which case the window will be maximized when it appears onscreen * initially . * * If a window is not explicitly maximized or unmaximized before it is * shown , the initial state is at the window managers discretion . For * example , it might decide to maximize a window that almost fills the * screen . * * You can track the result of this operation via the * [ property @ Gdk . Toplevel : state ] property , or by listening to * notifications on the [ property @ Gtk . Window : maximized ] * property . void TRUE ;if (_gtk_widget_get_mapped (GTK_WIDGET (window)))TRUE );else if (!priv->maximized)TRUE ;/** * gtk_window_unmaximize : * @ window : a window * * Asks to unmaximize the window . * * Note that you shouldn ’ t assume the window is definitely unmaximized * afterward , because other entities ( e . g . the user or window manager ) * maximize it again , and not all window managers honor requests to * unmaximize . * * If a window is not explicitly maximized or unmaximized before it is * shown , the initial state is at the window managers discretion . For * example , it might decide to maximize a window that almost fills the * screen . * * You can track the result of this operation via the * [ property @ Gdk . Toplevel : state ] property , or by listening to * notifications on the [ property @ Gtk . Window : maximized ] property . void TRUE ;if (_gtk_widget_get_mapped (GTK_WIDGET (window)))FALSE );else if (priv->maximized)FALSE ;static void if (priv->initial_fullscreen_monitor)creen_monitor, window);/** * gtk_window_fullscreen : * @ window : a window * * Asks to place the window in the fullscreen state . * * Note that you shouldn ’ t assume the window is definitely fullscreen * afterward , because other entities ( e . g . the user or window manager ) * unfullscreen it again , and not all window managers honor requests * to fullscreen windows . * * If a window is not explicitly fullscreened or unfullscreened before * it is shown , the initial state is at the window managers discretion . * * You can track the result of this operation via the * [ property @ Gdk . Toplevel : state ] property , or by listening to * notifications of the [ property @ Gtk . Window : fullscreened ] property . void TRUE ;if (_gtk_widget_get_mapped (GTK_WIDGET (window)))TRUE , NULL);else if (!priv->fullscreen)TRUE ;/** * gtk_window_fullscreen_on_monitor : * @ window : a window * @ monitor : which monitor to go fullscreen on * * Asks to place the window in the fullscreen state on the given monitor . * * Note that you shouldn ' t assume the window is definitely fullscreen * afterward , or that the windowing system allows fullscreen windows on * any given monitor . * * You can track the result of this operation via the * [ property @ Gdk . Toplevel : state ] property , or by listening to * notifications of the [ property @ Gtk . Window : fullscreened ] property . void "invalidate" ,TRUE ;if (_gtk_widget_get_mapped (GTK_WIDGET (window)))TRUE , monitor);else if (!priv->fullscreen)TRUE ;/** * gtk_window_unfullscreen : * @ window : a window * * Asks to remove the fullscreen state for the window , and return to * its previous state . * * Note that you shouldn ’ t assume the window is definitely not * fullscreen afterward , because other entities ( e . g . the user or * window manager ) could fullscreen it again , and not all window * managers honor requests to unfullscreen windows ; normally the * window will end up restored to its normal state . Just don ’ t * write code that crashes if not . * * If a window is not explicitly fullscreened or unfullscreened before * it is shown , the initial state is at the window managers discretion . * * You can track the result of this operation via the * [ property @ Gdk . Toplevel : state ] property , or by listening to * notifications of the [ property @ Gtk . Window : fullscreened ] property . void TRUE ;if (_gtk_widget_get_mapped (GTK_WIDGET (window)))FALSE , NULL);else if (priv->fullscreen)FALSE ;/** * gtk_window_set_resizable : * @ window : a window * @ resizable : true if the user can resize this window * * Sets whether the user can resize a window . * * Windows are user resizable by default . void FALSE );if (priv->resizable != resizable)/** * gtk_window_get_resizable : * @ window : a window * * Gets whether the user can resize the window . * * Returns : true if the user can resize the window FALSE );return priv->resizable;/** * gtk_window_set_display : * @ window : a window * @ display : a display * * Sets the display where the window is displayed . * * If the window is already mapped , it will be unmapped , * and then remapped on the new display . void int old_scale;if (display == priv->display)return ;/* reset initial_fullscreen_monitor since they are relative to the screen */ if (was_mapped)if (_gtk_widget_get_realized (widget))if (priv->transient_parent && gtk_widget_get_display (GTK_WIDGET (priv->transient_parent)) != display)#ifdef GDK_WINDOWING_X11"notify::gtk-interface-color-scheme" ,#endif if (was_mapped)if (old_scale != gtk_widget_get_scale_factor (GTK_WIDGET (window)));static void #ifdef GDK_WINDOWING_X11"gtk-interface-color-scheme" , &color_scheme,if (GDK_IS_X11_SURFACE (priv->surface))"dark" : NULL);#endif #ifdef GDK_WINDOWING_X11static void #endif /** * gtk_window_is_active : * @ window : a window * * Returns whether the window is part of the current active toplevel . * * The active toplevel is the window receiving keystrokes . * * The return value is % TRUE if the window is active toplevel itself . * You might use this function if you wanted to draw a widget * differently in an active window from a widget in an inactive window . * * Returns : true if the window part of the current active window . FALSE );return priv->is_active;/** * gtk_window_get_group : * @ window : ( nullable ) : a window * * Returns the group for the window . * * If the window has no group , then the default group is returned . * * Returns : ( transfer none ) : the window group for @ window * or the default group static GtkWindowGroup *default_group = NULL;if (window)if (priv->group)return priv->group;if (!default_group)return default_group;/** * gtk_window_has_group : * @ window : a window * * Returns whether the window has an explicit window group . * * Returns : true if @ window has an explicit window group FALSE );return priv->group != NULL;return priv->group;void static gbooleanif (tmp_menubars == NULL)return priv->title_box != NULL &&for (l = tmp_menubars; l; l = l->next)0 );if (GTK_IS_POPOVER_MENU_BAR (first))else if (GTK_IS_MENU_BUTTON (first))TRUE );return TRUE ;static void /* * _ gtk_window_set_is_active : * @ window : a window * @ is_active : true if the window is in the currently active toplevel * * Internal function that sets whether the window is part * of the currently active toplevel window ( taking into account * inter - process embedding ) . static void if (priv->is_active == is_active)return ;if (priv->focus_widget)if (is_active)TRUE );else FALSE );/** * gtk_window_set_auto_startup_notification : * @ setting : true to automatically do startup notification * * Sets whether the window should request startup notification . * * By default , after showing the first window , GTK calls * [ method @ Gdk . Toplevel . set_startup_id ] . Call this function * to disable the automatic startup notification . You might do this * if your first window is a splash screen , and you want to delay * notification until after your real main window has been shown , * for example . * * In that example , you would disable startup notification * temporarily , show your splash screen , then re - enable it so that * showing the main window would automatically result in notification . void /** * gtk_window_get_mnemonics_visible : * @ window : a window * * Gets whether mnemonics are supposed to be visible . * * Returns : true if mnemonics are supposed to be visible * in this window FALSE );return priv->mnemonics_visible;/** * gtk_window_set_mnemonics_visible : * @ window : a window * @ setting : the new value * * Sets whether mnemonics are supposed to be visible . * * This property is maintained by GTK based on user input , * and should not be set by applications . void FALSE ;if (priv->mnemonics_visible != setting)static gboolean0 ;TRUE );return G_SOURCE_REMOVE;void if (priv->mnemonics_display_timeout_id)return ;"[gtk] schedule_mnemonics_visible_cb" );/** * gtk_window_get_focus_visible : * @ window : a window * * Gets whether “ focus rectangles ” are supposed to be visible . * * Returns : true if “ focus rectangles ” are supposed to be visible * in this window FALSE );return priv->focus_visible;static gboolean0 ;FALSE );return G_SOURCE_REMOVE;/** * gtk_window_set_focus_visible : * @ window : a window * @ setting : the new value * * Sets whether “ focus rectangles ” are supposed to be visible . * * This property is maintained by GTK based on user input , * and should not be set by applications . void if (priv->focus_visible)cus_visible, window);"[gtk] unset_focus_visible" );if (changed)if (priv->focus_widget)for (widget = priv->focus_widget; widget; widget = gtk_widget_get_parent (widget))if (priv->focus_visible)FALSE );else static void TRUE ;VEL_STATE_FOCUSED;if (!surface_focused)FALSE );else static void set_warn_again (gboolean warn);static void gtk_window_set_debugging (GdkDisplay *display,static void int response)r_window));"check" );"warning_dialog" , NULL);if (response == GTK_RESPONSE_NO)FALSE , FALSE , FALSE , FALSE );else static void "-gtk-debugging-enabled" ));if (toggle)"-gtk-debugging-enabled" , GINT_TO_POINTER (enable));if (enable)if (warn)"Do you want to use GTK Inspector?" ));"GTK Inspector is an interactive debugger that lets you explore and " "modify the internals of any GTK application. Using it may cause the " "application to break or crash." ));"Don’t show this message again" ));10 );"check" , check);"_Cancel" ), GTK_RESPONSE_NO);"_OK" ), GTK_RESPONSE_YES);"response" , G_CALLBACK (warn_response), inspector_window);"warning_dialog" , dialog);if (select)window));else if (was_debugging)FALSE );/** * gtk_window_set_interactive_debugging : * @ enable : true to enable interactive debugging * * Opens or closes the [ interactive debugger ] ( running . html # interactive - debugging ) . * * The debugger offers access to the widget hierarchy of the application * and to useful debugging tools . * * This function allows applications that already use * < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > I < / kbd > * ( or < kbd > Ctrl < / kbd > + < kbd > Shift < / kbd > + < kbd > D < / kbd > ) * for their own key shortcuts to add a different shortcut to open the Inspector . * * If you are not overriding the default key shortcuts for the Inspector , * you should not use this function . void FALSE , FALSE , FALSE );static gbooleanTRUE ;TRUE ;"org.gtk.gtk4.Settings.Debug" ,TRUE );if (schema)"enable-inspector-keybinding" );"inspector-warning" );return enabled;static void "org.gtk.gtk4.Settings.Debug" ,TRUE );if (schema)"inspector-warning" , warn);static gbooleanif (!inspector_keybinding_enabled (&warn))return FALSE ;TRUE , toggle, !toggle, warn);return TRUE ;typedef struct {static char *char *handle)#ifdef GDK_WINDOWING_WAYLANDif (GDK_IS_WAYLAND_DISPLAY (display))return g_strconcat ("wayland:" , handle, NULL);else #endif #ifdef GDK_WINDOWING_X11if (GDK_IS_X11_DISPLAY (display))return g_strconcat ("x11:" , handle, NULL);else #endif return NULL;static const char *const char *handle)if (g_str_has_prefix (handle, "wayland:" ))return handle + strlen ("wayland:" );else if (g_str_has_prefix (handle, "x11:" ))return handle + strlen ("x11:" );else return handle;static void void *user_data)char *handle;;if (handle)char *prefixed;else if (G_UNLIKELY (!priv->surface))return FALSE ;1 );ta);return TRUE ;void const char *handle)if (G_LIKELY (priv->surface));static GtkPointerFocus *for (l = priv->foci; l; l = l->next)if (focus->device == device && focus->sequence == sequence)return focus;return NULL;return focus ? gtk_pointer_focus_get_target (focus) : NULL;return focus ? gtk_pointer_focus_get_effective_target (focus) : NULL;return focus ? gtk_pointer_focus_get_implicit_grab (focus) : NULL;static void while (w)if (w == topmost)break ;void double x,double y)if (focus)if (target)else if (pos)if (focus->grab_widget)FALSE );else if (target)void while (l)if (focus->grab_widget &&FALSE );if (GTK_WIDGET (focus->toplevel) == widget)/* Unmapping the toplevel, remove pointer focus */ else if (focus->target == widget ||if (gtk_widget_get_native (focus->target) == gtk_widget_get_native (old_target))void while (l)if (focus->toplevel != window)continue ;if ((!device || focus->device == device) &&void if (!focus && !grab_widget)return ;if (current == grab_widget)return ;if (current)FALSE );if (grab_widget)TRUE );static void if (grab_widget && !gtk_widget_is_ancestor (target, grab_widget) && target != grab_widget)/* Outside the grab widget, cursor stays to whatever the grab * widget says . if (gtk_widget_get_native (grab_widget) == native)else else /* Inside the grab widget or in absence of grabs, allow walking * up the hierarchy to find out the cursor . while (target)/* Don't inherit cursors across surfaces */ if (native != gtk_widget_get_native (target))break ;if (target == GTK_WIDGET (toplevel) && priv->resize_cursor != NULL)else if (cursor)break ;if (grab_widget && target == grab_widget)break ;void for (l = priv->foci; l; l = l->next)if (focus->sequence)continue ;if (device && device != focus->device)continue ;if (!grab_widget)if (widget)/* Check whether the changed widget affects the current cursor * lookups . if (grab_widget && grab_widget != widget &&continue ;if (target != widget &&continue ;if (device)break ;/** * gtk_window_set_child : * @ window : a window * @ child : ( nullable ) : the child widget * * Sets the child widget of the window . void ULL);if (priv->child == child)return ;if (child)/** * gtk_window_get_child : * @ window : a window * * Gets the child widget of the window . * * Returns : ( nullable ) ( transfer none ) : the child widget of @ window return priv->child;/** * gtk_window_destroy : * @ window : the window to destroy * * Drops the internal reference GTK holds on toplevel windows . void /* If gtk_window_destroy() has been called before. Can happen * when destroying a dialog manually in a : : close handler for example . if (!g_list_store_find (toplevel_list, window, &i))return ;for (l = priv->foci; l; l = l->next)if (target == widget || gtk_widget_is_ancestor (target, widget))if (n_devices)return (GdkDevice**) g_ptr_array_free (array, FALSE );static void if (is_shadowed)if (!was_shadowed &&else if (was_shadowed &&static void FALSE , is_grabbed = FALSE ;while (target)if (target == old_grab_widget)TRUE ;if (target == new_grab_widget)TRUE ;for (l = widgets; l; l = l->next)if (l->data == old_grab_widget)FALSE ;if (l->data == new_grab_widget)FALSE ;if (was_shadowed == is_shadowed)break ;void for (l = priv->foci; l; l = l->next)/** * gtk_window_set_handle_menubar_accel : * @ window : a window * @ handle_menubar_accel : true to make @ window handle < kbd > F10 < / kbd > * * Sets whether this window should react to < kbd > F10 < / kbd > * presses by activating a menubar it contains . * * Since : 4 . 2 void if (gtk_event_controller_get_propagation_phase (priv->menubar_controller) == phase)return ;]);/** * gtk_window_get_handle_menubar_accel : * @ window : a window * * Returns whether this window reacts to < kbd > F10 < / kbd > * presses by activating a menubar it contains . * * Returns : true if the window handles < kbd > F10 < / kbd > * * Since : 4 . 2 TRUE );return phase == GTK_PHASE_CAPTURE;/** * gtk_window_get_gravity : * @ window : a window * * Returns the gravity that is used when changing the window size programmatically . * * Returns : the gravity * * Since : 4 . 20 return priv->gravity;/** * gtk_window_set_gravity : * @ window : a window * @ gravity : the new gravity * * Sets the gravity that is used when changing the window size programmatically . * * Since : 4 . 20 void if (priv->gravity == gravity)return ;if (priv->surface)
Messung V0.5 in Prozent C=98 H=96 G=96
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.304Bemerkung:
(vorverarbeitet am 2026-07-03)
¤ *Bot Zugriff
2026-07-09
