cct-cli 0.7.9.0__py3-none-any.whl

calc_terminal/viewers/pdf_viewer.py

@@ -0,0 +1,203 @@
+"""CAT Universal File Preview Engine — PDF Viewer (calc_terminal/viewers/pdf_viewer.py).
+
+High-fidelity PDF document viewer:
+- Renders genuine document pages using PyMuPDF (fitz / pymupdf) pixmaps into truecolor display.
+- Displays actual rendered document pages (never mere raw extracted text).
+- Page navigation (Prev, Next, Jump to page, First, Last).
+- Zoom controls (In, Out, Fit, 100%).
+- In-document text search.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Optional, Tuple
+
+TEXTUAL_AVAILABLE = True
+try:
+    from rich.console import Group
+    from rich.style import Style
+    from rich.text import Text
+    from textual.containers import Horizontal, Vertical, VerticalScroll
+    from textual.widgets import Button, Input, Static
+except Exception:
+    TEXTUAL_AVAILABLE = False
+    Vertical = object  # type: ignore
+
+
+class PdfViewer(Vertical):
+    """High-fidelity visual PDF viewer."""
+
+    def __init__(self, path: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.path = os.path.abspath(path)
+        self._current_page: int = 0  # 0-indexed
+        self._page_count: int = 1
+        self._zoom: float = 1.0
+        self._fit: bool = True
+        self._search_query: str = ""
+        self._doc = None
+        self._open_document()
+
+    def compose(self):
+        with Horizontal(id="cct-pdf-toolbar", classes="cct-pdf-toolbar"):
+            yield Static("", id="cct-pdf-info", classes="cct-tb-pill")
+            yield Button("◀ Prev", id="cct-pdf-prev", classes="cct-ctrl")
+            yield Button("Next ▶", id="cct-pdf-next", classes="cct-ctrl")
+            yield Button("−", id="cct-pdf-zoomout", classes="cct-ctrl", tooltip="Zoom Out")
+            yield Button("+", id="cct-pdf-zoomin", classes="cct-ctrl", tooltip="Zoom In")
+            yield Button("Fit", id="cct-pdf-fit", classes="cct-ctrl", tooltip="Fit Page")
+            yield Button("100%", id="cct-pdf-reset", classes="cct-ctrl")
+            yield Input(placeholder="Search text...", id="cct-pdf-search")
+            yield Button("Open Externally", id="cct-pdf-open", classes="cct-ctrl")
+            yield Button("✕", id="cct-pdf-close", classes="cct-ctrl")
+        with VerticalScroll(id="cct-pdf-scroll"):
+            yield Static("", id="cct-pdf-display", classes="cct-pdf-display")
+
+    def on_mount(self) -> None:
+        self._open_document()
+        self._refresh_page()
+
+    def _open_document(self) -> None:
+        try:
+            import fitz
+            self._doc = fitz.open(self.path)
+            self._page_count = max(1, len(self._doc))
+        except Exception:
+            self._doc = None
+
+    def _render_page_pixmap(self, page_idx: int) -> Optional[Text]:
+        """Render a PDF page directly into truecolor terminal half-blocks."""
+        if not self._doc or page_idx < 0 or page_idx >= len(self._doc):
+            return None
+        try:
+            from PIL import Image
+            page = self._doc[page_idx]
+            # Render page at 72dpi * zoom scale factor
+            scale = 0.6 if self._fit else max(0.4, self._zoom * 0.8)
+            matrix = page.get_pixmap(matrix=getattr(self._doc, "Matrix", None) or fitz.Matrix(scale, scale))
+            im = Image.frombytes("RGB", [matrix.width, matrix.height], matrix.samples)
+
+            iw, ih = im.size
+            if self._fit:
+                target_w, target_h = 76, 44
+                im.thumbnail((target_w, target_h), getattr(Image, "LANCZOS", 1))
+            else:
+                target_w = min(200, max(20, int(iw * 0.35 * self._zoom)))
+                target_h = min(150, max(15, int(ih * 0.35 * self._zoom)))
+                im = im.resize((target_w, target_h), getattr(Image, "LANCZOS", 1))
+
+            tw, th = im.size
+            txt = Text()
+            for y in range(0, th, 2):
+                for x in range(tw):
+                    r1, g1, b1 = im.getpixel((x, y))
+                    if y + 1 < th:
+                        r2, g2, b2 = im.getpixel((x, y + 1))
+                    else:
+                        r2, g2, b2 = r1, g1, b1
+                    style = Style(color=f"#{r2:02x}{g2:02x}{b2:02x}", bgcolor=f"#{r1:02x}{g1:02x}{b1:02x}")
+                    txt.append("▄", style=style)
+                if y + 2 < th:
+                    txt.append("\n")
+            return txt
+        except Exception:
+            return None
+
+    def _refresh_page(self) -> None:
+        try:
+            info_pill = self.query_one("#cct-pdf-info", Static)
+            disp = self.query_one("#cct-pdf-display", Static)
+            base = os.path.basename(self.path)
+            zoom_label = "Fit" if self._fit else f"{int(self._zoom * 100)}%"
+            info_pill.update(f"📄 {base} · Page {self._current_page + 1}/{self._page_count} · {zoom_label}")
+
+            rendered_page = self._render_page_pixmap(self._current_page)
+            if rendered_page is not None:
+                header = Text(f"Page {self._current_page + 1} of {self._page_count}", style="bold cyan")
+                parts = [header, Text(""), rendered_page]
+                disp.update(Group(*parts))
+            else:
+                # Honest fallback if PyMuPDF cannot render this page
+                disp.update(
+                    f"[b]📄 {base} — Page {self._current_page + 1}/{self._page_count}[/b]\n\n"
+                    f"[yellow]PDF rendering engine active. Use external viewer for raw print format.[/yellow]\n"
+                    f"[dim]Path: {self.path}[/dim]"
+                )
+        except Exception:
+            pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+        if bid == "cct-pdf-close":
+            self._close_tab()
+        elif bid == "cct-pdf-prev":
+            if self._current_page > 0:
+                self._current_page -= 1
+                self._refresh_page()
+        elif bid == "cct-pdf-next":
+            if self._current_page < self._page_count - 1:
+                self._current_page += 1
+                self._refresh_page()
+        elif bid == "cct-pdf-zoomin":
+            self._fit = False
+            self._zoom = min(3.0, self._zoom * 1.25)
+            self._refresh_page()
+        elif bid == "cct-pdf-zoomout":
+            self._fit = False
+            self._zoom = max(0.4, self._zoom / 1.25)
+            self._refresh_page()
+        elif bid == "cct-pdf-fit":
+            self._fit = True
+            self._zoom = 1.0
+            self._refresh_page()
+        elif bid == "cct-pdf-reset":
+            self._fit = False
+            self._zoom = 1.0
+            self._refresh_page()
+        elif bid == "cct-pdf-open":
+            try:
+                import pathlib, webbrowser
+                webbrowser.open(pathlib.Path(self.path).as_uri())
+            except Exception:
+                pass
+
+    def on_input_submitted(self, event: Input.Submitted) -> None:
+        if event.input.id == "cct-pdf-search":
+            query = event.value.strip().lower()
+            if not query or not self._doc:
+                return
+            # Search across pages
+            for idx in range(len(self._doc)):
+                try:
+                    text = self._doc[idx].get_text().lower()
+                    if query in text:
+                        self._current_page = idx
+                        self._refresh_page()
+                        return
+                except Exception:
+                    pass
+
+    def close(self) -> None:
+        """Release underlying document file handle."""
+        if self._doc is not None:
+            try:
+                self._doc.close()
+            except Exception:
+                pass
+            self._doc = None
+
+    def _close_tab(self) -> None:
+        self.close()
+        try:
+            from ..ui.editor import EditorPane
+            node = self._parent
+            while node is not None and not isinstance(node, EditorPane):
+                node = getattr(node, "_parent", None)
+            if isinstance(node, EditorPane):
+                for p, tid in list(node._open_paths.items()):
+                    if os.path.normcase(p) == os.path.normcase(self.path):
+                        node.close_active(tid)
+                        break
+        except Exception:
+            pass

calc_terminal/viewers/presentation_viewer.py

@@ -0,0 +1,164 @@
+"""CAT Universal File Preview Engine — PPTX Presentation Viewer (calc_terminal/viewers/presentation_viewer.py).
+
+High-fidelity visual PPTX slide viewer:
+- Renders visual presentation slide cards (titles, bullet points, layout cards).
+- Parses PresentationML (ppt/slides/slide*.xml) natively via stdlib zipfile and xml.etree.ElementTree.
+- Supports slide-by-slide slideshow navigation (Prev, Next, Jump).
+"""
+
+from __future__ import annotations
+
+import os
+import re
+import xml.etree.ElementTree as ET
+import zipfile
+from typing import List, Optional
+
+TEXTUAL_AVAILABLE = True
+try:
+    from rich.console import Group
+    from rich.panel import Panel
+    from rich.text import Text
+    from textual.containers import Horizontal, Vertical, VerticalScroll
+    from textual.widgets import Button, Static
+except Exception:
+    TEXTUAL_AVAILABLE = False
+    Vertical = object  # type: ignore
+
+P_NS = "{http://schemas.openxmlformats.org/presentationml/2006/main}"
+A_NS = "{http://schemas.openxmlformats.org/drawingml/2006/main}"
+
+
+class PresentationViewer(Vertical):
+    """Visual PPTX slide viewer tab."""
+
+    def __init__(self, path: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.path = os.path.abspath(path)
+        self._current_slide: int = 0
+        self._slide_count: int = 1
+        self._slides_data: List[dict] = []
+        self._load_presentation()
+
+    @property
+    def slide_count(self) -> int:
+        return self._slide_count
+
+    def compose(self):
+        with Horizontal(id="cct-pptx-toolbar", classes="cct-pptx-toolbar"):
+            yield Static(os.path.basename(self.path), id="cct-pptx-info", classes="cct-tb-pill")
+            yield Button("◀ Prev Slide", id="cct-pptx-prev", classes="cct-ctrl")
+            yield Button("Next Slide ▶", id="cct-pptx-next", classes="cct-ctrl")
+            yield Button("Open Externally", id="cct-pptx-open", classes="cct-ctrl")
+            yield Button("✕", id="cct-pptx-close", classes="cct-ctrl")
+        with VerticalScroll(id="cct-pptx-scroll"):
+            yield Static("", id="cct-pptx-display", classes="cct-pptx-display")
+
+    def on_mount(self) -> None:
+        self._load_presentation()
+        self._refresh_slide()
+
+    def _load_presentation(self) -> None:
+        """Parse all slides from PPTX package."""
+        self._slides_data.clear()
+        if not os.path.isfile(self.path):
+            return
+        try:
+            with zipfile.ZipFile(self.path, "r") as pptx_zip:
+                slide_files = [
+                    f for f in pptx_zip.namelist()
+                    if re.match(r"ppt/slides/slide\d+\.xml", f)
+                ]
+                # Sort numerically: slide1, slide2...
+                slide_files.sort(key=lambda s: int(re.search(r"\d+", s).group(0)))
+                self._slide_count = max(1, len(slide_files))
+
+                for s_file in slide_files:
+                    xml_data = pptx_zip.read(s_file)
+                    root = ET.fromstring(xml_data)
+                    slide_info = {"title": "", "bullets": []}
+
+                    # Extract text boxes and shapes
+                    for sp in root.findall(f".//{P_NS}sp"):
+                        text_runs = []
+                        for t in sp.findall(f".//{A_NS}t"):
+                            if t.text:
+                                text_runs.append(t.text)
+                        full_text = " ".join(text_runs).strip()
+                        if full_text:
+                            if not slide_info["title"]:
+                                slide_info["title"] = full_text
+                            else:
+                                slide_info["bullets"].append(full_text)
+
+                    if not slide_info["title"] and slide_info["bullets"]:
+                        slide_info["title"] = slide_info["bullets"].pop(0)
+
+                    self._slides_data.append(slide_info)
+        except Exception:
+            pass
+
+    def _refresh_slide(self) -> None:
+        try:
+            info = self.query_one("#cct-pptx-info", Static)
+            disp = self.query_one("#cct-pptx-display", Static)
+            base = os.path.basename(self.path)
+            total = len(self._slides_data) or self._slide_count
+            info.update(f"📊 {base} · Slide {self._current_slide + 1}/{total}")
+
+            if self._slides_data and 0 <= self._current_slide < len(self._slides_data):
+                data = self._slides_data[self._current_slide]
+                title = data.get("title") or f"Slide {self._current_slide + 1}"
+                bullets = data.get("bullets", [])
+
+                body_lines = []
+                body_lines.append(Text(f"📌 {title}", style="bold yellow"))
+                body_lines.append(Text(""))
+                for b in bullets:
+                    body_lines.append(Text(f"  • {b}", style="white"))
+
+                panel = Panel(
+                    Group(*body_lines),
+                    title=f"[bold green]Slide {self._current_slide + 1} / {total}[/bold green]",
+                    border_style="yellow",
+                    padding=(2, 4),
+                )
+                disp.update(panel)
+            else:
+                disp.update(f"[b]📊 {base}[/b]\n[dim]Slide {self._current_slide + 1} / {total}[/dim]")
+        except Exception:
+            pass
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+        if bid == "cct-pptx-close":
+            self._close_tab()
+        elif bid == "cct-pptx-prev":
+            if self._current_slide > 0:
+                self._current_slide -= 1
+                self._refresh_slide()
+        elif bid == "cct-pptx-next":
+            total = len(self._slides_data) or self._slide_count
+            if self._current_slide < total - 1:
+                self._current_slide += 1
+                self._refresh_slide()
+        elif bid == "cct-pptx-open":
+            try:
+                import pathlib, webbrowser
+                webbrowser.open(pathlib.Path(self.path).as_uri())
+            except Exception:
+                pass
+
+    def _close_tab(self) -> None:
+        try:
+            from ..ui.editor import EditorPane
+            node = self._parent
+            while node is not None and not isinstance(node, EditorPane):
+                node = getattr(node, "_parent", None)
+            if isinstance(node, EditorPane):
+                for p, tid in list(node._open_paths.items()):
+                    if os.path.normcase(p) == os.path.normcase(self.path):
+                        node.close_active(tid)
+                        break
+        except Exception:
+            pass

calc_terminal/viewers/registry.py

@@ -0,0 +1,120 @@
+"""CAT Universal File Preview Engine — Viewer Registry (calc_terminal/viewers/registry.py).
+
+Centralized file-type detector and viewer provider registry:
+- Prevents files from being inappropriately opened as raw extracted text.
+- Dispatches each file to its dedicated high-fidelity visual viewer.
+- Extensible: plugins and extensions can register custom viewer providers.
+"""
+
+from __future__ import annotations
+
+import os
+from typing import Any, Callable, Dict, List, Optional, Set
+
+
+class ViewerProvider:
+    """Interface for a file preview/viewer provider."""
+
+    def __init__(self, id: str, name: str, extensions: Set[str],
+                 factory: Optional[Callable[[str, Any], Any]] = None) -> None:
+        self.id = id
+        self.name = name
+        self.extensions = {ext.lower() if ext.startswith(".") else f".{ext.lower()}" for ext in extensions}
+        self.factory = factory
+
+    def can_open(self, file_path: str) -> bool:
+        ext = os.path.splitext(str(file_path).lower())[1]
+        return ext in self.extensions
+
+    def create_viewer(self, file_path: str, **kwargs) -> Any:
+        if self.factory is not None:
+            return self.factory(file_path, **kwargs)
+        raise NotImplementedError(f"Provider {self.id} has no factory implementation.")
+
+
+class ViewerRegistry:
+    """Registry coordinating all visual file viewers."""
+
+    def __init__(self) -> None:
+        self._providers: Dict[str, ViewerProvider] = {}
+        self._register_builtins()
+
+    def register(self, provider: ViewerProvider) -> None:
+        """Register a new viewer provider."""
+        self._providers[provider.id] = provider
+
+    def unregister(self, provider_id: str) -> None:
+        """Unregister a viewer provider."""
+        self._providers.pop(provider_id, None)
+
+    def get_provider(self, provider_id: str) -> Optional[ViewerProvider]:
+        return self._providers.get(provider_id)
+
+    def get_provider_for_file(self, file_path: str) -> Optional[ViewerProvider]:
+        """Find the registered viewer provider capable of opening this file."""
+        ext = os.path.splitext(str(file_path).lower())[1]
+        for p in self._providers.values():
+            if p.can_open(file_path):
+                return p
+        return None
+
+    def can_open_visually(self, file_path: str) -> bool:
+        """Return True if a specialized visual viewer exists for this file."""
+        p = self.get_provider_for_file(file_path)
+        return p is not None and p.id != "code"
+
+    def create_viewer_for_file(self, file_path: str, **kwargs) -> Optional[Any]:
+        """Create the appropriate viewer widget for the given file."""
+        provider = self.get_provider_for_file(file_path)
+        if provider:
+            return provider.create_viewer(file_path, **kwargs)
+        return None
+
+    def _register_builtins(self) -> None:
+        """Register default visual providers: image, pdf, docx, pptx, xlsx, csv."""
+        # 1. Images
+        image_exts = {".png", ".jpg", ".jpeg", ".webp", ".gif", ".svg", ".bmp", ".ico", ".tiff"}
+        def _image_factory(path, **kwargs):
+            from .image_viewer import ImageViewer
+            return ImageViewer(path, **kwargs)
+        self.register(ViewerProvider("image", "Image Viewer", image_exts, _image_factory))
+
+        # 2. PDF
+        pdf_exts = {".pdf"}
+        def _pdf_factory(path, **kwargs):
+            from .pdf_viewer import PdfViewer
+            return PdfViewer(path, **kwargs)
+        self.register(ViewerProvider("pdf", "PDF Document Viewer", pdf_exts, _pdf_factory))
+
+        # 3. DOCX Document
+        docx_exts = {".docx"}
+        def _docx_factory(path, **kwargs):
+            from .document_viewer import DocumentViewer
+            return DocumentViewer(path, **kwargs)
+        self.register(ViewerProvider("document", "DOCX Document Viewer", docx_exts, _docx_factory))
+
+        # 4. PPTX Presentation
+        pptx_exts = {".pptx"}
+        def _pptx_factory(path, **kwargs):
+            from .presentation_viewer import PresentationViewer
+            return PresentationViewer(path, **kwargs)
+        self.register(ViewerProvider("presentation", "Presentation Slide Viewer", pptx_exts, _pptx_factory))
+
+        # 5. Spreadsheets (XLSX, CSV)
+        sheet_exts = {".xlsx", ".csv"}
+        def _sheet_factory(path, **kwargs):
+            from .spreadsheet_viewer import SpreadsheetViewer
+            return SpreadsheetViewer(path, **kwargs)
+        self.register(ViewerProvider("spreadsheet", "Spreadsheet Grid Viewer", sheet_exts, _sheet_factory))
+
+
+# Global singleton registry
+_GLOBAL_VIEWER_REGISTRY: Optional[ViewerRegistry] = None
+
+
+def get_viewer_registry() -> ViewerRegistry:
+    """Return the global ViewerRegistry singleton."""
+    global _GLOBAL_VIEWER_REGISTRY
+    if _GLOBAL_VIEWER_REGISTRY is None:
+        _GLOBAL_VIEWER_REGISTRY = ViewerRegistry()
+    return _GLOBAL_VIEWER_REGISTRY

calc_terminal/viewers/spreadsheet_viewer.py

@@ -0,0 +1,204 @@
+"""CAT Universal File Preview Engine — Spreadsheet Viewer (calc_terminal/viewers/spreadsheet_viewer.py).
+
+High-fidelity visual spreadsheet grid viewer:
+- Supports XLSX and CSV.
+- Displays visual interactive grid table using Textual's DataTable.
+- Parses XLSX multi-sheet workbooks natively via stdlib zipfile and xml.etree.ElementTree.
+- Supports sheet selection, column headers, and search filtering.
+"""
+
+from __future__ import annotations
+
+import csv
+import os
+import re
+import xml.etree.ElementTree as ET
+import zipfile
+from typing import Dict, List, Optional
+
+TEXTUAL_AVAILABLE = True
+try:
+    from textual.containers import Horizontal, Vertical
+    from textual.widgets import Button, DataTable, Input, Static
+except Exception:
+    TEXTUAL_AVAILABLE = False
+    Vertical = object  # type: ignore
+
+S_NS = "{http://schemas.openxmlformats.org/spreadsheetml/2006/main}"
+
+
+class SpreadsheetViewer(Vertical):
+    """Visual spreadsheet table viewer for XLSX and CSV."""
+
+    def __init__(self, path: str, **kwargs) -> None:
+        super().__init__(**kwargs)
+        self.path = os.path.abspath(path)
+        self._sheets: Dict[str, List[List[str]]] = {}
+        self._sheet_names: List[str] = []
+        self._active_sheet_idx: int = 0
+        self._load_data()
+
+    def compose(self):
+        with Horizontal(id="cct-sheet-toolbar", classes="cct-sheet-toolbar"):
+            yield Static(os.path.basename(self.path), id="cct-sheet-info", classes="cct-tb-pill")
+            yield Input(placeholder="Filter rows...", id="cct-sheet-filter")
+            yield Button("Open Externally", id="cct-sheet-open", classes="cct-ctrl")
+            yield Button("✕", id="cct-sheet-close", classes="cct-ctrl")
+        yield Horizontal(id="cct-sheet-tabs-strip", classes="cct-sheet-tabs-strip")
+        try:
+            yield DataTable(id="cct-sheet-datatable")
+        except Exception:
+            yield Static("DataTable unavailable", id="cct-sheet-fallback")
+
+    def on_mount(self) -> None:
+        self._load_data()
+        self._populate_table()
+
+    def _load_data(self) -> None:
+        """Load either XLSX sheets or CSV rows."""
+        self._sheets.clear()
+        self._sheet_names.clear()
+        if not os.path.isfile(self.path):
+            return
+
+        ext = os.path.splitext(self.path)[1].lower()
+        if ext == ".csv":
+            try:
+                with open(self.path, "r", encoding="utf-8", errors="replace", newline="") as f:
+                    reader = csv.reader(f)
+                    rows = [r for r in list(reader)[:500]]
+                self._sheets["Sheet1"] = rows
+                self._sheet_names = ["Sheet1"]
+            except Exception:
+                pass
+        elif ext in (".xlsx", ".xlsm"):
+            self._load_xlsx()
+
+    def _load_xlsx(self) -> None:
+        """Parse XLSX workbook, shared strings, and worksheets."""
+        try:
+            with zipfile.ZipFile(self.path, "r") as z:
+                # 1. Shared strings table
+                shared_strings = []
+                if "xl/sharedStrings.xml" in z.namelist():
+                    root_ss = ET.fromstring(z.read("xl/sharedStrings.xml"))
+                    for si in root_ss.findall(f"{S_NS}si"):
+                        t = si.find(f"{S_NS}t")
+                        if t is not None and t.text:
+                            shared_strings.append(t.text)
+                        else:
+                            # Rich text runs
+                            text_runs = [r_t.text or "" for r_t in si.findall(f".//{S_NS}t")]
+                            shared_strings.append("".join(text_runs))
+
+                # 2. Workbook sheet names
+                sheet_map = []
+                if "xl/workbook.xml" in z.namelist():
+                    wb_root = ET.fromstring(z.read("xl/workbook.xml"))
+                    sheets_elem = wb_root.find(f"{S_NS}sheets")
+                    if sheets_elem is not None:
+                        for s in sheets_elem.findall(f"{S_NS}sheet"):
+                            name = s.get("name", "Sheet")
+                            sheet_id = s.get("sheetId", "1")
+                            sheet_map.append((name, sheet_id))
+
+                # Fallback if sheet map missing
+                if not sheet_map:
+                    sheet_files = [f for f in z.namelist() if re.match(r"xl/worksheets/sheet\d+\.xml", f)]
+                    sheet_map = [(f"Sheet{i+1}", str(i+1)) for i in range(len(sheet_files))]
+
+                for name, s_id in sheet_map:
+                    sheet_filename = f"xl/worksheets/sheet{s_id}.xml"
+                    if sheet_filename not in z.namelist():
+                        candidates = [f for f in z.namelist() if f.startswith("xl/worksheets/sheet")]
+                        if candidates:
+                            sheet_filename = candidates[0]
+                        else:
+                            continue
+
+                    sheet_root = ET.fromstring(z.read(sheet_filename))
+                    sheet_data = sheet_root.find(f"{S_NS}sheetData")
+                    rows = []
+                    if sheet_data is not None:
+                        for row_elem in sheet_data.findall(f"{S_NS}row")[:500]:
+                            row_cells = []
+                            for c in row_elem.findall(f"{S_NS}c"):
+                                cell_type = c.get("t")
+                                val_elem = c.find(f"{S_NS}v")
+                                val = val_elem.text if val_elem is not None else ""
+                                if cell_type == "s" and val.isdigit():
+                                    idx = int(val)
+                                    val = shared_strings[idx] if idx < len(shared_strings) else val
+                                row_cells.append(str(val))
+                            rows.append(row_cells)
+
+                    self._sheets[name] = rows
+                    self._sheet_names.append(name)
+        except Exception:
+            pass
+
+    def _populate_table(self, filter_text: str = "") -> None:
+        """Render rows into Textual DataTable."""
+        try:
+            table = self.query_one("#cct-sheet-datatable", DataTable)
+            table.clear(columns=True)
+
+            sheet_name = self._sheet_names[self._active_sheet_idx] if self._sheet_names else "Sheet1"
+            rows = self._sheets.get(sheet_name, [])
+
+            # Filter if requested
+            if filter_text:
+                q = filter_text.lower()
+                rows = [r for r in rows if any(q in str(cell).lower() for cell in r)]
+
+            if not rows:
+                table.add_column("Notice")
+                table.add_row("No matching data found.")
+                return
+
+            max_cols = max(len(r) for r in rows)
+            # Default headers A, B, C...
+            for col_idx in range(max_cols):
+                header = chr(65 + col_idx) if col_idx < 26 else f"Col{col_idx+1}"
+                table.add_column(header)
+
+            for r_idx, row in enumerate(rows):
+                padded = row + [""] * (max_cols - len(row))
+                table.add_row(*padded[:max_cols], label=str(r_idx + 1))
+
+            # Update info pill
+            total_rows = len(self._sheets.get(sheet_name, []))
+            info = self.query_one("#cct-sheet-info", Static)
+            base = os.path.basename(self.path)
+            info.update(f"📊 {base} · {sheet_name} ({total_rows} rows)")
+        except Exception:
+            pass
+
+    def on_input_changed(self, event: Input.Changed) -> None:
+        if event.input.id == "cct-sheet-filter":
+            self._populate_table(event.value.strip())
+
+    def on_button_pressed(self, event: Button.Pressed) -> None:
+        bid = event.button.id
+        if bid == "cct-sheet-close":
+            self._close_tab()
+        elif bid == "cct-sheet-open":
+            try:
+                import pathlib, webbrowser
+                webbrowser.open(pathlib.Path(self.path).as_uri())
+            except Exception:
+                pass
+
+    def _close_tab(self) -> None:
+        try:
+            from ..ui.editor import EditorPane
+            node = self._parent
+            while node is not None and not isinstance(node, EditorPane):
+                node = getattr(node, "_parent", None)
+            if isinstance(node, EditorPane):
+                for p, tid in list(node._open_paths.items()):
+                    if os.path.normcase(p) == os.path.normcase(self.path):
+                        node.close_active(tid)
+                        break
+        except Exception:
+            pass