gtk/auto/

native_dialog.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::{ResponseType, Window, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// Native dialogs are platform dialogs that don't use [`Dialog`][crate::Dialog] or
    /// [`Window`][crate::Window]. They are used in order to integrate better with a
    /// platform, by looking the same as other native applications and
    /// supporting platform specific features.
    ///
    /// The [`Dialog`][crate::Dialog] functions cannot be used on such objects, but we
    /// need a similar API in order to drive them. The [`NativeDialog`][crate::NativeDialog]
    /// object is an API that allows you to do this. It allows you to set
    /// various common properties on the dialog, as well as show and hide
    /// it and get a [`response`][struct@crate::NativeDialog#response] signal when the user finished
    /// with the dialog.
    ///
    /// There is also a [`NativeDialogExt::run()`][crate::prelude::NativeDialogExt::run()] helper that makes it easy
    /// to run any native dialog in a modal way with a recursive mainloop,
    /// similar to [`DialogExt::run()`][crate::prelude::DialogExt::run()].
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `modal`
    ///  Whether the window should be modal with respect to its transient parent.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `title`
    ///  The title of the dialog window
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `transient-for`
    ///  The transient parent of the dialog, or [`None`] for none.
    ///
    /// Readable | Writable | Construct
    ///
    ///
    /// #### `visible`
    ///  Whether the window is currenlty visible.
    ///
    /// Readable | Writable
    ///
    /// ## Signals
    ///
    ///
    /// #### `response`
    ///  Emitted when the user responds to the dialog.
    ///
    /// When this is called the dialog has been hidden.
    ///
    /// If you call [`NativeDialogExt::hide()`][crate::prelude::NativeDialogExt::hide()] before the user responds to
    /// the dialog this signal will not be emitted.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`NativeDialogExt`][trait@crate::prelude::NativeDialogExt], [`trait@glib::ObjectExt`], [`NativeDialogExtManual`][trait@crate::prelude::NativeDialogExtManual]
    #[doc(alias = "GtkNativeDialog")]
    pub struct NativeDialog(Object<ffi::GtkNativeDialog, ffi::GtkNativeDialogClass>);

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

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

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

    /// Returns whether the dialog is modal. See [`set_modal()`][Self::set_modal()].
    ///
    /// # Returns
    ///
    /// [`true`] if the dialog is set to be modal
    #[doc(alias = "gtk_native_dialog_get_modal")]
    #[doc(alias = "get_modal")]
    #[doc(alias = "modal")]
    fn is_modal(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_native_dialog_get_modal(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the title of the [`NativeDialog`][crate::NativeDialog].
    ///
    /// # Returns
    ///
    /// the title of the dialog, or [`None`] if none has
    ///  been set explicitly. The returned string is owned by the widget
    ///  and must not be modified or freed.
    #[doc(alias = "gtk_native_dialog_get_title")]
    #[doc(alias = "get_title")]
    fn title(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_native_dialog_get_title(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Fetches the transient parent for this window. See
    /// [`set_transient_for()`][Self::set_transient_for()].
    ///
    /// # Returns
    ///
    /// the transient parent for this window,
    /// or [`None`] if no transient parent has been set.
    #[doc(alias = "gtk_native_dialog_get_transient_for")]
    #[doc(alias = "get_transient_for")]
    #[doc(alias = "transient-for")]
    fn transient_for(&self) -> Option<Window> {
        unsafe {
            from_glib_none(ffi::gtk_native_dialog_get_transient_for(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Determines whether the dialog is visible.
    ///
    /// # Returns
    ///
    /// [`true`] if the dialog is visible
    #[doc(alias = "gtk_native_dialog_get_visible")]
    #[doc(alias = "get_visible")]
    #[doc(alias = "visible")]
    fn is_visible(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_native_dialog_get_visible(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Hides the dialog if it is visilbe, aborting any interaction. Once this
    /// is called the [`response`][struct@crate::NativeDialog#response] signal will not be emitted
    /// until after the next call to [`show()`][Self::show()].
    ///
    /// If the dialog is not visible this does nothing.
    #[doc(alias = "gtk_native_dialog_hide")]
    fn hide(&self) {
        unsafe {
            ffi::gtk_native_dialog_hide(self.as_ref().to_glib_none().0);
        }
    }

    /// Blocks in a recursive main loop until `self` emits the
    /// [`response`][struct@crate::NativeDialog#response] signal. It then returns the response ID
    /// from the ::response signal emission.
    ///
    /// Before entering the recursive main loop, [`run()`][Self::run()]
    /// calls [`show()`][Self::show()] on the dialog for you.
    ///
    /// After [`run()`][Self::run()] returns, then dialog will be hidden.
    ///
    /// Typical usage of this function might be:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///   gint result = gtk_native_dialog_run (GTK_NATIVE_DIALOG (dialog));
    ///   switch (result)
    ///     {
    ///       case GTK_RESPONSE_ACCEPT:
    ///          do_application_specific_something ();
    ///          break;
    ///       default:
    ///          do_nothing_since_dialog_was_cancelled ();
    ///          break;
    ///     }
    ///   g_object_unref (dialog);
    /// ```
    ///
    /// Note that even though the recursive main loop gives the effect of a
    /// modal dialog (it prevents the user from interacting with other
    /// windows in the same window group while the dialog is run), callbacks
    /// such as timeouts, IO channel watches, DND drops, etc, will
    /// be triggered during a [`run()`][Self::run()] call.
    ///
    /// # Returns
    ///
    /// response ID
    #[doc(alias = "gtk_native_dialog_run")]
    fn run(&self) -> ResponseType {
        unsafe { from_glib(ffi::gtk_native_dialog_run(self.as_ref().to_glib_none().0)) }
    }

    /// Sets a dialog modal or non-modal. Modal dialogs prevent interaction
    /// with other windows in the same application. To keep modal dialogs
    /// on top of main application windows, use
    /// [`set_transient_for()`][Self::set_transient_for()] to make the dialog transient for the
    /// parent; most [window managers][gtk-X11-arch]
    /// will then disallow lowering the dialog below the parent.
    /// ## `modal`
    /// whether the window is modal
    #[doc(alias = "gtk_native_dialog_set_modal")]
    #[doc(alias = "modal")]
    fn set_modal(&self, modal: bool) {
        unsafe {
            ffi::gtk_native_dialog_set_modal(self.as_ref().to_glib_none().0, modal.into_glib());
        }
    }

    /// Sets the title of the [`NativeDialog`][crate::NativeDialog].
    /// ## `title`
    /// title of the dialog
    #[doc(alias = "gtk_native_dialog_set_title")]
    #[doc(alias = "title")]
    fn set_title(&self, title: &str) {
        unsafe {
            ffi::gtk_native_dialog_set_title(
                self.as_ref().to_glib_none().0,
                title.to_glib_none().0,
            );
        }
    }

    /// Dialog windows should be set transient for the main application
    /// window they were spawned from. This allows
    /// [window managers][gtk-X11-arch] to e.g. keep the
    /// dialog on top of the main window, or center the dialog over the
    /// main window.
    ///
    /// Passing [`None`] for `parent` unsets the current transient window.
    /// ## `parent`
    /// parent window, or [`None`]
    #[doc(alias = "gtk_native_dialog_set_transient_for")]
    #[doc(alias = "transient-for")]
    fn set_transient_for(&self, parent: Option<&impl IsA<Window>>) {
        unsafe {
            ffi::gtk_native_dialog_set_transient_for(
                self.as_ref().to_glib_none().0,
                parent.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Shows the dialog on the display, allowing the user to interact with
    /// it. When the user accepts the state of the dialog the dialog will
    /// be automatically hidden and the [`response`][struct@crate::NativeDialog#response] signal
    /// will be emitted.
    ///
    /// Multiple calls while the dialog is visible will be ignored.
    #[doc(alias = "gtk_native_dialog_show")]
    fn show(&self) {
        unsafe {
            ffi::gtk_native_dialog_show(self.as_ref().to_glib_none().0);
        }
    }

    /// Whether the window is currenlty visible.
    fn set_visible(&self, visible: bool) {
        ObjectExt::set_property(self.as_ref(), "visible", visible)
    }

    /// Emitted when the user responds to the dialog.
    ///
    /// When this is called the dialog has been hidden.
    ///
    /// If you call [`hide()`][Self::hide()] before the user responds to
    /// the dialog this signal will not be emitted.
    /// ## `response_id`
    /// the response ID
    #[doc(alias = "response")]
    fn connect_response<F: Fn(&Self, ResponseType) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn response_trampoline<
            P: IsA<NativeDialog>,
            F: Fn(&P, ResponseType) + 'static,
        >(
            this: *mut ffi::GtkNativeDialog,
            response_id: ffi::GtkResponseType,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    NativeDialog::from_glib_borrow(this).unsafe_cast_ref(),
                    from_glib(response_id),
                )
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"response".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    response_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "modal")]
    fn connect_modal_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_modal_trampoline<P: IsA<NativeDialog>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkNativeDialog,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(NativeDialog::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::modal".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_modal_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<NativeDialog>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkNativeDialog,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(NativeDialog::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(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_title_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

impl<O: IsA<NativeDialog>> NativeDialogExt for O {}