gdk4/auto/

toplevel.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

#[cfg(feature = "v4_4")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
use crate::TitlebarGesture;
use crate::{
    Device, Event, FullscreenMode, Surface, SurfaceEdge, Texture, ToplevelLayout, ToplevelState,
    ffi,
};
#[cfg(feature = "v4_20")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
use crate::{Gravity, ToplevelCapabilities};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A freestanding toplevel surface.
    ///
    /// The [`Toplevel`][crate::Toplevel] interface provides useful APIs for interacting with
    /// the windowing system, such as controlling maximization and size of the
    /// surface, setting icons and transient parents for dialogs.
    ///
    /// ## Properties
    ///
    ///
    /// #### `capabilities`
    ///  The capabilities that are available for this toplevel.
    ///
    /// Readable
    ///
    ///
    /// #### `decorated`
    ///  Whether the window manager should add decorations.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `deletable`
    ///  Whether the window manager should allow to close the surface.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `fullscreen-mode`
    ///  The fullscreen mode of the surface.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `gravity`
    ///  The gravity to use when resizing a surface programmatically.
    ///
    /// Gravity describes which point of the surface we want to keep
    /// fixed (meaning that the surface will grow in the opposite direction).
    /// For example, a gravity of `GDK_GRAVITY_NORTH_EAST` means that we
    /// want to fix top right corner of the surface.
    ///
    /// This property is just a hint that may affect the result when negotiating
    /// toplevel sizes with the windowing system. It does not affect interactive
    /// resizes started with [`ToplevelExt::begin_resize()`][crate::prelude::ToplevelExt::begin_resize()].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `icon-list`
    ///  A list of textures to use as icon.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `modal`
    ///  Whether the surface is modal.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `shortcuts-inhibited`
    ///  Whether the surface should inhibit keyboard shortcuts.
    ///
    /// Readable
    ///
    ///
    /// #### `startup-id`
    ///  The startup ID of the surface.
    ///
    /// See [`AppLaunchContext`][crate::AppLaunchContext] for more information about
    /// startup feedback.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `state`
    ///  The state of the toplevel.
    ///
    /// Readable
    ///
    ///
    /// #### `title`
    ///  The title of the surface.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `transient-for`
    ///  The transient parent of the surface.
    ///
    /// Readable | Writable
    /// <details><summary><h4>Surface</h4></summary>
    ///
    ///
    /// #### `cursor`
    ///  The mouse pointer for the [`Surface`][crate::Surface].
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `display`
    ///  The [`Display`][crate::Display] connection of the surface.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `frame-clock`
    ///  The [`FrameClock`][crate::FrameClock] of the surface.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `height`
    ///  The height of the surface, in pixels.
    ///
    /// Readable
    ///
    ///
    /// #### `mapped`
    ///  Whether the surface is mapped.
    ///
    /// Readable
    ///
    ///
    /// #### `scale`
    ///  The scale of the surface.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the surface.
    ///
    /// The scale factor is the next larger integer,
    /// compared to [`scale`][struct@crate::Surface#scale].
    ///
    /// Readable
    ///
    ///
    /// #### `width`
    ///  The width of the surface in pixels.
    ///
    /// Readable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `compute-size`
    ///  Emitted when the size for the surface needs to be computed, when
    /// it is present.
    ///
    /// This signal will normally be emitted during or after a call to
    /// [`ToplevelExt::present()`][crate::prelude::ToplevelExt::present()], depending on the configuration
    /// received by the windowing system. It may also be emitted at any
    /// other point in time, in response to the windowing system
    /// spontaneously changing the configuration of the toplevel surface.
    ///
    /// It is the responsibility of the toplevel user to handle this signal
    /// and compute the desired size of the toplevel, given the information
    /// passed via the [`ToplevelSize`][crate::ToplevelSize] object. Failing to do so
    /// will result in an arbitrary size being used as a result.
    ///
    ///
    /// <details><summary><h4>Surface</h4></summary>
    ///
    ///
    /// #### `enter-monitor`
    ///  Emitted when @surface starts being present on the monitor.
    ///
    ///
    ///
    ///
    /// #### `event`
    ///  Emitted when GDK receives an input event for @surface.
    ///
    ///
    ///
    ///
    /// #### `layout`
    ///   (see gdk_surface_get_scale_factor()).
    ///
    ///
    ///
    ///
    /// #### `leave-monitor`
    ///  Emitted when @surface stops being present on the monitor.
    ///
    ///
    ///
    ///
    /// #### `render`
    ///  Emitted when part of the surface needs to be redrawn.
    ///
    ///
    /// </details>
    ///
    /// # Implements
    ///
    /// [`ToplevelExt`][trait@crate::prelude::ToplevelExt], [`SurfaceExt`][trait@crate::prelude::SurfaceExt], [`ToplevelExtManual`][trait@crate::prelude::ToplevelExtManual], [`SurfaceExtManual`][trait@crate::prelude::SurfaceExtManual]
    #[doc(alias = "GdkToplevel")]
    pub struct Toplevel(Interface<ffi::GdkToplevel, ffi::GdkToplevelInterface>) @requires Surface;

    match fn {
        type_ => || ffi::gdk_toplevel_get_type(),
    }
}

