gtk/auto/

application.rs

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

use crate::{ApplicationInhibitFlags, Window};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// [`Application`][crate::Application] is a class that handles many important aspects
    /// of a GTK+ application in a convenient fashion, without enforcing
    /// a one-size-fits-all application model.
    ///
    /// Currently, GtkApplication handles GTK+ initialization, application
    /// uniqueness, session management, provides some basic scriptability and
    /// desktop shell integration by exporting actions and menus and manages a
    /// list of toplevel windows whose life-cycle is automatically tied to the
    /// life-cycle of your application.
    ///
    /// While GtkApplication works fine with plain `GtkWindows`, it is recommended
    /// to use it together with [`ApplicationWindow`][crate::ApplicationWindow].
    ///
    /// When GDK threads are enabled, GtkApplication will acquire the GDK
    /// lock when invoking actions that arrive from other processes. The GDK
    /// lock is not touched for local action invocations. In order to have
    /// actions invoked in a predictable context it is therefore recommended
    /// that the GDK lock be held while invoking actions locally with
    /// [`ActionGroupExtManual::activate_action()`][crate::gio::prelude::ActionGroupExtManual::activate_action()]. The same applies to actions
    /// associated with [`ApplicationWindow`][crate::ApplicationWindow] and to the “activate” and
    /// “open” [`gio::Application`][crate::gio::Application] methods.
    ///
    /// ## Automatic resources ## {`automatic`-resources}
    ///
    /// [`Application`][crate::Application] will automatically load menus from the [`Builder`][crate::Builder]
    /// resource located at "gtk/menus.ui", relative to the application's
    /// resource base path (see [`ApplicationExtManual::set_resource_base_path()`][crate::gio::prelude::ApplicationExtManual::set_resource_base_path()]). The
    /// menu with the ID "app-menu" is taken as the application's app menu
    /// and the menu with the ID "menubar" is taken as the application's
    /// menubar. Additional menus (most interesting submenus) can be named
    /// and accessed via [`GtkApplicationExt::menu_by_id()`][crate::prelude::GtkApplicationExt::menu_by_id()] which allows for
    /// dynamic population of a part of the menu structure.
    ///
    /// If the resources "gtk/menus-appmenu.ui" or "gtk/menus-traditional.ui" are
    /// present then these files will be used in preference, depending on the value
    /// of [`GtkApplicationExt::prefers_app_menu()`][crate::prelude::GtkApplicationExt::prefers_app_menu()]. If the resource "gtk/menus-common.ui"
    /// is present it will be loaded as well. This is useful for storing items that
    /// are referenced from both "gtk/menus-appmenu.ui" and
    /// "gtk/menus-traditional.ui".
    ///
    /// It is also possible to provide the menus manually using
    /// [`GtkApplicationExt::set_app_menu()`][crate::prelude::GtkApplicationExt::set_app_menu()] and [`GtkApplicationExt::set_menubar()`][crate::prelude::GtkApplicationExt::set_menubar()].
    ///
    /// [`Application`][crate::Application] will also automatically setup an icon search path for
    /// the default icon theme by appending "icons" to the resource base
    /// path. This allows your application to easily store its icons as
    /// resources. See [`IconThemeExt::add_resource_path()`][crate::prelude::IconThemeExt::add_resource_path()] for more
    /// information.
    ///
    /// If there is a resource located at "gtk/help-overlay.ui" which
    /// defines a [`ShortcutsWindow`][crate::ShortcutsWindow] with ID "help_overlay" then GtkApplication
    /// associates an instance of this shortcuts window with each
    /// [`ApplicationWindow`][crate::ApplicationWindow] and sets up keyboard accelerators (Control-F1
    /// and Control-?) to open it. To create a menu item that displays the
    /// shortcuts window, associate the item with the action win.show-help-overlay.
    ///
    /// ## A simple application ## {`gtkapplication`}
    ///
    /// [A simple example](https://gitlab.gnome.org/GNOME/gtk/-/blob/gtk-3-24/examples/bp/bloatpad.c)
    ///
    /// GtkApplication optionally registers with a session manager
    /// of the users session (if you set the [`register-session`][struct@crate::Application#register-session]
    /// property) and offers various functionality related to the session
    /// life-cycle.
    ///
    /// An application can block various ways to end the session with
    /// the [`GtkApplicationExt::inhibit()`][crate::prelude::GtkApplicationExt::inhibit()] function. Typical use cases for
    /// this kind of inhibiting are long-running, uninterruptible operations,
    /// such as burning a CD or performing a disk backup. The session
    /// manager may not honor the inhibitor, but it can be expected to
    /// inform the user about the negative consequences of ending the
    /// session while inhibitors are present.
    ///
    /// ## See Also ## {`seealso`}
    /// [HowDoI: Using GtkApplication](https://wiki.gnome.org/HowDoI/GtkApplication),
    /// [Getting Started with GTK+: Basics](https://developer.gnome.org/gtk3/stable/gtk-getting-started.html`id`-1.2.3.3)
    ///
    /// ## Properties
    ///
    ///
    /// #### `active-window`
    ///  Readable
    ///
    ///
    /// #### `app-menu`
    ///  Readable | Writeable
    ///
    ///
    /// #### `menubar`
    ///  Readable | Writeable
    ///
    ///
    /// #### `register-session`
    ///  Set this property to [`true`] to register with the session manager.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `screensaver-active`
    ///  This property is [`true`] if GTK+ believes that the screensaver is
    /// currently active. GTK+ only tracks session state (including this)
    /// when [`register-session`][struct@crate::Application#register-session] is set to [`true`].
    ///
    /// Tracking the screensaver state is supported on Linux.
    ///
    /// Readable
    /// <details><summary><h4>Application</h4></summary>
    ///
    ///
    /// #### `action-group`
    ///  Writeable
    ///
    ///
    /// #### `application-id`
    ///  Readable | Writeable | Construct
    ///
    ///
    /// #### `flags`
    ///  Readable | Writeable
    ///
    ///
    /// #### `inactivity-timeout`
    ///  Readable | Writeable
    ///
    ///
    /// #### `is-busy`
    ///  Whether the application is currently marked as busy through
    /// [`ApplicationExtManual::mark_busy()`][crate::gio::prelude::ApplicationExtManual::mark_busy()] or [`ApplicationExtManual::bind_busy_property()`][crate::gio::prelude::ApplicationExtManual::bind_busy_property()].
    ///
    /// Readable
    ///
    ///
    /// #### `is-registered`
    ///  Readable
    ///
    ///
    /// #### `is-remote`
    ///  Readable
    ///
    ///
    /// #### `resource-base-path`
    ///  Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `query-end`
    ///  Emitted when the session manager is about to end the session, only
    /// if [`register-session`][struct@crate::Application#register-session] is [`true`]. Applications can
    /// connect to this signal and call [`GtkApplicationExt::inhibit()`][crate::prelude::GtkApplicationExt::inhibit()] with
    /// [`ApplicationInhibitFlags::LOGOUT`][crate::ApplicationInhibitFlags::LOGOUT] to delay the end of the session
    /// until state has been saved.
    ///
    ///
    ///
    ///
    /// #### `window-added`
    ///  Emitted when a [`Window`][crate::Window] is added to `application` through
    /// [`GtkApplicationExt::add_window()`][crate::prelude::GtkApplicationExt::add_window()].
    ///
    ///
    ///
    ///
    /// #### `window-removed`
    ///  Emitted when a [`Window`][crate::Window] is removed from `application`,
    /// either as a side-effect of being destroyed or explicitly
    /// through [`GtkApplicationExt::remove_window()`][crate::prelude::GtkApplicationExt::remove_window()].
    ///
    ///
    /// <details><summary><h4>Application</h4></summary>
    ///
    ///
    /// #### `activate`
    ///  The ::activate signal is emitted on the primary instance when an
    /// activation occurs. See [`ApplicationExtManual::activate()`][crate::gio::prelude::ApplicationExtManual::activate()].
    ///
    ///
    ///
    ///
    /// #### `command-line`
    ///  The ::command-line signal is emitted on the primary instance when
    /// a commandline is not handled locally. See [`ApplicationExtManual::run()`][crate::gio::prelude::ApplicationExtManual::run()] and
    /// the `GApplicationCommandLine` documentation for more information.
    ///
    ///
    ///
    ///
    /// #### `handle-local-options`
    ///  The ::handle-local-options signal is emitted on the local instance
    /// after the parsing of the commandline options has occurred.
    ///
    /// You can add options to be recognised during commandline option
    /// parsing using [`ApplicationExtManual::add_main_option_entries()`][crate::gio::prelude::ApplicationExtManual::add_main_option_entries()] and
    /// [`ApplicationExtManual::add_option_group()`][crate::gio::prelude::ApplicationExtManual::add_option_group()].
    ///
    /// Signal handlers can inspect `options` (along with values pointed to
    /// from the `arg_data` of an installed `GOptionEntrys`) in order to
    /// decide to perform certain actions, including direct local handling
    /// (which may be useful for options like --version).
    ///
    /// In the event that the application is marked
    /// [`gio::ApplicationFlags::HANDLES_COMMAND_LINE`][crate::gio::ApplicationFlags::HANDLES_COMMAND_LINE] the "normal processing" will
    /// send the `options` dictionary to the primary instance where it can be
    /// read with `g_application_command_line_get_options_dict()`. The signal
    /// handler can modify the dictionary before returning, and the
    /// modified dictionary will be sent.
    ///
    /// In the event that [`gio::ApplicationFlags::HANDLES_COMMAND_LINE`][crate::gio::ApplicationFlags::HANDLES_COMMAND_LINE] is not set,
    /// "normal processing" will treat the remaining uncollected command
    /// line arguments as filenames or URIs. If there are no arguments,
    /// the application is activated by [`ApplicationExtManual::activate()`][crate::gio::prelude::ApplicationExtManual::activate()]. One or
    /// more arguments results in a call to [`ApplicationExtManual::open()`][crate::gio::prelude::ApplicationExtManual::open()].
    ///
    /// If you want to handle the local commandline arguments for yourself
    /// by converting them to calls to [`ApplicationExtManual::open()`][crate::gio::prelude::ApplicationExtManual::open()] or
    /// [`ActionGroupExtManual::activate_action()`][crate::gio::prelude::ActionGroupExtManual::activate_action()] then you must be sure to register
    /// the application first. You should probably not call
    /// [`ApplicationExtManual::activate()`][crate::gio::prelude::ApplicationExtManual::activate()] for yourself, however: just return -1 and
    /// allow the default handler to do it for you. This will ensure that
    /// the `--gapplication-service` switch works properly (i.e. no activation
    /// in that case).
    ///
    /// Note that this signal is emitted from the default implementation of
    /// `local_command_line()`. If you override that function and don't
    /// chain up then this signal will never be emitted.
    ///
    /// You can override `local_command_line()` if you need more powerful
    /// capabilities than what is provided here, but this should not
    /// normally be required.
    ///
    ///
    ///
    ///
    /// #### `name-lost`
    ///  The ::name-lost signal is emitted only on the registered primary instance
    /// when a new instance has taken over. This can only happen if the application
    /// is using the [`gio::ApplicationFlags::ALLOW_REPLACEMENT`][crate::gio::ApplicationFlags::ALLOW_REPLACEMENT] flag.
    ///
    /// The default handler for this signal calls [`ApplicationExtManual::quit()`][crate::gio::prelude::ApplicationExtManual::quit()].
    ///
    ///
    ///
    ///
    /// #### `open`
    ///  The ::open signal is emitted on the primary instance when there are
    /// files to open. See [`ApplicationExtManual::open()`][crate::gio::prelude::ApplicationExtManual::open()] for more information.
    ///
    ///
    ///
    ///
    /// #### `shutdown`
    ///  The ::shutdown signal is emitted only on the registered primary instance
    /// immediately after the main loop terminates.
    ///
    ///
    ///
    ///
    /// #### `startup`
    ///  The ::startup signal is emitted on the primary instance immediately
    /// after registration. See [`ApplicationExtManual::register()`][crate::gio::prelude::ApplicationExtManual::register()].
    ///
    ///
    /// </details>
    /// <details><summary><h4>ActionGroup</h4></summary>
    ///
    ///
    /// #### `action-added`
    ///  Signals that a new action was just added to the group.
    /// This signal is emitted after the action has been added
    /// and is now visible.
    ///
    /// Detailed
    ///
    ///
    /// #### `action-enabled-changed`
    ///  Signals that the enabled status of the named action has changed.
    ///
    /// Detailed
    ///
    ///
    /// #### `action-removed`
    ///  Signals that an action is just about to be removed from the group.
    /// This signal is emitted before the action is removed, so the action
    /// is still visible and can be queried from the signal handler.
    ///
    /// Detailed
    ///
    ///
    /// #### `action-state-changed`
    ///  Signals that the state of the named action has changed.
    ///
    /// Detailed
    /// </details>
    ///
    /// # Implements
    ///
    /// [`GtkApplicationExt`][trait@crate::prelude::GtkApplicationExt], [`trait@gio::prelude::ApplicationExt`], [`trait@glib::ObjectExt`], [`trait@gio::prelude::ActionGroupExt`], [`trait@gio::prelude::ActionMapExt`], [`gio::ApplicationExtManual`][trait@crate::prelude::gio::ApplicationExtManual]
    #[doc(alias = "GtkApplication")]
    pub struct Application(Object<ffi::GtkApplication, ffi::GtkApplicationClass>) @extends gio::Application, @implements gio::ActionGroup, gio::ActionMap;

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

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

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Application`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct ApplicationBuilder {
    builder: glib::object::ObjectBuilder<'static, Application>,
}

impl ApplicationBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    pub fn app_menu(self, app_menu: &impl IsA<gio::MenuModel>) -> Self {
        Self {
            builder: self.builder.property("app-menu", app_menu.clone().upcast()),
        }
    }

    pub fn menubar(self, menubar: &impl IsA<gio::MenuModel>) -> Self {
        Self {
            builder: self.builder.property("menubar", menubar.clone().upcast()),
        }
    }

    /// Set this property to [`true`] to register with the session manager.
    pub fn register_session(self, register_session: bool) -> Self {
        Self {
            builder: self.builder.property("register-session", register_session),
        }
    }

    pub fn action_group(self, action_group: &impl IsA<gio::ActionGroup>) -> Self {
        Self {
            builder: self
                .builder
                .property("action-group", action_group.clone().upcast()),
        }
    }

    pub fn application_id(self, application_id: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("application-id", application_id.into()),
        }
    }

    pub fn flags(self, flags: gio::ApplicationFlags) -> Self {
        Self {
            builder: self.builder.property("flags", flags),
        }
    }

    pub fn inactivity_timeout(self, inactivity_timeout: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("inactivity-timeout", inactivity_timeout),
        }
    }

    pub fn resource_base_path(self, resource_base_path: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("resource-base-path", resource_base_path.into()),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Application`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Application {
        let ret = self.builder.build();
        {
            Application::register_startup_hook(&ret);
        }
        ret
    }
}

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::Application>> Sealed for T {}
}

