kollabor 0.4.9__py3-none-any.whl

core/fullscreen/components/animation.py

@@ -0,0 +1,258 @@
+"""Animation framework for full-screen plugins."""
+
+import math
+from typing import Callable, Any
+from dataclasses import dataclass
+
+
+@dataclass
+class AnimationState:
+    """State for an animation."""
+    start_value: float
+    end_value: float
+    duration: float
+    start_time: float
+    current_time: float = 0.0
+    completed: bool = False
+
+    @property
+    def progress(self) -> float:
+        """Get animation progress (0.0 to 1.0)."""
+        if self.duration <= 0:
+            return 1.0
+        return min(1.0, (self.current_time - self.start_time) / self.duration)
+
+    @property
+    def is_complete(self) -> bool:
+        """Check if animation is complete."""
+        return self.progress >= 1.0 or self.completed
+
+
+class EasingFunctions:
+    """Common easing functions for animations."""
+
+    @staticmethod
+    def linear(t: float) -> float:
+        """Linear interpolation."""
+        return t
+
+    @staticmethod
+    def ease_in_quad(t: float) -> float:
+        """Quadratic ease-in."""
+        return t * t
+
+    @staticmethod
+    def ease_out_quad(t: float) -> float:
+        """Quadratic ease-out."""
+        return 1 - (1 - t) * (1 - t)
+
+    @staticmethod
+    def ease_in_out_quad(t: float) -> float:
+        """Quadratic ease-in-out."""
+        if t < 0.5:
+            return 2 * t * t
+        return 1 - pow(-2 * t + 2, 2) / 2
+
+    @staticmethod
+    def ease_in_cubic(t: float) -> float:
+        """Cubic ease-in."""
+        return t * t * t
+
+    @staticmethod
+    def ease_out_cubic(t: float) -> float:
+        """Cubic ease-out."""
+        return 1 - pow(1 - t, 3)
+
+    @staticmethod
+    def ease_in_out_cubic(t: float) -> float:
+        """Cubic ease-in-out."""
+        if t < 0.5:
+            return 4 * t * t * t
+        return 1 - pow(-2 * t + 2, 3) / 2
+
+    @staticmethod
+    def bounce_out(t: float) -> float:
+        """Bounce ease-out."""
+        n1 = 7.5625
+        d1 = 2.75
+        if t < 1 / d1:
+            return n1 * t * t
+        elif t < 2 / d1:
+            t -= 1.5 / d1
+            return n1 * t * t + 0.75
+        elif t < 2.5 / d1:
+            t -= 2.25 / d1
+            return n1 * t * t + 0.9375
+        else:
+            t -= 2.625 / d1
+            return n1 * t * t + 0.984375
+
+    @staticmethod
+    def elastic_out(t: float) -> float:
+        """Elastic ease-out."""
+        if t == 0 or t == 1:
+            return t
+        c4 = (2 * math.pi) / 3
+        return pow(2, -10 * t) * math.sin((t * 10 - 0.75) * c4) + 1
+
+
+class AnimationFramework:
+    """Framework for managing animations in full-screen plugins."""
+
+    def __init__(self):
+        """Initialize the animation framework."""
+        self.animations = {}
+        self.next_id = 0
+
+    def animate(self, start_value: float, end_value: float, duration: float,
+               start_time: float, easing: Callable[[float], float] = EasingFunctions.linear) -> int:
+        """Create a new animation.
+
+        Args:
+            start_value: Starting value
+            end_value: Ending value
+            duration: Animation duration in seconds
+            start_time: Animation start time
+            easing: Easing function
+
+        Returns:
+            Animation ID
+        """
+        animation_id = self.next_id
+        self.next_id += 1
+
+        self.animations[animation_id] = {
+            'state': AnimationState(start_value, end_value, duration, start_time),
+            'easing': easing
+        }
+
+        return animation_id
+
+    def update(self, current_time: float):
+        """Update all animations.
+
+        Args:
+            current_time: Current time
+        """
+        completed_animations = []
+
+        for anim_id, animation in self.animations.items():
+            state = animation['state']
+            state.current_time = current_time
+
+            if state.is_complete:
+                completed_animations.append(anim_id)
+
+        # Remove completed animations
+        for anim_id in completed_animations:
+            del self.animations[anim_id]
+
+    def get_value(self, animation_id: int) -> float:
+        """Get current animated value.
+
+        Args:
+            animation_id: Animation ID
+
+        Returns:
+            Current animated value
+        """
+        if animation_id not in self.animations:
+            return 0.0
+
+        animation = self.animations[animation_id]
+        state = animation['state']
+        easing = animation['easing']
+
+        if state.is_complete:
+            return state.end_value
+
+        # Apply easing to progress
+        eased_progress = easing(state.progress)
+
+        # Interpolate between start and end values
+        return state.start_value + (state.end_value - state.start_value) * eased_progress
+
+    def is_complete(self, animation_id: int) -> bool:
+        """Check if animation is complete.
+
+        Args:
+            animation_id: Animation ID
+
+        Returns:
+            True if animation is complete or doesn't exist
+        """
+        if animation_id not in self.animations:
+            return True
+
+        return self.animations[animation_id]['state'].is_complete
+
+    def stop_animation(self, animation_id: int):
+        """Stop an animation.
+
+        Args:
+            animation_id: Animation ID to stop
+        """
+        if animation_id in self.animations:
+            del self.animations[animation_id]
+
+    def clear_all(self):
+        """Clear all animations."""
+        self.animations.clear()
+
+    def get_active_count(self) -> int:
+        """Get number of active animations.
+
+        Returns:
+            Number of active animations
+        """
+        return len(self.animations)
+
+    # Utility methods for common animation patterns
+    def fade_in(self, duration: float, start_time: float) -> int:
+        """Create a fade-in animation (0 to 1).
+
+        Args:
+            duration: Fade duration
+            start_time: Start time
+
+        Returns:
+            Animation ID
+        """
+        return self.animate(0.0, 1.0, duration, start_time, EasingFunctions.ease_out_quad)
+
+    def fade_out(self, duration: float, start_time: float) -> int:
+        """Create a fade-out animation (1 to 0).
+
+        Args:
+            duration: Fade duration
+            start_time: Start time
+
+        Returns:
+            Animation ID
+        """
+        return self.animate(1.0, 0.0, duration, start_time, EasingFunctions.ease_in_quad)
+
+    def slide_in(self, distance: float, duration: float, start_time: float) -> int:
+        """Create a slide-in animation.
+
+        Args:
+            distance: Distance to slide
+            duration: Animation duration
+            start_time: Start time
+
+        Returns:
+            Animation ID
+        """
+        return self.animate(-distance, 0.0, duration, start_time, EasingFunctions.ease_out_cubic)
+
+    def bounce_in(self, duration: float, start_time: float) -> int:
+        """Create a bounce-in animation.
+
+        Args:
+            duration: Animation duration
+            start_time: Start time
+
+        Returns:
+            Animation ID
+        """
+        return self.animate(0.0, 1.0, duration, start_time, EasingFunctions.bounce_out)

