scrollkit 0.8.3__py3-none-any.whl

scrollkit/simulator/adafruit_bitmap_font/bitmap_font.py

@@ -0,0 +1,273 @@
+"""BDF font loading and rendering for bitmap displays."""
+
+import os
+from ..displayio import Bitmap, Palette
+from .glyph_cache import GlyphCache
+
+
+class BitmapFont:
+    """Bitmap font for rendering text on displays.
+    
+    Loads and renders BDF (Bitmap Distribution Format) fonts.
+    Compatible with CircuitPython's adafruit_bitmap_font API.
+    """
+    
+    def __init__(self):
+        """Initialize empty bitmap font."""
+        self.name = None
+        self.size = 0
+        self.height = 0
+        self.ascent = 0
+        self.descent = 0
+        # Global font metrics from BDF
+        self.font_bounding_box = None  # (width, height, x_offset, y_offset)
+        self.font_ascent = None   # From FONT_ASCENT property
+        self.font_descent = None  # From FONT_DESCENT property
+        self.baseline_to_top = 0  # Distance from baseline to top of font bounding box
+        self.glyphs = {}
+        self.default_char = ord('?')
+        self._glyph_cache = GlyphCache()
+        
+    def load_font(self, filename):
+        """Load a BDF font file.
+        
+        Args:
+            filename: Path to BDF font file
+        """
+        self.glyphs.clear()
+        self._glyph_cache.clear()
+        
+        with open(filename, 'r', encoding='latin-1') as f:
+            self._parse_bdf(f)
+            
+    def _parse_bdf(self, file):
+        """Parse BDF font file.
+        
+        Args:
+            file: Open file object
+        """
+        current_char = None
+        current_bitmap = []
+        current_dwidth = None
+        in_bitmap = False
+        in_properties = False
+        
+        for line in file:
+            line = line.strip()
+            
+            if line.startswith('FONT '):
+                self.name = line[5:].strip()
+            elif line.startswith('SIZE'):
+                parts = line.split()
+                if len(parts) >= 2:
+                    self.size = int(parts[1])
+            elif line.startswith('FONTBOUNDINGBOX'):
+                parts = line.split()
+                if len(parts) >= 5:
+                    bbox_width = int(parts[1])
+                    bbox_height = int(parts[2])
+                    bbox_x_offset = int(parts[3])
+                    bbox_y_offset = int(parts[4])
+                    self.font_bounding_box = (bbox_width, bbox_height, bbox_x_offset, bbox_y_offset)
+                    # Set initial values (may be overridden by FONT_ASCENT/FONT_DESCENT)
+                    self.height = bbox_height
+                    self.ascent = bbox_height + bbox_y_offset  # Distance from baseline to top
+                    self.descent = -bbox_y_offset  # Distance from baseline to bottom
+                    self.baseline_to_top = self.ascent
+            elif line.startswith('STARTPROPERTIES'):
+                in_properties = True
+            elif line.startswith('ENDPROPERTIES'):
+                in_properties = False
+            elif in_properties and line.startswith('FONT_ASCENT'):
+                parts = line.split()
+                if len(parts) >= 2:
+                    self.font_ascent = int(parts[1])
+                    self.ascent = self.font_ascent
+                    self.baseline_to_top = self.font_ascent
+            elif in_properties and line.startswith('FONT_DESCENT'):
+                parts = line.split()
+                if len(parts) >= 2:
+                    self.font_descent = int(parts[1])
+                    self.descent = self.font_descent
+                    # Update total height if we have both ascent and descent
+                    if self.font_ascent is not None:
+                        self.height = self.font_ascent + self.font_descent
+            elif line.startswith('STARTCHAR'):
+                current_char = None
+                current_bitmap = []
+                current_dwidth = None
+            elif line.startswith('ENCODING'):
+                current_char = int(line.split()[1])
+            elif line.startswith('DWIDTH'):
+                # Parse device width (advance width for kerning)
+                parts = line.split()
+                if len(parts) >= 2:
+                    current_dwidth = int(parts[1])
+            elif line.startswith('BBX'):
+                if current_char is not None:
+                    parts = line.split()
+                    if len(parts) >= 5:
+                        char_width = int(parts[1])
+                        char_height = int(parts[2])
+                        x_offset = int(parts[3])
+                        y_offset = int(parts[4])
+                        
+                        if current_char not in self.glyphs:
+                            self.glyphs[current_char] = {
+                                'width': char_width,
+                                'height': char_height,
+                                'x_offset': x_offset,
+                                'y_offset': y_offset,
+                                'dwidth': current_dwidth if current_dwidth is not None else char_width,  # Use DWIDTH or fallback to bitmap width
+                                'bitmap': []
+                            }
+            elif line.startswith('BITMAP'):
+                in_bitmap = True
+                current_bitmap = []
+            elif line.startswith('ENDCHAR'):
+                if current_char is not None and current_char in self.glyphs:
+                    self.glyphs[current_char]['bitmap'] = current_bitmap
+                in_bitmap = False
+                current_char = None
+            elif in_bitmap and current_char is not None:
+                # Parse hex bitmap data
+                current_bitmap.append(line)
+                
+    def get_glyph(self, char):
+        """Get glyph information for a character.
+        
+        Args:
+            char: Character or character code
+            
+        Returns:
+            Dictionary with glyph information or None
+        """
+        if isinstance(char, str):
+            char_code = ord(char)
+        else:
+            char_code = char
+            
+        # Check cache first
+        cached = self._glyph_cache.get(char_code)
+        if cached:
+            return cached
+            
+        # Get glyph data
+        if char_code not in self.glyphs:
+            # Use default character
+            char_code = self.default_char
+            if char_code not in self.glyphs:
+                return None
+                
+        glyph_data = self.glyphs[char_code]
+        
+        # Create bitmap for glyph
+        width = glyph_data['width']
+        height = glyph_data['height']
+        
+        if width == 0 or height == 0:
+            # Handle zero-size glyphs (like spaces) - they still need DWIDTH for advancement
+            result = {
+                'bitmap': None,  # No bitmap to render
+                'width': width,
+                'height': height,
+                'dx': glyph_data['dwidth'],  # Still use DWIDTH for spacing
+                'dy': 0,
+                'x_offset': glyph_data['x_offset'],
+                'y_offset': glyph_data['y_offset']
+            }
+            # Cache the result
+            self._glyph_cache.put(char_code, None, result)
+            return result
+            
+        # Create bitmap with 2 colors (0=background, 1=foreground)
+        bitmap = Bitmap(width, height, 2)
+        
+        # Parse hex bitmap data
+        for y, hex_line in enumerate(glyph_data['bitmap']):
+            if y >= height:
+                break
+                
+            # Convert hex to binary
+            byte_width = (width + 7) // 8
+            hex_line = hex_line.ljust(byte_width * 2, '0')
+            
+            for byte_idx in range(0, len(hex_line), 2):
+                if byte_idx // 2 >= byte_width:
+                    break
+                    
+                byte_val = int(hex_line[byte_idx:byte_idx + 2], 16)
+                
+                for bit in range(8):
+                    x = (byte_idx // 2) * 8 + bit
+                    if x >= width:
+                        break
+                        
+                    if byte_val & (0x80 >> bit):
+                        bitmap[x, y] = 1
+                    else:
+                        bitmap[x, y] = 0
+                        
+        # Create result dictionary
+        result = {
+            'bitmap': bitmap,
+            'width': width,
+            'height': height,
+            'dx': glyph_data['dwidth'],  # Use DWIDTH for proper kerning/spacing
+            'dy': 0,
+            'x_offset': glyph_data['x_offset'],
+            'y_offset': glyph_data['y_offset']
+        }
+        
+        # Cache the result
+        self._glyph_cache.put(char_code, bitmap, result)
+        
+        return result
+        
+    def get_bounding_box(self):
+        """Get font bounding box.
+        
+        Returns:
+            Tuple of (width, height, x_offset, y_offset)
+        """
+        # Calculate from all glyphs
+        min_x = 0
+        max_x = 0
+        min_y = 0
+        max_y = 0
+        
+        for glyph_data in self.glyphs.values():
+            x_offset = glyph_data['x_offset']
+            y_offset = glyph_data['y_offset']
+            width = glyph_data['width']
+            height = glyph_data['height']
+            
+            min_x = min(min_x, x_offset)
+            max_x = max(max_x, x_offset + width)
+            min_y = min(min_y, y_offset)
+            max_y = max(max_y, y_offset + height)
+            
+        return (max_x - min_x, max_y - min_y, min_x, min_y)
+        
+
+def load_font(filename, bitmap_class=Bitmap):
+    """Load a font file.
+    
+    Args:
+        filename: Path to font file
+        bitmap_class: Bitmap class to use (for compatibility)
+        
+    Returns:
+        BitmapFont instance
+    """
+    font = BitmapFont()
+    
+    # Check if file exists, otherwise try to find it in package fonts
+    if not os.path.exists(filename):
+        # Try package fonts directory
+        package_dir = os.path.dirname(os.path.dirname(__file__))
+        fonts_dir = os.path.join(package_dir, 'fonts')
+        filename = os.path.join(fonts_dir, os.path.basename(filename))
+        
+    font.load_font(filename)
+    return font

scrollkit/simulator/adafruit_bitmap_font/glyph_cache.py

@@ -0,0 +1,70 @@
+"""Glyph caching for bitmap fonts."""
+
+from ..displayio import Bitmap
+
+
+class GlyphCache:
+    """Cache for rendered font glyphs.
+    
+    Stores pre-rendered glyphs to improve text rendering performance.
+    """
+    
+    def __init__(self, max_glyphs=256):
+        """Initialize glyph cache.
+        
+        Args:
+            max_glyphs: Maximum number of glyphs to cache
+        """
+        self.max_glyphs = max_glyphs
+        self._cache = {}
+        self._access_order = []
+        
+    def get(self, char_code):
+        """Get a cached glyph.
+        
+        Args:
+            char_code: Character code to get
+            
+        Returns:
+            Cached glyph info dictionary or None if not cached
+        """
+        if char_code in self._cache:
+            # Move to end of access order (most recently used)
+            self._access_order.remove(char_code)
+            self._access_order.append(char_code)
+            return self._cache[char_code]['info']
+        return None
+        
+    def put(self, char_code, glyph_bitmap, glyph_info):
+        """Add a glyph to the cache.
+        
+        Args:
+            char_code: Character code
+            glyph_bitmap: Bitmap containing glyph pixels
+            glyph_info: Dictionary with glyph metrics
+        """
+        # Check if we need to evict old glyphs
+        if len(self._cache) >= self.max_glyphs and char_code not in self._cache:
+            # Evict least recently used
+            old_char = self._access_order.pop(0)
+            del self._cache[old_char]
+            
+        # Add to cache
+        self._cache[char_code] = {
+            'bitmap': glyph_bitmap,
+            'info': glyph_info
+        }
+        
+        # Update access order
+        if char_code in self._access_order:
+            self._access_order.remove(char_code)
+        self._access_order.append(char_code)
+        
+    def clear(self):
+        """Clear all cached glyphs."""
+        self._cache.clear()
+        self._access_order.clear()
+        
+    def __len__(self):
+        """Get number of cached glyphs."""
+        return len(self._cache)

scrollkit/simulator/adafruit_display_text/__init__.py

@@ -0,0 +1,5 @@
+"""Adafruit display text library compatibility."""
+
+from .label import Label
+
+__all__ = ['Label']

scrollkit/simulator/adafruit_display_text/label.py

@@ -0,0 +1,336 @@
+"""Text label implementation for displayio."""
+
+from ..displayio import Group, Bitmap, Palette, TileGrid
+from ..core.color_utils import rgb888_to_rgb565
+
+
+class Label(Group):
+    """A label displaying a string of text.
+    
+    Compatible with CircuitPython's adafruit_display_text.label.Label API.
+    """
+    
+    def __init__(self, font, *, text="", color=0xFFFFFF, background_color=None,
+                 line_spacing=1.25, background_tight=False, padding_top=0,
+                 padding_bottom=0, padding_left=0, padding_right=0,
+                 anchor_point=None, anchored_position=None, scale=1,
+                 base_alignment=False, tab_replacement=(4, " "), label_direction="LTR",
+                 **kwargs):
+        """Initialize Label.
+        
+        Args:
+            font: Font to use for text
+            text: Initial text to display
+            color: Text color (RGB565 or RGB888)
+            background_color: Background color (None for transparent)
+            line_spacing: Line spacing multiplier
+            background_tight: Whether background fits text tightly
+            padding_top: Top padding in pixels
+            padding_bottom: Bottom padding in pixels
+            padding_left: Left padding in pixels
+            padding_right: Right padding in pixels
+            anchor_point: Anchor point as (x, y) normalized values
+            anchored_position: Position for anchor point
+            scale: Scale factor for text
+            base_alignment: Whether to align text baselines
+            tab_replacement: Tuple of (spaces, character) for tab replacement
+            label_direction: Text direction ("LTR" or "RTL")
+            **kwargs: Additional keyword arguments
+        """
+        # Store the font first
+        self.font = font
+        
+        # Initialize parent with all parameters
+        super().__init__(scale=scale, **kwargs)
+        self._text = ""
+        if isinstance(color, int):
+            self._color = color
+        else:
+            # Convert tuple/list to RGB565
+            if hasattr(color, '__iter__'):
+                self._color = rgb888_to_rgb565(*color)
+            else:
+                self._color = color
+        self._background_color = background_color
+        self.line_spacing = line_spacing
+        self.background_tight = background_tight
+        self.padding_top = padding_top
+        self.padding_bottom = padding_bottom
+        self.padding_left = padding_left
+        self.padding_right = padding_right
+        self._anchor_point = anchor_point
+        self._anchored_position = anchored_position
+        self.base_alignment = base_alignment
+        self.tab_replacement = tab_replacement
+        self.label_direction = label_direction
+        
+        # Internal display objects
+        self._bitmap = None
+        self._palette = None
+        self._tilegrid = None
+        
+        # Set initial text
+        if text:
+            self.text = text
+            
+    @property
+    def text(self):
+        """Get the current text."""
+        return self._text
+        
+    @text.setter
+    def text(self, new_text):
+        """Set the text to display.
+        
+        Args:
+            new_text: New text string
+        """
+        if new_text == self._text:
+            return
+            
+        self._text = str(new_text)
+        self._update_text()
+        
+    @property
+    def color(self):
+        """Get the text color."""
+        return self._color
+        
+    @color.setter
+    def color(self, new_color):
+        """Set the text color.
+        
+        Args:
+            new_color: New color value
+        """
+        if isinstance(new_color, int):
+            self._color = new_color
+        else:
+            if hasattr(new_color, '__iter__'):
+                self._color = rgb888_to_rgb565(*new_color)
+            else:
+                self._color = new_color
+        if self._palette:
+            self._palette[1] = self._color
+            
+    @property
+    def background_color(self):
+        """Get the background color."""
+        return self._background_color
+        
+    @background_color.setter
+    def background_color(self, new_color):
+        """Set the background color.
+        
+        Args:
+            new_color: New color value or None for transparent
+        """
+        self._background_color = new_color
+        if self._palette and new_color is not None:
+            if isinstance(new_color, int):
+                self._palette[0] = new_color
+            else:
+                self._palette[0] = rgb888_to_rgb565(*new_color)
+        self._update_text()
+        
+    @property
+    def anchor_point(self):
+        """Get the anchor point."""
+        return self._anchor_point
+        
+    @anchor_point.setter
+    def anchor_point(self, new_anchor):
+        """Set the anchor point.
+        
+        Args:
+            new_anchor: (x, y) tuple with normalized coordinates (0.0-1.0)
+        """
+        self._anchor_point = new_anchor
+        self._update_position()
+        
+    @property
+    def anchored_position(self):
+        """Get the anchored position."""
+        return self._anchored_position
+        
+    @anchored_position.setter
+    def anchored_position(self, new_position):
+        """Set the anchored position.
+        
+        Args:
+            new_position: (x, y) position for the anchor point
+        """
+        self._anchored_position = new_position
+        self._update_position()
+        
+    def _update_text(self):
+        """Update the text bitmap and display objects."""
+        # Replace tabs
+        display_text = self._text
+        if '\t' in display_text:
+            tab_spaces, tab_char = self.tab_replacement
+            display_text = display_text.replace('\t', tab_char * tab_spaces)
+            
+        # Calculate text dimensions
+        lines = display_text.split('\n')
+        max_width = 0
+        total_height = 0
+        
+        for i, line in enumerate(lines):
+            line_width = 0
+            line_height = 0
+            char_count = 0
+            
+            for char in line:
+                glyph = self.font.get_glyph(char)
+                if glyph:
+                    line_width += glyph['dx']
+                    line_height = max(line_height, glyph['height'])
+                    char_count += 1
+                    
+            # Character spacing is now handled by DWIDTH from BDF file
+                    
+            max_width = max(max_width, line_width)
+            if i == 0:
+                total_height = self.font.height  # Use font height, not glyph height
+            else:
+                total_height += int(self.font.height * self.line_spacing)
+                
+        # Add padding
+        bitmap_width = max_width + self.padding_left + self.padding_right
+        # Calculate bitmap height for proper baseline alignment
+        # Need space for: padding_top + font.ascent (above baseline) + font.descent (below baseline) + padding_bottom
+        # For multiline text, add space for additional lines
+        bitmap_height = self.padding_top + self.font.ascent + self.padding_bottom
+        if len(lines) > 1:
+            # Add space for additional lines
+            bitmap_height += (len(lines) - 1) * int(self.font.height * self.line_spacing)
+        # Add space for descenders (font.descent is the maximum depth below baseline)
+        bitmap_height += self.font.descent
+        
+        # Ensure minimum size
+        bitmap_width = max(1, bitmap_width)
+        bitmap_height = max(1, bitmap_height)
+
+        # Hardware-realism hook: rebuilding the glyph bitmap is the dominant
+        # per-frame cost on CircuitPython. No-op unless a PerformanceManager is
+        # active (opt-in via SimulatorDisplay(hardware_timing=True)).
+        from ..core import performance_manager as _pm_mod
+        _pm = _pm_mod.get_active()
+        if _pm is not None and _pm.enabled:
+            _pm.account_bitmap_rebuild(bitmap_width, bitmap_height)
+
+        # Create new bitmap and palette
+        self._bitmap = Bitmap(bitmap_width, bitmap_height, 2)
+        self._palette = Palette(2)
+        
+        # Set colors
+        if self._background_color is None:
+            self._palette.make_transparent(0)
+        else:
+            self._palette[0] = self._background_color
+        self._palette[1] = self._color
+        
+        # Fill background
+        if self._background_color is not None:
+            self._bitmap.fill(0)
+            
+        # Render text with proper baseline alignment
+        # The baseline should be positioned font.ascent pixels from the top of the text area
+        # This leaves room for ascenders above and descenders below the baseline
+        baseline_y = self.padding_top + self.font.ascent
+        
+        for line_num, line in enumerate(lines):
+            x_offset = self.padding_left
+            
+            # Handle RTL text direction
+            if self.label_direction == "RTL":
+                line = line[::-1]
+                
+            for char in line:
+                glyph = self.font.get_glyph(char)
+                if not glyph:
+                    continue
+                    
+                # Get glyph bitmap
+                glyph_bitmap = glyph['bitmap']
+                glyph_x_offset = glyph.get('x_offset', 0)
+                glyph_y_offset = glyph.get('y_offset', 0)
+                
+                # Calculate position with proper baseline alignment
+                # All characters are positioned relative to the common baseline
+                draw_x = x_offset + glyph_x_offset
+                # Position character so its bottom edge aligns with baseline + y_offset
+                # For y_offset=0: character bottom is at baseline
+                # For y_offset=-2: character bottom is 2 pixels below baseline (descender)
+                draw_y = baseline_y - glyph['height'] - glyph_y_offset
+                
+                # Copy glyph pixels to main bitmap (skip if no bitmap, e.g., spaces)
+                if glyph_bitmap is not None:
+                    for gy in range(glyph_bitmap.height):
+                        for gx in range(glyph_bitmap.width):
+                            if glyph_bitmap[gx, gy] > 0:
+                                bx = draw_x + gx
+                                by = draw_y + gy
+                                if 0 <= bx < bitmap_width and 0 <= by < bitmap_height:
+                                    self._bitmap[bx, by] = 1
+                                
+                # Use DWIDTH from BDF file for proper kerning
+                x_offset += glyph['dx']
+                
+            # Move to next line
+            if line_num < len(lines) - 1:
+                baseline_y += int(self.font.height * self.line_spacing)
+                
+        # Update or create tilegrid
+        if self._tilegrid:
+            self.remove(self._tilegrid)
+            
+        self._tilegrid = TileGrid(self._bitmap, pixel_shader=self._palette)
+        
+        # Apply baseline adjustment to TileGrid position
+        # In CircuitPython, label.y represents the baseline position
+        # We need to offset the TileGrid to account for this
+        # The adjustment needs to account for the actual character positioning
+        # For a font with ascent=9, setting y=15 should put the baseline at row 15
+        # This means the top of the bitmap (which includes ascent space) should be at y=15-9=6
+        # But we also need to account for the actual glyph positioning within the bitmap
+        baseline_offset = self.font.ascent + self.padding_top - 4  # Fine-tuned for CircuitPython compatibility
+        self._tilegrid.y = -baseline_offset
+        
+        self.append(self._tilegrid)
+        
+        # Update position if anchored
+        self._update_position()
+        
+    def _update_position(self):
+        """Update position based on anchor point."""
+        if self._anchor_point and self._anchored_position and self._bitmap:
+            anchor_x, anchor_y = self._anchor_point
+            pos_x, pos_y = self._anchored_position
+            
+            # Calculate actual position
+            self.x = int(pos_x - self._bitmap.width * anchor_x)
+            self.y = int(pos_y - self._bitmap.height * anchor_y)
+            
+    @property
+    def bounding_box(self):
+        """Get the bounding box of the label.
+        
+        Returns:
+            Tuple of (x, y, width, height)
+        """
+        if self._bitmap:
+            return (self.x, self.y, self._bitmap.width, self._bitmap.height)
+        return (self.x, self.y, 0, 0)
+        
+    @property
+    def width(self):
+        """Get the width of the label."""
+        return self._bitmap.width if self._bitmap else 0
+        
+    @property
+    def height(self):
+        """Get the height of the label."""
+        return self._bitmap.height if self._bitmap else 0
+