gtk/auto/

recent_chooser.rs

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

use crate::{RecentFilter, RecentInfo, RecentSortType};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem, mem::transmute, ptr};

glib::wrapper! {
    /// [`RecentChooser`][crate::RecentChooser] is an interface that can be implemented by widgets
    /// displaying the list of recently used files. In GTK+, the main objects
    /// that implement this interface are [`RecentChooserWidget`][crate::RecentChooserWidget],
    /// [`RecentChooserDialog`][crate::RecentChooserDialog] and [`RecentChooserMenu`][crate::RecentChooserMenu].
    ///
    /// Recently used files are supported since GTK+ 2.10.
    ///
    /// ## Properties
    ///
    ///
    /// #### `filter`
    ///  The [`RecentFilter`][crate::RecentFilter] object to be used when displaying
    /// the recently used resources.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `limit`
    ///  The maximum number of recently used resources to be displayed,
    /// or -1 to display all items.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `local-only`
    ///  Whether this [`RecentChooser`][crate::RecentChooser] should display only local (file:)
    /// resources.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `recent-manager`
    ///  The [`RecentManager`][crate::RecentManager] instance used by the [`RecentChooser`][crate::RecentChooser] to
    /// display the list of recently used resources.
    ///
    /// Writeable | Construct Only
    ///
    ///
    /// #### `select-multiple`
    ///  Allow the user to select multiple resources.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `show-icons`
    ///  Whether this [`RecentChooser`][crate::RecentChooser] should display an icon near the item.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `show-not-found`
    ///  Whether this [`RecentChooser`][crate::RecentChooser] should display the recently used resources
    /// even if not present anymore. Setting this to [`false`] will perform a
    /// potentially expensive check on every local resource (every remote
    /// resource will always be displayed).
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `show-private`
    ///  Readable | Writeable
    ///
    ///
    /// #### `show-tips`
    ///  Whether this [`RecentChooser`][crate::RecentChooser] should display a tooltip containing the
    /// full path of the recently used resources.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `sort-type`
    ///  Sorting order to be used when displaying the recently used resources.
    ///
    /// Readable | Writeable
    ///
    /// ## Signals
    ///
    ///
    /// #### `item-activated`
    ///  This signal is emitted when the user "activates" a recent item
    /// in the recent chooser. This can happen by double-clicking on an item
    /// in the recently used resources list, or by pressing
    /// `Enter`.
    ///
    ///
    ///
    ///
    /// #### `selection-changed`
    ///  This signal is emitted when there is a change in the set of
    /// selected recently used resources. This can happen when a user
    /// modifies the selection with the mouse or the keyboard, or when
    /// explicitly calling functions to change the selection.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`RecentChooserExt`][trait@crate::prelude::RecentChooserExt]
    #[doc(alias = "GtkRecentChooser")]
    pub struct RecentChooser(Interface<ffi::GtkRecentChooser, ffi::GtkRecentChooserIface>);

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

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

mod sealed {
    pub trait Sealed {}
    impl<T: super::IsA<super::RecentChooser>> Sealed for T {}
}

/// Trait containing all [`struct@RecentChooser`] methods.
///
/// # Implementors
///
/// [`RecentChooserDialog`][struct@crate::RecentChooserDialog], [`RecentChooserMenu`][struct@crate::RecentChooserMenu], [`RecentChooserWidget`][struct@crate::RecentChooserWidget], [`RecentChooser`][struct@crate::RecentChooser]
pub trait RecentChooserExt: IsA<RecentChooser> + sealed::Sealed + 'static {
    /// Adds `filter` to the list of [`RecentFilter`][crate::RecentFilter] objects held by `self`.
    ///
    /// If no previous filter objects were defined, this function will call
    /// [`set_filter()`][Self::set_filter()].
    /// ## `filter`
    /// a [`RecentFilter`][crate::RecentFilter]
    #[doc(alias = "gtk_recent_chooser_add_filter")]
    fn add_filter(&self, filter: &RecentFilter) {
        unsafe {
            ffi::gtk_recent_chooser_add_filter(
                self.as_ref().to_glib_none().0,
                filter.to_glib_none().0,
            );
        }
    }

    /// Gets the [`RecentInfo`][crate::RecentInfo] currently selected by `self`.
    ///
    /// # Returns
    ///
    /// a [`RecentInfo`][crate::RecentInfo]. Use `gtk_recent_info_unref()` when
    ///  when you have finished using it.
    #[doc(alias = "gtk_recent_chooser_get_current_item")]
    #[doc(alias = "get_current_item")]
    fn current_item(&self) -> Option<RecentInfo> {
        unsafe {
            from_glib_full(ffi::gtk_recent_chooser_get_current_item(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the URI currently selected by `self`.
    ///
    /// # Returns
    ///
    /// a newly allocated string holding a URI.
    #[doc(alias = "gtk_recent_chooser_get_current_uri")]
    #[doc(alias = "get_current_uri")]
    fn current_uri(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::gtk_recent_chooser_get_current_uri(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the [`RecentFilter`][crate::RecentFilter] object currently used by `self` to affect
    /// the display of the recently used resources.
    ///
    /// # Returns
    ///
    /// a [`RecentFilter`][crate::RecentFilter] object.
    #[doc(alias = "gtk_recent_chooser_get_filter")]
    #[doc(alias = "get_filter")]
    fn filter(&self) -> Option<RecentFilter> {
        unsafe {
            from_glib_none(ffi::gtk_recent_chooser_get_filter(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the list of recently used resources in form of [`RecentInfo`][crate::RecentInfo] objects.
    ///
    /// The return value of this function is affected by the “sort-type” and
    /// “limit” properties of `self`.
    ///
    /// # Returns
    ///
    /// A newly allocated
    ///  list of [`RecentInfo`][crate::RecentInfo] objects. You should
    ///  use `gtk_recent_info_unref()` on every item of the list, and then free
    ///  the list itself using `g_list_free()`.
    #[doc(alias = "gtk_recent_chooser_get_items")]
    #[doc(alias = "get_items")]
    fn items(&self) -> Vec<RecentInfo> {
        unsafe {
            FromGlibPtrContainer::from_glib_full(ffi::gtk_recent_chooser_get_items(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the number of items returned by [`items()`][Self::items()]
    /// and [`uris()`][Self::uris()].
    ///
    /// # Returns
    ///
    /// A positive integer, or -1 meaning that all items are
    ///  returned.
    #[doc(alias = "gtk_recent_chooser_get_limit")]
    #[doc(alias = "get_limit")]
    fn limit(&self) -> i32 {
        unsafe { ffi::gtk_recent_chooser_get_limit(self.as_ref().to_glib_none().0) }
    }

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

    /// Gets whether `self` can select multiple items.
    ///
    /// # Returns
    ///
    /// [`true`] if `self` can select more than one item.
    #[doc(alias = "gtk_recent_chooser_get_select_multiple")]
    #[doc(alias = "get_select_multiple")]
    fn selects_multiple(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_recent_chooser_get_select_multiple(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves whether `self` should show an icon near the resource.
    ///
    /// # Returns
    ///
    /// [`true`] if the icons should be displayed, [`false`] otherwise.
    #[doc(alias = "gtk_recent_chooser_get_show_icons")]
    #[doc(alias = "get_show_icons")]
    fn shows_icons(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_recent_chooser_get_show_icons(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves whether `self` should show the recently used resources that
    /// were not found.
    ///
    /// # Returns
    ///
    /// [`true`] if the resources not found should be displayed, and
    ///  [`false`] otheriwse.
    #[doc(alias = "gtk_recent_chooser_get_show_not_found")]
    #[doc(alias = "get_show_not_found")]
    fn shows_not_found(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_recent_chooser_get_show_not_found(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns whether `self` should display recently used resources
    /// registered as private.
    ///
    /// # Returns
    ///
    /// [`true`] if the recent chooser should show private items,
    ///  [`false`] otherwise.
    #[doc(alias = "gtk_recent_chooser_get_show_private")]
    #[doc(alias = "get_show_private")]
    fn shows_private(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_recent_chooser_get_show_private(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets whether `self` should display tooltips containing the full path
    /// of a recently user resource.
    ///
    /// # Returns
    ///
    /// [`true`] if the recent chooser should show tooltips,
    ///  [`false`] otherwise.
    #[doc(alias = "gtk_recent_chooser_get_show_tips")]
    #[doc(alias = "get_show_tips")]
    fn shows_tips(&self) -> bool {
        unsafe {
            from_glib(ffi::gtk_recent_chooser_get_show_tips(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the value set by [`set_sort_type()`][Self::set_sort_type()].
    ///
    /// # Returns
    ///
    /// the sorting order of the `self`.
    #[doc(alias = "gtk_recent_chooser_get_sort_type")]
    #[doc(alias = "get_sort_type")]
    fn sort_type(&self) -> RecentSortType {
        unsafe {
            from_glib(ffi::gtk_recent_chooser_get_sort_type(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the URI of the recently used resources.
    ///
    /// The return value of this function is affected by the “sort-type” and “limit”
    /// properties of `self`.
    ///
    /// Since the returned array is [`None`] terminated, `length` may be [`None`].
    ///
    /// # Returns
    ///
    ///
    ///  A newly allocated, [`None`]-terminated array of strings. Use
    ///  `g_strfreev()` to free it.
    #[doc(alias = "gtk_recent_chooser_get_uris")]
    #[doc(alias = "get_uris")]
    fn uris(&self) -> Vec<glib::GString> {
        unsafe {
            let mut length = mem::MaybeUninit::uninit();
            let ret = FromGlibContainer::from_glib_full_num(
                ffi::gtk_recent_chooser_get_uris(
                    self.as_ref().to_glib_none().0,
                    length.as_mut_ptr(),
                ),
                length.assume_init() as _,
            );
            ret
        }
    }

    /// Gets the [`RecentFilter`][crate::RecentFilter] objects held by `self`.
    ///
    /// # Returns
    ///
    /// A singly linked list
    ///  of [`RecentFilter`][crate::RecentFilter] objects. You
    ///  should just free the returned list using `g_slist_free()`.
    #[doc(alias = "gtk_recent_chooser_list_filters")]
    fn list_filters(&self) -> Vec<RecentFilter> {
        unsafe {
            FromGlibPtrContainer::from_glib_container(ffi::gtk_recent_chooser_list_filters(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Removes `filter` from the list of [`RecentFilter`][crate::RecentFilter] objects held by `self`.
    /// ## `filter`
    /// a [`RecentFilter`][crate::RecentFilter]
    #[doc(alias = "gtk_recent_chooser_remove_filter")]
    fn remove_filter(&self, filter: &RecentFilter) {
        unsafe {
            ffi::gtk_recent_chooser_remove_filter(
                self.as_ref().to_glib_none().0,
                filter.to_glib_none().0,
            );
        }
    }

    /// Selects all the items inside `self`, if the `self` supports
    /// multiple selection.
    #[doc(alias = "gtk_recent_chooser_select_all")]
    fn select_all(&self) {
        unsafe {
            ffi::gtk_recent_chooser_select_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Selects `uri` inside `self`.
    /// ## `uri`
    /// a URI
    ///
    /// # Returns
    ///
    /// [`true`] if `uri` was found.
    #[doc(alias = "gtk_recent_chooser_select_uri")]
    fn select_uri(&self, uri: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gtk_recent_chooser_select_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets `uri` as the current URI for `self`.
    /// ## `uri`
    /// a URI
    ///
    /// # Returns
    ///
    /// [`true`] if the URI was found.
    #[doc(alias = "gtk_recent_chooser_set_current_uri")]
    fn set_current_uri(&self, uri: &str) -> Result<(), glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let is_ok = ffi::gtk_recent_chooser_set_current_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Sets `filter` as the current [`RecentFilter`][crate::RecentFilter] object used by `self`
    /// to affect the displayed recently used resources.
    /// ## `filter`
    /// a [`RecentFilter`][crate::RecentFilter]
    #[doc(alias = "gtk_recent_chooser_set_filter")]
    fn set_filter(&self, filter: Option<&RecentFilter>) {
        unsafe {
            ffi::gtk_recent_chooser_set_filter(
                self.as_ref().to_glib_none().0,
                filter.to_glib_none().0,
            );
        }
    }

    /// Sets the number of items that should be returned by
    /// [`items()`][Self::items()] and [`uris()`][Self::uris()].
    /// ## `limit`
    /// a positive integer, or -1 for all items
    #[doc(alias = "gtk_recent_chooser_set_limit")]
    fn set_limit(&self, limit: i32) {
        unsafe {
            ffi::gtk_recent_chooser_set_limit(self.as_ref().to_glib_none().0, limit);
        }
    }

    /// Sets whether only local resources, that is resources using the file:// URI
    /// scheme, should be shown in the recently used resources selector. If
    /// `local_only` is [`true`] (the default) then the shown resources are guaranteed
    /// to be accessible through the operating system native file system.
    /// ## `local_only`
    /// [`true`] if only local files can be shown
    #[doc(alias = "gtk_recent_chooser_set_local_only")]
    fn set_local_only(&self, local_only: bool) {
        unsafe {
            ffi::gtk_recent_chooser_set_local_only(
                self.as_ref().to_glib_none().0,
                local_only.into_glib(),
            );
        }
    }

    /// Sets whether `self` can select multiple items.
    /// ## `select_multiple`
    /// [`true`] if `self` can select more than one item
    #[doc(alias = "gtk_recent_chooser_set_select_multiple")]
    fn set_select_multiple(&self, select_multiple: bool) {
        unsafe {
            ffi::gtk_recent_chooser_set_select_multiple(
                self.as_ref().to_glib_none().0,
                select_multiple.into_glib(),
            );
        }
    }

    /// Sets whether `self` should show an icon near the resource when
    /// displaying it.
    /// ## `show_icons`
    /// whether to show an icon near the resource
    #[doc(alias = "gtk_recent_chooser_set_show_icons")]
    fn set_show_icons(&self, show_icons: bool) {
        unsafe {
            ffi::gtk_recent_chooser_set_show_icons(
                self.as_ref().to_glib_none().0,
                show_icons.into_glib(),
            );
        }
    }

    /// Sets whether `self` should display the recently used resources that
    /// it didn’t find. This only applies to local resources.
    /// ## `show_not_found`
    /// whether to show the local items we didn’t find
    #[doc(alias = "gtk_recent_chooser_set_show_not_found")]
    fn set_show_not_found(&self, show_not_found: bool) {
        unsafe {
            ffi::gtk_recent_chooser_set_show_not_found(
                self.as_ref().to_glib_none().0,
                show_not_found.into_glib(),
            );
        }
    }

    /// Whether to show recently used resources marked registered as private.
    /// ## `show_private`
    /// [`true`] to show private items, [`false`] otherwise
    #[doc(alias = "gtk_recent_chooser_set_show_private")]
    fn set_show_private(&self, show_private: bool) {
        unsafe {
            ffi::gtk_recent_chooser_set_show_private(
                self.as_ref().to_glib_none().0,
                show_private.into_glib(),
            );
        }
    }

    /// Sets whether to show a tooltips containing the full path of each
    /// recently used resource in a [`RecentChooser`][crate::RecentChooser] widget.
    /// ## `show_tips`
    /// [`true`] if tooltips should be shown
    #[doc(alias = "gtk_recent_chooser_set_show_tips")]
    fn set_show_tips(&self, show_tips: bool) {
        unsafe {
            ffi::gtk_recent_chooser_set_show_tips(
                self.as_ref().to_glib_none().0,
                show_tips.into_glib(),
            );
        }
    }

    /// Sets the comparison function used when sorting to be `sort_func`. If
    /// the `self` has the sort type set to [`RecentSortType::Custom`][crate::RecentSortType::Custom] then
    /// the chooser will sort using this function.
    ///
    /// To the comparison function will be passed two [`RecentInfo`][crate::RecentInfo] structs and
    /// `sort_data`; `sort_func` should return a positive integer if the first
    /// item comes before the second, zero if the two items are equal and
    /// a negative integer if the first item comes after the second.
    /// ## `sort_func`
    /// the comparison function
    /// ## `sort_data`
    /// user data to pass to `sort_func`, or [`None`]
    /// ## `data_destroy`
    /// destroy notifier for `sort_data`, or [`None`]
    #[doc(alias = "gtk_recent_chooser_set_sort_func")]
    fn set_sort_func<P: Fn(&RecentInfo, &RecentInfo) -> i32 + 'static>(&self, sort_func: P) {
        let sort_func_data: Box_<P> = Box_::new(sort_func);
        unsafe extern "C" fn sort_func_func<P: Fn(&RecentInfo, &RecentInfo) -> i32 + 'static>(
            a: *mut ffi::GtkRecentInfo,
            b: *mut ffi::GtkRecentInfo,
            user_data: glib::ffi::gpointer,
        ) -> libc::c_int {
            let a = from_glib_borrow(a);
            let b = from_glib_borrow(b);
            let callback: &P = &*(user_data as *mut _);
            (*callback)(&a, &b)
        }
        let sort_func = Some(sort_func_func::<P> as _);
        unsafe extern "C" fn data_destroy_func<P: Fn(&RecentInfo, &RecentInfo) -> i32 + 'static>(
            data: glib::ffi::gpointer,
        ) {
            let _callback: Box_<P> = Box_::from_raw(data as *mut _);
        }
        let destroy_call3 = Some(data_destroy_func::<P> as _);
        let super_callback0: Box_<P> = sort_func_data;
        unsafe {
            ffi::gtk_recent_chooser_set_sort_func(
                self.as_ref().to_glib_none().0,
                sort_func,
                Box_::into_raw(super_callback0) as *mut _,
                destroy_call3,
            );
        }
    }

    /// Changes the sorting order of the recently used resources list displayed by
    /// `self`.
    /// ## `sort_type`
    /// sort order that the chooser should use
    #[doc(alias = "gtk_recent_chooser_set_sort_type")]
    fn set_sort_type(&self, sort_type: RecentSortType) {
        unsafe {
            ffi::gtk_recent_chooser_set_sort_type(
                self.as_ref().to_glib_none().0,
                sort_type.into_glib(),
            );
        }
    }

    /// Unselects all the items inside `self`.
    #[doc(alias = "gtk_recent_chooser_unselect_all")]
    fn unselect_all(&self) {
        unsafe {
            ffi::gtk_recent_chooser_unselect_all(self.as_ref().to_glib_none().0);
        }
    }

    /// Unselects `uri` inside `self`.
    /// ## `uri`
    /// a URI
    #[doc(alias = "gtk_recent_chooser_unselect_uri")]
    fn unselect_uri(&self, uri: &str) {
        unsafe {
            ffi::gtk_recent_chooser_unselect_uri(
                self.as_ref().to_glib_none().0,
                uri.to_glib_none().0,
            );
        }
    }

    /// This signal is emitted when the user "activates" a recent item
    /// in the recent chooser. This can happen by double-clicking on an item
    /// in the recently used resources list, or by pressing
    /// `Enter`.
    #[doc(alias = "item-activated")]
    fn connect_item_activated<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn item_activated_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"item-activated\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    item_activated_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// This signal is emitted when there is a change in the set of
    /// selected recently used resources. This can happen when a user
    /// modifies the selection with the mouse or the keyboard, or when
    /// explicitly calling functions to change the selection.
    #[doc(alias = "selection-changed")]
    fn connect_selection_changed<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn selection_changed_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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),
            )
        }
    }

    #[doc(alias = "filter")]
    fn connect_filter_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_filter_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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),
            )
        }
    }

    #[doc(alias = "limit")]
    fn connect_limit_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_limit_trampoline<P: IsA<RecentChooser>, F: Fn(&P) + 'static>(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::limit\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_limit_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "local-only")]
    fn connect_local_only_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_local_only_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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),
            )
        }
    }

    #[doc(alias = "select-multiple")]
    fn connect_select_multiple_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_select_multiple_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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),
            )
        }
    }

    #[doc(alias = "show-icons")]
    fn connect_show_icons_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_icons_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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-icons\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_show_icons_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-not-found")]
    fn connect_show_not_found_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_not_found_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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-not-found\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_show_not_found_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-private")]
    fn connect_show_private_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_private_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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-private\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_show_private_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "show-tips")]
    fn connect_show_tips_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_show_tips_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::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-tips\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_show_tips_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "sort-type")]
    fn connect_sort_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_sort_type_trampoline<
            P: IsA<RecentChooser>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GtkRecentChooser,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(RecentChooser::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::sort-type\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_sort_type_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<RecentChooser>> RecentChooserExt for O {}

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