prezo 0.3.1__py3-none-any.whl

prezo/screens/toc.py

@@ -0,0 +1,254 @@
+"""Table of Contents screen for prezo."""
+
+from __future__ import annotations
+
+import re
+from typing import TYPE_CHECKING, ClassVar
+
+from textual.binding import Binding, BindingType
+from textual.containers import VerticalScroll
+from textual.widgets import Static
+
+from .base import ThemedModalScreen
+
+if TYPE_CHECKING:
+    from textual.app import ComposeResult
+
+    from prezo.parser import Presentation
+
+
+class TocEntry(Static):
+    """A single TOC entry."""
+
+    def __init__(
+        self,
+        slide_index: int,
+        title: str,
+        level: int,
+        is_current: bool = False,
+        **kwargs,
+    ) -> None:
+        """Initialize a TOC entry.
+
+        Args:
+            slide_index: Index of the slide this entry refers to.
+            title: Title text for the entry.
+            level: Heading level (1-6) for indentation.
+            is_current: Whether this is the current slide.
+            **kwargs: Additional arguments for Static widget.
+
+        """
+        super().__init__(**kwargs)
+        self.slide_index = slide_index
+        self.title = title
+        self.level = level
+        self.is_current = is_current
+
+    def render(self) -> str:
+        """Render the TOC entry with indentation and marker."""
+        indent = "  " * (self.level - 1)
+        marker = "►" if self.is_current else " "
+        return f"{marker} {indent}{self.title} ({self.slide_index + 1})"
+
+
+class TableOfContentsScreen(ThemedModalScreen[int | None]):
+    """Modal screen showing table of contents based on headings."""
+
+    CSS = """
+    TableOfContentsScreen {
+        align: center middle;
+    }
+
+    #toc-container {
+        width: 70%;
+        height: 80%;
+        background: $surface;
+        border: thick $primary;
+        padding: 1 2;
+    }
+
+    #toc-title {
+        width: 100%;
+        height: 3;
+        content-align: center middle;
+        text-style: bold;
+        background: $primary;
+        color: $text;
+        margin-bottom: 1;
+    }
+
+    #toc-list {
+        width: 100%;
+        height: 1fr;
+    }
+
+    .toc-entry {
+        width: 100%;
+        height: 1;
+        padding: 0 1;
+    }
+
+    .toc-entry:hover {
+        background: $primary-darken-2;
+    }
+
+    .toc-entry.selected {
+        background: $primary;
+    }
+
+    .toc-entry.current {
+        text-style: bold;
+    }
+
+    #toc-hint {
+        width: 100%;
+        text-align: center;
+        color: $text-muted;
+        margin-top: 1;
+    }
+    """
+
+    BINDINGS: ClassVar[list[BindingType]] = [
+        Binding("escape", "cancel", "Cancel"),
+        Binding("q", "cancel", "Cancel"),
+        Binding("enter", "select", "Select"),
+        Binding("space", "select", "Select", show=False),
+        Binding("up", "move_up", "Up", show=False),
+        Binding("down", "move_down", "Down", show=False),
+        Binding("k", "move_up", "Up", show=False),
+        Binding("j", "move_down", "Down", show=False),
+        Binding("home", "first", "First", show=False),
+        Binding("end", "last", "Last", show=False),
+    ]
+
+    def __init__(self, presentation: Presentation, current_slide: int) -> None:
+        """Initialize the table of contents screen.
+
+        Args:
+            presentation: The presentation to build TOC from.
+            current_slide: Index of the currently active slide.
+
+        """
+        super().__init__()
+        self.presentation = presentation
+        self.current_slide = current_slide
+        self.entries: list[tuple[int, str, int]] = []  # (slide_index, title, level)
+        self.selected_index = 0
+        self._build_toc()
+
+    def _build_toc(self) -> None:
+        """Build table of contents from slide headings."""
+        for i, slide in enumerate(self.presentation.slides):
+            heading = self._extract_heading(slide.content)
+            if heading:
+                title, level = heading
+                self.entries.append((i, title, level))
+
+        # If no headings found, create entries for all slides
+        if not self.entries:
+            for i, slide in enumerate(self.presentation.slides):
+                title = self._get_first_line(slide.content)
+                self.entries.append((i, title, 1))
+
+        # Set initial selection to current slide's entry
+        for idx, (slide_idx, _, _) in enumerate(self.entries):
+            if slide_idx >= self.current_slide:
+                self.selected_index = idx
+                break
+
+    def _extract_heading(self, content: str) -> tuple[str, int] | None:
+        """Extract first heading and its level from content."""
+        for line in content.strip().split("\n"):
+            line = line.strip()
+            match = re.match(r"^(#{1,6})\s+(.+)$", line)
+            if match:
+                level = len(match.group(1))
+                title = match.group(2).strip()
+                # Remove markdown formatting
+                title = re.sub(r"\*{1,2}([^*]+)\*{1,2}", r"\1", title)
+                return title[:60], level
+        return None
+
+    def _get_first_line(self, content: str) -> str:
+        """Get first non-empty line of content."""
+        for line in content.strip().split("\n"):
+            line = line.strip()
+            if line and not line.startswith("<!--"):
+                return line[:60]
+        return "Untitled"
+
+    def compose(self) -> ComposeResult:
+        """Compose the table of contents layout."""
+        with VerticalScroll(id="toc-container"):
+            yield Static(" Table of Contents ", id="toc-title")
+            with VerticalScroll(id="toc-list"):
+                for idx, (slide_idx, title, level) in enumerate(self.entries):
+                    is_current = slide_idx == self.current_slide
+                    classes = "toc-entry"
+                    if idx == self.selected_index:
+                        classes += " selected"
+                    if is_current:
+                        classes += " current"
+                    yield TocEntry(slide_idx, title, level, is_current, classes=classes)
+            yield Static("Enter to jump, Esc to cancel", id="toc-hint")
+
+    def on_mount(self) -> None:
+        """Scroll to the selected entry on mount."""
+        super().on_mount()
+        self._scroll_to_selected()
+
+    def _update_selection(self) -> None:
+        """Update visual selection."""
+        toc_list = self.query_one("#toc-list", VerticalScroll)
+        for idx, child in enumerate(toc_list.query(".toc-entry")):
+            if idx == self.selected_index:
+                child.add_class("selected")
+                child.scroll_visible()
+            else:
+                child.remove_class("selected")
+
+    def _scroll_to_selected(self) -> None:
+        """Scroll to show the selected entry."""
+        toc_list = self.query_one("#toc-list", VerticalScroll)
+        entries = list(toc_list.query(".toc-entry"))
+        if 0 <= self.selected_index < len(entries):
+            entries[self.selected_index].scroll_visible()
+
+    def action_cancel(self) -> None:
+        """Cancel and dismiss the TOC screen."""
+        self.dismiss(None)
+
+    def action_select(self) -> None:
+        """Select the currently highlighted TOC entry."""
+        if 0 <= self.selected_index < len(self.entries):
+            self.dismiss(self.entries[self.selected_index][0])
+        else:
+            self.dismiss(None)
+
+    def action_move_up(self) -> None:
+        """Move selection up in the TOC list."""
+        if self.selected_index > 0:
+            self.selected_index -= 1
+            self._update_selection()
+
+    def action_move_down(self) -> None:
+        """Move selection down in the TOC list."""
+        if self.selected_index < len(self.entries) - 1:
+            self.selected_index += 1
+            self._update_selection()
+
+    def action_first(self) -> None:
+        """Jump to first TOC entry."""
+        self.selected_index = 0
+        self._update_selection()
+
+    def action_last(self) -> None:
+        """Jump to last TOC entry."""
+        self.selected_index = len(self.entries) - 1
+        self._update_selection()
+
+    def on_click(self, event) -> None:
+        """Handle clicking on a TOC entry."""
+        widget = self.get_widget_at(event.screen_x, event.screen_y)
+        if widget and isinstance(widget, TocEntry):
+            self.dismiss(widget.slide_index)

