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

#[cfg(feature = "v4_24")]
#[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
use crate::RestoreReason;
use crate::{ApplicationInhibitFlags, Window, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A high-level API for writing applications.
    ///
    /// [`Application`][crate::Application] supports many aspects of writing a GTK application
    /// in a convenient fashion, without enforcing a one-size-fits-all model.
    ///
    /// Currently, it 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 [`Application`][crate::Application] works fine with plain [`Window`][crate::Window]s,
    /// it is recommended to use it together with [`ApplicationWindow`][crate::ApplicationWindow].
    ///
    /// ## Initialization
    ///
    /// A typical [`Application`][crate::Application] will create a window in its
    /// [`activate`][struct@crate::GIO::Application#activate], [`open`][struct@crate::GIO::Application#open]
    /// or [`command-line`][struct@crate::GIO::Application#command-line] handlers. Note that all
    /// of these signals may be emitted multiple times, so handlers must
    /// be careful to take existing windows into account.
    ///
    /// A typical ::activate handler should look like this:
    ///
    /// ```text
    /// static void
    /// activate (GApplication *gapp)
    /// {
    ///   GtkApplication *app = GTK_APPLICATION (gapp);
    ///   GtkWindow *window;
    ///
    ///   window = gtk_application_get_active_window (app);
    ///   if (!window)
    ///     window = create_window (app);
    ///
    ///   gtk_window_present (window);
    /// }
    /// ```
    ///
    /// ## 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 "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.
    ///
    /// Note that automatic resource loading uses the resource base path
    /// that is set at construction time and will not work if the resource
    /// base path is changed at a later time.
    ///
    /// It is also possible to provide the menubar manually using
    /// [`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 [`IconTheme::add_resource_path()`][crate::IconTheme::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
    /// [`Application`][crate::Application] associates an instance of this shortcuts window with
    /// each [`ApplicationWindow`][crate::ApplicationWindow] and sets up the keyboard accelerator
    /// <kbd>Control</kbd>+<kbd>?</kbd> to open it. To create a menu item that
    /// displays the shortcuts window, associate the item with the action
    /// `win.show-help-overlay`.
    ///
    /// [`Application`][crate::Application] will also automatically set the application id as the
    /// default window icon. Use [`Window::set_default_icon_name()`][crate::Window::set_default_icon_name()] or
    /// [`icon-name`][struct@crate::Window#icon-name] to override that behavior.
    ///
    /// ## State saving
    ///
    /// [`Application`][crate::Application] registers with a session manager if possible and
    /// offers various functionality related to the session life-cycle,
    /// such as state saving.
    ///
    /// State-saving functionality can be enabled by setting the
    /// [`support-save`][struct@crate::Application#support-save] property to true.
    ///
    /// In order to save and restore per-window state, applications must
    /// connect to the [`restore-window`][struct@crate::Application#restore-window] signal and
    /// handle the [`save-state`][struct@crate::ApplicationWindow#save-state] signal. There
    /// are also [`restore-state`][struct@crate::Application#restore-state] and
    /// [`save-state`][struct@crate::GtkApplication#save-state] signals, which can be used
    /// for global state that is not connected to any window.
    ///
    /// [`Application`][crate::Application] automatically saves state before app shutdown, and by
    /// default periodically auto-saves app state (as configured by the
    /// [`autosave-interval`][struct@crate::Application#autosave-interval] property). Applications can
    /// also call [`GtkApplicationExt::save()`][crate::prelude::GtkApplicationExt::save()] themselves at opportune times.
    ///
    /// # Inhibiting
    ///
    /// 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.
    ///
    /// ## A simple application
    ///
    /// [A simple example](https://gitlab.gnome.org/GNOME/gtk/tree/main/examples/bp/bloatpad.c)
    /// is available in the GTK source code repository
    ///
    /// ## See Also
    ///
    /// - [Using GtkApplication](https://developer.gnome.org/documentation/tutorials/application.html)
    /// - [Getting Started with GTK: Basics](getting_started.html#basics)
    ///
    /// ## Properties
    ///
    ///
    /// #### `active-window`
    ///  The currently focused window of the application.
    ///
    /// Readable
    ///
    ///
    /// #### `autosave-interval`
    ///  The number of seconds between automatic state saves. Defaults to 15.
    /// A value of 0 will opt out of automatic state saving.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `menubar`
    ///  The menu model to be used for the application's menu bar.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `register-session`
    ///  Set this property to true to register with the session manager.
    ///
    /// This will make GTK track the session state (such as the
    /// [`screensaver-active`][struct@crate::Application#screensaver-active] property).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `screensaver-active`
    ///  This property is true if GTK believes that the screensaver
    /// is currently active.
    ///
    /// Tracking the screensaver state is currently only supported on
    /// Linux.
    ///
    /// Readable
    ///
    ///
    /// #### `support-save`
    ///  Set this property to true if the application supports
    /// state saving and restoring.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>Application</h4></summary>
    ///
    ///
    /// #### `action-group`
    ///  The group of actions that the application exports.
    ///
    /// Writeable
    ///
    ///
    /// #### `application-id`
    ///  The unique identifier for the application.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `flags`
    ///  Flags specifying the behaviour of the application.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `inactivity-timeout`
    ///  Time (in milliseconds) to stay alive after becoming idle.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-busy`
    ///  Whether the application is currently marked as busy through
    /// g_application_mark_busy() or g_application_bind_busy_property().
    ///
    /// Readable
    ///
    ///
    /// #### `is-registered`
    ///  Whether [`ApplicationExtManual::register()`][crate::gio::prelude::ApplicationExtManual::register()] has been called.
    ///
    /// Readable
    ///
    ///
    /// #### `is-remote`
    ///  Whether this application instance is remote.
    ///
    /// Readable
    ///
    ///
    /// #### `resource-base-path`
    ///  The base resource path for the application.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `version`
    ///  The human-readable version number of the application.
    ///
    /// Readable | Writeable
    /// </details>
    ///
    /// ## Signals
    ///
    ///
    /// #### `query-end`
    ///  Emitted when the session manager is about to end the session.
    ///
    /// Applications can connect to this signal and call
    /// [`GtkApplicationExt::inhibit()`][crate::prelude::GtkApplicationExt::inhibit()] with [flags@Gtk.ApplicationInhibitFlags.logout]
    /// to delay the end of the session until state has been saved.
    ///
    ///
    ///
    ///
    /// #### `restore-state`
    ///  Emitted when application global state is restored.
    ///
    /// The handler for this signal should do the opposite of what the
    /// corresponding handler for [`save-state`][struct@crate::Application#save-state]
    /// does.
    ///
    /// You must be careful to be robust in the face of app upgrades and downgrades:
    /// the @state might have been created by a previous or occasionally even a future
    /// version of your app. Do not assume that a given key exists in the state.
    /// Apps must try to restore state saved by a previous version, but are free to
    /// discard state if it was written by a future version.
    ///
    ///
    ///
    ///
    /// #### `restore-window`
    ///  Emitted when an application's per-window state is restored.
    ///
    /// In response to this signal, you should create a new application
    /// window, add it to @application, apply the provided @state, and present it.
    /// The application can use the @reason to determine how much of the state
    /// should be restored.
    ///
    /// You must be careful to be robust in the face of app upgrades and downgrades:
    /// the @state might have been created by a previous or occasionally even a future
    /// version of your app. Do not assume that a given key exists in the state.
    /// Apps must try to restore state saved by a previous version, but are free to
    /// discard state if it was written by a future version.
    ///
    /// GTK will remember which window the user was using most recently, and will
    /// emit this signal for that window first. Thus, if you decide that the provided
    /// @reason means that only one window should be restored, you can reliably
    /// ignore emissions if a window already exists
    ///
    /// This signal will be emitted whenever the application needs to restore its
    /// windows. This normally happens during the initial launch, but it can also
    /// happen in the existing application instance if it is re-activated after all
    /// application windows were closed.
    ///
    ///
    ///
    ///
    /// #### `save-state`
    ///  Emitted when the application is saving global state.
    ///
    /// The handler for this signal should persist any global state of
    /// @application into @dict.
    ///
    /// See [`restore-state`][struct@crate::Application#restore-state] for how to
    /// restore global state, and [`save-state`][struct@crate::ApplicationWindow#save-state]
    /// and [`restore-window`][struct@crate::Application#restore-window] for handling
    /// per-window state.
    ///
    ///
    ///
    ///
    /// #### `window-added`
    ///  Emitted when a window is added to an application.
    ///
    /// See [`GtkApplicationExt::add_window()`][crate::prelude::GtkApplicationExt::add_window()].
    ///
    ///
    ///
    ///
    /// #### `window-removed`
    ///  Emitted when a window is removed from an application.
    ///
    /// This can happen as a side-effect of the window 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 g_application_activate().
    ///
    ///
    ///
    ///
    /// #### `command-line`
    ///  The ::command-line signal is emitted on the primary instance when
    /// a commandline is not handled locally. See g_application_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 g_application_add_main_option_entries() and
    /// g_application_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 g_application_activate().  One or
    /// more arguments results in a call to g_application_open().
    ///
    /// If you want to handle the local commandline arguments for yourself
    /// by converting them to calls to g_application_open() or
    /// g_action_group_activate_action() then you must be sure to register
    /// the application first.  You should probably not call
    /// g_application_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 g_application_quit().
    ///
    ///
    ///
    ///
    /// #### `open`
    ///  The ::open signal is emitted on the primary instance when there are
    /// files to open. See g_application_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 g_application_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`]
    #[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(),
        }
    }

    /// The number of seconds between automatic state saves. Defaults to 15.
    /// A value of 0 will opt out of automatic state saving.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    pub fn autosave_interval(self, autosave_interval: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("autosave-interval", autosave_interval),
        }
    }

    /// The menu model to be used for the application's menu bar.
    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.
    ///
    /// This will make GTK track the session state (such as the
    /// [`screensaver-active`][struct@crate::Application#screensaver-active] property).
    /// This property is ignored. GTK always registers
    /// with the session manager
    #[cfg_attr(feature = "v4_22", deprecated = "Since 4.22")]
    pub fn register_session(self, register_session: bool) -> Self {
        Self {
            builder: self.builder.property("register-session", register_session),
        }
    }

    /// Set this property to true if the application supports
    /// state saving and restoring.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    pub fn support_save(self, support_save: bool) -> Self {
        Self {
            builder: self.builder.property("support-save", support_save),
        }
    }

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

    /// Flags specifying the behaviour of the application.
    pub fn flags(self, flags: gio::ApplicationFlags) -> Self {
        Self {
            builder: self.builder.property("flags", flags),
        }
    }

    /// Time (in milliseconds) to stay alive after becoming idle.
    pub fn inactivity_timeout(self, inactivity_timeout: u32) -> Self {
        Self {
            builder: self
                .builder
                .property("inactivity-timeout", inactivity_timeout),
        }
    }

    /// The base resource path for the application.
    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()),
        }
    }

    /// The human-readable version number of the application.
    #[cfg(feature = "gio_v2_80")]
    #[cfg_attr(docsrs, doc(cfg(feature = "gio_v2_80")))]
    pub fn version(self, version: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("version", version.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
    }
}

