libpanel/auto/

save_delegate.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT

use crate::ffi;
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    ///
    ///
    /// ## Properties
    ///
    ///
    /// #### `icon`
    ///  The "icon" property contains a [`gio::Icon`][crate::gio::Icon] that describes the save
    /// operation. Generally, this should be the symbolic icon of the
    /// document class you are saving.
    ///
    /// Alternatively, you can use [`icon-name`][struct@crate::SaveDelegate#icon-name] for a
    /// named icon.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `icon-name`
    ///  The "icon-name" property contains the name of an icon to use when
    /// showing information about the save operation in UI such as a save
    /// dialog.
    ///
    /// You can also use [`icon`][struct@crate::SaveDelegate#icon] to set a [`gio::Icon`][crate::gio::Icon] instead of
    /// an icon name.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `is-draft`
    ///  The "is-draft" property indicates that the document represented by the
    /// delegate is a draft and might be lost of not saved.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `progress`
    ///  The "progress" property contains progress between 0.0 and 1.0 and
    /// should be updated by the delegate implementation as saving progresses.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `subtitle`
    ///  The "subtitle" property contains additional information that may
    /// not make sense to put in the title. This might include the directory
    /// that the file will be saved within.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `title`
    ///  The "title" property contains the title of the document being saved.
    /// Generally, this should be the base name of the document such as
    /// `file.txt`.
    ///
    /// Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `close`
    ///  This signal is emitted when the save delegate should close
    /// the widget it is related to. This can happen after saving as
    /// part of a close request and it is now save for the delegate to
    /// close.
    ///
    /// Implementations are encouraged to connect to this signal (or
    /// implement the virtual method) and call [`PanelWidgetExt::force_close()`][crate::prelude::PanelWidgetExt::force_close()].
    ///
    ///
    ///
    ///
    /// #### `discard`
    ///  This signal is emitted when the user has requested that the
    /// delegate discard the changes instead of saving them.
    ///
    /// Implementations are encouraged to connect to this signal (or
    /// implement the virtual method) and revert the document to the
    /// last saved state and/or close the document.
    ///
    ///
    ///
    ///
    /// #### `save`
    ///  This signal can be used when subclassing [`SaveDelegate`][crate::SaveDelegate] is not
    /// possible or cumbersome. The default implementation of
    /// `PanelSaveDelegateClass.save_async()` will emit this signal to allow
    /// the consumer to implement asynchronous save in a flexible manner.
    ///
    /// The caller is expected to complete `task` with a boolean when the
    /// save operation has completed.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`SaveDelegateExt`][trait@crate::prelude::SaveDelegateExt], [`trait@glib::ObjectExt`], [`SaveDelegateExtManual`][trait@crate::prelude::SaveDelegateExtManual]
    #[doc(alias = "PanelSaveDelegate")]
    pub struct SaveDelegate(Object<ffi::PanelSaveDelegate, ffi::PanelSaveDelegateClass>);

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

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

    /// Create a new [`SaveDelegate`][crate::SaveDelegate].
    ///
    /// # Returns
    ///
    /// a newly created [`SaveDelegate`][crate::SaveDelegate]
    #[doc(alias = "panel_save_delegate_new")]
    pub fn new() -> SaveDelegate {
        assert_initialized_main_thread!();
        unsafe { from_glib_full(ffi::panel_save_delegate_new()) }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`SaveDelegate`] objects.
    ///
    /// This method returns an instance of [`SaveDelegateBuilder`](crate::builders::SaveDelegateBuilder) which can be used to create [`SaveDelegate`] objects.
    pub fn builder() -> SaveDelegateBuilder {
        SaveDelegateBuilder::new()
    }
}

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`SaveDelegate`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct SaveDelegateBuilder {
    builder: glib::object::ObjectBuilder<'static, SaveDelegate>,
}

