Package ch.bailu.gtk.adw

Klasse Animation

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.type.PropertyHolder
ch.bailu.gtk.adw.Animation
Alle implementierten Schnittstellen:
PointerInterface
Bekannte direkte Unterklassen:
SpringAnimation, TimedAnimation
public class Animation extends PropertyHolder
A base class for animations.

`AdwAnimation` 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:
[class@TimedAnimation] and [class@SpringAnimation].

`AdwAnimation` will automatically skip the animation if
[property@Animation:widget] is unmapped, or if
[property@Gtk.Settings:gtk-enable-animations] is `FALSE`.

The [signal@Animation::done] signal can be used to perform an action after
the animation ends, for example hiding a widget after animating its
[property@Gtk.Widget:opacity] to 0.

`AdwAnimation` 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:

```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
`AdwAnimation` object can be reused.

https://gnome.pages.gitlab.gnome.org/libadwaita/doc/main/class.Animation.html

  • Felddetails

  • Konstruktordetails

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • getFollowEnableAnimationsSetting

      public boolean getFollowEnableAnimationsSetting()
      Gets whether @self should be skipped when animations are globally disabled.
      Gibt zurück:
      whether to follow the global setting

    • getState

      public int getState()
      Gets the current value of @self.

      The state indicates whether @self is currently playing, paused, finished or
      hasn't been started yet.
      Gibt zurück:
      the animation value

    • getTarget

      public AnimationTarget getTarget()
      Gets the target @self animates.
      Gibt zurück:
      the animation target

    • getValue

      public double getValue()
      Gets the current value of @self.
      Gibt zurück:
      the current value

    • getWidget

      public Widget getWidget()
      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.
      Gibt zurück:
      the animation widget

    • pause

      public void pause()
      Pauses a playing animation for @self.

      Does nothing if the current state of @self isn't `ADW_ANIMATION_PLAYING`.

      Sets [property@Animation:state] to `ADW_ANIMATION_PAUSED`.

    • play

      public void play()
      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 [property@Animation:state] to `ADW_ANIMATION_PLAYING`.

      The animation will be automatically skipped if [property@Animation:widget] is
      unmapped, or if [property@Gtk.Settings:gtk-enable-animations] is `FALSE`.

      As such, it's not guaranteed that the animation will actually run. For
      example, when using [func@GLib.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.

    • reset

      public void reset()
      Resets the animation for @self.

      Sets [property@Animation:state] to `ADW_ANIMATION_IDLE`.

    • resume

      public void resume()
      Resumes a paused animation for @self.

      This function must only be used if the animation has been paused with
      [method@Animation.pause].

      Sets [property@Animation:state] to `ADW_ANIMATION_PLAYING`.

    • setFollowEnableAnimationsSetting

      public void setFollowEnableAnimationsSetting(boolean setting)
      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 [property@Gtk.Settings:gtk-enable-animations].
      Parameter:
      setting - whether to follow the global setting

    • setTarget

      public void setTarget(@Nonnull AnimationTarget target)
      Sets the target @self animates to @target.
      Parameter:
      target - an animation target

    • skip

      public void skip()
      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 [signal@Animation::done] to be
      emitted.

      Sets [property@Animation:state] to `ADW_ANIMATION_FINISHED`.

    • onDone

      public SignalHandler onDone(Animation.OnDone signal)
      Connect to signal "done".
      See Animation.OnDone.onDone() for signal description.
      Field SIGNAL_ON_DONE contains original signal name and can be used as resource reference.
      Parameter:
      signal - callback function (lambda).
      Gibt zurück:
      SignalHandler. Can be used to disconnect signal and to release callback function.

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()