// 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 gio_sys;
use glib;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::GString;
use glib_sys;
use gobject_sys;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
use std::pin::Pin;
use std::ptr;
use Cancellable;
use Drive;
use File;
use Icon;
use MountMountFlags;
use MountOperation;
use MountUnmountFlags;
use Volume;

glib_wrapper! {
    /// The `Mount` interface represents user-visible mounts. Note, when
    /// porting from GnomeVFS, `Mount` is the moral equivalent of `GnomeVFSVolume`.
    ///
    /// `Mount` is a "mounted" filesystem that you can access. Mounted is in
    /// quotes because it's not the same as a unix mount, it might be a gvfs
    /// mount, but you can still access the files on it if you use GIO. Might or
    /// might not be related to a volume object.
    ///
    /// Unmounting a `Mount` instance is an asynchronous operation. For
    /// more information about asynchronous operations, see `AsyncResult`
    /// and `Task`. To unmount a `Mount` instance, first call
    /// `Mount::unmount_with_operation` with (at least) the `Mount` instance and a
    /// `GAsyncReadyCallback`. The callback will be fired when the
    /// operation has resolved (either with success or failure), and a
    /// `AsyncResult` structure will be passed to the callback. That
    /// callback should then call `Mount::unmount_with_operation_finish` with the `Mount`
    /// and the `AsyncResult` data to see if the operation was completed
    /// successfully. If an `error` is present when `Mount::unmount_with_operation_finish`
    /// is called, then it will be filled with any error information.
    ///
    /// # Implements
    ///
    /// [`MountExt`](trait.MountExt.html)
    pub struct Mount(Interface<gio_sys::GMount>);

    match fn {
        get_type => || gio_sys::g_mount_get_type(),
    }
}

pub const NONE_MOUNT: Option<&Mount> = None;