impl SaveDelegateBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The "icon" property contains a [`gio::Icon`][crate::gio::Icon] that describes the save
    /// operation. Generally, this should be the symbolic icon of the
    /// document class you are saving.
    ///
    /// Alternatively, you can use [`icon-name`][struct@crate::SaveDelegate#icon-name] for a
    /// named icon.
    pub fn icon(self, icon: &impl IsA<gio::Icon>) -> Self {
        Self {
            builder: self.builder.property("icon", icon.clone().upcast()),
        }
    }

    /// The "icon-name" property contains the name of an icon to use when
    /// showing information about the save operation in UI such as a save
    /// dialog.
    ///
    /// You can also use [`icon`][struct@crate::SaveDelegate#icon] to set a [`gio::Icon`][crate::gio::Icon] instead of
    /// an icon name.
    pub fn icon_name(self, icon_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("icon-name", icon_name.into()),
        }
    }

    /// The "is-draft" property indicates that the document represented by the
    /// delegate is a draft and might be lost of not saved.
    pub fn is_draft(self, is_draft: bool) -> Self {
        Self {
            builder: self.builder.property("is-draft", is_draft),
        }
    }

    /// The "progress" property contains progress between 0.0 and 1.0 and
    /// should be updated by the delegate implementation as saving progresses.
    pub fn progress(self, progress: f64) -> Self {
        Self {
            builder: self.builder.property("progress", progress),
        }
    }

    /// The "subtitle" property contains additional information that may
    /// not make sense to put in the title. This might include the directory
    /// that the file will be saved within.
    pub fn subtitle(self, subtitle: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("subtitle", subtitle.into()),
        }
    }

    /// The "title" property contains the title of the document being saved.
    /// Generally, this should be the base name of the document such as
    /// `file.txt`.
    pub fn title(self, title: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("title", title.into()),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`SaveDelegate`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> SaveDelegate {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}

/// Trait containing all [`struct@SaveDelegate`] methods.
///
/// # Implementors
///
/// [`SaveDelegate`][struct@crate::SaveDelegate]
pub trait SaveDelegateExt: IsA<SaveDelegate> + 'static {
    #[doc(alias = "panel_save_delegate_close")]
    fn close(&self) {
        unsafe {
            ffi::panel_save_delegate_close(self.as_ref().to_glib_none().0);
        }
    }

    #[doc(alias = "panel_save_delegate_discard")]
    fn discard(&self) {
        unsafe {
            ffi::panel_save_delegate_discard(self.as_ref().to_glib_none().0);
        }
    }

    /// Gets the [`gio::Icon`][crate::gio::Icon] for the save delegate, or [`None`] if unset.
    ///
    /// # Returns
    ///
    /// a [`gio::Icon`][crate::gio::Icon] or [`None`]
    #[doc(alias = "panel_save_delegate_get_icon")]
    #[doc(alias = "get_icon")]
    fn icon(&self) -> Option<gio::Icon> {
        unsafe {
            from_glib_none(ffi::panel_save_delegate_get_icon(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the icon name for the save delegate.
    ///
    /// # Returns
    ///
    /// the icon name or [`None`]
    #[doc(alias = "panel_save_delegate_get_icon_name")]
    #[doc(alias = "get_icon_name")]
    #[doc(alias = "icon-name")]
    fn icon_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::panel_save_delegate_get_icon_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "panel_save_delegate_get_is_draft")]
    #[doc(alias = "get_is_draft")]
    #[doc(alias = "is-draft")]
    fn is_draft(&self) -> bool {
        unsafe {
            from_glib(ffi::panel_save_delegate_get_is_draft(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "panel_save_delegate_get_progress")]
    #[doc(alias = "get_progress")]
    fn progress(&self) -> f64 {
        unsafe { ffi::panel_save_delegate_get_progress(self.as_ref().to_glib_none().0) }
    }

    /// Gets the subtitle for the save delegate.
    ///
    /// # Returns
    ///
    /// the subtitle or [`None`]
    #[doc(alias = "panel_save_delegate_get_subtitle")]
    #[doc(alias = "get_subtitle")]
    fn subtitle(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::panel_save_delegate_get_subtitle(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the title for the save delegate.
    ///
    /// # Returns
    ///
    /// the title or [`None`]
    #[doc(alias = "panel_save_delegate_get_title")]
    #[doc(alias = "get_title")]
    fn title(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::panel_save_delegate_get_title(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[doc(alias = "panel_save_delegate_save_async")]
    fn save_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        cancellable: Option<&impl IsA<gio::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 save_async_trampoline<P: FnOnce(Result<(), glib::Error>) + 'static>(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut gio::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            let mut error = std::ptr::null_mut();
            ffi::panel_save_delegate_save_finish(_source_object as *mut _, 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 = save_async_trampoline::<P>;
        unsafe {
            ffi::panel_save_delegate_save_async(
                self.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 save_future(
        &self,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(gio::GioFuture::new(self, move |obj, cancellable, send| {
            obj.save_async(Some(cancellable), move |res| {
                send.resolve(res);
            });
        }))
    }

    /// Sets the [`gio::Icon`][crate::gio::Icon] for the save delegate. Pass [`None`] to unset.
    /// ## `icon`
    /// a [`gio::Icon`][crate::gio::Icon] or [`None`]
    #[doc(alias = "panel_save_delegate_set_icon")]
    #[doc(alias = "icon")]
    fn set_icon(&self, icon: Option<&impl IsA<gio::Icon>>) {
        unsafe {
            ffi::panel_save_delegate_set_icon(
                self.as_ref().to_glib_none().0,
                icon.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the icon name for the save delegate. Pass [`None`] to unset.
    /// ## `icon`
    /// the icon name or [`None`]
    #[doc(alias = "panel_save_delegate_set_icon_name")]
    #[doc(alias = "icon-name")]
    fn set_icon_name(&self, icon: Option<&str>) {
        unsafe {
            ffi::panel_save_delegate_set_icon_name(
                self.as_ref().to_glib_none().0,
                icon.to_glib_none().0,
            );
        }
    }

    #[doc(alias = "panel_save_delegate_set_is_draft")]
    #[doc(alias = "is-draft")]
    fn set_is_draft(&self, is_draft: bool) {
        unsafe {
            ffi::panel_save_delegate_set_is_draft(
                self.as_ref().to_glib_none().0,
                is_draft.into_glib(),
            );
        }
    }

    #[doc(alias = "panel_save_delegate_set_progress")]
    #[doc(alias = "progress")]
    fn set_progress(&self, progress: f64) {
        unsafe {
            ffi::panel_save_delegate_set_progress(self.as_ref().to_glib_none().0, progress);
        }
    }

    /// Sets the subtitle for the save delegate. Pass [`None`] to unset.
    /// ## `subtitle`
    /// the subtitle or [`None`]
    #[doc(alias = "panel_save_delegate_set_subtitle")]
    #[doc(alias = "subtitle")]
    fn set_subtitle(&self, subtitle: Option<&str>) {
        unsafe {
            ffi::panel_save_delegate_set_subtitle(
                self.as_ref().to_glib_none().0,
                subtitle.to_glib_none().0,
            );
        }
    }

    /// Sets the title for the save delegate. Pass [`None`] to unset.
    /// ## `title`
    /// the title or [`None`]
    #[doc(alias = "panel_save_delegate_set_title")]
    #[doc(alias = "title")]
    fn set_title(&self, title: Option<&str>) {
        unsafe {
            ffi::panel_save_delegate_set_title(
                self.as_ref().to_glib_none().0,
                title.to_glib_none().0,
            );
        }
    }

    /// This signal is emitted when the save delegate should close
    /// the widget it is related to. This can happen after saving as
    /// part of a close request and it is now save for the delegate to
    /// close.
    ///
    /// Implementations are encouraged to connect to this signal (or
    /// implement the virtual method) and call [`PanelWidgetExt::force_close()`][crate::prelude::PanelWidgetExt::force_close()].
    #[doc(alias = "close")]
    fn connect_close<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn close_trampoline<P: IsA<SaveDelegate>, F: Fn(&P) + 'static>(
            this: *mut ffi::PanelSaveDelegate,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"close".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    close_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the user has requested that the
    /// delegate discard the changes instead of saving them.
    ///
    /// Implementations are encouraged to connect to this signal (or
    /// implement the virtual method) and revert the document to the
    /// last saved state and/or close the document.
    #[doc(alias = "discard")]
    fn connect_discard<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn discard_trampoline<P: IsA<SaveDelegate>, F: Fn(&P) + 'static>(
            this: *mut ffi::PanelSaveDelegate,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"discard".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    discard_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "icon")]
    fn connect_icon_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_icon_trampoline<P: IsA<SaveDelegate>, F: Fn(&P) + 'static>(
            this: *mut ffi::PanelSaveDelegate,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::icon".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_icon_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "icon-name")]
    fn connect_icon_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_icon_name_trampoline<
            P: IsA<SaveDelegate>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::PanelSaveDelegate,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::icon-name".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_icon_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "is-draft")]
    fn connect_is_draft_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_is_draft_trampoline<
            P: IsA<SaveDelegate>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::PanelSaveDelegate,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::is-draft".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_is_draft_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "progress")]
    fn connect_progress_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_progress_trampoline<
            P: IsA<SaveDelegate>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::PanelSaveDelegate,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::progress".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_progress_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "subtitle")]
    fn connect_subtitle_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_subtitle_trampoline<
            P: IsA<SaveDelegate>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::PanelSaveDelegate,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::subtitle".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_subtitle_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "title")]
    fn connect_title_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_title_trampoline<P: IsA<SaveDelegate>, F: Fn(&P) + 'static>(
            this: *mut ffi::PanelSaveDelegate,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(SaveDelegate::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::title".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_title_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<SaveDelegate>> SaveDelegateExt for O {}