// 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;
use crate::FileChooserConfirmation;
use crate::FileFilter;
use crate::Widget;
use glib::object::Cast;
use glib::object::IsA;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;
use std::ptr;

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 `open()` or `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
    /// `signal::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.
    ///
    /// # Implements
    ///
    /// [`FileChooserExt`][trait@crate::prelude::FileChooserExt]
    #[doc(alias = "GtkFileChooser")]
    pub struct FileChooser(Interface<ffi::GtkFileChooser>);

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

pub const NONE_FILE_CHOOSER: Option<&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: '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);

    /// 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<P: AsRef<std::path::Path>>(&self, folder: P) -> Result<(), glib::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>;

    /// 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;

    /// 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
    #[cfg(any(feature = "v3_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
    #[doc(alias = "gtk_file_chooser_get_choice")]
    #[doc(alias = "get_choice")]
    fn choice(&self, id: &str) -> Option<glib::GString>;

    /// 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")]
    fn creates_folders(&self) -> bool;

    /// 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>;

    /// 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>;

    /// 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>;

    /// 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>;

    /// 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")]
    fn does_overwrite_confirmation(&self) -> bool;

    /// 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")]
    fn extra_widget(&self) -> Option<Widget>;

    /// 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>;

    /// 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>;

    /// 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>;

    /// 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>;

    /// 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>;

    /// 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")]
    fn is_local_only(&self) -> bool;

    /// 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>;

    /// 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>;

    /// 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>;

    /// 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")]
    fn preview_widget(&self) -> Option<Widget>;

    /// 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")]
    fn is_preview_widget_active(&self) -> bool;

    /// 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")]
    fn selects_multiple(&self) -> bool;

    /// 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")]
    fn shows_hidden(&self) -> bool;

    /// 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>;

    /// 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>;

    /// 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")]
    fn uses_preview_label(&self) -> bool;

    /// 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>;

    /// 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>;

    /// 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>;

    /// Removes a 'choice' that has been added with `gtk_file_chooser_add_choice()`.
    /// ## `id`
    /// the ID of the choice to remove
    #[cfg(any(feature = "v3_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
    #[doc(alias = "gtk_file_chooser_remove_choice")]
    fn remove_choice(&self, id: &str);

    /// 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);

    /// 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<P: AsRef<std::path::Path>>(
        &self,
        folder: P,
    ) -> Result<(), glib::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>;

    /// Selects all the files in the current folder of a file chooser.
    #[doc(alias = "gtk_file_chooser_select_all")]
    fn select_all(&self);

    /// 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<P: IsA<gio::File>>(&self, file: &P) -> Result<(), glib::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<P: AsRef<std::path::Path>>(&self, filename: P) -> bool;

    /// 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;

    /// 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")]
    fn set_action(&self, action: FileChooserAction);

    /// Selects an option in a 'choice' that has been added with
    /// `gtk_file_chooser_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
    #[cfg(any(feature = "v3_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
    #[doc(alias = "gtk_file_chooser_set_choice")]
    fn set_choice(&self, id: &str, option: &str);

    /// 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")]
    fn set_create_folders(&self, create_folders: bool);

    /// 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<P: AsRef<std::path::Path>>(&self, filename: P) -> bool;

    /// 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<P: IsA<gio::File>>(&self, file: &P) -> Result<(), glib::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;

    /// 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);

    /// 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
    /// `signal::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
    /// `signal::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")]
    fn set_do_overwrite_confirmation(&self, do_overwrite_confirmation: bool);

    /// 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")]
    fn set_extra_widget<P: IsA<Widget>>(&self, extra_widget: &P);

    /// 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<P: IsA<gio::File>>(&self, file: &P) -> Result<(), glib::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<P: AsRef<std::path::Path>>(&self, filename: P) -> bool;

    /// 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")]
    fn set_filter(&self, filter: &FileFilter);

    /// 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")]
    fn set_local_only(&self, local_only: bool);

    /// 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 `signal::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")]
    fn set_preview_widget<P: IsA<Widget>>(&self, preview_widget: &P);

    /// 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")]
    fn set_preview_widget_active(&self, active: bool);

    /// 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")]
    fn set_select_multiple(&self, select_multiple: bool);

    /// 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")]
    fn set_show_hidden(&self, show_hidden: bool);

    /// 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;

    /// 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")]
    fn set_use_preview_label(&self, use_label: bool);

    /// Unselects all the files in the current folder of a file chooser.
    #[doc(alias = "gtk_file_chooser_unselect_all")]
    fn unselect_all(&self);

    /// 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<P: IsA<gio::File>>(&self, file: &P);

    /// 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<P: AsRef<std::path::Path>>(&self, filename: P);

    /// 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);

    /// 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
    /// `property::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 `signal::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;

    /// 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;

    /// 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;

    /// 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;

    /// 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;

    #[doc(alias = "action")]
    fn connect_action_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "create-folders")]
    fn connect_create_folders_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "do-overwrite-confirmation")]
    fn connect_do_overwrite_confirmation_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId;

    #[doc(alias = "extra-widget")]
    fn connect_extra_widget_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "filter")]
    fn connect_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "local-only")]
    fn connect_local_only_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "preview-widget")]
    fn connect_preview_widget_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "preview-widget-active")]
    fn connect_preview_widget_active_notify<F: Fn(&Self) + 'static>(&self, f: F)
        -> SignalHandlerId;

    #[doc(alias = "select-multiple")]
    fn connect_select_multiple_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "show-hidden")]
    fn connect_show_hidden_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "use-preview-label")]
    fn connect_use_preview_label_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<FileChooser>> FileChooserExt for O {
    fn add_filter(&self, filter: &FileFilter) {
        unsafe {
            ffi::gtk_file_chooser_add_filter(self.as_ref().to_glib_none().0, filter.to_glib_full());
        }
    }

    fn add_shortcut_folder<P: AsRef<std::path::Path>>(&self, folder: P) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_add_shortcut_folder(
                self.as_ref().to_glib_none().0,
                folder.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn add_shortcut_folder_uri(&self, uri: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_add_shortcut_folder_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn action(&self) -> FileChooserAction {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_action(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    #[cfg(any(feature = "v3_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
    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,
            ))
        }
    }

    fn creates_folders(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_create_folders(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            ))
        }
    }

    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,
            ))
        }
    }

    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,
            ))
        }
    }

    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,
            ))
        }
    }

    fn does_overwrite_confirmation(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_do_overwrite_confirmation(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn extra_widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_extra_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn file(&self) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_file(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn filename(&self) -> Option<std::path::PathBuf> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_filename(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            ))
        }
    }

    fn files(&self) -> Vec<gio::File> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_get_files(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn filter(&self) -> Option<FileFilter> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_filter(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn is_local_only(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_local_only(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            ))
        }
    }

    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,
            ))
        }
    }

    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,
            ))
        }
    }

    fn preview_widget(&self) -> Option<Widget> {
        unsafe {
            from_glib_none(ffi::gtk_file_chooser_get_preview_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            ))
        }
    }

    fn selects_multiple(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_select_multiple(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn shows_hidden(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_show_hidden(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn uris(&self) -> Vec<glib::GString> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_file_chooser_get_uris(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn uses_preview_label(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_get_use_preview_label(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn list_filters(&self) -> Vec<FileFilter> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_file_chooser_list_filters(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            ))
        }
    }

    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,
            ))
        }
    }

    #[cfg(any(feature = "v3_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
    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,
            );
        }
    }

    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,
            );
        }
    }

    fn remove_shortcut_folder<P: AsRef<std::path::Path>>(
        &self,
        folder: P,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_remove_shortcut_folder(
                self.as_ref().to_glib_none().0,
                folder.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn remove_shortcut_folder_uri(&self, uri: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_remove_shortcut_folder_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn select_all(&self) {
        unsafe {
            ffi::gtk_file_chooser_select_all(self.as_ref().to_glib_none().0);
        }
    }

    fn select_file<P: IsA<gio::File>>(&self, file: &P) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_select_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn select_filename<P: AsRef<std::path::Path>>(&self, filename: P) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_select_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            ))
        }
    }

    fn set_action(&self, action: FileChooserAction) {
        unsafe {
            ffi::gtk_file_chooser_set_action(self.as_ref().to_glib_none().0, action.into_glib());
        }
    }

    #[cfg(any(feature = "v3_22", feature = "dox"))]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v3_22")))]
    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,
            );
        }
    }

    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(),
            );
        }
    }

    fn set_current_folder<P: AsRef<std::path::Path>>(&self, filename: P) -> 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,
            ))
        }
    }

    fn set_current_folder_file<P: IsA<gio::File>>(&self, file: &P) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_set_current_folder_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    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,
            ))
        }
    }

    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,
            );
        }
    }

    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(),
            );
        }
    }

    fn set_extra_widget<P: IsA<Widget>>(&self, extra_widget: &P) {
        unsafe {
            ffi::gtk_file_chooser_set_extra_widget(
                self.as_ref().to_glib_none().0,
                extra_widget.as_ref().to_glib_none().0,
            );
        }
    }

    fn set_file<P: IsA<gio::File>>(&self, file: &P) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let _ = ffi::gtk_file_chooser_set_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    fn set_filename<P: AsRef<std::path::Path>>(&self, filename: P) -> bool {
        unsafe {
            from_glib(ffi::gtk_file_chooser_set_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            ))
        }
    }

    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,
            );
        }
    }

    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(),
            );
        }
    }

    fn set_preview_widget<P: IsA<Widget>>(&self, preview_widget: &P) {
        unsafe {
            ffi::gtk_file_chooser_set_preview_widget(
                self.as_ref().to_glib_none().0,
                preview_widget.as_ref().to_glib_none().0,
            );
        }
    }

    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(),
            );
        }
    }

    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(),
            );
        }
    }

    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(),
            );
        }
    }

    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,
            ))
        }
    }

    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(),
            );
        }
    }

    fn unselect_all(&self) {
        unsafe {
            ffi::gtk_file_chooser_unselect_all(self.as_ref().to_glib_none().0);
        }
    }

    fn unselect_file<P: IsA<gio::File>>(&self, file: &P) {
        unsafe {
            ffi::gtk_file_chooser_unselect_file(
                self.as_ref().to_glib_none().0,
                file.as_ref().to_glib_none().0,
            );
        }
    }

    fn unselect_filename<P: AsRef<std::path::Path>>(&self, filename: P) {
        unsafe {
            ffi::gtk_file_chooser_unselect_filename(
                self.as_ref().to_glib_none().0,
                filename.as_ref().to_glib_none().0,
            );
        }
    }

    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,
            );
        }
    }

    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 {
            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 _,
                b"confirm-overwrite\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    confirm_overwrite_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"current-folder-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    current_folder_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"file-activated\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    file_activated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"selection-changed\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    selection_changed_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"update-preview\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    update_preview_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::action\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_action_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::create-folders\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_create_folders_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::do-overwrite-confirmation\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_do_overwrite_confirmation_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::extra-widget\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_extra_widget_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::filter\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_filter_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::local-only\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_local_only_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::preview-widget\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_preview_widget_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::preview-widget-active\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_preview_widget_active_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::select-multiple\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_select_multiple_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::show-hidden\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_show_hidden_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    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,
        ) {
            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 _,
                b"notify::use-preview-label\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_use_preview_label_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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