SMS Scroller Code update

adding Messageboard folder to lib

Author: firepixie

Matrix_Portal_S3_SMS_Scroller/Matrix Portal SMS Fonts.zip

@@ -0,0 +1,164 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import bitmaptools
+import displayio
+import adafruit_imageload
+from .doublebuffer import DoubleBuffer
+from .message import Message
+
+
+class MessageBoard:
+    def __init__(self, matrix):
+        self.fonts = {}
+        self.display = matrix.display
+        self._buffer_width = self.display.width * 2
+        self._buffer_height = self.display.height * 2
+        self._dbl_buf = DoubleBuffer(
+            self.display, self._buffer_width, self._buffer_height
+        )
+        self._background = None
+        self.set_background()  # Set to black
+        self._position = (0, 0)
+
+    def set_background(self, file_or_color=0x000000):
+        """The background image to a bitmap file."""
+        if isinstance(file_or_color, str):  # its a filenme:
+            background, bg_shader = adafruit_imageload.load(file_or_color)
+            self._dbl_buf.shader = bg_shader
+            self._background = background
+        elif isinstance(file_or_color, int):
+            # Make a background color fill
+            bg_shader = displayio.ColorConverter(
+                input_colorspace=displayio.Colorspace.RGB565
+            )
+            background = displayio.Bitmap(
+                self.display.width, self.display.height, 65535
+            )
+            background.fill(displayio.ColorConverter().convert(file_or_color))
+            self._dbl_buf.shader = bg_shader
+            self._background = background
+        else:
+            raise RuntimeError("Unknown type of background")
+
+    def animate(self, message, animation_class, animation_function, **kwargs):
+        anim_class = __import__(
+            f"{self.__module__}.animations.{animation_class.lower()}"
+        )
+        anim_class = getattr(anim_class, "animations")
+        anim_class = getattr(anim_class, animation_class.lower())
+        anim_class = getattr(anim_class, animation_class)
+        animation = anim_class(
+            self.display, self._draw, self._position
+        )  # Instantiate the class
+        # Call the animation function and pass kwargs along with the message (positional)
+        anim_func = getattr(animation, animation_function)
+        anim_func(message, **kwargs)
+
+    def set_message_position(self, x, y):
+        """Set the position of the message on the display"""
+        self._position = (x, y)
+
+    def _draw(
+        self,
+        image,
+        x,
+        y,
+        opacity=None,
+        mask_color=0xFF00FF,
+        blendmode=bitmaptools.BlendMode.Normal,
+        post_draw_position=None,
+    ):
+        """Draws a message to the buffer taking its current settings into account.
+        It also sets the current position and performs a swap.
+        """
+        self._position = (x, y)
+        buffer_x_offset = self._buffer_width - self.display.width
+        buffer_y_offset = self._buffer_height - self.display.height
+
+        # Image can be a message in which case its properties will be used
+        if isinstance(image, Message):
+            if opacity is None:
+                opacity = image.opacity
+            mask_color = image.mask_color
+            blendmode = image.blendmode
+            image = image.buffer
+        if opacity is None:
+            opacity = 1.0
+
+        if mask_color > 65535:
+            mask_color = displayio.ColorConverter().convert(mask_color)
+
+        # Blit the background
+        bitmaptools.blit(
+            self._dbl_buf.active_buffer,
+            self._background,
+            buffer_x_offset,
+            buffer_y_offset,
+        )
+
+        # If the image is wider than the display buffer, we need to shrink it
+        while x + buffer_x_offset < 0:
+            new_image = displayio.Bitmap(
+                image.width - self.display.width, image.height, 65535
+            )
+            bitmaptools.blit(
+                new_image,
+                image,
+                0,
+                0,
+                x1=self.display.width,
+                y1=0,
+                x2=image.width,
+                y2=image.height,
+            )
+            x += self.display.width
+            self._position = (x, y) # Update the stored position
+            image = new_image
+
+        # If the image is taller than the display buffer, we need to shrink it
+        while y + buffer_y_offset < 0:
+            new_image = displayio.Bitmap(
+                image.width, image.height - self.display.height, 65535
+            )
+            bitmaptools.blit(
+                new_image,
+                image,
+                0,
+                0,
+                x1=0,
+                y1=self.display.height,
+                x2=image.width,
+                y2=image.height,
+            )
+            y += self.display.height
+            self._position = (x, y) # Update the stored position
+            image = new_image
+
+        # Clear the foreground buffer
+        foreground_buffer = displayio.Bitmap(
+            self._buffer_width, self._buffer_height, 65535
+        )
+        foreground_buffer.fill(mask_color)
+
+        bitmaptools.blit(
+            foreground_buffer, image, x + buffer_x_offset, y + buffer_y_offset
+        )
+
+        # Blend the foreground buffer into the main buffer
+        bitmaptools.alphablend(
+            self._dbl_buf.active_buffer,
+            self._dbl_buf.active_buffer,
+            foreground_buffer,
+            displayio.Colorspace.RGB565,
+            1.0,
+            opacity,
+            blendmode=blendmode,
+            skip_source2_index=mask_color,
+        )
+        self._dbl_buf.show()
+
+        # Allow for an override of the position after drawing (needed for split effects)
+        if post_draw_position is not None and isinstance(post_draw_position, tuple):
+            self._position = post_draw_position

Matrix_Portal_S3_SMS_Scroller/lib/messageboard/__init__.py