prezo/terminal.py

@@ -0,0 +1,147 @@
+"""Terminal capability detection for Prezo."""
+
+from __future__ import annotations
+
+import os
+import sys
+from enum import Enum
+from functools import lru_cache
+
+
+class ImageCapability(Enum):
+    """Terminal image rendering capabilities."""
+
+    KITTY = "kitty"
+    SIXEL = "sixel"
+    ITERM = "iterm"
+    ASCII = "ascii"
+    NONE = "none"
+
+
+@lru_cache(maxsize=1)
+def detect_image_capability() -> ImageCapability:
+    """Detect the best image rendering capability for the current terminal.
+
+    Returns:
+        The detected image capability.
+
+    """
+    # Check for Kitty terminal
+    if _is_kitty():
+        return ImageCapability.KITTY
+
+    # Check for iTerm2
+    if _is_iterm():
+        return ImageCapability.ITERM
+
+    # Check for Sixel support
+    if _has_sixel_support():
+        return ImageCapability.SIXEL
+
+    # Fallback to ASCII
+    return ImageCapability.ASCII
+
+
+def _is_kitty() -> bool:
+    """Check if running in Kitty terminal."""
+    # KITTY_WINDOW_ID is set by Kitty
+    if os.environ.get("KITTY_WINDOW_ID"):
+        return True
+
+    # Check TERM
+    term = os.environ.get("TERM", "")
+    return "kitty" in term.lower()
+
+
+def _is_iterm() -> bool:
+    """Check if running in iTerm2."""
+    # iTerm2 sets these environment variables
+    if os.environ.get("TERM_PROGRAM") == "iTerm.app":
+        return True
+
+    if os.environ.get("LC_TERMINAL") == "iTerm2":
+        return True
+
+    # Check for iTerm2 specific env var
+    return bool(os.environ.get("ITERM_SESSION_ID"))
+
+
+def _has_sixel_support() -> bool:
+    """Check if terminal supports Sixel graphics.
+
+    Note: This is a heuristic check. Proper detection would require
+    querying the terminal with escape sequences.
+
+    """
+    term = os.environ.get("TERM", "")
+    term_program = os.environ.get("TERM_PROGRAM", "")
+
+    # Known Sixel-capable terminals
+    sixel_terms = ["mlterm", "xterm", "mintty", "foot"]
+
+    for t in sixel_terms:
+        if t in term.lower() or t in term_program.lower():
+            return True
+
+    # Check for explicit sixel in TERM
+    return "sixel" in term.lower()
+
+
+def get_terminal_size() -> tuple[int, int]:
+    """Get terminal size in columns and rows.
+
+    Returns:
+        Tuple of (columns, rows).
+
+    """
+    try:
+        size = os.get_terminal_size()
+        return size.columns, size.lines
+    except OSError:
+        # Fallback for non-TTY
+        return 80, 24
+
+
+def supports_unicode() -> bool:
+    """Check if terminal supports Unicode output."""
+    # Check encoding
+    encoding = getattr(sys.stdout, "encoding", "") or ""
+    if "utf" in encoding.lower():
+        return True
+
+    # Check LANG environment variable
+    lang = os.environ.get("LANG", "")
+    return "utf" in lang.lower()
+
+
+def supports_true_color() -> bool:
+    """Check if terminal supports 24-bit true color."""
+    colorterm = os.environ.get("COLORTERM", "")
+    if colorterm in ("truecolor", "24bit"):
+        return True
+
+    term = os.environ.get("TERM", "")
+    if "256color" in term or "truecolor" in term:
+        return True
+
+    # iTerm2 and Kitty support true color
+    return _is_iterm() or _is_kitty()
+
+
+def get_capability_summary() -> dict[str, bool | str]:
+    """Get a summary of terminal capabilities.
+
+    Returns:
+        Dictionary of capability names to values.
+
+    """
+    cols, rows = get_terminal_size()
+    return {
+        "image_capability": detect_image_capability().value,
+        "unicode": supports_unicode(),
+        "true_color": supports_true_color(),
+        "columns": cols,
+        "rows": rows,
+        "term": os.environ.get("TERM", ""),
+        "term_program": os.environ.get("TERM_PROGRAM", ""),
+    }

