// 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::FileChooser;
use crate::FileChooserAction;
use crate::FileFilter;
use crate::NativeDialog;
use crate::Widget;
use crate::Window;
use glib::object::Cast;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use glib::StaticType;
use glib::ToValue;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// [`FileChooserNative`][crate::FileChooserNative] is an abstraction of a dialog box suitable
    /// for use with “File/Open” or “File/Save as” commands. By default, this
    /// just uses a [`FileChooserDialog`][crate::FileChooserDialog] to implement the actual dialog.
    /// However, on certain platforms, such as Windows and macOS, the native platform
    /// file chooser is used instead. When the application is running in a
    /// sandboxed environment without direct filesystem access (such as Flatpak),
    /// [`FileChooserNative`][crate::FileChooserNative] may call the proper APIs (portals) to let the user
    /// choose a file and make it available to the application.
    ///
    /// While the API of [`FileChooserNative`][crate::FileChooserNative] closely mirrors [`FileChooserDialog`][crate::FileChooserDialog], the main
    /// difference is that there is no access to any [`Window`][crate::Window] or [`Widget`][crate::Widget] for the dialog.
    /// This is required, as there may not be one in the case of a platform native dialog.
    /// Showing, hiding and running the dialog is handled by the [`NativeDialog`][crate::NativeDialog] functions.
    ///
    /// ## Typical usage ## {`gtkfilechoosernative`-typical-usage}
    ///
    /// In the simplest of cases, you can the following code to use
    /// [`FileChooserDialog`][crate::FileChooserDialog] to select a file for opening:
    ///
    ///
    /// ```text
    /// GtkFileChooserNative *native;
    /// GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_OPEN;
    /// gint res;
    ///
    /// native = gtk_file_chooser_native_new ("Open File",
    ///                                       parent_window,
    ///                                       action,
    ///                                       "_Open",
    ///                                       "_Cancel");
    ///
    /// res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (native));
    /// if (res == GTK_RESPONSE_ACCEPT)
    ///   {
    ///     char *filename;
    ///     GtkFileChooser *chooser = GTK_FILE_CHOOSER (native);
    ///     filename = gtk_file_chooser_get_filename (chooser);
    ///     open_file (filename);
    ///     g_free (filename);
    ///   }
    ///
    /// g_object_unref (native);
    /// ```
    ///
    /// To use a dialog for saving, you can use this:
    ///
    ///
    /// ```text
    /// GtkFileChooserNative *native;
    /// GtkFileChooser *chooser;
    /// GtkFileChooserAction action = GTK_FILE_CHOOSER_ACTION_SAVE;
    /// gint res;
    ///
    /// native = gtk_file_chooser_native_new ("Save File",
    ///                                       parent_window,
    ///                                       action,
    ///                                       "_Save",
    ///                                       "_Cancel");
    /// chooser = GTK_FILE_CHOOSER (native);
    ///
    /// gtk_file_chooser_set_do_overwrite_confirmation (chooser, TRUE);
    ///
    /// if (user_edited_a_new_document)
    ///   gtk_file_chooser_set_current_name (chooser,
    ///                                      _("Untitled document"));
    /// else
    ///   gtk_file_chooser_set_filename (chooser,
    ///                                  existing_filename);
    ///
    /// res = gtk_native_dialog_run (GTK_NATIVE_DIALOG (native));
    /// if (res == GTK_RESPONSE_ACCEPT)
    ///   {
    ///     char *filename;
    ///
    ///     filename = gtk_file_chooser_get_filename (chooser);
    ///     save_to_file (filename);
    ///     g_free (filename);
    ///   }
    ///
    /// g_object_unref (native);
    /// ```
    ///
    /// For more information on how to best set up a file dialog, see [`FileChooserDialog`][crate::FileChooserDialog].
    ///
    /// ## Response Codes ## {`gtkfilechooserdialognative`-responses}
    ///
    /// [`FileChooserNative`][crate::FileChooserNative] inherits from [`NativeDialog`][crate::NativeDialog], which means it
    /// will return [`ResponseType::Accept`][crate::ResponseType::Accept] if the user accepted, and
    /// [`ResponseType::Cancel`][crate::ResponseType::Cancel] if he pressed cancel. It can also return
    /// [`ResponseType::DeleteEvent`][crate::ResponseType::DeleteEvent] if the window was unexpectedly closed.
    ///
    /// ## Differences from [`FileChooserDialog`][crate::FileChooserDialog] ## {`gtkfilechooserdialognative`-differences}
    ///
    /// There are a few things in the GtkFileChooser API that are not
    /// possible to use with [`FileChooserNative`][crate::FileChooserNative], as such use would
    /// prohibit the use of a native dialog.
    ///
    /// There is no support for the signals that are emitted when the user
    /// navigates in the dialog, including:
    /// * `signal::FileChooser::current-folder-changed`
    /// * `signal::FileChooser::selection-changed`
    /// * `signal::FileChooser::file-activated`
    /// * `signal::FileChooser::confirm-overwrite`
    ///
    /// You can also not use the methods that directly control user navigation:
    /// * [`FileChooserExt::unselect_filename()`][crate::prelude::FileChooserExt::unselect_filename()]
    /// * [`FileChooserExt::select_all()`][crate::prelude::FileChooserExt::select_all()]
    /// * [`FileChooserExt::unselect_all()`][crate::prelude::FileChooserExt::unselect_all()]
    ///
    /// If you need any of the above you will have to use [`FileChooserDialog`][crate::FileChooserDialog] directly.
    ///
    /// No operations that change the the dialog work while the dialog is
    /// visible. Set all the properties that are required before showing the dialog.
    ///
    /// ## Win32 details ## {`gtkfilechooserdialognative`-win32}
    ///
    /// On windows the IFileDialog implementation (added in Windows Vista) is
    /// used. It supports many of the features that [`FileChooserDialog`][crate::FileChooserDialog]
    /// does, but there are some things it does not handle:
    ///
    /// * Extra widgets added with [`FileChooserExt::set_extra_widget()`][crate::prelude::FileChooserExt::set_extra_widget()].
    ///
    /// * Use of custom previews by connecting to `signal::FileChooser::update-preview`.
    ///
    /// * Any [`FileFilter`][crate::FileFilter] added using a mimetype or custom filter.
    ///
    /// If any of these features are used the regular [`FileChooserDialog`][crate::FileChooserDialog]
    /// will be used in place of the native one.
    ///
    /// ## Portal details ## {`gtkfilechooserdialognative`-portal}
    ///
    /// When the org.freedesktop.portal.FileChooser portal is available on the
    /// session bus, it is used to bring up an out-of-process file chooser. Depending
    /// on the kind of session the application is running in, this may or may not
    /// be a GTK+ file chooser. In this situation, the following things are not
    /// supported and will be silently ignored:
    ///
    /// * Extra widgets added with [`FileChooserExt::set_extra_widget()`][crate::prelude::FileChooserExt::set_extra_widget()].
    ///
    /// * Use of custom previews by connecting to `signal::FileChooser::update-preview`.
    ///
    /// * Any [`FileFilter`][crate::FileFilter] added with a custom filter.
    ///
    /// ## macOS details ## {`gtkfilechooserdialognative`-macos}
    ///
    /// On macOS the NSSavePanel and NSOpenPanel classes are used to provide native
    /// file chooser dialogs. Some features provided by [`FileChooserDialog`][crate::FileChooserDialog] are
    /// not supported:
    ///
    /// * Extra widgets added with [`FileChooserExt::set_extra_widget()`][crate::prelude::FileChooserExt::set_extra_widget()], unless the
    ///  widget is an instance of GtkLabel, in which case the label text will be used
    ///  to set the NSSavePanel message instance property.
    ///
    /// * Use of custom previews by connecting to `signal::FileChooser::update-preview`.
    ///
    /// * Any [`FileFilter`][crate::FileFilter] added with a custom filter.
    ///
    /// * Shortcut folders.
    ///
    /// # Implements
    ///
    /// [`NativeDialogExt`][trait@crate::prelude::NativeDialogExt], [`trait@glib::ObjectExt`], [`FileChooserExt`][trait@crate::prelude::FileChooserExt], [`NativeDialogExtManual`][trait@crate::prelude::NativeDialogExtManual]
    #[doc(alias = "GtkFileChooserNative")]
    pub struct FileChooserNative(Object<ffi::GtkFileChooserNative, ffi::GtkFileChooserNativeClass>) @extends NativeDialog, @implements FileChooser;

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

