scrollkit 0.8.3__py3-none-any.whl

scrollkit/simulator/displayio/palette.py

@@ -0,0 +1,115 @@
+# Copyright (c) 2024-2026 Michael Winslow Czeiszperger
+"""CircuitPython displayio.Palette equivalent."""
+
+from ..core.color_utils import rgb565_to_rgb888, rgb888_to_rgb565
+
+
+class Palette:
+    """Color palette for indexed color display.
+    
+    Stores a collection of colors that can be referenced by index.
+    Compatible with CircuitPython's displayio.Palette API.
+    """
+    
+    def __init__(self, color_count):
+        """Initialize palette with specified number of colors.
+        
+        Args:
+            color_count: Maximum number of colors in palette
+        """
+        self._color_count = color_count
+        self._colors = [None] * color_count
+        self._transparent = [False] * color_count
+        
+    def __len__(self):
+        """Get number of colors in palette."""
+        return self._color_count
+        
+    def __setitem__(self, index, color):
+        """Set a color in the palette.
+        
+        Args:
+            index: Color index (0 to color_count-1)
+            color: Color value as RGB565 integer or RGB888 tuple
+        """
+        if not 0 <= index < self._color_count:
+            raise IndexError(f"Palette index {index} out of range")
+            
+        if isinstance(color, (list, tuple)):
+            # Convert RGB888 tuple to RGB565
+            if len(color) >= 3:
+                self._colors[index] = rgb888_to_rgb565(color[0], color[1], color[2])
+            else:
+                raise ValueError("Color tuple must have at least 3 values")
+        else:
+            # displayio palettes take 24-bit RGB888 integers (0xRRGGBB). Do NOT
+            # guess RGB565-vs-RGB888 by magnitude: colors with a zero red byte
+            # (e.g. green 0x00FF00, blue 0x0000FF) are <= 0xFFFF and would be
+            # mis-read as RGB565, rendering green as yellow, blue as purple, etc.
+            r = (color >> 16) & 0xFF
+            g = (color >> 8) & 0xFF
+            b = color & 0xFF
+            self._colors[index] = rgb888_to_rgb565(r, g, b)
+            
+    def __getitem__(self, index):
+        """Get a color from the palette.
+        
+        Args:
+            index: Color index
+            
+        Returns:
+            Color value as RGB565 integer
+        """
+        if not 0 <= index < self._color_count:
+            raise IndexError(f"Palette index {index} out of range")
+            
+        color = self._colors[index]
+        return 0 if color is None else color
+        
+    def make_transparent(self, index):
+        """Make a palette entry transparent.
+        
+        Args:
+            index: Color index to make transparent
+        """
+        if not 0 <= index < self._color_count:
+            raise IndexError(f"Palette index {index} out of range")
+            
+        self._transparent[index] = True
+        
+    def make_opaque(self, index):
+        """Make a palette entry opaque.
+        
+        Args:
+            index: Color index to make opaque
+        """
+        if not 0 <= index < self._color_count:
+            raise IndexError(f"Palette index {index} out of range")
+            
+        self._transparent[index] = False
+        
+    def is_transparent(self, index):
+        """Check if a palette entry is transparent.
+        
+        Args:
+            index: Color index to check
+            
+        Returns:
+            True if transparent, False otherwise
+        """
+        if not 0 <= index < self._color_count:
+            return False
+            
+        return self._transparent[index]
+        
+    def get_rgb888(self, index):
+        """Get a color as RGB888 tuple.
+        
+        Args:
+            index: Color index
+            
+        Returns:
+            (r, g, b) tuple in 0-255 range
+        """
+        color565 = self[index]
+        return rgb565_to_rgb888(color565)

scrollkit/simulator/displayio/tilegrid.py