impl Toplevel {
    pub const NONE: Option<&'static Toplevel> = None;
}

/// Trait containing all [`struct@Toplevel`] methods.
///
/// # Implementors
///
/// [`Toplevel`][struct@crate::Toplevel]
pub trait ToplevelExt: IsA<Toplevel> + 'static {
    /// Begins an interactive move operation.
    ///
    /// You might use this function to implement draggable titlebars.
    /// ## `device`
    /// the device used for the operation
    /// ## `button`
    /// the button being used to drag, or 0 for a keyboard-initiated drag
    /// ## `x`
    /// surface X coordinate of mouse click that began the drag
    /// ## `y`
    /// surface Y coordinate of mouse click that began the drag
    /// ## `timestamp`
    /// timestamp of mouse click that began the drag (use
    ///   [`Event::time()`][crate::Event::time()])
    #[doc(alias = "gdk_toplevel_begin_move")]
    fn begin_move(&self, device: &impl IsA<Device>, button: i32, x: f64, y: f64, timestamp: u32) {
        unsafe {
            ffi::gdk_toplevel_begin_move(
                self.as_ref().to_glib_none().0,
                device.as_ref().to_glib_none().0,
                button,
                x,
                y,
                timestamp,
            );
        }
    }

    /// window resize grip.
    /// ## `edge`
    /// the edge or corner from which the drag is started
    /// ## `device`
    /// the device used for the operation
    /// ## `button`
    /// the button being used to drag, or 0 for a keyboard-initiated drag
    /// ## `x`
    /// surface X coordinate of mouse click that began the drag
    /// ## `y`
    /// surface Y coordinate of mouse click that began the drag
    /// ## `timestamp`
    /// timestamp of mouse click that began the drag (use
    ///   [`Event::time()`][crate::Event::time()])
    #[doc(alias = "gdk_toplevel_begin_resize")]
    fn begin_resize(
        &self,
        edge: SurfaceEdge,
        device: Option<&impl IsA<Device>>,
        button: i32,
        x: f64,
        y: f64,
        timestamp: u32,
    ) {
        unsafe {
            ffi::gdk_toplevel_begin_resize(
                self.as_ref().to_glib_none().0,
                edge.into_glib(),
                device.map(|p| p.as_ref()).to_glib_none().0,
                button,
                x,
                y,
                timestamp,
            );
        }
    }

    /// Sets keyboard focus to @surface.
    ///
    /// In most cases, [gtk_window_present_with_time()](../gtk4/method.Window.present_with_time.html)
    /// should be used on a [GtkWindow](../gtk4/class.Window.html), rather than
    /// calling this function.
    /// ## `timestamp`
    /// timestamp of the event triggering the surface focus
    #[doc(alias = "gdk_toplevel_focus")]
    fn focus(&self, timestamp: u32) {
        unsafe {
            ffi::gdk_toplevel_focus(self.as_ref().to_glib_none().0, timestamp);
        }
    }

    /// The capabilities that are available for this toplevel.
    ///
    /// # Returns
    ///
    /// the capabilities of the [`Toplevel`][crate::Toplevel].
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "gdk_toplevel_get_capabilities")]
    #[doc(alias = "get_capabilities")]
    fn capabilities(&self) -> ToplevelCapabilities {
        unsafe {
            from_glib(ffi::gdk_toplevel_get_capabilities(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the gravity that is used when changing the toplevel
    /// size programmatically.
    ///
    /// # Returns
    ///
    /// the gravity
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "gdk_toplevel_get_gravity")]
    #[doc(alias = "get_gravity")]
    fn gravity(&self) -> Gravity {
        unsafe {
            from_glib(ffi::gdk_toplevel_get_gravity(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the bitwise or of the currently active surface state flags,
    /// from the [`ToplevelState`][crate::ToplevelState] enumeration.
    ///
    /// # Returns
    ///
    /// surface state bitfield
    #[doc(alias = "gdk_toplevel_get_state")]
    #[doc(alias = "get_state")]
    fn state(&self) -> ToplevelState {
        unsafe { from_glib(ffi::gdk_toplevel_get_state(self.as_ref().to_glib_none().0)) }
    }

    /// Requests that the @self inhibit the system shortcuts.
    ///
    /// This is asking the desktop environment/windowing system to let all
    /// keyboard events reach the surface, as long as it is focused, instead
    /// of triggering system actions.
    ///
    /// If granted, the rerouting remains active until the default shortcuts
    /// processing is restored with [`restore_system_shortcuts()`][Self::restore_system_shortcuts()],
    /// or the request is revoked by the desktop environment, windowing system
    /// or the user.
    ///
    /// A typical use case for this API is remote desktop or virtual machine
    /// viewers which need to inhibit the default system keyboard shortcuts
    /// so that the remote session or virtual host gets those instead of the
    /// local environment.
    ///
    /// The windowing system or desktop environment may ask the user to grant
    /// or deny the request or even choose to ignore the request entirely.
    ///
    /// The caller can be notified whenever the request is granted or revoked
    /// by listening to the [`shortcuts-inhibited`][struct@crate::Toplevel#shortcuts-inhibited] property.
    /// ## `event`
    /// the [`Event`][crate::Event] that is triggering the inhibit
    ///   request, or [`None`] if none is available
    #[doc(alias = "gdk_toplevel_inhibit_system_shortcuts")]
    fn inhibit_system_shortcuts(&self, event: Option<impl AsRef<Event>>) {
        unsafe {
            ffi::gdk_toplevel_inhibit_system_shortcuts(
                self.as_ref().to_glib_none().0,
                event.as_ref().map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Asks to lower the @self below other windows.
    ///
    /// The windowing system may choose to ignore the request.
    ///
    /// # Returns
    ///
    /// [`true`] if the surface was lowered
    #[doc(alias = "gdk_toplevel_lower")]
    fn lower(&self) -> bool {
        unsafe { from_glib(ffi::gdk_toplevel_lower(self.as_ref().to_glib_none().0)) }
    }

    /// Asks to minimize the @self.
    ///
    /// The windowing system may choose to ignore the request.
    ///
    /// # Returns
    ///
    /// [`true`] if the surface was minimized
    #[doc(alias = "gdk_toplevel_minimize")]
    fn minimize(&self) -> bool {
        unsafe { from_glib(ffi::gdk_toplevel_minimize(self.as_ref().to_glib_none().0)) }
    }

    /// Present @self after having processed the [`ToplevelLayout`][crate::ToplevelLayout] rules.
    ///
    /// If the toplevel was previously not showing, it will be showed,
    /// otherwise it will change layout according to @layout.
    ///
    /// GDK may emit the [`compute-size`][struct@crate::Toplevel#compute-size] signal to let
    /// the user of this toplevel compute the preferred size of the toplevel
    /// surface.
    ///
    /// Presenting is asynchronous and the specified layout parameters are not
    /// guaranteed to be respected.
    /// ## `layout`
    /// the [`ToplevelLayout`][crate::ToplevelLayout] object used to layout
    #[doc(alias = "gdk_toplevel_present")]
    fn present(&self, layout: &ToplevelLayout) {
        unsafe {
            ffi::gdk_toplevel_present(self.as_ref().to_glib_none().0, layout.to_glib_none().0);
        }
    }

    /// Restore default system keyboard shortcuts which were previously
    /// inhibited.
    ///
    /// This undoes the effect of [`inhibit_system_shortcuts()`][Self::inhibit_system_shortcuts()].
    #[doc(alias = "gdk_toplevel_restore_system_shortcuts")]
    fn restore_system_shortcuts(&self) {
        unsafe {
            ffi::gdk_toplevel_restore_system_shortcuts(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets the toplevel to be decorated.
    ///
    /// Setting @decorated to [`false`] hints the desktop environment
    /// that the surface has its own, client-side decorations and
    /// does not need to have window decorations added.
    /// ## `decorated`
    /// [`true`] to request decorations
    #[doc(alias = "gdk_toplevel_set_decorated")]
    #[doc(alias = "decorated")]
    fn set_decorated(&self, decorated: bool) {
        unsafe {
            ffi::gdk_toplevel_set_decorated(self.as_ref().to_glib_none().0, decorated.into_glib());
        }
    }

    /// Sets the toplevel to be deletable.
    ///
    /// Setting @deletable to [`true`] hints the desktop environment
    /// that it should offer the user a way to close the surface.
    /// ## `deletable`
    /// [`true`] to request a delete button
    #[doc(alias = "gdk_toplevel_set_deletable")]
    #[doc(alias = "deletable")]
    fn set_deletable(&self, deletable: bool) {
        unsafe {
            ffi::gdk_toplevel_set_deletable(self.as_ref().to_glib_none().0, deletable.into_glib());
        }
    }

    /// Sets the gravity that is used when changing the toplevel
    /// size programmatically.
    /// ## `gravity`
    /// the new gravity
    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "gdk_toplevel_set_gravity")]
    #[doc(alias = "gravity")]
    fn set_gravity(&self, gravity: Gravity) {
        unsafe {
            ffi::gdk_toplevel_set_gravity(self.as_ref().to_glib_none().0, gravity.into_glib());
        }
    }

    /// Sets a list of icons for the surface.
    ///
    /// One of these will be used to represent the surface in iconic form.
    /// The icon may be shown in window lists or task bars. Which icon
    /// size is shown depends on the window manager. The window manager
    /// can scale the icon but setting several size icons can give better
    /// image quality.
    ///
    /// Note that some platforms don't support surface icons.
    /// ## `surfaces`
    ///
    ///   A list of textures to use as icon, of different sizes
    #[doc(alias = "gdk_toplevel_set_icon_list")]
    #[doc(alias = "icon-list")]
    fn set_icon_list(&self, surfaces: &[Texture]) {
        unsafe {
            ffi::gdk_toplevel_set_icon_list(
                self.as_ref().to_glib_none().0,
                surfaces.to_glib_none().0,
            );
        }
    }

    /// Sets the toplevel to be modal.
    ///
    /// The application can use this hint to tell the
    /// window manager that a certain surface has modal
    /// behaviour. The window manager can use this information
    /// to handle modal surfaces in a special way.
    ///
    /// You should only use this on surfaces for which you have
    /// previously called [`set_transient_for()`][Self::set_transient_for()].
    /// ## `modal`
    /// [`true`] if the surface is modal, [`false`] otherwise.
    #[doc(alias = "gdk_toplevel_set_modal")]
    #[doc(alias = "modal")]
    fn set_modal(&self, modal: bool) {
        unsafe {
            ffi::gdk_toplevel_set_modal(self.as_ref().to_glib_none().0, modal.into_glib());
        }
    }

    /// Sets the startup notification ID.
    ///
    /// When using GTK, typically you should use
    /// [gtk_window_set_startup_id()](../gtk4/method.Window.set_startup_id.html)
    /// instead of this low-level function.
    /// ## `startup_id`
    /// a string with startup-notification identifier
    #[doc(alias = "gdk_toplevel_set_startup_id")]
    #[doc(alias = "startup-id")]
    fn set_startup_id(&self, startup_id: &str) {
        unsafe {
            ffi::gdk_toplevel_set_startup_id(
                self.as_ref().to_glib_none().0,
                startup_id.to_glib_none().0,
            );
        }
    }

    /// Sets the title of a toplevel surface.
    ///
    /// The title maybe be displayed in the titlebar,
    /// in lists of windows, etc.
    /// ## `title`
    /// title of @surface
    #[doc(alias = "gdk_toplevel_set_title")]
    #[doc(alias = "title")]
    fn set_title(&self, title: &str) {
        unsafe {
            ffi::gdk_toplevel_set_title(self.as_ref().to_glib_none().0, title.to_glib_none().0);
        }
    }

    /// re using [GtkWindow](../gtk4/class.Window.html).
    /// ## `parent`
    /// another toplevel [`Surface`][crate::Surface]
    #[doc(alias = "gdk_toplevel_set_transient_for")]
    #[doc(alias = "transient-for")]
    fn set_transient_for(&self, parent: &impl IsA<Surface>) {
        unsafe {
            ffi::gdk_toplevel_set_transient_for(
                self.as_ref().to_glib_none().0,
                parent.as_ref().to_glib_none().0,
            );
        }
    }

    /// Asks the windowing system to show the window menu.
    ///
    /// The window menu is the menu shown when right-clicking the titlebar
    /// on traditional windows managed by the window manager. This is useful
    /// for windows using client-side decorations, activating it with a
    /// right-click on the window decorations.
    /// ## `event`
    /// a [`Event`][crate::Event] to show the menu for
    ///
    /// # Returns
    ///
    /// [`true`] if the window menu was shown and [`false`] otherwise.
    #[doc(alias = "gdk_toplevel_show_window_menu")]
    fn show_window_menu(&self, event: impl AsRef<Event>) -> bool {
        unsafe {
            from_glib(ffi::gdk_toplevel_show_window_menu(
                self.as_ref().to_glib_none().0,
                event.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether the desktop environment supports
    /// tiled window states.
    ///
    /// # Returns
    ///
    /// [`true`] if the desktop environment supports tiled window states
    #[doc(alias = "gdk_toplevel_supports_edge_constraints")]
    fn supports_edge_constraints(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_toplevel_supports_edge_constraints(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Performs a title bar gesture.
    /// ## `gesture`
    /// a [`TitlebarGesture`][crate::TitlebarGesture]
    ///
    /// # Returns
    ///
    /// whether the gesture was performed
    #[cfg(feature = "v4_4")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gdk_toplevel_titlebar_gesture")]
    fn titlebar_gesture(&self, gesture: TitlebarGesture) -> bool {
        unsafe {
            from_glib(ffi::gdk_toplevel_titlebar_gesture(
                self.as_ref().to_glib_none().0,
                gesture.into_glib(),
            ))
        }
    }

    /// Whether the window manager should add decorations.
    fn is_decorated(&self) -> bool {
        ObjectExt::property(self.as_ref(), "decorated")
    }

    /// Whether the window manager should allow to close the surface.
    fn is_deletable(&self) -> bool {
        ObjectExt::property(self.as_ref(), "deletable")
    }

    /// The fullscreen mode of the surface.
    #[doc(alias = "fullscreen-mode")]
    fn fullscreen_mode(&self) -> FullscreenMode {
        ObjectExt::property(self.as_ref(), "fullscreen-mode")
    }

    /// The fullscreen mode of the surface.
    #[doc(alias = "fullscreen-mode")]
    fn set_fullscreen_mode(&self, fullscreen_mode: FullscreenMode) {
        ObjectExt::set_property(self.as_ref(), "fullscreen-mode", fullscreen_mode)
    }

    //#[doc(alias = "icon-list")]
    //fn icon_list(&self) -> /*Unimplemented*/Basic: Pointer {
    //    ObjectExt::property(self.as_ref(), "icon-list")
    //}

    /// Whether the surface is modal.
    fn is_modal(&self) -> bool {
        ObjectExt::property(self.as_ref(), "modal")
    }

    /// Whether the surface should inhibit keyboard shortcuts.
    #[doc(alias = "shortcuts-inhibited")]
    fn is_shortcuts_inhibited(&self) -> bool {
        ObjectExt::property(self.as_ref(), "shortcuts-inhibited")
    }

    /// The startup ID of the surface.
    ///
    /// See [`AppLaunchContext`][crate::AppLaunchContext] for more information about
    /// startup feedback.
    #[doc(alias = "startup-id")]
    fn startup_id(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "startup-id")
    }

    /// The title of the surface.
    fn title(&self) -> Option<glib::GString> {
        ObjectExt::property(self.as_ref(), "title")
    }

    /// The transient parent of the surface.
    #[doc(alias = "transient-for")]
    fn transient_for(&self) -> Option<Surface> {
        ObjectExt::property(self.as_ref(), "transient-for")
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "capabilities")]
    fn connect_capabilities_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_capabilities_trampoline<
            P: IsA<Toplevel>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::capabilities".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_capabilities_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "decorated")]
    fn connect_decorated_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_decorated_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::decorated".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_decorated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "deletable")]
    fn connect_deletable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_deletable_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::deletable".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_deletable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "fullscreen-mode")]
    fn connect_fullscreen_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_fullscreen_mode_trampoline<
            P: IsA<Toplevel>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::fullscreen-mode".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fullscreen_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_20")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_20")))]
    #[doc(alias = "gravity")]
    fn connect_gravity_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_gravity_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::gravity".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_gravity_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "icon-list")]
    fn connect_icon_list_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_icon_list_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::icon-list".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_icon_list_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "modal")]
    fn connect_modal_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_modal_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::modal".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_modal_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "shortcuts-inhibited")]
    fn connect_shortcuts_inhibited_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_shortcuts_inhibited_trampoline<
            P: IsA<Toplevel>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::shortcuts-inhibited".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_shortcuts_inhibited_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "startup-id")]
    fn connect_startup_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_startup_id_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::startup-id".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_startup_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "state")]
    fn connect_state_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_state_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "title")]
    fn connect_title_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_title_trampoline<P: IsA<Toplevel>, F: Fn(&P) + 'static>(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::title".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_title_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "transient-for")]
    fn connect_transient_for_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_transient_for_trampoline<
            P: IsA<Toplevel>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GdkToplevel,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(Toplevel::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::transient-for".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_transient_for_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Toplevel>> ToplevelExt for O {}