// 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::AppInfo;
use crate::File;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// Integrating the launch with the launching application. This is used to
    /// handle for instance startup notification and launching the new application
    /// on the same screen as the launching window.
    ///
    /// # Implements
    ///
    /// [`AppLaunchContextExt`][trait@crate::prelude::AppLaunchContextExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "GAppLaunchContext")]
    pub struct AppLaunchContext(Object<ffi::GAppLaunchContext, ffi::GAppLaunchContextClass>);

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

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

    /// Creates a new application launch context. This is not normally used,
    /// instead you instantiate a subclass of this, such as `GdkAppLaunchContext`.
    ///
    /// # Returns
    ///
    /// a [`AppLaunchContext`][crate::AppLaunchContext].
    #[doc(alias = "g_app_launch_context_new")]
    pub fn new() -> AppLaunchContext {
        unsafe { from_glib_full(ffi::g_app_launch_context_new()) }
    }
}

impl Default for AppLaunchContext {
    fn default() -> Self {
        Self::new()
    }
}

/// Trait containing all [`struct@AppLaunchContext`] methods.
///
/// # Implementors
///
/// [`AppLaunchContext`][struct@crate::AppLaunchContext]
pub trait AppLaunchContextExt: 'static {
    /// Gets the display string for the `self`. This is used to ensure new
    /// applications are started on the same display as the launching
    /// application, by setting the `DISPLAY` environment variable.
    /// ## `info`
    /// a [`AppInfo`][crate::AppInfo]
    /// ## `files`
    /// a `GList` of [`File`][crate::File] objects
    ///
    /// # Returns
    ///
    /// a display string for the display.
    #[doc(alias = "g_app_launch_context_get_display")]
    #[doc(alias = "get_display")]
    fn display(&self, info: &impl IsA<AppInfo>, files: &[File]) -> Option<glib::GString>;

    /// Gets the complete environment variable list to be passed to
    /// the child process when `self` is used to launch an application.
    /// This is a [`None`]-terminated array of strings, where each string has
    /// the form `KEY=VALUE`.
    ///
    /// # Returns
    ///
    ///
    ///  the child's environment
    #[doc(alias = "g_app_launch_context_get_environment")]
    #[doc(alias = "get_environment")]
    fn environment(&self) -> Vec<std::ffi::OsString>;

    /// Initiates startup notification for the application and returns the
    /// `DESKTOP_STARTUP_ID` for the launched operation, if supported.
    ///
    /// Startup notification IDs are defined in the
    /// [FreeDesktop.Org Startup Notifications standard](http://standards.freedesktop.org/startup-notification-spec/startup-notification-latest.txt).
    /// ## `info`
    /// a [`AppInfo`][crate::AppInfo]
    /// ## `files`
    /// a `GList` of of [`File`][crate::File] objects
    ///
    /// # Returns
    ///
    /// a startup notification ID for the application, or [`None`] if
    ///  not supported.
    #[doc(alias = "g_app_launch_context_get_startup_notify_id")]
    #[doc(alias = "get_startup_notify_id")]
    fn startup_notify_id(&self, info: &impl IsA<AppInfo>, files: &[File]) -> Option<glib::GString>;

    /// Called when an application has failed to launch, so that it can cancel
    /// the application startup notification started in [`startup_notify_id()`][Self::startup_notify_id()].
    /// ## `startup_notify_id`
    /// the startup notification id that was returned by [`startup_notify_id()`][Self::startup_notify_id()].
    #[doc(alias = "g_app_launch_context_launch_failed")]
    fn launch_failed(&self, startup_notify_id: &str);

    /// Arranges for `variable` to be set to `value` in the child's
    /// environment when `self` is used to launch an application.
    /// ## `variable`
    /// the environment variable to set
    /// ## `value`
    /// the value for to set the variable to.
    #[doc(alias = "g_app_launch_context_setenv")]
    fn setenv(&self, variable: impl AsRef<std::ffi::OsStr>, value: impl AsRef<std::ffi::OsStr>);

    /// Arranges for `variable` to be unset in the child's environment
    /// when `self` is used to launch an application.
    /// ## `variable`
    /// the environment variable to remove
    #[doc(alias = "g_app_launch_context_unsetenv")]
    fn unsetenv(&self, variable: impl AsRef<std::ffi::OsStr>);

    /// The `signal::AppLaunchContext::launch-failed` signal is emitted when a [`AppInfo`][crate::AppInfo] launch
    /// fails. The startup notification id is provided, so that the launcher
    /// can cancel the startup notification.
    ///
    /// Because a launch operation may involve spawning multiple instances of the
    /// target application, you should expect this signal to be emitted multiple
    /// times, one for each spawned instance.
    /// ## `startup_notify_id`
    /// the startup notification id for the failed launch
    #[doc(alias = "launch-failed")]
    fn connect_launch_failed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId;

    /// The `signal::AppLaunchContext::launch-started` signal is emitted when a [`AppInfo`][crate::AppInfo] is
    /// about to be launched. If non-null the `platform_data` is an
    /// GVariant dictionary mapping strings to variants (ie `a{sv}`), which
    /// contains additional, platform-specific data about this launch. On
    /// UNIX, at least the `startup-notification-id` keys will be
    /// present.
    ///
    /// The value of the `startup-notification-id` key (type `s`) is a startup
    /// notification ID corresponding to the format from the [startup-notification
    /// specification](https://specifications.freedesktop.org/startup-notification-spec/startup-notification-0.1.txt).
    /// It allows tracking the progress of the launchee through startup.
    ///
    /// It is guaranteed that this signal is followed by either a `signal::AppLaunchContext::launched` or
    /// `signal::AppLaunchContext::launch-failed` signal.
    ///
    /// Because a launch operation may involve spawning multiple instances of the
    /// target application, you should expect this signal to be emitted multiple
    /// times, one for each spawned instance.
    /// ## `info`
    /// the [`AppInfo`][crate::AppInfo] that is about to be launched
    /// ## `platform_data`
    /// additional platform-specific data for this launch
    #[cfg(any(feature = "v2_72", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_72")))]
    #[doc(alias = "launch-started")]
    fn connect_launch_started<F: Fn(&Self, &AppInfo, Option<&glib::Variant>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    /// The `signal::AppLaunchContext::launched` signal is emitted when a [`AppInfo`][crate::AppInfo] is successfully
    /// launched.
    ///
    /// Because a launch operation may involve spawning multiple instances of the
    /// target application, you should expect this signal to be emitted multiple
    /// times, one time for each spawned instance.
    ///
    /// The `platform_data` is an GVariant dictionary mapping
    /// strings to variants (ie `a{sv}`), which contains additional,
    /// platform-specific data about this launch. On UNIX, at least the
    /// `pid` and `startup-notification-id` keys will be present.
    ///
    /// Since 2.72 the `pid` may be 0 if the process id wasn't known (for
    /// example if the process was launched via D-Bus). The `pid` may not be
    /// set at all in subsequent releases.
    ///
    /// On Windows, `pid` is guaranteed to be valid only for the duration of the
    /// `signal::AppLaunchContext::launched` signal emission; after the signal is emitted,
    /// GLib will call `g_spawn_close_pid()`. If you need to keep the `GPid` after the
    /// signal has been emitted, then you can duplicate `pid` using `DuplicateHandle()`.
    /// ## `info`
    /// the [`AppInfo`][crate::AppInfo] that was just launched
    /// ## `platform_data`
    /// additional platform-specific data for this launch
    #[doc(alias = "launched")]
    fn connect_launched<F: Fn(&Self, &AppInfo, &glib::Variant) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;
}

