// 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;
use crate::AppLaunchContext;
#[cfg(any(feature = "v2_50", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
use crate::AsyncResult;
#[cfg(any(feature = "v2_50", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
use crate::Cancellable;
use crate::File;
use crate::Icon;
use glib::object::IsA;
use glib::translate::*;
#[cfg(any(feature = "v2_50", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
use std::boxed::Box as Box_;
use std::fmt;
#[cfg(any(feature = "v2_50", feature = "dox"))]
#[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
use std::pin::Pin;
use std::ptr;

glib::wrapper! {
    /// [`AppInfo`][crate::AppInfo] and [`AppLaunchContext`][crate::AppLaunchContext] 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 [`Vfs`][crate::Vfs] 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:
    ///
    ///
    /// ```text
    /// 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 {
    /// Creates a new [`AppInfo`][crate::AppInfo] 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 [`AppInfo`][crate::AppInfo]
    ///
    /// # Returns
    ///
    /// new [`AppInfo`][crate::AppInfo] for given command.
    #[doc(alias = "g_app_info_create_from_commandline")]
    pub fn create_from_commandline<P: AsRef<std::ffi::OsStr>>(
        commandline: P,
        application_name: Option<&str>,
        flags: AppInfoCreateFlags,
    ) -> Result<AppInfo, glib::Error> {
        unsafe {
            let mut error = 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 [`AppInfoExt::should_show()`][crate::prelude::AppInfoExt::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
    /// [`recommended_for_type()`][Self::recommended_for_type()] and
    /// [`fallback_for_type()`][Self::fallback_for_type()].
    /// ## `content_type`
    /// the content type to find a [`AppInfo`][crate::AppInfo] 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 [`AppInfo`][crate::AppInfo] for a given content type.
    /// ## `content_type`
    /// the content type to find a [`AppInfo`][crate::AppInfo] for
    /// ## `must_support_uris`
    /// if [`true`], the [`AppInfo`][crate::AppInfo] is expected to
    ///  support URIs
    ///
    /// # Returns
    ///
    /// [`AppInfo`][crate::AppInfo] 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(),
            ))
        }
    }

    /// 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
    ///
    /// [`AppInfo`][crate::AppInfo] 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,
            ))
        }
    }

    /// 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 [`AppInfo`][crate::AppInfo] 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 [`AppInfoExt::set_as_last_used_for_type()`][crate::prelude::AppInfoExt::set_as_last_used_for_type()] has been
    /// called.
    /// ## `content_type`
    /// the content type to find a [`AppInfo`][crate::AppInfo] 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
    /// [`launch_default_for_uri_async()`][Self::launch_default_for_uri_async()] instead.
    /// ## `uri`
    /// the uri to show
    /// ## `context`
    /// an optional [`AppLaunchContext`][crate::AppLaunchContext]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] on error.
    #[doc(alias = "g_app_info_launch_default_for_uri")]
    pub fn launch_default_for_uri<P: IsA<AppLaunchContext>>(
        uri: &str,
        context: Option<&P>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = 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,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Async version of [`launch_default_for_uri()`][Self::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 [`AppLaunchContext`][crate::AppLaunchContext]
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable]
    /// ## `callback`
    /// a `GAsyncReadyCallback` to call when the request is done
    #[cfg(any(feature = "v2_50", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
    #[doc(alias = "g_app_info_launch_default_for_uri_async")]
    pub fn launch_default_for_uri_async<
        P: IsA<AppLaunchContext>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        uri: &str,
        context: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    ) {
        let user_data: Box_<R> = Box_::new(callback);
        unsafe extern "C" fn launch_default_for_uri_async_trampoline<
            R: FnOnce(Result<(), glib::Error>) + Send + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = 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_<R> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = launch_default_for_uri_async_trampoline::<R>;
        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 _,
            );
        }
    }

    #[cfg(any(feature = "v2_50", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_50")))]
    pub fn launch_default_for_uri_async_future<P: IsA<AppLaunchContext> + Clone + 'static>(
        uri: &str,
        context: Option<&P>,
    ) -> 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
    /// [`AppInfoExt::set_as_default_for_type()`][crate::prelude::AppInfoExt::set_as_default_for_type()],
    /// [`AppInfoExt::set_as_default_for_extension()`][crate::prelude::AppInfoExt::set_as_default_for_extension()],
    /// [`AppInfoExt::add_supports_type()`][crate::prelude::AppInfoExt::add_supports_type()] or
    /// [`AppInfoExt::remove_supports_type()`][crate::prelude::AppInfoExt::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);
        }
    }
}

pub const NONE_APP_INFO: Option<&AppInfo> = None;

