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

use crate::FileChooserAction;
use crate::FileFilter;
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] and [`FileChooserDialog`][crate::FileChooserDialog].
    ///
    /// 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 filenames as `GFile`s.
    ///
    /// # Adding options
    ///
    /// You can add extra widgets to a file chooser to provide options
    /// that are not present in the default design, by using
    /// [`FileChooserExtManual::add_choice()`][crate::prelude::FileChooserExtManual::add_choice()]. Each choice has an identifier and
    /// a user visible label; additionally, each choice can have multiple
    /// options. If a choice has no option, it will be rendered as a
    /// check button with the given label; if a choice has options, it will
    /// be rendered as a combo box.
    ///
    /// # 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
///
/// [`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 if it is floating,
    /// 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.
    /// ## `folder`
    /// a `GFile` for the folder to add
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be added successfully,
    ///   [`false`] otherwise.
    #[doc(alias = "gtk_file_chooser_add_shortcut_folder")]
    fn add_shortcut_folder(&self, folder: &impl IsA<gio::File>) -> Result<(), glib::Error>;

    /// Gets the type of operation that the file chooser is performing.
    ///
    /// # 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 currently selected option
    #[doc(alias = "gtk_file_chooser_get_choice")]
    #[doc(alias = "get_choice")]
    fn choice(&self, id: &str) -> Option<glib::GString>;

    /// Gets whether file chooser will offer to create new 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 `GFile`.
    ///
    /// # Returns
    ///
    /// the `GFile` for the current folder.
    #[doc(alias = "gtk_file_chooser_get_current_folder")]
    #[doc(alias = "get_current_folder")]
    fn current_folder(&self) -> Option<gio::File>;

    /// Gets the current name in the file selector, as entered by the user.
    ///
    /// This is meant to be used in save dialogs, to get the currently typed
    /// filename when the file itself does not exist yet.
    ///
    /// # Returns
    ///
    /// The raw text from the file chooser’s “Name” entry. Free 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>;

    /// Gets the `GFile` 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 `GFile`. 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>;

    /// Lists all the selected files and subfolders in the current folder
    /// of @self as `GFile`.
    ///
    /// # Returns
    ///
    /// a list model containing a `GFile` for each
    ///   selected file and subfolder in the current folder. Free the returned
    ///   list with g_object_unref().
    #[doc(alias = "gtk_file_chooser_get_files")]
    #[doc(alias = "get_files")]
    fn files(&self) -> gio::ListModel;

    /// Gets the current filter.
    ///
    /// # Returns
    ///
    /// the current filter
    #[doc(alias = "gtk_file_chooser_get_filter")]
    #[doc(alias = "get_filter")]
    fn filter(&self) -> Option<FileFilter>;

    /// Gets the current set of user-selectable filters, as a list model.
    ///
    /// See [`add_filter()`][Self::add_filter()] and
    /// [`remove_filter()`][Self::remove_filter()] for changing individual filters.
    ///
    /// You should not modify the returned list model. Future changes to
    /// @self may or may not affect the returned model.
    ///
    /// # Returns
    ///
    /// a `GListModel` containing the current set
    ///   of user-selectable filters.
    #[doc(alias = "gtk_file_chooser_get_filters")]
    #[doc(alias = "get_filters")]
    fn filters(&self) -> gio::ListModel;

    /// Gets whether multiple files can be selected in the file
    /// chooser.
    ///
    /// # 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;

    /// Queries the list of shortcut folders in the file chooser.
    ///
    /// You should not modify the returned list model. Future changes to
    /// @self may or may not affect the returned model.
    ///
    /// # Returns
    ///
    /// A list model of `GFile`s
    #[doc(alias = "gtk_file_chooser_get_shortcut_folders")]
    #[doc(alias = "get_shortcut_folders")]
    fn shortcut_folders(&self) -> gio::ListModel;

    /// Removes a 'choice' that has been added with gtk_file_chooser_add_choice().
    /// ## `id`
    /// the ID of the choice to remove
    #[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 the shortcut folders in a file chooser.
    /// ## `folder`
    /// a `GFile` for the folder to remove
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be removed successfully,
    ///   [`false`] otherwise.
    #[doc(alias = "gtk_file_chooser_remove_shortcut_folder")]
    fn remove_shortcut_folder(&self, folder: &impl IsA<gio::File>) -> Result<(), glib::Error>;

    /// 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
    #[doc(alias = "gtk_file_chooser_set_choice")]
    fn set_choice(&self, id: &str, option: &str);

    /// Sets whether file chooser 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 `GFile`.
    /// ## `file`
    /// the `GFile` for the new folder
    ///
    /// # Returns
    ///
    /// [`true`] if the folder could be changed successfully, [`false`]
    ///   otherwise.
    #[doc(alias = "gtk_file_chooser_set_current_folder")]
    fn set_current_folder(&self, file: Option<&impl IsA<gio::File>>) -> Result<(), glib::Error>;

    /// 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_file()`][Self::set_file()] 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 @file as the current filename for the file chooser.
    ///
    /// This includes 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 @file.
    ///
    /// 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
    /// static void
    /// prepare_file_chooser (GtkFileChooser *chooser,
    ///                       GFile          *existing_file)
    /// {
    ///   gboolean document_is_new = (existing_file == NULL);
    ///
    ///   if (document_is_new)
    ///     {
    ///       GFile *default_file_for_saving = g_file_new_for_path ("./out.txt");
    ///       // the user just created a new document
    ///       gtk_file_chooser_set_current_folder (chooser, default_file_for_saving, NULL);
    ///       gtk_file_chooser_set_current_name (chooser, "Untitled document");
    ///       g_object_unref (default_file_for_saving);
    ///     }
    ///   else
    ///     {
    ///       // the user edited an existing document
    ///       gtk_file_chooser_set_file (chooser, existing_file, NULL);
    ///     }
    /// }
    /// ```
    /// ## `file`
    /// the `GFile` 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>;

    /// 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 multiple files can be selected in the file chooser.
    ///
    /// 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);

    #[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 = "filter")]
    fn connect_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;

    #[doc(alias = "filters")]
    fn connect_filters_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 = "shortcut-folders")]
    fn connect_shortcut_folders_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_none().0,
            );
        }
    }

    fn add_shortcut_folder(&self, folder: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = 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,
            );
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            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,
            ))
        }
    }

    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<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_current_folder(
                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 file(&self) -> Option<gio::File> {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_file(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    fn files(&self) -> gio::ListModel {
        unsafe {
            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 filters(&self) -> gio::ListModel {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_filters(
                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 shortcut_folders(&self) -> gio::ListModel {
        unsafe {
            from_glib_full(ffi::gtk_file_chooser_get_shortcut_folders(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    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(&self, folder: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = 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,
            );
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

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

    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(&self, file: Option<&impl IsA<gio::File>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gtk_file_chooser_set_current_folder(
                self.as_ref().to_glib_none().0,
                file.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    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_file(&self, file: &impl IsA<gio::File>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = 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,
            );
            assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    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_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 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_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_filters_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_filters_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::filters\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_filters_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_shortcut_folders_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_shortcut_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::shortcut-folders\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_shortcut_folders_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")
    }
}