impl FileChooserNative {
    /// Creates a new [`FileChooserNative`][crate::FileChooserNative].
    /// ## `title`
    /// Title of the native, or [`None`]
    /// ## `parent`
    /// Transient parent of the native, or [`None`]
    /// ## `action`
    /// Open or save mode for the dialog
    /// ## `accept_label`
    /// text to go in the accept button, or [`None`] for the default
    /// ## `cancel_label`
    /// text to go in the cancel button, or [`None`] for the default
    ///
    /// # Returns
    ///
    /// a new [`FileChooserNative`][crate::FileChooserNative]
    #[doc(alias = "gtk_file_chooser_native_new")]
    pub fn new<P: IsA<Window>>(
        title: Option<&str>,
        parent: Option<&P>,
        action: FileChooserAction,
        accept_label: Option<&str>,
        cancel_label: Option<&str>,
    ) -> FileChooserNative {
        assert_initialized_main_thread!();
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_native_new(
                title.to_glib_none().0,
                parent.map(|p| p.as_ref()).to_glib_none().0,
                action.into_glib(),
                accept_label.to_glib_none().0,
                cancel_label.to_glib_none().0,
            ))
        }
    }

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

    /// Retrieves the custom label text for the accept button.
    ///
    /// # Returns
    ///
    /// The custom label, or [`None`] for the default. This string
    /// is owned by GTK+ and should not be modified or freed
    #[doc(alias = "gtk_file_chooser_native_get_accept_label")]
    #[doc(alias = "get_accept_label")]
    pub fn accept_label(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_native_get_accept_label(
                self.to_glib_none().0,
            ))
        }
    }

    /// Retrieves the custom label text for the cancel button.
    ///
    /// # Returns
    ///
    /// The custom label, or [`None`] for the default. This string
    /// is owned by GTK+ and should not be modified or freed
    #[doc(alias = "gtk_file_chooser_native_get_cancel_label")]
    #[doc(alias = "get_cancel_label")]
    pub fn cancel_label(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_native_get_cancel_label(
                self.to_glib_none().0,
            ))
        }
    }

    /// Sets the custom label text for the accept button.
    ///
    /// If characters in `label` are preceded by an underscore, they are underlined.
    /// If you need a literal underscore character in a label, use “__” (two
    /// underscores). The first underlined character represents a keyboard
    /// accelerator called a mnemonic.
    /// Pressing Alt and that key activates the button.
    /// ## `accept_label`
    /// custom label or [`None`] for the default
    #[doc(alias = "gtk_file_chooser_native_set_accept_label")]
    pub fn set_accept_label(&self, accept_label: Option<&str>) {
        unsafe {
            ffi::gtk_file_chooser_native_set_accept_label(
                self.to_glib_none().0,
                accept_label.to_glib_none().0,
            );
        }
    }

    /// Sets the custom label text for the cancel button.
    ///
    /// If characters in `label` are preceded by an underscore, they are underlined.
    /// If you need a literal underscore character in a label, use “__” (two
    /// underscores). The first underlined character represents a keyboard
    /// accelerator called a mnemonic.
    /// Pressing Alt and that key activates the button.
    /// ## `cancel_label`
    /// custom label or [`None`] for the default
    #[doc(alias = "gtk_file_chooser_native_set_cancel_label")]
    pub fn set_cancel_label(&self, cancel_label: Option<&str>) {
        unsafe {
            ffi::gtk_file_chooser_native_set_cancel_label(
                self.to_glib_none().0,
                cancel_label.to_glib_none().0,
            );
        }
    }

    /// The text used for the label on the accept button in the dialog, or
    /// [`None`] to use the default text.
    #[doc(alias = "accept-label")]
    pub fn get_property_accept_label(&self) -> Option<glib::GString> {
        unsafe {
            let mut value = glib::Value::from_type(<glib::GString as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.as_ptr() as *mut glib::gobject_ffi::GObject,
                b"accept-label\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `accept-label` getter")
        }
    }

    /// The text used for the label on the accept button in the dialog, or
    /// [`None`] to use the default text.
    #[doc(alias = "accept-label")]
    pub fn set_property_accept_label(&self, accept_label: Option<&str>) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.as_ptr() as *mut glib::gobject_ffi::GObject,
                b"accept-label\0".as_ptr() as *const _,
                accept_label.to_value().to_glib_none().0,
            );
        }
    }

    /// The text used for the label on the cancel button in the dialog, or
    /// [`None`] to use the default text.
    #[doc(alias = "cancel-label")]
    pub fn get_property_cancel_label(&self) -> Option<glib::GString> {
        unsafe {
            let mut value = glib::Value::from_type(<glib::GString as StaticType>::static_type());
            glib::gobject_ffi::g_object_get_property(
                self.as_ptr() as *mut glib::gobject_ffi::GObject,
                b"cancel-label\0".as_ptr() as *const _,
                value.to_glib_none_mut().0,
            );
            value
                .get()
                .expect("Return Value for property `cancel-label` getter")
        }
    }

    /// The text used for the label on the cancel button in the dialog, or
    /// [`None`] to use the default text.
    #[doc(alias = "cancel-label")]
    pub fn set_property_cancel_label(&self, cancel_label: Option<&str>) {
        unsafe {
            glib::gobject_ffi::g_object_set_property(
                self.as_ptr() as *mut glib::gobject_ffi::GObject,
                b"cancel-label\0".as_ptr() as *const _,
                cancel_label.to_value().to_glib_none().0,
            );
        }
    }

    #[doc(alias = "accept-label")]
    pub fn connect_accept_label_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_accept_label_trampoline<F: Fn(&FileChooserNative) + 'static>(
            this: *mut ffi::GtkFileChooserNative,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::accept-label\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_accept_label_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "cancel-label")]
    pub fn connect_cancel_label_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_cancel_label_trampoline<F: Fn(&FileChooserNative) + 'static>(
            this: *mut ffi::GtkFileChooserNative,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::cancel-label\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_cancel_label_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