@@ -0,0 +1,155 @@
+# Copyright (c) 2024-2026 Michael Winslow Czeiszperger
+"""CircuitPython displayio.TileGrid equivalent."""
+
+
+class TileGrid:
+    """TileGrid arranges bitmap tiles on screen.
+    
+    A TileGrid is a grid of tiles that are sourced from a bitmap.
+    Each tile can be individually positioned and colored using a palette.
+    Compatible with CircuitPython's displayio.TileGrid API.
+    """
+    
+    def __init__(self, bitmap, *, pixel_shader, width=1, height=1, 
+                 tile_width=None, tile_height=None, default_tile=0, x=0, y=0):
+        """Initialize TileGrid.
+        
+        Args:
+            bitmap: Source bitmap containing tile graphics
+            pixel_shader: Palette to use for coloring
+            width: Number of tiles wide (default 1)
+            height: Number of tiles high (default 1)
+            tile_width: Width of each tile in pixels (default: bitmap width)
+            tile_height: Height of each tile in pixels (default: bitmap height)
+            default_tile: Default tile index (default 0)
+            x: X position of grid (default 0)
+            y: Y position of grid (default 0)
+        """
+        self.bitmap = bitmap
+        self.pixel_shader = pixel_shader
+        self.width = width
+        self.height = height
+        
+        # Set tile dimensions
+        if tile_width is None:
+            self.tile_width = bitmap.width
+        else:
+            self.tile_width = tile_width
+            
+        if tile_height is None:
+            self.tile_height = bitmap.height
+        else:
+            self.tile_height = tile_height
+            
+        # Calculate tiles per row in bitmap
+        self._tiles_per_row = bitmap.width // self.tile_width
+        
+        # Initialize tile indices
+        self._tiles = [[default_tile for _ in range(width)] for _ in range(height)]
+        
+        # Position and visibility
+        self.x = x
+        self.y = y
+        self.hidden = False
+        self._transpose_xy = False
+        self._flip_x = False
+        self._flip_y = False
+        
+    def __setitem__(self, index, tile_index):
+        """Set tile at given position.
+        
+        Args:
+            index: (x, y) tuple or flat index
+            tile_index: Index of tile in bitmap
+        """
+        if isinstance(index, tuple):
+            x, y = index
+            if not (0 <= x < self.width and 0 <= y < self.height):
+                raise IndexError(f"Tile index ({x}, {y}) out of bounds")
+        else:
+            # Convert flat index to x, y
+            y = index // self.width
+            x = index % self.width
+            if not (0 <= index < self.width * self.height):
+                raise IndexError(f"Tile index {index} out of bounds")
+                
+        self._tiles[y][x] = tile_index
+        
+    def __getitem__(self, index):
+        """Get tile at given position.
+        
+        Args:
+            index: (x, y) tuple or flat index
+            
+        Returns:
+            Tile index
+        """
+        if isinstance(index, tuple):
+            x, y = index
+            if not (0 <= x < self.width and 0 <= y < self.height):
+                raise IndexError(f"Tile index ({x}, {y}) out of bounds")
+        else:
+            # Convert flat index to x, y
+            y = index // self.width
+            x = index % self.width
+            if not (0 <= index < self.width * self.height):
+                raise IndexError(f"Tile index {index} out of bounds")
+                
+        return self._tiles[y][x]
+        
+    @property
+    def transpose_xy(self):
+        """Get transpose_xy setting."""
+        return self._transpose_xy
+        
+    @transpose_xy.setter
+    def transpose_xy(self, value):
+        """Set whether to swap x and y coordinates."""
+        self._transpose_xy = bool(value)
+        
+    @property
+    def flip_x(self):
+        """Get flip_x setting."""
+        return self._flip_x
+        
+    @flip_x.setter
+    def flip_x(self, value):
+        """Set whether to flip horizontally."""
+        self._flip_x = bool(value)
+        
+    @property
+    def flip_y(self):
+        """Get flip_y setting."""
+        return self._flip_y
+        
+    @flip_y.setter  
+    def flip_y(self, value):
+        """Set whether to flip vertically."""
+        self._flip_y = bool(value)
+        
+    def get_tile_bitmap(self, tile_index):
+        """Get bitmap data for a specific tile.
+        
+        Args:
+            tile_index: Index of tile to get
+            
+        Returns:
+            Bitmap-like object with tile data
+        """
+        # Calculate tile position in source bitmap
+        tile_x = (tile_index % self._tiles_per_row) * self.tile_width
+        tile_y = (tile_index // self._tiles_per_row) * self.tile_height
+        
+        # Create a view of the tile data
+        # (In actual implementation, this would return a view of the bitmap data)
+        return (tile_x, tile_y, self.tile_width, self.tile_height)
+        
+    @property
+    def pixel_width(self):
+        """Get total width in pixels."""
+        return self.width * self.tile_width
+        
+    @property
+    def pixel_height(self):
+        """Get total height in pixels."""
+        return self.height * self.tile_height