// 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

use crate::{AnimationState, AnimationTarget};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// A base class for animations.
    ///
    /// [`Animation`][crate::Animation] represents an animation on a widget. It has a target that
    /// provides a value to animate, and a state indicating whether the
    /// animation hasn't been started yet, is playing, paused or finished.
    ///
    /// Currently there are two concrete animation types:
    /// [`TimedAnimation`][crate::TimedAnimation] and [`SpringAnimation`][crate::SpringAnimation].
    ///
    /// [`Animation`][crate::Animation] will automatically skip the animation if
    /// [`widget`][struct@crate::Animation#widget] is unmapped, or if
    /// [`gtk-enable-animations`][struct@crate::gtk::Settings#gtk-enable-animations] is `FALSE`.
    ///
    /// The [`done`][struct@crate::Animation#done] signal can be used to perform an action after
    /// the animation ends, for example hiding a widget after animating its
    /// [`opacity`][struct@crate::gtk::Widget#opacity] to 0.
    ///
    /// [`Animation`][crate::Animation] will be kept alive while the animation is playing. As such,
    /// it's safe to create an animation, start it and immediately unref it:
    /// A fire-and-forget animation:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static void
    /// animation_cb (double    value,
    ///               MyObject *self)
    /// {
    ///   // Do something with @value
    /// }
    ///
    /// static void
    /// my_object_animate (MyObject *self)
    /// {
    ///   AdwAnimationTarget *target =
    ///     adw_callback_animation_target_new ((AdwAnimationTargetFunc) animation_cb,
    ///                                        self, NULL);
    ///   g_autoptr (AdwAnimation) animation =
    ///     adw_timed_animation_new (widget, 0, 1, 250, target);
    ///
    ///   adw_animation_play (animation);
    /// }
    /// ```
    ///
    /// If there's a chance the previous animation for the same target hasn't yet
    /// finished, the previous animation should be stopped first, or the existing
    /// [`Animation`][crate::Animation] object can be reused.
    ///
    /// This is an Abstract Base Class, you cannot instantiate it.
    ///
    /// ## Properties
    ///
    ///
    /// #### `follow-enable-animations-setting`
    ///  Whether to skip the animation when animations are globally disabled.
    ///
    /// The default behavior is to skip the animation. Set to `FALSE` to disable
    /// this behavior.
    ///
    /// This can be useful for cases where animation is essential, like spinners,
    /// or in demo applications. Most other animations should keep it enabled.
    ///
    /// See [`gtk-enable-animations`][struct@crate::gtk::Settings#gtk-enable-animations].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `state`
    ///  The animation state.
    ///
    /// The state indicates whether the animation is currently playing, paused,
    /// finished or hasn't been started yet.
    ///
    /// Readable
    ///
    ///
    /// #### `target`
    ///  The target to animate.
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `value`
    ///  The current value of the animation.
    ///
    /// Readable
    ///
    ///
    /// #### `widget`
    ///  The animation widget.
    ///
    /// It provides the frame clock for the animation. It's not strictly necessary
    /// for this widget to be same as the one being animated.
    ///
    /// The widget must be mapped in order for the animation to work. If it's not
    /// mapped, or if it gets unmapped during an ongoing animation, the animation
    /// will be automatically skipped.
    ///
    /// Readable | Writeable | Construct Only
    ///
    /// ## Signals
    ///
    ///
    /// #### `done`
    ///  This signal is emitted when the animation has been completed, either on its
    /// own or via calling [`AnimationExt::skip()`][crate::prelude::AnimationExt::skip()].
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`AnimationExt`][trait@crate::prelude::AnimationExt], [`trait@glib::ObjectExt`]
    #[doc(alias = "AdwAnimation")]
    pub struct Animation(Object<ffi::AdwAnimation, ffi::AdwAnimationClass>);

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

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

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

