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

use crate::AccelGroup;
use crate::Align;
use crate::Application;
use crate::Bin;
use crate::Buildable;
use crate::Container;
use crate::ResizeMode;
use crate::Widget;
use crate::WindowGroup;
use crate::WindowPosition;
use crate::WindowType;
use glib::object::Cast;
use glib::object::IsA;
use glib::object::ObjectExt;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem;
use std::mem::transmute;
use std::ptr;

glib::wrapper! {
    /// A GtkWindow is a toplevel window which can contain other widgets.
    /// Windows normally have decorations that are under the control
    /// of the windowing system and allow the user to manipulate the window
    /// (resize it, move it, close it,...).
    ///
    /// # GtkWindow as GtkBuildable
    ///
    /// The GtkWindow implementation of the [`Buildable`][crate::Buildable] interface supports a
    /// custom `<accel-groups>` element, which supports any number of `<group>`
    /// elements representing the [`AccelGroup`][crate::AccelGroup] objects you want to add to
    /// your window (synonymous with [`GtkWindowExt::add_accel_group()`][crate::prelude::GtkWindowExt::add_accel_group()].
    ///
    /// It also supports the `<initial-focus>` element, whose name property names
    /// the widget to receive the focus when the window is mapped.
    ///
    /// An example of a UI definition fragment with accel groups:
    ///
    ///
    /// **⚠️ The following code is in plain ⚠️**
    ///
    /// ```plain
    /// window.background
    /// ├── decoration
    /// ├── <titlebar child>.titlebar [.default-decoration]
    /// ╰── <child>
    /// ```
    ///
    /// GtkWindow has a main CSS node with name window and style class .background,
    /// and a subnode with name decoration.
    ///
    /// Style classes that are typically used with the main CSS node are .csd (when
    /// client-side decorations are in use), .solid-csd (for client-side decorations
    /// without invisible borders), .ssd (used by mutter when rendering server-side
    /// decorations). GtkWindow also represents window states with the following
    /// style classes on the main node: .tiled, .maximized, .fullscreen. Specialized
    /// types of window often add their own discriminating style classes, such as
    /// .popup or .tooltip.
    ///
    /// GtkWindow adds the .titlebar and .default-decoration style classes to the
    /// widget that is added as a titlebar child.
    ///
    /// # Implements
    ///
    /// [`GtkWindowExt`][trait@crate::prelude::GtkWindowExt], [`BinExt`][trait@crate::prelude::BinExt], [`ContainerExt`][trait@crate::prelude::ContainerExt], [`WidgetExt`][trait@crate::prelude::WidgetExt], [`trait@glib::ObjectExt`], [`BuildableExt`][trait@crate::prelude::BuildableExt], [`GtkWindowExtManual`][trait@crate::prelude::GtkWindowExtManual], [`WidgetExtManual`][trait@crate::prelude::WidgetExtManual], [`BuildableExtManual`][trait@crate::prelude::BuildableExtManual]
    #[doc(alias = "GtkWindow")]
    pub struct Window(Object<ffi::GtkWindow, ffi::GtkWindowClass>) @extends Bin, Container, Widget, @implements Buildable;

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

impl Window {
    /// Creates a new [`Window`][crate::Window], which is a toplevel window that can
    /// contain other widgets. Nearly always, the type of the window should
    /// be [`WindowType::Toplevel`][crate::WindowType::Toplevel]. If you’re implementing something like a
    /// popup menu from scratch (which is a bad idea, just use [`Menu`][crate::Menu]),
    /// you might use [`WindowType::Popup`][crate::WindowType::Popup]. [`WindowType::Popup`][crate::WindowType::Popup] is not for
    /// dialogs, though in some other toolkits dialogs are called “popups”.
    /// In GTK+, [`WindowType::Popup`][crate::WindowType::Popup] means a pop-up menu or pop-up tooltip.
    /// On X11, popup windows are not controlled by the
    /// [window manager][gtk-X11-arch].
    ///
    /// If you simply want an undecorated window (no window borders), use
    /// [`GtkWindowExt::set_decorated()`][crate::prelude::GtkWindowExt::set_decorated()], don’t use [`WindowType::Popup`][crate::WindowType::Popup].
    ///
    /// All top-level windows created by [`new()`][Self::new()] are stored in
    /// an internal top-level window list. This list can be obtained from
    /// [`list_toplevels()`][Self::list_toplevels()]. Due to Gtk+ keeping a reference to
    /// the window internally, [`new()`][Self::new()] does not return a reference
    /// to the caller.
    ///
    /// To delete a [`Window`][crate::Window], call `gtk_widget_destroy()`.
    /// ## `type_`
    /// type of window
    ///
    /// # Returns
    ///
    /// a new [`Window`][crate::Window].
    #[doc(alias = "gtk_window_new")]
    pub fn new(type_: WindowType) -> Window {
        assert_initialized_main_thread!();
        unsafe { Widget::from_glib_none(ffi::gtk_window_new(type_.into_glib())).unsafe_cast() }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Window`] objects.
    ///
    /// This method returns an instance of [`WindowBuilder`] which can be used to create [`Window`] objects.
    pub fn builder() -> WindowBuilder {
        WindowBuilder::default()
    }

    /// Gets the value set by [`set_default_icon_list()`][Self::set_default_icon_list()].
    /// The list is a copy and should be freed with `g_list_free()`,
    /// but the pixbufs in the list have not had their reference count
    /// incremented.
    ///
    /// # Returns
    ///
    /// copy of default icon list
    #[doc(alias = "gtk_window_get_default_icon_list")]
    #[doc(alias = "get_default_icon_list")]
    pub fn default_icon_list() -> Vec<gdk_pixbuf::Pixbuf> {
        assert_initialized_main_thread!();
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_window_get_default_icon_list())
        }
    }

    /// Returns the fallback icon name for windows that has been set
    /// with [`set_default_icon_name()`][Self::set_default_icon_name()]. The returned
    /// string is owned by GTK+ and should not be modified. It
    /// is only valid until the next call to
    /// [`set_default_icon_name()`][Self::set_default_icon_name()].
    ///
    /// # Returns
    ///
    /// the fallback icon name for windows
    #[doc(alias = "gtk_window_get_default_icon_name")]
    #[doc(alias = "get_default_icon_name")]
    pub fn default_icon_name() -> Option<glib::GString> {
        assert_initialized_main_thread!();
        unsafe { from_glib_none(ffi::gtk_window_get_default_icon_name()) }
    }

    /// Returns a list of all existing toplevel windows. The widgets
    /// in the list are not individually referenced. If you want
    /// to iterate through the list and perform actions involving
    /// callbacks that might destroy the widgets, you must call
    /// `g_list_foreach (result, (GFunc)g_object_ref, NULL)` first, and
    /// then unref all the widgets afterwards.
    ///
    /// # Returns
    ///
    /// list of toplevel widgets
    #[doc(alias = "gtk_window_list_toplevels")]
    pub fn list_toplevels() -> Vec<Widget> {
        assert_initialized_main_thread!();
        unsafe { FromGlibPtrContainer::from_glib_container(ffi::gtk_window_list_toplevels()) }
    }

    /// By default, after showing the first [`Window`][crate::Window], GTK+ calls
    /// `gdk_notify_startup_complete()`. Call this function to disable
    /// the automatic startup notification. You might do this if your
    /// first window is a splash screen, and you want to delay notification
    /// until after your real main window has been shown, for example.
    ///
    /// In that example, you would disable startup notification
    /// temporarily, show your splash screen, then re-enable it so that
    /// showing the main window would automatically result in notification.
    /// ## `setting`
    /// [`true`] to automatically do startup notification
    #[doc(alias = "gtk_window_set_auto_startup_notification")]
    pub fn set_auto_startup_notification(setting: bool) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_window_set_auto_startup_notification(setting.into_glib());
        }
    }

    /// Sets an icon to be used as fallback for windows that haven't
    /// had [`GtkWindowExt::set_icon()`][crate::prelude::GtkWindowExt::set_icon()] called on them from a pixbuf.
    /// ## `icon`
    /// the icon
    #[doc(alias = "gtk_window_set_default_icon")]
    pub fn set_default_icon(icon: &gdk_pixbuf::Pixbuf) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_window_set_default_icon(icon.to_glib_none().0);
        }
    }

    /// Sets an icon to be used as fallback for windows that haven't
    /// had [`GtkWindowExt::set_icon_list()`][crate::prelude::GtkWindowExt::set_icon_list()] called on them from a file
    /// on disk. Warns on failure if `err` is [`None`].
    /// ## `filename`
    /// location of icon file
    ///
    /// # Returns
    ///
    /// [`true`] if setting the icon succeeded.
    #[doc(alias = "gtk_window_set_default_icon_from_file")]
    pub fn set_default_icon_from_file<P: AsRef<std::path::Path>>(
        filename: P,
    ) -> Result<(), glib::Error> {
        assert_initialized_main_thread!();
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_window_set_default_icon_from_file(
                filename.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets an icon list to be used as fallback for windows that haven't
    /// had [`GtkWindowExt::set_icon_list()`][crate::prelude::GtkWindowExt::set_icon_list()] called on them to set up a
    /// window-specific icon list. This function allows you to set up the
    /// icon for all windows in your app at once.
    ///
    /// See [`GtkWindowExt::set_icon_list()`][crate::prelude::GtkWindowExt::set_icon_list()] for more details.
    /// ## `list`
    /// a list of [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf]
    #[doc(alias = "gtk_window_set_default_icon_list")]
    pub fn set_default_icon_list(list: &[gdk_pixbuf::Pixbuf]) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_window_set_default_icon_list(list.to_glib_container().0);
        }
    }

    /// Sets an icon to be used as fallback for windows that haven't
    /// had [`GtkWindowExt::set_icon_list()`][crate::prelude::GtkWindowExt::set_icon_list()] called on them from a named
    /// themed icon, see [`GtkWindowExt::set_icon_name()`][crate::prelude::GtkWindowExt::set_icon_name()].
    /// ## `name`
    /// the name of the themed icon
    #[doc(alias = "gtk_window_set_default_icon_name")]
    pub fn set_default_icon_name(name: &str) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_window_set_default_icon_name(name.to_glib_none().0);
        }
    }

    /// Opens or closes the [interactive debugger][interactive-debugging],
    /// which offers access to the widget hierarchy of the application
    /// and to useful debugging tools.
    /// ## `enable`
    /// [`true`] to enable interactive debugging
    #[doc(alias = "gtk_window_set_interactive_debugging")]
    pub fn set_interactive_debugging(enable: bool) {
        assert_initialized_main_thread!();
        unsafe {
            ffi::gtk_window_set_interactive_debugging(enable.into_glib());
        }
    }
}

#[derive(Clone, Default)]
// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Window`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
pub struct WindowBuilder {
    accept_focus: Option<bool>,
    application: Option<Application>,
    attached_to: Option<Widget>,
    decorated: Option<bool>,
    default_height: Option<i32>,
    default_width: Option<i32>,
    deletable: Option<bool>,
    destroy_with_parent: Option<bool>,
    focus_on_map: Option<bool>,
    focus_visible: Option<bool>,
    gravity: Option<gdk::Gravity>,
    hide_titlebar_when_maximized: Option<bool>,
    icon: Option<gdk_pixbuf::Pixbuf>,
    icon_name: Option<String>,
    mnemonics_visible: Option<bool>,
    modal: Option<bool>,
    resizable: Option<bool>,
    role: Option<String>,
    screen: Option<gdk::Screen>,
    skip_pager_hint: Option<bool>,
    skip_taskbar_hint: Option<bool>,
    startup_id: Option<String>,
    title: Option<String>,
    transient_for: Option<Window>,
    type_: Option<WindowType>,
    type_hint: Option<gdk::WindowTypeHint>,
    urgency_hint: Option<bool>,
    window_position: Option<WindowPosition>,
    border_width: Option<u32>,
    child: Option<Widget>,
    resize_mode: Option<ResizeMode>,
    app_paintable: Option<bool>,
    can_default: Option<bool>,
    can_focus: Option<bool>,
    events: Option<gdk::EventMask>,
    expand: Option<bool>,
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    focus_on_click: Option<bool>,
    halign: Option<Align>,
    has_default: Option<bool>,
    has_focus: Option<bool>,
    has_tooltip: Option<bool>,
    height_request: Option<i32>,
    hexpand: Option<bool>,
    hexpand_set: Option<bool>,
    is_focus: Option<bool>,
    margin: Option<i32>,
    margin_bottom: Option<i32>,
    margin_end: Option<i32>,
    margin_start: Option<i32>,
    margin_top: Option<i32>,
    name: Option<String>,
    no_show_all: Option<bool>,
    opacity: Option<f64>,
    parent: Option<Container>,
    receives_default: Option<bool>,
    sensitive: Option<bool>,
    tooltip_markup: Option<String>,
    tooltip_text: Option<String>,
    valign: Option<Align>,
    vexpand: Option<bool>,
    vexpand_set: Option<bool>,
    visible: Option<bool>,
    width_request: Option<i32>,
}

impl WindowBuilder {
    // rustdoc-stripper-ignore-next
    /// Create a new [`WindowBuilder`].
    pub fn new() -> Self {
        Self::default()
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Window`].
    pub fn build(self) -> Window {
        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
        if let Some(ref accept_focus) = self.accept_focus {
            properties.push(("accept-focus", accept_focus));
        }
        if let Some(ref application) = self.application {
            properties.push(("application", application));
        }
        if let Some(ref attached_to) = self.attached_to {
            properties.push(("attached-to", attached_to));
        }
        if let Some(ref decorated) = self.decorated {
            properties.push(("decorated", decorated));
        }
        if let Some(ref default_height) = self.default_height {
            properties.push(("default-height", default_height));
        }
        if let Some(ref default_width) = self.default_width {
            properties.push(("default-width", default_width));
        }
        if let Some(ref deletable) = self.deletable {
            properties.push(("deletable", deletable));
        }
        if let Some(ref destroy_with_parent) = self.destroy_with_parent {
            properties.push(("destroy-with-parent", destroy_with_parent));
        }
        if let Some(ref focus_on_map) = self.focus_on_map {
            properties.push(("focus-on-map", focus_on_map));
        }
        if let Some(ref focus_visible) = self.focus_visible {
            properties.push(("focus-visible", focus_visible));
        }
        if let Some(ref gravity) = self.gravity {
            properties.push(("gravity", gravity));
        }
        if let Some(ref hide_titlebar_when_maximized) = self.hide_titlebar_when_maximized {
            properties.push(("hide-titlebar-when-maximized", hide_titlebar_when_maximized));
        }
        if let Some(ref icon) = self.icon {
            properties.push(("icon", icon));
        }
        if let Some(ref icon_name) = self.icon_name {
            properties.push(("icon-name", icon_name));
        }
        if let Some(ref mnemonics_visible) = self.mnemonics_visible {
            properties.push(("mnemonics-visible", mnemonics_visible));
        }
        if let Some(ref modal) = self.modal {
            properties.push(("modal", modal));
        }
        if let Some(ref resizable) = self.resizable {
            properties.push(("resizable", resizable));
        }
        if let Some(ref role) = self.role {
            properties.push(("role", role));
        }
        if let Some(ref screen) = self.screen {
            properties.push(("screen", screen));
        }
        if let Some(ref skip_pager_hint) = self.skip_pager_hint {
            properties.push(("skip-pager-hint", skip_pager_hint));
        }
        if let Some(ref skip_taskbar_hint) = self.skip_taskbar_hint {
            properties.push(("skip-taskbar-hint", skip_taskbar_hint));
        }
        if let Some(ref startup_id) = self.startup_id {
            properties.push(("startup-id", startup_id));
        }
        if let Some(ref title) = self.title {
            properties.push(("title", title));
        }
        if let Some(ref transient_for) = self.transient_for {
            properties.push(("transient-for", transient_for));
        }
        if let Some(ref type_) = self.type_ {
            properties.push(("type", type_));
        }
        if let Some(ref type_hint) = self.type_hint {
            properties.push(("type-hint", type_hint));
        }
        if let Some(ref urgency_hint) = self.urgency_hint {
            properties.push(("urgency-hint", urgency_hint));
        }
        if let Some(ref window_position) = self.window_position {
            properties.push(("window-position", window_position));
        }
        if let Some(ref border_width) = self.border_width {
            properties.push(("border-width", border_width));
        }
        if let Some(ref child) = self.child {
            properties.push(("child", child));
        }
        if let Some(ref resize_mode) = self.resize_mode {
            properties.push(("resize-mode", resize_mode));
        }
        if let Some(ref app_paintable) = self.app_paintable {
            properties.push(("app-paintable", app_paintable));
        }
        if let Some(ref can_default) = self.can_default {
            properties.push(("can-default", can_default));
        }
        if let Some(ref can_focus) = self.can_focus {
            properties.push(("can-focus", can_focus));
        }
        if let Some(ref events) = self.events {
            properties.push(("events", events));
        }
        if let Some(ref expand) = self.expand {
            properties.push(("expand", expand));
        }
        #[cfg(any(feature = "v3_20", feature = "dox"))]
        if let Some(ref focus_on_click) = self.focus_on_click {
            properties.push(("focus-on-click", focus_on_click));
        }
        if let Some(ref halign) = self.halign {
            properties.push(("halign", halign));
        }
        if let Some(ref has_default) = self.has_default {
            properties.push(("has-default", has_default));
        }
        if let Some(ref has_focus) = self.has_focus {
            properties.push(("has-focus", has_focus));
        }
        if let Some(ref has_tooltip) = self.has_tooltip {
            properties.push(("has-tooltip", has_tooltip));
        }
        if let Some(ref height_request) = self.height_request {
            properties.push(("height-request", height_request));
        }
        if let Some(ref hexpand) = self.hexpand {
            properties.push(("hexpand", hexpand));
        }
        if let Some(ref hexpand_set) = self.hexpand_set {
            properties.push(("hexpand-set", hexpand_set));
        }
        if let Some(ref is_focus) = self.is_focus {
            properties.push(("is-focus", is_focus));
        }
        if let Some(ref margin) = self.margin {
            properties.push(("margin", margin));
        }
        if let Some(ref margin_bottom) = self.margin_bottom {
            properties.push(("margin-bottom", margin_bottom));
        }
        if let Some(ref margin_end) = self.margin_end {
            properties.push(("margin-end", margin_end));
        }
        if let Some(ref margin_start) = self.margin_start {
            properties.push(("margin-start", margin_start));
        }
        if let Some(ref margin_top) = self.margin_top {
            properties.push(("margin-top", margin_top));
        }
        if let Some(ref name) = self.name {
            properties.push(("name", name));
        }
        if let Some(ref no_show_all) = self.no_show_all {
            properties.push(("no-show-all", no_show_all));
        }
        if let Some(ref opacity) = self.opacity {
            properties.push(("opacity", opacity));
        }
        if let Some(ref parent) = self.parent {
            properties.push(("parent", parent));
        }
        if let Some(ref receives_default) = self.receives_default {
            properties.push(("receives-default", receives_default));
        }
        if let Some(ref sensitive) = self.sensitive {
            properties.push(("sensitive", sensitive));
        }
        if let Some(ref tooltip_markup) = self.tooltip_markup {
            properties.push(("tooltip-markup", tooltip_markup));
        }
        if let Some(ref tooltip_text) = self.tooltip_text {
            properties.push(("tooltip-text", tooltip_text));
        }
        if let Some(ref valign) = self.valign {
            properties.push(("valign", valign));
        }
        if let Some(ref vexpand) = self.vexpand {
            properties.push(("vexpand", vexpand));
        }
        if let Some(ref vexpand_set) = self.vexpand_set {
            properties.push(("vexpand-set", vexpand_set));
        }
        if let Some(ref visible) = self.visible {
            properties.push(("visible", visible));
        }
        if let Some(ref width_request) = self.width_request {
            properties.push(("width-request", width_request));
        }
        glib::Object::new::<Window>(&properties).expect("Failed to create an instance of Window")
    }

    /// Whether the window should receive the input focus.
    pub fn accept_focus(mut self, accept_focus: bool) -> Self {
        self.accept_focus = Some(accept_focus);
        self
    }

    /// The [`Application`][crate::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 property to [`None`].
    pub fn application<P: IsA<Application>>(mut self, application: &P) -> Self {
        self.application = Some(application.clone().upcast());
        self
    }

    /// The widget to which this window is attached.
    /// See [`GtkWindowExt::set_attached_to()`][crate::prelude::GtkWindowExt::set_attached_to()].
    ///
    /// Examples of places where specifying this relation is useful are
    /// for instance a [`Menu`][crate::Menu] created by a [`ComboBox`][crate::ComboBox], a completion
    /// popup window created by [`Entry`][crate::Entry] or a typeahead search entry
    /// created by [`TreeView`][crate::TreeView].
    pub fn attached_to<P: IsA<Widget>>(mut self, attached_to: &P) -> Self {
        self.attached_to = Some(attached_to.clone().upcast());
        self
    }

    /// Whether the window should be decorated by the window manager.
    pub fn decorated(mut self, decorated: bool) -> Self {
        self.decorated = Some(decorated);
        self
    }

    pub fn default_height(mut self, default_height: i32) -> Self {
        self.default_height = Some(default_height);
        self
    }

    pub fn default_width(mut self, default_width: i32) -> Self {
        self.default_width = Some(default_width);
        self
    }

    /// Whether the window frame should have a close button.
    pub fn deletable(mut self, deletable: bool) -> Self {
        self.deletable = Some(deletable);
        self
    }

    pub fn destroy_with_parent(mut self, destroy_with_parent: bool) -> Self {
        self.destroy_with_parent = Some(destroy_with_parent);
        self
    }

    /// Whether the window should receive the input focus when mapped.
    pub fn focus_on_map(mut self, focus_on_map: bool) -> Self {
        self.focus_on_map = Some(focus_on_map);
        self
    }

    /// Whether 'focus rectangles' are currently visible in this window.
    ///
    /// This property is maintained by GTK+ based on user input
    /// and should not be set by applications.
    pub fn focus_visible(mut self, focus_visible: bool) -> Self {
        self.focus_visible = Some(focus_visible);
        self
    }

    /// The window gravity of the window. See [`GtkWindowExt::move_()`][crate::prelude::GtkWindowExt::move_()] and [`gdk::Gravity`][crate::gdk::Gravity] for
    /// more details about window gravity.
    pub fn gravity(mut self, gravity: gdk::Gravity) -> Self {
        self.gravity = Some(gravity);
        self
    }

    /// Whether the titlebar should be hidden during maximization.
    pub fn hide_titlebar_when_maximized(mut self, hide_titlebar_when_maximized: bool) -> Self {
        self.hide_titlebar_when_maximized = Some(hide_titlebar_when_maximized);
        self
    }

    pub fn icon(mut self, icon: &gdk_pixbuf::Pixbuf) -> Self {
        self.icon = Some(icon.clone());
        self
    }

    /// The :icon-name property specifies the name of the themed icon to
    /// use as the window icon. See [`IconTheme`][crate::IconTheme] for more details.
    pub fn icon_name(mut self, icon_name: &str) -> Self {
        self.icon_name = Some(icon_name.to_string());
        self
    }

    /// Whether mnemonics are currently visible in this window.
    ///
    /// This property is maintained by GTK+ based on user input,
    /// and should not be set by applications.
    pub fn mnemonics_visible(mut self, mnemonics_visible: bool) -> Self {
        self.mnemonics_visible = Some(mnemonics_visible);
        self
    }

    pub fn modal(mut self, modal: bool) -> Self {
        self.modal = Some(modal);
        self
    }

    pub fn resizable(mut self, resizable: bool) -> Self {
        self.resizable = Some(resizable);
        self
    }

    pub fn role(mut self, role: &str) -> Self {
        self.role = Some(role.to_string());
        self
    }

    pub fn screen(mut self, screen: &gdk::Screen) -> Self {
        self.screen = Some(screen.clone());
        self
    }

    pub fn skip_pager_hint(mut self, skip_pager_hint: bool) -> Self {
        self.skip_pager_hint = Some(skip_pager_hint);
        self
    }

    pub fn skip_taskbar_hint(mut self, skip_taskbar_hint: bool) -> Self {
        self.skip_taskbar_hint = Some(skip_taskbar_hint);
        self
    }

    /// The :startup-id is a write-only property for setting window's
    /// startup notification identifier. See [`GtkWindowExt::set_startup_id()`][crate::prelude::GtkWindowExt::set_startup_id()]
    /// for more details.
    pub fn startup_id(mut self, startup_id: &str) -> Self {
        self.startup_id = Some(startup_id.to_string());
        self
    }

    pub fn title(mut self, title: &str) -> Self {
        self.title = Some(title.to_string());
        self
    }

    /// The transient parent of the window. See [`GtkWindowExt::set_transient_for()`][crate::prelude::GtkWindowExt::set_transient_for()] for
    /// more details about transient windows.
    pub fn transient_for<P: IsA<Window>>(mut self, transient_for: &P) -> Self {
        self.transient_for = Some(transient_for.clone().upcast());
        self
    }

    pub fn type_(mut self, type_: WindowType) -> Self {
        self.type_ = Some(type_);
        self
    }

    pub fn type_hint(mut self, type_hint: gdk::WindowTypeHint) -> Self {
        self.type_hint = Some(type_hint);
        self
    }

    pub fn urgency_hint(mut self, urgency_hint: bool) -> Self {
        self.urgency_hint = Some(urgency_hint);
        self
    }

    pub fn window_position(mut self, window_position: WindowPosition) -> Self {
        self.window_position = Some(window_position);
        self
    }

    pub fn border_width(mut self, border_width: u32) -> Self {
        self.border_width = Some(border_width);
        self
    }

    pub fn child<P: IsA<Widget>>(mut self, child: &P) -> Self {
        self.child = Some(child.clone().upcast());
        self
    }

    pub fn resize_mode(mut self, resize_mode: ResizeMode) -> Self {
        self.resize_mode = Some(resize_mode);
        self
    }

    pub fn app_paintable(mut self, app_paintable: bool) -> Self {
        self.app_paintable = Some(app_paintable);
        self
    }

    pub fn can_default(mut self, can_default: bool) -> Self {
        self.can_default = Some(can_default);
        self
    }

    pub fn can_focus(mut self, can_focus: bool) -> Self {
        self.can_focus = Some(can_focus);
        self
    }

    pub fn events(mut self, events: gdk::EventMask) -> Self {
        self.events = Some(events);
        self
    }

    /// Whether to expand in both directions. Setting this sets both `property::Widget::hexpand` and `property::Widget::vexpand`
    pub fn expand(mut self, expand: bool) -> Self {
        self.expand = Some(expand);
        self
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Before 3.20, several widgets (GtkButton, GtkFileChooserButton,
    /// GtkComboBox) implemented this property individually.
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    pub fn focus_on_click(mut self, focus_on_click: bool) -> Self {
        self.focus_on_click = Some(focus_on_click);
        self
    }

    /// How to distribute horizontal space if widget gets extra space, see [`Align`][crate::Align]
    pub fn halign(mut self, halign: Align) -> Self {
        self.halign = Some(halign);
        self
    }

    pub fn has_default(mut self, has_default: bool) -> Self {
        self.has_default = Some(has_default);
        self
    }

    pub fn has_focus(mut self, has_focus: bool) -> Self {
        self.has_focus = Some(has_focus);
        self
    }

    /// Enables or disables the emission of `signal::Widget::query-tooltip` on `widget`.
    /// A value of [`true`] indicates that `widget` can have a tooltip, in this case
    /// the widget will be queried using `signal::Widget::query-tooltip` to determine
    /// whether it will provide a tooltip or not.
    ///
    /// Note that setting this property to [`true`] for the first time will change
    /// the event masks of the GdkWindows of this widget to include leave-notify
    /// and motion-notify events. This cannot and will not be undone when the
    /// property is set to [`false`] again.
    pub fn has_tooltip(mut self, has_tooltip: bool) -> Self {
        self.has_tooltip = Some(has_tooltip);
        self
    }

    pub fn height_request(mut self, height_request: i32) -> Self {
        self.height_request = Some(height_request);
        self
    }

    /// Whether to expand horizontally. See [`WidgetExt::set_hexpand()`][crate::prelude::WidgetExt::set_hexpand()].
    pub fn hexpand(mut self, hexpand: bool) -> Self {
        self.hexpand = Some(hexpand);
        self
    }

    /// Whether to use the `property::Widget::hexpand` property. See [`WidgetExt::is_hexpand_set()`][crate::prelude::WidgetExt::is_hexpand_set()].
    pub fn hexpand_set(mut self, hexpand_set: bool) -> Self {
        self.hexpand_set = Some(hexpand_set);
        self
    }

    pub fn is_focus(mut self, is_focus: bool) -> Self {
        self.is_focus = Some(is_focus);
        self
    }

    /// Sets all four sides' margin at once. If read, returns max
    /// margin on any side.
    pub fn margin(mut self, margin: i32) -> Self {
        self.margin = Some(margin);
        self
    }

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_bottom(mut self, margin_bottom: i32) -> Self {
        self.margin_bottom = Some(margin_bottom);
        self
    }

    /// Margin on end of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_end(mut self, margin_end: i32) -> Self {
        self.margin_end = Some(margin_end);
        self
    }

    /// Margin on start of widget, horizontally. This property supports
    /// left-to-right and right-to-left text directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_start(mut self, margin_start: i32) -> Self {
        self.margin_start = Some(margin_start);
        self
    }

    /// Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExt::set_size_request()`][crate::prelude::WidgetExt::set_size_request()] for example.
    pub fn margin_top(mut self, margin_top: i32) -> Self {
        self.margin_top = Some(margin_top);
        self
    }

    pub fn name(mut self, name: &str) -> Self {
        self.name = Some(name.to_string());
        self
    }

    pub fn no_show_all(mut self, no_show_all: bool) -> Self {
        self.no_show_all = Some(no_show_all);
        self
    }

    /// The requested opacity of the widget. See [`WidgetExt::set_opacity()`][crate::prelude::WidgetExt::set_opacity()] for
    /// more details about window opacity.
    ///
    /// Before 3.8 this was only available in GtkWindow
    pub fn opacity(mut self, opacity: f64) -> Self {
        self.opacity = Some(opacity);
        self
    }

    pub fn parent<P: IsA<Container>>(mut self, parent: &P) -> Self {
        self.parent = Some(parent.clone().upcast());
        self
    }

    pub fn receives_default(mut self, receives_default: bool) -> Self {
        self.receives_default = Some(receives_default);
        self
    }

    pub fn sensitive(mut self, sensitive: bool) -> Self {
        self.sensitive = Some(sensitive);
        self
    }

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with the [Pango text markup language][PangoMarkupFormat].
    /// Also see [`Tooltip::set_markup()`][crate::Tooltip::set_markup()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: `property::Widget::has-tooltip`
    /// will automatically be set to [`true`] and there will be taken care of
    /// `signal::Widget::query-tooltip` in the default signal handler.
    ///
    /// Note that if both `property::Widget::tooltip-text` and `property::Widget::tooltip-markup`
    /// are set, the last one wins.
    pub fn tooltip_markup(mut self, tooltip_markup: &str) -> Self {
        self.tooltip_markup = Some(tooltip_markup.to_string());
        self
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see [`Tooltip::set_text()`][crate::Tooltip::set_text()].
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not [`None`]: `property::Widget::has-tooltip`
    /// will automatically be set to [`true`] and there will be taken care of
    /// `signal::Widget::query-tooltip` in the default signal handler.
    ///
    /// Note that if both `property::Widget::tooltip-text` and `property::Widget::tooltip-markup`
    /// are set, the last one wins.
    pub fn tooltip_text(mut self, tooltip_text: &str) -> Self {
        self.tooltip_text = Some(tooltip_text.to_string());
        self
    }

    /// How to distribute vertical space if widget gets extra space, see [`Align`][crate::Align]
    pub fn valign(mut self, valign: Align) -> Self {
        self.valign = Some(valign);
        self
    }

    /// Whether to expand vertically. See [`WidgetExt::set_vexpand()`][crate::prelude::WidgetExt::set_vexpand()].
    pub fn vexpand(mut self, vexpand: bool) -> Self {
        self.vexpand = Some(vexpand);
        self
    }

    /// Whether to use the `property::Widget::vexpand` property. See [`WidgetExt::is_vexpand_set()`][crate::prelude::WidgetExt::is_vexpand_set()].
    pub fn vexpand_set(mut self, vexpand_set: bool) -> Self {
        self.vexpand_set = Some(vexpand_set);
        self
    }

    pub fn visible(mut self, visible: bool) -> Self {
        self.visible = Some(visible);
        self
    }

    pub fn width_request(mut self, width_request: i32) -> Self {
        self.width_request = Some(width_request);
        self
    }
}

pub const NONE_WINDOW: Option<&Window> = None;

/// Trait containing all [`struct@Window`] methods.
///
/// # Implementors
///
/// [`ApplicationWindow`][struct@crate::ApplicationWindow], [`Assistant`][struct@crate::Assistant], [`Dialog`][struct@crate::Dialog], [`OffscreenWindow`][struct@crate::OffscreenWindow], [`Plug`][struct@crate::Plug], [`ShortcutsWindow`][struct@crate::ShortcutsWindow], [`Window`][struct@crate::Window]
pub trait GtkWindowExt: 'static {
    /// 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()`][crate::prelude::WidgetExt::set_receives_default()]), in which case the
    /// focused widget is activated.
    ///
    /// # Returns
    ///
    /// [`true`] if a widget got activated.
    #[doc(alias = "gtk_window_activate_default")]
    fn activate_default(&self) -> bool;

    /// Activates the current focused widget within the window.
    ///
    /// # Returns
    ///
    /// [`true`] if a widget got activated.
    #[doc(alias = "gtk_window_activate_focus")]
    fn activate_focus(&self) -> bool;

    /// Activates mnemonics and accelerators for this [`Window`][crate::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`
    /// a [`gdk::EventKey`][crate::gdk::EventKey]
    ///
    /// # Returns
    ///
    /// [`true`] if a mnemonic or accelerator was found and activated.
    #[doc(alias = "gtk_window_activate_key")]
    fn activate_key(&self, event: &gdk::EventKey) -> bool;

    /// Associate `accel_group` with `self`, such that calling
    /// [`accel_groups_activate()`][crate::accel_groups_activate()] on `self` will activate accelerators
    /// in `accel_group`.
    /// ## `accel_group`
    /// a [`AccelGroup`][crate::AccelGroup]
    #[doc(alias = "gtk_window_add_accel_group")]
    fn add_accel_group<P: IsA<AccelGroup>>(&self, accel_group: &P);

    /// Adds a mnemonic to this window.
    /// ## `keyval`
    /// the mnemonic
    /// ## `target`
    /// the widget that gets activated by the mnemonic
    #[doc(alias = "gtk_window_add_mnemonic")]
    fn add_mnemonic<P: IsA<Widget>>(&self, keyval: u32, target: &P);

    /// 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
    #[doc(alias = "gtk_window_begin_move_drag")]
    fn begin_move_drag(&self, 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
    #[doc(alias = "gtk_window_begin_resize_drag")]
    fn begin_resize_drag(
        &self,
        edge: gdk::WindowEdge,
        button: i32,
        root_x: i32,
        root_y: i32,
        timestamp: u32,
    );

    /// 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.
    #[doc(alias = "gtk_window_close")]
    fn close(&self);

    /// 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`][crate::Widget].
    #[doc(alias = "gtk_window_deiconify")]
    fn deiconify(&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`][crate::Widget].
    #[doc(alias = "gtk_window_fullscreen")]
    fn fullscreen(&self);

    /// 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`][crate::Widget].
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen] to draw to
    /// ## `monitor`
    /// which monitor to go fullscreen on
    #[doc(alias = "gtk_window_fullscreen_on_monitor")]
    fn fullscreen_on_monitor(&self, screen: &gdk::Screen, monitor: i32);

    /// Gets the value set by [`set_accept_focus()`][Self::set_accept_focus()].
    ///
    /// # Returns
    ///
    /// [`true`] if window should receive the input focus
    #[doc(alias = "gtk_window_get_accept_focus")]
    #[doc(alias = "get_accept_focus")]
    fn accepts_focus(&self) -> bool;

    /// Gets the [`Application`][crate::Application] associated with the window (if any).
    ///
    /// # Returns
    ///
    /// a [`Application`][crate::Application], or [`None`]
    #[doc(alias = "gtk_window_get_application")]
    #[doc(alias = "get_application")]
    fn application(&self) -> Option<Application>;

    /// Fetches the attach widget for this window. See
    /// [`set_attached_to()`][Self::set_attached_to()].
    ///
    /// # Returns
    ///
    /// the widget where the window
    /// is attached, or [`None`] if the window is not attached to any widget.
    #[doc(alias = "gtk_window_get_attached_to")]
    #[doc(alias = "get_attached_to")]
    fn attached_to(&self) -> Option<Widget>;

    /// Returns whether the window has been set to have decorations
    /// such as a title bar via [`set_decorated()`][Self::set_decorated()].
    ///
    /// # Returns
    ///
    /// [`true`] if the window has been set to have decorations
    #[doc(alias = "gtk_window_get_decorated")]
    #[doc(alias = "get_decorated")]
    fn is_decorated(&self) -> bool;

    /// 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`]
    #[doc(alias = "gtk_window_get_default_size")]
    #[doc(alias = "get_default_size")]
    fn default_size(&self) -> (i32, i32);

    /// Returns the default widget for `self`. See
    /// [`set_default()`][Self::set_default()] for more details.
    ///
    /// # Returns
    ///
    /// the default widget, or [`None`]
    /// if there is none.
    #[doc(alias = "gtk_window_get_default_widget")]
    #[doc(alias = "get_default_widget")]
    fn default_widget(&self) -> Option<Widget>;

    /// Returns whether the window has been set to have a close button
    /// via [`set_deletable()`][Self::set_deletable()].
    ///
    /// # Returns
    ///
    /// [`true`] if the window has been set to have a close button
    #[doc(alias = "gtk_window_get_deletable")]
    #[doc(alias = "get_deletable")]
    fn is_deletable(&self) -> bool;

    /// Returns whether the window will be destroyed with its transient parent. See
    /// gtk_window_set_destroy_with_parent ().
    ///
    /// # Returns
    ///
    /// [`true`] if the window will be destroyed with its transient parent.
    #[doc(alias = "gtk_window_get_destroy_with_parent")]
    #[doc(alias = "get_destroy_with_parent")]
    fn must_destroy_with_parent(&self) -> bool;

    /// 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.
    #[doc(alias = "gtk_window_get_focus")]
    #[doc(alias = "get_focus")]
    fn focus(&self) -> Option<Widget>;

    /// Gets the value set by [`set_focus_on_map()`][Self::set_focus_on_map()].
    ///
    /// # Returns
    ///
    /// [`true`] if window should receive the input focus when
    /// mapped.
    #[doc(alias = "gtk_window_get_focus_on_map")]
    #[doc(alias = "get_focus_on_map")]
    fn gets_focus_on_map(&self) -> bool;

    /// Gets the value of the `property::Window::focus-visible` property.
    ///
    /// # Returns
    ///
    /// [`true`] if “focus rectangles” are supposed to be visible
    ///  in this window.
    #[doc(alias = "gtk_window_get_focus_visible")]
    #[doc(alias = "get_focus_visible")]
    fn gets_focus_visible(&self) -> bool;

    /// Gets the value set by [`set_gravity()`][Self::set_gravity()].
    ///
    /// # Returns
    ///
    /// window gravity
    #[doc(alias = "gtk_window_get_gravity")]
    #[doc(alias = "get_gravity")]
    fn gravity(&self) -> gdk::Gravity;

    /// 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`][crate::WindowGroup] for a window or the default group
    #[doc(alias = "gtk_window_get_group")]
    #[doc(alias = "get_group")]
    fn group(&self) -> Option<WindowGroup>;

    /// Returns whether the window has requested to have its titlebar hidden
    /// when maximized. See gtk_window_set_hide_titlebar_when_maximized ().
    ///
    /// # Returns
    ///
    /// [`true`] if the window has requested to have its titlebar
    ///  hidden when maximized
    #[doc(alias = "gtk_window_get_hide_titlebar_when_maximized")]
    #[doc(alias = "get_hide_titlebar_when_maximized")]
    fn hides_titlebar_when_maximized(&self) -> bool;

    /// Gets the value set by [`set_icon()`][Self::set_icon()] (or if you've
    /// called [`set_icon_list()`][Self::set_icon_list()], gets the first icon in
    /// the icon list).
    ///
    /// # Returns
    ///
    /// icon for window or [`None`] if none
    #[doc(alias = "gtk_window_get_icon")]
    #[doc(alias = "get_icon")]
    fn icon(&self) -> Option<gdk_pixbuf::Pixbuf>;

    /// Retrieves the list of icons set by [`set_icon_list()`][Self::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
    #[doc(alias = "gtk_window_get_icon_list")]
    #[doc(alias = "get_icon_list")]
    fn icon_list(&self) -> Vec<gdk_pixbuf::Pixbuf>;

    /// Returns the name of the themed icon for the window,
    /// see [`set_icon_name()`][Self::set_icon_name()].
    ///
    /// # Returns
    ///
    /// the icon name or [`None`] if the window has
    /// no themed icon
    #[doc(alias = "gtk_window_get_icon_name")]
    #[doc(alias = "get_icon_name")]
    fn icon_name(&self) -> Option<glib::GString>;

    /// Returns the mnemonic modifier for this window. See
    /// [`set_mnemonic_modifier()`][Self::set_mnemonic_modifier()].
    ///
    /// # Returns
    ///
    /// the modifier mask used to activate
    ///  mnemonics on this window.
    #[doc(alias = "gtk_window_get_mnemonic_modifier")]
    #[doc(alias = "get_mnemonic_modifier")]
    fn mnemonic_modifier(&self) -> gdk::ModifierType;

    /// Gets the value of the `property::Window::mnemonics-visible` property.
    ///
    /// # Returns
    ///
    /// [`true`] if mnemonics are supposed to be visible
    /// in this window.
    #[doc(alias = "gtk_window_get_mnemonics_visible")]
    #[doc(alias = "get_mnemonics_visible")]
    fn is_mnemonics_visible(&self) -> bool;

    /// Returns whether the window is modal. See [`set_modal()`][Self::set_modal()].
    ///
    /// # Returns
    ///
    /// [`true`] if the window is set to be modal and
    ///  establishes a grab when shown
    #[doc(alias = "gtk_window_get_modal")]
    #[doc(alias = "get_modal")]
    fn is_modal(&self) -> bool;

    /// This function returns the position you need to pass to
    /// [`move_()`][Self::move_()] to keep `self` in its current position.
    /// This means that the meaning of the returned value varies with
    /// window gravity. See [`move_()`][Self::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`][crate::gdk::Gravity::NorthWest]. This means that [`position()`][Self::position()]
    /// gets the position of the top-left corner of the window manager
    /// frame for the window. [`move_()`][Self::move_()] sets the position of this
    /// same top-left corner.
    ///
    /// If a window has gravity [`gdk::Gravity::Static`][crate::gdk::Gravity::Static] the window manager
    /// frame is not relevant, and thus [`position()`][Self::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`]
    #[doc(alias = "gtk_window_get_position")]
    #[doc(alias = "get_position")]
    fn position(&self) -> (i32, i32);

    /// Gets the value set by [`set_resizable()`][Self::set_resizable()].
    ///
    /// # Returns
    ///
    /// [`true`] if the user can resize the window
    #[doc(alias = "gtk_window_get_resizable")]
    #[doc(alias = "get_resizable")]
    fn is_resizable(&self) -> bool;

    /// Returns the role of the window. See [`set_role()`][Self::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.
    #[doc(alias = "gtk_window_get_role")]
    #[doc(alias = "get_role")]
    fn role(&self) -> Option<glib::GString>;

    /// 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()`][Self::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()`][Self::resize()]; additionally, since [`resize()`][Self::resize()] may be
    /// implemented as an asynchronous operation, GTK+ cannot guarantee in any
    /// way that this code:
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```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`][crate::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()`][Self::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 ⚠️**
    ///
    /// ```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()`][Self::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()`][Self::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()`][Self::set_position()].
    ///
    /// # Returns
    ///
    ///
    /// ## `width`
    /// return location for width, or [`None`]
    ///
    /// ## `height`
    /// return location for height, or [`None`]
    #[doc(alias = "gtk_window_get_size")]
    #[doc(alias = "get_size")]
    fn size(&self) -> (i32, i32);

    /// Gets the value set by [`set_skip_pager_hint()`][Self::set_skip_pager_hint()].
    ///
    /// # Returns
    ///
    /// [`true`] if window shouldn’t be in pager
    #[doc(alias = "gtk_window_get_skip_pager_hint")]
    #[doc(alias = "get_skip_pager_hint")]
    fn skips_pager_hint(&self) -> bool;

    /// Gets the value set by [`set_skip_taskbar_hint()`][Self::set_skip_taskbar_hint()]
    ///
    /// # Returns
    ///
    /// [`true`] if window shouldn’t be in taskbar
    #[doc(alias = "gtk_window_get_skip_taskbar_hint")]
    #[doc(alias = "get_skip_taskbar_hint")]
    fn skips_taskbar_hint(&self) -> bool;

    /// Retrieves the title of the window. See [`set_title()`][Self::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.
    #[doc(alias = "gtk_window_get_title")]
    #[doc(alias = "get_title")]
    fn title(&self) -> Option<glib::GString>;

    /// Returns the custom titlebar that has been set with
    /// [`set_titlebar()`][Self::set_titlebar()].
    ///
    /// # Returns
    ///
    /// the custom titlebar, or [`None`]
    #[doc(alias = "gtk_window_get_titlebar")]
    #[doc(alias = "get_titlebar")]
    fn titlebar(&self) -> Option<Widget>;

    /// Fetches the transient parent for this window. See
    /// [`set_transient_for()`][Self::set_transient_for()].
    ///
    /// # Returns
    ///
    /// the transient parent for this
    /// window, or [`None`] if no transient parent has been set.
    #[doc(alias = "gtk_window_get_transient_for")]
    #[doc(alias = "get_transient_for")]
    fn transient_for(&self) -> Option<Window>;

    /// Gets the type hint for this window. See [`set_type_hint()`][Self::set_type_hint()].
    ///
    /// # Returns
    ///
    /// the type hint for `self`.
    #[doc(alias = "gtk_window_get_type_hint")]
    #[doc(alias = "get_type_hint")]
    fn type_hint(&self) -> gdk::WindowTypeHint;

    /// Gets the value set by [`set_urgency_hint()`][Self::set_urgency_hint()]
    ///
    /// # Returns
    ///
    /// [`true`] if window is urgent
    #[doc(alias = "gtk_window_get_urgency_hint")]
    #[doc(alias = "get_urgency_hint")]
    fn is_urgency_hint(&self) -> bool;

    /// Gets the type of the window. See [`WindowType`][crate::WindowType].
    ///
    /// # Returns
    ///
    /// the type of the window
    #[doc(alias = "gtk_window_get_window_type")]
    #[doc(alias = "get_window_type")]
    fn window_type(&self) -> WindowType;

    /// Returns whether `self` has an explicit window group.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` has an explicit window group.
    ///
    /// Since 2.22
    #[doc(alias = "gtk_window_has_group")]
    fn has_group(&self) -> bool;

    /// Returns whether the input focus is within this GtkWindow.
    /// For real toplevel windows, this is identical to [`is_active()`][Self::is_active()],
    /// but for embedded windows, like [`Plug`][crate::Plug], the results will differ.
    ///
    /// # Returns
    ///
    /// [`true`] if the input focus is within this GtkWindow
    #[doc(alias = "gtk_window_has_toplevel_focus")]
    fn has_toplevel_focus(&self) -> bool;

    /// 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`][crate::Widget].
    #[doc(alias = "gtk_window_iconify")]
    fn iconify(&self);

    /// 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`][crate::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()`][Self::has_toplevel_focus()]
    ///
    /// # Returns
    ///
    /// [`true`] if the window part of the current active window.
    #[doc(alias = "gtk_window_is_active")]
    fn is_active(&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()`][Self::maximize()] or [`unmaximize()`][Self::unmaximize()].
    ///
    /// # Returns
    ///
    /// whether the window has a maximized state.
    #[doc(alias = "gtk_window_is_maximized")]
    fn is_maximized(&self) -> bool;

    /// 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`][crate::Widget], or by listening to notifications on the
    /// `property::Window::is-maximized` property.
    #[doc(alias = "gtk_window_maximize")]
    fn maximize(&self);

    /// Activates the targets associated with the mnemonic.
    /// ## `keyval`
    /// the mnemonic
    /// ## `modifier`
    /// the modifiers
    ///
    /// # Returns
    ///
    /// [`true`] if the activation is done.
    #[doc(alias = "gtk_window_mnemonic_activate")]
    fn mnemonic_activate(&self, keyval: u32, modifier: gdk::ModifierType) -> bool;

    #[doc(alias = "gtk_window_move")]
    #[doc(alias = "move")]
    fn move_(&self, x: i32, y: i32);

    /// Parses a standard X Window System geometry string - see the
    /// manual page for X (type “man X”) for details on this.
    /// [`parse_geometry()`][Self::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()`][Self::parse_geometry()] returns [`true`]
    /// and calls [`set_default_size()`][Self::set_default_size()] and/or [`move_()`][Self::move_()]
    /// to resize/move the window.
    ///
    /// If [`parse_geometry()`][Self::parse_geometry()] returns [`true`], it will also
    /// set the [`gdk::WindowHints::USER_POS`][crate::gdk::WindowHints::USER_POS] and/or [`gdk::WindowHints::USER_SIZE`][crate::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()`][Self::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()`][crate::prelude::WidgetExt::show_all()] on the contents and [`set_geometry_hints()`][Self::set_geometry_hints()]
    /// on the window.
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```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
    #[cfg_attr(feature = "v3_20", deprecated = "Since 3.20")]
    #[doc(alias = "gtk_window_parse_geometry")]
    fn parse_geometry(&self, geometry: &str) -> bool;

    /// 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.
    #[doc(alias = "gtk_window_present")]
    fn present(&self);

    /// 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()`][crate::prelude::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()`][Self::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
    #[doc(alias = "gtk_window_present_with_time")]
    fn present_with_time(&self, timestamp: u32);

    /// 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`
    /// a [`gdk::EventKey`][crate::gdk::EventKey]
    ///
    /// # Returns
    ///
    /// [`true`] if a widget in the focus chain handled the event.
    #[doc(alias = "gtk_window_propagate_key_event")]
    fn propagate_key_event(&self, event: &gdk::EventKey) -> bool;

    /// Reverses the effects of [`add_accel_group()`][Self::add_accel_group()].
    /// ## `accel_group`
    /// a [`AccelGroup`][crate::AccelGroup]
    #[doc(alias = "gtk_window_remove_accel_group")]
    fn remove_accel_group<P: IsA<AccelGroup>>(&self, accel_group: &P);

    /// Removes a mnemonic from this window.
    /// ## `keyval`
    /// the mnemonic
    /// ## `target`
    /// the widget that gets activated by the mnemonic
    #[doc(alias = "gtk_window_remove_mnemonic")]
    fn remove_mnemonic<P: IsA<Widget>>(&self, keyval: u32, target: &P);

    /// 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()`][crate::prelude::WidgetExt::set_size_request()] to set the window's
    /// request to a smaller value.
    ///
    /// If [`resize()`][Self::resize()] is called before showing a window for the
    /// first time, it overrides any default size set with
    /// [`set_default_size()`][Self::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()`][Self::resize()] is issued.
    ///
    /// If the GtkWindow has a titlebar widget (see [`set_titlebar()`][Self::set_titlebar()]), then
    /// typically, [`resize()`][Self::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()`][Self::resize()] and not
    /// a larger window.
    /// ## `width`
    /// width in pixels to resize the window to
    /// ## `height`
    /// height in pixels to resize the window to
    #[doc(alias = "gtk_window_resize")]
    fn resize(&self, width: i32, height: i32);

    /// Like [`resize()`][Self::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()`][Self::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
    #[cfg_attr(feature = "v3_20", deprecated = "Since 3.20")]
    #[doc(alias = "gtk_window_resize_to_geometry")]
    fn resize_to_geometry(&self, width: i32, height: i32);

    /// Windows may set a hint asking the desktop environment not to receive
    /// the input focus. This function sets this hint.
    /// ## `setting`
    /// [`true`] to let this window receive input focus
    #[doc(alias = "gtk_window_set_accept_focus")]
    fn set_accept_focus(&self, setting: bool);

    /// Sets or unsets the [`Application`][crate::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()`][crate::prelude::GtkApplicationExt::remove_window()] and/or
    /// [`GtkApplicationExt::add_window()`][crate::prelude::GtkApplicationExt::add_window()] on the old/new applications as relevant.
    /// ## `application`
    /// a [`Application`][crate::Application], or [`None`] to unset
    #[doc(alias = "gtk_window_set_application")]
    fn set_application<P: IsA<Application>>(&self, application: Option<&P>);

    /// 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`][crate::Menu] created by a [`ComboBox`][crate::ComboBox], a completion popup window
    /// created by [`Entry`][crate::Entry] or a typeahead search entry created by [`TreeView`][crate::TreeView].
    ///
    /// Note that this function should not be confused with
    /// [`set_transient_for()`][Self::set_transient_for()], which specifies a window manager relation
    /// between two toplevels instead.
    ///
    /// Passing [`None`] for `attach_widget` detaches the window.
    /// ## `attach_widget`
    /// a [`Widget`][crate::Widget], or [`None`]
    #[doc(alias = "gtk_window_set_attached_to")]
    fn set_attached_to<P: IsA<Widget>>(&self, attach_widget: Option<&P>);

    /// 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()`][crate::prelude::WidgetExt::show()].
    ///
    /// On Windows, this function always works, since there’s no window manager
    /// policy involved.
    /// ## `setting`
    /// [`true`] to decorate the window
    #[doc(alias = "gtk_window_set_decorated")]
    fn set_decorated(&self, setting: bool);

    /// 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`][crate::Window]. When setting (rather
    /// than unsetting) the default widget it’s generally easier to call
    /// [`WidgetExt::grab_default()`][crate::prelude::WidgetExt::grab_default()] on the widget. Before making a widget
    /// the default widget, you must call [`WidgetExt::set_can_default()`][crate::prelude::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
    #[doc(alias = "gtk_window_set_default")]
    fn set_default<P: IsA<Widget>>(&self, default_widget: Option<&P>);

    /// Like [`set_default_size()`][Self::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()`][Self::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
    #[cfg_attr(feature = "v3_20", deprecated = "Since 3.20")]
    #[doc(alias = "gtk_window_set_default_geometry")]
    fn set_default_geometry(&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()`][Self::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()`][crate::prelude::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()`][Self::set_geometry_hints()].
    ///
    /// For some uses, [`resize()`][Self::resize()] is a more appropriate function.
    /// [`resize()`][Self::resize()] changes the current size of the window, rather
    /// than the size to be used on initial display. [`resize()`][Self::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()`][Self::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
    #[doc(alias = "gtk_window_set_default_size")]
    fn set_default_size(&self, width: i32, height: i32);

    /// 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()`][crate::prelude::WidgetExt::show()].
    ///
    /// On Windows, this function always works, since there’s no window manager
    /// policy involved.
    /// ## `setting`
    /// [`true`] to decorate the window as deletable
    #[doc(alias = "gtk_window_set_deletable")]
    fn set_deletable(&self, setting: bool);

    /// If `setting` is [`true`], then destroying the transient parent of `self`
    /// will also destroy `self` itself. This is useful for dialogs that
    /// shouldn’t persist beyond the lifetime of the main window they're
    /// associated with, for example.
    /// ## `setting`
    /// whether to destroy `self` with its transient parent
    #[doc(alias = "gtk_window_set_destroy_with_parent")]
    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()`][crate::prelude::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.
    #[doc(alias = "gtk_window_set_focus")]
    fn set_focus<P: IsA<Widget>>(&self, focus: Option<&P>);

    /// Windows may set a hint asking the desktop environment not to receive
    /// the input focus when the window is mapped. This function sets this
    /// hint.
    /// ## `setting`
    /// [`true`] to let this window receive input focus on map
    #[doc(alias = "gtk_window_set_focus_on_map")]
    fn set_focus_on_map(&self, setting: bool);

    /// Sets the `property::Window::focus-visible` property.
    /// ## `setting`
    /// the new value
    #[doc(alias = "gtk_window_set_focus_visible")]
    fn set_focus_visible(&self, setting: bool);

    /// 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`][crate::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
    #[doc(alias = "gtk_window_set_geometry_hints")]
    fn set_geometry_hints<P: IsA<Widget>>(
        &self,
        geometry_widget: Option<&P>,
        geometry: Option<&gdk::Geometry>,
        geom_mask: gdk::WindowHints,
    );

    /// Window gravity defines the meaning of coordinates passed to
    /// [`move_()`][Self::move_()]. See [`move_()`][Self::move_()] and [`gdk::Gravity`][crate::gdk::Gravity] for
    /// more details.
    ///
    /// The default window gravity is [`gdk::Gravity::NorthWest`][crate::gdk::Gravity::NorthWest] which will
    /// typically “do what you mean.”
    /// ## `gravity`
    /// window gravity
    #[doc(alias = "gtk_window_set_gravity")]
    fn set_gravity(&self, gravity: gdk::Gravity);

    /// 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
    #[doc(alias = "gtk_window_set_has_user_ref_count")]
    fn set_has_user_ref_count(&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()`][Self::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
    #[doc(alias = "gtk_window_set_hide_titlebar_when_maximized")]
    fn set_hide_titlebar_when_maximized(&self, setting: bool);

    /// Sets up the icon representing a [`Window`][crate::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()`][Self::set_icon_list()]. Then the best size will be used.
    ///
    /// This function is equivalent to calling [`set_icon_list()`][Self::set_icon_list()]
    /// with a 1-element list.
    ///
    /// See also [`Window::set_default_icon_list()`][crate::Window::set_default_icon_list()] to set the icon
    /// for all windows in your application in one go.
    /// ## `icon`
    /// icon image, or [`None`]
    #[doc(alias = "gtk_window_set_icon")]
    fn set_icon(&self, icon: Option<&gdk_pixbuf::Pixbuf>);

    /// Sets the icon for `self`.
    /// Warns on failure if `err` is [`None`].
    ///
    /// This function is equivalent to calling [`set_icon()`][Self::set_icon()]
    /// with a pixbuf created by loading the image from `filename`.
    /// ## `filename`
    /// location of icon file
    ///
    /// # Returns
    ///
    /// [`true`] if setting the icon succeeded.
    #[doc(alias = "gtk_window_set_icon_from_file")]
    fn set_icon_from_file<P: AsRef<std::path::Path>>(&self, filename: P)
        -> Result<(), glib::Error>;

    /// Sets up the icon representing a [`Window`][crate::Window]. The 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.
    ///
    /// [`set_icon_list()`][Self::set_icon_list()] allows you to pass in the same icon in
    /// several hand-drawn sizes. The list should contain the natural sizes
    /// your icon is available in; 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.
    ///
    /// By passing several sizes, you may improve the final image quality
    /// of the icon, by reducing or eliminating automatic image scaling.
    ///
    /// Recommended sizes to provide: 16x16, 32x32, 48x48 at minimum, and
    /// larger images (64x64, 128x128) if you have them.
    ///
    /// See also [`Window::set_default_icon_list()`][crate::Window::set_default_icon_list()] to set the icon
    /// for all windows in your application in one go.
    ///
    /// Note that transient windows (those who have been set transient for another
    /// window using [`set_transient_for()`][Self::set_transient_for()]) will inherit their
    /// icon from their transient parent. So there’s no need to explicitly
    /// set the icon on transient windows.
    /// ## `list`
    /// list of [`gdk_pixbuf::Pixbuf`][crate::gdk_pixbuf::Pixbuf]
    #[doc(alias = "gtk_window_set_icon_list")]
    fn set_icon_list(&self, list: &[gdk_pixbuf::Pixbuf]);

    /// Sets the icon for the window from a named themed icon.
    /// See the docs for [`IconTheme`][crate::IconTheme] for more details.
    /// On some platforms, the window icon is not used at all.
    ///
    /// Note that this has nothing to do with the WM_ICON_NAME
    /// property which is mentioned in the ICCCM.
    /// ## `name`
    /// the name of the themed icon
    #[doc(alias = "gtk_window_set_icon_name")]
    fn set_icon_name(&self, name: Option<&str>);

    /// Asks to keep `self` above, so that it stays on top. Note that
    /// you shouldn’t assume the window is definitely above afterward,
    /// because other entities (e.g. the user or
    /// [window manager][gtk-X11-arch]) could not keep it above,
    /// and not all window managers support keeping windows above. But
    /// normally the window will end kept above. 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 kept above when it appears onscreen
    /// initially.
    ///
    /// You can track the above state via the “window-state-event” signal
    /// on [`Widget`][crate::Widget].
    ///
    /// Note that, according to the
    /// [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec),
    /// the above state is mainly meant for user preferences and should not
    /// be used by applications e.g. for drawing attention to their
    /// dialogs.
    /// ## `setting`
    /// whether to keep `self` above other windows
    #[doc(alias = "gtk_window_set_keep_above")]
    fn set_keep_above(&self, setting: bool);

    /// Asks to keep `self` below, so that it stays in bottom. Note that
    /// you shouldn’t assume the window is definitely below afterward,
    /// because other entities (e.g. the user or
    /// [window manager][gtk-X11-arch]) could not keep it below,
    /// and not all window managers support putting windows below. But
    /// normally the window will be kept below. 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 kept below when it appears onscreen
    /// initially.
    ///
    /// You can track the below state via the “window-state-event” signal
    /// on [`Widget`][crate::Widget].
    ///
    /// Note that, according to the
    /// [Extended Window Manager Hints Specification](http://www.freedesktop.org/Standards/wm-spec),
    /// the above state is mainly meant for user preferences and should not
    /// be used by applications e.g. for drawing attention to their
    /// dialogs.
    /// ## `setting`
    /// whether to keep `self` below other windows
    #[doc(alias = "gtk_window_set_keep_below")]
    fn set_keep_below(&self, setting: bool);

    /// Sets the mnemonic modifier for this window.
    /// ## `modifier`
    /// the modifier mask used to activate
    ///  mnemonics on this window.
    #[doc(alias = "gtk_window_set_mnemonic_modifier")]
    fn set_mnemonic_modifier(&self, modifier: gdk::ModifierType);

    /// Sets the `property::Window::mnemonics-visible` property.
    /// ## `setting`
    /// the new value
    #[doc(alias = "gtk_window_set_mnemonics_visible")]
    fn set_mnemonics_visible(&self, setting: bool);

    /// Sets a window modal or non-modal. Modal windows prevent interaction
    /// with other windows in the same application. To keep modal dialogs
    /// on top of main application windows, use
    /// [`set_transient_for()`][Self::set_transient_for()] to make the dialog transient for the
    /// parent; most [window managers][gtk-X11-arch]
    /// will then disallow lowering the dialog below the parent.
    /// ## `modal`
    /// whether the window is modal
    #[doc(alias = "gtk_window_set_modal")]
    fn set_modal(&self, modal: bool);

    /// Sets a position constraint for this window. If the old or new
    /// constraint is [`WindowPosition::CenterAlways`][crate::WindowPosition::CenterAlways], this will also cause
    /// the window to be repositioned to satisfy the new constraint.
    /// ## `position`
    /// a position constraint.
    #[doc(alias = "gtk_window_set_position")]
    fn set_position(&self, position: WindowPosition);

    /// Sets whether the user can resize a window. Windows are user resizable
    /// by default.
    /// ## `resizable`
    /// [`true`] if the user can resize this window
    #[doc(alias = "gtk_window_set_resizable")]
    fn set_resizable(&self, resizable: bool);

    /// This function is only useful on X11, not with other GTK+ targets.
    ///
    /// In combination with the window title, the window role allows a
    /// [window manager][gtk-X11-arch] to identify "the
    /// same" window when an application is restarted. So for example you
    /// might set the “toolbox” role on your app’s toolbox window, so that
    /// when the user restarts their session, the window manager can put
    /// the toolbox back in the same place.
    ///
    /// If a window already has a unique title, you don’t need to set the
    /// role, since the WM can use the title to identify the window when
    /// restoring the session.
    /// ## `role`
    /// unique identifier for the window to be used when restoring a session
    #[doc(alias = "gtk_window_set_role")]
    fn set_role(&self, role: &str);

    /// Sets the [`gdk::Screen`][crate::gdk::Screen] where the `self` is displayed; if
    /// the window is already mapped, it will be unmapped, and
    /// then remapped on the new screen.
    /// ## `screen`
    /// a [`gdk::Screen`][crate::gdk::Screen].
    #[doc(alias = "gtk_window_set_screen")]
    fn set_screen(&self, screen: &gdk::Screen);

    /// Windows may set a hint asking the desktop environment not to display
    /// the window in the pager. This function sets this hint.
    /// (A "pager" is any desktop navigation tool such as a workspace
    /// switcher that displays a thumbnail representation of the windows
    /// on the screen.)
    /// ## `setting`
    /// [`true`] to keep this window from appearing in the pager
    #[doc(alias = "gtk_window_set_skip_pager_hint")]
    fn set_skip_pager_hint(&self, setting: bool);

    /// Windows may set a hint asking the desktop environment not to display
    /// the window in the task bar. This function sets this hint.
    /// ## `setting`
    /// [`true`] to keep this window from appearing in the task bar
    #[doc(alias = "gtk_window_set_skip_taskbar_hint")]
    fn set_skip_taskbar_hint(&self, setting: bool);

    /// Startup notification identifiers are used by desktop environment to
    /// track application startup, to provide user feedback and other
    /// features. This function changes the corresponding property on the
    /// underlying GdkWindow. Normally, startup identifier is managed
    /// automatically and you should only use this function in special cases
    /// like transferring focus from other processes. You should use this
    /// function before calling [`present()`][Self::present()] or any equivalent
    /// function generating a window map event.
    ///
    /// This function is only useful on X11, not with other GTK+ targets.
    /// ## `startup_id`
    /// a string with startup-notification identifier
    #[doc(alias = "gtk_window_set_startup_id")]
    fn set_startup_id(&self, startup_id: &str);

    /// Sets the title of the [`Window`][crate::Window]. The title of a window will be
    /// displayed in its title bar; on the X Window System, the title bar
    /// is rendered by the [window manager][gtk-X11-arch],
    /// so exactly how the title appears to users may vary
    /// according to a user’s exact configuration. The title should help a
    /// user distinguish this window from other windows they may have
    /// open. A good title might include the application name and current
    /// document filename, for example.
    /// ## `title`
    /// title of the window
    #[doc(alias = "gtk_window_set_title")]
    fn set_title(&self, title: &str);

    /// Sets a custom titlebar for `self`.
    ///
    /// A typical widget used here is [`HeaderBar`][crate::HeaderBar], as it provides various features
    /// expected of a titlebar while allowing the addition of child widgets to it.
    ///
    /// If you set a custom titlebar, GTK+ will do its best to convince
    /// the window manager not to put its own titlebar on the window.
    /// Depending on the system, this function may not work for a window
    /// that is already visible, so you set the titlebar before calling
    /// [`WidgetExt::show()`][crate::prelude::WidgetExt::show()].
    /// ## `titlebar`
    /// the widget to use as titlebar
    #[doc(alias = "gtk_window_set_titlebar")]
    fn set_titlebar<P: IsA<Widget>>(&self, titlebar: Option<&P>);

    /// Dialog windows should be set transient for the main application
    /// window they were spawned from. This allows
    /// [window managers][gtk-X11-arch] to e.g. keep the
    /// dialog on top of the main window, or center the dialog over the
    /// main window. `gtk_dialog_new_with_buttons()` and other convenience
    /// functions in GTK+ will sometimes call
    /// [`set_transient_for()`][Self::set_transient_for()] on your behalf.
    ///
    /// Passing [`None`] for `parent` unsets the current transient window.
    ///
    /// On Wayland, this function can also be used to attach a new
    /// [`WindowType::Popup`][crate::WindowType::Popup] to a [`WindowType::Toplevel`][crate::WindowType::Toplevel] parent already mapped
    /// on screen so that the [`WindowType::Popup`][crate::WindowType::Popup] will be created as a
    /// subsurface-based window `GDK_WINDOW_SUBSURFACE` which can be
    /// positioned at will relatively to the [`WindowType::Toplevel`][crate::WindowType::Toplevel] surface.
    ///
    /// On Windows, this function puts the child window on top of the parent,
    /// much as the window manager would have done on X.
    /// ## `parent`
    /// parent window, or [`None`]
    #[doc(alias = "gtk_window_set_transient_for")]
    fn set_transient_for<P: IsA<Window>>(&self, parent: Option<&P>);

    /// By setting the type hint for the window, you allow the window
    /// manager to decorate and handle the window in a way which is
    /// suitable to the function of the window in your application.
    ///
    /// This function should be called before the window becomes visible.
    ///
    /// `gtk_dialog_new_with_buttons()` and other convenience functions in GTK+
    /// will sometimes call [`set_type_hint()`][Self::set_type_hint()] on your behalf.
    /// ## `hint`
    /// the window type
    #[doc(alias = "gtk_window_set_type_hint")]
    fn set_type_hint(&self, hint: gdk::WindowTypeHint);

    /// Windows may set a hint asking the desktop environment to draw
    /// the users attention to the window. This function sets this hint.
    /// ## `setting`
    /// [`true`] to mark this window as urgent
    #[doc(alias = "gtk_window_set_urgency_hint")]
    fn set_urgency_hint(&self, setting: bool);

    /// Don’t use this function. It sets the X Window System “class” and
    /// “name” hints for a window. According to the ICCCM, you should
    /// always set these to the same value for all windows in an
    /// application, and GTK+ sets them to that value by default, so calling
    /// this function is sort of pointless. However, you may want to call
    /// [`set_role()`][Self::set_role()] on each window in your application, for the
    /// benefit of the session manager. Setting the role allows the window
    /// manager to restore window positions when loading a saved session.
    ///
    /// # Deprecated since 3.22
    ///
    /// ## `wmclass_name`
    /// window name hint
    /// ## `wmclass_class`
    /// window class hint
    #[cfg_attr(feature = "v3_22", deprecated = "Since 3.22")]
    #[doc(alias = "gtk_window_set_wmclass")]
    fn set_wmclass(&self, wmclass_name: &str, wmclass_class: &str);

    /// Asks to stick `self`, which means that it will appear on all user
    /// desktops. Note that you shouldn’t assume the window is definitely
    /// stuck afterward, because other entities (e.g. the user or
    /// [window manager][gtk-X11-arch] could unstick it
    /// again, and some window managers do not support sticking
    /// windows. But normally the window will end up stuck. Just don't
    /// write code that crashes if not.
    ///
    /// It’s permitted to call this function before showing a window.
    ///
    /// You can track stickiness via the “window-state-event” signal
    /// on [`Widget`][crate::Widget].
    #[doc(alias = "gtk_window_stick")]
    fn stick(&self);

    /// Asks to toggle off the fullscreen state for `self`. Note that you
    /// shouldn’t assume the window is definitely not full screen
    /// afterward, because other entities (e.g. the user or
    /// [window manager][gtk-X11-arch]) could fullscreen it
    /// again, and not all window managers honor requests to unfullscreen
    /// windows. But normally the window will end up restored to its normal
    /// state. Just don’t write code that crashes if not.
    ///
    /// You can track the fullscreen state via the “window-state-event” signal
    /// on [`Widget`][crate::Widget].
    #[doc(alias = "gtk_window_unfullscreen")]
    fn unfullscreen(&self);

    /// Asks to unmaximize `self`. Note that you shouldn’t assume the
    /// window is definitely unmaximized afterward, because other entities
    /// (e.g. the user or [window manager][gtk-X11-arch])
    /// could maximize it again, and not all window
    /// managers honor requests to unmaximize. But normally the window will
    /// end up unmaximized. Just don’t write code that crashes if not.
    ///
    /// You can track maximization via the “window-state-event” signal
    /// on [`Widget`][crate::Widget].
    #[doc(alias = "gtk_window_unmaximize")]
    fn unmaximize(&self);

    /// Asks to unstick `self`, which means that it will appear on only
    /// one of the user’s desktops. Note that you shouldn’t assume the
    /// window is definitely unstuck afterward, because other entities
    /// (e.g. the user or [window manager][gtk-X11-arch]) could
    /// stick it again. But normally the window will
    /// end up stuck. Just don’t write code that crashes if not.
    ///
    /// You can track stickiness via the “window-state-event” signal
    /// on [`Widget`][crate::Widget].
    #[doc(alias = "gtk_window_unstick")]
    fn unstick(&self);

    #[doc(alias = "default-height")]
    fn default_height(&self) -> i32;

    #[doc(alias = "default-height")]
    fn set_default_height(&self, default_height: i32);

    #[doc(alias = "default-width")]
    fn default_width(&self) -> i32;

    #[doc(alias = "default-width")]
    fn set_default_width(&self, default_width: i32);

    #[doc(alias = "type")]
    fn type_(&self) -> WindowType;

    #[doc(alias = "window-position")]
    fn window_position(&self) -> WindowPosition;

    #[doc(alias = "window-position")]
    fn set_window_position(&self, window_position: WindowPosition);

    /// The ::activate-default signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user activates the default widget
    /// of `window`.
    #[doc(alias = "activate-default")]
    fn connect_activate_default<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    fn emit_activate_default(&self);

    /// The ::activate-focus signal is a
    /// [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user activates the currently
    /// focused widget of `window`.
    #[doc(alias = "activate-focus")]
    fn connect_activate_focus<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    fn emit_activate_focus(&self);

    /// The ::enable-debugging signal is a [keybinding signal][GtkBindingSignal]
    /// which gets emitted when the user enables or disables interactive
    /// debugging. When `toggle` is [`true`], interactive debugging is toggled
    /// on or off, when it is [`false`], the debugger will be pointed at the
    /// widget under the pointer.
    ///
    /// The default bindings for this signal are Ctrl-Shift-I
    /// and Ctrl-Shift-D.
    /// ## `toggle`
    /// toggle the debugger
    ///
    /// # Returns
    ///
    /// [`true`] if the key binding was handled
    #[doc(alias = "enable-debugging")]
    fn connect_enable_debugging<F: Fn(&Self, bool) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    fn emit_enable_debugging(&self, toggle: bool) -> bool;

    /// The ::keys-changed signal gets emitted when the set of accelerators
    /// or mnemonics that are associated with `window` changes.
    #[doc(alias = "keys-changed")]
    fn connect_keys_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    /// This signal is emitted whenever the currently focused widget in
    /// this window changes.
    /// ## `widget`
    /// the newly focused widget (or [`None`] for no focus)
    #[doc(alias = "set-focus")]
    fn connect_set_focus<F: Fn(&Self, Option<&Widget>) + 'static>(&self, f: F) -> SignalHandlerId;

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

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

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

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

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

    #[doc(alias = "default-width")]
    fn connect_default_width_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 = "destroy-with-parent")]
    fn connect_destroy_with_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

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

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

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

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

    #[doc(alias = "hide-titlebar-when-maximized")]
    fn connect_hide_titlebar_when_maximized_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

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

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

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

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

    #[doc(alias = "mnemonics-visible")]
    fn connect_mnemonics_visible_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 = "resizable")]
    fn connect_resizable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

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

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

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

    #[doc(alias = "skip-taskbar-hint")]
    fn connect_skip_taskbar_hint_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 = "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;

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

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

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

impl<O: IsA<Window>> GtkWindowExt for O {
    fn activate_default(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_window_activate_default(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

    fn activate_key(&self, event: &gdk::EventKey) -> bool {
        unsafe {
            from_glib(ffi::gtk_window_activate_key(
                self.as_ref().to_glib_none().0,
                mut_override(event.to_glib_none().0),
            ))
        }
    }

    fn add_accel_group<P: IsA<AccelGroup>>(&self, accel_group: &P) {
        unsafe {
            ffi::gtk_window_add_accel_group(
                self.as_ref().to_glib_none().0,
                accel_group.as_ref().to_glib_none().0,
            );
        }
    }

    fn add_mnemonic<P: IsA<Widget>>(&self, keyval: u32, target: &P) {
        unsafe {
            ffi::gtk_window_add_mnemonic(
                self.as_ref().to_glib_none().0,
                keyval,
                target.as_ref().to_glib_none().0,
            );
        }
    }

    fn begin_move_drag(&self, button: i32, root_x: i32, root_y: i32, timestamp: u32) {
        unsafe {
            ffi::gtk_window_begin_move_drag(
                self.as_ref().to_glib_none().0,
                button,
                root_x,
                root_y,
                timestamp,
            );
        }
    }

    fn begin_resize_drag(
        &self,
        edge: gdk::WindowEdge,
        button: i32,
        root_x: i32,
        root_y: i32,
        timestamp: u32,
    ) {
        unsafe {
            ffi::gtk_window_begin_resize_drag(
                self.as_ref().to_glib_none().0,
                edge.into_glib(),
                button,
                root_x,
                root_y,
                timestamp,
            );
        }
    }

    fn close(&self) {
        unsafe {
            ffi::gtk_window_close(self.as_ref().to_glib_none().0);
        }
    }

    fn deiconify(&self) {
        unsafe {
            ffi::gtk_window_deiconify(self.as_ref().to_glib_none().0);
        }
    }

    fn fullscreen(&self) {
        unsafe {
            ffi::gtk_window_fullscreen(self.as_ref().to_glib_none().0);
        }
    }

    fn fullscreen_on_monitor(&self, screen: &gdk::Screen, monitor: i32) {
        unsafe {
            ffi::gtk_window_fullscreen_on_monitor(
                self.as_ref().to_glib_none().0,
                screen.to_glib_none().0,
                monitor,
            );
        }
    }

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

    fn application(&self) -> Option<Application> {
        unsafe {
            from_glib_none(ffi::gtk_window_get_application(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn attached_to(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_window_get_attached_to(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

    fn default_size(&self) -> (i32, i32) {
        unsafe {
            let mut width = mem::MaybeUninit::uninit();
            let mut height = mem::MaybeUninit::uninit();
            ffi::gtk_window_get_default_size(
                self.as_ref().to_glib_none().0,
                width.as_mut_ptr(),
                height.as_mut_ptr(),
            );
            let width = width.assume_init();
            let height = height.assume_init();
            (width, height)
        }
    }

    fn default_widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_window_get_default_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

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

    fn focus(&self) -> Option<Widget> {
        unsafe { from_glib_none(ffi::gtk_window_get_focus(self.as_ref().to_glib_none().0)) }
    }

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

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

    fn gravity(&self) -> gdk::Gravity {
        unsafe { from_glib(ffi::gtk_window_get_gravity(self.as_ref().to_glib_none().0)) }
    }

    fn group(&self) -> Option<WindowGroup> {
        unsafe { from_glib_none(ffi::gtk_window_get_group(self.as_ref().to_glib_none().0)) }
    }

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

    fn icon(&self) -> Option<gdk_pixbuf::Pixbuf> {
        unsafe { from_glib_none(ffi::gtk_window_get_icon(self.as_ref().to_glib_none().0)) }
    }

    fn icon_list(&self) -> Vec<gdk_pixbuf::Pixbuf> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_window_get_icon_list(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn icon_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_window_get_icon_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn mnemonic_modifier(&self) -> gdk::ModifierType {
        unsafe {
            from_glib(ffi::gtk_window_get_mnemonic_modifier(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

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

    fn position(&self) -> (i32, i32) {
        unsafe {
            let mut root_x = mem::MaybeUninit::uninit();
            let mut root_y = mem::MaybeUninit::uninit();
            ffi::gtk_window_get_position(
                self.as_ref().to_glib_none().0,
                root_x.as_mut_ptr(),
                root_y.as_mut_ptr(),
            );
            let root_x = root_x.assume_init();
            let root_y = root_y.assume_init();
            (root_x, root_y)
        }
    }

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

    fn role(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::gtk_window_get_role(self.as_ref().to_glib_none().0)) }
    }

    fn size(&self) -> (i32, i32) {
        unsafe {
            let mut width = mem::MaybeUninit::uninit();
            let mut height = mem::MaybeUninit::uninit();
            ffi::gtk_window_get_size(
                self.as_ref().to_glib_none().0,
                width.as_mut_ptr(),
                height.as_mut_ptr(),
            );
            let width = width.assume_init();
            let height = height.assume_init();
            (width, height)
        }
    }

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

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

    fn title(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::gtk_window_get_title(self.as_ref().to_glib_none().0)) }
    }

    fn titlebar(&self) -> Option<Widget> {
        unsafe { from_glib_none(ffi::gtk_window_get_titlebar(self.as_ref().to_glib_none().0)) }
    }

    fn transient_for(&self) -> Option<Window> {
        unsafe {
            from_glib_none(ffi::gtk_window_get_transient_for(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn type_hint(&self) -> gdk::WindowTypeHint {
        unsafe {
            from_glib(ffi::gtk_window_get_type_hint(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

    fn window_type(&self) -> WindowType {
        unsafe {
            from_glib(ffi::gtk_window_get_window_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

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

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

    fn iconify(&self) {
        unsafe {
            ffi::gtk_window_iconify(self.as_ref().to_glib_none().0);
        }
    }

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

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

    fn maximize(&self) {
        unsafe {
            ffi::gtk_window_maximize(self.as_ref().to_glib_none().0);
        }
    }

    fn mnemonic_activate(&self, keyval: u32, modifier: gdk::ModifierType) -> bool {
        unsafe {
            from_glib(ffi::gtk_window_mnemonic_activate(
                self.as_ref().to_glib_none().0,
                keyval,
                modifier.into_glib(),
            ))
        }
    }

    fn move_(&self, x: i32, y: i32) {
        unsafe {
            ffi::gtk_window_move(self.as_ref().to_glib_none().0, x, y);
        }
    }

    fn parse_geometry(&self, geometry: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_window_parse_geometry(
                self.as_ref().to_glib_none().0,
                geometry.to_glib_none().0,
            ))
        }
    }

    fn present(&self) {
        unsafe {
            ffi::gtk_window_present(self.as_ref().to_glib_none().0);
        }
    }

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

    fn propagate_key_event(&self, event: &gdk::EventKey) -> bool {
        unsafe {
            from_glib(ffi::gtk_window_propagate_key_event(
                self.as_ref().to_glib_none().0,
                mut_override(event.to_glib_none().0),
            ))
        }
    }

    fn remove_accel_group<P: IsA<AccelGroup>>(&self, accel_group: &P) {
        unsafe {
            ffi::gtk_window_remove_accel_group(
                self.as_ref().to_glib_none().0,
                accel_group.as_ref().to_glib_none().0,
            );
        }
    }

    fn remove_mnemonic<P: IsA<Widget>>(&self, keyval: u32, target: &P) {
        unsafe {
            ffi::gtk_window_remove_mnemonic(
                self.as_ref().to_glib_none().0,
                keyval,
                target.as_ref().to_glib_none().0,
            );
        }
    }

    fn resize(&self, width: i32, height: i32) {
        unsafe {
            ffi::gtk_window_resize(self.as_ref().to_glib_none().0, width, height);
        }
    }

    fn resize_to_geometry(&self, width: i32, height: i32) {
        unsafe {
            ffi::gtk_window_resize_to_geometry(self.as_ref().to_glib_none().0, width, height);
        }
    }

    fn set_accept_focus(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_accept_focus(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    fn set_application<P: IsA<Application>>(&self, application: Option<&P>) {
        unsafe {
            ffi::gtk_window_set_application(
                self.as_ref().to_glib_none().0,
                application.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn set_attached_to<P: IsA<Widget>>(&self, attach_widget: Option<&P>) {
        unsafe {
            ffi::gtk_window_set_attached_to(
                self.as_ref().to_glib_none().0,
                attach_widget.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

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

    fn set_default<P: IsA<Widget>>(&self, default_widget: Option<&P>) {
        unsafe {
            ffi::gtk_window_set_default(
                self.as_ref().to_glib_none().0,
                default_widget.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn set_default_geometry(&self, width: i32, height: i32) {
        unsafe {
            ffi::gtk_window_set_default_geometry(self.as_ref().to_glib_none().0, width, height);
        }
    }

    fn set_default_size(&self, width: i32, height: i32) {
        unsafe {
            ffi::gtk_window_set_default_size(self.as_ref().to_glib_none().0, width, height);
        }
    }

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

    fn set_destroy_with_parent(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_destroy_with_parent(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    fn set_focus<P: IsA<Widget>>(&self, focus: Option<&P>) {
        unsafe {
            ffi::gtk_window_set_focus(
                self.as_ref().to_glib_none().0,
                focus.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn set_focus_on_map(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_focus_on_map(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    fn set_focus_visible(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_focus_visible(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    fn set_geometry_hints<P: IsA<Widget>>(
        &self,
        geometry_widget: Option<&P>,
        geometry: Option<&gdk::Geometry>,
        geom_mask: gdk::WindowHints,
    ) {
        unsafe {
            ffi::gtk_window_set_geometry_hints(
                self.as_ref().to_glib_none().0,
                geometry_widget.map(|p| p.as_ref()).to_glib_none().0,
                mut_override(geometry.to_glib_none().0),
                geom_mask.into_glib(),
            );
        }
    }

    fn set_gravity(&self, gravity: gdk::Gravity) {
        unsafe {
            ffi::gtk_window_set_gravity(self.as_ref().to_glib_none().0, gravity.into_glib());
        }
    }

    fn set_has_user_ref_count(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_has_user_ref_count(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    fn set_hide_titlebar_when_maximized(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_hide_titlebar_when_maximized(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    fn set_icon(&self, icon: Option<&gdk_pixbuf::Pixbuf>) {
        unsafe {
            ffi::gtk_window_set_icon(self.as_ref().to_glib_none().0, icon.to_glib_none().0);
        }
    }

    fn set_icon_from_file<P: AsRef<std::path::Path>>(
        &self,
        filename: P,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_window_set_icon_from_file(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_icon_list(&self, list: &[gdk_pixbuf::Pixbuf]) {
        unsafe {
            ffi::gtk_window_set_icon_list(self.as_ref().to_glib_none().0, list.to_glib_none().0);
        }
    }

    fn set_icon_name(&self, name: Option<&str>) {
        unsafe {
            ffi::gtk_window_set_icon_name(self.as_ref().to_glib_none().0, name.to_glib_none().0);
        }
    }

    fn set_keep_above(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_keep_above(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    fn set_keep_below(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_keep_below(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    fn set_mnemonic_modifier(&self, modifier: gdk::ModifierType) {
        unsafe {
            ffi::gtk_window_set_mnemonic_modifier(
                self.as_ref().to_glib_none().0,
                modifier.into_glib(),
            );
        }
    }

    fn set_mnemonics_visible(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_mnemonics_visible(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

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

    fn set_position(&self, position: WindowPosition) {
        unsafe {
            ffi::gtk_window_set_position(self.as_ref().to_glib_none().0, position.into_glib());
        }
    }

    fn set_resizable(&self, resizable: bool) {
        unsafe {
            ffi::gtk_window_set_resizable(self.as_ref().to_glib_none().0, resizable.into_glib());
        }
    }

    fn set_role(&self, role: &str) {
        unsafe {
            ffi::gtk_window_set_role(self.as_ref().to_glib_none().0, role.to_glib_none().0);
        }
    }

    fn set_screen(&self, screen: &gdk::Screen) {
        unsafe {
            ffi::gtk_window_set_screen(self.as_ref().to_glib_none().0, screen.to_glib_none().0);
        }
    }

    fn set_skip_pager_hint(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_skip_pager_hint(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    fn set_skip_taskbar_hint(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_skip_taskbar_hint(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    fn set_startup_id(&self, startup_id: &str) {
        unsafe {
            ffi::gtk_window_set_startup_id(
                self.as_ref().to_glib_none().0,
                startup_id.to_glib_none().0,
            );
        }
    }

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

    fn set_titlebar<P: IsA<Widget>>(&self, titlebar: Option<&P>) {
        unsafe {
            ffi::gtk_window_set_titlebar(
                self.as_ref().to_glib_none().0,
                titlebar.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn set_transient_for<P: IsA<Window>>(&self, parent: Option<&P>) {
        unsafe {
            ffi::gtk_window_set_transient_for(
                self.as_ref().to_glib_none().0,
                parent.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    fn set_type_hint(&self, hint: gdk::WindowTypeHint) {
        unsafe {
            ffi::gtk_window_set_type_hint(self.as_ref().to_glib_none().0, hint.into_glib());
        }
    }

    fn set_urgency_hint(&self, setting: bool) {
        unsafe {
            ffi::gtk_window_set_urgency_hint(self.as_ref().to_glib_none().0, setting.into_glib());
        }
    }

    fn set_wmclass(&self, wmclass_name: &str, wmclass_class: &str) {
        unsafe {
            ffi::gtk_window_set_wmclass(
                self.as_ref().to_glib_none().0,
                wmclass_name.to_glib_none().0,
                wmclass_class.to_glib_none().0,
            );
        }
    }

    fn stick(&self) {
        unsafe {
            ffi::gtk_window_stick(self.as_ref().to_glib_none().0);
        }
    }

    fn unfullscreen(&self) {
        unsafe {
            ffi::gtk_window_unfullscreen(self.as_ref().to_glib_none().0);
        }
    }

    fn unmaximize(&self) {
        unsafe {
            ffi::gtk_window_unmaximize(self.as_ref().to_glib_none().0);
        }
    }

    fn unstick(&self) {
        unsafe {
            ffi::gtk_window_unstick(self.as_ref().to_glib_none().0);
        }
    }

    fn default_height(&self) -> i32 {
        unsafe {
            let mut value = glib::Value::from_type(<i32 as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"default-height\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `default-height` getter")
        }
    }

    fn set_default_height(&self, default_height: i32) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"default-height\0".as_ptr() as *const _,
                default_height.to_value().to_glib_none().0,
            );
        }
    }

    fn default_width(&self) -> i32 {
        unsafe {
            let mut value = glib::Value::from_type(<i32 as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"default-width\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `default-width` getter")
        }
    }

    fn set_default_width(&self, default_width: i32) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"default-width\0".as_ptr() as *const _,
                default_width.to_value().to_glib_none().0,
            );
        }
    }

    fn type_(&self) -> WindowType {
        unsafe {
            let mut value = glib::Value::from_type(<WindowType as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"type\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `type` getter")
        }
    }

    fn window_position(&self) -> WindowPosition {
        unsafe {
            let mut value = glib::Value::from_type(<WindowPosition as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"window-position\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `window-position` getter")
        }
    }

    fn set_window_position(&self, window_position: WindowPosition) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.to_glib_none().0 as *mut glib::gobject_ffi::GObject,
                b"window-position\0".as_ptr() as *const _,
                window_position.to_value().to_glib_none().0,
            );
        }
    }

    fn connect_activate_default<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn activate_default_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"activate-default\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    activate_default_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_activate_default(&self) {
        let _ = unsafe {
            glib::Object::from_glib_borrow(self.as_ptr() as *mut glib::gobject_ffi::GObject)
                .emit_by_name("activate-default", &[])
                .unwrap()
        };
    }

    fn connect_activate_focus<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn activate_focus_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"activate-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    activate_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_activate_focus(&self) {
        let _ = unsafe {
            glib::Object::from_glib_borrow(self.as_ptr() as *mut glib::gobject_ffi::GObject)
                .emit_by_name("activate-focus", &[])
                .unwrap()
        };
    }

    fn connect_enable_debugging<F: Fn(&Self, bool) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn enable_debugging_trampoline<
            P: IsA<Window>,
            F: Fn(&P, bool) -> bool + 'static,
        >(
            this: *mut ffi::GtkWindow,
            toggle: glib::ffi::gboolean,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                Window::from_glib_borrow(this).unsafe_cast_ref(),
                from_glib(toggle),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"enable-debugging\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    enable_debugging_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn emit_enable_debugging(&self, toggle: bool) -> bool {
        let res = unsafe {
            glib::Object::from_glib_borrow(self.as_ptr() as *mut glib::gobject_ffi::GObject)
                .emit_by_name("enable-debugging", &[&toggle])
                .unwrap()
        };
        res.unwrap()
            .get()
            .expect("Return Value for `emit_enable_debugging`")
    }

    fn connect_keys_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn keys_changed_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"keys-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    keys_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_set_focus<F: Fn(&Self, Option<&Widget>) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn set_focus_trampoline<
            P: IsA<Window>,
            F: Fn(&P, Option<&Widget>) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            widget: *mut ffi::GtkWidget,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Window::from_glib_borrow(this).unsafe_cast_ref(),
                Option::<Widget>::from_glib_borrow(widget).as_ref().as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"set-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    set_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_accept_focus_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accept_focus_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accept-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accept_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_application_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_application_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::application\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_application_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_attached_to_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_attached_to_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::attached-to\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_attached_to_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_decorated_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_decorated_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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_default_height_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_height_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::default-height\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_default_height_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_default_width_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_default_width_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::default-width\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_default_width_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<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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_destroy_with_parent_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_destroy_with_parent_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::destroy-with-parent\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_destroy_with_parent_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_focus_on_map_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_focus_on_map_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::focus-on-map\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_focus_on_map_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_focus_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_focus_visible_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::focus-visible\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_focus_visible_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_gravity_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_gravity_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::gravity\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_gravity_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_has_toplevel_focus_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_has_toplevel_focus_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::has-toplevel-focus\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_has_toplevel_focus_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_hide_titlebar_when_maximized_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_hide_titlebar_when_maximized_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::hide-titlebar-when-maximized\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_hide_titlebar_when_maximized_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_icon_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_icon_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_icon_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_icon_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_icon_name_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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-name\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_icon_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_is_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_active_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::is-active\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_is_active_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_is_maximized_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_maximized_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::is-maximized\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_is_maximized_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_mnemonics_visible_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_mnemonics_visible_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::mnemonics-visible\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_mnemonics_visible_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<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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_resizable_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_resizable_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::resizable\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_resizable_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_role_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_role_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::role\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_role_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_screen_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_screen_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::screen\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_screen_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_skip_pager_hint_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_skip_pager_hint_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::skip-pager-hint\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_skip_pager_hint_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_skip_taskbar_hint_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_skip_taskbar_hint_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::skip-taskbar-hint\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_skip_taskbar_hint_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<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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_title_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_title_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::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),
            )
        }
    }

    fn connect_type_hint_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_type_hint_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::type-hint\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_type_hint_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_urgency_hint_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_urgency_hint_trampoline<P: IsA<Window>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::urgency-hint\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_urgency_hint_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_window_position_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_window_position_trampoline<
            P: IsA<Window>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkWindow,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Window::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::window-position\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_window_position_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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