Trait gtk::prelude::GtkWindowExt
source · [−]pub trait GtkWindowExt: 'static {
Show 146 methods
fn activate_default(&self) -> bool;
fn activate_focus(&self) -> bool;
fn activate_key(&self, event: &EventKey) -> bool;
fn add_accel_group(&self, accel_group: &impl IsA<AccelGroup>);
fn add_mnemonic(&self, keyval: u32, target: &impl IsA<Widget>);
fn begin_move_drag(
&self,
button: i32,
root_x: i32,
root_y: i32,
timestamp: u32
);
fn begin_resize_drag(
&self,
edge: WindowEdge,
button: i32,
root_x: i32,
root_y: i32,
timestamp: u32
);
fn close(&self);
fn deiconify(&self);
fn fullscreen(&self);
fn fullscreen_on_monitor(&self, screen: &Screen, monitor: i32);
fn accepts_focus(&self) -> bool;
fn application(&self) -> Option<Application>;
fn attached_to(&self) -> Option<Widget>;
fn is_decorated(&self) -> bool;
fn default_size(&self) -> (i32, i32);
fn default_widget(&self) -> Option<Widget>;
fn is_deletable(&self) -> bool;
fn must_destroy_with_parent(&self) -> bool;
fn focused_widget(&self) -> Option<Widget>;
fn gets_focus_on_map(&self) -> bool;
fn gets_focus_visible(&self) -> bool;
fn gravity(&self) -> Gravity;
fn group(&self) -> Option<WindowGroup>;
fn hides_titlebar_when_maximized(&self) -> bool;
fn icon(&self) -> Option<Pixbuf>;
fn icon_list(&self) -> Vec<Pixbuf>;
fn icon_name(&self) -> Option<GString>;
fn mnemonic_modifier(&self) -> ModifierType;
fn is_mnemonics_visible(&self) -> bool;
fn is_modal(&self) -> bool;
fn position(&self) -> (i32, i32);
fn is_resizable(&self) -> bool;
fn role(&self) -> Option<GString>;
fn size(&self) -> (i32, i32);
fn skips_pager_hint(&self) -> bool;
fn skips_taskbar_hint(&self) -> bool;
fn title(&self) -> Option<GString>;
fn titlebar(&self) -> Option<Widget>;
fn transient_for(&self) -> Option<Window>;
fn type_hint(&self) -> WindowTypeHint;
fn is_urgency_hint(&self) -> bool;
fn window_type(&self) -> WindowType;
fn has_group(&self) -> bool;
fn has_toplevel_focus(&self) -> bool;
fn iconify(&self);
fn is_active(&self) -> bool;
fn is_maximized(&self) -> bool;
fn maximize(&self);
fn mnemonic_activate(&self, keyval: u32, modifier: ModifierType) -> bool;
fn move_(&self, x: i32, y: i32);
fn parse_geometry(&self, geometry: &str) -> bool;
fn present(&self);
fn present_with_time(&self, timestamp: u32);
fn propagate_key_event(&self, event: &EventKey) -> bool;
fn remove_accel_group(&self, accel_group: &impl IsA<AccelGroup>);
fn remove_mnemonic(&self, keyval: u32, target: &impl IsA<Widget>);
fn resize(&self, width: i32, height: i32);
fn resize_to_geometry(&self, width: i32, height: i32);
fn set_accept_focus(&self, setting: bool);
fn set_application(&self, application: Option<&impl IsA<Application>>);
fn set_attached_to(&self, attach_widget: Option<&impl IsA<Widget>>);
fn set_decorated(&self, setting: bool);
fn set_default(&self, default_widget: Option<&impl IsA<Widget>>);
fn set_default_geometry(&self, width: i32, height: i32);
fn set_default_size(&self, width: i32, height: i32);
fn set_deletable(&self, setting: bool);
fn set_destroy_with_parent(&self, setting: bool);
fn set_focus(&self, focus: Option<&impl IsA<Widget>>);
fn set_focus_on_map(&self, setting: bool);
fn set_focus_visible(&self, setting: bool);
fn set_geometry_hints(
&self,
geometry_widget: Option<&impl IsA<Widget>>,
geometry: Option<&Geometry>,
geom_mask: WindowHints
);
fn set_gravity(&self, gravity: Gravity);
fn set_has_user_ref_count(&self, setting: bool);
fn set_hide_titlebar_when_maximized(&self, setting: bool);
fn set_icon(&self, icon: Option<&Pixbuf>);
fn set_icon_from_file(
&self,
filename: impl AsRef<Path>
) -> Result<(), Error>;
fn set_icon_list(&self, list: &[Pixbuf]);
fn set_icon_name(&self, name: Option<&str>);
fn set_keep_above(&self, setting: bool);
fn set_keep_below(&self, setting: bool);
fn set_mnemonic_modifier(&self, modifier: ModifierType);
fn set_mnemonics_visible(&self, setting: bool);
fn set_modal(&self, modal: bool);
fn set_position(&self, position: WindowPosition);
fn set_resizable(&self, resizable: bool);
fn set_role(&self, role: &str);
fn set_screen(&self, screen: &Screen);
fn set_skip_pager_hint(&self, setting: bool);
fn set_skip_taskbar_hint(&self, setting: bool);
fn set_startup_id(&self, startup_id: &str);
fn set_title(&self, title: &str);
fn set_titlebar(&self, titlebar: Option<&impl IsA<Widget>>);
fn set_transient_for(&self, parent: Option<&impl IsA<Window>>);
fn set_type_hint(&self, hint: WindowTypeHint);
fn set_urgency_hint(&self, setting: bool);
fn set_wmclass(&self, wmclass_name: &str, wmclass_class: &str);
fn stick(&self);
fn unfullscreen(&self);
fn unmaximize(&self);
fn unstick(&self);
fn default_height(&self) -> i32;
fn set_default_height(&self, default_height: i32);
fn default_width(&self) -> i32;
fn set_default_width(&self, default_width: i32);
fn type_(&self) -> WindowType;
fn window_position(&self) -> WindowPosition;
fn set_window_position(&self, window_position: WindowPosition);
fn connect_activate_default<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn emit_activate_default(&self);
fn connect_activate_focus<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn emit_activate_focus(&self);
fn connect_enable_debugging<F: Fn(&Self, bool) -> bool + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn emit_enable_debugging(&self, toggle: bool) -> bool;
fn connect_keys_changed<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_set_focus<F: Fn(&Self, Option<&Widget>) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_accept_focus_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_application_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_attached_to_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_decorated_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_default_height_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_default_width_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_deletable_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_destroy_with_parent_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_focus_on_map_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_focus_visible_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_gravity_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_has_toplevel_focus_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_hide_titlebar_when_maximized_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_icon_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_icon_name_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_is_active_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_is_maximized_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_mnemonics_visible_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_modal_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_resizable_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_role_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_screen_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_skip_pager_hint_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_skip_taskbar_hint_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_startup_id_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_title_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_transient_for_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_type_hint_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_urgency_hint_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
fn connect_window_position_notify<F: Fn(&Self) + 'static>(
&self,
f: F
) -> SignalHandlerId;
}Expand description
Trait containing all Window methods.
Implementors
ApplicationWindow, Assistant, Dialog, OffscreenWindow, Plug, ShortcutsWindow, Window
Required Methods
fn activate_default(&self) -> bool
fn activate_default(&self) -> bool
Activates the default widget for the window, unless the current
focused widget has been configured to receive the default action
(see WidgetExt::set_receives_default()), in which case the
focused widget is activated.
Returns
true if a widget got activated.
fn activate_focus(&self) -> bool
fn activate_focus(&self) -> bool
fn activate_key(&self, event: &EventKey) -> bool
fn activate_key(&self, event: &EventKey) -> bool
Activates mnemonics and accelerators for this Window. This is normally
called by the default ::key_press_event handler for toplevel windows,
however in some cases it may be useful to call this directly when
overriding the standard key handling for a toplevel window.
event
Returns
true if a mnemonic or accelerator was found and activated.
fn add_accel_group(&self, accel_group: &impl IsA<AccelGroup>)
fn add_accel_group(&self, accel_group: &impl IsA<AccelGroup>)
Associate accel_group with self, such that calling
accel_groups_activate() on self will activate accelerators
in accel_group.
accel_group
fn add_mnemonic(&self, keyval: u32, target: &impl IsA<Widget>)
fn add_mnemonic(&self, keyval: u32, target: &impl IsA<Widget>)
Starts moving a window. This function is used if an application has window movement grips. When GDK can support it, the window movement will be done using the standard mechanism for the [window manager][gtk-X11-arch] or windowing system. Otherwise, GDK will try to emulate window movement, potentially not all that well, depending on the windowing system.
button
mouse button that initiated the drag
root_x
X position where the user clicked to initiate the drag, in root window coordinates
root_y
Y position where the user clicked to initiate the drag
timestamp
timestamp from the click event that initiated the drag
fn begin_resize_drag(
&self,
edge: WindowEdge,
button: i32,
root_x: i32,
root_y: i32,
timestamp: u32
)
fn begin_resize_drag(
&self,
edge: WindowEdge,
button: i32,
root_x: i32,
root_y: i32,
timestamp: u32
)
Starts resizing a window. This function is used if an application has window resizing controls. When GDK can support it, the resize will be done using the standard mechanism for the [window manager][gtk-X11-arch] or windowing system. Otherwise, GDK will try to emulate window resizing, potentially not all that well, depending on the windowing system.
edge
position of the resize control
button
mouse button that initiated the drag
root_x
X position where the user clicked to initiate the drag, in root window coordinates
root_y
Y position where the user clicked to initiate the drag
timestamp
timestamp from the click event that initiated the drag
Requests that the window is closed, similar to what happens when a window manager close button is clicked.
This function can be used with close buttons in custom titlebars.
Asks to deiconify (i.e. unminimize) the specified self. Note
that you shouldn’t assume the window is definitely deiconified
afterward, because other entities (e.g. the user or
[window manager][gtk-X11-arch])) could iconify it
again before your code which assumes deiconification gets to run.
You can track iconification via the “window-state-event” signal
on Widget.
fn fullscreen(&self)
fn fullscreen(&self)
Asks to place self in the fullscreen state. Note that you
shouldn’t assume the window is definitely full screen afterward,
because other entities (e.g. the user or
[window manager][gtk-X11-arch]) could unfullscreen it
again, and not all window managers honor requests to fullscreen
windows. But normally the window will end up fullscreen. Just
don’t write code that crashes if not.
You can track the fullscreen state via the “window-state-event” signal
on Widget.
fn fullscreen_on_monitor(&self, screen: &Screen, monitor: i32)
fn fullscreen_on_monitor(&self, screen: &Screen, monitor: i32)
Asks to place self in the fullscreen state. Note that you shouldn’t assume
the window is definitely full screen afterward.
You can track the fullscreen state via the “window-state-event” signal
on Widget.
screen
a gdk::Screen to draw to
monitor
which monitor to go fullscreen on
fn accepts_focus(&self) -> bool
fn accepts_focus(&self) -> bool
fn application(&self) -> Option<Application>
fn application(&self) -> Option<Application>
fn attached_to(&self) -> Option<Widget>
fn attached_to(&self) -> Option<Widget>
Fetches the attach widget for this window. See
set_attached_to().
Returns
the widget where the window
is attached, or None if the window is not attached to any widget.
fn is_decorated(&self) -> bool
fn is_decorated(&self) -> bool
Returns whether the window has been set to have decorations
such as a title bar via set_decorated().
Returns
true if the window has been set to have decorations
Gets the default size of the window. A value of -1 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.
Returns
width
location to store the default width, or None
height
location to store the default height, or None
fn default_widget(&self) -> Option<Widget>
fn default_widget(&self) -> Option<Widget>
Returns the default widget for self. See
set_default() for more details.
Returns
the default widget, or None
if there is none.
fn is_deletable(&self) -> bool
fn is_deletable(&self) -> bool
Returns whether the window has been set to have a close button
via set_deletable().
Returns
true if the window has been set to have a close button
fn must_destroy_with_parent(&self) -> bool
fn must_destroy_with_parent(&self) -> bool
fn focused_widget(&self) -> Option<Widget>
fn focused_widget(&self) -> Option<Widget>
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 true for the widget.
Returns
the currently focused widget,
or None if there is none.
fn gets_focus_on_map(&self) -> bool
fn gets_focus_on_map(&self) -> bool
Gets the value set by set_focus_on_map().
Returns
true if window should receive the input focus when
mapped.
fn gets_focus_visible(&self) -> bool
fn gets_focus_visible(&self) -> bool
fn group(&self) -> Option<WindowGroup>
fn group(&self) -> Option<WindowGroup>
Returns the group for self or the default group, if
self is None or if self does not have an explicit
window group.
Returns
the WindowGroup for a window or the default group
fn hides_titlebar_when_maximized(&self) -> bool
fn hides_titlebar_when_maximized(&self) -> bool
Gets the value set by set_icon() (or if you’ve
called set_icon_list(), gets the first icon in
the icon list).
Returns
icon for window or None if none
Retrieves the list of icons set by set_icon_list().
The list is copied, but the reference count on each
member won’t be incremented.
Returns
copy of window’s icon list
Returns the name of the themed icon for the window,
see set_icon_name().
Returns
the icon name or None if the window has
no themed icon
fn mnemonic_modifier(&self) -> ModifierType
fn mnemonic_modifier(&self) -> ModifierType
Returns the mnemonic modifier for this window. See
set_mnemonic_modifier().
Returns
the modifier mask used to activate mnemonics on this window.
fn is_mnemonics_visible(&self) -> bool
fn is_mnemonics_visible(&self) -> bool
Returns whether the window is modal. See set_modal().
Returns
true if the window is set to be modal and
establishes a grab when shown
This function returns the position you need to pass to
move_() to keep self in its current position.
This means that the meaning of the returned value varies with
window gravity. See move_() for more details.
The reliability of this function depends on the windowing system currently in use. Some windowing systems, such as Wayland, do not support a global coordinate system, and thus the position of the window will always be (0, 0). Others, like X11, do not have a reliable way to obtain the geometry of the decorations of a window if they are provided by the window manager. Additionally, on X11, window manager have been known to mismanage window gravity, which result in windows moving even if you use the coordinates of the current position as returned by this function.
If you haven’t changed the window gravity, its gravity will be
gdk::Gravity::NorthWest. This means that position()
gets the position of the top-left corner of the window manager
frame for the window. move_() sets the position of this
same top-left corner.
If a window has gravity gdk::Gravity::Static the window manager
frame is not relevant, and thus position() will
always produce accurate results. However you can’t use static
gravity to do things like place a window in a corner of the screen,
because static gravity ignores the window manager decorations.
Ideally, this function should return appropriate values if the window has client side decorations, assuming that the windowing system supports global coordinates.
In practice, saving the window position should not be left to applications, as they lack enough knowledge of the windowing system and the window manager state to effectively do so. The appropriate way to implement saving the window position is to use a platform-specific protocol, wherever that is available.
Returns
root_x
return location for X coordinate of
gravity-determined reference point, or None
root_y
return location for Y coordinate of
gravity-determined reference point, or None
fn is_resizable(&self) -> bool
fn is_resizable(&self) -> bool
Returns the role of the window. See set_role() for
further explanation.
Returns
the role of the window if set, or None. The
returned is owned by the widget and must not be modified or freed.
Obtains the current size of self.
If self is not visible on screen, this function return the size GTK+
will suggest to the [window manager][gtk-X11-arch] for the initial window
size (but this is not reliably the same as the size the window manager
will actually select). See: set_default_size().
Depending on the windowing system and the window manager constraints,
the size returned by this function may not match the size set using
resize(); additionally, since resize() may be
implemented as an asynchronous operation, GTK+ cannot guarantee in any
way that this code:
⚠️ The following code is in C ⚠️
// width and height are set elsewhere
gtk_window_resize (window, width, height);
int new_width, new_height;
gtk_window_get_size (window, &new_width, &new_height);will result in new_width and new_height matching width and
height, respectively.
This function will return the logical size of the Window,
excluding the widgets used in client side decorations; there is,
however, no guarantee that the result will be completely accurate
because client side decoration may include widgets that depend on
the user preferences and that may not be visibile at the time you
call this function.
The dimensions returned by this function are suitable for being
stored across sessions; use set_default_size() to
restore them when before showing the window.
To avoid potential race conditions, you should only call this
function in response to a size change notification, for instance
inside a handler for the signal::Widget::size-allocate signal, or
inside a handler for the signal::Widget::configure-event signal:
⚠️ The following code is in C ⚠️
static void
on_size_allocate (GtkWidget *widget, GtkAllocation *allocation)
{
int new_width, new_height;
gtk_window_get_size (GTK_WINDOW (widget), &new_width, &new_height);
...
}Note that, if you connect to the signal::Widget::size-allocate signal,
you should not use the dimensions of the GtkAllocation passed to
the signal handler, as the allocation may contain client side
decorations added by GTK+, depending on the windowing system in
use.
If you are getting a window size in order to position the window
on the screen, you should, instead, simply set the window’s semantic
type with set_type_hint(), which allows the window manager
to e.g. center dialogs. Also, if you set the transient parent of
dialogs with set_transient_for() window managers will
often center the dialog over its parent window. It’s much preferred
to let the window manager handle these cases rather than doing it
yourself, because all apps will behave consistently and according to
user or system preferences, if the window manager handles it. Also,
the window manager can take into account the size of the window
decorations and border that it may add, and of which GTK+ has no
knowledge. Additionally, positioning windows in global screen coordinates
may not be allowed by the windowing system. For more information,
see: set_position().
Returns
width
return location for width, or None
height
return location for height, or None
fn skips_pager_hint(&self) -> bool
fn skips_pager_hint(&self) -> bool
fn skips_taskbar_hint(&self) -> bool
fn skips_taskbar_hint(&self) -> bool
Retrieves the title of the window. See set_title().
Returns
the title of the window, or None if none has
been set explicitly. The returned string is owned by the widget
and must not be modified or freed.
Returns the custom titlebar that has been set with
set_titlebar().
Returns
the custom titlebar, or None
fn transient_for(&self) -> Option<Window>
fn transient_for(&self) -> Option<Window>
Fetches the transient parent for this window. See
set_transient_for().
Returns
the transient parent for this
window, or None if no transient parent has been set.
fn type_hint(&self) -> WindowTypeHint
fn type_hint(&self) -> WindowTypeHint
fn is_urgency_hint(&self) -> bool
fn is_urgency_hint(&self) -> bool
fn window_type(&self) -> WindowType
fn window_type(&self) -> WindowType
fn has_toplevel_focus(&self) -> bool
fn has_toplevel_focus(&self) -> bool
Returns whether the input focus is within this GtkWindow.
For real toplevel windows, this is identical to is_active(),
but for embedded windows, like Plug, the results will differ.
Returns
true if the input focus is within this GtkWindow
Asks to iconify (i.e. minimize) the specified self. Note that
you shouldn’t assume the window is definitely iconified afterward,
because other entities (e.g. the user or
[window manager][gtk-X11-arch]) could deiconify it
again, or there may not be a window manager in which case
iconification isn’t possible, etc. But normally the window will end
up iconified. Just don’t write code that crashes if not.
It’s permitted to call this function before showing a window, in which case the window will be iconified before it ever appears onscreen.
You can track iconification via the “window-state-event” signal
on Widget.
Returns whether the window is part of the current active toplevel.
(That is, the toplevel window receiving keystrokes.)
The return value is true if the window is active toplevel
itself, but also if it is, say, a Plug embedded in the active toplevel.
You might use this function if you wanted to draw a widget
differently in an active window from a widget in an inactive window.
See has_toplevel_focus()
Returns
true if the window part of the current active window.
fn is_maximized(&self) -> bool
fn is_maximized(&self) -> bool
Retrieves the current maximized state of self.
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
maximize() or unmaximize().
Returns
whether the window has a maximized state.
Asks to maximize self, so that it becomes full-screen. Note that
you shouldn’t assume the window is definitely maximized afterward,
because other entities (e.g. the user or
[window manager][gtk-X11-arch]) could unmaximize it
again, and not all window managers support maximization. But
normally the window will end up maximized. Just don’t write code
that crashes if not.
It’s permitted to call this function before showing a window, in which case the window will be maximized when it appears onscreen initially.
You can track maximization via the “window-state-event” signal
on Widget, or by listening to notifications on the
property::Window::is-maximized property.
fn mnemonic_activate(&self, keyval: u32, modifier: ModifierType) -> bool
fn mnemonic_activate(&self, keyval: u32, modifier: ModifierType) -> bool
fn parse_geometry(&self, geometry: &str) -> bool
fn parse_geometry(&self, geometry: &str) -> bool
Parses a standard X Window System geometry string - see the
manual page for X (type “man X”) for details on this.
parse_geometry() does work on all GTK+ ports
including Win32 but is primarily intended for an X environment.
If either a size or a position can be extracted from the
geometry string, parse_geometry() returns true
and calls set_default_size() and/or move_()
to resize/move the window.
If parse_geometry() returns true, it will also
set the gdk::WindowHints::USER_POS and/or gdk::WindowHints::USER_SIZE hints
indicating to the window manager that the size/position of
the window was user-specified. This causes most window
managers to honor the geometry.
Note that for parse_geometry() to work as expected, it has
to be called when the window has its “final” size, i.e. after calling
WidgetExt::show_all() on the contents and set_geometry_hints()
on the window.
⚠️ The following code is in C ⚠️
#include <gtk/gtk.h>
static void
fill_with_content (GtkWidget *vbox)
{
// fill with content...
}
int
main (int argc, char *argv[])
{
GtkWidget *window, *vbox;
GdkGeometry size_hints = {
100, 50, 0, 0, 100, 50, 10,
10, 0.0, 0.0, GDK_GRAVITY_NORTH_WEST
};
gtk_init (&argc, &argv);
window = gtk_window_new (GTK_WINDOW_TOPLEVEL);
vbox = gtk_box_new (GTK_ORIENTATION_VERTICAL, 0);
gtk_container_add (GTK_CONTAINER (window), vbox);
fill_with_content (vbox);
gtk_widget_show_all (vbox);
gtk_window_set_geometry_hints (GTK_WINDOW (window),
NULL,
&size_hints,
GDK_HINT_MIN_SIZE |
GDK_HINT_BASE_SIZE |
GDK_HINT_RESIZE_INC);
if (argc > 1)
{
gboolean res;
res = gtk_window_parse_geometry (GTK_WINDOW (window),
argv[1]);
if (! res)
fprintf (stderr,
"Failed to parse “%s”\n",
argv[1]);
}
gtk_widget_show_all (window);
gtk_main ();
return 0;
}Deprecated since 3.20
Geometry handling in GTK is deprecated.
geometry
geometry string
Returns
true if string was parsed successfully
Presents a window to the user. This function should not be used as when it is called, it is too late to gather a valid timestamp to allow focus stealing prevention to work correctly.
fn present_with_time(&self, timestamp: u32)
fn present_with_time(&self, timestamp: u32)
Presents a window to the user. This may mean raising the window in the stacking order, deiconifying 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 self is hidden, this function calls WidgetExt::show()
as well.
This function should be used when the user tries to open a window
that’s already open. Say for example the preferences dialog is
currently open, and the user chooses Preferences from the menu
a second time; use present() to move the already-open dialog
where the user can see it.
Presents a window to the user in response to a user interaction. 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.
timestamp
the timestamp of the user interaction (typically a button or key press event) which triggered this call
fn propagate_key_event(&self, event: &EventKey) -> bool
fn propagate_key_event(&self, event: &EventKey) -> bool
Propagate a key press or release event to the focus widget and
up the focus container chain until a widget handles event.
This is normally called by the default ::key_press_event and
::key_release_event handlers for toplevel windows,
however in some cases it may be useful to call this directly when
overriding the standard key handling for a toplevel window.
event
Returns
true if a widget in the focus chain handled the event.
fn remove_accel_group(&self, accel_group: &impl IsA<AccelGroup>)
fn remove_accel_group(&self, accel_group: &impl IsA<AccelGroup>)
fn remove_mnemonic(&self, keyval: u32, target: &impl IsA<Widget>)
fn remove_mnemonic(&self, keyval: u32, target: &impl IsA<Widget>)
Resizes the window as if the user had done so, obeying geometry
constraints. The default geometry constraint is that windows may
not be smaller than their size request; to override this
constraint, call WidgetExt::set_size_request() to set the window’s
request to a smaller value.
If resize() is called before showing a window for the
first time, it overrides any default size set with
set_default_size().
Windows may not be resized smaller than 1 by 1 pixels.
When using client side decorations, GTK+ will do its best to adjust
the given size so that the resulting window size matches the
requested size without the title bar, borders and shadows added for
the client side decorations, but there is no guarantee that the
result will be totally accurate because these widgets added for
client side decorations depend on the theme and may not be realized
or visible at the time resize() is issued.
If the GtkWindow has a titlebar widget (see set_titlebar()), then
typically, resize() will compensate for the height of the titlebar
widget only if the height is known when the resulting GtkWindow configuration
is issued.
For example, if new widgets are added after the GtkWindow configuration
and cause the titlebar widget to grow in height, this will result in a
window content smaller that specified by resize() and not
a larger window.
width
width in pixels to resize the window to
height
height in pixels to resize the window to
fn resize_to_geometry(&self, width: i32, height: i32)
fn resize_to_geometry(&self, width: i32, height: i32)
Like resize(), but width and height are interpreted
in terms of the base size and increment set with
gtk_window_set_geometry_hints.
Deprecated since 3.20
This function does nothing. Use
resize() and compute the geometry yourself.
width
width in resize increments to resize the window to
height
height in resize increments to resize the window to
fn set_accept_focus(&self, setting: bool)
fn set_accept_focus(&self, setting: bool)
fn set_application(&self, application: Option<&impl IsA<Application>>)
fn set_application(&self, application: Option<&impl IsA<Application>>)
Sets or unsets the Application associated with the window.
The application will be kept alive for at least as long as it has any windows
associated with it (see [ApplicationExtManual::hold()][crate::gio::prelude::ApplicationExtManual::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 None.
This is equivalent to calling GtkApplicationExt::remove_window() and/or
GtkApplicationExt::add_window() on the old/new applications as relevant.
application
a Application, or None to unset
fn set_attached_to(&self, attach_widget: Option<&impl IsA<Widget>>)
fn set_attached_to(&self, attach_widget: Option<&impl IsA<Widget>>)
Marks self as attached to attach_widget. This creates a logical binding
between the window and the widget it belongs to, which is used by GTK+ to
propagate information such as styling or accessibility to self as if it
was a children of attach_widget.
Examples of places where specifying this relation is useful are for instance
a Menu created by a ComboBox, a completion popup window
created by Entry or a typeahead search entry created by TreeView.
Note that this function should not be confused with
set_transient_for(), which specifies a window manager relation
between two toplevels instead.
Passing None for attach_widget detaches the window.
attach_widget
fn set_decorated(&self, setting: bool)
fn set_decorated(&self, setting: bool)
By default, windows are decorated with a title bar, resize
controls, etc. Some [window managers][gtk-X11-arch]
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 WidgetExt::show().
On Windows, this function always works, since there’s no window manager policy involved.
setting
true to decorate the window
fn set_default(&self, default_widget: Option<&impl IsA<Widget>>)
fn set_default(&self, default_widget: Option<&impl IsA<Widget>>)
The default widget is the widget that’s activated when the user
presses Enter in a dialog (for example). This function sets or
unsets the default widget for a Window. When setting (rather
than unsetting) the default widget it’s generally easier to call
WidgetExt::grab_default() on the widget. Before making a widget
the default widget, you must call WidgetExt::set_can_default() on
the widget you’d like to make the default.
default_widget
widget to be the default, or None
to unset the default widget for the toplevel
fn set_default_geometry(&self, width: i32, height: i32)
fn set_default_geometry(&self, width: i32, height: i32)
Like set_default_size(), but width and height are interpreted
in terms of the base size and increment set with
gtk_window_set_geometry_hints.
Deprecated since 3.20
This function does nothing. If you want to set a default
size, use set_default_size() instead.
width
width in resize increments, or -1 to unset the default width
height
height in resize increments, or -1 to unset the default height
fn set_default_size(&self, width: i32, height: i32)
fn set_default_size(&self, width: i32, height: i32)
Sets the default size of a window. If the window’s “natural” size
(its size request) is larger than the default, the default will be
ignored. More generally, if the default size does not obey the
geometry hints for the window (set_geometry_hints() can
be used to set these explicitly), the default size will be clamped
to the nearest permitted size.
Unlike WidgetExt::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).
For more control over a window’s initial size and how resizing works,
investigate set_geometry_hints().
For some uses, resize() is a more appropriate function.
resize() changes the current size of the window, rather
than the size to be used on initial display. resize() always
affects the window itself, not the geometry widget.
The default size of a window only affects the first time a window is shown; if a window is hidden and re-shown, it will remember the size it had prior to hiding, rather than using the default size.
Windows can’t actually be 0x0 in size, they must be at least 1x1, but
passing 0 for width and height is OK, resulting in a 1x1 default size.
If you use this function to reestablish a previously saved window size,
note that the appropriate size to save is the one returned by
size(). Using the window allocation directly will not
work in all circumstances and can lead to growing or shrinking windows.
width
width in pixels, or -1 to unset the default width
height
height in pixels, or -1 to unset the default height
fn set_deletable(&self, setting: bool)
fn set_deletable(&self, setting: bool)
By default, windows have a close button in the window frame. Some
[window managers][gtk-X11-arch] 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 WidgetExt::show().
On Windows, this function always works, since there’s no window manager policy involved.
setting
true to decorate the window as deletable
fn set_destroy_with_parent(&self, setting: bool)
fn set_destroy_with_parent(&self, setting: bool)
If focus is not the current focus widget, and is focusable, sets
it as the focus widget for the window. If focus is None, 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
WidgetExt::grab_focus() instead of this function.
focus
widget to be the new focus widget, or None to unset
any focus widget for the toplevel window.
fn set_focus_on_map(&self, setting: bool)
fn set_focus_on_map(&self, setting: bool)
fn set_focus_visible(&self, setting: bool)
fn set_focus_visible(&self, setting: bool)
fn set_geometry_hints(
&self,
geometry_widget: Option<&impl IsA<Widget>>,
geometry: Option<&Geometry>,
geom_mask: WindowHints
)
fn set_geometry_hints(
&self,
geometry_widget: Option<&impl IsA<Widget>>,
geometry: Option<&Geometry>,
geom_mask: WindowHints
)
This function sets up hints about how a window can be resized by
the user. You can set a minimum and maximum size; allowed resize
increments (e.g. for xterm, you can only resize by the size of a
character); aspect ratios; and more. See the gdk::Geometry struct.
geometry_widget
widget the geometry hints used to be applied to
or None. Since 3.20 this argument is ignored and GTK behaves as if None was
set.
geometry
struct containing geometry information or None
geom_mask
mask indicating which struct fields should be paid attention to
fn set_gravity(&self, gravity: Gravity)
fn set_gravity(&self, gravity: Gravity)
Window gravity defines the meaning of coordinates passed to
move_(). See move_() and gdk::Gravity for
more details.
The default window gravity is gdk::Gravity::NorthWest which will
typically “do what you mean.”
gravity
window gravity
fn set_has_user_ref_count(&self, setting: bool)
fn set_has_user_ref_count(&self, setting: bool)
Tells GTK+ whether to drop its extra reference to the window
when gtk_widget_destroy() is called.
This function is only exported for the benefit of language bindings which may need to keep the window alive until their wrapper object is garbage collected. There is no justification for ever calling this function in an application.
setting
the new value
fn set_hide_titlebar_when_maximized(&self, setting: bool)
fn set_hide_titlebar_when_maximized(&self, setting: bool)
If setting is true, then self will request that it’s titlebar
should be hidden when maximized.
This is useful for windows that don’t convey any information other
than the application name in the titlebar, to put the available
screen space to better use. If the underlying window system does not
support the request, the setting will not have any effect.
Note that custom titlebars set with set_titlebar() are
not affected by this. The application is in full control of their
content and visibility anyway.
setting
whether to hide the titlebar when self is maximized
Sets up the icon representing a Window. This icon is used when
the window is minimized (also known as iconified). Some window
managers or desktop environments may also place it in the window
frame, or display it in other contexts. On others, the icon is not
used at all, so your mileage may vary.
The icon should be provided in whatever size it was naturally drawn; that is, don’t scale the image before passing it to GTK+. Scaling is postponed until the last minute, when the desired final size is known, to allow best quality.
If you have your icon hand-drawn in multiple sizes, use
set_icon_list(). Then the best size will be used.
This function is equivalent to calling set_icon_list()
with a 1-element list.
See also Window::set_default_icon_list() to set the icon
for all windows in your application in one go.
icon
icon image, or None
Sets the icon for self.
Warns on failure if err is None.
This function is equivalent to calling set_icon()
with a pixbuf created by loading the image from filename.
filename
location of icon file
Returns
true if setting the icon succeeded.