gtk/auto/

file_chooser.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::{FileChooserAction, FileChooserConfirmation, FileFilter, Widget, ffi};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// [`FileChooser`][crate::FileChooser] is an interface that can be implemented by file
    /// selection widgets. In GTK+, the main objects that implement this
    /// interface are [`FileChooserWidget`][crate::FileChooserWidget], [`FileChooserDialog`][crate::FileChooserDialog], and
    /// [`FileChooserButton`][crate::FileChooserButton]. You do not need to write an object that
    /// implements the [`FileChooser`][crate::FileChooser] interface unless you are trying to
    /// adapt an existing file selector to expose a standard programming
    /// interface.
    ///
    /// [`FileChooser`][crate::FileChooser] allows for shortcuts to various places in the filesystem.
    /// In the default implementation these are displayed in the left pane. It
    /// may be a bit confusing at first that these shortcuts come from various
    /// sources and in various flavours, so lets explain the terminology here:
    ///
    /// - Bookmarks: are created by the user, by dragging folders from the
    ///  right pane to the left pane, or by using the “Add”. Bookmarks
    ///  can be renamed and deleted by the user.
    ///
    /// - Shortcuts: can be provided by the application. For example, a Paint
    ///  program may want to add a shortcut for a Clipart folder. Shortcuts
    ///  cannot be modified by the user.
    ///
    /// - Volumes: are provided by the underlying filesystem abstraction. They are
    ///  the “roots” of the filesystem.
    ///
    /// # File Names and Encodings
    ///
    /// When the user is finished selecting files in a
    /// [`FileChooser`][crate::FileChooser], your program can get the selected names
    /// either as filenames or as URIs. For URIs, the normal escaping
    /// rules are applied if the URI contains non-ASCII characters.
    /// However, filenames are always returned in
    /// the character set specified by the
    /// `G_FILENAME_ENCODING` environment variable.
    /// Please see the GLib documentation for more details about this
    /// variable.
    ///
    /// This means that while you can pass the result of
    /// [`FileChooserExt::filename()`][crate::prelude::FileChooserExt::filename()] to `g_open()` or `g_fopen()`,
    /// you may not be able to directly set it as the text of a
    /// [`Label`][crate::Label] widget unless you convert it first to UTF-8,
    /// which all GTK+ widgets expect. You should use `g_filename_to_utf8()`
    /// to convert filenames into strings that can be passed to GTK+
    /// widgets.
    ///
    /// # Adding a Preview Widget
    ///
    /// You can add a custom preview widget to a file chooser and then
    /// get notification about when the preview needs to be updated.
    /// To install a preview widget, use
    /// [`FileChooserExt::set_preview_widget()`][crate::prelude::FileChooserExt::set_preview_widget()]. Then, connect to the
    /// [`update-preview`][struct@crate::FileChooser#update-preview] signal to get notified when
    /// you need to update the contents of the preview.
    ///
    /// Your callback should use
    /// [`FileChooserExt::preview_filename()`][crate::prelude::FileChooserExt::preview_filename()] to see what needs
    /// previewing. Once you have generated the preview for the
    /// corresponding file, you must call
    /// [`FileChooserExt::set_preview_widget_active()`][crate::prelude::FileChooserExt::set_preview_widget_active()] with a boolean
    /// flag that indicates whether your callback could successfully
    /// generate a preview.
    ///
    /// ## Example: Using a Preview Widget ## {`gtkfilechooser`-preview}
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// {
    ///   GtkImage *preview;
    ///
    ///   ...
    ///
    ///   preview = gtk_image_new ();
    ///
    ///   gtk_file_chooser_set_preview_widget (my_file_chooser, preview);
    ///   g_signal_connect (my_file_chooser, "update-preview",
    ///             G_CALLBACK (update_preview_cb), preview);
    /// }
    ///
    /// static void
    /// update_preview_cb (GtkFileChooser *file_chooser, gpointer data)
    /// {
    ///   GtkWidget *preview;
    ///   char *filename;
    ///   GdkPixbuf *pixbuf;
    ///   gboolean have_preview;
    ///
    ///   preview = GTK_WIDGET (data);
    ///   filename = gtk_file_chooser_get_preview_filename (file_chooser);
    ///
    ///   pixbuf = gdk_pixbuf_new_from_file_at_size (filename, 128, 128, NULL);
    ///   have_preview = (pixbuf != NULL);
    ///   g_free (filename);
    ///
    ///   gtk_image_set_from_pixbuf (GTK_IMAGE (preview), pixbuf);
    ///   if (pixbuf)
    ///     g_object_unref (pixbuf);
    ///
    ///   gtk_file_chooser_set_preview_widget_active (file_chooser, have_preview);
    /// }
    /// ```
    ///
    /// # Adding Extra Widgets
    ///
    /// You can add extra widgets to a file chooser to provide options
    /// that are not present in the default design. For example, you
    /// can add a toggle button to give the user the option to open a
    /// file in read-only mode. You can use
    /// [`FileChooserExt::set_extra_widget()`][crate::prelude::FileChooserExt::set_extra_widget()] to insert additional
    /// widgets in a file chooser.
    ///
    /// An example for adding extra widgets:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    ///
    ///   GtkWidget *toggle;
    ///
    ///   ...
    ///
    ///   toggle = gtk_check_button_new_with_label ("Open file read-only");
    ///   gtk_widget_show (toggle);
    ///   gtk_file_chooser_set_extra_widget (my_file_chooser, toggle);
    /// }
    /// ```
    ///
    /// If you want to set more than one extra widget in the file
    /// chooser, you can a container such as a [`Box`][crate::Box] or a [`Grid`][crate::Grid]
    /// and include your widgets in it. Then, set the container as
    /// the whole extra widget.
    ///
    /// ## Properties
    ///
    ///
    /// #### `action`
    ///  Readable | Writable
    ///
    ///
    /// #### `create-folders`
    ///  Whether a file chooser not in [`FileChooserAction::Open`][crate::FileChooserAction::Open] mode
    /// will offer the user to create new folders.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `do-overwrite-confirmation`
    ///  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.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `extra-widget`
    ///  Readable | Writable
    ///
    ///
    /// #### `filter`
    ///  Readable | Writable
    ///
    ///
    /// #### `local-only`
    ///  Readable | Writable
    ///
    ///
    /// #### `preview-widget`
    ///  Readable | Writable
    ///
    ///
    /// #### `preview-widget-active`
    ///  Readable | Writable
    ///
    ///
    /// #### `select-multiple`
    ///  Readable | Writable
    ///
    ///
    /// #### `show-hidden`
    ///  Readable | Writable
    ///
    ///
    /// #### `use-preview-label`
    ///  Readable | Writable
    ///
    /// ## Signals
    ///
    ///
    /// #### `confirm-overwrite`
    ///  This signal gets emitted whenever it is appropriate to present a
    /// confirmation dialog when the user has selected a file name that
    /// already exists. The signal only gets emitted when the file
    /// chooser is in [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode.
    ///
    /// Most applications just need to turn on the
    /// [`do-overwrite-confirmation`][struct@crate::FileChooser#do-overwrite-confirmation] property (or call the
    /// [`FileChooserExt::set_do_overwrite_confirmation()`][crate::prelude::FileChooserExt::set_do_overwrite_confirmation()] function), and
    /// they will automatically get a stock confirmation dialog.
    /// Applications which need to customize this behavior should do
    /// that, and also connect to the [`confirm-overwrite`][struct@crate::FileChooser#confirm-overwrite]
    /// signal.
    ///
    /// A signal handler for this signal must return a
    /// [`FileChooserConfirmation`][crate::FileChooserConfirmation] value, which indicates the action to
    /// take. If the handler determines that the user wants to select a
    /// different filename, it should return
    /// [`FileChooserConfirmation::SelectAgain`][crate::FileChooserConfirmation::SelectAgain]. If it determines
    /// that the user is satisfied with his choice of file name, it
    /// should return [`FileChooserConfirmation::AcceptFilename`][crate::FileChooserConfirmation::AcceptFilename].
    /// On the other hand, if it determines that the stock confirmation
    /// dialog should be used, it should return
    /// [`FileChooserConfirmation::Confirm`][crate::FileChooserConfirmation::Confirm]. The following example
    /// illustrates this.
    ///
    /// ## Custom confirmation ## {`gtkfilechooser`-confirmation}
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static GtkFileChooserConfirmation
    /// confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data)
    /// {
    ///   char *uri;
    ///
    ///   uri = gtk_file_chooser_get_uri (chooser);
    ///
    ///   if (is_uri_read_only (uri))
    ///     {
    ///       if (user_wants_to_replace_read_only_file (uri))
    ///         return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME;
    ///       else
    ///         return GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN;
    ///     } else
    ///       return GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM; // fall back to the default dialog
    /// }
    ///
    /// ...
    ///
    /// chooser = gtk_file_chooser_dialog_new (...);
    ///
    /// gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
    /// g_signal_connect (chooser, "confirm-overwrite",
    ///                   G_CALLBACK (confirm_overwrite_callback), NULL);
    ///
    /// if (gtk_dialog_run (chooser) == GTK_RESPONSE_ACCEPT)
    ///         save_to_file (gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
    ///
    /// gtk_widget_destroy (chooser);
    /// ```
    ///
    ///
    ///
    ///
    /// #### `current-folder-changed`
    ///  This signal is emitted when the current folder in a [`FileChooser`][crate::FileChooser]
    /// changes. This can happen due to the user performing some action that
    /// changes folders, such as selecting a bookmark or visiting a folder on the
    /// file list. It can also happen as a result of calling a function to
    /// explicitly change the current folder in a file chooser.
    ///
    /// Normally you do not need to connect to this signal, unless you need to keep
    /// track of which folder a file chooser is showing.
    ///
    /// See also: [`FileChooserExt::set_current_folder()`][crate::prelude::FileChooserExt::set_current_folder()],
    /// [`FileChooserExt::current_folder()`][crate::prelude::FileChooserExt::current_folder()],
    /// [`FileChooserExt::set_current_folder_uri()`][crate::prelude::FileChooserExt::set_current_folder_uri()],
    /// [`FileChooserExt::current_folder_uri()`][crate::prelude::FileChooserExt::current_folder_uri()].
    ///
    ///
    ///
    ///
    /// #### `file-activated`
    ///  This signal is emitted when the user "activates" a file in the file
    /// chooser. This can happen by double-clicking on a file in the file list, or
    /// by pressing `Enter`.
    ///
    /// Normally you do not need to connect to this signal. It is used internally
    /// by [`FileChooserDialog`][crate::FileChooserDialog] to know when to activate the default button in the
    /// dialog.
    ///
    /// See also: [`FileChooserExt::filename()`][crate::prelude::FileChooserExt::filename()],
    /// [`FileChooserExt::filenames()`][crate::prelude::FileChooserExt::filenames()], [`FileChooserExt::uri()`][crate::prelude::FileChooserExt::uri()],
    /// [`FileChooserExt::uris()`][crate::prelude::FileChooserExt::uris()].
    ///
    ///
    ///
    ///
    /// #### `selection-changed`
    ///  This signal is emitted when there is a change in the set of selected files
    /// in a [`FileChooser`][crate::FileChooser]. This can happen when the user modifies the selection
    /// with the mouse or the keyboard, or when explicitly calling functions to
    /// change the selection.
    ///
    /// Normally you do not need to connect to this signal, as it is easier to wait
    /// for the file chooser to finish running, and then to get the list of
    /// selected files using the functions mentioned below.
    ///
    /// See also: [`FileChooserExt::select_filename()`][crate::prelude::FileChooserExt::select_filename()],
    /// [`FileChooserExt::unselect_filename()`][crate::prelude::FileChooserExt::unselect_filename()], [`FileChooserExt::filename()`][crate::prelude::FileChooserExt::filename()],
    /// [`FileChooserExt::filenames()`][crate::prelude::FileChooserExt::filenames()], [`FileChooserExt::select_uri()`][crate::prelude::FileChooserExt::select_uri()],
    /// [`FileChooserExt::unselect_uri()`][crate::prelude::FileChooserExt::unselect_uri()], [`FileChooserExt::uri()`][crate::prelude::FileChooserExt::uri()],
    /// [`FileChooserExt::uris()`][crate::prelude::FileChooserExt::uris()].
    ///
    ///
    ///
    ///
    /// #### `update-preview`
    ///  This signal is emitted when the preview in a file chooser should be
    /// regenerated. For example, this can happen when the currently selected file
    /// changes. You should use this signal if you want your file chooser to have
    /// a preview widget.
    ///
    /// Once you have installed a preview widget with
    /// [`FileChooserExt::set_preview_widget()`][crate::prelude::FileChooserExt::set_preview_widget()], you should update it when this
    /// signal is emitted. You can use the functions
    /// [`FileChooserExt::preview_filename()`][crate::prelude::FileChooserExt::preview_filename()] or
    /// [`FileChooserExt::preview_uri()`][crate::prelude::FileChooserExt::preview_uri()] to get the name of the file to preview.
    /// Your widget may not be able to preview all kinds of files; your callback
    /// must call [`FileChooserExt::set_preview_widget_active()`][crate::prelude::FileChooserExt::set_preview_widget_active()] to inform the file
    /// chooser about whether the preview was generated successfully or not.
    ///
    /// Please see the example code in
    /// [Using a Preview Widget][gtkfilechooser-preview].
    ///
    /// See also: [`FileChooserExt::set_preview_widget()`][crate::prelude::FileChooserExt::set_preview_widget()],
    /// [`FileChooserExt::set_preview_widget_active()`][crate::prelude::FileChooserExt::set_preview_widget_active()],
    /// [`FileChooserExt::set_use_preview_label()`][crate::prelude::FileChooserExt::set_use_preview_label()],
    /// [`FileChooserExt::preview_filename()`][crate::prelude::FileChooserExt::preview_filename()],
    /// [`FileChooserExt::preview_uri()`][crate::prelude::FileChooserExt::preview_uri()].
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`FileChooserExt`][trait@crate::prelude::FileChooserExt], [`FileChooserExtManual`][trait@crate::prelude::FileChooserExtManual]
    #[doc(alias = "GtkFileChooser")]
    pub struct FileChooser(Interface<ffi::GtkFileChooser>);

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

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

