gio/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::{
    ffi, ActionGroup, ActionMap, ApplicationCommandLine, ApplicationFlags, Cancellable,
    DBusConnection, File, Notification,
};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// `GApplication` is the core class for application support.
    ///
    /// A `GApplication` is the foundation of an application. It wraps some
    /// low-level platform-specific services and is intended to act as the
    /// foundation for higher-level application classes such as
    /// `GtkApplication` or `MxApplication`. In general, you should not use
    /// this class outside of a higher level framework.
    ///
    /// `GApplication` provides convenient life-cycle management by maintaining
    /// a "use count" for the primary application instance. The use count can
    /// be changed using [`ApplicationExtManual::hold()`][crate::prelude::ApplicationExtManual::hold()] and
    /// [`ApplicationExtManual::release()`][crate::prelude::ApplicationExtManual::release()]. If it drops to zero, the application
    /// exits. Higher-level classes such as `GtkApplication` employ the use count
    /// to ensure that the application stays alive as long as it has any opened
    /// windows.
    ///
    /// Another feature that `GApplication` (optionally) provides is process
    /// uniqueness. Applications can make use of this functionality by
    /// providing a unique application ID. If given, only one application
    /// with this ID can be running at a time per session. The session
    /// concept is platform-dependent, but corresponds roughly to a graphical
    /// desktop login. When your application is launched again, its
    /// arguments are passed through platform communication to the already
    /// running program. The already running instance of the program is
    /// called the "primary instance"; for non-unique applications this is
    /// always the current instance. On Linux, the D-Bus session bus
    /// is used for communication.
    ///
    /// The use of `GApplication` differs from some other commonly-used
    /// uniqueness libraries (such as libunique) in important ways. The
    /// application is not expected to manually register itself and check
    /// if it is the primary instance. Instead, the main() function of a
    /// `GApplication` should do very little more than instantiating the
    /// application instance, possibly connecting signal handlers, then
    /// calling [`ApplicationExtManual::run()`][crate::prelude::ApplicationExtManual::run()]. All checks for uniqueness are done
    /// internally. If the application is the primary instance then the
    /// startup signal is emitted and the mainloop runs. If the application
    /// is not the primary instance then a signal is sent to the primary
    /// instance and [`ApplicationExtManual::run()`][crate::prelude::ApplicationExtManual::run()] promptly returns. See the code
    /// examples below.
    ///
    /// If used, the expected form of an application identifier is the
    /// same as that of a
    /// [D-Bus well-known bus name](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
    /// Examples include: `com.example.MyApp`, `org.example.internal_apps.Calculator`,
    /// `org._7_zip.Archiver`.
    /// For details on valid application identifiers, see [`id_is_valid()`][Self::id_is_valid()].
    ///
    /// On Linux, the application identifier is claimed as a well-known bus name
    /// on the user's session bus. This means that the uniqueness of your
    /// application is scoped to the current session. It also means that your
    /// application may provide additional services (through registration of other
    /// object paths) at that bus name. The registration of these object paths
    /// should be done with the shared GDBus session bus. Note that due to the
    /// internal architecture of GDBus, method calls can be dispatched at any time
    /// (even if a main loop is not running). For this reason, you must ensure that
    /// any object paths that you wish to register are registered before #GApplication
    /// attempts to acquire the bus name of your application (which happens in
    /// [`ApplicationExt::register()`][crate::prelude::ApplicationExt::register()]). Unfortunately, this means that you cannot
    /// use [`is-remote`][struct@crate::Application#is-remote] to decide if you want to register
    /// object paths.
    ///
    /// `GApplication` also implements the [`ActionGroup`][crate::ActionGroup] and [`ActionMap`][crate::ActionMap]
    /// interfaces and lets you easily export actions by adding them with
    /// [`ActionMapExt::add_action()`][crate::prelude::ActionMapExt::add_action()]. When invoking an action by calling
    /// [`ActionGroupExt::activate_action()`][crate::prelude::ActionGroupExt::activate_action()] on the application, it is always
    /// invoked in the primary instance. The actions are also exported on
    /// the session bus, and GIO provides the [`DBusActionGroup`][crate::DBusActionGroup] wrapper to
    /// conveniently access them remotely. GIO provides a [`DBusMenuModel`][crate::DBusMenuModel] wrapper
    /// for remote access to exported [`MenuModel`][crate::MenuModel]s.
    ///
    /// Note: Due to the fact that actions are exported on the session bus,
    /// using `maybe` parameters is not supported, since D-Bus does not support
    /// `maybe` types.
    ///
    /// There is a number of different entry points into a `GApplication`:
    ///
    /// - via 'Activate' (i.e. just starting the application)
    ///
    /// - via 'Open' (i.e. opening some files)
    ///
    /// - by handling a command-line
    ///
    /// - via activating an action
    ///
    /// The [`startup`][struct@crate::Application#startup] signal lets you handle the application
    /// initialization for all of these in a single place.
    ///
    /// Regardless of which of these entry points is used to start the
    /// application, `GApplication` passes some ‘platform data’ from the
    /// launching instance to the primary instance, in the form of a
    /// [`glib::Variant`][struct@crate::glib::Variant] dictionary mapping strings to variants. To use platform
    /// data, override the [`ApplicationImpl::before_emit()`][crate::subclass::prelude::ApplicationImpl::before_emit()] or
    /// [`ApplicationImpl::after_emit()`][crate::subclass::prelude::ApplicationImpl::after_emit()] virtual functions
    /// in your `GApplication` subclass. When dealing with
    /// [`ApplicationCommandLine`][crate::ApplicationCommandLine] objects, the platform data is
    /// directly available via [`ApplicationCommandLineExt::cwd()`][crate::prelude::ApplicationCommandLineExt::cwd()],
    /// [`ApplicationCommandLineExt::environ()`][crate::prelude::ApplicationCommandLineExt::environ()] and
    /// [`ApplicationCommandLineExt::platform_data()`][crate::prelude::ApplicationCommandLineExt::platform_data()].
    ///
    /// As the name indicates, the platform data may vary depending on the
    /// operating system, but it always includes the current directory (key
    /// `cwd`), and optionally the environment (ie the set of environment
    /// variables and their values) of the calling process (key `environ`).
    /// The environment is only added to the platform data if the
    /// `G_APPLICATION_SEND_ENVIRONMENT` flag is set. `GApplication` subclasses
    /// can add their own platform data by overriding the
    /// `vfunc::Gio::Application::add_platform_data` virtual function. For instance,
    /// `GtkApplication` adds startup notification data in this way.
    ///
    /// To parse commandline arguments you may handle the
    /// [`command-line`][struct@crate::Application#command-line] signal or override the
    /// `vfunc::Gio::Application::local_command_line` virtual function, to parse them in
    /// either the primary instance or the local instance, respectively.
    ///
    /// For an example of opening files with a `GApplication`, see
    /// [gapplication-example-open.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-open.c).
    ///
    /// For an example of using actions with `GApplication`, see
    /// [gapplication-example-actions.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-actions.c).
    ///
    /// For an example of using extra D-Bus hooks with `GApplication`, see
    /// [gapplication-example-dbushooks.c](https://gitlab.gnome.org/GNOME/glib/-/blob/HEAD/gio/tests/gapplication-example-dbushooks.c).
    ///
    /// ## Properties
    ///
    ///
    /// #### `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 [`ApplicationExt::register()`][crate::prelude::ApplicationExt::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
    ///
    /// ## Signals
    ///
    ///
    /// #### `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
    /// [`ApplicationFlags::HANDLES_COMMAND_LINE`][crate::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 [`ApplicationFlags::HANDLES_COMMAND_LINE`][crate::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 [`ApplicationFlags::ALLOW_REPLACEMENT`][crate::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><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
    ///
    /// [`ApplicationExt`][trait@crate::prelude::ApplicationExt], [`trait@glib::ObjectExt`], [`ActionGroupExt`][trait@crate::prelude::ActionGroupExt], [`ActionMapExt`][trait@crate::prelude::ActionMapExt], [`ApplicationExtManual`][trait@crate::prelude::ApplicationExtManual], [`ActionMapExtManual`][trait@crate::prelude::ActionMapExtManual]
    #[doc(alias = "GApplication")]
    pub struct Application(Object<ffi::GApplication, ffi::GApplicationClass>) @implements ActionGroup, ActionMap;

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

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

    /// Creates a new #GApplication instance.
    ///
    /// If non-[`None`], the application id must be valid.  See
    /// g_application_id_is_valid().
    ///
    /// If no application ID is given then some features of #GApplication
    /// (most notably application uniqueness) will be disabled.
    /// ## `application_id`
    /// the application id
    /// ## `flags`
    /// the application flags
    ///
    /// # Returns
    ///
    /// a new #GApplication instance
    #[doc(alias = "g_application_new")]
    pub fn new(application_id: Option<&str>, flags: ApplicationFlags) -> Application {
        unsafe {
            from_glib_full(ffi::g_application_new(
                application_id.to_glib_none().0,
                flags.into_glib(),
            ))
        }
    }

    // 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()
    }

    /// Returns the default #GApplication instance for this process.
    ///
    /// Normally there is only one #GApplication per process and it becomes
    /// the default when it is created.  You can exercise more control over
    /// this by using g_application_set_default().
    ///
    /// If there is no default application then [`None`] is returned.
    ///
    /// # Returns
    ///
    /// the default application for this process, or [`None`]
    #[doc(alias = "g_application_get_default")]
    #[doc(alias = "get_default")]
    #[allow(clippy::should_implement_trait)]
    pub fn default() -> Option<Application> {
        unsafe { from_glib_none(ffi::g_application_get_default()) }
    }

    /// Checks if @application_id is a valid application identifier.
    ///
    /// A valid ID is required for calls to g_application_new() and
    /// g_application_set_application_id().
    ///
    /// Application identifiers follow the same format as
    /// [D-Bus well-known bus names](https://dbus.freedesktop.org/doc/dbus-specification.html#message-protocol-names-bus).
    /// For convenience, the restrictions on application identifiers are
    /// reproduced here:
    ///
    /// - Application identifiers are composed of 1 or more elements separated by a
    ///   period (`.`) character. All elements must contain at least one character.
    ///
    /// - Each element must only contain the ASCII characters `[A-Z][a-z][0-9]_-`,
    ///   with `-` discouraged in new application identifiers. Each element must not
    ///   begin with a digit.
    ///
    /// - Application identifiers must contain at least one `.` (period) character
    ///   (and thus at least two elements).
    ///
    /// - Application identifiers must not begin with a `.` (period) character.
    ///
    /// - Application identifiers must not exceed 255 characters.
    ///
    /// Note that the hyphen (`-`) character is allowed in application identifiers,
    /// but is problematic or not allowed in various specifications and APIs that
    /// refer to D-Bus, such as
    /// [Flatpak application IDs](http://docs.flatpak.org/en/latest/introduction.html#identifiers),
    /// the
    /// [`DBusActivatable` interface in the Desktop Entry Specification](https://specifications.freedesktop.org/desktop-entry-spec/desktop-entry-spec-latest.html#dbus),
    /// and the convention that an application's "main" interface and object path
    /// resemble its application identifier and bus name. To avoid situations that
    /// require special-case handling, it is recommended that new application
    /// identifiers consistently replace hyphens with underscores.
    ///
    /// Like D-Bus interface names, application identifiers should start with the
    /// reversed DNS domain name of the author of the interface (in lower-case), and
    /// it is conventional for the rest of the application identifier to consist of
    /// words run together, with initial capital letters.
    ///
    /// As with D-Bus interface names, if the author's DNS domain name contains
    /// hyphen/minus characters they should be replaced by underscores, and if it
    /// contains leading digits they should be escaped by prepending an underscore.
    /// For example, if the owner of 7-zip.org used an application identifier for an
    /// archiving application, it might be named `org._7_zip.Archiver`.
    /// ## `application_id`
    /// a potential application identifier
    ///
    /// # Returns
    ///
    /// [`true`] if @application_id is valid
    #[doc(alias = "g_application_id_is_valid")]
    pub fn id_is_valid(application_id: &str) -> bool {
        unsafe {
            from_glib(ffi::g_application_id_is_valid(
                application_id.to_glib_none().0,
            ))
        }
    }
}

