// 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(any(feature = "v4_4", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v4_4")))]
use crate::TitlebarGesture;
use crate::{
    Device, Event, FullscreenMode, Surface, SurfaceEdge, Texture, ToplevelLayout, ToplevelState,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// A [`Toplevel`][crate::Toplevel] is 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
    ///
    ///
    /// #### `decorated`
    ///  Whether the window manager should add decorations.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `deletable`
    ///  Whether the window manager should allow to close the surface.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `fullscreen-mode`
    ///  The fullscreen mode of the surface.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `icon-list`
    ///  A list of textures to use as icon.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `modal`
    ///  Whether the surface is modal.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `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 | Writeable
    ///
    ///
    /// #### `state`
    ///  The state of the toplevel.
    ///
    /// Readable
    ///
    ///
    /// #### `title`
    ///  The title of the surface.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `transient-for`
    ///  The transient parent of the surface.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Surface</h4></summary>
    ///
    ///
    /// #### `cursor`
    ///  The mouse pointer for the [`Surface`][crate::Surface].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `display`
    ///  The [`Display`][crate::Display] connection of the surface.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `frame-clock`
    ///  The [`FrameClock`][crate::FrameClock] of the surface.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `height`
    ///  The height of the surface, in pixels.
    ///
    /// Readable
    ///
    ///
    /// #### `mapped`
    ///  Whether the surface is mapped.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the surface.
    ///
    /// 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.
    ///
    /// It will normally be emitted during or after [`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.
    ///
    /// 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`
    ///  Emitted when the size of @surface is changed, or when relayout should
    /// be performed.
    ///
    /// Surface size is reported in ”application pixels”, not
    /// ”device pixels” (see gdk_surface_get_scale_factor()).
    ///
    ///
    ///
    ///
    /// #### `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: '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);

    /// Begins an interactive resize operation.
    ///
    /// You might use this function to implement a “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,
    );

    /// Sets keyboard focus to @surface.
    ///
    /// In most cases, `Gtk::Window::present_with_time()` should be
    /// used on a `Gtk::Window`, rather than calling this function.
    /// ## `timestamp`
    /// timestamp of the event triggering the surface focus
    #[doc(alias = "gdk_toplevel_focus")]
    fn focus(&self, timestamp: u32);

    /// 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;

    /// 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>>);

    /// 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;

    /// 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;

    /// 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);

    /// 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);

    /// 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")]
    fn set_decorated(&self, decorated: bool);

    /// 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")]
    fn set_deletable(&self, deletable: bool);

    /// 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")]
    fn set_icon_list(&self, surfaces: &[Texture]);

    /// 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")]
    fn set_modal(&self, modal: bool);

    /// Sets the startup notification ID.
    ///
    /// When using GTK, typically you should use
    /// `Gtk::Window::set_startup_id()` instead of this
    /// low-level function.
    /// ## `startup_id`
    /// a string with startup-notification identifier
    #[doc(alias = "gdk_toplevel_set_startup_id")]
    fn set_startup_id(&self, startup_id: &str);

    /// 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")]
    fn set_title(&self, title: &str);

    /// Sets a transient-for parent.
    ///
    /// Indicates to the window manager that @surface is a transient
    /// dialog associated with the application surface @parent. This
    /// allows the window manager to do things like center @surface
    /// on @parent and keep @surface above @parent.
    ///
    /// See `Gtk::Window::set_transient_for()` if you’re using
    /// `Gtk::Window` or `Gtk::Dialog`.
    /// ## `parent`
    /// another toplevel [`Surface`][crate::Surface]
    #[doc(alias = "gdk_toplevel_set_transient_for")]
    fn set_transient_for(&self, parent: &impl IsA<Surface>);

    /// 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;

    #[doc(alias = "gdk_toplevel_supports_edge_constraints")]
    fn supports_edge_constraints(&self) -> bool;

    #[cfg(any(feature = "v4_4", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_4")))]
    #[doc(alias = "gdk_toplevel_titlebar_gesture")]
    fn titlebar_gesture(&self, gesture: TitlebarGesture) -> bool;

    fn is_decorated(&self) -> bool;

    fn is_deletable(&self) -> bool;

    #[doc(alias = "fullscreen-mode")]
    fn fullscreen_mode(&self) -> FullscreenMode;

    #[doc(alias = "fullscreen-mode")]
    fn set_fullscreen_mode(&self, fullscreen_mode: FullscreenMode);

    //#[doc(alias = "icon-list")]
    //fn icon_list(&self) -> /*Unimplemented*/Basic: Pointer;

    fn is_modal(&self) -> bool;

    #[doc(alias = "shortcuts-inhibited")]
    fn is_shortcuts_inhibited(&self) -> bool;

    #[doc(alias = "startup-id")]
    fn startup_id(&self) -> Option<glib::GString>;

    fn title(&self) -> Option<glib::GString>;

    #[doc(alias = "transient-for")]
    fn transient_for(&self) -> Option<Surface>;

    #[doc(alias = "decorated")]
    fn connect_decorated_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "deletable")]
    fn connect_deletable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "fullscreen-mode")]
    fn connect_fullscreen_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "icon-list")]
    fn connect_icon_list_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "modal")]
    fn connect_modal_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "shortcuts-inhibited")]
    fn connect_shortcuts_inhibited_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "startup-id")]
    fn connect_startup_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "state")]
    fn connect_state_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "title")]
    fn connect_title_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "transient-for")]
    fn connect_transient_for_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Toplevel>> ToplevelExt for O {
    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,
            );
        }
    }

    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,
            );
        }
    }

    fn focus(&self, timestamp: u32) {
        unsafe {
            ffi::gdk_toplevel_focus(self.as_ref().to_glib_none().0, timestamp);
        }
    }

    fn state(&self) -> ToplevelState {
        unsafe { from_glib(ffi::gdk_toplevel_get_state(self.as_ref().to_glib_none().0)) }
    }

    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,
            );
        }
    }

    fn lower(&self) -> bool {
        unsafe { from_glib(ffi::gdk_toplevel_lower(self.as_ref().to_glib_none().0)) }
    }

    fn minimize(&self) -> bool {
        unsafe { from_glib(ffi::gdk_toplevel_minimize(self.as_ref().to_glib_none().0)) }
    }

    fn present(&self, layout: &ToplevelLayout) {
        unsafe {
            ffi::gdk_toplevel_present(self.as_ref().to_glib_none().0, layout.to_glib_none().0);
        }
    }

    fn restore_system_shortcuts(&self) {
        unsafe {
            ffi::gdk_toplevel_restore_system_shortcuts(self.as_ref().to_glib_none().0);
        }
    }

    fn set_decorated(&self, decorated: bool) {
        unsafe {
            ffi::gdk_toplevel_set_decorated(self.as_ref().to_glib_none().0, decorated.into_glib());
        }
    }

    fn set_deletable(&self, deletable: bool) {
        unsafe {
            ffi::gdk_toplevel_set_deletable(self.as_ref().to_glib_none().0, deletable.into_glib());
        }
    }

    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,
            );
        }
    }

    fn set_modal(&self, modal: bool) {
        unsafe {
            ffi::gdk_toplevel_set_modal(self.as_ref().to_glib_none().0, modal.into_glib());
        }
    }

    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,
            );
        }
    }

    fn set_title(&self, title: &str) {
        unsafe {
            ffi::gdk_toplevel_set_title(self.as_ref().to_glib_none().0, title.to_glib_none().0);
        }
    }

    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,
            );
        }
    }

    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,
            ))
        }
    }

    fn supports_edge_constraints(&self) -> bool {
        unsafe {
            from_glib(ffi::gdk_toplevel_supports_edge_constraints(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v4_4", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_4")))]
    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(),
            ))
        }
    }

    fn is_decorated(&self) -> bool {
        glib::ObjectExt::property(self.as_ref(), "decorated")
    }

    fn is_deletable(&self) -> bool {
        glib::ObjectExt::property(self.as_ref(), "deletable")
    }

    fn fullscreen_mode(&self) -> FullscreenMode {
        glib::ObjectExt::property(self.as_ref(), "fullscreen-mode")
    }

    fn set_fullscreen_mode(&self, fullscreen_mode: FullscreenMode) {
        glib::ObjectExt::set_property(self.as_ref(), "fullscreen-mode", fullscreen_mode)
    }

    //fn icon_list(&self) -> /*Unimplemented*/Basic: Pointer {
    //    glib::ObjectExt::property(self.as_ref(), "icon-list")
    //}

    fn is_modal(&self) -> bool {
        glib::ObjectExt::property(self.as_ref(), "modal")
    }

    fn is_shortcuts_inhibited(&self) -> bool {
        glib::ObjectExt::property(self.as_ref(), "shortcuts-inhibited")
    }

    fn startup_id(&self) -> Option<glib::GString> {
        glib::ObjectExt::property(self.as_ref(), "startup-id")
    }

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

    fn transient_for(&self) -> Option<Surface> {
        glib::ObjectExt::property(self.as_ref(), "transient-for")
    }

    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,
        ) {
            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 _,
                b"notify::decorated\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_decorated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::deletable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_deletable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::fullscreen-mode\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_fullscreen_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::icon-list\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_icon_list_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::modal\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_modal_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::shortcuts-inhibited\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_shortcuts_inhibited_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::startup-id\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_startup_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::state\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::title\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_title_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::transient-for\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_transient_for_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Toplevel {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("Toplevel")
    }
}