/// Trait containing all [`struct@FileChooser`] methods.
///
/// # Implementors
///
/// [`FileChooserButton`][struct@crate::FileChooserButton], [`FileChooserDialog`][struct@crate::FileChooserDialog], [`FileChooserNative`][struct@crate::FileChooserNative], [`FileChooserWidget`][struct@crate::FileChooserWidget], [`FileChooser`][struct@crate::FileChooser]
pub trait FileChooserExt: IsA<FileChooser> + 'static {
    /// Adds `filter` to the list of filters that the user can select between.
    /// When a filter is selected, only files that are passed by that
    /// filter are displayed.
    ///
    /// Note that the `self` takes ownership of the filter, so you have to
    /// ref and sink it if you want to keep a reference.
    /// ## `filter`
    /// a [`FileFilter`][crate::FileFilter]
    #[doc(alias = "gtk_file_chooser_add_filter")]
    fn add_filter(&self, filter: FileFilter) {
        unsafe {
            ffi::gtk_file_chooser_add_filter(
                self.as_ref().to_glib_none().0,
                filter.into_glib_ptr(),
            );
        }
    }

    /// Adds a folder to be displayed with the shortcut folders in a file chooser.
    /// Note that shortcut folders do not get saved, as they are provided by the
    /// application. For example, you can use this to add a
    /// “/usr/share/mydrawprogram/Clipart” folder to the volume list.
    /// ## `folder`
    /// filename of the folder to add
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be added successfully, [`false`]
    /// otherwise. In the latter case, the `error` will be set as appropriate.
    #[doc(alias = "gtk_file_chooser_add_shortcut_folder")]
    fn add_shortcut_folder(&self, folder: impl AsRef<std::path::Path>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_add_shortcut_folder(
                self.as_ref().to_glib_none().0,
                folder.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Adds a folder URI to be displayed with the shortcut folders in a file
    /// chooser. Note that shortcut folders do not get saved, as they are provided
    /// by the application. For example, you can use this to add a
    /// “file:///usr/share/mydrawprogram/Clipart” folder to the volume list.
    /// ## `uri`
    /// URI of the folder to add
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be added successfully, [`false`]
    /// otherwise. In the latter case, the `error` will be set as appropriate.
    #[doc(alias = "gtk_file_chooser_add_shortcut_folder_uri")]
    fn add_shortcut_folder_uri(&self, uri: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_add_shortcut_folder_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Gets the type of operation that the file chooser is performing; see
    /// [`set_action()`][Self::set_action()].
    ///
    /// # Returns
    ///
    /// the action that the file selector is performing
    #[doc(alias = "gtk_file_chooser_get_action")]
    #[doc(alias = "get_action")]
    fn action(&self) -> FileChooserAction {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_action(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the currently selected option in the 'choice' with the given ID.
    /// ## `id`
    /// the ID of the choice to get
    ///
    /// # Returns
    ///
    /// the ID of the currenly selected option
    #[doc(alias = "gtk_file_chooser_get_choice")]
    #[doc(alias = "get_choice")]
    fn choice(&self, id: &str) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_choice(
                self.as_ref().to_glib_none().0,
                id.to_glib_none().0,
            ))
        }
    }

    /// Gets whether file choser will offer to create new folders.
    /// See [`set_create_folders()`][Self::set_create_folders()].
    ///
    /// # Returns
    ///
    /// [`true`] if the Create Folder button should be displayed.
    #[doc(alias = "gtk_file_chooser_get_create_folders")]
    #[doc(alias = "get_create_folders")]
    #[doc(alias = "create-folders")]
    fn creates_folders(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_create_folders(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current folder of `self` as a local filename.
    /// See [`set_current_folder()`][Self::set_current_folder()].
    ///
    /// Note that this is the folder that the file chooser is currently displaying
    /// (e.g. "/home/username/Documents"), which is not the same
    /// as the currently-selected folder if the chooser is in
    /// [`FileChooserAction::SelectFolder`][crate::FileChooserAction::SelectFolder] mode
    /// (e.g. "/home/username/Documents/selected-folder/". To get the
    /// currently-selected folder in that mode, use [`uri()`][Self::uri()] as the
    /// usual way to get the selection.
    ///
    /// # Returns
    ///
    /// the full path of the current
    /// folder, or [`None`] if the current path cannot be represented as a local
    /// filename. Free with `g_free()`. This function will also return
    /// [`None`] if the file chooser was unable to load the last folder that
    /// was requested from it; for example, as would be for calling
    /// [`set_current_folder()`][Self::set_current_folder()] on a nonexistent folder.
    #[doc(alias = "gtk_file_chooser_get_current_folder")]
    #[doc(alias = "get_current_folder")]
    fn current_folder(&self) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_current_folder(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current folder of `self` as [`gio::File`][crate::gio::File].
    /// See [`current_folder_uri()`][Self::current_folder_uri()].
    ///
    /// # Returns
    ///
    /// the [`gio::File`][crate::gio::File] for the current folder.
    #[doc(alias = "gtk_file_chooser_get_current_folder_file")]
    #[doc(alias = "get_current_folder_file")]
    fn current_folder_file(&self) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_current_folder_file(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current folder of `self` as an URI.
    /// See [`set_current_folder_uri()`][Self::set_current_folder_uri()].
    ///
    /// Note that this is the folder that the file chooser is currently displaying
    /// (e.g. "file:///home/username/Documents"), which is not the same
    /// as the currently-selected folder if the chooser is in
    /// [`FileChooserAction::SelectFolder`][crate::FileChooserAction::SelectFolder] mode
    /// (e.g. "file:///home/username/Documents/selected-folder/". To get the
    /// currently-selected folder in that mode, use [`uri()`][Self::uri()] as the
    /// usual way to get the selection.
    ///
    /// # Returns
    ///
    /// the URI for the current folder.
    /// Free with `g_free()`. This function will also return [`None`] if the file chooser
    /// was unable to load the last folder that was requested from it; for example,
    /// as would be for calling [`set_current_folder_uri()`][Self::set_current_folder_uri()] on a
    /// nonexistent folder.
    #[doc(alias = "gtk_file_chooser_get_current_folder_uri")]
    #[doc(alias = "get_current_folder_uri")]
    fn current_folder_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_current_folder_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current name in the file selector, as entered by the user in the
    /// text entry for “Name”.
    ///
    /// This is meant to be used in save dialogs, to get the currently typed filename
    /// when the file itself does not exist yet. For example, an application that
    /// adds a custom extra widget to the file chooser for “file format” may want to
    /// change the extension of the typed filename based on the chosen format, say,
    /// from “.jpg” to “.png”.
    ///
    /// # Returns
    ///
    /// The raw text from the file chooser’s “Name” entry. Free this with
    /// `g_free()`. Note that this string is not a full pathname or URI; it is
    /// whatever the contents of the entry are. Note also that this string is in
    /// UTF-8 encoding, which is not necessarily the system’s encoding for filenames.
    #[doc(alias = "gtk_file_chooser_get_current_name")]
    #[doc(alias = "get_current_name")]
    fn current_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_current_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries whether a file chooser is set to confirm for overwriting when the user
    /// types a file name that already exists.
    ///
    /// # Returns
    ///
    /// [`true`] if the file chooser will present a confirmation dialog;
    /// [`false`] otherwise.
    #[doc(alias = "gtk_file_chooser_get_do_overwrite_confirmation")]
    #[doc(alias = "get_do_overwrite_confirmation")]
    #[doc(alias = "do-overwrite-confirmation")]
    fn does_overwrite_confirmation(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_do_overwrite_confirmation(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current extra widget; see
    /// [`set_extra_widget()`][Self::set_extra_widget()].
    ///
    /// # Returns
    ///
    /// the current extra widget, or [`None`]
    #[doc(alias = "gtk_file_chooser_get_extra_widget")]
    #[doc(alias = "get_extra_widget")]
    #[doc(alias = "extra-widget")]
    fn extra_widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_extra_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`gio::File`][crate::gio::File] for the currently selected file in
    /// the file selector. If multiple files are selected,
    /// one of the files will be returned at random.
    ///
    /// If the file chooser is in folder mode, this function returns the selected
    /// folder.
    ///
    /// # Returns
    ///
    /// a selected [`gio::File`][crate::gio::File]. You own the returned file;
    ///  use `g_object_unref()` to release it.
    #[doc(alias = "gtk_file_chooser_get_file")]
    #[doc(alias = "get_file")]
    fn file(&self) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_file(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the filename for the currently selected file in
    /// the file selector. The filename is returned as an absolute path. If
    /// multiple files are selected, one of the filenames will be returned at
    /// random.
    ///
    /// If the file chooser is in folder mode, this function returns the selected
    /// folder.
    ///
    /// # Returns
    ///
    /// The currently selected filename,
    ///  or [`None`] if no file is selected, or the selected file can't
    ///  be represented with a local filename. Free with `g_free()`.
    #[doc(alias = "gtk_file_chooser_get_filename")]
    #[doc(alias = "get_filename")]
    fn filename(&self) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_filename(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Lists all the selected files and subfolders in the current folder of
    /// `self`. The returned names are full absolute paths. If files in the current
    /// folder cannot be represented as local filenames they will be ignored. (See
    /// [`uris()`][Self::uris()])
    ///
    /// # Returns
    ///
    /// a `GSList`
    ///  containing the filenames of all selected files and subfolders in
    ///  the current folder. Free the returned list with `g_slist_free()`,
    ///  and the filenames with `g_free()`.
    #[doc(alias = "gtk_file_chooser_get_filenames")]
    #[doc(alias = "get_filenames")]
    fn filenames(&self) -> Vec<std::path::PathBuf> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_get_filenames(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Lists all the selected files and subfolders in the current folder of `self`
    /// as [`gio::File`][crate::gio::File]. An internal function, see [`uris()`][Self::uris()].
    ///
    /// # Returns
    ///
    /// a `GSList`
    ///  containing a [`gio::File`][crate::gio::File] for each selected file and subfolder in the
    ///  current folder. Free the returned list with `g_slist_free()`, and
    ///  the files with `g_object_unref()`.
    #[doc(alias = "gtk_file_chooser_get_files")]
    #[doc(alias = "get_files")]
    fn files(&self) -> Vec<gio::File> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_get_files(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current filter; see [`set_filter()`][Self::set_filter()].
    ///
    /// # Returns
    ///
    /// the current filter, or [`None`]
    #[doc(alias = "gtk_file_chooser_get_filter")]
    #[doc(alias = "get_filter")]
    fn filter(&self) -> Option<FileFilter> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_filter(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether only local files can be selected in the
    /// file selector. See [`set_local_only()`][Self::set_local_only()]
    ///
    /// # Returns
    ///
    /// [`true`] if only local files can be selected.
    #[doc(alias = "gtk_file_chooser_get_local_only")]
    #[doc(alias = "get_local_only")]
    #[doc(alias = "local-only")]
    fn is_local_only(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_local_only(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`gio::File`][crate::gio::File] that should be previewed in a custom preview
    /// Internal function, see [`preview_uri()`][Self::preview_uri()].
    ///
    /// # Returns
    ///
    /// the [`gio::File`][crate::gio::File] for the file to preview,
    ///  or [`None`] if no file is selected. Free with `g_object_unref()`.
    #[doc(alias = "gtk_file_chooser_get_preview_file")]
    #[doc(alias = "get_preview_file")]
    fn preview_file(&self) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_preview_file(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the filename that should be previewed in a custom preview
    /// widget. See [`set_preview_widget()`][Self::set_preview_widget()].
    ///
    /// # Returns
    ///
    /// the filename to preview, or [`None`] if
    ///  no file is selected, or if the selected file cannot be represented
    ///  as a local filename. Free with `g_free()`
    #[doc(alias = "gtk_file_chooser_get_preview_filename")]
    #[doc(alias = "get_preview_filename")]
    fn preview_filename(&self) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_preview_filename(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the URI that should be previewed in a custom preview
    /// widget. See [`set_preview_widget()`][Self::set_preview_widget()].
    ///
    /// # Returns
    ///
    /// the URI for the file to preview,
    ///  or [`None`] if no file is selected. Free with `g_free()`.
    #[doc(alias = "gtk_file_chooser_get_preview_uri")]
    #[doc(alias = "get_preview_uri")]
    fn preview_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_preview_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current preview widget; see
    /// [`set_preview_widget()`][Self::set_preview_widget()].
    ///
    /// # Returns
    ///
    /// the current preview widget, or [`None`]
    #[doc(alias = "gtk_file_chooser_get_preview_widget")]
    #[doc(alias = "get_preview_widget")]
    #[doc(alias = "preview-widget")]
    fn preview_widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_preview_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether the preview widget set by [`set_preview_widget()`][Self::set_preview_widget()]
    /// should be shown for the current filename. See
    /// [`set_preview_widget_active()`][Self::set_preview_widget_active()].
    ///
    /// # Returns
    ///
    /// [`true`] if the preview widget is active for the current filename.
    #[doc(alias = "gtk_file_chooser_get_preview_widget_active")]
    #[doc(alias = "get_preview_widget_active")]
    #[doc(alias = "preview-widget-active")]
    fn is_preview_widget_active(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_preview_widget_active(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether multiple files can be selected in the file
    /// selector. See [`set_select_multiple()`][Self::set_select_multiple()].
    ///
    /// # Returns
    ///
    /// [`true`] if multiple files can be selected.
    #[doc(alias = "gtk_file_chooser_get_select_multiple")]
    #[doc(alias = "get_select_multiple")]
    #[doc(alias = "select-multiple")]
    fn selects_multiple(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_select_multiple(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether hidden files and folders are displayed in the file selector.
    /// See [`set_show_hidden()`][Self::set_show_hidden()].
    ///
    /// # Returns
    ///
    /// [`true`] if hidden files and folders are displayed.
    #[doc(alias = "gtk_file_chooser_get_show_hidden")]
    #[doc(alias = "get_show_hidden")]
    #[doc(alias = "show-hidden")]
    fn shows_hidden(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_show_hidden(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the URI for the currently selected file in
    /// the file selector. If multiple files are selected,
    /// one of the filenames will be returned at random.
    ///
    /// If the file chooser is in folder mode, this function returns the selected
    /// folder.
    ///
    /// # Returns
    ///
    /// The currently selected URI, or [`None`]
    ///  if no file is selected. If [`set_local_only()`][Self::set_local_only()] is set to
    ///  [`true`] (the default) a local URI will be returned for any FUSE locations.
    ///  Free with `g_free()`
    #[doc(alias = "gtk_file_chooser_get_uri")]
    #[doc(alias = "get_uri")]
    fn uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Lists all the selected files and subfolders in the current folder of
    /// `self`. The returned names are full absolute URIs.
    ///
    /// # Returns
    ///
    /// a `GSList` containing the URIs of all selected
    ///  files and subfolders in the current folder. Free the returned list
    ///  with `g_slist_free()`, and the filenames with `g_free()`.
    #[doc(alias = "gtk_file_chooser_get_uris")]
    #[doc(alias = "get_uris")]
    fn uris(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_get_uris(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether a stock label should be drawn with the name of the previewed
    /// file. See [`set_use_preview_label()`][Self::set_use_preview_label()].
    ///
    /// # Returns
    ///
    /// [`true`] if the file chooser is set to display a label with the
    /// name of the previewed file, [`false`] otherwise.
    #[doc(alias = "gtk_file_chooser_get_use_preview_label")]
    #[doc(alias = "get_use_preview_label")]
    #[doc(alias = "use-preview-label")]
    fn uses_preview_label(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_use_preview_label(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Lists the current set of user-selectable filters; see
    /// [`add_filter()`][Self::add_filter()], [`remove_filter()`][Self::remove_filter()].
    ///
    /// # Returns
    ///
    /// a
    ///  `GSList` containing the current set of user selectable filters. The
    ///  contents of the list are owned by GTK+, but you must free the list
    ///  itself with `g_slist_free()` when you are done with it.
    #[doc(alias = "gtk_file_chooser_list_filters")]
    fn list_filters(&self) -> Vec<FileFilter> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_file_chooser_list_filters(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries the list of shortcut folders in the file chooser, as set by
    /// [`add_shortcut_folder_uri()`][Self::add_shortcut_folder_uri()].
    ///
    /// # Returns
    ///
    /// A list of
    /// folder URIs, or [`None`] if there are no shortcut folders. Free the
    /// returned list with `g_slist_free()`, and the URIs with `g_free()`.
    #[doc(alias = "gtk_file_chooser_list_shortcut_folder_uris")]
    fn list_shortcut_folder_uris(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_list_shortcut_folder_uris(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Queries the list of shortcut folders in the file chooser, as set by
    /// [`add_shortcut_folder()`][Self::add_shortcut_folder()].
    ///
    /// # Returns
    ///
    /// A list
    /// of folder filenames, or [`None`] if there are no shortcut folders.
    /// Free the returned list with `g_slist_free()`, and the filenames with
    /// `g_free()`.
    #[doc(alias = "gtk_file_chooser_list_shortcut_folders")]
    fn list_shortcut_folders(&self) -> Vec<std::path::PathBuf> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_list_shortcut_folders(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Removes a 'choice' that has been added with [`FileChooserExtManual::add_choice()`][crate::prelude::FileChooserExtManual::add_choice()].
    /// ## `id`
    /// the ID of the choice to remove
    #[doc(alias = "gtk_file_chooser_remove_choice")]
    fn remove_choice(&self, id: &str) {
        unsafe {
            ffi::gtk_file_chooser_remove_choice(
                self.as_ref().to_glib_none().0,
                id.to_glib_none().0,
            );
        }
    }

    /// Removes `filter` from the list of filters that the user can select between.
    /// ## `filter`
    /// a [`FileFilter`][crate::FileFilter]
    #[doc(alias = "gtk_file_chooser_remove_filter")]
    fn remove_filter(&self, filter: &FileFilter) {
        unsafe {
            ffi::gtk_file_chooser_remove_filter(
                self.as_ref().to_glib_none().0,
                filter.to_glib_none().0,
            );
        }
    }

    /// Removes a folder from a file chooser’s list of shortcut folders.
    /// ## `folder`
    /// filename of the folder to remove
    ///
    /// # Returns
    ///
    /// [`true`] if the operation succeeds, [`false`] otherwise.
    /// In the latter case, the `error` will be set as appropriate.
    ///
    /// See also: [`add_shortcut_folder()`][Self::add_shortcut_folder()]
    #[doc(alias = "gtk_file_chooser_remove_shortcut_folder")]
    fn remove_shortcut_folder(
        &self,
        folder: impl AsRef<std::path::Path>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_remove_shortcut_folder(
                self.as_ref().to_glib_none().0,
                folder.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Removes a folder URI from a file chooser’s list of shortcut folders.
    /// ## `uri`
    /// URI of the folder to remove
    ///
    /// # Returns
    ///
    /// [`true`] if the operation succeeds, [`false`] otherwise.
    /// In the latter case, the `error` will be set as appropriate.
    ///
    /// See also: [`add_shortcut_folder_uri()`][Self::add_shortcut_folder_uri()]
    #[doc(alias = "gtk_file_chooser_remove_shortcut_folder_uri")]
    fn remove_shortcut_folder_uri(&self, uri: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_remove_shortcut_folder_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Selects all the files in the current folder of a file chooser.
    #[doc(alias = "gtk_file_chooser_select_all")]
    fn select_all(&self) {
        unsafe {
            ffi::gtk_file_chooser_select_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Selects the file referred to by `file`. An internal function. See
    /// `_gtk_file_chooser_select_uri()`.
    /// ## `file`
    /// the file to select
    ///
    /// # Returns
    ///
    /// Not useful.
    #[doc(alias = "gtk_file_chooser_select_file")]
    fn select_file(&self, file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_select_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Selects a filename. If the file name isn’t in the current
    /// folder of `self`, then the current folder of `self` will
    /// be changed to the folder containing `filename`.
    /// ## `filename`
    /// the filename to select
    ///
    /// # Returns
    ///
    /// Not useful.
    ///
    /// See also: [`set_filename()`][Self::set_filename()]
    #[doc(alias = "gtk_file_chooser_select_filename")]
    fn select_filename(&self, filename: impl AsRef<std::path::Path>) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_select_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Selects the file to by `uri`. If the URI doesn’t refer to a
    /// file in the current folder of `self`, then the current folder of
    /// `self` will be changed to the folder containing `filename`.
    /// ## `uri`
    /// the URI to select
    ///
    /// # Returns
    ///
    /// Not useful.
    #[doc(alias = "gtk_file_chooser_select_uri")]
    fn select_uri(&self, uri: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_select_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            ))
        }
    }

    /// Sets the type of operation that the chooser is performing; the
    /// user interface is adapted to suit the selected action. For example,
    /// an option to create a new folder might be shown if the action is
    /// [`FileChooserAction::Save`][crate::FileChooserAction::Save] but not if the action is
    /// [`FileChooserAction::Open`][crate::FileChooserAction::Open].
    /// ## `action`
    /// the action that the file selector is performing
    #[doc(alias = "gtk_file_chooser_set_action")]
    #[doc(alias = "action")]
    fn set_action(&self, action: FileChooserAction) {
        unsafe {
            ffi::gtk_file_chooser_set_action(self.as_ref().to_glib_none().0, action.into_glib());
        }
    }

    /// Selects an option in a 'choice' that has been added with
    /// [`FileChooserExtManual::add_choice()`][crate::prelude::FileChooserExtManual::add_choice()]. For a boolean choice, the
    /// possible options are "true" and "false".
    /// ## `id`
    /// the ID of the choice to set
    /// ## `option`
    /// the ID of the option to select
    #[doc(alias = "gtk_file_chooser_set_choice")]
    fn set_choice(&self, id: &str, option: &str) {
        unsafe {
            ffi::gtk_file_chooser_set_choice(
                self.as_ref().to_glib_none().0,
                id.to_glib_none().0,
                option.to_glib_none().0,
            );
        }
    }

    /// Sets whether file choser will offer to create new folders.
    /// This is only relevant if the action is not set to be
    /// [`FileChooserAction::Open`][crate::FileChooserAction::Open].
    /// ## `create_folders`
    /// [`true`] if the Create Folder button should be displayed
    #[doc(alias = "gtk_file_chooser_set_create_folders")]
    #[doc(alias = "create-folders")]
    fn set_create_folders(&self, create_folders: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_create_folders(
                self.as_ref().to_glib_none().0,
                create_folders.into_glib(),
            );
        }
    }

    /// Sets the current folder for `self` from a local filename.
    /// The user will be shown the full contents of the current folder,
    /// plus user interface elements for navigating to other folders.
    ///
    /// In general, you should not use this function. See the
    /// [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
    /// for the rationale behind this.
    /// ## `filename`
    /// the full path of the new current folder
    ///
    /// # Returns
    ///
    /// Not useful.
    #[doc(alias = "gtk_file_chooser_set_current_folder")]
    fn set_current_folder(&self, filename: impl AsRef<std::path::Path>) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_set_current_folder(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the current folder for `self` from a [`gio::File`][crate::gio::File].
    /// Internal function, see [`set_current_folder_uri()`][Self::set_current_folder_uri()].
    /// ## `file`
    /// the [`gio::File`][crate::gio::File] for the new folder
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be changed successfully, [`false`]
    /// otherwise.
    #[doc(alias = "gtk_file_chooser_set_current_folder_file")]
    fn set_current_folder_file(&self, file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_set_current_folder_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets the current folder for `self` from an URI.
    /// The user will be shown the full contents of the current folder,
    /// plus user interface elements for navigating to other folders.
    ///
    /// In general, you should not use this function. See the
    /// [section on setting up a file chooser dialog][gtkfilechooserdialog-setting-up]
    /// for the rationale behind this.
    /// ## `uri`
    /// the URI for the new current folder
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be changed successfully, [`false`]
    /// otherwise.
    #[doc(alias = "gtk_file_chooser_set_current_folder_uri")]
    fn set_current_folder_uri(&self, uri: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_set_current_folder_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            ))
        }
    }

    /// Sets the current name in the file selector, as if entered
    /// by the user. Note that the name passed in here is a UTF-8
    /// string rather than a filename. This function is meant for
    /// such uses as a suggested name in a “Save As...” dialog. You can
    /// pass “Untitled.doc” or a similarly suitable suggestion for the `name`.
    ///
    /// If you want to preselect a particular existing file, you should use
    /// [`set_filename()`][Self::set_filename()] or [`set_uri()`][Self::set_uri()] instead.
    /// Please see the documentation for those functions for an example of using
    /// [`set_current_name()`][Self::set_current_name()] as well.
    /// ## `name`
    /// the filename to use, as a UTF-8 string
    #[doc(alias = "gtk_file_chooser_set_current_name")]
    fn set_current_name(&self, name: &str) {
        unsafe {
            ffi::gtk_file_chooser_set_current_name(
                self.as_ref().to_glib_none().0,
                name.to_glib_none().0,
            );
        }
    }

    /// Sets whether a file chooser in [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode will present
    /// a confirmation dialog if the user types a file name that already exists. This
    /// is [`false`] by default.
    ///
    /// If set to [`true`], the `self` will emit the
    /// [`confirm-overwrite`][struct@crate::FileChooser#confirm-overwrite] signal when appropriate.
    ///
    /// If all you need is the stock confirmation dialog, set this property to [`true`].
    /// You can override the way confirmation is done by actually handling the
    /// [`confirm-overwrite`][struct@crate::FileChooser#confirm-overwrite] signal; please refer to its documentation
    /// for the details.
    /// ## `do_overwrite_confirmation`
    /// whether to confirm overwriting in save mode
    #[doc(alias = "gtk_file_chooser_set_do_overwrite_confirmation")]
    #[doc(alias = "do-overwrite-confirmation")]
    fn set_do_overwrite_confirmation(&self, do_overwrite_confirmation: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_do_overwrite_confirmation(
                self.as_ref().to_glib_none().0,
                do_overwrite_confirmation.into_glib(),
            );
        }
    }

    /// Sets an application-supplied widget to provide extra options to the user.
    /// ## `extra_widget`
    /// widget for extra options
    #[doc(alias = "gtk_file_chooser_set_extra_widget")]
    #[doc(alias = "extra-widget")]
    fn set_extra_widget(&self, extra_widget: &impl IsA<Widget>) {
        unsafe {
            ffi::gtk_file_chooser_set_extra_widget(
                self.as_ref().to_glib_none().0,
                extra_widget.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets `file` as the current filename for the file chooser, by changing
    /// to the file’s parent folder and actually selecting the file in list. If
    /// the `self` is in [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode, the file’s base name
    /// will also appear in the dialog’s file name entry.
    ///
    /// If the file name isn’t in the current folder of `self`, then the current
    /// folder of `self` will be changed to the folder containing `filename`. This
    /// is equivalent to a sequence of [`unselect_all()`][Self::unselect_all()] followed by
    /// [`select_filename()`][Self::select_filename()].
    ///
    /// Note that the file must exist, or nothing will be done except
    /// for the directory change.
    ///
    /// If you are implementing a save dialog,
    /// you should use this function if you already have a file name to which the
    /// user may save; for example, when the user opens an existing file and then
    /// does Save As... If you don’t have
    /// a file name already — for example, if the user just created a new
    /// file and is saving it for the first time, do not call this function.
    /// Instead, use something similar to this:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// if (document_is_new)
    ///   {
    ///     // the user just created a new document
    ///     gtk_file_chooser_set_current_folder_file (chooser, default_file_for_saving);
    ///     gtk_file_chooser_set_current_name (chooser, "Untitled document");
    ///   }
    /// else
    ///   {
    ///     // the user edited an existing document
    ///     gtk_file_chooser_set_file (chooser, existing_file);
    ///   }
    /// ```
    /// ## `file`
    /// the [`gio::File`][crate::gio::File] to set as current
    ///
    /// # Returns
    ///
    /// Not useful.
    #[doc(alias = "gtk_file_chooser_set_file")]
    fn set_file(&self, file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_set_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets `filename` as the current filename for the file chooser, by changing to
    /// the file’s parent folder and actually selecting the file in list; all other
    /// files will be unselected. If the `self` is in
    /// [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode, the file’s base name will also appear in
    /// the dialog’s file name entry.
    ///
    /// Note that the file must exist, or nothing will be done except
    /// for the directory change.
    ///
    /// You should use this function only when implementing a save
    /// dialog for which you already have a file name to which
    /// the user may save. For example, when the user opens an existing file and
    /// then does Save As... to save a copy or
    /// a modified version. If you don’t have a file name already — for
    /// example, if the user just created a new file and is saving it for the first
    /// time, do not call this function. Instead, use something similar to this:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// if (document_is_new)
    ///   {
    ///     // the user just created a new document
    ///     gtk_file_chooser_set_current_name (chooser, "Untitled document");
    ///   }
    /// else
    ///   {
    ///     // the user edited an existing document
    ///     gtk_file_chooser_set_filename (chooser, existing_filename);
    ///   }
    /// ```
    ///
    /// In the first case, the file chooser will present the user with useful suggestions
    /// as to where to save his new file. In the second case, the file’s existing location
    /// is already known, so the file chooser will use it.
    /// ## `filename`
    /// the filename to set as current
    ///
    /// # Returns
    ///
    /// Not useful.
    #[doc(alias = "gtk_file_chooser_set_filename")]
    fn set_filename(&self, filename: impl AsRef<std::path::Path>) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_set_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the current filter; only the files that pass the
    /// filter will be displayed. If the user-selectable list of filters
    /// is non-empty, then the filter should be one of the filters
    /// in that list. Setting the current filter when the list of
    /// filters is empty is useful if you want to restrict the displayed
    /// set of files without letting the user change it.
    /// ## `filter`
    /// a [`FileFilter`][crate::FileFilter]
    #[doc(alias = "gtk_file_chooser_set_filter")]
    #[doc(alias = "filter")]
    fn set_filter(&self, filter: &FileFilter) {
        unsafe {
            ffi::gtk_file_chooser_set_filter(
                self.as_ref().to_glib_none().0,
                filter.to_glib_none().0,
            );
        }
    }

    /// Sets whether only local files can be selected in the
    /// file selector. If `local_only` is [`true`] (the default),
    /// then the selected file or files are guaranteed to be
    /// accessible through the operating systems native file
    /// system and therefore the application only
    /// needs to worry about the filename functions in
    /// [`FileChooser`][crate::FileChooser], like [`filename()`][Self::filename()],
    /// rather than the URI functions like
    /// [`uri()`][Self::uri()],
    ///
    /// On some systems non-native files may still be
    /// available using the native filesystem via a userspace
    /// filesystem (FUSE).
    /// ## `local_only`
    /// [`true`] if only local files can be selected
    #[doc(alias = "gtk_file_chooser_set_local_only")]
    #[doc(alias = "local-only")]
    fn set_local_only(&self, local_only: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_local_only(
                self.as_ref().to_glib_none().0,
                local_only.into_glib(),
            );
        }
    }

    /// Sets an application-supplied widget to use to display a custom preview
    /// of the currently selected file. To implement a preview, after setting the
    /// preview widget, you connect to the [`update-preview`][struct@crate::FileChooser#update-preview]
    /// signal, and call [`preview_filename()`][Self::preview_filename()] or
    /// [`preview_uri()`][Self::preview_uri()] on each change. If you can
    /// display a preview of the new file, update your widget and
    /// set the preview active using [`set_preview_widget_active()`][Self::set_preview_widget_active()].
    /// Otherwise, set the preview inactive.
    ///
    /// When there is no application-supplied preview widget, or the
    /// application-supplied preview widget is not active, the file chooser
    /// will display no preview at all.
    /// ## `preview_widget`
    /// widget for displaying preview.
    #[doc(alias = "gtk_file_chooser_set_preview_widget")]
    #[doc(alias = "preview-widget")]
    fn set_preview_widget(&self, preview_widget: &impl IsA<Widget>) {
        unsafe {
            ffi::gtk_file_chooser_set_preview_widget(
                self.as_ref().to_glib_none().0,
                preview_widget.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets whether the preview widget set by
    /// [`set_preview_widget()`][Self::set_preview_widget()] should be shown for the
    /// current filename. When `active` is set to false, the file chooser
    /// may display an internally generated preview of the current file
    /// or it may display no preview at all. See
    /// [`set_preview_widget()`][Self::set_preview_widget()] for more details.
    /// ## `active`
    /// whether to display the user-specified preview widget
    #[doc(alias = "gtk_file_chooser_set_preview_widget_active")]
    #[doc(alias = "preview-widget-active")]
    fn set_preview_widget_active(&self, active: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_preview_widget_active(
                self.as_ref().to_glib_none().0,
                active.into_glib(),
            );
        }
    }

    /// Sets whether multiple files can be selected in the file selector. This is
    /// only relevant if the action is set to be [`FileChooserAction::Open`][crate::FileChooserAction::Open] or
    /// [`FileChooserAction::SelectFolder`][crate::FileChooserAction::SelectFolder].
    /// ## `select_multiple`
    /// [`true`] if multiple files can be selected.
    #[doc(alias = "gtk_file_chooser_set_select_multiple")]
    #[doc(alias = "select-multiple")]
    fn set_select_multiple(&self, select_multiple: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_select_multiple(
                self.as_ref().to_glib_none().0,
                select_multiple.into_glib(),
            );
        }
    }

    /// Sets whether hidden files and folders are displayed in the file selector.
    /// ## `show_hidden`
    /// [`true`] if hidden files and folders should be displayed.
    #[doc(alias = "gtk_file_chooser_set_show_hidden")]
    #[doc(alias = "show-hidden")]
    fn set_show_hidden(&self, show_hidden: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_show_hidden(
                self.as_ref().to_glib_none().0,
                show_hidden.into_glib(),
            );
        }
    }

    /// Sets the file referred to by `uri` as the current file for the file chooser,
    /// by changing to the URI’s parent folder and actually selecting the URI in the
    /// list. If the `self` is [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode, the URI’s base
    /// name will also appear in the dialog’s file name entry.
    ///
    /// Note that the URI must exist, or nothing will be done except for the
    /// directory change.
    ///
    /// You should use this function only when implementing a save
    /// dialog for which you already have a file name to which
    /// the user may save. For example, when the user opens an existing file and then
    /// does Save As... to save a copy or a
    /// modified version. If you don’t have a file name already — for example,
    /// if the user just created a new file and is saving it for the first time, do
    /// not call this function. Instead, use something similar to this:
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// if (document_is_new)
    ///   {
    ///     // the user just created a new document
    ///     gtk_file_chooser_set_current_name (chooser, "Untitled document");
    ///   }
    /// else
    ///   {
    ///     // the user edited an existing document
    ///     gtk_file_chooser_set_uri (chooser, existing_uri);
    ///   }
    /// ```
    ///
    ///
    /// In the first case, the file chooser will present the user with useful suggestions
    /// as to where to save his new file. In the second case, the file’s existing location
    /// is already known, so the file chooser will use it.
    /// ## `uri`
    /// the URI to set as current
    ///
    /// # Returns
    ///
    /// Not useful.
    #[doc(alias = "gtk_file_chooser_set_uri")]
    fn set_uri(&self, uri: &str) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_set_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            ))
        }
    }

    /// Sets whether the file chooser should display a stock label with the name of
    /// the file that is being previewed; the default is [`true`]. Applications that
    /// want to draw the whole preview area themselves should set this to [`false`] and
    /// display the name themselves in their preview widget.
    ///
    /// See also: [`set_preview_widget()`][Self::set_preview_widget()]
    /// ## `use_label`
    /// whether to display a stock label with the name of the previewed file
    #[doc(alias = "gtk_file_chooser_set_use_preview_label")]
    #[doc(alias = "use-preview-label")]
    fn set_use_preview_label(&self, use_label: bool) {
        unsafe {
            ffi::gtk_file_chooser_set_use_preview_label(
                self.as_ref().to_glib_none().0,
                use_label.into_glib(),
            );
        }
    }

    /// Unselects all the files in the current folder of a file chooser.
    #[doc(alias = "gtk_file_chooser_unselect_all")]
    fn unselect_all(&self) {
        unsafe {
            ffi::gtk_file_chooser_unselect_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Unselects the file referred to by `file`. If the file is not in the current
    /// directory, does not exist, or is otherwise not currently selected, does nothing.
    /// ## `file`
    /// a [`gio::File`][crate::gio::File]
    #[doc(alias = "gtk_file_chooser_unselect_file")]
    fn unselect_file(&self, file: &impl IsA<gio::File>) {
        unsafe {
            ffi::gtk_file_chooser_unselect_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
            );
        }
    }

    /// Unselects a currently selected filename. If the filename
    /// is not in the current directory, does not exist, or
    /// is otherwise not currently selected, does nothing.
    /// ## `filename`
    /// the filename to unselect
    #[doc(alias = "gtk_file_chooser_unselect_filename")]
    fn unselect_filename(&self, filename: impl AsRef<std::path::Path>) {
        unsafe {
            ffi::gtk_file_chooser_unselect_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            );
        }
    }

    /// Unselects the file referred to by `uri`. If the file
    /// is not in the current directory, does not exist, or
    /// is otherwise not currently selected, does nothing.
    /// ## `uri`
    /// the URI to unselect
    #[doc(alias = "gtk_file_chooser_unselect_uri")]
    fn unselect_uri(&self, uri: &str) {
        unsafe {
            ffi::gtk_file_chooser_unselect_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            );
        }
    }

    /// This signal gets emitted whenever it is appropriate to present a
    /// confirmation dialog when the user has selected a file name that
    /// already exists. The signal only gets emitted when the file
    /// chooser is in [`FileChooserAction::Save`][crate::FileChooserAction::Save] mode.
    ///
    /// Most applications just need to turn on the
    /// [`do-overwrite-confirmation`][struct@crate::FileChooser#do-overwrite-confirmation] property (or call the
    /// [`set_do_overwrite_confirmation()`][Self::set_do_overwrite_confirmation()] function), and
    /// they will automatically get a stock confirmation dialog.
    /// Applications which need to customize this behavior should do
    /// that, and also connect to the [`confirm-overwrite`][struct@crate::FileChooser#confirm-overwrite]
    /// signal.
    ///
    /// A signal handler for this signal must return a
    /// [`FileChooserConfirmation`][crate::FileChooserConfirmation] value, which indicates the action to
    /// take. If the handler determines that the user wants to select a
    /// different filename, it should return
    /// [`FileChooserConfirmation::SelectAgain`][crate::FileChooserConfirmation::SelectAgain]. If it determines
    /// that the user is satisfied with his choice of file name, it
    /// should return [`FileChooserConfirmation::AcceptFilename`][crate::FileChooserConfirmation::AcceptFilename].
    /// On the other hand, if it determines that the stock confirmation
    /// dialog should be used, it should return
    /// [`FileChooserConfirmation::Confirm`][crate::FileChooserConfirmation::Confirm]. The following example
    /// illustrates this.
    ///
    /// ## Custom confirmation ## {`gtkfilechooser`-confirmation}
    ///
    ///
    ///
    /// **⚠️ The following code is in C ⚠️**
    ///
    /// ```C
    /// static GtkFileChooserConfirmation
    /// confirm_overwrite_callback (GtkFileChooser *chooser, gpointer data)
    /// {
    ///   char *uri;
    ///
    ///   uri = gtk_file_chooser_get_uri (chooser);
    ///
    ///   if (is_uri_read_only (uri))
    ///     {
    ///       if (user_wants_to_replace_read_only_file (uri))
    ///         return GTK_FILE_CHOOSER_CONFIRMATION_ACCEPT_FILENAME;
    ///       else
    ///         return GTK_FILE_CHOOSER_CONFIRMATION_SELECT_AGAIN;
    ///     } else
    ///       return GTK_FILE_CHOOSER_CONFIRMATION_CONFIRM; // fall back to the default dialog
    /// }
    ///
    /// ...
    ///
    /// chooser = gtk_file_chooser_dialog_new (...);
    ///
    /// gtk_file_chooser_set_do_overwrite_confirmation (GTK_FILE_CHOOSER (dialog), TRUE);
    /// g_signal_connect (chooser, "confirm-overwrite",
    ///                   G_CALLBACK (confirm_overwrite_callback), NULL);
    ///
    /// if (gtk_dialog_run (chooser) == GTK_RESPONSE_ACCEPT)
    ///         save_to_file (gtk_file_chooser_get_filename (GTK_FILE_CHOOSER (chooser));
    ///
    /// gtk_widget_destroy (chooser);
    /// ```
    ///
    /// # Returns
    ///
    /// a [`FileChooserConfirmation`][crate::FileChooserConfirmation] value that indicates which
    ///  action to take after emitting the signal.
    #[doc(alias = "confirm-overwrite")]
    fn connect_confirm_overwrite<F: Fn(&Self) -> FileChooserConfirmation + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn confirm_overwrite_trampoline<
            P: IsA<FileChooser>,
            F: Fn(&P) -> FileChooserConfirmation + 'static,
        >(
            this: *mut ffi::GtkFileChooser,
            f: glib::ffi::gpointer,
        ) -> ffi::GtkFileChooserConfirmation {
            unsafe {
                let f: &F = &*(f as *const F);
                f(FileChooser::from_glib_borrow(this).unsafe_cast_ref()).into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"confirm-overwrite".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    confirm_overwrite_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the current folder in a [`FileChooser`][crate::FileChooser]
    /// changes. This can happen due to the user performing some action that
    /// changes folders, such as selecting a bookmark or visiting a folder on the
    /// file list. It can also happen as a result of calling a function to
    /// explicitly change the current folder in a file chooser.
    ///
    /// Normally you do not need to connect to this signal, unless you need to keep
    /// track of which folder a file chooser is showing.
    ///
    /// See also: [`set_current_folder()`][Self::set_current_folder()],
    /// [`current_folder()`][Self::current_folder()],
    /// [`set_current_folder_uri()`][Self::set_current_folder_uri()],
    /// [`current_folder_uri()`][Self::current_folder_uri()].
    #[doc(alias = "current-folder-changed")]
    fn connect_current_folder_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn current_folder_changed_trampoline<
            P: IsA<FileChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkFileChooser,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(FileChooser::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"current-folder-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    current_folder_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the user "activates" a file in the file
    /// chooser. This can happen by double-clicking on a file in the file list, or
    /// by pressing `Enter`.
    ///
    /// Normally you do not need to connect to this signal. It is used internally
    /// by [`FileChooserDialog`][crate::FileChooserDialog] to know when to activate the default button in the
    /// dialog.
    ///
    /// See also: [`filename()`][Self::filename()],
    /// [`filenames()`][Self::filenames()], [`uri()`][Self::uri()],
    /// [`uris()`][Self::uris()].
    #[doc(alias = "file-activated")]
    fn connect_file_activated<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn file_activated_trampoline<P: IsA<FileChooser>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkFileChooser,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(FileChooser::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"file-activated".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    file_activated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when there is a change in the set of selected files
    /// in a [`FileChooser`][crate::FileChooser]. This can happen when the user modifies the selection
    /// with the mouse or the keyboard, or when explicitly calling functions to
    /// change the selection.
    ///
    /// Normally you do not need to connect to this signal, as it is easier to wait
    /// for the file chooser to finish running, and then to get the list of
    /// selected files using the functions mentioned below.
    ///
    /// See also: [`select_filename()`][Self::select_filename()],
    /// [`unselect_filename()`][Self::unselect_filename()], [`filename()`][Self::filename()],
    /// [`filenames()`][Self::filenames()], [`select_uri()`][Self::select_uri()],
    /// [`unselect_uri()`][Self::unselect_uri()], [`uri()`][Self::uri()],
    /// [`uris()`][Self::uris()].
    #[doc(alias = "selection-changed")]
    fn connect_selection_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn selection_changed_trampoline<
            P: IsA<FileChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkFileChooser,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(FileChooser::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"selection-changed".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    selection_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when the preview in a file chooser should be
    /// regenerated. For example, this can happen when the currently selected file
    /// changes. You should use this signal if you want your file chooser to have
    /// a preview widget.
    ///
    /// Once you have installed a preview widget with
    /// [`set_preview_widget()`][Self::set_preview_widget()], you should update it when this
    /// signal is emitted. You can use the functions
    /// [`preview_filename()`][Self::preview_filename()] or
    /// [`preview_uri()`][Self::preview_uri()] to get the name of the file to preview.
    /// Your widget may not be able to preview all kinds of files; your callback
    /// must call [`set_preview_widget_active()`][Self::set_preview_widget_active()] to inform the file
    /// chooser about whether the preview was generated successfully or not.
    ///
    /// Please see the example code in
    /// [Using a Preview Widget][gtkfilechooser-preview].
    ///
    /// See also: [`set_preview_widget()`][Self::set_preview_widget()],
    /// [`set_preview_widget_active()`][Self::set_preview_widget_active()],
    /// [`set_use_preview_label()`][Self::set_use_preview_label()],
    /// [`preview_filename()`][Self::preview_filename()],
    /// [`preview_uri()`][Self::preview_uri()].
    #[doc(alias = "update-preview")]
    fn connect_update_preview<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn update_preview_trampoline<P: IsA<FileChooser>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkFileChooser,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(FileChooser::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"update-preview".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    update_preview_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

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

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

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

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

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

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

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

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

impl<O: IsA<FileChooser>> FileChooserExt for O {}