/// Trait containing all [`struct@Application`] methods.
///
/// # Implementors
///
/// [`Application`][struct@crate::Application]
pub trait GtkApplicationExt: IsA<Application> + sealed::Sealed + 'static {
    /// Adds a window to `self`.
    ///
    /// This call can only happen after the `self` has started;
    /// typically, you should add new application windows in response
    /// to the emission of the [`activate`][struct@crate::gio::Application#activate] signal.
    ///
    /// This call is equivalent to setting the [`application`][struct@crate::Window#application]
    /// property of `window` to `self`.
    ///
    /// Normally, the connection between the application and the window
    /// will remain until the window is destroyed, but you can explicitly
    /// remove it with [`remove_window()`][Self::remove_window()].
    ///
    /// GTK+ will keep the `self` running as long as it has
    /// any windows.
    /// ## `window`
    /// a [`Window`][crate::Window]
    #[doc(alias = "gtk_application_add_window")]
    fn add_window(&self, window: &impl IsA<Window>) {
        unsafe {
            ffi::gtk_application_add_window(
                self.as_ref().to_glib_none().0,
                window.as_ref().to_glib_none().0,
            );
        }
    }

    /// Gets the accelerators that are currently associated with
    /// the given action.
    /// ## `detailed_action_name`
    /// a detailed action name, specifying an action
    ///  and target to obtain accelerators for
    ///
    /// # Returns
    ///
    /// accelerators for `detailed_action_name`, as
    ///  a [`None`]-terminated array. Free with `g_strfreev()` when no longer needed
    #[doc(alias = "gtk_application_get_accels_for_action")]
    #[doc(alias = "get_accels_for_action")]
    fn accels_for_action(&self, detailed_action_name: &str) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_application_get_accels_for_action(
                self.as_ref().to_glib_none().0,
                detailed_action_name.to_glib_none().0,
            ))
        }
    }

    /// Returns the list of actions (possibly empty) that `accel` maps to.
    /// Each item in the list is a detailed action name in the usual form.
    ///
    /// This might be useful to discover if an accel already exists in
    /// order to prevent installation of a conflicting accelerator (from
    /// an accelerator editor or a plugin system, for example). Note that
    /// having more than one action per accelerator may not be a bad thing
    /// and might make sense in cases where the actions never appear in the
    /// same context.
    ///
    /// In case there are no actions for a given accelerator, an empty array
    /// is returned. [`None`] is never returned.
    ///
    /// It is a programmer error to pass an invalid accelerator string.
    /// If you are unsure, check it with [`accelerator_parse()`][crate::accelerator_parse()] first.
    /// ## `accel`
    /// an accelerator that can be parsed by [`accelerator_parse()`][crate::accelerator_parse()]
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array of actions for `accel`
    #[doc(alias = "gtk_application_get_actions_for_accel")]
    #[doc(alias = "get_actions_for_accel")]
    fn actions_for_accel(&self, accel: &str) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_application_get_actions_for_accel(
                self.as_ref().to_glib_none().0,
                accel.to_glib_none().0,
            ))
        }
    }

    /// Gets the “active” window for the application.
    ///
    /// The active window is the one that was most recently focused (within
    /// the application). This window may not have the focus at the moment
    /// if another application has it — this is just the most
    /// recently-focused window within this application.
    ///
    /// # Returns
    ///
    /// the active window, or [`None`] if
    ///  there isn't one.
    #[doc(alias = "gtk_application_get_active_window")]
    #[doc(alias = "get_active_window")]
    fn active_window(&self) -> Option<Window> {
        unsafe {
            from_glib_none(ffi::gtk_application_get_active_window(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the menu model that has been set with
    /// [`set_app_menu()`][Self::set_app_menu()].
    ///
    /// # Returns
    ///
    /// the application menu of `self`
    ///  or [`None`] if no application menu has been set.
    #[doc(alias = "gtk_application_get_app_menu")]
    #[doc(alias = "get_app_menu")]
    fn app_menu(&self) -> Option<gio::MenuModel> {
        unsafe {
            from_glib_none(ffi::gtk_application_get_app_menu(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets a menu from automatically loaded resources.
    /// See [Automatic resources][automatic-resources]
    /// for more information.
    /// ## `id`
    /// the id of the menu to look up
    ///
    /// # Returns
    ///
    /// Gets the menu with the
    ///  given id from the automatically loaded resources
    #[doc(alias = "gtk_application_get_menu_by_id")]
    #[doc(alias = "get_menu_by_id")]
    fn menu_by_id(&self, id: &str) -> Option<gio::Menu> {
        unsafe {
            from_glib_none(ffi::gtk_application_get_menu_by_id(
                self.as_ref().to_glib_none().0,
                id.to_glib_none().0,
            ))
        }
    }

    /// Returns the menu model that has been set with
    /// [`set_menubar()`][Self::set_menubar()].
    ///
    /// # Returns
    ///
    /// the menubar for windows of `self`
    #[doc(alias = "gtk_application_get_menubar")]
    #[doc(alias = "get_menubar")]
    fn menubar(&self) -> Option<gio::MenuModel> {
        unsafe {
            from_glib_none(ffi::gtk_application_get_menubar(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the [`ApplicationWindow`][crate::ApplicationWindow] with the given ID.
    ///
    /// The ID of a [`ApplicationWindow`][crate::ApplicationWindow] can be retrieved with
    /// [`ApplicationWindowExt::id()`][crate::prelude::ApplicationWindowExt::id()].
    /// ## `id`
    /// an identifier number
    ///
    /// # Returns
    ///
    /// the window with ID `id`, or
    ///  [`None`] if there is no window with this ID
    #[doc(alias = "gtk_application_get_window_by_id")]
    #[doc(alias = "get_window_by_id")]
    fn window_by_id(&self, id: u32) -> Option<Window> {
        unsafe {
            from_glib_none(ffi::gtk_application_get_window_by_id(
                self.as_ref().to_glib_none().0,
                id,
            ))
        }
    }

    /// Gets a list of the `GtkWindows` associated with `self`.
    ///
    /// The list is sorted by most recently focused window, such that the first
    /// element is the currently focused window. (Useful for choosing a parent
    /// for a transient window.)
    ///
    /// The list that is returned should not be modified in any way. It will
    /// only remain valid until the next focus change or window creation or
    /// deletion.
    ///
    /// # Returns
    ///
    /// a `GList` of [`Window`][crate::Window]
    #[doc(alias = "gtk_application_get_windows")]
    #[doc(alias = "get_windows")]
    fn windows(&self) -> Vec<Window> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::gtk_application_get_windows(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Inform the session manager that certain types of actions should be
    /// inhibited. This is not guaranteed to work on all platforms and for
    /// all types of actions.
    ///
    /// Applications should invoke this method when they begin an operation
    /// that should not be interrupted, such as creating a CD or DVD. The
    /// types of actions that may be blocked are specified by the `flags`
    /// parameter. When the application completes the operation it should
    /// call [`uninhibit()`][Self::uninhibit()] to remove the inhibitor. Note that
    /// an application can have multiple inhibitors, and all of them must
    /// be individually removed. Inhibitors are also cleared when the
    /// application exits.
    ///
    /// Applications should not expect that they will always be able to block
    /// the action. In most cases, users will be given the option to force
    /// the action to take place.
    ///
    /// Reasons should be short and to the point.
    ///
    /// If `window` is given, the session manager may point the user to
    /// this window to find out more about why the action is inhibited.
    /// ## `window`
    /// a [`Window`][crate::Window], or [`None`]
    /// ## `flags`
    /// what types of actions should be inhibited
    /// ## `reason`
    /// a short, human-readable string that explains
    ///  why these operations are inhibited
    ///
    /// # Returns
    ///
    /// A non-zero cookie that is used to uniquely identify this
    ///  request. It should be used as an argument to [`uninhibit()`][Self::uninhibit()]
    ///  in order to remove the request. If the platform does not support
    ///  inhibiting or the request failed for some reason, 0 is returned.
    #[doc(alias = "gtk_application_inhibit")]
    fn inhibit(
        &self,
        window: Option<&impl IsA<Window>>,
        flags: ApplicationInhibitFlags,
        reason: Option<&str>,
    ) -> u32 {
        unsafe {
            ffi::gtk_application_inhibit(
                self.as_ref().to_glib_none().0,
                window.map(|p| p.as_ref()).to_glib_none().0,
                flags.into_glib(),
                reason.to_glib_none().0,
            )
        }
    }

    /// Determines if any of the actions specified in `flags` are
    /// currently inhibited (possibly by another application).
    ///
    /// Note that this information may not be available (for example
    /// when the application is running in a sandbox).
    /// ## `flags`
    /// what types of actions should be queried
    ///
    /// # Returns
    ///
    /// [`true`] if any of the actions specified in `flags` are inhibited
    #[doc(alias = "gtk_application_is_inhibited")]
    fn is_inhibited(&self, flags: ApplicationInhibitFlags) -> bool {
        unsafe {
            from_glib(ffi::gtk_application_is_inhibited(
                self.as_ref().to_glib_none().0,
                flags.into_glib(),
            ))
        }
    }

    /// Lists the detailed action names which have associated accelerators.
    /// See [`set_accels_for_action()`][Self::set_accels_for_action()].
    ///
    /// # Returns
    ///
    /// a [`None`]-terminated array of strings,
    ///  free with `g_strfreev()` when done
    #[doc(alias = "gtk_application_list_action_descriptions")]
    fn list_action_descriptions(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_application_list_action_descriptions(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines if the desktop environment in which the application is
    /// running would prefer an application menu be shown.
    ///
    /// If this function returns [`true`] then the application should call
    /// [`set_app_menu()`][Self::set_app_menu()] with the contents of an application
    /// menu, which will be shown by the desktop environment. If it returns
    /// [`false`] then you should consider using an alternate approach, such as
    /// a menubar.
    ///
    /// The value returned by this function is purely advisory and you are
    /// free to ignore it. If you call [`set_app_menu()`][Self::set_app_menu()] even
    /// if the desktop environment doesn't support app menus, then a fallback
    /// will be provided.
    ///
    /// Applications are similarly free not to set an app menu even if the
    /// desktop environment wants to show one. In that case, a fallback will
    /// also be created by the desktop environment (GNOME, for example, uses
    /// a menu with only a "Quit" item in it).
    ///
    /// The value returned by this function never changes. Once it returns a
    /// particular value, it is guaranteed to always return the same value.
    ///
    /// You may only call this function after the application has been
    /// registered and after the base startup handler has run. You're most
    /// likely to want to use this from your own startup handler. It may
    /// also make sense to consult this function while constructing UI (in
    /// activate, open or an action activation handler) in order to determine
    /// if you should show a gear menu or not.
    ///
    /// This function will return [`false`] on Mac OS and a default app menu
    /// will be created automatically with the "usual" contents of that menu
    /// typical to most Mac OS applications. If you call
    /// [`set_app_menu()`][Self::set_app_menu()] anyway, then this menu will be
    /// replaced with your own.
    ///
    /// # Returns
    ///
    /// [`true`] if you should set an app menu
    #[doc(alias = "gtk_application_prefers_app_menu")]
    fn prefers_app_menu(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_application_prefers_app_menu(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Remove a window from `self`.
    ///
    /// If `window` belongs to `self` then this call is equivalent to
    /// setting the [`application`][struct@crate::Window#application] property of `window` to
    /// [`None`].
    ///
    /// The application may stop running as a result of a call to this
    /// function.
    /// ## `window`
    /// a [`Window`][crate::Window]
    #[doc(alias = "gtk_application_remove_window")]
    fn remove_window(&self, window: &impl IsA<Window>) {
        unsafe {
            ffi::gtk_application_remove_window(
                self.as_ref().to_glib_none().0,
                window.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets zero or more keyboard accelerators that will trigger the
    /// given action. The first item in `accels` will be the primary
    /// accelerator, which may be displayed in the UI.
    ///
    /// To remove all accelerators for an action, use an empty, zero-terminated
    /// array for `accels`.
    ///
    /// For the `detailed_action_name`, see `g_action_parse_detailed_name()` and
    /// `g_action_print_detailed_name()`.
    /// ## `detailed_action_name`
    /// a detailed action name, specifying an action
    ///  and target to associate accelerators with
    /// ## `accels`
    /// a list of accelerators in the format
    ///  understood by [`accelerator_parse()`][crate::accelerator_parse()]
    #[doc(alias = "gtk_application_set_accels_for_action")]
    fn set_accels_for_action(&self, detailed_action_name: &str, accels: &[&str]) {
        unsafe {
            ffi::gtk_application_set_accels_for_action(
                self.as_ref().to_glib_none().0,
                detailed_action_name.to_glib_none().0,
                accels.to_glib_none().0,
            );
        }
    }

    /// Sets or unsets the application menu for `self`.
    ///
    /// This can only be done in the primary instance of the application,
    /// after it has been registered. [`startup`][struct@crate::gio::Application#startup] is a good place
    /// to call this.
    ///
    /// The application menu is a single menu containing items that typically
    /// impact the application as a whole, rather than acting on a specific
    /// window or document. For example, you would expect to see
    /// “Preferences” or “Quit” in an application menu, but not “Save” or
    /// “Print”.
    ///
    /// If supported, the application menu will be rendered by the desktop
    /// environment.
    ///
    /// Use the base [`gio::ActionMap`][crate::gio::ActionMap] interface to add actions, to respond to the user
    /// selecting these menu items.
    /// ## `app_menu`
    /// a [`gio::MenuModel`][crate::gio::MenuModel], or [`None`]
    #[doc(alias = "gtk_application_set_app_menu")]
    fn set_app_menu(&self, app_menu: Option<&impl IsA<gio::MenuModel>>) {
        unsafe {
            ffi::gtk_application_set_app_menu(
                self.as_ref().to_glib_none().0,
                app_menu.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets or unsets the menubar for windows of `self`.
    ///
    /// This is a menubar in the traditional sense.
    ///
    /// This can only be done in the primary instance of the application,
    /// after it has been registered. [`startup`][struct@crate::gio::Application#startup] is a good place
    /// to call this.
    ///
    /// Depending on the desktop environment, this may appear at the top of
    /// each window, or at the top of the screen. In some environments, if
    /// both the application menu and the menubar are set, the application
    /// menu will be presented as if it were the first item of the menubar.
    /// Other environments treat the two as completely separate — for example,
    /// the application menu may be rendered by the desktop shell while the
    /// menubar (if set) remains in each individual window.
    ///
    /// Use the base [`gio::ActionMap`][crate::gio::ActionMap] interface to add actions, to respond to the
    /// user selecting these menu items.
    /// ## `menubar`
    /// a [`gio::MenuModel`][crate::gio::MenuModel], or [`None`]
    #[doc(alias = "gtk_application_set_menubar")]
    fn set_menubar(&self, menubar: Option<&impl IsA<gio::MenuModel>>) {
        unsafe {
            ffi::gtk_application_set_menubar(
                self.as_ref().to_glib_none().0,
                menubar.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Removes an inhibitor that has been established with [`inhibit()`][Self::inhibit()].
    /// Inhibitors are also cleared when the application exits.
    /// ## `cookie`
    /// a cookie that was returned by [`inhibit()`][Self::inhibit()]
    #[doc(alias = "gtk_application_uninhibit")]
    fn uninhibit(&self, cookie: u32) {
        unsafe {
            ffi::gtk_application_uninhibit(self.as_ref().to_glib_none().0, cookie);
        }
    }

    /// Set this property to [`true`] to register with the session manager.
    #[doc(alias = "register-session")]
    fn is_register_session(&self) -> bool {
        ObjectExt::property(self.as_ref(), "register-session")
    }

    /// Set this property to [`true`] to register with the session manager.
    #[doc(alias = "register-session")]
    fn set_register_session(&self, register_session: bool) {
        ObjectExt::set_property(self.as_ref(), "register-session", register_session)
    }

    /// This property is [`true`] if GTK+ believes that the screensaver is
    /// currently active. GTK+ only tracks session state (including this)
    /// when [`register-session`][struct@crate::Application#register-session] is set to [`true`].
    ///
    /// Tracking the screensaver state is supported on Linux.
    #[cfg(feature = "v3_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24")))]
    #[doc(alias = "screensaver-active")]
    fn is_screensaver_active(&self) -> bool {
        ObjectExt::property(self.as_ref(), "screensaver-active")
    }

    /// Emitted when the session manager is about to end the session, only
    /// if [`register-session`][struct@crate::Application#register-session] is [`true`]. Applications can
    /// connect to this signal and call [`inhibit()`][Self::inhibit()] with
    /// [`ApplicationInhibitFlags::LOGOUT`][crate::ApplicationInhibitFlags::LOGOUT] to delay the end of the session
    /// until state has been saved.
    #[cfg(feature = "v3_24_8")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24_8")))]
    #[doc(alias = "query-end")]
    fn connect_query_end<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn query_end_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkApplication,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"query-end\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    query_end_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a [`Window`][crate::Window] is added to `application` through
    /// [`add_window()`][Self::add_window()].
    /// ## `window`
    /// the newly-added [`Window`][crate::Window]
    #[doc(alias = "window-added")]
    fn connect_window_added<F: Fn(&Self, &Window) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn window_added_trampoline<
            P: IsA<Application>,
            F: Fn(&P, &Window) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            window: *mut ffi::GtkWindow,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Application::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(window),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"window-added\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    window_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a [`Window`][crate::Window] is removed from `application`,
    /// either as a side-effect of being destroyed or explicitly
    /// through [`remove_window()`][Self::remove_window()].
    /// ## `window`
    /// the [`Window`][crate::Window] that is being removed
    #[doc(alias = "window-removed")]
    fn connect_window_removed<F: Fn(&Self, &Window) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn window_removed_trampoline<
            P: IsA<Application>,
            F: Fn(&P, &Window) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            window: *mut ffi::GtkWindow,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                Application::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(window),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"window-removed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    window_removed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "active-window")]
    fn connect_active_window_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_active_window_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::active-window\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_active_window_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "app-menu")]
    fn connect_app_menu_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_app_menu_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::app-menu\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_app_menu_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "menubar")]
    fn connect_menubar_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_menubar_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::menubar\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_menubar_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "register-session")]
    fn connect_register_session_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_register_session_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::register-session\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_register_session_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v3_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v3_24")))]
    #[doc(alias = "screensaver-active")]
    fn connect_screensaver_active_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_screensaver_active_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::screensaver-active\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_screensaver_active_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<Application>> GtkApplicationExt for O {}

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