/// Trait containing all [`struct@AppInfo`] methods.
///
/// # Implementors
///
/// [`AppInfo`][struct@crate::AppInfo], [`DesktopAppInfo`][struct@crate::DesktopAppInfo]
pub trait AppInfoExt: '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>;

    /// Obtains the information whether the [`AppInfo`][crate::AppInfo] can be deleted.
    /// See [`delete()`][Self::delete()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` can be deleted
    #[doc(alias = "g_app_info_can_delete")]
    fn can_delete(&self) -> bool;

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

    /// Tries to delete a [`AppInfo`][crate::AppInfo].
    ///
    /// On some platforms, there may be a difference between user-defined
    /// `GAppInfos` which can be deleted, and system-wide ones which cannot.
    /// See [`can_delete()`][Self::can_delete()].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` has been deleted
    #[doc(alias = "g_app_info_delete")]
    fn delete(&self) -> bool;

    /// Creates a duplicate of a [`AppInfo`][crate::AppInfo].
    ///
    /// # Returns
    ///
    /// a duplicate of `self`.
    #[doc(alias = "g_app_info_dup")]
    fn dup(&self) -> AppInfo;

    /// Checks if two `GAppInfos` are equal.
    ///
    /// Note that the check *may not* compare each individual
    /// field, and only does an identity check. In case detecting changes in the
    /// contents is needed, program code must additionally compare relevant fields.
    /// ## `appinfo2`
    /// the second [`AppInfo`][crate::AppInfo].
    ///
    /// # Returns
    ///
    /// [`true`] if `self` is equal to `appinfo2`. [`false`] otherwise.
    #[doc(alias = "g_app_info_equal")]
    fn equal<P: IsA<AppInfo>>(&self, appinfo2: &P) -> bool;

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

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

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

    /// Gets the executable's name for the installed application.
    ///
    /// # 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;

    /// Gets the icon for the application.
    ///
    /// # Returns
    ///
    /// the default [`Icon`][crate::Icon] 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>;

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

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

    /// 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
    /// [`add_supports_type()`][Self::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>;

    /// 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
    /// [`launch_uris()`][Self::launch_uris()] instead.
    ///
    /// The launched application inherits the environment of the launching
    /// process, but it can be modified with [`AppLaunchContextExt::setenv()`][crate::prelude::AppLaunchContextExt::setenv()]
    /// and [`AppLaunchContextExt::unsetenv()`][crate::prelude::AppLaunchContextExt::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` and
    /// `DESKTOP_STARTUP_ID` environment variables are also set, based
    /// on information provided in `context`.
    /// ## `files`
    /// a `GList` of [`File`][crate::File] objects
    /// ## `context`
    /// a [`AppLaunchContext`][crate::AppLaunchContext] or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on successful launch, [`false`] otherwise.
    #[doc(alias = "g_app_info_launch")]
    fn launch<P: IsA<AppLaunchContext>>(
        &self,
        files: &[File],
        context: Option<&P>,
    ) -> Result<(), glib::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.
    ///
    /// 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 [`AppLaunchContext`][crate::AppLaunchContext] or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on successful launch, [`false`] otherwise.
    #[doc(alias = "g_app_info_launch_uris")]
    fn launch_uris<P: IsA<AppLaunchContext>>(
        &self,
        uris: &[&str],
        context: Option<&P>,
    ) -> Result<(), glib::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>;

    /// 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<P: AsRef<std::path::Path>>(
        &self,
        extension: P,
    ) -> Result<(), glib::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>;

    /// 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 [`AppInfo::recommended_for_type()`][crate::AppInfo::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>;

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

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

    /// 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;
}

impl<O: IsA<AppInfo>> AppInfoExt for O {
    fn add_supports_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_app_info_add_supports_type(
                self.as_ref().to_glib_none().0,
                content_type.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn can_delete(&self) -> bool {
        unsafe { from_glib(ffi::g_app_info_can_delete(self.as_ref().to_glib_none().0)) }
    }

    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,
            ))
        }
    }

    fn delete(&self) -> bool {
        unsafe { from_glib(ffi::g_app_info_delete(self.as_ref().to_glib_none().0)) }
    }

    fn dup(&self) -> AppInfo {
        unsafe { from_glib_full(ffi::g_app_info_dup(self.as_ref().to_glib_none().0)) }
    }

    fn equal<P: IsA<AppInfo>>(&self, appinfo2: &P) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_equal(
                self.as_ref().to_glib_none().0,
                appinfo2.as_ref().to_glib_none().0,
            ))
        }
    }

    fn commandline(&self) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_none(ffi::g_app_info_get_commandline(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn description(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_app_info_get_description(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn display_name(&self) -> glib::GString {
        unsafe {
            from_glib_none(ffi::g_app_info_get_display_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn executable(&self) -> std::path::PathBuf {
        unsafe {
            from_glib_none(ffi::g_app_info_get_executable(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn icon(&self) -> Option<Icon> {
        unsafe { from_glib_none(ffi::g_app_info_get_icon(self.as_ref().to_glib_none().0)) }
    }

    fn id(&self) -> Option<glib::GString> {
        unsafe { from_glib_none(ffi::g_app_info_get_id(self.as_ref().to_glib_none().0)) }
    }

    fn name(&self) -> glib::GString {
        unsafe { from_glib_none(ffi::g_app_info_get_name(self.as_ref().to_glib_none().0)) }
    }

    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,
            ))
        }
    }

    fn launch<P: IsA<AppLaunchContext>>(
        &self,
        files: &[File],
        context: Option<&P>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = 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,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn launch_uris<P: IsA<AppLaunchContext>>(
        &self,
        uris: &[&str],
        context: Option<&P>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = 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,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn remove_supports_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_app_info_remove_supports_type(
                self.as_ref().to_glib_none().0,
                content_type.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_as_default_for_extension<P: AsRef<std::path::Path>>(
        &self,
        extension: P,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = 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,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_as_default_for_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::g_app_info_set_as_default_for_type(
                self.as_ref().to_glib_none().0,
                content_type.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_as_last_used_for_type(&self, content_type: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = 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,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn should_show(&self) -> bool {
        unsafe { from_glib(ffi::g_app_info_should_show(self.as_ref().to_glib_none().0)) }
    }

    fn supports_files(&self) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_supports_files(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn supports_uris(&self) -> bool {
        unsafe {
            from_glib(ffi::g_app_info_supports_uris(
                self.as_ref().to_glib_none().0,
            ))
        }
    }
}

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