// 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::FlapFoldPolicy;
use crate::FlapTransitionType;
use crate::Swipeable;
use glib::object::Cast;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    pub struct Flap(Object<ffi::HdyFlap, ffi::HdyFlapClass>) @extends gtk::Widget, @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, gtk::Orientable, Swipeable;

    match fn {
        get_type => || ffi::hdy_flap_get_type(),
    }
}

impl Flap {
    /// Creates a new `Flap`.
    ///
    /// # Returns
    ///
    /// a new `Flap`
    #[doc(alias = "hdy_flap_new")]
    pub fn new() -> Flap {
        assert_initialized_main_thread!();
        unsafe { gtk::Widget::from_glib_none(ffi::hdy_flap_new()).unsafe_cast() }
    }

    /// Gets the content widget for `self`
    ///
    /// # Returns
    ///
    /// the content widget for `self`
    #[doc(alias = "hdy_flap_get_content")]
    pub fn get_content(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::hdy_flap_get_content(self.to_glib_none().0)) }
    }

    /// Gets the flap widget for `self`
    ///
    /// # Returns
    ///
    /// the flap widget for `self`
    #[doc(alias = "hdy_flap_get_flap")]
    pub fn get_flap(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::hdy_flap_get_flap(self.to_glib_none().0)) }
    }

    /// Gets the flap position for `self`.
    ///
    /// # Returns
    ///
    /// the flap position for `self`
    #[doc(alias = "hdy_flap_get_flap_position")]
    pub fn get_flap_position(&self) -> gtk::PackType {
        unsafe { from_glib(ffi::hdy_flap_get_flap_position(self.to_glib_none().0)) }
    }

    /// Returns the amount of time (in milliseconds) that fold transitions in `self`
    /// will take.
    ///
    /// # Returns
    ///
    /// the fold transition duration
    #[doc(alias = "hdy_flap_get_fold_duration")]
    pub fn get_fold_duration(&self) -> u32 {
        unsafe { ffi::hdy_flap_get_fold_duration(self.to_glib_none().0) }
    }

    /// Gets the current fold policy of `self`. See `Flap::set_fold_policy`.
    ///
    /// # Returns
    ///
    /// the current fold policy of `self`
    #[doc(alias = "hdy_flap_get_fold_policy")]
    pub fn get_fold_policy(&self) -> FlapFoldPolicy {
        unsafe { from_glib(ffi::hdy_flap_get_fold_policy(self.to_glib_none().0)) }
    }

    /// Gets whether `self` is currently folded.
    ///
    /// See `Flap:fold-policy`.
    ///
    /// # Returns
    ///
    /// `true` if `self` is currently folded, `false` otherwise
    #[doc(alias = "hdy_flap_get_folded")]
    pub fn get_folded(&self) -> bool {
        unsafe { from_glib(ffi::hdy_flap_get_folded(self.to_glib_none().0)) }
    }

    /// Gets whether `self` is locked.
    ///
    /// # Returns
    ///
    /// `true` if `self` is locked, `false` otherwise
    #[doc(alias = "hdy_flap_get_locked")]
    pub fn get_locked(&self) -> bool {
        unsafe { from_glib(ffi::hdy_flap_get_locked(self.to_glib_none().0)) }
    }

    /// Gets whether the `self` is modal. See `Flap::set_modal`.
    ///
    /// # Returns
    ///
    /// `true` if `self` is modal
    #[doc(alias = "hdy_flap_get_modal")]
    pub fn get_modal(&self) -> bool {
        unsafe { from_glib(ffi::hdy_flap_get_modal(self.to_glib_none().0)) }
    }

    /// Returns the amount of time (in milliseconds) that reveal transitions in `self`
    /// will take.
    ///
    /// # Returns
    ///
    /// the reveal transition duration
    #[doc(alias = "hdy_flap_get_reveal_duration")]
    pub fn get_reveal_duration(&self) -> u32 {
        unsafe { ffi::hdy_flap_get_reveal_duration(self.to_glib_none().0) }
    }

    /// Gets whether the flap widget is revealed for `self`.
    ///
    /// # Returns
    ///
    /// `true` if the flap widget is revealed, `false` otherwise.
    #[doc(alias = "hdy_flap_get_reveal_flap")]
    pub fn get_reveal_flap(&self) -> bool {
        unsafe { from_glib(ffi::hdy_flap_get_reveal_flap(self.to_glib_none().0)) }
    }

    /// Gets the current reveal transition progress for `self`. 0 means fully hidden,
    /// 1 means fully revealed. See `Flap:reveal-flap`.
    ///
    /// # Returns
    ///
    /// the current reveal progress for `self`
    #[doc(alias = "hdy_flap_get_reveal_progress")]
    pub fn get_reveal_progress(&self) -> f64 {
        unsafe { ffi::hdy_flap_get_reveal_progress(self.to_glib_none().0) }
    }

    /// Gets the separator widget for `self`.
    ///
    /// # Returns
    ///
    /// the separator widget for `self`
    #[doc(alias = "hdy_flap_get_separator")]
    pub fn get_separator(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::hdy_flap_get_separator(self.to_glib_none().0)) }
    }

    /// Gets whether `self` can be closed with a swipe gesture.
    ///
    /// # Returns
    ///
    /// `true` if `self` can be closed with a swipe gesture
    #[doc(alias = "hdy_flap_get_swipe_to_close")]
    pub fn get_swipe_to_close(&self) -> bool {
        unsafe { from_glib(ffi::hdy_flap_get_swipe_to_close(self.to_glib_none().0)) }
    }

    /// Gets whether `self` can be opened with a swipe gesture.
    ///
    /// # Returns
    ///
    /// `true` if `self` can be opened with a swipe gesture
    #[doc(alias = "hdy_flap_get_swipe_to_open")]
    pub fn get_swipe_to_open(&self) -> bool {
        unsafe { from_glib(ffi::hdy_flap_get_swipe_to_open(self.to_glib_none().0)) }
    }

    /// Gets the type of animation that will be used for reveal and fold transitions
    /// in `self`.
    ///
    /// # Returns
    ///
    /// the current transition type of `self`
    #[doc(alias = "hdy_flap_get_transition_type")]
    pub fn get_transition_type(&self) -> FlapTransitionType {
        unsafe { from_glib(ffi::hdy_flap_get_transition_type(self.to_glib_none().0)) }
    }

    /// Sets the content widget for `self`, always displayed when unfolded, and
    /// partially visible when folded.
    /// ## `content`
    /// the content widget, or `None`
    #[doc(alias = "hdy_flap_set_content")]
    pub fn set_content<P: IsA<gtk::Widget>>(&self, content: Option<&P>) {
        unsafe {
            ffi::hdy_flap_set_content(
                self.to_glib_none().0,
                content.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the flap widget for `self`, only visible when `Flap:reveal-progress` is
    /// greater than 0.
    /// ## `flap`
    /// the flap widget, or `None`
    #[doc(alias = "hdy_flap_set_flap")]
    pub fn set_flap<P: IsA<gtk::Widget>>(&self, flap: Option<&P>) {
        unsafe {
            ffi::hdy_flap_set_flap(
                self.to_glib_none().0,
                flap.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the flap position for `self`. If `gtk::PackType::Start`, the flap is displayed
    /// before the content, if `gtk::PackType::End`, it's displayed after the content.
    /// ## `position`
    /// the new value
    #[doc(alias = "hdy_flap_set_flap_position")]
    pub fn set_flap_position(&self, position: gtk::PackType) {
        unsafe {
            ffi::hdy_flap_set_flap_position(self.to_glib_none().0, position.to_glib());
        }
    }

    /// Sets the duration that fold transitions in `self` will take.
    /// ## `duration`
    /// the new duration, in milliseconds
    #[doc(alias = "hdy_flap_set_fold_duration")]
    pub fn set_fold_duration(&self, duration: u32) {
        unsafe {
            ffi::hdy_flap_set_fold_duration(self.to_glib_none().0, duration);
        }
    }

    /// Sets the current fold policy for `self`. See `FlapFoldPolicy` for available
    /// policies.
    /// ## `policy`
    /// Fold policy
    #[doc(alias = "hdy_flap_set_fold_policy")]
    pub fn set_fold_policy(&self, policy: FlapFoldPolicy) {
        unsafe {
            ffi::hdy_flap_set_fold_policy(self.to_glib_none().0, policy.to_glib());
        }
    }

    /// Sets whether `self` is locked.
    ///
    /// If `false`, folding `self` when the flap is revealed automatically closes it,
    /// and unfolding it when the flap is not revealed opens it. If `true`,
    /// `Flap:reveal-flap` value never changes on its own.
    /// ## `locked`
    /// the new value
    #[doc(alias = "hdy_flap_set_locked")]
    pub fn set_locked(&self, locked: bool) {
        unsafe {
            ffi::hdy_flap_set_locked(self.to_glib_none().0, locked.to_glib());
        }
    }

    /// Sets whether the `self` can be closed with a click.
    ///
    /// If `modal` is `true`, clicking the content widget while flap is revealed, or
    /// pressing Escape key, will close the flap. If `false`, clicks are passed
    /// through to the content widget.
    /// ## `modal`
    /// Whether `self` can be closed with a click
    #[doc(alias = "hdy_flap_set_modal")]
    pub fn set_modal(&self, modal: bool) {
        unsafe {
            ffi::hdy_flap_set_modal(self.to_glib_none().0, modal.to_glib());
        }
    }

    /// Sets the duration that reveal transitions in `self` will take.
    /// ## `duration`
    /// the new duration, in milliseconds
    #[doc(alias = "hdy_flap_set_reveal_duration")]
    pub fn set_reveal_duration(&self, duration: u32) {
        unsafe {
            ffi::hdy_flap_set_reveal_duration(self.to_glib_none().0, duration);
        }
    }

    /// Sets whether the flap widget is revealed for `self`.
    /// ## `reveal_flap`
    /// `true` to reveal the flap widget, `false` otherwise
    #[doc(alias = "hdy_flap_set_reveal_flap")]
    pub fn set_reveal_flap(&self, reveal_flap: bool) {
        unsafe {
            ffi::hdy_flap_set_reveal_flap(self.to_glib_none().0, reveal_flap.to_glib());
        }
    }

    /// Sets the separator widget for `self`, displayed between content and flap when
    /// there's no shadow to display. When exactly it's visible depends on the
    /// `Flap:transition-type` value. If `None`, no separator will be used.
    /// ## `separator`
    /// the separator widget, or `None`
    #[doc(alias = "hdy_flap_set_separator")]
    pub fn set_separator<P: IsA<gtk::Widget>>(&self, separator: Option<&P>) {
        unsafe {
            ffi::hdy_flap_set_separator(
                self.to_glib_none().0,
                separator.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets whether `self` can be closed with a swipe gesture.
    ///
    /// The area that can be swiped depends on the `Flap:transition-type` value.
    /// ## `swipe_to_close`
    /// Whether `self` can be closed with a swipe gesture
    #[doc(alias = "hdy_flap_set_swipe_to_close")]
    pub fn set_swipe_to_close(&self, swipe_to_close: bool) {
        unsafe {
            ffi::hdy_flap_set_swipe_to_close(self.to_glib_none().0, swipe_to_close.to_glib());
        }
    }

    /// Sets whether `self` can be opened with a swipe gesture.
    ///
    /// The area that can be swiped depends on the `Flap:transition-type` value.
    /// ## `swipe_to_open`
    /// Whether `self` can be opened with a swipe gesture
    #[doc(alias = "hdy_flap_set_swipe_to_open")]
    pub fn set_swipe_to_open(&self, swipe_to_open: bool) {
        unsafe {
            ffi::hdy_flap_set_swipe_to_open(self.to_glib_none().0, swipe_to_open.to_glib());
        }
    }

    /// Sets the type of animation that will be used for reveal and fold transitions
    /// in `self`.
    ///
    /// `Flap:flap` is transparent by default, which means the content will be seen
    /// through it with `FlapTransitionType::Over` transitions; add the
    /// .background style class to it if this is unwanted.
    /// ## `transition_type`
    /// the new transition type
    #[doc(alias = "hdy_flap_set_transition_type")]
    pub fn set_transition_type(&self, transition_type: FlapTransitionType) {
        unsafe {
            ffi::hdy_flap_set_transition_type(self.to_glib_none().0, transition_type.to_glib());
        }
    }

    pub fn connect_property_content_notify<F: Fn(&Flap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_content_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::content\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_content_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_flap_notify<F: Fn(&Flap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flap_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::flap\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_flap_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_flap_position_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_flap_position_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::flap-position\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_flap_position_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_fold_duration_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_fold_duration_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::fold-duration\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_fold_duration_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_fold_policy_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_fold_policy_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::fold-policy\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_fold_policy_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_folded_notify<F: Fn(&Flap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_folded_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::folded\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_folded_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_locked_notify<F: Fn(&Flap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_locked_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::locked\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_locked_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_modal_notify<F: Fn(&Flap) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_modal_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::modal\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_modal_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_reveal_duration_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_reveal_duration_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::reveal-duration\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_reveal_duration_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_reveal_flap_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_reveal_flap_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::reveal-flap\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_reveal_flap_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_reveal_progress_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_reveal_progress_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::reveal-progress\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_reveal_progress_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_separator_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_separator_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::separator\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_separator_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_swipe_to_close_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_swipe_to_close_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::swipe-to-close\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_swipe_to_close_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_swipe_to_open_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_swipe_to_open_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::swipe-to-open\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_swipe_to_open_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    pub fn connect_property_transition_type_notify<F: Fn(&Flap) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_transition_type_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::HdyFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(&from_glib_borrow(this))
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::transition-type\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_transition_type_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for Flap {
    fn default() -> Self {
        Self::new()
    }
}

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