// 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::{AppInfoCreateFlags, AppLaunchContext, AsyncResult, Cancellable, File, Icon};
use glib::{prelude::*, translate::*};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    /// Information about an installed application and methods to launch
    /// it (with file arguments).
    ///
    /// `GAppInfo` and `GAppLaunchContext` are used for describing and launching
    /// applications installed on the system.
    ///
    /// As of GLib 2.20, URIs will always be converted to POSIX paths
    /// (using [`FileExt::path()`][crate::prelude::FileExt::path()]) when using [`AppInfoExt::launch()`][crate::prelude::AppInfoExt::launch()]
    /// even if the application requested an URI and not a POSIX path. For example
    /// for a desktop-file based application with Exec key `totem
    /// `U`` and a single URI, `sftp://foo/file.avi`, then
    /// `/home/user/.gvfs/sftp on foo/file.avi` will be passed. This will
    /// only work if a set of suitable GIO extensions (such as GVfs 2.26
    /// compiled with FUSE support), is available and operational; if this
    /// is not the case, the URI will be passed unmodified to the application.
    /// Some URIs, such as `mailto:`, of course cannot be mapped to a POSIX
    /// path (in GVfs there's no FUSE mount for it); such URIs will be
    /// passed unmodified to the application.
    ///
    /// Specifically for GVfs 2.26 and later, the POSIX URI will be mapped
    /// back to the GIO URI in the [`File`][crate::File] constructors (since GVfs
    /// implements the GVfs extension point). As such, if the application
    /// needs to examine the URI, it needs to use [`FileExt::uri()`][crate::prelude::FileExt::uri()]
    /// or similar on [`File`][crate::File]. In other words, an application cannot
    /// assume that the URI passed to e.g. [`File::for_commandline_arg()`][crate::File::for_commandline_arg()]
    /// is equal to the result of [`FileExt::uri()`][crate::prelude::FileExt::uri()]. The following snippet
    /// illustrates this:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// GFile *f;
    /// char *uri;
    ///
    /// file = g_file_new_for_commandline_arg (uri_from_commandline);
    ///
    /// uri = g_file_get_uri (file);
    /// strcmp (uri, uri_from_commandline) == 0;
    /// g_free (uri);
    ///
    /// if (g_file_has_uri_scheme (file, "cdda"))
    ///   {
    ///     // do something special with uri
    ///   }
    /// g_object_unref (file);
    /// ```
    ///
    /// This code will work when both `cdda://sr0/Track 1.wav` and
    /// `/home/user/.gvfs/cdda on sr0/Track 1.wav` is passed to the
    /// application. It should be noted that it's generally not safe
    /// for applications to rely on the format of a particular URIs.
    /// Different launcher applications (e.g. file managers) may have
    /// different ideas of what a given URI means.
    ///
    /// # Implements
    ///
    /// [`AppInfoExt`][trait@crate::prelude::AppInfoExt], [`AppInfoExtManual`][trait@crate::prelude::AppInfoExtManual]
    #[doc(alias = "GAppInfo")]
    pub struct AppInfo(Interface<ffi::GAppInfo, ffi::GAppInfoIface>);

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

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

    /// Creates a new #GAppInfo from the given information.
    ///
    /// Note that for @commandline, the quoting rules of the Exec key of the
    /// [freedesktop.org Desktop Entry Specification](http://freedesktop.org/Standards/desktop-entry-spec)
    /// are applied. For example, if the @commandline contains
    /// percent-encoded URIs, the percent-character must be doubled in order to prevent it from
    /// being swallowed by Exec key unquoting. See the specification for exact quoting rules.
    /// ## `commandline`
    /// the commandline to use
    /// ## `application_name`
    /// the application name, or [`None`] to use @commandline
    /// ## `flags`
    /// flags that can specify details of the created #GAppInfo
    ///
    /// # Returns
    ///
    /// new #GAppInfo for given command.
    #[doc(alias = "g_app_info_create_from_commandline")]
    pub fn create_from_commandline(
        commandline: impl AsRef<std::ffi::OsStr>,
        application_name: Option<&str>,
        flags: AppInfoCreateFlags,
    ) -> Result<AppInfo, glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_app_info_create_from_commandline(
                commandline.as_ref().to_glib_none().0,
                application_name.to_glib_none().0,
                flags.into_glib(),
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets a list of all of the applications currently registered
    /// on this system.
    ///
    /// For desktop files, this includes applications that have
    /// `NoDisplay=true` set or are excluded from display by means
    /// of `OnlyShowIn` or `NotShowIn`. See g_app_info_should_show().
    /// The returned list does not include applications which have
    /// the `Hidden` key set.
    ///
    /// # Returns
    ///
    /// a newly allocated #GList of references to #GAppInfos.
    #[doc(alias = "g_app_info_get_all")]
    #[doc(alias = "get_all")]
    pub fn all() -> Vec<AppInfo> {
        unsafe { FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_all()) }
    }

    /// Gets a list of all #GAppInfos for a given content type,
    /// including the recommended and fallback #GAppInfos. See
    /// g_app_info_get_recommended_for_type() and
    /// g_app_info_get_fallback_for_type().
    /// ## `content_type`
    /// the content type to find a #GAppInfo for
    ///
    /// # Returns
    ///
    /// #GList of #GAppInfos
    ///     for given @content_type or [`None`] on error.
    #[doc(alias = "g_app_info_get_all_for_type")]
    #[doc(alias = "get_all_for_type")]
    pub fn all_for_type(content_type: &str) -> Vec<AppInfo> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_all_for_type(
                content_type.to_glib_none().0,
            ))
        }
    }

    /// Gets the default #GAppInfo for a given content type.
    /// ## `content_type`
    /// the content type to find a #GAppInfo for
    /// ## `must_support_uris`
    /// if [`true`], the #GAppInfo is expected to
    ///     support URIs
    ///
    /// # Returns
    ///
    /// #GAppInfo for given @content_type or
    ///     [`None`] on error.
    #[doc(alias = "g_app_info_get_default_for_type")]
    #[doc(alias = "get_default_for_type")]
    pub fn default_for_type(content_type: &str, must_support_uris: bool) -> Option<AppInfo> {
        unsafe {
            from_glib_full(ffi::g_app_info_get_default_for_type(
                content_type.to_glib_none().0,
                must_support_uris.into_glib(),
            ))
        }
    }

    /// Asynchronously gets the default #GAppInfo for a given content type.
    /// ## `content_type`
    /// the content type to find a #GAppInfo for
    /// ## `must_support_uris`
    /// if [`true`], the #GAppInfo is expected to
    ///     support URIs
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is done
    #[cfg(feature = "v2_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
    #[doc(alias = "g_app_info_get_default_for_type_async")]
    #[doc(alias = "get_default_for_type_async")]
    pub fn default_for_type_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
        content_type: &str,
        must_support_uris: bool,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn default_for_type_async_trampoline<
            P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_app_info_get_default_for_type_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = default_for_type_async_trampoline::<P>;
        unsafe {
            ffi::g_app_info_get_default_for_type_async(
                content_type.to_glib_none().0,
                must_support_uris.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v2_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
    pub fn default_for_type_future(
        content_type: &str,
        must_support_uris: bool,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<AppInfo, glib::Error>> + 'static>> {
        let content_type = String::from(content_type);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::default_for_type_async(
                    &content_type,
                    must_support_uris,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Gets the default application for handling URIs with
    /// the given URI scheme. A URI scheme is the initial part
    /// of the URI, up to but not including the ':', e.g. "http",
    /// "ftp" or "sip".
    /// ## `uri_scheme`
    /// a string containing a URI scheme.
    ///
    /// # Returns
    ///
    /// #GAppInfo for given @uri_scheme or
    ///     [`None`] on error.
    #[doc(alias = "g_app_info_get_default_for_uri_scheme")]
    #[doc(alias = "get_default_for_uri_scheme")]
    pub fn default_for_uri_scheme(uri_scheme: &str) -> Option<AppInfo> {
        unsafe {
            from_glib_full(ffi::g_app_info_get_default_for_uri_scheme(
                uri_scheme.to_glib_none().0,
            ))
        }
    }

    /// Asynchronously gets the default application for handling URIs with
    /// the given URI scheme. A URI scheme is the initial part
    /// of the URI, up to but not including the ':', e.g. "http",
    /// "ftp" or "sip".
    /// ## `uri_scheme`
    /// a string containing a URI scheme.
    /// ## `cancellable`
    /// optional #GCancellable object, [`None`] to ignore
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is done
    #[cfg(feature = "v2_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
    #[doc(alias = "g_app_info_get_default_for_uri_scheme_async")]
    #[doc(alias = "get_default_for_uri_scheme_async")]
    pub fn default_for_uri_scheme_async<P: FnOnce(Result<AppInfo, glib::Error>) + 'static>(
        uri_scheme: &str,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn default_for_uri_scheme_async_trampoline<
            P: FnOnce(Result<AppInfo, glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let ret = ffi::g_app_info_get_default_for_uri_scheme_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = default_for_uri_scheme_async_trampoline::<P>;
        unsafe {
            ffi::g_app_info_get_default_for_uri_scheme_async(
                uri_scheme.to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    #[cfg(feature = "v2_74")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_74")))]
    pub fn default_for_uri_scheme_future(
        uri_scheme: &str,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<AppInfo, glib::Error>> + 'static>> {
        let uri_scheme = String::from(uri_scheme);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::default_for_uri_scheme_async(&uri_scheme, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Gets a list of fallback #GAppInfos for a given content type, i.e.
    /// those applications which claim to support the given content type
    /// by MIME type subclassing and not directly.
    /// ## `content_type`
    /// the content type to find a #GAppInfo for
    ///
    /// # Returns
    ///
    /// #GList of #GAppInfos
    ///     for given @content_type or [`None`] on error.
    #[doc(alias = "g_app_info_get_fallback_for_type")]
    #[doc(alias = "get_fallback_for_type")]
    pub fn fallback_for_type(content_type: &str) -> Vec<AppInfo> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_fallback_for_type(
                content_type.to_glib_none().0,
            ))
        }
    }

    /// Gets a list of recommended #GAppInfos for a given content type, i.e.
    /// those applications which claim to support the given content type exactly,
    /// and not by MIME type subclassing.
    /// Note that the first application of the list is the last used one, i.e.
    /// the last one for which g_app_info_set_as_last_used_for_type() has been
    /// called.
    /// ## `content_type`
    /// the content type to find a #GAppInfo for
    ///
    /// # Returns
    ///
    /// #GList of #GAppInfos
    ///     for given @content_type or [`None`] on error.
    #[doc(alias = "g_app_info_get_recommended_for_type")]
    #[doc(alias = "get_recommended_for_type")]
    pub fn recommended_for_type(content_type: &str) -> Vec<AppInfo> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::g_app_info_get_recommended_for_type(
                content_type.to_glib_none().0,
            ))
        }
    }

    /// Utility function that launches the default application
    /// registered to handle the specified uri. Synchronous I/O
    /// is done on the uri to detect the type of the file if
    /// required.
    ///
    /// The D-Bus–activated applications don't have to be started if your application
    /// terminates too soon after this function. To prevent this, use
    /// g_app_info_launch_default_for_uri_async() instead.
    /// ## `uri`
    /// the uri to show
    /// ## `context`
    /// an optional #GAppLaunchContext
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_launch_default_for_uri")]
    pub fn launch_default_for_uri(
        uri: &str,
        context: Option<&impl IsA<AppLaunchContext>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_launch_default_for_uri(
                uri.to_glib_none().0,
                context.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))
            }
        }
    }

    /// Async version of g_app_info_launch_default_for_uri().
    ///
    /// This version is useful if you are interested in receiving
    /// error information in the case where the application is
    /// sandboxed and the portal may present an application chooser
    /// dialog to the user.
    ///
    /// This is also useful if you want to be sure that the D-Bus–activated
    /// applications are really started before termination and if you are interested
    /// in receiving error information from their activation.
    /// ## `uri`
    /// the uri to show
    /// ## `context`
    /// an optional #GAppLaunchContext
    /// ## `cancellable`
    /// a #GCancellable
    /// ## `callback`
    /// a #GAsyncReadyCallback to call when the request is done
    #[doc(alias = "g_app_info_launch_default_for_uri_async")]
    pub fn launch_default_for_uri_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        uri: &str,
        context: Option<&impl IsA<AppLaunchContext>>,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn launch_default_for_uri_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            let _ = ffi::g_app_info_launch_default_for_uri_finish(res, &mut error);
            let result = if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                Box_::from_raw(user_data as *mut _);
            let callback: P = callback.into_inner();
            callback(result);
        }
        let callback = launch_default_for_uri_async_trampoline::<P>;
        unsafe {
            ffi::g_app_info_launch_default_for_uri_async(
                uri.to_glib_none().0,
                context.map(|p| p.as_ref()).to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    pub fn launch_default_for_uri_future(
        uri: &str,
        context: Option<&(impl IsA<AppLaunchContext> + Clone + 'static)>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let uri = String::from(uri);
        let context = context.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(
            &(),
            move |_obj, cancellable, send| {
                Self::launch_default_for_uri_async(
                    &uri,
                    context.as_ref().map(::std::borrow::Borrow::borrow),
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// Removes all changes to the type associations done by
    /// g_app_info_set_as_default_for_type(),
    /// g_app_info_set_as_default_for_extension(),
    /// g_app_info_add_supports_type() or
    /// g_app_info_remove_supports_type().
    /// ## `content_type`
    /// a content type
    #[doc(alias = "g_app_info_reset_type_associations")]
    pub fn reset_type_associations(content_type: &str) {
        unsafe {
            ffi::g_app_info_reset_type_associations(content_type.to_glib_none().0);
        }
    }
}

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

/// Trait containing all [`struct@AppInfo`] methods.
///
/// # Implementors
///
/// [`AppInfo`][struct@crate::AppInfo], [`DesktopAppInfo`][struct@crate::DesktopAppInfo]
pub trait AppInfoExt: IsA<AppInfo> + sealed::Sealed + 'static {
    /// Adds a content type to the application information to indicate the
    /// application is capable of opening files with the given content type.
    /// ## `content_type`
    /// a string.
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_add_supports_type")]
    fn add_supports_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_add_supports_type(
                self.as_ref().to_glib_none().0,
                content_type.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))
            }
        }
    }

    /// Obtains the information whether the #GAppInfo can be deleted.
    /// See g_app_info_delete().
    ///
    /// # Returns
    ///
    /// [`true`] if @self can be deleted
    #[doc(alias = "g_app_info_can_delete")]
    fn can_delete(&self) -> bool {
        unsafe { from_glib(ffi::g_app_info_can_delete(self.as_ref().to_glib_none().0)) }
    }

    /// Checks if a supported content type can be removed from an application.
    ///
    /// # Returns
    ///
    /// [`true`] if it is possible to remove supported
    ///     content types from a given @self, [`false`] if not.
    #[doc(alias = "g_app_info_can_remove_supports_type")]
    fn can_remove_supports_type(&self) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_can_remove_supports_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Tries to delete a #GAppInfo.
    ///
    /// On some platforms, there may be a difference between user-defined
    /// #GAppInfos which can be deleted, and system-wide ones which cannot.
    /// See g_app_info_can_delete().
    ///
    /// # Returns
    ///
    /// [`true`] if @self has been deleted
    #[doc(alias = "g_app_info_delete")]
    fn delete(&self) -> bool {
        unsafe { from_glib(ffi::g_app_info_delete(self.as_ref().to_glib_none().0)) }
    }

    /// Creates a duplicate of a #GAppInfo.
    ///
    /// # Returns
    ///
    /// a duplicate of @self.
    #[doc(alias = "g_app_info_dup")]
    #[must_use]
    fn dup(&self) -> AppInfo {
        unsafe { from_glib_full(ffi::g_app_info_dup(self.as_ref().to_glib_none().0)) }
    }

    #[doc(alias = "g_app_info_equal")]
    fn equal(&self, appinfo2: &impl IsA<AppInfo>) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_equal(
                self.as_ref().to_glib_none().0,
                appinfo2.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the commandline with which the application will be
    /// started.
    ///
    /// # Returns
    ///
    /// a string containing the @self's commandline,
    ///     or [`None`] if this information is not available
    #[doc(alias = "g_app_info_get_commandline")]
    #[doc(alias = "get_commandline")]
    fn commandline(&self) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_none(ffi::g_app_info_get_commandline(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets a human-readable description of an installed application.
    ///
    /// # Returns
    ///
    /// a string containing a description of the
    /// application @self, or [`None`] if none.
    #[doc(alias = "g_app_info_get_description")]
    #[doc(alias = "get_description")]
    fn description(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_app_info_get_description(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the display name of the application. The display name is often more
    /// descriptive to the user than the name itself.
    ///
    /// # Returns
    ///
    /// the display name of the application for @self, or the name if
    /// no display name is available.
    #[doc(alias = "g_app_info_get_display_name")]
    #[doc(alias = "get_display_name")]
    fn display_name(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::g_app_info_get_display_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the executable's name for the installed application.
    ///
    /// This is intended to be used for debugging or labelling what program is going
    /// to be run. To launch the executable, use g_app_info_launch() and related
    /// functions, rather than spawning the return value from this function.
    ///
    /// # Returns
    ///
    /// a string containing the @self's application
    /// binaries name
    #[doc(alias = "g_app_info_get_executable")]
    #[doc(alias = "get_executable")]
    fn executable(&self) -> std::path::PathBuf {
        unsafe {
            from_glib_none(ffi::g_app_info_get_executable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the icon for the application.
    ///
    /// # Returns
    ///
    /// the default #GIcon for @self or [`None`]
    /// if there is no default icon.
    #[doc(alias = "g_app_info_get_icon")]
    #[doc(alias = "get_icon")]
    fn icon(&self) -> Option<Icon> {
        unsafe { from_glib_none(ffi::g_app_info_get_icon(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the ID of an application. An id is a string that
    /// identifies the application. The exact format of the id is
    /// platform dependent. For instance, on Unix this is the
    /// desktop file id from the xdg menu specification.
    ///
    /// Note that the returned ID may be [`None`], depending on how
    /// the @self has been constructed.
    ///
    /// # Returns
    ///
    /// a string containing the application's ID.
    #[doc(alias = "g_app_info_get_id")]
    #[doc(alias = "get_id")]
    fn id(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_app_info_get_id(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the installed name of the application.
    ///
    /// # Returns
    ///
    /// the name of the application for @self.
    #[doc(alias = "g_app_info_get_name")]
    #[doc(alias = "get_name")]
    fn name(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::g_app_info_get_name(self.as_ref().to_glib_none().0)) }
    }

    /// Retrieves the list of content types that @app_info claims to support.
    /// If this information is not provided by the environment, this function
    /// will return [`None`].
    /// This function does not take in consideration associations added with
    /// g_app_info_add_supports_type(), but only those exported directly by
    /// the application.
    ///
    /// # Returns
    ///
    ///
    ///    a list of content types.
    #[doc(alias = "g_app_info_get_supported_types")]
    #[doc(alias = "get_supported_types")]
    fn supported_types(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_none(ffi::g_app_info_get_supported_types(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Launches the application. Passes @files to the launched application
    /// as arguments, using the optional @context to get information
    /// about the details of the launcher (like what screen it is on).
    /// On error, @error will be set accordingly.
    ///
    /// To launch the application without arguments pass a [`None`] @files list.
    ///
    /// Note that even if the launch is successful the application launched
    /// can fail to start if it runs into problems during startup. There is
    /// no way to detect this.
    ///
    /// Some URIs can be changed when passed through a GFile (for instance
    /// unsupported URIs with strange formats like mailto:), so if you have
    /// a textual URI you want to pass in as argument, consider using
    /// g_app_info_launch_uris() instead.
    ///
    /// The launched application inherits the environment of the launching
    /// process, but it can be modified with g_app_launch_context_setenv()
    /// and g_app_launch_context_unsetenv().
    ///
    /// On UNIX, this function sets the `GIO_LAUNCHED_DESKTOP_FILE`
    /// environment variable with the path of the launched desktop file and
    /// `GIO_LAUNCHED_DESKTOP_FILE_PID` to the process id of the launched
    /// process. This can be used to ignore `GIO_LAUNCHED_DESKTOP_FILE`,
    /// should it be inherited by further processes. The `DISPLAY`,
    /// `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
    /// variables are also set, based on information provided in @context.
    /// ## `files`
    /// a #GList of #GFile objects
    /// ## `context`
    /// a #GAppLaunchContext or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on successful launch, [`false`] otherwise.
    #[doc(alias = "g_app_info_launch")]
    fn launch(
        &self,
        files: &[File],
        context: Option<&impl IsA<AppLaunchContext>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_launch(
                self.as_ref().to_glib_none().0,
                files.to_glib_none().0,
                context.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))
            }
        }
    }

    /// Launches the application. This passes the @uris to the launched application
    /// as arguments, using the optional @context to get information
    /// about the details of the launcher (like what screen it is on).
    /// On error, @error will be set accordingly. If the application only supports
    /// one URI per invocation as part of their command-line, multiple instances
    /// of the application will be spawned.
    ///
    /// To launch the application without arguments pass a [`None`] @uris list.
    ///
    /// Note that even if the launch is successful the application launched
    /// can fail to start if it runs into problems during startup. There is
    /// no way to detect this.
    /// ## `uris`
    /// a #GList containing URIs to launch.
    /// ## `context`
    /// a #GAppLaunchContext or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on successful launch, [`false`] otherwise.
    #[doc(alias = "g_app_info_launch_uris")]
    fn launch_uris(
        &self,
        uris: &[&str],
        context: Option<&impl IsA<AppLaunchContext>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_launch_uris(
                self.as_ref().to_glib_none().0,
                uris.to_glib_none().0,
                context.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))
            }
        }
    }

    /// Removes a supported type from an application, if possible.
    /// ## `content_type`
    /// a string.
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_remove_supports_type")]
    fn remove_supports_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_remove_supports_type(
                self.as_ref().to_glib_none().0,
                content_type.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))
            }
        }
    }

    /// Sets the application as the default handler for the given file extension.
    /// ## `extension`
    /// a string containing the file extension
    ///     (without the dot).
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_set_as_default_for_extension")]
    fn set_as_default_for_extension(
        &self,
        extension: impl AsRef<std::path::Path>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_set_as_default_for_extension(
                self.as_ref().to_glib_none().0,
                extension.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))
            }
        }
    }

    /// Sets the application as the default handler for a given type.
    /// ## `content_type`
    /// the content type.
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_set_as_default_for_type")]
    fn set_as_default_for_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_set_as_default_for_type(
                self.as_ref().to_glib_none().0,
                content_type.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))
            }
        }
    }

    /// Sets the application as the last used application for a given type.
    /// This will make the application appear as first in the list returned
    /// by g_app_info_get_recommended_for_type(), regardless of the default
    /// application for that content type.
    /// ## `content_type`
    /// the content type.
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_set_as_last_used_for_type")]
    fn set_as_last_used_for_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_app_info_set_as_last_used_for_type(
                self.as_ref().to_glib_none().0,
                content_type.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))
            }
        }
    }

    /// Checks if the application info should be shown in menus that
    /// list available applications.
    ///
    /// # Returns
    ///
    /// [`true`] if the @self should be shown, [`false`] otherwise.
    #[doc(alias = "g_app_info_should_show")]
    fn should_show(&self) -> bool {
        unsafe { from_glib(ffi::g_app_info_should_show(self.as_ref().to_glib_none().0)) }
    }

    /// Checks if the application accepts files as arguments.
    ///
    /// # Returns
    ///
    /// [`true`] if the @self supports files.
    #[doc(alias = "g_app_info_supports_files")]
    fn supports_files(&self) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_supports_files(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Checks if the application supports reading files and directories from URIs.
    ///
    /// # Returns
    ///
    /// [`true`] if the @self supports URIs.
    #[doc(alias = "g_app_info_supports_uris")]
    fn supports_uris(&self) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_supports_uris(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

impl<O: IsA<AppInfo>> AppInfoExt for O {}