a bunch of protocol changes to allow a second stage of drawing, and to move the cycle done callback out to animate()

Author: rhooper

adafruit_led_animation/animation/__init__.py

@@ -54,14 +54,13 @@ class Animation:
     """
     Base class for animations.
     """
-    cycle_complete_supported = False
+    on_cycle_complete_supported = False
 
     # pylint: disable=too-many-arguments
     def __init__(self, pixel_object, speed, color, peers=None, paused=False, name=None):
         self.pixel_object = pixel_object
         self.pixel_object.auto_write = False
-        self.peers = peers if peers else []
-        """A sequence of animations to trigger .draw() on when this animation draws."""
+        self._peers = [self] + peers if peers is not None else [self]
         self._speed_ns = 0
         self._color = None
         self._paused = paused
@@ -71,6 +70,7 @@ def __init__(self, pixel_object, speed, color, peers=None, paused=False, name=No
         self.speed = speed  # sets _speed_ns
         self.color = color  # Triggers _recompute_color
         self.name = name
+        self.cycle_complete = False
         self.notify_cycles = 1
         """Number of cycles to trigger additional cycle_done notifications after"""
         self.draw_count = 0
@@ -95,30 +95,59 @@ def animate(self):
         if now < self._next_update:
             return False
 
-        self.draw()
-        self.draw_count += 1
-
         # Draw related animations together
-        if self.peers:
-            for peer in self.peers:
-                peer.draw()
+        for anim in self._peers:
+            anim.draw()
+            anim.after_draw()
+
+        for anim in self._peers:
+            anim.show()
+
+        # Note that the main animation cycle_complete flag is used, not the peer flag.
+        for anim in self._peers:
+            if self.cycle_complete:
+                anim.on_cycle_complete()
+                anim.cycle_complete = False
 
         self._next_update = now + self._speed_ns
         return True
 
     def draw(self):
         """
         Animation subclasses must implement draw() to render the animation sequence.
-        Draw must call show().
+        Animations should not call show(), as animate() will do so, after after_draw().
+        Animations should set .cycle_done = True when an animation cycle is completed.
         """
         raise NotImplementedError()
 
+    def after_draw(self):
+        """
+        Animation subclasses may implement after_draw() to do operations after the main draw()
+        is called.
+        """
+
     def show(self):
         """
         Displays the updated pixels.  Called during animates with changes.
         """
         self.pixel_object.show()
 
+    @property
+    def peers(self):
+        """
+        Get the animation's peers.  Peers are drawn, then shown together.
+        """
+        return self._peers[1:]
+
+    @peers.setter
+    def peers(self, peer_list):
+        """
+        Set the animation's peers.
+        :param list peer_list: List of peer animations.
+        """
+        if peer_list is not None:
+            self._peers = [self] + peer_list
+
     def freeze(self):
         """
         Stops the animation until resumed.
@@ -173,7 +202,7 @@ def _recompute_color(self, color):
         Override as needed.
         """
 
-    def cycle_complete(self):
+    def on_cycle_complete(self):
         """
         Called by some animations when they complete an animation cycle.
         Animations that support cycle complete notifications will have X property set to False.

adafruit_led_animation/animation/chase.py

@@ -83,7 +83,7 @@ def _resetter():
 
         super().__init__(pixel_object, speed, color, name=name)
 
-    cycle_complete_supported = True
+    on_cycle_complete_supported = True
 
     @property
     def reverse(self):
@@ -115,10 +115,9 @@ def bar_colors():
 
         colorgen = bar_colors()
         self.pixel_object[:] = [next(colorgen) for _ in self.pixel_object]
-        self.show()
 
         if self.draw_count % len(self.pixel_object) == 0:
-            self.cycle_complete()
+            self.cycle_complete = True
         self._offset = (self._offset + self._direction) % self._repeat_width
 
     def bar_color(self, n, pixel_no=0):  # pylint: disable=unused-argument

adafruit_led_animation/animation/colorcycle.py

@@ -64,11 +64,10 @@ def __init__(self, pixel_object, speed, colors=RAINBOW, name=None):
         self._generator = self._color_generator()
         next(self._generator)
 
-    cycle_complete_supported = True
+    on_cycle_complete_supported = True
 
     def draw(self):
         self.pixel_object.fill(self.color)
-        self.show()
         next(self._generator)
 
     def _color_generator(self):
@@ -78,7 +77,7 @@ def _color_generator(self):
             yield
             index = (index + 1) % len(self.colors)
             if index == 0:
-                self.cycle_complete()
+                self.cycle_complete = True
 
     def reset(self):
         """

adafruit_led_animation/animation/comet.py

@@ -89,7 +89,7 @@ def __init__(
         self._generator = self._comet_generator()
         super().__init__(pixel_object, speed, color, name=name)
 
-    cycle_complete_supported = True
+    on_cycle_complete_supported = True
 
     def _recompute_color(self, color):
         pass
@@ -130,13 +130,12 @@ def _comet_generator(self):
                     ]
                 else:
                     self.pixel_object[start : start + end] = colors[0:end]
-                self.show()
                 yield
             cycle_passes += 1
             if self.bounce:
                 self.reverse = not self.reverse
             if not self.bounce or cycle_passes == 2:
-                self.cycle_complete()
+                self.cycle_complete = True
                 cycle_passes = 0
 
     def draw(self):

adafruit_led_animation/animation/pulse.py

@@ -64,12 +64,11 @@ def __init__(self, pixel_object, speed, color, period=5, name=None):
         self._generator = None
         self.reset()
 
-    cycle_complete_supported = True
+    on_cycle_complete_supported = True
 
     def draw(self):
         color = next(self._generator)
         self.fill(color)
-        self.show()
 
     def reset(self):
         """

adafruit_led_animation/animation/rainbow.py

@@ -85,7 +85,7 @@ def generate_rainbow(self):
             self.colors.append(colorwheel(int(i)))
             i += self._step
 
-    cycle_complete_supported = True
+    on_cycle_complete_supported = True
 
     def _color_wheel_generator(self):
         period = int(self._period * NANOS_PER_SECOND)
@@ -113,9 +113,8 @@ def _color_wheel_generator(self):
                     colorwheel((i + wheel_index) % 255) for i in range(num_pixels)
                 ]
             self._wheel_index = wheel_index
-            self.show()
             if cycle_completed:
-                self.cycle_complete()
+                self.cycle_complete = True
             yield
 
     def _draw_precomputed(self, num_pixels, wheel_index):

adafruit_led_animation/animation/rainbowchase.py

@@ -80,6 +80,6 @@ def __init__(
     def bar_color(self, n, pixel_no=0):
         return self._colors[self._color_idx - n]
 
-    def cycle_complete(self):
+    def on_cycle_complete(self):
         self._color_idx = (self._color_idx + self._direction) % len(self._colors)
-        super().cycle_complete()
+        super().on_cycle_complete()

adafruit_led_animation/animation/rainbowsparkle.py

@@ -106,7 +106,8 @@ def generate_rainbow(self):
                     int(self._background_brightness * color[2]),
                 )
 
-    def show(self):
+    def after_draw(self):
+        self.show()
         pixels = [
             random.randint(0, len(self.pixel_object) - 1)
             for n in range(self._num_sparkles)
@@ -115,4 +116,3 @@ def show(self):
             self.pixel_object[pixel] = self._bright_colors[
                 (self._wheel_index + pixel) % len(self._bright_colors)
             ]
-        super().show()

adafruit_led_animation/animation/sparkle.py

@@ -91,4 +91,3 @@ def draw(self):
         for pixel in pixels:
             self.pixel_object[pixel] = self._half_color
             self.pixel_object[pixel + 1] = self._dim_color
-        self.show()

adafruit_led_animation/animation/sparklepulse.py

@@ -74,7 +74,7 @@ def __init__(
         self._half_period = period / 2
         self._position_factor = 1 / self._half_period
         self._bpp = len(pixel_object[0])
-        if isinstance(pixel_object[-1], float):
+        if self._bpp == 4 and isinstance(pixel_object[0][3], float):
             self._bpp = 3
         self._last_update = monotonic_ns()
         self._cycle_position = 0

adafruit_led_animation/group.py

@@ -79,15 +79,15 @@ def __init__(self, *members, sync=False, name=None):
 
         # Catch cycle_complete on the last animation.
         self._members[-1].add_cycle_complete_receiver(self._group_done)
-        self.cycle_complete_supported = self._members[-1].cycle_complete_supported
+        self.on_cycle_complete_supported = self._members[-1].on_cycle_complete_supported
 
     def __str__(self):
         return "<AnimationGroup %s: %s>" % (self.__class__.__name__, self.name)
 
     def _group_done(self, animation):  # pylint: disable=unused-argument
-        self.cycle_complete()
+        self.on_cycle_complete()
 
-    def cycle_complete(self):
+    def on_cycle_complete(self):
         """
         Called by some animations when they complete an animation cycle.
         Animations that support cycle complete notifications will have X property set to False.

adafruit_led_animation/helper.py

@@ -381,7 +381,7 @@ def pulse_generator(period: float, animation_object, white=False):
         last_update = now
         pos = cycle_position = (cycle_position + time_since_last_draw) % period
         if pos < last_pos:
-            animation_object.cycle_complete()
+            animation_object.on_cycle_complete()
         last_pos = pos
         if pos > half_period:
             pos = period - pos

adafruit_led_animation/sequence.py

@@ -65,9 +65,9 @@ class AnimationSequence:
                             Defaults to ``False``.
     :param bool random_order: Activate the animations in a random order. Defaults to ``False``.
     :param bool auto_reset: Automatically call reset() on animations when changing animations.
-    :param bool advance_on_cycle_complete: Automatically advance when `cycle_complete` is triggered
-                                           on member animations. All Animations must support
-                                           cycle_complete to use this.
+    :param bool advance_on_cycle_complete: Automatically advance when `on_cycle_complete` is
+                                           triggered on member animations. All Animations must
+                                           support on_cycle_complete to use this.
 
     .. code-block:: python
 
@@ -126,14 +126,14 @@ def __init__(
         self._color = None
         for member in self._members:
             member.add_cycle_complete_receiver(self._sequence_complete)
-        self.cycle_complete_supported = self._members[-1].cycle_complete_supported
+        self.on_cycle_complete_supported = self._members[-1].on_cycle_complete_supported
 
-    cycle_complete_supported = True
+    on_cycle_complete_supported = True
 
     def __str__(self):
         return "<%s: %s>" % (self.__class__.__name__, self.name)
 
-    def cycle_complete(self):
+    def on_cycle_complete(self):
         """
         Called by some animations when they complete an animation cycle.
         Animations that support cycle complete notifications will have X property set to False.
@@ -145,7 +145,7 @@ def cycle_complete(self):
                 callback(self)
 
     def _sequence_complete(self, animation):  # pylint: disable=unused-argument
-        self.cycle_complete()
+        self.on_cycle_complete()
         if self.advance_on_cycle_complete:
             self._advance()
 
@@ -194,7 +194,7 @@ def next(self):
         """
         current = self._current
         if current > self._current:
-            self.cycle_complete()
+            self.on_cycle_complete()
         self.activate((self._current + 1) % len(self._members))
 
     def random(self):