#[derive(Clone, Default)]
// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`FileChooserNative`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
pub struct FileChooserNativeBuilder {
    accept_label: Option<String>,
    cancel_label: Option<String>,
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    modal: Option<bool>,
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    title: Option<String>,
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    transient_for: Option<Window>,
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    visible: Option<bool>,
    action: Option<FileChooserAction>,
    create_folders: Option<bool>,
    do_overwrite_confirmation: Option<bool>,
    extra_widget: Option<Widget>,
    filter: Option<FileFilter>,
    local_only: Option<bool>,
    preview_widget: Option<Widget>,
    preview_widget_active: Option<bool>,
    select_multiple: Option<bool>,
    show_hidden: Option<bool>,
    use_preview_label: Option<bool>,
}

impl FileChooserNativeBuilder {
    // rustdoc-stripper-ignore-next
    /// Create a new [`FileChooserNativeBuilder`].
    pub fn new() -> Self {
        Self::default()
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`FileChooserNative`].
    pub fn build(self) -> FileChooserNative {
        let mut properties: Vec<(&str, &dyn ToValue)> = vec![];
        if let Some(ref accept_label) = self.accept_label {
            properties.push(("accept-label", accept_label));
        }
        if let Some(ref cancel_label) = self.cancel_label {
            properties.push(("cancel-label", cancel_label));
        }
        #[cfg(any(feature = "v3_20", feature = "dox"))]
        if let Some(ref modal) = self.modal {
            properties.push(("modal", modal));
        }
        #[cfg(any(feature = "v3_20", feature = "dox"))]
        if let Some(ref title) = self.title {
            properties.push(("title", title));
        }
        #[cfg(any(feature = "v3_20", feature = "dox"))]
        if let Some(ref transient_for) = self.transient_for {
            properties.push(("transient-for", transient_for));
        }
        #[cfg(any(feature = "v3_20", feature = "dox"))]
        if let Some(ref visible) = self.visible {
            properties.push(("visible", visible));
        }
        if let Some(ref action) = self.action {
            properties.push(("action", action));
        }
        if let Some(ref create_folders) = self.create_folders {
            properties.push(("create-folders", create_folders));
        }
        if let Some(ref do_overwrite_confirmation) = self.do_overwrite_confirmation {
            properties.push(("do-overwrite-confirmation", do_overwrite_confirmation));
        }
        if let Some(ref extra_widget) = self.extra_widget {
            properties.push(("extra-widget", extra_widget));
        }
        if let Some(ref filter) = self.filter {
            properties.push(("filter", filter));
        }
        if let Some(ref local_only) = self.local_only {
            properties.push(("local-only", local_only));
        }
        if let Some(ref preview_widget) = self.preview_widget {
            properties.push(("preview-widget", preview_widget));
        }
        if let Some(ref preview_widget_active) = self.preview_widget_active {
            properties.push(("preview-widget-active", preview_widget_active));
        }
        if let Some(ref select_multiple) = self.select_multiple {
            properties.push(("select-multiple", select_multiple));
        }
        if let Some(ref show_hidden) = self.show_hidden {
            properties.push(("show-hidden", show_hidden));
        }
        if let Some(ref use_preview_label) = self.use_preview_label {
            properties.push(("use-preview-label", use_preview_label));
        }
        glib::Object::new::<FileChooserNative>(&properties)
            .expect("Failed to create an instance of FileChooserNative")
    }