impl Default for Application {
    fn default() -> Self {
        glib::object::Object::new::<Self>()
    }
}

// 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 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: 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 = "v2_80")]
    #[cfg_attr(docsrs, doc(cfg(feature = "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 {
        self.builder.build()
    }
}

/// Trait containing all [`struct@Application`] methods.
///
/// # Implementors
///
/// [`Application`][struct@crate::Application]
pub trait ApplicationExt: IsA<Application> + 'static {
    /// Activates the application.
    ///
    /// In essence, this results in the #GApplication::activate signal being
    /// emitted in the primary instance.
    ///
    /// The application must be registered before calling this function.
    #[doc(alias = "g_application_activate")]
    fn activate(&self) {
        unsafe {
            ffi::g_application_activate(self.as_ref().to_glib_none().0);
        }
    }

    /// Add an option to be handled by @self.
    ///
    /// Calling this function is the equivalent of calling
    /// g_application_add_main_option_entries() with a single #GOptionEntry
    /// that has its arg_data member set to [`None`].
    ///
    /// The parsed arguments will be packed into a #GVariantDict which
    /// is passed to #GApplication::handle-local-options. If
    /// [`ApplicationFlags::HANDLES_COMMAND_LINE`][crate::ApplicationFlags::HANDLES_COMMAND_LINE] is set, then it will also
    /// be sent to the primary instance. See
    /// g_application_add_main_option_entries() for more details.
    ///
    /// See #GOptionEntry for more documentation of the arguments.
    /// ## `long_name`
    /// the long name of an option used to specify it in a commandline
    /// ## `short_name`
    /// the short name of an option
    /// ## `flags`
    /// flags from #GOptionFlags
    /// ## `arg`
    /// the type of the option, as a #GOptionArg
    /// ## `description`
    /// the description for the option in `--help` output
    /// ## `arg_description`
    /// the placeholder to use for the extra argument
    ///    parsed by the option in `--help` output
    #[doc(alias = "g_application_add_main_option")]
    fn add_main_option(
        &self,
        long_name: &str,
        short_name: glib::Char,
        flags: glib::OptionFlags,
        arg: glib::OptionArg,
        description: &str,
        arg_description: Option<&str>,
    ) {
        unsafe {
            ffi::g_application_add_main_option(
                self.as_ref().to_glib_none().0,
                long_name.to_glib_none().0,
                short_name.into_glib(),
                flags.into_glib(),
                arg.into_glib(),
                description.to_glib_none().0,
                arg_description.to_glib_none().0,
            );
        }
    }

    //#[doc(alias = "g_application_add_main_option_entries")]
    //fn add_main_option_entries(&self, entries: /*Ignored*/&[glib::OptionEntry]) {
    //    unsafe { TODO: call ffi:g_application_add_main_option_entries() }
    //}

    //#[doc(alias = "g_application_add_option_group")]
    //fn add_option_group(&self, group: /*Ignored*/glib::OptionGroup) {
    //    unsafe { TODO: call ffi:g_application_add_option_group() }
    //}

    /// Marks @self as busy (see g_application_mark_busy()) while
    /// @property on @object is [`true`].
    ///
    /// The binding holds a reference to @self while it is active, but
    /// not to @object. Instead, the binding is destroyed when @object is
    /// finalized.
    /// ## `object`
    /// a #GObject
    /// ## `property`
    /// the name of a boolean property of @object
    #[doc(alias = "g_application_bind_busy_property")]
    fn bind_busy_property(&self, object: &impl IsA<glib::Object>, property: &str) {
        unsafe {
            ffi::g_application_bind_busy_property(
                self.as_ref().to_glib_none().0,
                object.as_ref().to_glib_none().0,
                property.to_glib_none().0,
            );
        }
    }

    /// Gets the unique identifier for @self.
    ///
    /// # Returns
    ///
    /// the identifier for @self, owned by @self
    #[doc(alias = "g_application_get_application_id")]
    #[doc(alias = "get_application_id")]
    #[doc(alias = "application-id")]
    fn application_id(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_application_get_application_id(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the #GDBusConnection being used by the application, or [`None`].
    ///
    /// If #GApplication is using its D-Bus backend then this function will
    /// return the #GDBusConnection being used for uniqueness and
    /// communication with the desktop environment and other instances of the
    /// application.
    ///
    /// If #GApplication is not using D-Bus then this function will return
    /// [`None`].  This includes the situation where the D-Bus backend would
    /// normally be in use but we were unable to connect to the bus.
    ///
    /// This function must not be called before the application has been
    /// registered.  See g_application_get_is_registered().
    ///
    /// # Returns
    ///
    /// a #GDBusConnection, or [`None`]
    #[doc(alias = "g_application_get_dbus_connection")]
    #[doc(alias = "get_dbus_connection")]
    fn dbus_connection(&self) -> Option<DBusConnection> {
        unsafe {
            from_glib_none(ffi::g_application_get_dbus_connection(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the D-Bus object path being used by the application, or [`None`].
    ///
    /// If #GApplication is using its D-Bus backend then this function will
    /// return the D-Bus object path that #GApplication is using.  If the
    /// application is the primary instance then there is an object published
    /// at this path.  If the application is not the primary instance then
    /// the result of this function is undefined.
    ///
    /// If #GApplication is not using D-Bus then this function will return
    /// [`None`].  This includes the situation where the D-Bus backend would
    /// normally be in use but we were unable to connect to the bus.
    ///
    /// This function must not be called before the application has been
    /// registered.  See g_application_get_is_registered().
    ///
    /// # Returns
    ///
    /// the object path, or [`None`]
    #[doc(alias = "g_application_get_dbus_object_path")]
    #[doc(alias = "get_dbus_object_path")]
    fn dbus_object_path(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_application_get_dbus_object_path(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the flags for @self.
    ///
    /// See #GApplicationFlags.
    ///
    /// # Returns
    ///
    /// the flags for @self
    #[doc(alias = "g_application_get_flags")]
    #[doc(alias = "get_flags")]
    fn flags(&self) -> ApplicationFlags {
        unsafe { from_glib(ffi::g_application_get_flags(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the current inactivity timeout for the application.
    ///
    /// This is the amount of time (in milliseconds) after the last call to
    /// g_application_release() before the application stops running.
    ///
    /// # Returns
    ///
    /// the timeout, in milliseconds
    #[doc(alias = "g_application_get_inactivity_timeout")]
    #[doc(alias = "get_inactivity_timeout")]
    #[doc(alias = "inactivity-timeout")]
    fn inactivity_timeout(&self) -> u32 {
        unsafe { ffi::g_application_get_inactivity_timeout(self.as_ref().to_glib_none().0) }
    }

    /// Gets the application's current busy state, as set through
    /// g_application_mark_busy() or g_application_bind_busy_property().
    ///
    /// # Returns
    ///
    /// [`true`] if @self is currently marked as busy
    #[doc(alias = "g_application_get_is_busy")]
    #[doc(alias = "get_is_busy")]
    #[doc(alias = "is-busy")]
    fn is_busy(&self) -> bool {
        unsafe {
            from_glib(ffi::g_application_get_is_busy(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if @self is registered.
    ///
    /// An application is registered if g_application_register() has been
    /// successfully called.
    ///
    /// # Returns
    ///
    /// [`true`] if @self is registered
    #[doc(alias = "g_application_get_is_registered")]
    #[doc(alias = "get_is_registered")]
    #[doc(alias = "is-registered")]
    fn is_registered(&self) -> bool {
        unsafe {
            from_glib(ffi::g_application_get_is_registered(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if @self is remote.
    ///
    /// If @self is remote then it means that another instance of
    /// application already exists (the 'primary' instance).  Calls to
    /// perform actions on @self will result in the actions being
    /// performed by the primary instance.
    ///
    /// The value of this property cannot be accessed before
    /// g_application_register() has been called.  See
    /// g_application_get_is_registered().
    ///
    /// # Returns
    ///
    /// [`true`] if @self is remote
    #[doc(alias = "g_application_get_is_remote")]
    #[doc(alias = "get_is_remote")]
    #[doc(alias = "is-remote")]
    fn is_remote(&self) -> bool {
        unsafe {
            from_glib(ffi::g_application_get_is_remote(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the resource base path of @self.
    ///
    /// See g_application_set_resource_base_path() for more information.
    ///
    /// # Returns
    ///
    /// the base resource path, if one is set
    #[doc(alias = "g_application_get_resource_base_path")]
    #[doc(alias = "get_resource_base_path")]
    #[doc(alias = "resource-base-path")]
    fn resource_base_path(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_application_get_resource_base_path(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the version of @self.
    ///
    /// # Returns
    ///
    /// the version of @self
    #[cfg(feature = "v2_80")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
    #[doc(alias = "g_application_get_version")]
    #[doc(alias = "get_version")]
    fn version(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_application_get_version(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Opens the given files.
    ///
    /// In essence, this results in the #GApplication::open signal being emitted
    /// in the primary instance.
    ///
    /// @n_files must be greater than zero.
    ///
    /// @hint is simply passed through to the ::open signal.  It is
    /// intended to be used by applications that have multiple modes for
    /// opening files (eg: "view" vs "edit", etc).  Unless you have a need
    /// for this functionality, you should use "".
    ///
    /// The application must be registered before calling this function
    /// and it must have the [`ApplicationFlags::HANDLES_OPEN`][crate::ApplicationFlags::HANDLES_OPEN] flag set.
    /// ## `files`
    /// an array of #GFiles to open
    /// ## `hint`
    /// a hint (or ""), but never [`None`]
    #[doc(alias = "g_application_open")]
    fn open(&self, files: &[File], hint: &str) {
        let n_files = files.len() as _;
        unsafe {
            ffi::g_application_open(
                self.as_ref().to_glib_none().0,
                files.to_glib_none().0,
                n_files,
                hint.to_glib_none().0,
            );
        }
    }

    /// Immediately quits the application.
    ///
    /// Upon return to the mainloop, g_application_run() will return,
    /// calling only the 'shutdown' function before doing so.
    ///
    /// The hold count is ignored.
    /// Take care if your code has called g_application_hold() on the application and
    /// is therefore still expecting it to exist.
    /// (Note that you may have called g_application_hold() indirectly, for example
    /// through gtk_application_add_window().)
    ///
    /// The result of calling g_application_run() again after it returns is
    /// unspecified.
    #[doc(alias = "g_application_quit")]
    fn quit(&self) {
        unsafe {
            ffi::g_application_quit(self.as_ref().to_glib_none().0);
        }
    }

    /// Attempts registration of the application.
    ///
    /// This is the point at which the application discovers if it is the
    /// primary instance or merely acting as a remote for an already-existing
    /// primary instance.  This is implemented by attempting to acquire the
    /// application identifier as a unique bus name on the session bus using
    /// GDBus.
    ///
    /// If there is no application ID or if [`ApplicationFlags::NON_UNIQUE`][crate::ApplicationFlags::NON_UNIQUE] was
    /// given, then this process will always become the primary instance.
    ///
    /// Due to the internal architecture of GDBus, method calls can be
    /// dispatched at any time (even if a main loop is not running).  For
    /// this reason, you must ensure that any object paths that you wish to
    /// register are registered before calling this function.
    ///
    /// If the application has already been registered then [`true`] is
    /// returned with no work performed.
    ///
    /// The #GApplication::startup signal is emitted if registration succeeds
    /// and @self is the primary instance (including the non-unique
    /// case).
    ///
    /// In the event of an error (such as @cancellable being cancelled, or a
    /// failure to connect to the session bus), [`false`] is returned and @error
    /// is set appropriately.
    ///
    /// Note: the return value of this function is not an indicator that this
    /// instance is or is not the primary instance of the application.  See
    /// g_application_get_is_remote() for that.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] if registration succeeded
    #[doc(alias = "g_application_register")]
    fn register(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_application_register(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sends a notification on behalf of @self to the desktop shell.
    /// There is no guarantee that the notification is displayed immediately,
    /// or even at all.
    ///
    /// Notifications may persist after the application exits. It will be
    /// D-Bus-activated when the notification or one of its actions is
    /// activated.
    ///
    /// Modifying @notification after this call has no effect. However, the
    /// object can be reused for a later call to this function.
    ///
    /// @id may be any string that uniquely identifies the event for the
    /// application. It does not need to be in any special format. For
    /// example, "new-message" might be appropriate for a notification about
    /// new messages.
    ///
    /// If a previous notification was sent with the same @id, it will be
    /// replaced with @notification and shown again as if it was a new
    /// notification. This works even for notifications sent from a previous
    /// execution of the application, as long as @id is the same string.
    ///
    /// @id may be `NULL`, but it is impossible to replace or withdraw
    /// notifications without an id.
    ///
    /// If @notification is no longer relevant, it can be withdrawn with
    /// [`withdraw_notification()`][Self::withdraw_notification()].
    ///
    /// It is an error to call this function if @self has no
    /// application ID.
    /// ## `id`
    /// id of the notification, or [`None`]
    /// ## `notification`
    /// the #GNotification to send
    #[doc(alias = "g_application_send_notification")]
    fn send_notification(&self, id: Option<&str>, notification: &Notification) {
        unsafe {
            ffi::g_application_send_notification(
                self.as_ref().to_glib_none().0,
                id.to_glib_none().0,
                notification.to_glib_none().0,
            );
        }
    }

    /// Sets the unique identifier for @self.
    ///
    /// The application id can only be modified if @self has not yet
    /// been registered.
    ///
    /// If non-[`None`], the application id must be valid.  See
    /// g_application_id_is_valid().
    /// ## `application_id`
    /// the identifier for @self
    #[doc(alias = "g_application_set_application_id")]
    #[doc(alias = "application-id")]
    fn set_application_id(&self, application_id: Option<&str>) {
        unsafe {
            ffi::g_application_set_application_id(
                self.as_ref().to_glib_none().0,
                application_id.to_glib_none().0,
            );
        }
    }

    /// Sets or unsets the default application for the process, as returned
    /// by g_application_get_default().
    ///
    /// This function does not take its own reference on @self.  If
    /// @self is destroyed then the default application will revert
    /// back to [`None`].
    #[doc(alias = "g_application_set_default")]
    fn set_default(&self) {
        unsafe {
            ffi::g_application_set_default(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets the flags for @self.
    ///
    /// The flags can only be modified if @self has not yet been
    /// registered.
    ///
    /// See #GApplicationFlags.
    /// ## `flags`
    /// the flags for @self
    #[doc(alias = "g_application_set_flags")]
    #[doc(alias = "flags")]
    fn set_flags(&self, flags: ApplicationFlags) {
        unsafe {
            ffi::g_application_set_flags(self.as_ref().to_glib_none().0, flags.into_glib());
        }
    }

    /// Sets the current inactivity timeout for the application.
    ///
    /// This is the amount of time (in milliseconds) after the last call to
    /// g_application_release() before the application stops running.
    ///
    /// This call has no side effects of its own.  The value set here is only
    /// used for next time g_application_release() drops the use count to
    /// zero.  Any timeouts currently in progress are not impacted.
    /// ## `inactivity_timeout`
    /// the timeout, in milliseconds
    #[doc(alias = "g_application_set_inactivity_timeout")]
    #[doc(alias = "inactivity-timeout")]
    fn set_inactivity_timeout(&self, inactivity_timeout: u32) {
        unsafe {
            ffi::g_application_set_inactivity_timeout(
                self.as_ref().to_glib_none().0,
                inactivity_timeout,
            );
        }
    }

    /// Adds a description to the @self option context.
    ///
    /// See g_option_context_set_description() for more information.
    /// ## `description`
    /// a string to be shown in `--help` output
    ///  after the list of options, or [`None`]
    #[doc(alias = "g_application_set_option_context_description")]
    fn set_option_context_description(&self, description: Option<&str>) {
        unsafe {
            ffi::g_application_set_option_context_description(
                self.as_ref().to_glib_none().0,
                description.to_glib_none().0,
            );
        }
    }

    /// Sets the parameter string to be used by the commandline handling of @self.
    ///
    /// This function registers the argument to be passed to g_option_context_new()
    /// when the internal #GOptionContext of @self is created.
    ///
    /// See g_option_context_new() for more information about @parameter_string.
    /// ## `parameter_string`
    /// a string which is displayed
    ///   in the first line of `--help` output, after the usage summary `programname [OPTION...]`.
    #[doc(alias = "g_application_set_option_context_parameter_string")]
    fn set_option_context_parameter_string(&self, parameter_string: Option<&str>) {
        unsafe {
            ffi::g_application_set_option_context_parameter_string(
                self.as_ref().to_glib_none().0,
                parameter_string.to_glib_none().0,
            );
        }
    }

    /// Adds a summary to the @self option context.
    ///
    /// See g_option_context_set_summary() for more information.
    /// ## `summary`
    /// a string to be shown in `--help` output
    ///  before the list of options, or [`None`]
    #[doc(alias = "g_application_set_option_context_summary")]
    fn set_option_context_summary(&self, summary: Option<&str>) {
        unsafe {
            ffi::g_application_set_option_context_summary(
                self.as_ref().to_glib_none().0,
                summary.to_glib_none().0,
            );
        }
    }

    /// Sets (or unsets) the base resource path of @self.
    ///
    /// The path is used to automatically load various [application
    /// resources][gresource] such as menu layouts and action descriptions.
    /// The various types of resources will be found at fixed names relative
    /// to the given base path.
    ///
    /// By default, the resource base path is determined from the application
    /// ID by prefixing '/' and replacing each '.' with '/'.  This is done at
    /// the time that the #GApplication object is constructed.  Changes to
    /// the application ID after that point will not have an impact on the
    /// resource base path.
    ///
    /// As an example, if the application has an ID of "org.example.app" then
    /// the default resource base path will be "/org/example/app".  If this
    /// is a #GtkApplication (and you have not manually changed the path)
    /// then Gtk will then search for the menus of the application at
    /// "/org/example/app/gtk/menus.ui".
    ///
    /// See #GResource for more information about adding resources to your
    /// application.
    ///
    /// You can disable automatic resource loading functionality by setting
    /// the path to [`None`].
    ///
    /// Changing the resource base path once the application is running is
    /// not recommended.  The point at which the resource path is consulted
    /// for forming paths for various purposes is unspecified.  When writing
    /// a sub-class of #GApplication you should either set the
    /// #GApplication:resource-base-path property at construction time, or call
    /// this function during the instance initialization. Alternatively, you
    /// can call this function in the #GApplicationClass.startup virtual function,
    /// before chaining up to the parent implementation.
    /// ## `resource_path`
    /// the resource path to use
    #[doc(alias = "g_application_set_resource_base_path")]
    #[doc(alias = "resource-base-path")]
    fn set_resource_base_path(&self, resource_path: Option<&str>) {
        unsafe {
            ffi::g_application_set_resource_base_path(
                self.as_ref().to_glib_none().0,
                resource_path.to_glib_none().0,
            );
        }
    }

    /// Sets the version number of @self. This will be used to implement
    /// a `--version` command line argument
    ///
    /// The application version can only be modified if @self has not yet
    /// been registered.
    /// ## `version`
    /// the version of @self
    #[cfg(feature = "v2_80")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_80")))]
    #[doc(alias = "g_application_set_version")]
    #[doc(alias = "version")]
    fn set_version(&self, version: &str) {
        unsafe {
            ffi::g_application_set_version(
                self.as_ref().to_glib_none().0,
                version.to_glib_none().0,
            );
        }
    }

    /// Destroys a binding between @property and the busy state of
    /// @self that was previously created with
    /// g_application_bind_busy_property().
    /// ## `object`
    /// a #GObject
    /// ## `property`
    /// the name of a boolean property of @object
    #[doc(alias = "g_application_unbind_busy_property")]
    fn unbind_busy_property(&self, object: &impl IsA<glib::Object>, property: &str) {
        unsafe {
            ffi::g_application_unbind_busy_property(
                self.as_ref().to_glib_none().0,
                object.as_ref().to_glib_none().0,
                property.to_glib_none().0,
            );
        }
    }

    /// Withdraws a notification that was sent with
    /// g_application_send_notification().
    ///
    /// This call does nothing if a notification with @id doesn't exist or
    /// the notification was never sent.
    ///
    /// This function works even for notifications sent in previous
    /// executions of this application, as long @id is the same as it was for
    /// the sent notification.
    ///
    /// Note that notifications are dismissed when the user clicks on one
    /// of the buttons in a notification or triggers its default action, so
    /// there is no need to explicitly withdraw the notification in that case.
    /// ## `id`
    /// id of a previously sent notification
    #[doc(alias = "g_application_withdraw_notification")]
    fn withdraw_notification(&self, id: &str) {
        unsafe {
            ffi::g_application_withdraw_notification(
                self.as_ref().to_glib_none().0,
                id.to_glib_none().0,
            );
        }
    }

    /// The ::activate signal is emitted on the primary instance when an
    /// activation occurs. See g_application_activate().
    #[doc(alias = "activate")]
    fn connect_activate<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn activate_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GApplication,
            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 _,
                c"activate".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    activate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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.
    /// ## `command_line`
    /// a #GApplicationCommandLine representing the
    ///     passed commandline
    ///
    /// # Returns
    ///
    /// An integer that is set as the exit status for the calling
    ///   process. See g_application_command_line_set_exit_status().
    #[doc(alias = "command-line")]
    fn connect_command_line<F: Fn(&Self, &ApplicationCommandLine) -> i32 + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn command_line_trampoline<
            P: IsA<Application>,
            F: Fn(&P, &ApplicationCommandLine) -> i32 + 'static,
        >(
            this: *mut ffi::GApplication,
            command_line: *mut ffi::GApplicationCommandLine,
            f: glib::ffi::gpointer,
        ) -> std::ffi::c_int {
            let f: &F = &*(f as *const F);
            f(
                Application::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(command_line),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"command-line".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    command_line_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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
    /// [`ApplicationFlags::HANDLES_COMMAND_LINE`][crate::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 [`ApplicationFlags::HANDLES_COMMAND_LINE`][crate::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.
    /// ## `options`
    /// the options dictionary
    ///
    /// # Returns
    ///
    /// an exit code. If you have handled your options and want
    /// to exit the process, return a non-negative option, 0 for success,
    /// and a positive value for failure. To continue, return -1 to let
    /// the default option processing continue.
    #[doc(alias = "handle-local-options")]
    fn connect_handle_local_options<F: Fn(&Self, &glib::VariantDict) -> i32 + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn handle_local_options_trampoline<
            P: IsA<Application>,
            F: Fn(&P, &glib::VariantDict) -> i32 + 'static,
        >(
            this: *mut ffi::GApplication,
            options: *mut glib::ffi::GVariantDict,
            f: glib::ffi::gpointer,
        ) -> std::ffi::c_int {
            let f: &F = &*(f as *const F);
            f(
                Application::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(options),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"handle-local-options".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    handle_local_options_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// 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 [`ApplicationFlags::ALLOW_REPLACEMENT`][crate::ApplicationFlags::ALLOW_REPLACEMENT] flag.
    ///
    /// The default handler for this signal calls g_application_quit().
    ///
    /// # Returns
    ///
    /// [`true`] if the signal has been handled
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "name-lost")]
    fn connect_name_lost<F: Fn(&Self) -> bool + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn name_lost_trampoline<
            P: IsA<Application>,
            F: Fn(&P) -> bool + 'static,
        >(
            this: *mut ffi::GApplication,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(Application::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"name-lost".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    name_lost_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::shutdown signal is emitted only on the registered primary instance
    /// immediately after the main loop terminates.
    #[doc(alias = "shutdown")]
    fn connect_shutdown<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn shutdown_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GApplication,
            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 _,
                c"shutdown".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    shutdown_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// The ::startup signal is emitted on the primary instance immediately
    /// after registration. See g_application_register().
    #[doc(alias = "startup")]
    fn connect_startup<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn startup_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GApplication,
            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 _,
                c"startup".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    startup_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "application-id")]
    fn connect_application_id_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_application_id_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::application-id".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_application_id_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "flags")]
    fn connect_flags_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flags_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::flags".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_flags_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "inactivity-timeout")]
    fn connect_inactivity_timeout_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_inactivity_timeout_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::inactivity-timeout".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_inactivity_timeout_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-busy")]
    fn connect_is_busy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_busy_trampoline<P: IsA<Application>, F: Fn(&P) + 'static>(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::is-busy".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_busy_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-registered")]
    fn connect_is_registered_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_registered_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::is-registered".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_registered_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-remote")]
    fn connect_is_remote_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_remote_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::is-remote".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_remote_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "resource-base-path")]
    fn connect_resource_base_path_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_resource_base_path_trampoline<
            P: IsA<Application>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GApplication,
            _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 _,
                c"notify::resource-base-path".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_resource_base_path_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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