prezo/themes.py

@@ -0,0 +1,129 @@
+"""Theme definitions for Prezo."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Theme:
+    """A color theme for the presentation viewer."""
+
+    name: str
+    primary: str
+    secondary: str
+    background: str
+    surface: str
+    text: str
+    text_muted: str
+    success: str
+    warning: str
+    error: str
+
+
+# Built-in themes
+THEMES: dict[str, Theme] = {
+    "dark": Theme(
+        name="dark",
+        primary="#0178d4",
+        secondary="#6f42c1",
+        background="#121212",
+        surface="#1e1e1e",
+        text="#e0e0e0",
+        text_muted="#888888",
+        success="#28a745",
+        warning="#ffc107",
+        error="#dc3545",
+    ),
+    "light": Theme(
+        name="light",
+        primary="#0066cc",
+        secondary="#6f42c1",
+        background="#ffffff",
+        surface="#f5f5f5",
+        text="#1a1a1a",
+        text_muted="#666666",
+        success="#28a745",
+        warning="#ffc107",
+        error="#dc3545",
+    ),
+    "dracula": Theme(
+        name="dracula",
+        primary="#bd93f9",
+        secondary="#ff79c6",
+        background="#282a36",
+        surface="#44475a",
+        text="#f8f8f2",
+        text_muted="#6272a4",
+        success="#50fa7b",
+        warning="#f1fa8c",
+        error="#ff5555",
+    ),
+    "solarized-dark": Theme(
+        name="solarized-dark",
+        primary="#268bd2",
+        secondary="#2aa198",
+        background="#002b36",
+        surface="#073642",
+        text="#839496",
+        text_muted="#586e75",
+        success="#859900",
+        warning="#b58900",
+        error="#dc322f",
+    ),
+    "nord": Theme(
+        name="nord",
+        primary="#88c0d0",
+        secondary="#81a1c1",
+        background="#2e3440",
+        surface="#3b4252",
+        text="#eceff4",
+        text_muted="#7b88a1",
+        success="#a3be8c",
+        warning="#ebcb8b",
+        error="#bf616a",
+    ),
+    "gruvbox": Theme(
+        name="gruvbox",
+        primary="#83a598",
+        secondary="#d3869b",
+        background="#282828",
+        surface="#3c3836",
+        text="#ebdbb2",
+        text_muted="#928374",
+        success="#b8bb26",
+        warning="#fabd2f",
+        error="#fb4934",
+    ),
+}
+
+THEME_ORDER = ["dark", "light", "dracula", "solarized-dark", "nord", "gruvbox"]
+
+
+def get_theme(name: str) -> Theme:
+    """Get a theme by name, defaulting to 'dark'."""
+    return THEMES.get(name, THEMES["dark"])
+
+
+def get_next_theme(current: str) -> str:
+    """Get the next theme name in the cycle."""
+    try:
+        idx = THEME_ORDER.index(current)
+        return THEME_ORDER[(idx + 1) % len(THEME_ORDER)]
+    except ValueError:
+        return THEME_ORDER[0]
+
+
+def theme_to_css(theme: Theme) -> str:
+    """Generate Textual CSS variables from a theme."""
+    return f"""
+    $primary: {theme.primary};
+    $secondary: {theme.secondary};
+    $background: {theme.background};
+    $surface: {theme.surface};
+    $text: {theme.text};
+    $text-muted: {theme.text_muted};
+    $success: {theme.success};
+    $warning: {theme.warning};
+    $error: {theme.error};
+    """

prezo/widgets/__init__.py

@@ -0,0 +1,9 @@
+"""Custom widgets for Prezo."""
+
+from __future__ import annotations
+
+from .image_display import ImageDisplay
+from .slide_button import SlideButton
+from .status_bar import ClockDisplay, ProgressBar, StatusBar
+
+__all__ = ["ClockDisplay", "ImageDisplay", "ProgressBar", "SlideButton", "StatusBar"]

prezo/widgets/image_display.py

@@ -0,0 +1,117 @@
+"""Image display widget for Prezo.
+
+Uses textual-image for native terminal graphics protocol support (Kitty, Sixel).
+Falls back to Unicode halfcell rendering for unsupported terminals.
+"""
+
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from textual.widgets import Static
+from textual_image.widget import Image as TextualImage
+
+if TYPE_CHECKING:
+    from pathlib import Path
+
+    from textual.app import ComposeResult
+
+
+class ImageDisplay(Static):
+    """Widget that displays images in the terminal.
+
+    Uses textual-image library which supports:
+    - Kitty Terminal Graphics Protocol (TGP)
+    - Sixel graphics (iTerm2, WezTerm, xterm, etc.)
+    - Unicode halfcell fallback for other terminals
+
+    This is a container widget that wraps textual_image.widget.Image
+    to provide a consistent API for Prezo.
+    """
+
+    DEFAULT_CSS = """
+    ImageDisplay {
+        width: 100%;
+        height: auto;
+        min-height: 10;
+        padding: 0;
+    }
+
+    ImageDisplay > Image {
+        width: 100%;
+        height: auto;
+    }
+    """
+
+    def __init__(
+        self,
+        image_path: Path | str | None = None,
+        *,
+        width: int | None = None,
+        height: int | None = None,
+        name: str | None = None,
+        id: str | None = None,
+        classes: str | None = None,
+    ) -> None:
+        """Initialize the image display widget.
+
+        Args:
+            image_path: Path to the image file.
+            width: Width in characters (None = auto).
+            height: Height in characters (None = auto).
+            name: Widget name.
+            id: Widget ID.
+            classes: CSS classes.
+
+        """
+        super().__init__(name=name, id=id, classes=classes)
+        self._image_path: Path | str | None = image_path
+        self._width: int | None = width
+        self._height: int | None = height
+        self._image_widget: TextualImage | None = None
+
+    def compose(self) -> ComposeResult:
+        """Compose the image widget."""
+        self._image_widget = TextualImage(self._image_path)
+        self._apply_dimensions()
+        yield self._image_widget
+
+    def _apply_dimensions(self) -> None:
+        """Apply width/height dimensions to the image widget."""
+        if self._image_widget is None:
+            return
+
+        # Apply width if specified
+        if self._width is not None:
+            self._image_widget.styles.width = self._width
+        # Apply height if specified
+        if self._height is not None:
+            self._image_widget.styles.height = self._height
+
+    def set_image(
+        self,
+        path: Path | str | None,
+        *,
+        width: int | None = None,
+        height: int | None = None,
+    ) -> None:
+        """Set the image to display.
+
+        Args:
+            path: Path to the image file, or None to clear.
+            width: Width in characters (None = auto).
+            height: Height in characters (None = auto).
+
+        """
+        self._image_path = path
+        self._width = width
+        self._height = height
+        if self._image_widget is not None:
+            self._image_widget.image = path
+            self._apply_dimensions()
+
+    def clear(self) -> None:
+        """Clear the image display."""
+        self._image_path = None
+        if self._image_widget is not None:
+            self._image_widget.image = None