    /// The text used for the label on the accept button in the dialog, or
    /// [`None`] to use the default text.
    pub fn accept_label(mut self, accept_label: &str) -> Self {
        self.accept_label = Some(accept_label.to_string());
        self
    }

    /// The text used for the label on the cancel button in the dialog, or
    /// [`None`] to use the default text.
    pub fn cancel_label(mut self, cancel_label: &str) -> Self {
        self.cancel_label = Some(cancel_label.to_string());
        self
    }

    /// Whether the window should be modal with respect to its transient parent.
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    pub fn modal(mut self, modal: bool) -> Self {
        self.modal = Some(modal);
        self
    }

    /// The title of the dialog window
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    pub fn title(mut self, title: &str) -> Self {
        self.title = Some(title.to_string());
        self
    }

    /// The transient parent of the dialog, or [`None`] for none.
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    pub fn transient_for<P: IsA<Window>>(mut self, transient_for: &P) -> Self {
        self.transient_for = Some(transient_for.clone().upcast());
        self
    }

    /// Whether the window is currenlty visible.
    #[cfg(any(feature = "v3_20", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_20")))]
    pub fn visible(mut self, visible: bool) -> Self {
        self.visible = Some(visible);
        self
    }

    pub fn action(mut self, action: FileChooserAction) -> Self {
        self.action = Some(action);
        self
    }

