gio/auto/

app_info.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::{AppInfoCreateFlags, AppLaunchContext, AsyncResult, Cancellable, File, Icon, ffi};
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 the following Exec key:
    ///
    /// ```text
    /// Exec=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 [`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](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s07.html)
    /// for exact quoting rules.
    /// ## `commandline`
    /// the command line to use
    /// ## `application_name`
    /// the application name, or `NULL` 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(
        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`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-nodisplay)
    /// set or are excluded from display by means of
    /// [`OnlyShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-onlyshowin)
    /// or [`NotShowIn`](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-notshowin).
    /// See [`AppInfoExt::should_show()`][crate::prelude::AppInfoExt::should_show()].
    ///
    /// The returned list does not include applications which have the
    /// [`Hidden` key](https://specifications.freedesktop.org/desktop-entry-spec/latest/ar01s06.html#key-hidden)
    /// set.
    ///
    /// # Returns
    ///
    /// a newly allocated
    ///   list of references to [`AppInfo`][crate::AppInfo]s.
    #[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 [`AppInfo`][crate::AppInfo]s for a given content type,
    /// including the recommended and fallback [`AppInfo`][crate::AppInfo]s. 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
    ///
    /// list of
    ///   [`AppInfo`][crate::AppInfo]s for given @content_type.
    #[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 `NULL` 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 [`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
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable]
    /// ## `callback`
    /// a [type@Gio.AsyncReadyCallback] 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,
        ) {
            unsafe {
                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 `:`.
    /// For example, `http`, `ftp` or `sip`.
    /// ## `uri_scheme`
    /// a string containing a URI scheme.
    ///
    /// # Returns
    ///
    /// [`AppInfo`][crate::AppInfo] for given
    ///   @uri_scheme or `NULL` 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`
    /// a [`Cancellable`][crate::Cancellable]
    /// ## `callback`
    /// a [type@Gio.AsyncReadyCallback] 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,
        ) {
            unsafe {
                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 [`AppInfo`][crate::AppInfo]s 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
    ///
    /// list of [`AppInfo`][crate::AppInfo]s
    ///     for given @content_type or `NULL` 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 [`AppInfo`][crate::AppInfo]s 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
    ///
    /// list of
    ///   [`AppInfo`][crate::AppInfo]s for given @content_type or `NULL` 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`
    /// optional launch context
    ///
    /// # 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 [`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`
    /// optional launch context
    /// ## `cancellable`
    /// a [`Cancellable`][crate::Cancellable]
    /// ## `callback`
    /// a [type@Gio.AsyncReadyCallback] 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,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                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
    /// [`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);
        }
    }
}

/// Trait containing all [`struct@AppInfo`] methods.
///
/// # Implementors
///
/// [`AppInfo`][struct@crate::AppInfo]
pub trait AppInfoExt: IsA<AppInfo> + '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 [`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 {
        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 [`AppInfo`][crate::AppInfo].
    ///
    /// On some platforms, there may be a difference between user-defined
    /// [`AppInfo`][crate::AppInfo]s 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 {
        unsafe { from_glib(ffi::g_app_info_delete(self.as_ref().to_glib_none().0)) }
    }

    /// Creates a duplicate of a [`AppInfo`][crate::AppInfo].
    ///
    /// # 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 `NULL` 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 `NULL` 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 [`launch()`][Self::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 [`Icon`][crate::Icon] for
    ///   @self or `NULL` 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 `NULL`, 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 `NULL`.
    ///
    /// 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> {
        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 `NULL` @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`,
    /// `XDG_ACTIVATION_TOKEN` and `DESKTOP_STARTUP_ID` environment
    /// variables are also set, based on information provided in @context.
    /// ## `files`
    /// a list of [`File`][crate::File] objects
    /// ## `context`
    /// the launch context
    ///
    /// # 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 `NULL` @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 list of URIs to launch.
    /// ## `context`
    /// the launch context
    ///
    /// # 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
    /// [`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> {
        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 {}