libadwaita/auto/

flap.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git)
// DO NOT EDIT
#![allow(deprecated)]

use crate::{
    FlapFoldPolicy, FlapTransitionType, FoldThresholdPolicy, SpringParams, Swipeable, ffi,
};
use glib::{
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::boxed::Box as Box_;

#[cfg(feature = "gtk_v4_10")]
#[cfg_attr(docsrs, doc(cfg(feature = "gtk_v4_10")))]
glib::wrapper! {
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ` element, and separator by specifying “separator”. Specifying
    /// “content” child type or omitting it results in setting the content child.
    ///
    /// ## CSS nodes
    ///
    /// [`Flap`][crate::Flap] has a single CSS node with name `flap`. The node will get the style
    /// classes `.folded` when it is folded, and `.unfolded` when it's not.
    ///
    /// ## Properties
    ///
    ///
    /// #### `content`
    ///  The content widget.
    ///
    /// It's always displayed when unfolded, and partially visible when folded.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `flap`
    ///  The flap widget.
    ///
    /// It's only visible when [`reveal-progress`][struct@crate::Flap#reveal-progress] is greater than 0.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `flap-position`
    ///  The flap position.
    ///
    /// If it's set to [enum@Gtk.PackType.start], the flap is displayed before the
    /// content, if [enum@Gtk.PackType.end], it's displayed after the content.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `fold-duration`
    ///  The fold transition animation duration, in milliseconds.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `fold-policy`
    ///  The fold policy for the flap.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `fold-threshold-policy`
    ///  Determines when the flap will fold.
    ///
    /// If set to [enum@Adw.FoldThresholdPolicy.minimum], flap will only fold when
    /// the children cannot fit anymore. With [enum@Adw.FoldThresholdPolicy.natural],
    /// it will fold as soon as children don't get their natural size.
    ///
    /// This can be useful if you have a long ellipsizing label and want to let it
    /// ellipsize instead of immediately folding.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `folded`
    ///  Whether the flap is currently folded.
    ///
    /// See [`fold-policy`][struct@crate::Flap#fold-policy].
    ///
    /// Readable
    ///
    ///
    /// #### `locked`
    ///  Whether the flap is locked.
    ///
    /// If `FALSE`, folding when the flap is revealed automatically closes it, and
    /// unfolding it when the flap is not revealed opens it. If `TRUE`,
    /// [`reveal-flap`][struct@crate::Flap#reveal-flap] value never changes on its own.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `modal`
    ///   key, will close the flap. If `FALSE`, clicks
    /// are passed through to the content widget.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `reveal-flap`
    ///  Whether the flap widget is revealed.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `reveal-params`
    ///  The reveal animation spring parameters.
    ///
    /// The default value is equivalent to:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// adw_spring_params_new (1, 0.5, 500)
    /// ```
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `reveal-progress`
    ///  The current reveal transition progress.
    ///
    /// 0 means fully hidden, 1 means fully revealed.
    ///
    /// See [`reveal-flap`][struct@crate::Flap#reveal-flap].
    ///
    /// Readable
    ///
    ///
    /// #### `separator`
    ///  The separator widget.
    ///
    /// It's displayed between content and flap when there's no shadow to display.
    /// When exactly it's visible depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `swipe-to-close`
    ///  Whether the flap can be closed with a swipe gesture.
    ///
    /// The area that can be swiped depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `swipe-to-open`
    ///  Whether the flap can be opened with a swipe gesture.
    ///
    /// The area that can be swiped depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `transition-type`
    ///  the type of animation used for reveal and fold transitions.
    ///
    /// [`flap`][struct@crate::Flap#flap] is transparent by default, which means the content
    /// will be seen through it with [enum@Adw.FlapTransitionType.over] transitions;
    /// add the [`.background`](style-classes.html#background) style class to it if
    /// this is unwanted.
    ///
    /// Readable | Writable
    /// <details><summary><h4>Widget</h4></summary>
    ///
    ///
    /// #### `can-focus`
    ///  Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `can-target`
    ///  Whether the widget can receive pointer events.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `css-classes`
    ///  A list of css classes applied to this widget.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `css-name`
    ///  The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `cursor`
    ///  The cursor used by @widget.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `focus-on-click`
    ///  Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `focusable`
    ///  Whether this widget itself will accept the input focus.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `halign`
    ///  How to distribute horizontal space if widget gets extra space.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `has-default`
    ///  Whether the widget is the default widget.
    ///
    /// Readable
    ///
    ///
    /// #### `has-focus`
    ///  Whether the widget has the input focus.
    ///
    /// Readable
    ///
    ///
    /// #### `has-tooltip`
    ///  Enables or disables the emission of the [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `height-request`
    ///  Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `hexpand`
    ///  Whether to expand horizontally.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `hexpand-set`
    ///  Whether to use the `hexpand` property.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `layout-manager`
    ///  The [`gtk::LayoutManager`][crate::gtk::LayoutManager] instance to use to compute
    /// the preferred size of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `limit-events`
    ///  Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See `Gtk::EventController::set_propagation_limit()`.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-bottom`
    ///  Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-end`
    ///  Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-start`
    ///  Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `margin-top`
    ///  Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `name`
    ///  The name of the widget.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `opacity`
    ///  The requested opacity of the widget.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `overflow`
    ///  How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `parent`
    ///  The parent widget of this widget.
    ///
    /// Readable
    ///
    ///
    /// #### `receives-default`
    ///  Whether the widget will receive the default action when it is focused.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `root`
    ///  The [`gtk::Root`][crate::gtk::Root] widget of the widget tree containing this widget.
    ///
    /// This will be `NULL` if the widget is not contained in a root widget.
    ///
    /// Readable
    ///
    ///
    /// #### `scale-factor`
    ///  The scale factor of the widget.
    ///
    /// Readable
    ///
    ///
    /// #### `sensitive`
    ///  Whether the widget responds to input.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `tooltip-markup`
    ///  Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see `Gtk::Tooltip::set_markup()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `tooltip-text`
    ///  Sets the text of tooltip to be the given string.
    ///
    /// Also see `Gtk::Tooltip::set_text()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#tooltip-markup] are set, the last one wins.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `valign`
    ///  How to distribute vertical space if widget gets extra space.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `vexpand`
    ///  Whether to expand vertically.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `vexpand-set`
    ///  Whether to use the `vexpand` property.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `visible`
    ///  Whether the widget is visible.
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `width-request`
    ///  Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    ///
    /// Readable | Writable
    /// </details>
    /// <details><summary><h4>Accessible</h4></summary>
    ///
    ///
    /// #### `accessible-role`
    ///  The accessible role of the given [`gtk::Accessible`][crate::gtk::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    ///
    /// Readable | Writable
    /// </details>
    /// <details><summary><h4>Orientable</h4></summary>
    ///
    ///
    /// #### `orientation`
    ///  The orientation of the orientable.
    ///
    /// Readable | Writable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`trait@gtk::prelude::WidgetExt`], [`trait@glib::ObjectExt`], [`trait@gtk::prelude::AccessibleExt`], [`trait@gtk::prelude::BuildableExt`], [`trait@gtk::prelude::ConstraintTargetExt`], [`SwipeableExt`][trait@crate::prelude::SwipeableExt], [`trait@gtk::prelude::OrientableExt`]
    #[doc(alias = "AdwFlap")]
    pub struct Flap(Object<ffi::AdwFlap, ffi::AdwFlapClass>) @extends gtk::Widget, @implements gtk::Accessible, gtk::Buildable, gtk::ConstraintTarget, Swipeable, gtk::Orientable;

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

#[cfg(not(feature = "gtk_v4_10"))]
glib::wrapper! {
    #[doc(alias = "AdwFlap")]
    pub struct Flap(Object<ffi::AdwFlap, ffi::AdwFlapClass>) @extends gtk::Widget, @implements gtk::Buildable, gtk::ConstraintTarget, Swipeable, gtk::Orientable;

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

impl Flap {
    /// Creates a new [`Flap`][crate::Flap].
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the newly created [`Flap`][crate::Flap]
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_new")]
    pub fn new() -> Flap {
        assert_initialized_main_thread!();
        unsafe { gtk::Widget::from_glib_none(ffi::adw_flap_new()).unsafe_cast() }
    }

    // rustdoc-stripper-ignore-next
    /// Creates a new builder-pattern struct instance to construct [`Flap`] objects.
    ///
    /// This method returns an instance of [`FlapBuilder`](crate::builders::FlapBuilder) which can be used to create [`Flap`] objects.
    pub fn builder() -> FlapBuilder {
        FlapBuilder::new()
    }

    /// Gets the content widget for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the content widget for @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_content")]
    #[doc(alias = "get_content")]
    pub fn content(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::adw_flap_get_content(self.to_glib_none().0)) }
    }

    /// Gets the flap widget for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the flap widget for @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_flap")]
    #[doc(alias = "get_flap")]
    pub fn flap(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::adw_flap_get_flap(self.to_glib_none().0)) }
    }

    /// Gets the flap position for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the flap position for @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_flap_position")]
    #[doc(alias = "get_flap_position")]
    #[doc(alias = "flap-position")]
    pub fn flap_position(&self) -> gtk::PackType {
        unsafe { from_glib(ffi::adw_flap_get_flap_position(self.to_glib_none().0)) }
    }

    /// Gets the fold transition animation duration for @self, in milliseconds.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the fold transition duration
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_fold_duration")]
    #[doc(alias = "get_fold_duration")]
    #[doc(alias = "fold-duration")]
    pub fn fold_duration(&self) -> u32 {
        unsafe { ffi::adw_flap_get_fold_duration(self.to_glib_none().0) }
    }

    /// Gets the fold policy for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the fold policy for @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_fold_policy")]
    #[doc(alias = "get_fold_policy")]
    #[doc(alias = "fold-policy")]
    pub fn fold_policy(&self) -> FlapFoldPolicy {
        unsafe { from_glib(ffi::adw_flap_get_fold_policy(self.to_glib_none().0)) }
    }

    /// Gets the fold threshold policy for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the fold threshold policy
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_fold_threshold_policy")]
    #[doc(alias = "get_fold_threshold_policy")]
    #[doc(alias = "fold-threshold-policy")]
    pub fn fold_threshold_policy(&self) -> FoldThresholdPolicy {
        unsafe {
            from_glib(ffi::adw_flap_get_fold_threshold_policy(
                self.to_glib_none().0,
            ))
        }
    }

    /// Gets whether @self is currently folded.
    ///
    /// See [`fold-policy`][struct@crate::Flap#fold-policy].
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// `TRUE` if @self is currently folded
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_folded")]
    #[doc(alias = "get_folded")]
    #[doc(alias = "folded")]
    pub fn is_folded(&self) -> bool {
        unsafe { from_glib(ffi::adw_flap_get_folded(self.to_glib_none().0)) }
    }

    /// Gets whether @self is locked.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// `TRUE` if @self is locked
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_locked")]
    #[doc(alias = "get_locked")]
    #[doc(alias = "locked")]
    pub fn is_locked(&self) -> bool {
        unsafe { from_glib(ffi::adw_flap_get_locked(self.to_glib_none().0)) }
    }

    /// Gets whether @self is modal.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// `TRUE` if @self is modal
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_modal")]
    #[doc(alias = "get_modal")]
    #[doc(alias = "modal")]
    pub fn is_modal(&self) -> bool {
        unsafe { from_glib(ffi::adw_flap_get_modal(self.to_glib_none().0)) }
    }

    /// Gets whether the flap widget is revealed for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// `TRUE` if the flap widget is revealed
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_reveal_flap")]
    #[doc(alias = "get_reveal_flap")]
    #[doc(alias = "reveal-flap")]
    pub fn reveals_flap(&self) -> bool {
        unsafe { from_glib(ffi::adw_flap_get_reveal_flap(self.to_glib_none().0)) }
    }

    /// Gets the reveal animation spring parameters for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the reveal animation parameters
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_reveal_params")]
    #[doc(alias = "get_reveal_params")]
    #[doc(alias = "reveal-params")]
    pub fn reveal_params(&self) -> SpringParams {
        unsafe { from_glib_full(ffi::adw_flap_get_reveal_params(self.to_glib_none().0)) }
    }

    /// Gets the current reveal progress for @self.
    ///
    /// 0 means fully hidden, 1 means fully revealed.
    ///
    /// See [`reveal-flap`][struct@crate::Flap#reveal-flap].
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the current reveal progress for @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_reveal_progress")]
    #[doc(alias = "get_reveal_progress")]
    #[doc(alias = "reveal-progress")]
    pub fn reveal_progress(&self) -> f64 {
        unsafe { ffi::adw_flap_get_reveal_progress(self.to_glib_none().0) }
    }

    /// Gets the separator widget for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the separator widget for @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_separator")]
    #[doc(alias = "get_separator")]
    pub fn separator(&self) -> Option<gtk::Widget> {
        unsafe { from_glib_none(ffi::adw_flap_get_separator(self.to_glib_none().0)) }
    }

    /// Gets whether @self can be closed with a swipe gesture.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// `TRUE` if @self can be closed with a swipe gesture
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_swipe_to_close")]
    #[doc(alias = "get_swipe_to_close")]
    #[doc(alias = "swipe-to-close")]
    pub fn is_swipe_to_close(&self) -> bool {
        unsafe { from_glib(ffi::adw_flap_get_swipe_to_close(self.to_glib_none().0)) }
    }

    /// Gets whether @self can be opened with a swipe gesture.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// `TRUE` if @self can be opened with a swipe gesture
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_swipe_to_open")]
    #[doc(alias = "get_swipe_to_open")]
    #[doc(alias = "swipe-to-open")]
    pub fn is_swipe_to_open(&self) -> bool {
        unsafe { from_glib(ffi::adw_flap_get_swipe_to_open(self.to_glib_none().0)) }
    }

    /// Gets the type of animation used for reveal and fold transitions in @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    ///
    /// # Returns
    ///
    /// the current transition type of @self
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_get_transition_type")]
    #[doc(alias = "get_transition_type")]
    #[doc(alias = "transition-type")]
    pub fn transition_type(&self) -> FlapTransitionType {
        unsafe { from_glib(ffi::adw_flap_get_transition_type(self.to_glib_none().0)) }
    }

    /// Sets the content widget for @self.
    ///
    /// It's always displayed when unfolded, and partially visible when folded.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `content`
    /// the content widget
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_content")]
    #[doc(alias = "content")]
    pub fn set_content(&self, content: Option<&impl IsA<gtk::Widget>>) {
        unsafe {
            ffi::adw_flap_set_content(
                self.to_glib_none().0,
                content.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the flap widget for @self.
    ///
    /// It's only visible when [`reveal-progress`][struct@crate::Flap#reveal-progress] is greater than 0.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `flap`
    /// the flap widget
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_flap")]
    #[doc(alias = "flap")]
    pub fn set_flap(&self, flap: Option<&impl IsA<gtk::Widget>>) {
        unsafe {
            ffi::adw_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 it's set to [enum@Gtk.PackType.start], the flap is displayed before the
    /// content, if [enum@Gtk.PackType.end], it's displayed after the content.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `position`
    /// the new value
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_flap_position")]
    #[doc(alias = "flap-position")]
    pub fn set_flap_position(&self, position: gtk::PackType) {
        unsafe {
            ffi::adw_flap_set_flap_position(self.to_glib_none().0, position.into_glib());
        }
    }

    /// Sets the fold transition animation duration for @self, in milliseconds.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `duration`
    /// the new duration, in milliseconds
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_fold_duration")]
    #[doc(alias = "fold-duration")]
    pub fn set_fold_duration(&self, duration: u32) {
        unsafe {
            ffi::adw_flap_set_fold_duration(self.to_glib_none().0, duration);
        }
    }

    /// Sets the fold policy for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `policy`
    /// the fold policy
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_fold_policy")]
    #[doc(alias = "fold-policy")]
    pub fn set_fold_policy(&self, policy: FlapFoldPolicy) {
        unsafe {
            ffi::adw_flap_set_fold_policy(self.to_glib_none().0, policy.into_glib());
        }
    }

    /// Sets the fold threshold policy for @self.
    ///
    /// If set to [enum@Adw.FoldThresholdPolicy.minimum], flap will only fold when
    /// the children cannot fit anymore. With [enum@Adw.FoldThresholdPolicy.natural],
    /// it will fold as soon as children don't get their natural size.
    ///
    /// This can be useful if you have a long ellipsizing label and want to let it
    /// ellipsize instead of immediately folding.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `policy`
    /// the policy to use
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_fold_threshold_policy")]
    #[doc(alias = "fold-threshold-policy")]
    pub fn set_fold_threshold_policy(&self, policy: FoldThresholdPolicy) {
        unsafe {
            ffi::adw_flap_set_fold_threshold_policy(self.to_glib_none().0, policy.into_glib());
        }
    }

    /// Sets whether @self is locked.
    ///
    /// If `FALSE`, folding when the flap is revealed automatically closes it, and
    /// unfolding it when the flap is not revealed opens it. If `TRUE`,
    /// [`reveal-flap`][struct@crate::Flap#reveal-flap] value never changes on its own.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `locked`
    /// the new value
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_locked")]
    #[doc(alias = "locked")]
    pub fn set_locked(&self, locked: bool) {
        unsafe {
            ffi::adw_flap_set_locked(self.to_glib_none().0, locked.into_glib());
        }
    }

    ///  key, will close the flap. If `FALSE`, clicks are
    /// passed through to the content widget.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `modal`
    /// whether @self is modal
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_modal")]
    #[doc(alias = "modal")]
    pub fn set_modal(&self, modal: bool) {
        unsafe {
            ffi::adw_flap_set_modal(self.to_glib_none().0, modal.into_glib());
        }
    }

    /// Sets whether the flap widget is revealed for @self.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `reveal_flap`
    /// whether to reveal the flap widget
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_reveal_flap")]
    #[doc(alias = "reveal-flap")]
    pub fn set_reveal_flap(&self, reveal_flap: bool) {
        unsafe {
            ffi::adw_flap_set_reveal_flap(self.to_glib_none().0, reveal_flap.into_glib());
        }
    }

    /// Sets the reveal animation spring parameters for @self.
    ///
    /// The default value is equivalent to:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// adw_spring_params_new (1, 0.5, 500)
    /// ```
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `params`
    /// the new parameters
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_reveal_params")]
    #[doc(alias = "reveal-params")]
    pub fn set_reveal_params(&self, params: &SpringParams) {
        unsafe {
            ffi::adw_flap_set_reveal_params(self.to_glib_none().0, params.to_glib_none().0);
        }
    }

    /// Sets the separator widget for @self.
    ///
    /// It's displayed between content and flap when there's no shadow to display.
    /// When exactly it's visible depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `separator`
    /// the separator widget
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_separator")]
    #[doc(alias = "separator")]
    pub fn set_separator(&self, separator: Option<&impl IsA<gtk::Widget>>) {
        unsafe {
            ffi::adw_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 [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `swipe_to_close`
    /// whether @self can be closed with a swipe gesture
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_swipe_to_close")]
    #[doc(alias = "swipe-to-close")]
    pub fn set_swipe_to_close(&self, swipe_to_close: bool) {
        unsafe {
            ffi::adw_flap_set_swipe_to_close(self.to_glib_none().0, swipe_to_close.into_glib());
        }
    }

    /// Sets whether @self can be opened with a swipe gesture.
    ///
    /// The area that can be swiped depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `swipe_to_open`
    /// whether @self can be opened with a swipe gesture
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_swipe_to_open")]
    #[doc(alias = "swipe-to-open")]
    pub fn set_swipe_to_open(&self, swipe_to_open: bool) {
        unsafe {
            ffi::adw_flap_set_swipe_to_open(self.to_glib_none().0, swipe_to_open.into_glib());
        }
    }

    /// Sets the type of animation used for reveal and fold transitions in @self.
    ///
    /// [`flap`][struct@crate::Flap#flap] is transparent by default, which means the content will
    /// be seen through it with [enum@Adw.FlapTransitionType.over] transitions; add
    /// the [`.background`](style-classes.html#background) style class to it if this
    /// is unwanted.
    ///
    /// # Deprecated since 1.4
    ///
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    /// ## `transition_type`
    /// the new transition type
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[allow(deprecated)]
    #[doc(alias = "adw_flap_set_transition_type")]
    #[doc(alias = "transition-type")]
    pub fn set_transition_type(&self, transition_type: FlapTransitionType) {
        unsafe {
            ffi::adw_flap_set_transition_type(self.to_glib_none().0, transition_type.into_glib());
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "content")]
    pub fn connect_content_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_content_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::content".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_content_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "flap")]
    pub fn connect_flap_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flap_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::flap".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_flap_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "flap-position")]
    pub fn connect_flap_position_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_flap_position_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::flap-position".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_flap_position_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "fold-duration")]
    pub fn connect_fold_duration_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_fold_duration_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::fold-duration".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fold_duration_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "fold-policy")]
    pub fn connect_fold_policy_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_fold_policy_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::fold-policy".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fold_policy_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "fold-threshold-policy")]
    pub fn connect_fold_threshold_policy_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_fold_threshold_policy_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::fold-threshold-policy".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_fold_threshold_policy_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "folded")]
    pub fn connect_folded_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_folded_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::folded".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_folded_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "locked")]
    pub fn connect_locked_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_locked_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::locked".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_locked_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "modal")]
    pub fn connect_modal_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_modal_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::modal".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_modal_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "reveal-flap")]
    pub fn connect_reveal_flap_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_reveal_flap_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::reveal-flap".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_reveal_flap_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "reveal-params")]
    pub fn connect_reveal_params_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_reveal_params_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::reveal-params".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_reveal_params_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "reveal-progress")]
    pub fn connect_reveal_progress_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_reveal_progress_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::reveal-progress".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_reveal_progress_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "separator")]
    pub fn connect_separator_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_separator_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::separator".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_separator_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "swipe-to-close")]
    pub fn connect_swipe_to_close_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_swipe_to_close_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::swipe-to-close".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_swipe_to_close_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "swipe-to-open")]
    pub fn connect_swipe_to_open_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_swipe_to_open_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::swipe-to-open".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_swipe_to_open_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    #[doc(alias = "transition-type")]
    pub fn connect_transition_type_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_transition_type_trampoline<F: Fn(&Flap) + 'static>(
            this: *mut ffi::AdwFlap,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                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 _,
                c"notify::transition-type".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_transition_type_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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

// rustdoc-stripper-ignore-next
/// A [builder-pattern] type to construct [`Flap`] objects.
///
/// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html
#[must_use = "The builder must be built to be used"]
pub struct FlapBuilder {
    builder: glib::object::ObjectBuilder<'static, Flap>,
}

impl FlapBuilder {
    fn new() -> Self {
        Self {
            builder: glib::object::Object::builder(),
        }
    }

    /// The content widget.
    ///
    /// It's always displayed when unfolded, and partially visible when folded.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn content(self, content: &impl IsA<gtk::Widget>) -> Self {
        Self {
            builder: self.builder.property("content", content.clone().upcast()),
        }
    }

    /// The flap widget.
    ///
    /// It's only visible when [`reveal-progress`][struct@crate::Flap#reveal-progress] is greater than 0.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn flap(self, flap: &impl IsA<gtk::Widget>) -> Self {
        Self {
            builder: self.builder.property("flap", flap.clone().upcast()),
        }
    }

    /// The flap position.
    ///
    /// If it's set to [enum@Gtk.PackType.start], the flap is displayed before the
    /// content, if [enum@Gtk.PackType.end], it's displayed after the content.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn flap_position(self, flap_position: gtk::PackType) -> Self {
        Self {
            builder: self.builder.property("flap-position", flap_position),
        }
    }

    /// The fold transition animation duration, in milliseconds.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn fold_duration(self, fold_duration: u32) -> Self {
        Self {
            builder: self.builder.property("fold-duration", fold_duration),
        }
    }

    /// The fold policy for the flap.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn fold_policy(self, fold_policy: FlapFoldPolicy) -> Self {
        Self {
            builder: self.builder.property("fold-policy", fold_policy),
        }
    }

    /// Determines when the flap will fold.
    ///
    /// If set to [enum@Adw.FoldThresholdPolicy.minimum], flap will only fold when
    /// the children cannot fit anymore. With [enum@Adw.FoldThresholdPolicy.natural],
    /// it will fold as soon as children don't get their natural size.
    ///
    /// This can be useful if you have a long ellipsizing label and want to let it
    /// ellipsize instead of immediately folding.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn fold_threshold_policy(self, fold_threshold_policy: FoldThresholdPolicy) -> Self {
        Self {
            builder: self
                .builder
                .property("fold-threshold-policy", fold_threshold_policy),
        }
    }

    /// Whether the flap is locked.
    ///
    /// If `FALSE`, folding when the flap is revealed automatically closes it, and
    /// unfolding it when the flap is not revealed opens it. If `TRUE`,
    /// [`reveal-flap`][struct@crate::Flap#reveal-flap] value never changes on its own.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn locked(self, locked: bool) -> Self {
        Self {
            builder: self.builder.property("locked", locked),
        }
    }

    ///  key, will close the flap. If `FALSE`, clicks
    /// are passed through to the content widget.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn modal(self, modal: bool) -> Self {
        Self {
            builder: self.builder.property("modal", modal),
        }
    }

    /// Whether the flap widget is revealed.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn reveal_flap(self, reveal_flap: bool) -> Self {
        Self {
            builder: self.builder.property("reveal-flap", reveal_flap),
        }
    }

    /// The reveal animation spring parameters.
    ///
    /// The default value is equivalent to:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// adw_spring_params_new (1, 0.5, 500)
    /// ```
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn reveal_params(self, reveal_params: &SpringParams) -> Self {
        Self {
            builder: self
                .builder
                .property("reveal-params", reveal_params.clone()),
        }
    }

    /// The separator widget.
    ///
    /// It's displayed between content and flap when there's no shadow to display.
    /// When exactly it's visible depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn separator(self, separator: &impl IsA<gtk::Widget>) -> Self {
        Self {
            builder: self
                .builder
                .property("separator", separator.clone().upcast()),
        }
    }

    /// Whether the flap can be closed with a swipe gesture.
    ///
    /// The area that can be swiped depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn swipe_to_close(self, swipe_to_close: bool) -> Self {
        Self {
            builder: self.builder.property("swipe-to-close", swipe_to_close),
        }
    }

    /// Whether the flap can be opened with a swipe gesture.
    ///
    /// The area that can be swiped depends on the [`transition-type`][struct@crate::Flap#transition-type]
    /// value.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn swipe_to_open(self, swipe_to_open: bool) -> Self {
        Self {
            builder: self.builder.property("swipe-to-open", swipe_to_open),
        }
    }

    /// the type of animation used for reveal and fold transitions.
    ///
    /// [`flap`][struct@crate::Flap#flap] is transparent by default, which means the content
    /// will be seen through it with [enum@Adw.FlapTransitionType.over] transitions;
    /// add the [`.background`](style-classes.html#background) style class to it if
    /// this is unwanted.
    /// See [the migration guide](migrating-to-breakpoints.html#replace-adwflap)
    #[cfg_attr(feature = "v1_4", deprecated = "Since 1.4")]
    pub fn transition_type(self, transition_type: FlapTransitionType) -> Self {
        Self {
            builder: self.builder.property("transition-type", transition_type),
        }
    }

    /// Whether the widget or any of its descendents can accept
    /// the input focus.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn can_focus(self, can_focus: bool) -> Self {
        Self {
            builder: self.builder.property("can-focus", can_focus),
        }
    }

    /// Whether the widget can receive pointer events.
    pub fn can_target(self, can_target: bool) -> Self {
        Self {
            builder: self.builder.property("can-target", can_target),
        }
    }

    /// A list of css classes applied to this widget.
    pub fn css_classes(self, css_classes: impl Into<glib::StrV>) -> Self {
        Self {
            builder: self.builder.property("css-classes", css_classes.into()),
        }
    }

    /// The name of this widget in the CSS tree.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn css_name(self, css_name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("css-name", css_name.into()),
        }
    }

    /// The cursor used by @widget.
    pub fn cursor(self, cursor: &gdk::Cursor) -> Self {
        Self {
            builder: self.builder.property("cursor", cursor.clone()),
        }
    }

    /// Whether the widget should grab focus when it is clicked with the mouse.
    ///
    /// This property is only relevant for widgets that can take focus.
    pub fn focus_on_click(self, focus_on_click: bool) -> Self {
        Self {
            builder: self.builder.property("focus-on-click", focus_on_click),
        }
    }

    /// Whether this widget itself will accept the input focus.
    pub fn focusable(self, focusable: bool) -> Self {
        Self {
            builder: self.builder.property("focusable", focusable),
        }
    }

    /// How to distribute horizontal space if widget gets extra space.
    pub fn halign(self, halign: gtk::Align) -> Self {
        Self {
            builder: self.builder.property("halign", halign),
        }
    }

    /// Enables or disables the emission of the [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip]
    /// signal on @widget.
    ///
    /// A true value indicates that @widget can have a tooltip, in this case
    /// the widget will be queried using [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] to
    /// determine whether it will provide a tooltip or not.
    pub fn has_tooltip(self, has_tooltip: bool) -> Self {
        Self {
            builder: self.builder.property("has-tooltip", has_tooltip),
        }
    }

    /// Overrides for height request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn height_request(self, height_request: i32) -> Self {
        Self {
            builder: self.builder.property("height-request", height_request),
        }
    }

    /// Whether to expand horizontally.
    pub fn hexpand(self, hexpand: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand", hexpand),
        }
    }

    /// Whether to use the `hexpand` property.
    pub fn hexpand_set(self, hexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("hexpand-set", hexpand_set),
        }
    }

    /// The [`gtk::LayoutManager`][crate::gtk::LayoutManager] instance to use to compute
    /// the preferred size of the widget, and allocate its children.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn layout_manager(self, layout_manager: &impl IsA<gtk::LayoutManager>) -> Self {
        Self {
            builder: self
                .builder
                .property("layout-manager", layout_manager.clone().upcast()),
        }
    }

    /// Makes this widget act like a modal dialog, with respect to
    /// event delivery.
    ///
    /// Global event controllers will not handle events with targets
    /// inside the widget, unless they are set up to ignore propagation
    /// limits. See `Gtk::EventController::set_propagation_limit()`.
    #[cfg(feature = "gtk_v4_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "gtk_v4_18")))]
    pub fn limit_events(self, limit_events: bool) -> Self {
        Self {
            builder: self.builder.property("limit-events", limit_events),
        }
    }

    /// Margin on bottom side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    pub fn margin_bottom(self, margin_bottom: i32) -> Self {
        Self {
            builder: self.builder.property("margin-bottom", margin_bottom),
        }
    }

    /// Margin on end of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    pub fn margin_end(self, margin_end: i32) -> Self {
        Self {
            builder: self.builder.property("margin-end", margin_end),
        }
    }

    /// Margin on start of widget, horizontally.
    ///
    /// This property supports left-to-right and right-to-left text
    /// directions.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    pub fn margin_start(self, margin_start: i32) -> Self {
        Self {
            builder: self.builder.property("margin-start", margin_start),
        }
    }

    /// Margin on top side of widget.
    ///
    /// This property adds margin outside of the widget's normal size
    /// request, the margin will be added in addition to the size from
    /// [`WidgetExtManual::set_size_request()`][crate::gtk::prelude::WidgetExtManual::set_size_request()] for example.
    pub fn margin_top(self, margin_top: i32) -> Self {
        Self {
            builder: self.builder.property("margin-top", margin_top),
        }
    }

    /// The name of the widget.
    pub fn name(self, name: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("name", name.into()),
        }
    }

    /// The requested opacity of the widget.
    pub fn opacity(self, opacity: f64) -> Self {
        Self {
            builder: self.builder.property("opacity", opacity),
        }
    }

    /// How content outside the widget's content area is treated.
    ///
    /// This property is meant to be set by widget implementations,
    /// typically in their instance init function.
    pub fn overflow(self, overflow: gtk::Overflow) -> Self {
        Self {
            builder: self.builder.property("overflow", overflow),
        }
    }

    /// Whether the widget will receive the default action when it is focused.
    pub fn receives_default(self, receives_default: bool) -> Self {
        Self {
            builder: self.builder.property("receives-default", receives_default),
        }
    }

    /// Whether the widget responds to input.
    pub fn sensitive(self, sensitive: bool) -> Self {
        Self {
            builder: self.builder.property("sensitive", sensitive),
        }
    }

    /// Sets the text of tooltip to be the given string, which is marked up
    /// with Pango markup.
    ///
    /// Also see `Gtk::Tooltip::set_markup()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#tooltip-markup] are set, the last one wins.
    pub fn tooltip_markup(self, tooltip_markup: impl Into<glib::GString>) -> Self {
        Self {
            builder: self
                .builder
                .property("tooltip-markup", tooltip_markup.into()),
        }
    }

    /// Sets the text of tooltip to be the given string.
    ///
    /// Also see `Gtk::Tooltip::set_text()`.
    ///
    /// This is a convenience property which will take care of getting the
    /// tooltip shown if the given string is not `NULL`:
    /// [`has-tooltip`][struct@crate::gtk::Widget#has-tooltip] will automatically be set to true
    /// and there will be taken care of [`query-tooltip`][struct@crate::gtk::Widget#query-tooltip] in
    /// the default signal handler.
    ///
    /// Note that if both [`tooltip-text`][struct@crate::gtk::Widget#tooltip-text] and
    /// [`tooltip-markup`][struct@crate::gtk::Widget#tooltip-markup] are set, the last one wins.
    pub fn tooltip_text(self, tooltip_text: impl Into<glib::GString>) -> Self {
        Self {
            builder: self.builder.property("tooltip-text", tooltip_text.into()),
        }
    }

    /// How to distribute vertical space if widget gets extra space.
    pub fn valign(self, valign: gtk::Align) -> Self {
        Self {
            builder: self.builder.property("valign", valign),
        }
    }

    /// Whether to expand vertically.
    pub fn vexpand(self, vexpand: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand", vexpand),
        }
    }

    /// Whether to use the `vexpand` property.
    pub fn vexpand_set(self, vexpand_set: bool) -> Self {
        Self {
            builder: self.builder.property("vexpand-set", vexpand_set),
        }
    }

    /// Whether the widget is visible.
    pub fn visible(self, visible: bool) -> Self {
        Self {
            builder: self.builder.property("visible", visible),
        }
    }

    /// Overrides for width request of the widget.
    ///
    /// If this is -1, the natural request will be used.
    pub fn width_request(self, width_request: i32) -> Self {
        Self {
            builder: self.builder.property("width-request", width_request),
        }
    }

    /// The accessible role of the given [`gtk::Accessible`][crate::gtk::Accessible] implementation.
    ///
    /// The accessible role cannot be changed once set.
    pub fn accessible_role(self, accessible_role: gtk::AccessibleRole) -> Self {
        Self {
            builder: self.builder.property("accessible-role", accessible_role),
        }
    }

    /// The orientation of the orientable.
    pub fn orientation(self, orientation: gtk::Orientation) -> Self {
        Self {
            builder: self.builder.property("orientation", orientation),
        }
    }

    // rustdoc-stripper-ignore-next
    /// Build the [`Flap`].
    #[must_use = "Building the object from the builder is usually expensive and is not expected to have side effects"]
    pub fn build(self) -> Flap {
        assert_initialized_main_thread!();
        self.builder.build()
    }
}