sugar3.graphics.animator module

The animator module provides a simple framework to create animations.

Example

Animate the size of a window:

from gi.repository import Gtk
from sugar3.graphics.animator import Animator, Animation

# Construct a window to animate
w = Gtk.Window()
w.connect('destroy', Gtk.main_quit)
# Start the animation when the window is shown
w.connect('realize', lambda self: animator.start())
w.show()

# Construct a 5 second animator
animator = Animator(5, widget=w)

# Create an animation subclass to animate the widget
class SizeAnimation(Animation):
    def __init__(self):
        # Tell the animation to give us values between 20 and
        # 420 during the animation
        Animation.__init__(self, 20, 420)

    def next_frame(self, frame):
        size = int(frame)
        w.resize(size, size)
# Add the animation the the animator
animation = SizeAnimation()
animator.add(animation)

# The animation needs to run inside a GObject main loop
Gtk.main()

STABLE.

class sugar3.graphics.animator.Animation(start, end)

Bases: object

The animation class is a base class for creating an animation. It should be subclassed. Subclasses should specify a next_frame function to set the required properties based on the animation progress. The range of the frame value passed to the next_frame function is defined by the start and end values.

Parameters:
  • start (float) – the first frame value for the next_frame method
  • end (float) – the last frame value for the next_frame method
# Create an animation subclass
class MyAnimation(Animation):
    def __init__(self, thing):
        # Tell the animation to give us values between 0.0 and
        # 1.0 during the animation
        Animation.__init__(self, 0.0, 1.0)
        self._thing = thing

    def next_frame(self, frame):
        # Use the `frame` value to set properties
        self._thing.set_green_value(frame)
do_frame(t, duration, easing)

This method is called by the animator class every frame. This method calculated the frame value to then call next_frame.

Parameters:
  • t (float) – the current time elapsed of the animation in seconds
  • duration (float) – the length of the animation in seconds
  • easing (int) – the easing mode passed to the animator
do_stop()

This method is called whenever the animation is stopped, either due to the animation ending or being stopped by the animation. next_frame will not be called after do_stop, unless the animation is restarted.

New in version 0.109.0.3.

This should be used in subclasses if they bind any signals. Eg. if they bind the draw signal for a widget:

class SignalAnimation(Animation):

    def __init__(self, widget):
        Animation.__init__(self, 0, 1)
        self._draw_hid = None
        self._widget = widget

    def next_frame(self, frame):
        self._frame = frame
        if self._draw_hid is None:
            self._draw_hid = self._widget.connect_after(
                'draw', self.__draw_cb)
        self._widget.queue_draw()

    def __draw_cb(self, widget, cr):
        cr.save()
        # Do the draw
        cr.restore()

    def do_stop(self):
        self._widget.disconnect(self._draw_hid)
        self._widget.queue_draw()
next_frame(frame)

This method is called every frame and should be overridden by subclasses.

Parameters:frame (float) – a value between start and end representing the current progress in the animation
class sugar3.graphics.animator.Animator(duration, fps=20, easing=0, widget=None)

Bases: gi.overrides.GObject.Object

The animator class manages the timing for calling the animations. The animations can be added using the add function and then started with the start function. If multiple animations are added, then they will be played back at the same time and rate as each other.

The completed signal is emitted upon the completion of the animation and also when the stop function is called.

Parameters:
  • duration (float) – the duration of the animation in seconds
  • fps (int, optional) – the number of animation callbacks to make per second (frames per second)
  • easing (int) – the desired easing mode, either EASE_OUT_EXPO or EASE_IN_EXPO
  • widget (Gtk.Widget) – one of the widgets that the animation is acting on. If supplied and if the user’s Gtk+ version supports it, the animation will run on the frame clock of the widget, resulting in a smoother animation and the fps value will be disregarded.

Note

When creating an animation, take into account the limited cpu power on some devices, such as the XO. Setting the fps too high on can use significant cpu usage on the XO.

add(animation)

Add an animation to this animator

Parameters:animation (sugar3.graphics.animator.Animation) – the animation instance to add
remove_all()

Remove all animations and stop this animator

start()

Start the animation running. This will stop and restart the animation if the animation is currently running

stop()

Stop the animation and emit the completed signal