impl<O: IsA<AppLaunchContext>> AppLaunchContextExt for O {
    fn display(&self, info: &impl IsA<AppInfo>, files: &[File]) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::g_app_launch_context_get_display(
                self.as_ref().to_glib_none().0,
                info.as_ref().to_glib_none().0,
                files.to_glib_none().0,
            ))
        }
    }

    fn environment(&self) -> Vec<std::ffi::OsString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_app_launch_context_get_environment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn startup_notify_id(&self, info: &impl IsA<AppInfo>, files: &[File]) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::g_app_launch_context_get_startup_notify_id(
                self.as_ref().to_glib_none().0,
                info.as_ref().to_glib_none().0,
                files.to_glib_none().0,
            ))
        }
    }

    fn launch_failed(&self, startup_notify_id: &str) {
        unsafe {
            ffi::g_app_launch_context_launch_failed(
                self.as_ref().to_glib_none().0,
                startup_notify_id.to_glib_none().0,
            );
        }
    }

    fn setenv(&self, variable: impl AsRef<std::ffi::OsStr>, value: impl AsRef<std::ffi::OsStr>) {
        unsafe {
            ffi::g_app_launch_context_setenv(
                self.as_ref().to_glib_none().0,
                variable.as_ref().to_glib_none().0,
                value.as_ref().to_glib_none().0,
            );
        }
    }

    fn unsetenv(&self, variable: impl AsRef<std::ffi::OsStr>) {
        unsafe {
            ffi::g_app_launch_context_unsetenv(
                self.as_ref().to_glib_none().0,
                variable.as_ref().to_glib_none().0,
            );
        }
    }

    fn connect_launch_failed<F: Fn(&Self, &str) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn launch_failed_trampoline<
            P: IsA<AppLaunchContext>,
            F: Fn(&P, &str) + 'static,
        >(
            this: *mut ffi::GAppLaunchContext,
            startup_notify_id: *mut libc::c_char,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                AppLaunchContext::from_glib_borrow(this).unsafe_cast_ref(),
                &glib::GString::from_glib_borrow(startup_notify_id),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"launch-failed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    launch_failed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(any(feature = "v2_72", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_72")))]
    fn connect_launch_started<F: Fn(&Self, &AppInfo, Option<&glib::Variant>) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn launch_started_trampoline<
            P: IsA<AppLaunchContext>,
            F: Fn(&P, &AppInfo, Option<&glib::Variant>) + 'static,
        >(
            this: *mut ffi::GAppLaunchContext,
            info: *mut ffi::GAppInfo,
            platform_data: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                AppLaunchContext::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(info),
                Option::<glib::Variant>::from_glib_borrow(platform_data)
                    .as_ref()
                    .as_ref(),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"launch-started\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    launch_started_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_launched<F: Fn(&Self, &AppInfo, &glib::Variant) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn launched_trampoline<
            P: IsA<AppLaunchContext>,
            F: Fn(&P, &AppInfo, &glib::Variant) + 'static,
        >(
            this: *mut ffi::GAppLaunchContext,
            info: *mut ffi::GAppInfo,
            platform_data: *mut glib::ffi::GVariant,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(
                AppLaunchContext::from_glib_borrow(this).unsafe_cast_ref(),
                &from_glib_borrow(info),
                &from_glib_borrow(platform_data),
            )
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"launched\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    launched_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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