    /// Whether a file chooser not in [`FileChooserAction::Open`][crate::FileChooserAction::Open] mode
    /// will offer the user to create new folders.
    pub fn create_folders(mut self, create_folders: bool) -> Self {
        self.create_folders = Some(create_folders);
        self
    }

    /// Whether a file chooser in [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode
    /// will present an overwrite confirmation dialog if the user
    /// selects a file name that already exists.
    pub fn do_overwrite_confirmation(mut self, do_overwrite_confirmation: bool) -> Self {
        self.do_overwrite_confirmation = Some(do_overwrite_confirmation);
        self
    }

    pub fn extra_widget<P: IsA<Widget>>(mut self, extra_widget: &P) -> Self {
        self.extra_widget = Some(extra_widget.clone().upcast());
        self
    }

    pub fn filter(mut self, filter: &FileFilter) -> Self {
        self.filter = Some(filter.clone());
        self
    }

    pub fn local_only(mut self, local_only: bool) -> Self {
        self.local_only = Some(local_only);
        self
    }

    pub fn preview_widget<P: IsA<Widget>>(mut self, preview_widget: &P) -> Self {
        self.preview_widget = Some(preview_widget.clone().upcast());
        self
    }

    pub fn preview_widget_active(mut self, preview_widget_active: bool) -> Self {
        self.preview_widget_active = Some(preview_widget_active);
        self
    }

    pub fn select_multiple(mut self, select_multiple: bool) -> Self {
        self.select_multiple = Some(select_multiple);
        self
    }

    pub fn show_hidden(mut self, show_hidden: bool) -> Self {
        self.show_hidden = Some(show_hidden);
        self
    }

    pub fn use_preview_label(mut self, use_preview_label: bool) -> Self {
        self.use_preview_label = Some(use_preview_label);
        self
    }
}

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