/// Trait containing all [`struct@Application`] methods.
///
/// # Implementors
///
/// [`Application`][struct@crate::Application]
pub trait GtkApplicationExt: IsA<Application> + 'static {
    /// Adds a window to the application.
    ///
    /// This call can only happen after the application 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 the 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 application running as long as it has any windows.
    /// ## `window`
    /// a 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,
            );
        }
    }

    /// Forget state that has been previously saved and prevent further automatic
    /// state saving.
    ///
    /// In order to re-enable state saving, call [`save()`][Self::save()].
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "gtk_application_forget")]
    fn forget(&self) {
        unsafe {
            ffi::gtk_application_forget(self.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
    #[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 the accelerator 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. `NULL` 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
    ///
    /// 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
    #[doc(alias = "gtk_application_get_active_window")]
    #[doc(alias = "get_active_window")]
    #[doc(alias = "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,
            ))
        }
    }

    /// Gets a menu from automatically loaded resources.
    ///
    /// See [the section on Automatic resources](class.Application.html#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 for the menu bar of the application.
    ///
    /// # Returns
    ///
    /// the menubar for windows of the application
    #[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 window 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 for the given 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 window associated with the application.
    ///
    /// 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
    ///
    /// the list of windows
    #[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,
            ))
        }
    }

    /// Informs 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.
    ///
    /// The @reason message should be short and to the point.
    ///
    /// If a window is given, the session manager may point the user to
    /// this window to find out more about why the action is inhibited.
    ///
    /// The cookie that is returned by this function  should be used as an
    /// argument to [`uninhibit()`][Self::uninhibit()] in order to remove
    /// the request.
    /// ## `window`
    /// a window
    /// ## `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, or
    ///   0 if the platform does not support inhibiting or the request failed
    ///   for some reason
    #[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,
            )
        }
    }

    /// Lists the detailed action names which have associated accelerators.
    ///
    /// See [`set_accels_for_action()`][Self::set_accels_for_action()].
    ///
    /// # Returns
    ///
    /// the detailed action names
    #[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,
            ))
        }
    }

    /// Remove a window from the application.
    ///
    /// If the window belongs to the application then this call is
    /// equivalent to setting the [`application`][struct@crate::Window#application]
    /// property of the window to `NULL`.
    ///
    /// The application may stop running as a result of a call to this
    /// function, if the window was the last window of the application.
    /// ## `window`
    /// a 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,
            );
        }
    }

    /// Saves the state of the application.
    ///
    /// See [`forget()`][Self::forget()] for a way to forget the state.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "gtk_application_save")]
    fn save(&self) {
        unsafe {
            ffi::gtk_application_save(self.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 [`gio::Action::parse_detailed_name()`][crate::gio::Action::parse_detailed_name()]
    /// and [Gio.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 menubar for windows of the application.
    ///
    /// 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. `vfunc::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 `GActionMap` interface to add actions, to respond to the
    /// user selecting these menu items.
    /// ## `menubar`
    /// a menu model
    #[doc(alias = "gtk_application_set_menubar")]
    #[doc(alias = "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 previously established.
    ///
    /// See [`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);
        }
    }

    /// The number of seconds between automatic state saves. Defaults to 15.
    /// A value of 0 will opt out of automatic state saving.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "autosave-interval")]
    fn autosave_interval(&self) -> u32 {
        ObjectExt::property(self.as_ref(), "autosave-interval")
    }

    /// The number of seconds between automatic state saves. Defaults to 15.
    /// A value of 0 will opt out of automatic state saving.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "autosave-interval")]
    fn set_autosave_interval(&self, autosave_interval: u32) {
        ObjectExt::set_property(self.as_ref(), "autosave-interval", autosave_interval)
    }

    /// Set this property to true to register with the session manager.
    ///
    /// This will make GTK track the session state (such as the
    /// [`screensaver-active`][struct@crate::Application#screensaver-active] property).
    ///
    /// # Deprecated since 4.22
    ///
    /// This property is ignored. GTK always registers
    /// with the session manager
    #[cfg_attr(feature = "v4_22", deprecated = "Since 4.22")]
    #[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.
    ///
    /// This will make GTK track the session state (such as the
    /// [`screensaver-active`][struct@crate::Application#screensaver-active] property).
    ///
    /// # Deprecated since 4.22
    ///
    /// This property is ignored. GTK always registers
    /// with the session manager
    #[cfg_attr(feature = "v4_22", deprecated = "Since 4.22")]
    #[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.
    ///
    /// Tracking the screensaver state is currently only supported on
    /// Linux.
    #[doc(alias = "screensaver-active")]
    fn is_screensaver_active(&self) -> bool {
        ObjectExt::property(self.as_ref(), "screensaver-active")
    }

    /// Set this property to true if the application supports
    /// state saving and restoring.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "support-save")]
    fn supports_save(&self) -> bool {
        ObjectExt::property(self.as_ref(), "support-save")
    }

    /// Set this property to true if the application supports
    /// state saving and restoring.
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "support-save")]
    fn set_support_save(&self, support_save: bool) {
        ObjectExt::set_property(self.as_ref(), "support-save", support_save)
    }

    /// Emitted when the session manager is about to end the session.
    ///
    /// Applications can connect to this signal and call
    /// [`inhibit()`][Self::inhibit()] with [flags@Gtk.ApplicationInhibitFlags.logout]
    /// to delay the end of the session until state has been saved.
    #[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,
        ) {
            unsafe {
                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 _,
                c"query-end".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    query_end_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when application global state is restored.
    ///
    /// The handler for this signal should do the opposite of what the
    /// corresponding handler for [`save-state`][struct@crate::Application#save-state]
    /// does.
    ///
    /// You must be careful to be robust in the face of app upgrades and downgrades:
    /// the @state might have been created by a previous or occasionally even a future
    /// version of your app. Do not assume that a given key exists in the state.
    /// Apps must try to restore state saved by a previous version, but are free to
    /// discard state if it was written by a future version.
    /// ## `reason`
    /// the reason for restoring state
    /// ## `state`
    /// an `a{sv}` dictionary containing the state to restore, as saved by a [`save-state`][struct@crate::Application#save-state] handler
    ///
    /// # Returns
    ///
    /// true to stop further handlers from running
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "restore-state")]
    fn connect_restore_state<F: Fn(&Self, RestoreReason, &glib::Variant) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn restore_state_trampoline<
            P: IsA<Application>,
            F: Fn(&P, RestoreReason, &glib::Variant) -> bool + 'static,
        >(
            this: *mut ffi::GtkApplication,
            reason: ffi::GtkRestoreReason,
            state: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Application::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(reason),
                    &from_glib_borrow(state),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"restore-state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    restore_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when an application's per-window state is restored.
    ///
    /// In response to this signal, you should create a new application
    /// window, add it to @application, apply the provided @state, and present it.
    /// The application can use the @reason to determine how much of the state
    /// should be restored.
    ///
    /// You must be careful to be robust in the face of app upgrades and downgrades:
    /// the @state might have been created by a previous or occasionally even a future
    /// version of your app. Do not assume that a given key exists in the state.
    /// Apps must try to restore state saved by a previous version, but are free to
    /// discard state if it was written by a future version.
    ///
    /// GTK will remember which window the user was using most recently, and will
    /// emit this signal for that window first. Thus, if you decide that the provided
    /// @reason means that only one window should be restored, you can reliably
    /// ignore emissions if a window already exists
    ///
    /// This signal will be emitted whenever the application needs to restore its
    /// windows. This normally happens during the initial launch, but it can also
    /// happen in the existing application instance if it is re-activated after all
    /// application windows were closed.
    /// ## `reason`
    /// the reason this window is restored
    /// ## `state`
    /// an `a{sv}` dictionary containing the state to restore, as saved by a [`save-state`][struct@crate::ApplicationWindow#save-state] handler
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "restore-window")]
    fn connect_restore_window<F: Fn(&Self, RestoreReason, &glib::Variant) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn restore_window_trampoline<
            P: IsA<Application>,
            F: Fn(&P, RestoreReason, &glib::Variant) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            reason: ffi::GtkRestoreReason,
            state: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Application::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(reason),
                    &from_glib_borrow(state),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"restore-window".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    restore_window_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when the application is saving global state.
    ///
    /// The handler for this signal should persist any global state of
    /// @application into @dict.
    ///
    /// See [`restore-state`][struct@crate::Application#restore-state] for how to
    /// restore global state, and [`save-state`][struct@crate::ApplicationWindow#save-state]
    /// and [`restore-window`][struct@crate::Application#restore-window] for handling
    /// per-window state.
    /// ## `dict`
    /// a dictionary to populate with application state
    ///
    /// # Returns
    ///
    /// true to stop further handlers from running
    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "save-state")]
    fn connect_save_state<F: Fn(&Self, &glib::VariantDict) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn save_state_trampoline<
            P: IsA<Application>,
            F: Fn(&P, &glib::VariantDict) -> bool + 'static,
        >(
            this: *mut ffi::GtkApplication,
            dict: *mut glib::ffi::GVariantDict,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    Application::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(dict),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"save-state".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    save_state_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a window is added to an application.
    ///
    /// See [`add_window()`][Self::add_window()].
    /// ## `window`
    /// the newly-added 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,
        ) {
            unsafe {
                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 _,
                c"window-added".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    window_added_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted when a window is removed from an application.
    ///
    /// This can happen as a side-effect of the window being destroyed
    /// or explicitly through [`remove_window()`][Self::remove_window()].
    /// ## `window`
    /// the 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,
        ) {
            unsafe {
                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 _,
                c"window-removed".as_ptr(),
                Some(std::mem::transmute::<*const (), 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,
        ) {
            unsafe {
                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 _,
                c"notify::active-window".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_active_window_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "autosave-interval")]
    fn connect_autosave_interval_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_autosave_interval_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::autosave-interval".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_autosave_interval_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,
        ) {
            unsafe {
                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 _,
                c"notify::menubar".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_menubar_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v4_22", deprecated = "Since 4.22")]
    #[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,
        ) {
            unsafe {
                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 _,
                c"notify::register-session".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_register_session_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[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,
        ) {
            unsafe {
                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 _,
                c"notify::screensaver-active".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_screensaver_active_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v4_24")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v4_24")))]
    #[doc(alias = "support-save")]
    fn connect_support_save_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_support_save_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkApplication,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::support-save".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_support_save_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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