@@ -0,0 +1,24 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import time
+
+
+class Animation:
+    def __init__(self, display, draw_callback, starting_position=(0, 0)):
+        self._display = display
+        self._position = starting_position
+        self._draw = draw_callback
+
+    @staticmethod
+    def _wait(start_time, duration):
+        """Uses time.monotonic() to wait from the start time for a specified duration"""
+        while time.monotonic() < (start_time + duration):
+            pass
+        return time.monotonic()
+
+    def _get_centered_position(self, message):
+        return int(self._display.width / 2 - message.buffer.width / 2), int(
+            self._display.height / 2 - message.buffer.height / 2
+        )

Matrix_Portal_S3_SMS_Scroller/lib/messageboard/animations/__init__.py

@@ -0,0 +1,146 @@
+# SPDX-FileCopyrightText: 2023 Melissa LeBlanc-Williams for Adafruit Industries
+#
+# SPDX-License-Identifier: MIT
+
+import time
+import displayio
+import bitmaptools
+from . import Animation
+
+
+class Loop(Animation):
+    def _create_loop_image(self, image, x_offset, y_offset, mask_color):
+        """Attach a copy of an image by a certain offset so it can be looped."""
+        if 0 < x_offset < self._display.width:
+            x_offset = self._display.width
+        if 0 < y_offset < self._display.height:
+            y_offset = self._display.height
+
+        loop_image = displayio.Bitmap(
+            image.width + x_offset, image.height + y_offset, 65535
+        )
+        loop_image.fill(mask_color)
+        bitmaptools.blit(loop_image, image, 0, 0)
+        bitmaptools.blit(loop_image, image, x_offset, y_offset)
+
+        return loop_image
+
+    def left(self, message, duration=1, count=1):
+        """Loop a message towards the left side of the display over a certain period of time by a
+        certain number of times. The message will re-enter from the right and end up back a the
+        starting position.
+
+        :param message: The message to animate.
+        :param float count: (optional) The number of times to loop. (default=1)
+        :param float duration: (optional) The period of time to perform the animation
+                               over. (default=1)
+        :type message: Message
+        """
+        current_x, current_y = self._position
+        distance = max(message.buffer.width, self._display.width)
+        loop_image = self._create_loop_image(
+            message.buffer, distance, 0, message.mask_color
+        )
+        for _ in range(count):
+            for _ in range(distance):
+                start_time = time.monotonic()
+                current_x -= 1
+                if current_x < 0 - message.buffer.width:
+                    current_x += distance
+                self._draw(
+                    loop_image,
+                    current_x,
+                    current_y,
+                    message.opacity,
+                )
+                self._wait(start_time, duration / distance / count)
+
+    def right(self, message, duration=1, count=1):
+        """Loop a message towards the right side of the display over a certain period of time by a
+        certain number of times. The message will re-enter from the left and end up back a the
+        starting position.
+
+        :param message: The message to animate.
+        :param float count: (optional) The number of times to loop. (default=1)
+        :param float duration: (optional) The period of time to perform the animation
+                               over. (default=1)
+        :type message: Message
+        """
+        current_x, current_y = self._position
+        distance = max(message.buffer.width, self._display.width)
+        loop_image = self._create_loop_image(
+            message.buffer, distance, 0, message.mask_color
+        )
+        for _ in range(count):
+            for _ in range(distance):
+                start_time = time.monotonic()
+                current_x += 1
+                if current_x > 0:
+                    current_x -= distance
+                self._draw(
+                    loop_image,
+                    current_x,
+                    current_y,
+                    message.opacity,
+                )
+                self._wait(start_time, duration / distance / count)
+
+    def up(self, message, duration=0.5, count=1):
+        """Loop a message towards the top side of the display over a certain period of time by a
+        certain number of times. The message will re-enter from the bottom and end up back a the
+        starting position.
+
+        :param message: The message to animate.
+        :param float count: (optional) The number of times to loop. (default=1)
+        :param float duration: (optional) The period of time to perform the animation
+                               over. (default=1)
+        :type message: Message
+        """
+        current_x, current_y = self._position
+        distance = max(message.buffer.height, self._display.height)
+        loop_image = self._create_loop_image(
+            message.buffer, 0, distance, message.mask_color
+        )
+        for _ in range(count):
+            for _ in range(distance):
+                start_time = time.monotonic()
+                current_y -= 1
+                if current_y < 0 - message.buffer.height:
+                    current_y += distance
+                self._draw(
+                    loop_image,
+                    current_x,
+                    current_y,
+                    message.opacity,
+                )
+                self._wait(start_time, duration / distance / count)
+
+    def down(self, message, duration=0.5, count=1):
+        """Loop a message towards the bottom side of the display over a certain period of time by a
+        certain number of times. The message will re-enter from the top and end up back a the
+        starting position.
+
+        :param message: The message to animate.
+        :param float count: (optional) The number of times to loop. (default=1)
+        :param float duration: (optional) The period of time to perform the animation
+                               over. (default=1)
+        :type message: Message
+        """
+        current_x, current_y = self._position
+        distance = max(message.buffer.height, self._display.height)
+        loop_image = self._create_loop_image(
+            message.buffer, 0, distance, message.mask_color
+        )
+        for _ in range(count):
+            for _ in range(distance):
+                start_time = time.monotonic()
+                current_y += 1
+                if current_y > 0:
+                    current_y -= distance
+                self._draw(
+                    loop_image,
+                    current_x,
+                    current_y,
+                    message.opacity,
+                )
+                self._wait(start_time, duration / distance / count)