// 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::{Adjustment, Border, ScrollablePolicy};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute};

glib::wrapper! {
    /// [`Scrollable`][crate::Scrollable] is an interface for widgets with native scrolling ability.
    ///
    /// To implement this interface you should override the
    /// [`hadjustment`][struct@crate::Scrollable#hadjustment] and
    /// [`vadjustment`][struct@crate::Scrollable#vadjustment] properties.
    ///
    /// ## Creating a scrollable widget
    ///
    /// All scrollable widgets should do the following.
    ///
    /// - When a parent widget sets the scrollable child widget’s adjustments,
    ///   the widget should connect to the [`value-changed`][struct@crate::Adjustment#value-changed]
    ///   signal. The child widget should then populate the adjustments’ properties
    ///   as soon as possible, which usually means queueing an allocation right away
    ///   and populating the properties in the [`WidgetImpl::size_allocate()`][crate::subclass::prelude::WidgetImpl::size_allocate()]
    ///   implementation.
    ///
    /// - Because its preferred size is the size for a fully expanded widget,
    ///   the scrollable widget must be able to cope with underallocations.
    ///   This means that it must accept any value passed to its
    ///   [`WidgetImpl::size_allocate()`][crate::subclass::prelude::WidgetImpl::size_allocate()] implementation.
    ///
    /// - When the parent allocates space to the scrollable child widget,
    ///   the widget must ensure the adjustments’ property values are correct and up
    ///   to date, for example using [`AdjustmentExt::configure()`][crate::prelude::AdjustmentExt::configure()].
    ///
    /// - When any of the adjustments emits the [`value-changed`][struct@crate::Adjustment#value-changed]
    ///   signal, the scrollable widget should scroll its contents.
    ///
    /// ## Properties
    ///
    ///
    /// #### `hadjustment`
    ///  Horizontal [`Adjustment`][crate::Adjustment] of the scrollable widget.
    ///
    /// This adjustment is shared between the scrollable widget and its parent.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `hscroll-policy`
    ///  Determines when horizontal scrolling should start.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `vadjustment`
    ///  Vertical [`Adjustment`][crate::Adjustment] of the scrollable widget.
    ///
    /// This adjustment is shared between the scrollable widget and its parent.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `vscroll-policy`
    ///  Determines when vertical scrolling should start.
    ///
    /// Readable | Writeable
    ///
    /// # Implements
    ///
    /// [`ScrollableExt`][trait@crate::prelude::ScrollableExt]
    #[doc(alias = "GtkScrollable")]
    pub struct Scrollable(Interface<ffi::GtkScrollable, ffi::GtkScrollableInterface>);

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

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

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

/// Trait containing all [`struct@Scrollable`] methods.
///
/// # Implementors
///
/// [`ColumnView`][struct@crate::ColumnView], [`GridView`][struct@crate::GridView], [`IconView`][struct@crate::IconView], [`ListBase`][struct@crate::ListBase], [`ListView`][struct@crate::ListView], [`Scrollable`][struct@crate::Scrollable], [`TextView`][struct@crate::TextView], [`TreeView`][struct@crate::TreeView], [`Viewport`][struct@crate::Viewport]
pub trait ScrollableExt: IsA<Scrollable> + sealed::Sealed + 'static {
    /// Returns the size of a non-scrolling border around the
    /// outside of the scrollable.
    ///
    /// An example for this would be treeview headers. GTK can use
    /// this information to display overlaid graphics, like the
    /// overshoot indication, at the right position.
    ///
    /// # Returns
    ///
    /// [`true`] if @border has been set
    ///
    /// ## `border`
    /// return location for the results
    #[doc(alias = "gtk_scrollable_get_border")]
    #[doc(alias = "get_border")]
    fn border(&self) -> Option<Border> {
        unsafe {
            let mut border = Border::uninitialized();
            let ret = from_glib(ffi::gtk_scrollable_get_border(
                self.as_ref().to_glib_none().0,
                border.to_glib_none_mut().0,
            ));
            if ret {
                Some(border)
            } else {
                None
            }
        }
    }

    /// Retrieves the [`Adjustment`][crate::Adjustment] used for horizontal scrolling.
    ///
    /// # Returns
    ///
    /// horizontal [`Adjustment`][crate::Adjustment].
    #[doc(alias = "gtk_scrollable_get_hadjustment")]
    #[doc(alias = "get_hadjustment")]
    fn hadjustment(&self) -> Option<Adjustment> {
        unsafe {
            from_glib_none(ffi::gtk_scrollable_get_hadjustment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the horizontal [`ScrollablePolicy`][crate::ScrollablePolicy].
    ///
    /// # Returns
    ///
    /// The horizontal [`ScrollablePolicy`][crate::ScrollablePolicy].
    #[doc(alias = "gtk_scrollable_get_hscroll_policy")]
    #[doc(alias = "get_hscroll_policy")]
    fn hscroll_policy(&self) -> ScrollablePolicy {
        unsafe {
            from_glib(ffi::gtk_scrollable_get_hscroll_policy(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Retrieves the [`Adjustment`][crate::Adjustment] used for vertical scrolling.
    ///
    /// # Returns
    ///
    /// vertical [`Adjustment`][crate::Adjustment].
    #[doc(alias = "gtk_scrollable_get_vadjustment")]
    #[doc(alias = "get_vadjustment")]
    fn vadjustment(&self) -> Option<Adjustment> {
        unsafe {
            from_glib_none(ffi::gtk_scrollable_get_vadjustment(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the vertical [`ScrollablePolicy`][crate::ScrollablePolicy].
    ///
    /// # Returns
    ///
    /// The vertical [`ScrollablePolicy`][crate::ScrollablePolicy].
    #[doc(alias = "gtk_scrollable_get_vscroll_policy")]
    #[doc(alias = "get_vscroll_policy")]
    fn vscroll_policy(&self) -> ScrollablePolicy {
        unsafe {
            from_glib(ffi::gtk_scrollable_get_vscroll_policy(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Sets the horizontal adjustment of the [`Scrollable`][crate::Scrollable].
    /// ## `hadjustment`
    /// a [`Adjustment`][crate::Adjustment]
    #[doc(alias = "gtk_scrollable_set_hadjustment")]
    fn set_hadjustment(&self, hadjustment: Option<&impl IsA<Adjustment>>) {
        unsafe {
            ffi::gtk_scrollable_set_hadjustment(
                self.as_ref().to_glib_none().0,
                hadjustment.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the [`ScrollablePolicy`][crate::ScrollablePolicy].
    ///
    /// The policy determines whether horizontal scrolling should start
    /// below the minimum width or below the natural width.
    /// ## `policy`
    /// the horizontal [`ScrollablePolicy`][crate::ScrollablePolicy]
    #[doc(alias = "gtk_scrollable_set_hscroll_policy")]
    fn set_hscroll_policy(&self, policy: ScrollablePolicy) {
        unsafe {
            ffi::gtk_scrollable_set_hscroll_policy(
                self.as_ref().to_glib_none().0,
                policy.into_glib(),
            );
        }
    }

    /// Sets the vertical adjustment of the [`Scrollable`][crate::Scrollable].
    /// ## `vadjustment`
    /// a [`Adjustment`][crate::Adjustment]
    #[doc(alias = "gtk_scrollable_set_vadjustment")]
    fn set_vadjustment(&self, vadjustment: Option<&impl IsA<Adjustment>>) {
        unsafe {
            ffi::gtk_scrollable_set_vadjustment(
                self.as_ref().to_glib_none().0,
                vadjustment.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Sets the [`ScrollablePolicy`][crate::ScrollablePolicy].
    ///
    /// The policy determines whether vertical scrolling should start
    /// below the minimum height or below the natural height.
    /// ## `policy`
    /// the vertical [`ScrollablePolicy`][crate::ScrollablePolicy]
    #[doc(alias = "gtk_scrollable_set_vscroll_policy")]
    fn set_vscroll_policy(&self, policy: ScrollablePolicy) {
        unsafe {
            ffi::gtk_scrollable_set_vscroll_policy(
                self.as_ref().to_glib_none().0,
                policy.into_glib(),
            );
        }
    }

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

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

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

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

impl<O: IsA<Scrollable>> ScrollableExt for O {}

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