core/fullscreen/components/drawing.py

@@ -0,0 +1,160 @@
+"""Drawing primitives for full-screen plugins."""
+
+import math
+from typing import Tuple, List, Optional
+from ...io.visual_effects import ColorPalette
+
+
+class DrawingPrimitives:
+    """Basic drawing operations for full-screen plugins."""
+
+    @staticmethod
+    def draw_text_centered(renderer, y: int, text: str, color: str = ColorPalette.WHITE):
+        """Draw text centered horizontally.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            y: Row position
+            text: Text to draw
+            color: Text color
+        """
+        width, _ = renderer.get_terminal_size()
+        x = max(0, (width - len(text)) // 2)
+        renderer.write_at(x, y, text, color)
+
+    @staticmethod
+    def draw_border(renderer, x: int, y: int, width: int, height: int,
+                   border_char: str = "─", corner_chars: Tuple[str, str, str, str] = ("╭", "╮", "╯", "╰"),
+                   color: str = ColorPalette.WHITE):
+        """Draw a decorative border.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            x, y: Top-left position
+            width, height: Border dimensions
+            border_char: Character for sides
+            corner_chars: Tuple of (top-left, top-right, bottom-right, bottom-left)
+            color: Border color
+        """
+        if width < 2 or height < 2:
+            return
+
+        # Top border
+        renderer.write_at(x, y, corner_chars[0], color)
+        for i in range(1, width - 1):
+            renderer.write_at(x + i, y, border_char, color)
+        renderer.write_at(x + width - 1, y, corner_chars[1], color)
+
+        # Side borders
+        for i in range(1, height - 1):
+            renderer.write_at(x, y + i, "│", color)
+            renderer.write_at(x + width - 1, y + i, "│", color)
+
+        # Bottom border
+        if height > 1:
+            renderer.write_at(x, y + height - 1, corner_chars[3], color)
+            for i in range(1, width - 1):
+                renderer.write_at(x + i, y + height - 1, border_char, color)
+            renderer.write_at(x + width - 1, y + height - 1, corner_chars[2], color)
+
+    @staticmethod
+    def draw_progress_bar(renderer, x: int, y: int, width: int, progress: float,
+                         fill_char: str = "█", empty_char: str = "░",
+                         color: str = ColorPalette.GREEN):
+        """Draw a progress bar.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            x, y: Position
+            width: Bar width
+            progress: Progress value (0.0 to 1.0)
+            fill_char: Character for filled portion
+            empty_char: Character for empty portion
+            color: Bar color
+        """
+        progress = max(0.0, min(1.0, progress))
+        filled_width = int(width * progress)
+
+        bar_text = fill_char * filled_width + empty_char * (width - filled_width)
+        renderer.write_at(x, y, bar_text, color)
+
+    @staticmethod
+    def draw_spinner(renderer, x: int, y: int, frame: int,
+                    frames: Optional[List[str]] = None, color: str = ColorPalette.CYAN):
+        """Draw an animated spinner.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            x, y: Position
+            frame: Current frame number
+            frames: List of spinner frames
+            color: Spinner color
+        """
+        if frames is None:
+            frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧"]
+
+        char = frames[frame % len(frames)]
+        renderer.write_at(x, y, char, color)
+
+    @staticmethod
+    def draw_circle_points(renderer, center_x: int, center_y: int, radius: int,
+                          char: str = "●", color: str = ColorPalette.WHITE):
+        """Draw points in a circle pattern.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            center_x, center_y: Circle center
+            radius: Circle radius
+            char: Character to draw
+            color: Character color
+        """
+        width, height = renderer.get_terminal_size()
+
+        for angle in range(0, 360, 15):  # Every 15 degrees
+            rad = math.radians(angle)
+            x = int(center_x + radius * math.cos(rad))
+            y = int(center_y + radius * math.sin(rad) * 0.5)  # Adjust for terminal aspect ratio
+
+            if 0 <= x < width and 0 <= y < height:
+                renderer.write_at(x, y, char, color)
+
+    @staticmethod
+    def draw_wave(renderer, y: int, amplitude: int, frequency: float, phase: float,
+                 char: str = "~", color: str = ColorPalette.BLUE):
+        """Draw a wave pattern.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            y: Base row position
+            amplitude: Wave height
+            frequency: Wave frequency
+            phase: Wave phase offset
+            char: Character to draw
+            color: Wave color
+        """
+        width, height = renderer.get_terminal_size()
+
+        for x in range(width):
+            wave_y = int(y + amplitude * math.sin(frequency * x + phase))
+            if 0 <= wave_y < height:
+                renderer.write_at(x, wave_y, char, color)
+
+    @staticmethod
+    def fill_area(renderer, x: int, y: int, width: int, height: int,
+                 char: str = " ", color: str = ColorPalette.RESET):
+        """Fill an area with a character.
+
+        Args:
+            renderer: FullScreenRenderer instance
+            x, y: Top-left position
+            width, height: Area dimensions
+            char: Fill character
+            color: Fill color
+        """
+        term_width, term_height = renderer.get_terminal_size()
+
+        for row in range(height):
+            for col in range(width):
+                draw_x, draw_y = x + col, y + row
+                if 0 <= draw_x < term_width and 0 <= draw_y < term_height:
+                    renderer.write_at(draw_x, draw_y, char, color)

core/fullscreen/components/matrix_components.py

@@ -0,0 +1,177 @@
+"""Matrix rain components for the full-screen framework."""
+
+import random
+from typing import List
+from ...io.visual_effects import ColorPalette
+
+
+class MatrixColumn:
+    """A single column of falling Matrix characters."""
+
+    def __init__(self, x: int, height: int):
+        """Initialize Matrix column.
+
+        Args:
+            x: X position (column number)
+            height: Terminal height
+        """
+        self.x = x
+        self.height = height
+        self.chars: List[str] = []
+        self.positions: List[int] = []
+        self.speed = random.uniform(1.5, 4.0)
+        self.next_update = 0
+        self.length = random.randint(5, 25)
+
+        # Matrix character set (katakana, numbers, symbols)
+        self.matrix_chars = [
+            'ア', 'イ', 'ウ', 'エ', 'オ', 'カ', 'キ', 'ク', 'ケ', 'コ',
+            'サ', 'シ', 'ス', 'セ', 'ソ', 'タ', 'チ', 'ツ', 'テ', 'ト',
+            'ナ', 'ニ', 'ヌ', 'ネ', 'ノ', 'ハ', 'ヒ', 'フ', 'ヘ', 'ホ',
+            'マ', 'ミ', 'ム', 'メ', 'モ', 'ヤ', 'ユ', 'ヨ', 'ラ', 'リ',
+            'ル', 'レ', 'ロ', 'ワ', 'ヲ', 'ン', '0', '1', '2', '3', '4',
+            '5', '6', '7', '8', '9', ':', '.', '"', '=', '*', '+', '<',
+            '>', '|', '\\', '/', '[', ']', '{', '}', '(', ')', '-', '_'
+        ]
+
+        self._reset()
+
+    def _reset(self):
+        """Reset column to start falling from top."""
+        self.chars = [random.choice(self.matrix_chars) for _ in range(self.length)]
+        self.positions = list(range(-self.length, 0))
+        self.speed = random.uniform(1.2, 3.5)
+        self.next_update = 0
+
+    def update(self, time: float) -> bool:
+        """Update column positions.
+
+        Args:
+            time: Current time
+
+        Returns:
+            True if column is still active
+        """
+        if time < self.next_update:
+            return True
+
+        self.next_update = time + (1.0 / self.speed)
+
+        # Move all positions down
+        for i in range(len(self.positions)):
+            self.positions[i] += 1
+
+        # Remove characters that have fallen off screen
+        while self.positions and self.positions[0] >= self.height:
+            self.positions.pop(0)
+            self.chars.pop(0)
+
+        # Check if column is done
+        if not self.positions:
+            # Random chance to restart
+            if random.random() < 0.1:
+                self._reset()
+            return False
+
+        # Randomly change some characters
+        for i in range(len(self.chars)):
+            if random.random() < 0.05:
+                self.chars[i] = random.choice(self.matrix_chars)
+
+        return True
+
+    def render(self, renderer):
+        """Render column using the full-screen renderer.
+
+        Args:
+            renderer: FullScreenRenderer instance
+        """
+        for i, (char, pos) in enumerate(zip(self.chars, self.positions)):
+            if 0 <= pos < self.height:
+                # Brightest character at the head
+                if i == len(self.chars) - 1:
+                    color = ColorPalette.BRIGHT_WHITE
+                # Bright green for recent characters
+                elif i >= len(self.chars) - 3:
+                    color = ColorPalette.BRIGHT_GREEN
+                # Normal green for middle
+                elif i >= len(self.chars) - 8:
+                    color = ColorPalette.GREEN
+                # Dim green for tail
+                else:
+                    color = ColorPalette.DIM_GREEN
+
+                # Write character at position
+                renderer.write_at(self.x, pos, char, color)
+
+
+class MatrixRenderer:
+    """Renders the complete Matrix rain effect using the full-screen framework."""
+
+    def __init__(self, terminal_width: int, terminal_height: int):
+        """Initialize Matrix renderer.
+
+        Args:
+            terminal_width: Terminal width in columns
+            terminal_height: Terminal height in rows
+        """
+        self.terminal_width = terminal_width
+        self.terminal_height = terminal_height
+        self.columns: List[MatrixColumn] = []
+        self.start_time = 0
+
+        # Create initial columns
+        self._create_columns()
+
+    def _create_columns(self):
+        """Create initial set of Matrix columns."""
+        self.columns = []
+        for x in range(self.terminal_width):
+            if random.random() < 0.5:  # 50% chance for each column to be active
+                column = MatrixColumn(x, self.terminal_height)
+                # Stagger start times
+                column.next_update = random.uniform(0, 3.0)
+                self.columns.append(column)
+
+    def update(self, current_time: float):
+        """Update all Matrix columns.
+
+        Args:
+            current_time: Current time for animation
+        """
+        # Update all columns
+        active_columns = []
+        for column in self.columns:
+            if column.update(current_time):
+                active_columns.append(column)
+
+        self.columns = active_columns
+
+        # Add new columns occasionally
+        if len(self.columns) < self.terminal_width * 0.4 and random.random() < 0.02:
+            x = random.randint(0, self.terminal_width - 1)
+            # Make sure we don't have a column too close
+            if not any(abs(col.x - x) < 2 for col in self.columns):
+                column = MatrixColumn(x, self.terminal_height)
+                self.columns.append(column)
+
+    def render(self, renderer):
+        """Render all Matrix columns.
+
+        Args:
+            renderer: FullScreenRenderer instance
+        """
+        # Clear screen
+        renderer.clear_screen()
+
+        # Render all columns
+        for column in self.columns:
+            column.render(renderer)
+
+        # Flush output
+        renderer.flush()
+
+    def reset(self):
+        """Reset the Matrix renderer."""
+        self._create_columns()
+        self.start_time = 0