/// Trait containing all [`struct@Animation`] methods.
///
/// # Implementors
///
/// [`Animation`][struct@crate::Animation], [`SpringAnimation`][struct@crate::SpringAnimation], [`TimedAnimation`][struct@crate::TimedAnimation]
pub trait AnimationExt: IsA<Animation> + sealed::Sealed + 'static {
    /// Gets whether @self should be skipped when animations are globally disabled.
    ///
    /// # Returns
    ///
    /// whether to follow the global setting
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    #[doc(alias = "adw_animation_get_follow_enable_animations_setting")]
    #[doc(alias = "get_follow_enable_animations_setting")]
    fn follows_enable_animations_setting(&self) -> bool {
        unsafe {
            from_glib(ffi::adw_animation_get_follow_enable_animations_setting(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current value of @self.
    ///
    /// The state indicates whether @self is currently playing, paused, finished or
    /// hasn't been started yet.
    ///
    /// # Returns
    ///
    /// the animation value
    #[doc(alias = "adw_animation_get_state")]
    #[doc(alias = "get_state")]
    fn state(&self) -> AnimationState {
        unsafe { from_glib(ffi::adw_animation_get_state(self.as_ref().to_glib_none().0)) }
    }

    /// Gets the target @self animates.
    ///
    /// # Returns
    ///
    /// the animation target
    #[doc(alias = "adw_animation_get_target")]
    #[doc(alias = "get_target")]
    fn target(&self) -> AnimationTarget {
        unsafe {
            from_glib_none(ffi::adw_animation_get_target(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the current value of @self.
    ///
    /// # Returns
    ///
    /// the current value
    #[doc(alias = "adw_animation_get_value")]
    #[doc(alias = "get_value")]
    fn value(&self) -> f64 {
        unsafe { ffi::adw_animation_get_value(self.as_ref().to_glib_none().0) }
    }

    /// Gets the widget @self was created for.
    ///
    /// It provides the frame clock for the animation. It's not strictly necessary
    /// for this widget to be same as the one being animated.
    ///
    /// The widget must be mapped in order for the animation to work. If it's not
    /// mapped, or if it gets unmapped during an ongoing animation, the animation
    /// will be automatically skipped.
    ///
    /// # Returns
    ///
    /// the animation widget
    #[doc(alias = "adw_animation_get_widget")]
    #[doc(alias = "get_widget")]
    fn widget(&self) -> gtk::Widget {
        unsafe {
            from_glib_none(ffi::adw_animation_get_widget(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Pauses a playing animation for @self.
    ///
    /// Does nothing if the current state of @self isn't `ADW_ANIMATION_PLAYING`.
    ///
    /// Sets [`state`][struct@crate::Animation#state] to `ADW_ANIMATION_PAUSED`.
    #[doc(alias = "adw_animation_pause")]
    fn pause(&self) {
        unsafe {
            ffi::adw_animation_pause(self.as_ref().to_glib_none().0);
        }
    }

    /// Starts the animation for @self.
    ///
    /// If the animation is playing, paused or has been completed, restarts it from
    /// the beginning. This allows to easily play an animation regardless of whether
    /// it's already playing or not.
    ///
    /// Sets [`state`][struct@crate::Animation#state] to `ADW_ANIMATION_PLAYING`.
    ///
    /// The animation will be automatically skipped if [`widget`][struct@crate::Animation#widget] is
    /// unmapped, or if [`gtk-enable-animations`][struct@crate::gtk::Settings#gtk-enable-animations] is `FALSE`.
    ///
    /// As such, it's not guaranteed that the animation will actually run. For
    /// example, when using `idle_add()` and starting an animation
    /// immediately afterwards, it's entirely possible that the idle callback will
    /// run after the animation has already finished, and not while it's playing.
    #[doc(alias = "adw_animation_play")]
    fn play(&self) {
        unsafe {
            ffi::adw_animation_play(self.as_ref().to_glib_none().0);
        }
    }

    /// Resets the animation for @self.
    ///
    /// Sets [`state`][struct@crate::Animation#state] to `ADW_ANIMATION_IDLE`.
    #[doc(alias = "adw_animation_reset")]
    fn reset(&self) {
        unsafe {
            ffi::adw_animation_reset(self.as_ref().to_glib_none().0);
        }
    }

    /// Resumes a paused animation for @self.
    ///
    /// This function must only be used if the animation has been paused with
    /// [`pause()`][Self::pause()].
    ///
    /// Sets [`state`][struct@crate::Animation#state] to `ADW_ANIMATION_PLAYING`.
    #[doc(alias = "adw_animation_resume")]
    fn resume(&self) {
        unsafe {
            ffi::adw_animation_resume(self.as_ref().to_glib_none().0);
        }
    }

    /// Sets whether to skip @self when animations are globally disabled.
    ///
    /// The default behavior is to skip the animation. Set to `FALSE` to disable this
    /// behavior.
    ///
    /// This can be useful for cases where animation is essential, like spinners, or
    /// in demo applications. Most other animations should keep it enabled.
    ///
    /// See [`gtk-enable-animations`][struct@crate::gtk::Settings#gtk-enable-animations].
    /// ## `setting`
    /// whether to follow the global setting
    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    #[doc(alias = "adw_animation_set_follow_enable_animations_setting")]
    fn set_follow_enable_animations_setting(&self, setting: bool) {
        unsafe {
            ffi::adw_animation_set_follow_enable_animations_setting(
                self.as_ref().to_glib_none().0,
                setting.into_glib(),
            );
        }
    }

    /// Sets the target @self animates to @target.
    /// ## `target`
    /// an animation target
    #[doc(alias = "adw_animation_set_target")]
    fn set_target(&self, target: &impl IsA<AnimationTarget>) {
        unsafe {
            ffi::adw_animation_set_target(
                self.as_ref().to_glib_none().0,
                target.as_ref().to_glib_none().0,
            );
        }
    }

    /// Skips the animation for @self.
    ///
    /// If the animation hasn't been started yet, is playing, or is paused, instantly
    /// skips the animation to the end and causes [`done`][struct@crate::Animation#done] to be
    /// emitted.
    ///
    /// Sets [`state`][struct@crate::Animation#state] to `ADW_ANIMATION_FINISHED`.
    #[doc(alias = "adw_animation_skip")]
    fn skip(&self) {
        unsafe {
            ffi::adw_animation_skip(self.as_ref().to_glib_none().0);
        }
    }

    /// This signal is emitted when the animation has been completed, either on its
    /// own or via calling [`skip()`][Self::skip()].
    #[doc(alias = "done")]
    fn connect_done<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn done_trampoline<P: IsA<Animation>, F: Fn(&P) + 'static>(
            this: *mut ffi::AdwAnimation,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Animation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"done\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    done_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v1_3")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v1_3")))]
    #[doc(alias = "follow-enable-animations-setting")]
    fn connect_follow_enable_animations_setting_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_follow_enable_animations_setting_trampoline<
            P: IsA<Animation>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::AdwAnimation,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(Animation::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::follow-enable-animations-setting\0".as_ptr() as *const _,
                Some(std::mem::transmute::<_, unsafe extern "C" fn()>(
                    notify_follow_enable_animations_setting_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

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

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

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

impl<O: IsA<Animation>> AnimationExt for O {}