Struct libadwaita::Animation

pub struct Animation { /* private fields */ }

A base class for animations.

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 and SpringAnimation.

Animation will automatically skip the animation if widget is unmapped, or if gtk-enable-animations is FALSE.

The done signal can be used to perform an action after the animation ends, for example hiding a widget after animating its opacity to 0.

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 ⚠️

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

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().

Implements

AnimationExt, [trait@glib::ObjectExt]

Implementations

impl Animation

pub const NONE: Option<&'static Animation> = None

Trait Implementations

impl Clone for Animation

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Animation

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl HasParamSpec for Animation

type ParamSpec = ParamSpecObject

type SetValue = Animation

Preferred value to be used as setter for the associated ParamSpec.

type BuilderFn = fn(_: &str) -> ParamSpecObjectBuilder<'_, Animation>

fn param_spec_builder() -> Self::BuilderFn

impl Hash for Animation

fn hash<H>(&self, state: &mut H)

where H: Hasher,

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl Ord for Animation

fn cmp(&self, other: &Self) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized + PartialOrd,

Restrict a value to a certain interval.

impl ParentClassIs for Animation

type Parent = Object

impl<OT: ObjectType> PartialEq<OT> for Animation

fn eq(&self, other: &OT) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<OT: ObjectType> PartialOrd<OT> for Animation

fn partial_cmp(&self, other: &OT) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

fn lt(&self, other: &Rhs) -> bool

This method tests less than (for self and other) and is used by the < operator.

fn le(&self, other: &Rhs) -> bool

This method tests less than or equal to (for self and other) and is used by the <= operator.

fn gt(&self, other: &Rhs) -> bool

This method tests greater than (for self and other) and is used by the > operator.

fn ge(&self, other: &Rhs) -> bool

This method tests greater than or equal to (for self and other) and is used by the >= operator.

impl StaticType for Animation

fn static_type() -> Type

Returns the type identifier of Self.

impl Eq for Animation

impl IsA<Animation> for SpringAnimation

impl IsA<Animation> for TimedAnimation