feat(preview): Excel-Vorschau für .xlsx/.xls (read-only, Blatt-Auswahl, Fallback)

lukisch · claude · lukisch · commit e44130932a1c · 2026-06-28T08:51:28.000+02:00
- src/core/xlsx_reader.py: Qt-freier Pure-Logic-Reader; read_workbook_meta
  (Blattnamen ohne Zelllast) + read_workbook_sheet (≤100×50 via iter_rows).
  openpyxl/xlrd per Import-Guard; fehlende Lib → WorkbookMeta.error statt Crash.
- ExcelPreview-Widget in preview_panel.py: QComboBox für Blatt-Auswahl,
  QTableWidget (read-only), Statuszeile + „Extern öffnen" als Fallback.
- PreviewPanel._show_preview_for_path: .xlsx/.xls → Stack-Index 6.
- tests/test_xlsx_preview.py: 15 Tests (Pure-Logic + GUI); 145/145 grün.

Co-Authored-By: Claude Opus 4.8 (1M context) &lt;noreply@anthropic.com&gt;
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -6,6 +6,11 @@ Format basiert auf [Keep a Changelog](https://keepachangelog.com/de/1.1.0/).
 ## [Unreleased]
 
 ### Hinzugefügt / Added
+- **Excel-Vorschau** (`.xlsx` / `.xls`, read-only) im Vorschau-Panel:
+  - `src/core/xlsx_reader.py`: Qt-freier Pure-Logic-Reader mit `read_workbook_meta` (Blattnamen) und `read_workbook_sheet` (erste ≤ 100 Zeilen × 50 Spalten). openpyxl via Import-Guard; fehlende Lib oder Lesefehler → typisierte Fehlerobjekte, kein Crash. `.xls` via xlrd-Guard (optional).
+  - `ExcelPreview`-Widget in `src/gui/preview/preview_panel.py`: Arbeitsblatt-Dropdown (QComboBox), Datentabelle (QTableWidget, read-only), Statuszeile + „Extern öffnen"-Schaltfläche als Fallback.
+  - `PreviewPanel._show_preview_for_path` leitet `.xlsx`/`.xls` jetzt an `ExcelPreview` weiter (Stack-Index 6).
+  - `tests/test_xlsx_preview.py`: 15 neue Tests — Blattnamen (Single/Multi), erste Zeilen/Spalten, leeres Blatt, Zeilen-Limit, Fallback bei korrupter Datei und fehlendem openpyxl, GUI-Integration. Gesamtsuite 145/145 grün.
 - **Erweitertes Syntax-Highlighting** (`src/modules/editor/syntax_highlighter.py`): 5 neue Highlighter-Klassen für bisher nicht unterstützte Coding-Dateitypen.
   - `YAMLHighlighter` für `.yaml` / `.yml` (Dokument-Marker, Keys, Anchors/Aliases, Strings, Zahlen, Booleans, Tags, Kommentare)
   - `ShellHighlighter` für `.sh` / `.bash` / `.zsh` / `.fish` (Shebang, Keywords, Variablen, Strings, Kommentare)
diff --git a/src/core/xlsx_reader.py b/src/core/xlsx_reader.py
@@ -0,0 +1,149 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+xlsx_reader.py — Read-only-Zugriff auf Excel-Tabellen (.xlsx / .xls)
+
+Keine Qt-Abhängigkeiten; vollständig ohne GUI testbar.
+Gibt bei Leseproblemen klar typisierte Fehlerobjekte zurück (kein Crash).
+"""
+from __future__ import annotations
+
+import os
+from dataclasses import dataclass, field
+from typing import Any
+
+# Optionale Imports — fehlendes Paket führt zum Fallback, nicht zum Abbruch
+try:
+    import openpyxl
+    HAS_OPENPYXL = True
+except ImportError:
+    openpyxl = None  # type: ignore[assignment]
+    HAS_OPENPYXL = False
+
+try:
+    import xlrd
+    HAS_XLRD = True
+except ImportError:
+    xlrd = None  # type: ignore[assignment]
+    HAS_XLRD = False
+
+
+# Maximale Zeilen/Spalten für die Vorschau
+MAX_ROWS: int = 100
+MAX_COLS: int = 50
+
+
+class XlsxReadError(Exception):
+    """Wird geworfen, wenn die Datei nicht gelesen werden kann."""
+
+
+@dataclass
+class WorkbookMeta:
+    """Ergebnis des Metadaten-Lesevorgangs (Blattnamen, kein Zelleninhalt)."""
+    sheets: list[str]
+    active_sheet: str
+    error: str | None = None
+
+
+def read_workbook_meta(path: str) -> WorkbookMeta:
+    """
+    Liest nur die Arbeitsblatt-Namen einer Excel-Datei.
+    Lädt keine Zellinhalte — sehr schnell, auch bei großen Dateien.
+    Gibt bei Fehler ein WorkbookMeta mit gesetztem `error`-Feld zurück.
+    """
+    ext = os.path.splitext(path)[1].lower()
+
+    if ext == ".xls":
+        return _read_xls_meta(path)
+
+    if not HAS_OPENPYXL:
+        return WorkbookMeta(sheets=[], active_sheet="", error="openpyxl nicht installiert")
+
+    try:
+        wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
+        try:
+            sheets = list(wb.sheetnames)
+            active = sheets[0] if sheets else ""
+            return WorkbookMeta(sheets=sheets, active_sheet=active)
+        finally:
+            wb.close()
+    except Exception as exc:
+        return WorkbookMeta(sheets=[], active_sheet="", error=str(exc))
+
+
+def read_workbook_sheet(
+    path: str,
+    sheet_name: str,
+    max_rows: int = MAX_ROWS,
+    max_cols: int = MAX_COLS,
+) -> list[list[Any]]:
+    """
+    Liest ein einzelnes Arbeitsblatt und gibt die Zellen als Zeilenliste zurück.
+    Maximal `max_rows` Zeilen und `max_cols` Spalten werden geladen.
+    Bei Fehler wird XlsxReadError geworfen.
+    """
+    ext = os.path.splitext(path)[1].lower()
+
+    if ext == ".xls":
+        return _read_xls_sheet(path, sheet_name, max_rows, max_cols)
+
+    if not HAS_OPENPYXL:
+        raise XlsxReadError("openpyxl nicht installiert")
+
+    try:
+        wb = openpyxl.load_workbook(path, read_only=True, data_only=True)
+        try:
+            ws = wb[sheet_name]
+            rows: list[list[Any]] = []
+            for row_tuple in ws.iter_rows(
+                max_row=max_rows, max_col=max_cols, values_only=True
+            ):
+                rows.append(list(row_tuple))
+                if len(rows) >= max_rows:
+                    break
+            return rows
+        finally:
+            wb.close()
+    except XlsxReadError:
+        raise
+    except Exception as exc:
+        raise XlsxReadError(f"Lesefehler: {exc}") from exc
+
+
+# ── .xls-Fallback (xlrd) ────────────────────────────────────────────────────
+
+def _read_xls_meta(path: str) -> WorkbookMeta:
+    if not HAS_XLRD:
+        return WorkbookMeta(
+            sheets=[], active_sheet="",
+            error=".xls-Vorschau benötigt xlrd (nicht installiert)"
+        )
+    try:
+        wb = xlrd.open_workbook(path)
+        sheets = wb.sheet_names()
+        active = sheets[0] if sheets else ""
+        return WorkbookMeta(sheets=list(sheets), active_sheet=active)
+    except Exception as exc:
+        return WorkbookMeta(sheets=[], active_sheet="", error=str(exc))
+
+
+def _read_xls_sheet(
+    path: str,
+    sheet_name: str,
+    max_rows: int,
+    max_cols: int,
+) -> list[list[Any]]:
+    if not HAS_XLRD:
+        raise XlsxReadError(".xls-Vorschau benötigt xlrd (nicht installiert)")
+    try:
+        wb = xlrd.open_workbook(path)
+        ws = wb.sheet_by_name(sheet_name)
+        rows: list[list[Any]] = []
+        for r in range(min(ws.nrows, max_rows)):
+            row = [ws.cell_value(r, c) for c in range(min(ws.ncols, max_cols))]
+            rows.append(row)
+        return rows
+    except XlsxReadError:
+        raise
+    except Exception as exc:
+        raise XlsxReadError(f"Lesefehler .xls: {exc}") from exc
diff --git a/src/gui/preview/preview_panel.py b/src/gui/preview/preview_panel.py
@@ -5,9 +5,10 @@
 """
 
 from PySide6.QtWidgets import (
-    QWidget, QVBoxLayout, QStackedWidget,
+    QWidget, QVBoxLayout, QHBoxLayout, QStackedWidget,
     QLabel, QScrollArea, QGroupBox, QFormLayout, QLineEdit,
-    QPlainTextEdit, QFrame
+    QPlainTextEdit, QFrame,
+    QComboBox, QPushButton, QTableWidget, QTableWidgetItem,
 )
 from PySide6.QtCore import Qt
 from PySide6.QtGui import QPixmap, QImage, QFont, QSyntaxHighlighter, QTextCharFormat, QColor
@@ -316,6 +317,134 @@ def show_metadata(self, path: str):
         self.created_label.setText(created.strftime("%d.%m.%Y %H:%M"))
 
 
+class ExcelPreview(QWidget):
+    """Read-only-Vorschau für .xlsx- und .xls-Dateien.
+
+    Zeigt eine Arbeitsblatt-Auswahl (Dropdown) und die ersten Zeilen/Spalten
+    in einer Tabelle. Bei fehlender Bibliothek oder Lesefehler erscheint
+    ein klar beschrifteter Fallback mit „Extern öffnen"-Schaltfläche.
+    """
+
+    def __init__(self, parent=None):
+        super().__init__(parent)
+        self._path: str | None = None
+        self._setup_ui()
+
+    def _setup_ui(self):
+        layout = QVBoxLayout(self)
+        layout.setContentsMargins(4, 4, 4, 4)
+
+        # Kopfzeile: Arbeitsblatt-Auswahl
+        header = QHBoxLayout()
+        header.addWidget(QLabel("Arbeitsblatt:"))
+
+        self.sheet_combo = QComboBox()
+        self.sheet_combo.setMinimumWidth(120)
+        self.sheet_combo.currentTextChanged.connect(self._on_sheet_changed)
+        header.addWidget(self.sheet_combo, 1)
+
+        self.open_extern_btn = QPushButton("Extern öffnen")
+        self.open_extern_btn.setVisible(False)
+        self.open_extern_btn.clicked.connect(self._open_extern)
+        header.addWidget(self.open_extern_btn)
+
+        layout.addLayout(header)
+
+        # Statuszeile (Fehler / Fallback-Hinweis)
+        self.status_label = QLabel()
+        self.status_label.setWordWrap(True)
+        self.status_label.setVisible(False)
+        layout.addWidget(self.status_label)
+
+        # Datentabelle
+        self.table = QTableWidget()
+        self.table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)
+        self.table.setAlternatingRowColors(True)
+        layout.addWidget(self.table, 1)
+
+    def load_file(self, path: str):
+        """Lädt eine Excel-Datei und zeigt das erste Arbeitsblatt an."""
+        from core.xlsx_reader import read_workbook_meta
+
+        self._path = path
+        self.sheet_combo.blockSignals(True)
+        self.sheet_combo.clear()
+
+        meta = read_workbook_meta(path)
+        if meta.error:
+            self._show_fallback(meta.error)
+            self.sheet_combo.blockSignals(False)
+            return
+
+        self.sheet_combo.addItems(meta.sheets)
+        self.sheet_combo.blockSignals(False)
+        self.status_label.setVisible(False)
+        self.open_extern_btn.setVisible(False)
+
+        if meta.active_sheet:
+            self._load_sheet(meta.active_sheet)
+
+    def _on_sheet_changed(self, sheet_name: str):
+        if sheet_name:
+            self._load_sheet(sheet_name)
+
+    def _load_sheet(self, sheet_name: str):
+        """Füllt die Tabelle mit den Zellinhalten des gewählten Arbeitsblatts."""
+        from core.xlsx_reader import read_workbook_sheet, XlsxReadError
+
+        if not self._path:
+            return
+
+        try:
+            rows = read_workbook_sheet(self._path, sheet_name)
+        except XlsxReadError as exc:
+            self._show_fallback(str(exc))
+            return
+
+        if not rows:
+            self.table.setRowCount(0)
+            self.table.setColumnCount(0)
+            return
+
+        col_count = max(len(r) for r in rows)
+        self.table.setRowCount(len(rows))
+        self.table.setColumnCount(col_count)
+
+        # Erste Zeile als Spaltenköpfe
+        header_row = rows[0]
+        self.table.setHorizontalHeaderLabels(
+            [str(v) if v is not None else "" for v in header_row]
+        )
+
+        for r_idx, row in enumerate(rows):
+            for c_idx, val in enumerate(row):
+                item = QTableWidgetItem(str(val) if val is not None else "")
+                self.table.setItem(r_idx, c_idx, item)
+
+    def _show_fallback(self, reason: str):
+        self.table.setRowCount(0)
+        self.table.setColumnCount(0)
+        self.status_label.setText(
+            f"Vorschau nicht verfügbar: {reason}\n→ Datei extern öffnen"
+        )
+        self.status_label.setVisible(True)
+        self.open_extern_btn.setVisible(True)
+
+    def _open_extern(self):
+        """Öffnet die Datei mit der systemseitig zugeordneten Anwendung."""
+        if not self._path:
+            return
+        import subprocess
+        import sys as _sys
+
+        if _sys.platform == "win32":
+            os.startfile(self._path)  # type: ignore[attr-defined]
+        elif _sys.platform == "darwin":
+            subprocess.Popen(["open", self._path])
+        else:
+            subprocess.Popen(["xdg-open", self._path])
+
+
 class PreviewPanel(QWidget):
     """
     Haupt-Vorschau-Panel mit:
@@ -362,6 +491,10 @@ def _setup_ui(self):
         self.unsupported_label = QLabel("Vorschau nicht verfügbar\nfür diesen Dateityp")
         self.unsupported_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
         self.preview_stack.addWidget(self.unsupported_label)
+
+        # Excel-Vorschau (.xlsx / .xls) — Index 6
+        self.excel_preview = ExcelPreview()
+        self.preview_stack.addWidget(self.excel_preview)
         
         layout.addWidget(self.preview_stack, 2)
         
@@ -433,7 +566,12 @@ def _show_preview_for_path(self, path: str, heading: str | None = None):
         elif ext == '.pdf':
             self.pdf_preview.load_pdf(path)
             self.preview_stack.setCurrentIndex(3)
-        
+
+        # Excel-Vorschau
+        elif ext in ['.xlsx', '.xls']:
+            self.excel_preview.load_file(path)
+            self.preview_stack.setCurrentIndex(6)
+
         # Nicht unterstützt
         else:
             self.preview_stack.setCurrentIndex(5)
diff --git a/tests/test_xlsx_preview.py b/tests/test_xlsx_preview.py