/// Trait containing all `Mount` methods.
///
/// # Implementors
///
/// [`Mount`](struct.Mount.html)
pub trait MountExt: 'static {
    /// Checks if `self` can be ejected.
    ///
    /// # Returns
    ///
    /// `true` if the `self` can be ejected.
    fn can_eject(&self) -> bool;

    /// Checks if `self` can be unmounted.
    ///
    /// # Returns
    ///
    /// `true` if the `self` can be unmounted.
    fn can_unmount(&self) -> bool;

    /// Ejects a mount. This is an asynchronous operation, and is
    /// finished by calling `Mount::eject_with_operation_finish` with the `self`
    /// and `AsyncResult` data returned in the `callback`.
    /// ## `flags`
    /// flags affecting the unmount if required for eject
    /// ## `mount_operation`
    /// a `MountOperation` or `None` to avoid
    ///  user interaction.
    /// ## `cancellable`
    /// optional `Cancellable` object, `None` to ignore.
    /// ## `callback`
    /// a `GAsyncReadyCallback`, or `None`.
    /// ## `user_data`
    /// user data passed to `callback`.
    fn eject_with_operation<
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    );

    fn eject_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>>;

    /// Gets the default location of `self`. The default location of the given
    /// `self` is a path that reflects the main entry point for the user (e.g.
    /// the home directory, or the root of the volume).
    ///
    /// # Returns
    ///
    /// a `File`.
    ///  The returned object should be unreffed with
    ///  `gobject::ObjectExt::unref` when no longer needed.
    fn get_default_location(&self) -> Option<File>;

    /// Gets the drive for the `self`.
    ///
    /// This is a convenience method for getting the `Volume` and then
    /// using that object to get the `Drive`.
    ///
    /// # Returns
    ///
    /// a `Drive` or `None` if `self` is not
    ///  associated with a volume or a drive.
    ///  The returned object should be unreffed with
    ///  `gobject::ObjectExt::unref` when no longer needed.
    fn get_drive(&self) -> Option<Drive>;

    /// Gets the icon for `self`.
    ///
    /// # Returns
    ///
    /// a `Icon`.
    ///  The returned object should be unreffed with
    ///  `gobject::ObjectExt::unref` when no longer needed.
    fn get_icon(&self) -> Option<Icon>;

    /// Gets the name of `self`.
    ///
    /// # Returns
    ///
    /// the name for the given `self`.
    ///  The returned string should be freed with `g_free`
    ///  when no longer needed.
    fn get_name(&self) -> Option<GString>;

    /// Gets the root directory on `self`.
    ///
    /// # Returns
    ///
    /// a `File`.
    ///  The returned object should be unreffed with
    ///  `gobject::ObjectExt::unref` when no longer needed.
    fn get_root(&self) -> Option<File>;

    /// Gets the sort key for `self`, if any.
    ///
    /// # Returns
    ///
    /// Sorting key for `self` or `None` if no such key is available.
    fn get_sort_key(&self) -> Option<GString>;

    /// Gets the symbolic icon for `self`.
    ///
    /// # Returns
    ///
    /// a `Icon`.
    ///  The returned object should be unreffed with
    ///  `gobject::ObjectExt::unref` when no longer needed.
    fn get_symbolic_icon(&self) -> Option<Icon>;

    /// Gets the UUID for the `self`. The reference is typically based on
    /// the file system UUID for the mount in question and should be
    /// considered an opaque string. Returns `None` if there is no UUID
    /// available.
    ///
    /// # Returns
    ///
    /// the UUID for `self` or `None` if no UUID
    ///  can be computed.
    ///  The returned string should be freed with `g_free`
    ///  when no longer needed.
    fn get_uuid(&self) -> Option<GString>;

    /// Gets the volume for the `self`.
    ///
    /// # Returns
    ///
    /// a `Volume` or `None` if `self` is not
    ///  associated with a volume.
    ///  The returned object should be unreffed with
    ///  `gobject::ObjectExt::unref` when no longer needed.
    fn get_volume(&self) -> Option<Volume>;

    /// Tries to guess the type of content stored on `self`. Returns one or
    /// more textual identifiers of well-known content types (typically
    /// prefixed with "x-content/"), e.g. x-content/image-dcf for camera
    /// memory cards. See the
    /// [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
    /// specification for more on x-content types.
    ///
    /// This is an asynchronous operation (see
    /// `Mount::guess_content_type_sync` for the synchronous version), and
    /// is finished by calling `Mount::guess_content_type_finish` with the
    /// `self` and `AsyncResult` data returned in the `callback`.
    /// ## `force_rescan`
    /// Whether to force a rescan of the content.
    ///  Otherwise a cached result will be used if available
    /// ## `cancellable`
    /// optional `Cancellable` object, `None` to ignore
    /// ## `callback`
    /// a `GAsyncReadyCallback`
    /// ## `user_data`
    /// user data passed to `callback`
    fn guess_content_type<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<GString>, glib::Error>) + Send + 'static,
    >(
        &self,
        force_rescan: bool,
        cancellable: Option<&P>,
        callback: Q,
    );

    fn guess_content_type_future(
        &self,
        force_rescan: bool,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<GString>, glib::Error>> + 'static>>;

    /// Tries to guess the type of content stored on `self`. Returns one or
    /// more textual identifiers of well-known content types (typically
    /// prefixed with "x-content/"), e.g. x-content/image-dcf for camera
    /// memory cards. See the
    /// [shared-mime-info](http://www.freedesktop.org/wiki/Specifications/shared-mime-info-spec)
    /// specification for more on x-content types.
    ///
    /// This is an synchronous operation and as such may block doing IO;
    /// see `Mount::guess_content_type` for the asynchronous version.
    /// ## `force_rescan`
    /// Whether to force a rescan of the content.
    ///  Otherwise a cached result will be used if available
    /// ## `cancellable`
    /// optional `Cancellable` object, `None` to ignore
    ///
    /// # Returns
    ///
    /// a `None`-terminated array of content types or `None` on error.
    ///  Caller should free this array with `g_strfreev` when done with it.
    fn guess_content_type_sync<P: IsA<Cancellable>>(
        &self,
        force_rescan: bool,
        cancellable: Option<&P>,
    ) -> Result<Vec<GString>, glib::Error>;

    /// Determines if `self` is shadowed. Applications or libraries should
    /// avoid displaying `self` in the user interface if it is shadowed.
    ///
    /// A mount is said to be shadowed if there exists one or more user
    /// visible objects (currently `Mount` objects) with a root that is
    /// inside the root of `self`.
    ///
    /// One application of shadow mounts is when exposing a single file
    /// system that is used to address several logical volumes. In this
    /// situation, a `VolumeMonitor` implementation would create two
    /// `Volume` objects (for example, one for the camera functionality of
    /// the device and one for a SD card reader on the device) with
    /// activation URIs `gphoto2://[usb:001,002]/store1/`
    /// and `gphoto2://[usb:001,002]/store2/`. When the
    /// underlying mount (with root
    /// `gphoto2://[usb:001,002]/`) is mounted, said
    /// `VolumeMonitor` implementation would create two `Mount` objects
    /// (each with their root matching the corresponding volume activation
    /// root) that would shadow the original mount.
    ///
    /// The proxy monitor in GVfs 2.26 and later, automatically creates and
    /// manage shadow mounts (and shadows the underlying mount) if the
    /// activation root on a `Volume` is set.
    ///
    /// # Returns
    ///
    /// `true` if `self` is shadowed.
    fn is_shadowed(&self) -> bool;

    /// Remounts a mount. This is an asynchronous operation, and is
    /// finished by calling `Mount::remount_finish` with the `self`
    /// and `GAsyncResults` data returned in the `callback`.
    ///
    /// Remounting is useful when some setting affecting the operation
    /// of the volume has been changed, as these may need a remount to
    /// take affect. While this is semantically equivalent with unmounting
    /// and then remounting not all backends might need to actually be
    /// unmounted.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a `MountOperation` or `None` to avoid
    ///  user interaction.
    /// ## `cancellable`
    /// optional `Cancellable` object, `None` to ignore.
    /// ## `callback`
    /// a `GAsyncReadyCallback`, or `None`.
    /// ## `user_data`
    /// user data passed to `callback`.
    fn remount<
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    );

    fn remount_future<P: IsA<MountOperation> + Clone + 'static>(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&P>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>>;

    /// Increments the shadow count on `self`. Usually used by
    /// `VolumeMonitor` implementations when creating a shadow mount for
    /// `self`, see `Mount::is_shadowed` for more information. The caller
    /// will need to emit the `Mount::changed` signal on `self` manually.
    fn shadow(&self);

    /// Unmounts a mount. This is an asynchronous operation, and is
    /// finished by calling `Mount::unmount_with_operation_finish` with the `self`
    /// and `AsyncResult` data returned in the `callback`.
    /// ## `flags`
    /// flags affecting the operation
    /// ## `mount_operation`
    /// a `MountOperation` or `None` to avoid
    ///  user interaction.
    /// ## `cancellable`
    /// optional `Cancellable` object, `None` to ignore.
    /// ## `callback`
    /// a `GAsyncReadyCallback`, or `None`.
    /// ## `user_data`
    /// user data passed to `callback`.
    fn unmount_with_operation<
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    );

    fn unmount_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>>;

    /// Decrements the shadow count on `self`. Usually used by
    /// `VolumeMonitor` implementations when destroying a shadow mount for
    /// `self`, see `Mount::is_shadowed` for more information. The caller
    /// will need to emit the `Mount::changed` signal on `self` manually.
    fn unshadow(&self);

    /// Emitted when the mount has been changed.
    fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    /// This signal may be emitted when the `Mount` is about to be
    /// unmounted.
    ///
    /// This signal depends on the backend and is only emitted if
    /// GIO was used to unmount.
    fn connect_pre_unmount<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    /// This signal is emitted when the `Mount` have been
    /// unmounted. If the recipient is holding references to the
    /// object they should release them so the object can be
    /// finalized.
    fn connect_unmounted<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<Mount>> MountExt for O {
    fn can_eject(&self) -> bool {
        unsafe { from_glib(gio_sys::g_mount_can_eject(self.as_ref().to_glib_none().0)) }
    }

    fn can_unmount(&self) -> bool {
        unsafe { from_glib(gio_sys::g_mount_can_unmount(self.as_ref().to_glib_none().0)) }
    }

    fn eject_with_operation<
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    ) {
        let user_data: Box_<R> = Box_::new(callback);
        unsafe extern "C" fn eject_with_operation_trampoline<
            R: FnOnce(Result<(), glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = gio_sys::g_mount_eject_with_operation_finish(
                _source_object as *mut _,
                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 = eject_with_operation_trampoline::<R>;
        unsafe {
            gio_sys::g_mount_eject_with_operation(
                self.as_ref().to_glib_none().0,
                flags.to_glib(),
                mount_operation.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 _,
            );
        }
    }

    fn eject_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.eject_with_operation(
                flags,
                mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                Some(&cancellable),
                move |res| {
                    send.resolve(res);
                },
            );

            cancellable
        }))
    }

    fn get_default_location(&self) -> Option<File> {
        unsafe {
            from_glib_full(gio_sys::g_mount_get_default_location(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_drive(&self) -> Option<Drive> {
        unsafe { from_glib_full(gio_sys::g_mount_get_drive(self.as_ref().to_glib_none().0)) }
    }

    fn get_icon(&self) -> Option<Icon> {
        unsafe { from_glib_full(gio_sys::g_mount_get_icon(self.as_ref().to_glib_none().0)) }
    }

    fn get_name(&self) -> Option<GString> {
        unsafe { from_glib_full(gio_sys::g_mount_get_name(self.as_ref().to_glib_none().0)) }
    }

    fn get_root(&self) -> Option<File> {
        unsafe { from_glib_full(gio_sys::g_mount_get_root(self.as_ref().to_glib_none().0)) }
    }

    fn get_sort_key(&self) -> Option<GString> {
        unsafe {
            from_glib_none(gio_sys::g_mount_get_sort_key(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_symbolic_icon(&self) -> Option<Icon> {
        unsafe {
            from_glib_full(gio_sys::g_mount_get_symbolic_icon(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn get_uuid(&self) -> Option<GString> {
        unsafe { from_glib_full(gio_sys::g_mount_get_uuid(self.as_ref().to_glib_none().0)) }
    }

    fn get_volume(&self) -> Option<Volume> {
        unsafe { from_glib_full(gio_sys::g_mount_get_volume(self.as_ref().to_glib_none().0)) }
    }

    fn guess_content_type<
        P: IsA<Cancellable>,
        Q: FnOnce(Result<Vec<GString>, glib::Error>) + Send + 'static,
    >(
        &self,
        force_rescan: bool,
        cancellable: Option<&P>,
        callback: Q,
    ) {
        let user_data: Box_<Q> = Box_::new(callback);
        unsafe extern "C" fn guess_content_type_trampoline<
            Q: FnOnce(Result<Vec<GString>, glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_mount_guess_content_type_finish(
                _source_object as *mut _,
                res,
                &mut error,
            );
            let result = if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            };
            let callback: Box_<Q> = Box_::from_raw(user_data as *mut _);
            callback(result);
        }
        let callback = guess_content_type_trampoline::<Q>;
        unsafe {
            gio_sys::g_mount_guess_content_type(
                self.as_ref().to_glib_none().0,
                force_rescan.to_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn guess_content_type_future(
        &self,
        force_rescan: bool,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<Vec<GString>, glib::Error>> + 'static>>
    {
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.guess_content_type(force_rescan, Some(&cancellable), move |res| {
                send.resolve(res);
            });

            cancellable
        }))
    }

    fn guess_content_type_sync<P: IsA<Cancellable>>(
        &self,
        force_rescan: bool,
        cancellable: Option<&P>,
    ) -> Result<Vec<GString>, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = gio_sys::g_mount_guess_content_type_sync(
                self.as_ref().to_glib_none().0,
                force_rescan.to_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(FromGlibPtrContainer::from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn is_shadowed(&self) -> bool {
        unsafe { from_glib(gio_sys::g_mount_is_shadowed(self.as_ref().to_glib_none().0)) }
    }

    fn remount<
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    ) {
        let user_data: Box_<R> = Box_::new(callback);
        unsafe extern "C" fn remount_trampoline<
            R: FnOnce(Result<(), glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = gio_sys::g_mount_remount_finish(_source_object as *mut _, 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 = remount_trampoline::<R>;
        unsafe {
            gio_sys::g_mount_remount(
                self.as_ref().to_glib_none().0,
                flags.to_glib(),
                mount_operation.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 _,
            );
        }
    }

    fn remount_future<P: IsA<MountOperation> + Clone + 'static>(
        &self,
        flags: MountMountFlags,
        mount_operation: Option<&P>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.remount(
                flags,
                mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                Some(&cancellable),
                move |res| {
                    send.resolve(res);
                },
            );

            cancellable
        }))
    }

    fn shadow(&self) {
        unsafe {
            gio_sys::g_mount_shadow(self.as_ref().to_glib_none().0);
        }
    }

    fn unmount_with_operation<
        P: IsA<MountOperation>,
        Q: IsA<Cancellable>,
        R: FnOnce(Result<(), glib::Error>) + Send + 'static,
    >(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
        cancellable: Option<&Q>,
        callback: R,
    ) {
        let user_data: Box_<R> = Box_::new(callback);
        unsafe extern "C" fn unmount_with_operation_trampoline<
            R: FnOnce(Result<(), glib::Error>) + Send + 'static,
        >(
            _source_object: *mut gobject_sys::GObject,
            res: *mut gio_sys::GAsyncResult,
            user_data: glib_sys::gpointer,
        ) {
            let mut error = ptr::null_mut();
            let _ = gio_sys::g_mount_unmount_with_operation_finish(
                _source_object as *mut _,
                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 = unmount_with_operation_trampoline::<R>;
        unsafe {
            gio_sys::g_mount_unmount_with_operation(
                self.as_ref().to_glib_none().0,
                flags.to_glib(),
                mount_operation.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 _,
            );
        }
    }

    fn unmount_with_operation_future<P: IsA<MountOperation> + Clone + 'static>(
        &self,
        flags: MountUnmountFlags,
        mount_operation: Option<&P>,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        let mount_operation = mount_operation.map(ToOwned::to_owned);
        Box_::pin(crate::GioFuture::new(self, move |obj, send| {
            let cancellable = Cancellable::new();
            obj.unmount_with_operation(
                flags,
                mount_operation.as_ref().map(::std::borrow::Borrow::borrow),
                Some(&cancellable),
                move |res| {
                    send.resolve(res);
                },
            );

            cancellable
        }))
    }

    fn unshadow(&self) {
        unsafe {
            gio_sys::g_mount_unshadow(self.as_ref().to_glib_none().0);
        }
    }

    fn connect_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn changed_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gio_sys::GMount,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Mount>,
        {
            let f: &F = &*(f as *const F);
            f(&Mount::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"changed\0".as_ptr() as *const _,
                Some(transmute(changed_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_pre_unmount<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn pre_unmount_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gio_sys::GMount,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Mount>,
        {
            let f: &F = &*(f as *const F);
            f(&Mount::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"pre-unmount\0".as_ptr() as *const _,
                Some(transmute(pre_unmount_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }

    fn connect_unmounted<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn unmounted_trampoline<P, F: Fn(&P) + 'static>(
            this: *mut gio_sys::GMount,
            f: glib_sys::gpointer,
        ) where
            P: IsA<Mount>,
        {
            let f: &F = &*(f as *const F);
            f(&Mount::from_glib_borrow(this).unsafe_cast())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"unmounted\0".as_ptr() as *const _,
                Some(transmute(unmounted_trampoline::<Self, F> as usize)),
                Box_::into_raw(f),
            )
        }
    }
}

impl fmt::Display for Mount {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "Mount")
    }
}