Basic Office Suite (Productivity)

A lightweight, free starter suite for everyday work — spreadsheets, documents, presentations, and PDFs. Built by CheapITSupport.com.

Download Bundle (Windows) ← Back to Home

Bundle Version 1.0.0 Updated Dec 24, 2025 Size 11MB No tracking • Offline-friendly

What’s included

▦

Sheets

Spreadsheet tool with Excel-like feel

Open/Save CSV and XLSX
Formatting, sort/filter, find/replace
Keyboard-friendly workflow

Download Sheets

Version 1.0.0 Size —

✎

Words

Document editor for drafts, notes, and exports

Rich text styles + page layout controls
Insert images, quick date/time
Export as PDF

Download Words

Version 1.0.0 Size —

▭

Slides

Presentation builder for quick decks

Drag/edit elements (text, images, tables)
PowerPoint export (when python-pptx available)
Simple “Office-like” styling

Download Slides

Version 1.0.0 Size —

PDF

PDF Tool

View + annotate PDFs (highlights, notes, draw)

Highlight, add notes, free-text, pen draw
Export page to PNG
Optional: register as “Open with” on Windows

Download PDF Tool

Version 1.0.0 Size —

Why you’ll like it

Fast & simple

Quick launch, familiar controls, no subscriptions.

Offline-friendly

Designed to be useful without accounts or internet.

Portable

Run standalone, or keep them in a tools folder. Bundle download available.

Open by default

Source code is viewable on this page (paste it into the modal blocks).

How it works

Download the bundle

Grab the ZIP and run the app you need (Sheets / Words / Slides / PDF Tool).

Use it like Office

Each app is focused and familiar—no clutter, just the basics done well.

Optional: view source

Click “View Source” for any tool and paste the code in the hidden blocks below.

FAQ

Is this really free?

Yes. No subscriptions and no sign-in required.

Does it work offline?

Yes—built to be useful without internet access.

Do I need admin rights?

No for basic use. Some optional Windows integrations (like “Open with”) may require permissions depending on your system.

Where do settings save?

Typically under your user profile/app data (varies by tool). Delete the app folder/settings to reset.

Download options

Bundle (ZIP)

Individual downloads

Prefer single tools? Use the buttons in “What’s included.”

Version 1.0.0 Updated 2025-12-24 Size —

System requirements

Windows 10 or later
~200 MB free space
No account required

Tip

Want the “Pro” bundle?

Add-ons like AV, MDR/EDR, and enterprise backups are COMING SOON, check back often!

Visit CheapITSupport.com

Want more free utilities? Browse the tools on the home page.

import os, sys, threading, hashlib, time, subprocess, urllib.request
from urllib.parse import urlparse
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
APP_TITLE = "Office Suite (Productivity) — CheapITSupport.com"
PUBLISHER = "Sean@CheapITSupport.com"
APPS = [
 {
 "key": "sheets",
 "name": "Sheets",
 "filename": "Sheets.exe",
 "url": "https://cheapitsupport.com/static/uploads/Sheets.exe",
 "sha256": "",
 "description": "Spreadsheet tool",
 },
 {
 "key": "words",
 "name": "Words",
 "filename": "Words.exe",
 "url": "https://cheapitsupport.com/static/uploads/Words.exe",
 "sha256": "",
 "description": "Document editor",
 },
 {
 "key": "slides",
 "name": "Slides",
 "filename": "Slides.exe",
 "url": "https://cheapitsupport.com/static/uploads/Slides.exe",
 "sha256": "",
 "description": "Presentation builder",
 },
 {
 "key": "pdf",
 "name": "PDF Tool",
 "filename": "PDF_Tool.exe",
 "url": "https://cheapitsupport.com/static/uploads/PDF_Tool.exe",
 "sha256": "",
 "description": "PDF viewer/annotator",
 },
]
DEFAULT_INSTALL_DIR = os.path.join(
 os.path.join(os.environ.get("USERPROFILE", os.path.expanduser("~")), "Desktop"),
 "OfficeSuite by CheapITSupport.com",
)
USER_AGENT = "OfficeSuiteInstaller/1.0 (+https://cheapitsupport.com)"
CONNECT_TIMEOUT_SECONDS = 25
class ScrollableFrame(ttk.Frame):
 def __init__(self, parent, *args, **kwargs):
 super().__init__(parent, *args, **kwargs)
 self.canvas = tk.Canvas(self, highlightthickness=0)
 self.vsb = ttk.Scrollbar(self, orient="vertical", command=self.canvas.yview)
 self.canvas.configure(yscrollcommand=self.vsb.set)
 self.inner = ttk.Frame(self.canvas)
 self.inner_id = self.canvas.create_window((0, 0), window=self.inner, anchor="nw")
 self.canvas.pack(side="left", fill="both", expand=True)
 self.vsb.pack(side="right", fill="y")
 self.inner.bind("<Configure>", self._on_inner_configure)
 self.canvas.bind("<Configure>", self._on_canvas_configure)
 self.canvas.bind_all("<MouseWheel>", self._on_mousewheel)
 def _on_inner_configure(self, event=None):
 self.canvas.configure(scrollregion=self.canvas.bbox("all"))
 def _on_canvas_configure(self, event):
 self.canvas.itemconfig(self.inner_id, width=event.width)
 def _on_mousewheel(self, event):
 if event.delta:
 self.canvas.yview_scroll(int(-1 * (event.delta / 120)), "units")
def _is_https_url(u: str) -> bool:
 try:
 p = urlparse(u.strip())
 return p.scheme.lower() == "https" and bool(p.netloc)
 except Exception:
 return False
def _sha256_file(path: str) -> str:
 h = hashlib.sha256()
 with open(path, "rb") as f:
 for chunk in iter(lambda: f.read(1024 * 1024), b""):
 h.update(chunk)
 return h.hexdigest()
class InstallerApp(tk.Tk):
 def __init__(self):
 super().__init__()
 self.title(APP_TITLE)
 self.geometry("860x560")
 self.minsize(820, 520)
 self.install_dir = tk.StringVar(value=DEFAULT_INSTALL_DIR)
 self.status = tk.StringVar(value="Ready.")
 self.busy = False
 self.rows = {}
 self._build_ui()
 bad = [a["name"] for a in APPS if not _is_https_url(a["url"])]
 if bad:
 self.after(
 250,
 lambda: messagebox.showwarning(
 "URL Warning",
 "These apps do not use an https:// URL (recommended):\n\n- "
 + "\n- ".join(bad)
 + "\n\nYou can still proceed, but HTTPS is strongly recommended.",
 ),
 )
 def _build_ui(self):
 style = ttk.Style()
 try:
 style.theme_use("clam")
 except Exception:
 pass
 root = ttk.Frame(self, padding=14)
 root.pack(fill="both", expand=True)
 header = ttk.Frame(root)
 header.pack(fill="x")
 ttk.Label(
 header,
 text="Office Suite (Productivity)",
 font=("Segoe UI", 18, "bold"),
 ).pack(anchor="w")
 ttk.Label(
 header,
 text=f"Installer / Launcher — {PUBLISHER}",
 font=("Segoe UI", 10),
 foreground="#666",
 ).pack(anchor="w", pady=(2, 10))
 loc = ttk.LabelFrame(root, text="Install Location", padding=(12, 10))
 loc.pack(fill="x", pady=(0, 12))
 row = ttk.Frame(loc)
 row.pack(fill="x")
 ttk.Entry(row, textvariable=self.install_dir).pack(side="left", fill="x", expand=True)
 ttk.Button(row, text="Browse…", command=self._browse_install_dir).pack(side="left", padx=(10, 0))
 ttk.Label(
 loc,
 text="Tip: This installs per-user (no admin required) unless you choose a protected folder.",
 foreground="#666",
 ).pack(anchor="w", pady=(6, 0))
 apps_frame = ttk.LabelFrame(root, text="Apps", padding=(10, 10))
 apps_frame.pack(fill="both", expand=True)
 cols = ttk.Frame(apps_frame)
 cols.pack(fill="x")
 ttk.Label(cols, text="Tool", width=22, font=("Segoe UI", 10, "bold")).grid(row=0, column=0, sticky="w")
 ttk.Label(cols, text="Status", width=40, font=("Segoe UI", 10, "bold")).grid(row=0, column=1, sticky="w")
 ttk.Label(cols, text="Actions", font=("Segoe UI", 10, "bold")).grid(row=0, column=2, sticky="w")
 sep = ttk.Separator(apps_frame, orient="horizontal")
 sep.pack(fill="x", pady=8)
 scroll = ScrollableFrame(apps_frame)
 scroll.pack(fill="both", expand=True)
 grid = scroll.inner
 for r, app in enumerate(APPS):
 key = app["key"]
 name = app["name"]
 desc = app.get("description", "")
 name_box = ttk.Frame(grid)
 name_box.grid(row=r, column=0, sticky="w", padx=(0, 10), pady=6)
 ttk.Label(name_box, text=name, font=("Segoe UI", 11, "bold")).pack(anchor="w")
 ttk.Label(name_box, text=desc, foreground="#666").pack(anchor="w")
 st = tk.StringVar(value="Not installed.")
 st_lbl = ttk.Label(grid, textvariable=st)
 st_lbl.grid(row=r, column=1, sticky="w")
 actions = ttk.Frame(grid)
 actions.grid(row=r, column=2, sticky="w", pady=6)
 dl_btn = ttk.Button(actions, text="Download / Update", command=lambda k=key: self.download_one(k))
 dl_btn.pack(side="left")
 run_btn = ttk.Button(actions, text="Run", command=lambda k=key: self.run_one(k))
 run_btn.pack(side="left", padx=8)
 self.rows[key] = {"status": st, "dl_btn": dl_btn, "run_btn": run_btn}
 bottom = ttk.Frame(root)
 bottom.pack(fill="x", pady=(10, 0))
 self.pbar = ttk.Progressbar(bottom, orient="horizontal", mode="determinate")
 self.pbar.pack(fill="x", expand=True)
 foot = ttk.Frame(root)
 foot.pack(fill="x", pady=(10, 0))
 ttk.Label(foot, textvariable=self.status, foreground="#333").pack(side="left")
 btns = ttk.Frame(foot)
 btns.pack(side="right")
 ttk.Button(btns, text="Install All", command=self.install_all).pack(side="left")
 ttk.Button(btns, text="Install + Run All", command=self.install_and_run_all).pack(side="left", padx=8)
 ttk.Button(btns, text="Open Install Folder", command=self.open_install_folder).pack(side="left")
 self._refresh_installed_status()
 def _browse_install_dir(self):
 d = filedialog.askdirectory(initialdir=self.install_dir.get() or DEFAULT_INSTALL_DIR, mustexist=False)
 if d:
 self.install_dir.set(d)
 self._refresh_installed_status()
 def _set_busy(self, busy: bool):
 self.busy = busy
 for app in APPS:
 w = self.rows[app["key"]]
 w["dl_btn"]["state"] = ("disabled" if busy else "normal")
 w["run_btn"]["state"] = ("disabled" if busy else "normal")
 def _ensure_dir(self):
 d = self.install_dir.get().strip()
 if not d:
 raise ValueError("Install directory is empty.")
 os.makedirs(d, exist_ok=True)
 return d
 def _app_path(self, app):
 d = self._ensure_dir()
 return os.path.join(d, app["filename"])
 def _refresh_installed_status(self):
 for app in APPS:
 key = app["key"]
 path = os.path.join(self.install_dir.get().strip() or DEFAULT_INSTALL_DIR, app["filename"])
 if os.path.isfile(path):
 self.rows[key]["status"].set(f"Installed: {path}")
 else:
 self.rows[key]["status"].set("Not installed.")
 def _progress(self, pct: float, msg: str | None = None):
 pct = max(0.0, min(100.0, pct))
 self.pbar["value"] = pct
 if msg is not None:
 self.status.set(msg)
 self.update_idletasks()
 def download_one(self, key: str):
 if self.busy:
 return
 app = next((a for a in APPS if a["key"] == key), None)
 if not app:
 return
 t = threading.Thread(target=self._download_worker, args=([app],), daemon=True)
 t.start()
 def install_all(self):
 if self.busy:
 return
 t = threading.Thread(target=self._download_worker, args=(APPS,), daemon=True)
 t.start()
 def install_and_run_all(self):
 if self.busy:
 return
 t = threading.Thread(target=self._download_worker, args=(APPS, True), daemon=True)
 t.start()
 def _download_worker(self, apps, run_after: bool = False):
 try:
 self._set_busy(True)
 self._progress(0, "Preparing downloads…")
 install_dir = self._ensure_dir()
 for a in apps:
 if not a.get("url") or "YOUR-DOMAIN" in a["url"]:
 raise ValueError(f"Please set a real download URL for: {a['name']}")
 total = len(apps)
 for idx, app in enumerate(apps, start=1):
 name = app["name"]
 url = app["url"].strip()
 out_path = os.path.join(install_dir, app["filename"])
 tmp_path = out_path + ".part"
 self._progress(((idx - 1) / total) * 100.0, f"Downloading {name}…")
 req = urllib.request.Request(
 url,
 headers={"User-Agent": USER_AGENT},
 method="GET",
 )
 with urllib.request.urlopen(req, timeout=CONNECT_TIMEOUT_SECONDS) as resp:
 length = resp.headers.get("Content-Length")
 total_bytes = int(length) if length and length.isdigit() else None
 read = 0
 with open(tmp_path, "wb") as f:
 while True:
 chunk = resp.read(1024 * 256)
 if not chunk:
 break
 f.write(chunk)
 read += len(chunk)
 if total_bytes:
 file_pct = (read / total_bytes) * 100.0
 overall_start = ((idx - 1) / total) * 100.0
 overall_end = (idx / total) * 100.0
 overall_pct = overall_start + (file_pct / 100.0) * (overall_end - overall_start)
 self._progress(overall_pct, f"Downloading {name}… ({read/1024/1024:.1f} MB)")
 expected = (app.get("sha256") or "").strip().lower()
 if expected:
 self._progress((idx / total) * 100.0, f"Verifying {name}…")
 actual = _sha256_file(tmp_path).lower()
 if actual != expected:
 try:
 os.remove(tmp_path)
 except Exception:
 pass
 raise ValueError(
 f"SHA-256 mismatch for {name}.\n\nExpected:\n{expected}\n\nActual:\n{actual}"
 )
 if os.path.isfile(out_path):
 try:
 os.remove(out_path)
 except Exception:
 pass
 os.replace(tmp_path, out_path)
 self.rows[app["key"]]["status"].set(f"Installed: {out_path}")
 self._progress(100, "All downloads complete.")
 self._refresh_installed_status()
 if run_after:
 time.sleep(0.25)
 self._progress(100, "Launching apps…")
 for app in apps:
 self._run_exe(app)
 self.status.set("Installed and launched all apps.")
 else:
 self.status.set("Install complete.")
 except Exception as e:
 self.status.set("Error.")
 messagebox.showerror("Installer Error", str(e))
 finally:
 try:
 install_dir = self.install_dir.get().strip()
 if install_dir and os.path.isdir(install_dir):
 for f in os.listdir(install_dir):
 if f.endswith(".part"):
 try:
 os.remove(os.path.join(install_dir, f))
 except Exception:
 pass
 except Exception:
 pass
 self._set_busy(False)
 self._progress(0)
 def _run_exe(self, app):
 exe_path = self._app_path(app)
 if not os.path.isfile(exe_path):
 raise FileNotFoundError(f"{app['name']} is not installed yet.\n\nExpected:\n{exe_path}")
 try:
 subprocess.Popen([exe_path], cwd=os.path.dirname(exe_path))
 except Exception as e:
 raise RuntimeError(f"Failed to launch {app['name']}:\n{e}") from e
 def run_one(self, key: str):
 if self.busy:
 return
 app = next((a for a in APPS if a["key"] == key), None)
 if not app:
 return
 try:
 self._run_exe(app)
 self.status.set(f"Launched {app['name']}.")
 except Exception as e:
 messagebox.showerror("Run Error", str(e))
 def open_install_folder(self):
 try:
 d = self._ensure_dir()
 os.startfile(d)
 except Exception as e:
 messagebox.showerror("Open Folder Error", str(e))
if __name__ == "__main__":
 app = InstallerApp()
 app.mainloop()

import sys, re, math, datetime
from dataclasses import dataclass, field
from typing import Any, Dict, Tuple, Optional, List
from PyQt6.QtCore import (
 Qt, QAbstractTableModel, QModelIndex, QVariant, QSortFilterProxyModel, QItemSelection, QItemSelectionModel,
 QRegularExpression, QSize
)
from PyQt6.QtGui import (
 QAction, QKeySequence, QFont, QBrush, QColor, QPalette, QIcon
)
from PyQt6.QtWidgets import (
 QApplication, QMainWindow, QWidget, QVBoxLayout, QHBoxLayout, QTabWidget, QToolButton,
 QLineEdit, QLabel, QTableView, QFileDialog, QMessageBox, QComboBox, QColorDialog, QSpinBox,
 QDialog, QFormLayout, QPushButton, QCheckBox, QSplitter, QMenu, QStatusBar
)
try:
 import openpyxl
 from openpyxl.styles import Font as XLFont, PatternFill as XLFill, Alignment as XLAlignment
except Exception:
 openpyxl = None
def col_to_name(col: int) -> str:
 col += 1
 name = ""
 while col > 0:
 col, rem = divmod(col - 1, 26)
 name = chr(65 + rem) + name
 return name
def name_to_col(name: str) -> int:
 name = name.upper()
 n = 0
 for ch in name:
 if not ("A" <= ch <= "Z"):
 break
 n = n * 26 + (ord(ch) - 64)
 return n - 1
ADDR_RE = re.compile(r"^\$?([A-Za-z]{1,3})\$?([1-9][0-9]*)$")
RANGE_RE = re.compile(r"^\$?([A-Za-z]{1,3})\$?([1-9][0-9]*)\s*:\s*\$?([A-Za-z]{1,3})\$?([1-9][0-9]*)$")
def parse_addr(addr: str) -> Optional[Tuple[int, int]]:
 addr = addr.strip()
 m = ADDR_RE.match(addr)
 if not m:
 return None
 c = name_to_col(m.group(1))
 r = int(m.group(2)) - 1
 if r < 0 or c < 0:
 return None
 return r, c
def parse_range(rng: str) -> Optional[Tuple[int, int, int, int]]:
 rng = rng.strip()
 m = RANGE_RE.match(rng)
 if not m:
 return None
 c1 = name_to_col(m.group(1))
 r1 = int(m.group(2)) - 1
 c2 = name_to_col(m.group(3))
 r2 = int(m.group(4)) - 1
 rmin, rmax = sorted((r1, r2))
 cmin, cmax = sorted((c1, c2))
 if rmin < 0 or cmin < 0:
 return None
 return rmin, cmin, rmax, cmax
def is_numberish(x: Any) -> bool:
 try:
 float(x)
 return True
 except Exception:
 return False
def to_number(x: Any) -> float:
 if x is None:
 return 0.0
 if isinstance(x, (int, float)):
 return float(x)
 s = str(x).strip()
 if s == "":
 return 0.0
 if s.endswith("%") and is_numberish(s[:-1].strip()):
 return float(s[:-1].strip()) / 100.0
 if s.startswith("$"):
 s = s[1:].strip()
 return float(s)
def try_parse_date(s: str) -> Optional[datetime.datetime]:
 s = s.strip()
 if not s:
 return None
 fmts = [
 "%Y-%m-%d",
 "%Y/%m/%d",
 "%m/%d/%Y",
 "%m/%d/%y",
 "%Y-%m-%d %H:%M",
 "%Y-%m-%d %H:%M:%S",
 "%m/%d/%Y %H:%M",
 "%m/%d/%Y %H:%M:%S",
 ]
 for f in fmts:
 try:
 dt = datetime.datetime.strptime(s, f)
 return dt
 except Exception:
 pass
 return None

def clamp(n, lo, hi):
 return max(lo, min(hi, n))
@dataclass
class CellFormat:
 font_family: str = "Calibri"
 font_size: int = 11
 bold: bool = False
 italic: bool = False
 underline: bool = False
 fg: Optional[str] = None
 bg: Optional[str] = None
 align: str = "left"
 wrap: bool = False
 num_format: str = "General"
@dataclass
class Cell:
 raw: str = ""
 formula: str = ""
 fmt: CellFormat = field(default_factory=CellFormat)
 cached_value: Any = None
 cache_valid: bool = False
@dataclass
class Sheet:
 name: str
 rows: int = 200
 cols: int = 26
 cells: Dict[Tuple[int, int], Cell] = field(default_factory=dict)
 def ensure_size(self, min_rows: int, min_cols: int):
 if self.rows < min_rows:
 self.rows = min_rows
 if self.cols < min_cols:
 self.cols = min_cols
@dataclass
class Workbook:
 sheets: List[Sheet] = field(default_factory=list)
 active_index: int = 0
class FormulaError(Exception):
 pass
_ALLOWED_FUNC_NAMES = {
 "SUM", "AVERAGE", "MIN", "MAX", "COUNT", "COUNTA", "IF", "ROUND", "INT", "ABS",
 "SQRT", "POWER", "LOG", "EXP",
 "LEN", "LEFT", "RIGHT", "MID",
 "CONCAT", "TEXT",
 "TODAY", "NOW",
 "AND", "OR", "NOT",
}
def _normalize_formula(expr: str) -> str:
 expr = expr.strip()
 expr = expr.replace("^", "**")
 expr = expr.replace("&", "+")
 expr = re.sub(r"(?i)\bTRUE\b", "True", expr)
 expr = re.sub(r"(?i)\bFALSE\b", "False", expr)
 expr = re.sub(r"(?i)\bNULL\b", "None", expr)
 return expr
_RANGE_TOKEN = re.compile(r"(\$?[A-Za-z]{1,3}\$?[1-9][0-9]*\s*:\s*\$?[A-Za-z]{1,3}\$?[1-9][0-9]*)")
_CELL_TOKEN = re.compile(r"(?<![A-Za-z0-9_])(\$?[A-Za-z]{1,3}\$?[1-9][0-9]*)(?![A-Za-z0-9_])")
def _tokenize_ranges_then_cells(expr: str) -> str:
 ranges: List[str] = []
 def range_repl(m):
 ranges.append(m.group(1))
 return f"__R{len(ranges)-1}__"
 temp = _RANGE_TOKEN.sub(range_repl, expr)
 def cell_repl(m):
 addr = m.group(1)
 return f'C("{addr}")'
 temp = _CELL_TOKEN.sub(cell_repl, temp)
 for i, r in enumerate(ranges):
 temp = temp.replace(f"__R{i}__", f'R("{r}")')
 return temp
def _safe_eval(expr: str, env: Dict[str, Any]) -> Any:
 import ast
 allowed_nodes = (
 ast.Expression,
 ast.BinOp, ast.UnaryOp,
 ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod, ast.Pow, ast.FloorDiv,
 ast.USub, ast.UAdd,
 ast.Compare, ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
 ast.BoolOp, ast.And, ast.Or,
 ast.Not,
 ast.Call,
 ast.Name,
 ast.Constant,
 ast.IfExp,
 ast.Tuple, ast.List,
 )
 tree = ast.parse(expr, mode="eval")
 for node in ast.walk(tree):
 if not isinstance(node, allowed_nodes):
 raise FormulaError("Unsupported expression")
 if isinstance(node, ast.Call):
 if isinstance(node.func, ast.Name):
 fn = node.func.id
 if fn not in env:
 raise FormulaError(f"Unknown function: {fn}")
 else:
 raise FormulaError("Unsupported function call")
 if isinstance(node, ast.Name):
 if node.id not in env:
 raise FormulaError(f"Unknown name: {node.id}")

code = compile(tree, "<formula>", "eval")
 return eval(code, {"__builtins__": {}}, env)
class SpreadsheetModel(QAbstractTableModel):
 def __init__(self, sheet: Sheet, parent=None):
 super().__init__(parent)
 self.sheet = sheet
 self._recalc_guard = False
 def rowCount(self, parent=QModelIndex()) -> int:
 return self.sheet.rows
 def columnCount(self, parent=QModelIndex()) -> int:
 return self.sheet.cols
 def headerData(self, section: int, orientation: Qt.Orientation, role: int = Qt.ItemDataRole.DisplayRole):
 if role != Qt.ItemDataRole.DisplayRole:
 return None
 if orientation == Qt.Orientation.Horizontal:
 return col_to_name(section)
 return str(section + 1)
 def flags(self, index: QModelIndex):
 if not index.isValid():
 return Qt.ItemFlag.NoItemFlags
 return Qt.ItemFlag.ItemIsSelectable | Qt.ItemFlag.ItemIsEnabled | Qt.ItemFlag.ItemIsEditable
 def _get_cell(self, r: int, c: int) -> Cell:
 key = (r, c)
 if key not in self.sheet.cells:
 self.sheet.cells[key] = Cell()
 return self.sheet.cells[key]
 def _get_cell_maybe(self, r: int, c: int) -> Optional[Cell]:
 return self.sheet.cells.get((r, c))
 def data(self, index: QModelIndex, role: int = Qt.ItemDataRole.DisplayRole):
 if not index.isValid():
 return None
 r, c = index.row(), index.column()
 cell = self._get_cell_maybe(r, c)
 if cell is None:
 if role in (Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole):
 return ""
 return None
 if role == Qt.ItemDataRole.EditRole:
 return ("=" + cell.formula) if cell.formula else cell.raw
 if role == Qt.ItemDataRole.DisplayRole:
 v = self.get_display_value(r, c)
 return "" if v is None else str(v)
 if role == Qt.ItemDataRole.FontRole:
 f = QFont(cell.fmt.font_family, cell.fmt.font_size)
 f.setBold(cell.fmt.bold)
 f.setItalic(cell.fmt.italic)
 f.setUnderline(cell.fmt.underline)
 return f
 if role == Qt.ItemDataRole.ForegroundRole and cell.fmt.fg:
 return QBrush(QColor(cell.fmt.fg))
 if role == Qt.ItemDataRole.BackgroundRole and cell.fmt.bg:
 return QBrush(QColor(cell.fmt.bg))
 if role == Qt.ItemDataRole.TextAlignmentRole:
 a = cell.fmt.align
 if a == "center":
 return int(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignHCenter)
 if a == "right":
 return int(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignRight)
 return int(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft)
 return None
 def setData(self, index: QModelIndex, value: Any, role: int = Qt.ItemDataRole.EditRole) -> bool:
 if role != Qt.ItemDataRole.EditRole or not index.isValid():
 return False
 r, c = index.row(), index.column()
 txt = "" if value is None else str(value)
 cell = self._get_cell(r, c)
 old_raw, old_formula = cell.raw, cell.formula
 txt_stripped = txt.strip()
 if txt_stripped.startswith("="):
 cell.formula = txt_stripped[1:].strip()
 cell.raw = ""
 else:
 cell.formula = ""
 cell.raw = txt
 cell.cache_valid = False
 if (old_raw, old_formula) != (cell.raw, cell.formula):
 self.invalidate_all_caches()
 self.dataChanged.emit(index, index, [
 Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole
 ])
 return True
 return False
 def invalidate_all_caches(self):
 for cell in self.sheet.cells.values():
 cell.cache_valid = False
 def _cell_value_for_formula(self, r: int, c: int, visiting: set) -> Any:
 cell = self._get_cell_maybe(r, c)
 if cell is None:
 return 0
 key = (r, c)
 if key in visiting:
 raise FormulaError("Circular reference")
 if cell.cache_valid:
 return cell.cached_value
 visiting.add(key)
 try:
 if cell.formula:
 val = self._eval_formula(cell.formula, visiting)
 else:
 val = cell.raw
 cell.cached_value = val
 cell.cache_valid = True
 return val
 finally:
 visiting.remove(key)
 def _range_values(self, rng: str, visiting: set) -> List[Any]:
 pr = parse_range(rng.replace("$", ""))
 if not pr:
 raise FormulaError("Bad range")
 r1, c1, r2, c2 = pr
 vals = []
 for rr in range(r1, r2 + 1):
 for cc in range(c1, c2 + 1):
 vals.append(self._cell_value_for_formula(rr, cc, visiting))
 return vals
 def _eval_formula(self, expr: str, visiting: set) -> Any:
 expr = _normalize_formula(expr)
 expr = _tokenize_ranges_then_cells(expr)
 def C(addr: str) -> Any:
 addr = addr.replace("$", "")
 p = parse_addr(addr)
 if not p:
 raise FormulaError("Bad address")
 rr, cc = p
 return self._cell_value_for_formula(rr, cc, visiting)
 def R(rng: str) -> List[Any]:
 rng = rng.replace("$", "")
 return self._range_values(rng, visiting)
 def _flatten_args(args):
 out = []
 for a in args:
 if isinstance(a, list):
 out.extend(_flatten_args(a))
 else:
 out.append(a)
 return out
 def SUM(*args):
 flat = _flatten_args(args)
 s = 0.0
 for x in flat:
 if x is None or str(x).strip() == "":
 continue
 if is_numberish(x):
 s += to_number(x)
 return s
 def AVERAGE(*args):
 flat = _flatten_args(args)
 nums = [to_number(x) for x in flat if x is not None and str(x).strip() != "" and is_numberish(x)]
 return (sum(nums) / len(nums)) if nums else 0
 def MIN(*args):
 flat = _flatten_args(args)
 nums = [to_number(x) for x in flat if x is not None and str(x).strip() != "" and is_numberish(x)]
 return min(nums) if nums else 0
 def MAX(*args):
 flat = _flatten_args(args)
 nums = [to_number(x) for x in flat if x is not None and str(x).strip() != "" and is_numberish(x)]
 return max(nums) if nums else 0
 def COUNT(*args):
 flat = _flatten_args(args)
 return sum(1 for x in flat if x is not None and str(x).strip() != "" and is_numberish(x))
 def COUNTA(*args):
 flat = _flatten_args(args)
 return sum(1 for x in flat if x is not None and str(x).strip() != "")
 def IF(cond, a, b):
 return a if bool(cond) else b
 def ROUND(x, n=0):
 return round(to_number(x), int(to_number(n)))
 def INT(x):
 return int(math.floor(to_number(x)))
 def ABS(x):
 return abs(to_number(x))
 def SQRT(x):
 return math.sqrt(to_number(x))
 def POWER(x, y):
 return to_number(x) ** to_number(y)
 def LOG(x, base=math.e):
 return math.log(to_number(x), to_number(base))
 def EXP(x):
 return math.exp(to_number(x))
 def LEN(x):
 return len("" if x is None else str(x))
 def LEFT(x, n=1):
 s = "" if x is None else str(x)
 return s[: int(to_number(n))]
 def RIGHT(x, n=1):
 s = "" if x is None else str(x)
 nn = int(to_number(n))
 return s[-nn:] if nn != 0 else ""
 def MID(x, start, n):
 s = "" if x is None else str(x)
 st = int(to_number(start)) - 1
 ln = int(to_number(n))
 if st < 0:
 st = 0
 return s[st: st + ln]
 def CONCAT(*args):
 flat = _flatten_args(args)
 return "".join("" if a is None else str(a) for a in flat)
 def TEXT(x, fmt):
 s = "" if x is None else str(x)
 fmt_s = "" if fmt is None else str(fmt)
 dt = try_parse_date(s)
 if dt:
 pyfmt = fmt_s.replace("yyyy", "%Y").replace("yy", "%y").replace("mm", "%m").replace("dd", "%d")
 pyfmt = pyfmt.replace("hh", "%H").replace("ss", "%S").replace("AM/PM", "%p")
 pyfmt = pyfmt.replace("m", "%m").replace("d", "%d")
 try:
 return dt.strftime(pyfmt)
 except Exception:
 return dt.isoformat(sep=" ")
 if is_numberish(s):
 try:
 n = to_number(s)
 if fmt_s.lower() in ("0.00", "0.0", "0"):
 dec = fmt_s.count("0") - 1 if "." in fmt_s else 0
 return f"{n:.{dec}f}"
 except Exception:
 pass
 return s
 def TODAY():
 return datetime.date.today().isoformat()
 def NOW():
 return datetime.datetime.now().isoformat(sep=" ", timespec="seconds")
 def AND(*args):
 return all(bool(a) for a in args)
 def OR(*args):
 return any(bool(a) for a in args)
 def NOT(a):
 return not bool(a)
 env = {
 "C": C,
 "R": R,
 "SUM": SUM,
 "AVERAGE": AVERAGE,
 "MIN": MIN,
 "MAX": MAX,
 "COUNT": COUNT,
 "COUNTA": COUNTA,
 "IF": IF,
 "ROUND": ROUND,
 "INT": INT,
 "ABS": ABS,
 "SQRT": SQRT,
 "POWER": POWER,
 "LOG": LOG,
 "EXP": EXP,
 "LEN": LEN,
 "LEFT": LEFT,
 "RIGHT": RIGHT,
 "MID": MID,
 "CONCAT": CONCAT,
 "TEXT": TEXT,
 "TODAY": TODAY,
 "NOW": NOW,
 "AND": AND,
 "OR": OR,
 "NOT": NOT,
 "True": True,
 "False": False,
 "None": None,
 }
 return _safe_eval(expr, env)
 def get_display_value(self, r: int, c: int) -> Any:
 cell = self._get_cell_maybe(r, c)
 if cell is None:
 return ""
 try:
 val = self._cell_value_for_formula(r, c, set()) if (cell.formula or cell.cache_valid) else (cell.raw or "")
 if cell.formula:
 val = self._cell_value_for_formula(r, c, set())
 except Exception:
 return "#ERROR"
 fmt = cell.fmt.num_format
 if fmt == "Text":
 return "" if val is None else str(val)
 if isinstance(val, (int, float)):
 num = float(val)
 elif is_numberish(val):
 try:
 num = to_number(val)
 except Exception:
 num = None
 else:
 num = None
 if fmt == "General":
 return "" if val is None else val
 if fmt == "Number" and num is not None:
 return f"{num:.2f}"
 if fmt == "Currency" and num is not None:
 return f"${num:,.2f}"
 if fmt == "Percent" and num is not None:
 return f"{num*100:.2f}%"
 if fmt in ("Date", "Time"):
 s = "" if val is None else str(val)
 dt = try_parse_date(s)
 if dt:
 if fmt == "Date":
 return dt.date().isoformat()
 return dt.strftime("%H:%M:%S")
 return s
 return "" if val is None else val
 def apply_format_to_cells(self, cells: List[Tuple[int, int]], updater):
 for r, c in cells:
 cell = self._get_cell(r, c)
 updater(cell.fmt)
 idx = self.index(r, c)
 self.dataChanged.emit(idx, idx, [
 Qt.ItemDataRole.FontRole, Qt.ItemDataRole.ForegroundRole, Qt.ItemDataRole.BackgroundRole,
 Qt.ItemDataRole.TextAlignmentRole, Qt.ItemDataRole.DisplayRole
 ])
 def clear_cells(self, cells: List[Tuple[int, int]]):
 for r, c in cells:
 cell = self._get_cell_maybe(r, c)
 if cell is None:
 continue
 cell.raw = ""
 cell.formula = ""
 cell.cache_valid = False
 idx = self.index(r, c)
 self.dataChanged.emit(idx, idx, [Qt.ItemDataRole.DisplayRole, Qt.ItemDataRole.EditRole])
 self.invalidate_all_caches()
class ColumnFilterProxy(QSortFilterProxyModel):
 def __init__(self, parent=None):
 super().__init__(parent)
 self.filters: Dict[int, str] = {}
 self.hide_blanks: Dict[int, bool] = {}
 self.setDynamicSortFilter(True)
 def set_column_filter(self, col: int, text: str, hide_blank: bool = False):
 text = (text or "").strip()
 if text:
 self.filters[col] = text
 else:
 self.filters.pop(col, None)
 self.hide_blanks[col] = bool(hide_blank)
 self.invalidateFilter()
 def clear_filters(self):
 self.filters.clear()
 self.hide_blanks.clear()
 self.invalidateFilter()
 def filterAcceptsRow(self, source_row: int, source_parent: QModelIndex) -> bool:
 model = self.sourceModel()
 for col, needle in self.filters.items():
 idx = model.index(source_row, col)
 s = model.data(idx, Qt.ItemDataRole.DisplayRole)
 s = "" if s is None else str(s)
 if needle.lower() not in s.lower():
 return False
 for col, hb in self.hide_blanks.items():
 if not hb:
 continue
 idx = model.index(source_row, col)
 s = model.data(idx, Qt.ItemDataRole.DisplayRole)
 s = "" if s is None else str(s)
 if s.strip() == "":
 return False
 return True
class FindReplaceDialog(QDialog):
 def __init__(self, parent=None):
 super().__init__(parent)
 self.setWindowTitle("Find & Replace")
 self.setModal(False)
 self.find_text = QLineEdit()
 self.replace_text = QLineEdit()
 self.match_case = QCheckBox("Match case")
 self.whole_cell = QCheckBox("Whole cell")
 self.btn_find_next = QPushButton("Find Next")
 self.btn_replace = QPushButton("Replace")
 self.btn_replace_all = QPushButton("Replace All")
 self.btn_close = QPushButton("Close")
 form = QFormLayout()
 form.addRow("Find:", self.find_text)
 form.addRow("Replace:", self.replace_text)
 form.addRow("", self.match_case)
 form.addRow("", self.whole_cell)
 btns = QHBoxLayout()
 btns.addWidget(self.btn_find_next)
 btns.addWidget(self.btn_replace)
 btns.addWidget(self.btn_replace_all)
 btns.addStretch(1)
 btns.addWidget(self.btn_close)
 layout = QVBoxLayout()
 layout.addLayout(form)
 layout.addLayout(btns)
 self.setLayout(layout)
 self.btn_close.clicked.connect(self.close)
class ColumnFilterDialog(QDialog):
 def __init__(self, parent=None):
 super().__init__(parent)
 self.setWindowTitle("Column Filter")
 self.setModal(True)
 self.filter_text = QLineEdit()
 self.hide_blanks = QCheckBox("Hide blank rows for this column")
 self.btn_ok = QPushButton("Apply")
 self.btn_cancel = QPushButton("Cancel")
 form = QFormLayout()
 form.addRow("Contains:", self.filter_text)
 form.addRow("", self.hide_blanks)
 btns = QHBoxLayout()
 btns.addStretch(1)
 btns.addWidget(self.btn_ok)
 btns.addWidget(self.btn_cancel)
 layout = QVBoxLayout()
 layout.addLayout(form)
 layout.addLayout(btns)
 self.setLayout(layout)
 self.btn_ok.clicked.connect(self.accept)
 self.btn_cancel.clicked.connect(self.reject)
class SheetView(QWidget):
 def __init__(self, sheet: Sheet, parent=None):
 super().__init__(parent)
 self.sheet = sheet
 self.model = SpreadsheetModel(sheet, self)
 self.proxy = ColumnFilterProxy(self)
 self.proxy.setSourceModel(self.model)
 self.view = QTableView()
 self.view.setModel(self.proxy)
 self.view.setSortingEnabled(True)
 self.view.setAlternatingRowColors(False)
 self.view.setSelectionBehavior(QTableView.SelectionBehavior.SelectItems)
 self.view.setSelectionMode(QTableView.SelectionMode.ExtendedSelection)
 self.view.setCornerButtonEnabled(True)
 self.view.horizontalHeader().setHighlightSections(False)
 self.view.verticalHeader().setHighlightSections(False)
 self.view.horizontalHeader().setDefaultSectionSize(90)
 self.view.verticalHeader().setDefaultSectionSize(22)
 self.view.setWordWrap(False)
 self.view.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
 self.view.customContextMenuRequested.connect(self._context_menu)
 layout = QVBoxLayout()
 layout.setContentsMargins(0, 0, 0, 0)
 layout.addWidget(self.view)
 self.setLayout(layout)
 def _context_menu(self, pos):
 idx = self.view.indexAt(pos)
 menu = QMenu(self)
 act_clear = QAction("Clear Contents", self)
 act_clear.triggered.connect(lambda: self.clear_selection())
 act_autofit_cols = QAction("AutoFit Columns", self)
 act_autofit_cols.triggered.connect(self.view.resizeColumnsToContents)
 act_autofit_rows = QAction("AutoFit Rows", self)
 act_autofit_rows.triggered.connect(self.view.resizeRowsToContents)
 menu.addAction(act_clear)
 menu.addSeparator()
 menu.addAction(act_autofit_cols)
 menu.addAction(act_autofit_rows)
 if idx.isValid():
 menu.addSeparator()
 col = idx.column()
 act_filter = QAction(f"Filter Column {col_to_name(col)}…", self)
 act_filter.triggered.connect(lambda: self.open_filter_dialog(col))
 act_clear_filters = QAction("Clear All Filters", self)
 act_clear_filters.triggered.connect(self.proxy.clear_filters)
 menu.addAction(act_filter)
 menu.addAction(act_clear_filters)
 menu.exec(self.view.viewport().mapToGlobal(pos))
 def source_index(self, proxy_index: QModelIndex) -> QModelIndex:
 return self.proxy.mapToSource(proxy_index)
 def selected_source_cells(self) -> List[Tuple[int, int]]:
 sel = self.view.selectionModel().selectedIndexes()
 out = []
 for pidx in sel:
 sidx = self.source_index(pidx)
 out.append((sidx.row(), sidx.column()))
 return out
 def current_source_cell(self) -> Optional[Tuple[int, int]]:
 pidx = self.view.currentIndex()
 if not pidx.isValid():
 return None
 sidx = self.source_index(pidx)
 return (sidx.row(), sidx.column())
 def set_current_cell(self, r: int, c: int):
 sidx = self.model.index(r, c)
 pidx = self.proxy.mapFromSource(sidx)
 if pidx.isValid():
 self.view.setCurrentIndex(pidx)
 self.view.scrollTo(pidx, QTableView.ScrollHint.PositionAtCenter)
 def edit_current(self):
 pidx = self.view.currentIndex()
 if pidx.isValid():
 self.view.edit(pidx)
 def clear_selection(self):
 cells = self.selected_source_cells()
 if not cells:
 cur = self.current_source_cell()
 if cur:
 cells = [cur]
 if cells:
 self.model.clear_cells(cells)
 def open_filter_dialog(self, col: int):
 dlg = ColumnFilterDialog(self)
 existing = self.proxy.filters.get(col, "")
 dlg.filter_text.setText(existing)
 dlg.hide_blanks.setChecked(self.proxy.hide_blanks.get(col, False))
 if dlg.exec() == QDialog.DialogCode.Accepted:
 self.proxy.set_column_filter(col, dlg.filter_text.text(), dlg.hide_blanks.isChecked())
class ExcelFree(QMainWindow):
 def __init__(self):
 super().__init__()
 self.setWindowTitle("Sheets (Free)")
 self.resize(1200, 760)
 self.workbook = Workbook(sheets=[Sheet("Sheet1")], active_index=0)
 self.central = QWidget()
 self.setCentralWidget(self.central)
 self.v = QVBoxLayout(self.central)
 self.v.setContentsMargins(0, 0, 0, 0)
 self.v.setSpacing(0)
 self.ribbon = QTabWidget()
 self.ribbon.setDocumentMode(True)
 self.ribbon.setTabPosition(QTabWidget.TabPosition.North)
 self.ribbon.setMovable(False)
 self._build_ribbon_tabs()
 self.formula_bar = self._build_formula_bar()
 self.sheet_stack = QTabWidget()
 self.sheet_stack.setTabPosition(QTabWidget.TabPosition.South)
 self.sheet_stack.setMovable(True)
 self.v.addWidget(self.ribbon)
 self.v.addWidget(self.formula_bar)
 self.v.addWidget(self.sheet_stack)
 self.find_dialog = FindReplaceDialog(self)
 self.find_dialog.btn_find_next.clicked.connect(self._find_next)
 self.find_dialog.btn_replace.clicked.connect(self._replace_one)
 self.find_dialog.btn_replace_all.clicked.connect(self._replace_all)
 self._build_menu()
 self._build_status_bar()
 self._init_sheets()
 self.sheet_stack.currentChanged.connect(self._on_sheet_changed)
 self._wire_selection_updates()
 self._update_title(None)
 def _build_ribbon_tabs(self):
 def make_tab():
 w = QWidget()
 lay = QHBoxLayout(w)
 lay.setContentsMargins(8, 6, 8, 6)
 lay.setSpacing(10)
 lay.addStretch(1)
 return w, lay
 home, lay = make_tab()
 lay.insertWidget(0, self._group_clipboard())
 lay.insertWidget(1, self._group_font())
 lay.insertWidget(2, self._group_alignment())
 lay.insertWidget(3, self._group_number())
 lay.insertWidget(4, self._group_cells())
 self.ribbon.addTab(home, "Home")
 insert, lay2 = make_tab()
 btn_new_sheet = QToolButton()
 btn_new_sheet.setText("New Sheet")
 btn_new_sheet.clicked.connect(self.add_sheet)
 lay2.insertWidget(0, self._wrap_group("Sheets", [btn_new_sheet]))
 self.ribbon.addTab(insert, "Insert")
 data, lay3 = make_tab()
 btn_sort_az = QToolButton()
 btn_sort_az.setText("Sort A→Z")
 btn_sort_az.clicked.connect(lambda: self._sort_current(True))
 btn_sort_za = QToolButton()
 btn_sort_za.setText("Sort Z→A")
 btn_sort_za.clicked.connect(lambda: self._sort_current(False))
 btn_clear_filters = QToolButton()
 btn_clear_filters.setText("Clear Filters")
 btn_clear_filters.clicked.connect(lambda: self.current_sheet().proxy.clear_filters())
 lay3.insertWidget(0, self._wrap_group("Sort & Filter", [btn_sort_az, btn_sort_za, btn_clear_filters]))
 self.ribbon.addTab(data, "Data")
 view, lay4 = make_tab()
 self.chk_grid = QCheckBox("Gridlines")
 self.chk_grid.setChecked(True)
 self.chk_grid.toggled.connect(self._toggle_grid)
 self.zoom = QSpinBox()
 self.zoom.setRange(50, 200)
 self.zoom.setValue(100)
 self.zoom.setSuffix("%")
 self.zoom.valueChanged.connect(self._set_zoom)
 lay4.insertWidget(0, self._wrap_group("Show", [self.chk_grid]))
 lay4.insertWidget(1, self._wrap_group("Zoom", [self.zoom]))
 self.ribbon.addTab(view, "View")
 def _wrap_group(self, title: str, widgets: List[QWidget]) -> QWidget:
 outer = QWidget()
 v = QVBoxLayout(outer)
 v.setContentsMargins(6, 4, 6, 4)
 row = QHBoxLayout()
 row.setSpacing(6)
 for w in widgets:
 row.addWidget(w)
 v.addLayout(row)
 lab = QLabel(title)
 lab.setAlignment(Qt.AlignmentFlag.AlignHCenter)
 lab.setStyleSheet("color:#555; font-size:11px;")
 v.addWidget(lab)
 outer.setStyleSheet("QWidget{background:transparent;}")
 return outer
 def _group_clipboard(self) -> QWidget:
 btn_copy = QToolButton()
 btn_copy.setText("Copy")
 btn_copy.clicked.connect(self.copy)
 btn_cut = QToolButton()
 btn_cut.setText("Cut")
 btn_cut.clicked.connect(self.cut)
 btn_paste = QToolButton()
 btn_paste.setText("Paste")
 btn_paste.clicked.connect(self.paste)
 return self._wrap_group("Clipboard", [btn_paste, btn_cut, btn_copy])
 def _group_font(self) -> QWidget:
 self.cmb_font = QComboBox()
 self.cmb_font.setEditable(True)
 self.cmb_font.addItems(["Calibri", "Arial", "Segoe UI", "Times New Roman", "Courier New"])
 self.cmb_font.setCurrentText("Calibri")
 self.cmb_font.currentTextChanged.connect(self._apply_font_family)
 self.spn_fontsize = QSpinBox()
 self.spn_fontsize.setRange(6, 72)
 self.spn_fontsize.setValue(11)
 self.spn_fontsize.valueChanged.connect(self._apply_font_size)
 btn_b = QToolButton()
 btn_b.setText("B")
 btn_b.setCheckable(True)
 btn_b.clicked.connect(lambda: self._toggle_fmt("bold", btn_b.isChecked()))
 btn_i = QToolButton()
 btn_i.setText("I")
 btn_i.setCheckable(True)
 btn_i.clicked.connect(lambda: self._toggle_fmt("italic", btn_i.isChecked()))
 btn_u = QToolButton()
 btn_u.setText("U")
 btn_u.setCheckable(True)
 btn_u.clicked.connect(lambda: self._toggle_fmt("underline", btn_u.isChecked()))
 btn_fg = QToolButton()
 btn_fg.setText("Text Color")
 btn_fg.clicked.connect(lambda: self._pick_color(is_bg=False))
 btn_bg = QToolButton()
 btn_bg.setText("Fill Color")
 btn_bg.clicked.connect(lambda: self._pick_color(is_bg=True))
 return self._wrap_group("Font", [self.cmb_font, self.spn_fontsize, btn_b, btn_i, btn_u, btn_fg, btn_bg])
 def _group_alignment(self) -> QWidget:
 btn_l = QToolButton()
 btn_l.setText("Left")
 btn_l.clicked.connect(lambda: self._set_align("left"))
 btn_c = QToolButton()
 btn_c.setText("Center")
 btn_c.clicked.connect(lambda: self._set_align("center"))
 btn_r = QToolButton()
 btn_r.setText("Right")
 btn_r.clicked.connect(lambda: self._set_align("right"))
 btn_wrap = QToolButton()
 btn_wrap.setText("Wrap")
 btn_wrap.setCheckable(True)
 btn_wrap.clicked.connect(lambda: self._toggle_wrap(btn_wrap.isChecked()))
 return self._wrap_group("Alignment", [btn_l, btn_c, btn_r, btn_wrap])
 def _group_number(self) -> QWidget:
 self.cmb_numfmt = QComboBox()
 self.cmb_numfmt.addItems(["General", "Number", "Currency", "Percent", "Date", "Time", "Text"])
 self.cmb_numfmt.currentTextChanged.connect(self._set_numfmt)
 btn_autosum = QToolButton()
 btn_autosum.setText("AutoSum")
 btn_autosum.clicked.connect(self._autosum)
 return self._wrap_group("Number", [self.cmb_numfmt, btn_autosum])
 def _group_cells(self) -> QWidget:
 btn_ins_row = QToolButton()
 btn_ins_row.setText("Insert Row")
 btn_ins_row.clicked.connect(self._insert_row)
 btn_del_row = QToolButton()
 btn_del_row.setText("Delete Row")
 btn_del_row.clicked.connect(self._delete_row)
 btn_ins_col = QToolButton()
 btn_ins_col.setText("Insert Col")
 btn_ins_col.clicked.connect(self._insert_col)
 btn_del_col = QToolButton()
 btn_del_col.setText("Delete Col")
 btn_del_col.clicked.connect(self._delete_col)
 return self._wrap_group("Cells", [btn_ins_row, btn_del_row, btn_ins_col, btn_del_col])
 def _build_formula_bar(self) -> QWidget:
 w = QWidget()
 lay = QHBoxLayout(w)
 lay.setContentsMargins(10, 6, 10, 6)
 lay.setSpacing(8)
 self.name_box = QLineEdit()
 self.name_box.setFixedWidth(110)
 self.name_box.setPlaceholderText("A1")
 self.name_box.returnPressed.connect(self._goto_from_namebox)
 fx = QLabel("fx")
 fx.setStyleSheet("color:#666; font-weight:600; padding-left:4px; padding-right:4px;")
 self.formula_edit = QLineEdit()
 self.formula_edit.setPlaceholderText("Enter value or =formula")
 self.formula_edit.returnPressed.connect(self._commit_formula_bar)
 lay.addWidget(self.name_box)
 lay.addWidget(fx)
 lay.addWidget(self.formula_edit, 1)
 return w
 def _build_menu(self):
 filem = self.menuBar().addMenu("&File")
 act_new = QAction("New", self)
 act_new.setShortcut(QKeySequence.StandardKey.New)
 act_new.triggered.connect(self.new_workbook)
 filem.addAction(act_new)
 act_open = QAction("Open…", self)
 act_open.setShortcut(QKeySequence.StandardKey.Open)
 act_open.triggered.connect(self.open_file)
 filem.addAction(act_open)
 act_save = QAction("Save As…", self)
 act_save.setShortcut(QKeySequence.StandardKey.SaveAs)
 act_save.triggered.connect(self.save_as)
 filem.addAction(act_save)
 filem.addSeparator()
 act_exit = QAction("Exit", self)
 act_exit.triggered.connect(self.close)
 filem.addAction(act_exit)
 editm = self.menuBar().addMenu("&Edit")
 act_undo = QAction("Undo", self)
 act_undo.setShortcut(QKeySequence.StandardKey.Undo)
 act_undo.triggered.connect(lambda: self.statusBar().showMessage("Undo not implemented (lightweight build).", 3000))
 editm.addAction(act_undo)
 act_redo = QAction("Redo", self)
 act_redo.setShortcut(QKeySequence.StandardKey.Redo)
 act_redo.triggered.connect(lambda: self.statusBar().showMessage("Redo not implemented (lightweight build).", 3000))
 editm.addAction(act_redo)
 editm.addSeparator()
 act_find = QAction("Find/Replace…", self)
 act_find.setShortcut(QKeySequence.StandardKey.Find)
 act_find.triggered.connect(self._show_find)
 editm.addAction(act_find)
 viewm = self.menuBar().addMenu("&View")
 act_grid = QAction("Toggle Gridlines", self)
 act_grid.triggered.connect(lambda: self.chk_grid.setChecked(not self.chk_grid.isChecked()))
 viewm.addAction(act_grid)
 helpm = self.menuBar().addMenu("&Help")
 act_about = QAction("About", self)
 act_about.triggered.connect(self._about)
 helpm.addAction(act_about)
 QAction("Copy", self, shortcut=QKeySequence.StandardKey.Copy, triggered=self.copy)
 QAction("Paste", self, shortcut=QKeySequence.StandardKey.Paste, triggered=self.paste)
 QAction("Cut", self, shortcut=QKeySequence.StandardKey.Cut, triggered=self.cut)
 QAction("Clear", self, shortcut=QKeySequence(Qt.Key.Key_Delete), triggered=lambda: self.current_sheet().clear_selection())
 QAction("Edit Cell", self, shortcut=QKeySequence(Qt.Key.Key_F2), triggered=lambda: self.current_sheet().edit_current())
 QAction("Bold", self, shortcut=QKeySequence("Ctrl+B"), triggered=lambda: self._toggle_fmt("bold", True))
 QAction("Italic", self, shortcut=QKeySequence("Ctrl+I"), triggered=lambda: self._toggle_fmt("italic", True))
 QAction("Underline", self, shortcut=QKeySequence("Ctrl+U"), triggered=lambda: self._toggle_fmt("underline", True))
 def _build_status_bar(self):
 sb = QStatusBar()
 self.setStatusBar(sb)
 self.lbl_ready = QLabel("Ready")
 self.lbl_stats = QLabel("")
 self.lbl_stats.setStyleSheet("color:#444;")
 sb.addWidget(self.lbl_ready)
 sb.addPermanentWidget(self.lbl_stats)
 def _excelish_theme(self):
 QApplication.setStyle("Fusion")
 pal = QPalette()
 pal.setColor(QPalette.ColorRole.Window, QColor("#f3f3f3"))
 pal.setColor(QPalette.ColorRole.Base, QColor("#ffffff"))
 pal.setColor(QPalette.ColorRole.AlternateBase, QColor("#fafafa"))
 pal.setColor(QPalette.ColorRole.Text, QColor("#111111"))
 pal.setColor(QPalette.ColorRole.Button, QColor("#f3f3f3"))
 pal.setColor(QPalette.ColorRole.ButtonText, QColor("#111111"))
 pal.setColor(QPalette.ColorRole.Highlight, QColor("#2b579a")) # Excel-ish blue
 pal.setColor(QPalette.ColorRole.HighlightedText, QColor("#ffffff"))
 QApplication.instance().setPalette(pal)
 self.setStyleSheet("""
 QTabWidget::pane { border-top: 1px solid #d0d0d0; }
 QTabBar::tab { padding: 8px 12px; background: #f3f3f3; border: 1px solid #d0d0d0; border-bottom: none; }
 QTabBar::tab:selected { background: #ffffff; }
 QLineEdit { background: #ffffff; border: 1px solid #cfcfcf; padding: 5px; border-radius: 4px; }
 QToolButton { padding: 6px 8px; border: 1px solid #cfcfcf; border-radius: 6px; background: #ffffff; }
 QToolButton:pressed { background: #e9e9e9; }
 QHeaderView::section { background: #f3f3f3; border: 1px solid #d0d0d0; padding: 4px; }
 QTableView { background: #ffffff; gridline-color: #d9d9d9; }
 """)
 def _init_sheets(self):
 self.sheet_stack.blockSignals(True)
 try:
 self.sheet_stack.clear()
 for sh in self.workbook.sheets:
 self.sheet_stack.addTab(SheetView(sh, self), sh.name)
 self.sheet_stack.setCurrentIndex(self.workbook.active_index)
 finally:
 self.sheet_stack.blockSignals(False)
 def add_sheet(self):
 base = "Sheet"
 i = 1
 names = {s.name for s in self.workbook.sheets}
 while f"{base}{i}" in names:
 i += 1
 sh = Sheet(f"{base}{i}")
 self.workbook.sheets.append(sh)
 self.sheet_stack.addTab(SheetView(sh, self), sh.name)
 self.sheet_stack.setCurrentIndex(self.sheet_stack.count() - 1)
 def current_sheet(self) -> SheetView:
 return self.sheet_stack.currentWidget()
 def _on_sheet_changed(self, idx: int):
 if idx < 0:
 return
 self.workbook.active_index = idx
 self._wire_selection_updates()
 self._sync_formula_bar()
 def _wire_selection_updates(self):
 sv = self.current_sheet()
 if not sv:
 return
 try:
 sv.view.selectionModel().selectionChanged.disconnect(self._on_selection_changed)
 except Exception:
 pass
 try:
 sv.view.selectionModel().currentChanged.disconnect(self._on_current_changed)
 except Exception:
 pass
 sv.view.selectionModel().selectionChanged.connect(self._on_selection_changed)
 sv.view.selectionModel().currentChanged.connect(self._on_current_changed)
 self._on_current_changed(sv.view.currentIndex(), QModelIndex())
 self._on_selection_changed(QItemSelection(), QItemSelection())
 def _on_current_changed(self, current: QModelIndex, previous: QModelIndex):
 self._sync_formula_bar()
 def _on_selection_changed(self, selected: QItemSelection, deselected: QItemSelection):
 sv = self.current_sheet()
 cells = sv.selected_source_cells()
 if not cells:
 self.lbl_stats.setText("")
 return
 nums = []
 nonblank = 0
 for r, c in cells:
 sidx = sv.model.index(r, c)
 v = sv.model.data(sidx, Qt.ItemDataRole.DisplayRole)
 v = "" if v is None else str(v)
 if v.strip() != "":
 nonblank += 1
 if is_numberish(v.replace(",", "")) or (v.strip().endswith("%") and is_numberish(v.strip()[:-1])):
 try:
 nums.append(to_number(v.replace(",", "")))
 except Exception:
 pass
 if nums:
 s = sum(nums)
 avg = s / len(nums)
 self.lbl_stats.setText(f"Sum: {s:.2f} Avg: {avg:.2f} Count: {len(nums)} Non-blank: {nonblank}")
 else:
 self.lbl_stats.setText(f"Non-blank: {nonblank} Cells: {len(cells)}")
 def _sync_formula_bar(self):
 sv = self.current_sheet()
 cur = sv.current_source_cell()
 if not cur:
 self.name_box.setText("")
 self.formula_edit.setText("")
 return
 r, c = cur
 addr = f"{col_to_name(c)}{r+1}"
 self.name_box.setText(addr)
 sidx = sv.model.index(r, c)
 txt = sv.model.data(sidx, Qt.ItemDataRole.EditRole)
 self.formula_edit.setText("" if txt is None else str(txt))
 def _goto_from_namebox(self):
 text = self.name_box.text().strip()
 if not text:
 return
 sv = self.current_sheet()
 pr = parse_addr(text.replace("$", ""))
 if pr:
 r, c = pr
 sv.model.sheet.ensure_size(r + 1, c + 1)
 sv.model.layoutChanged.emit()
 sv.set_current_cell(r, c)
 return
 prng = parse_range(text.replace("$", ""))
 if prng:
 r1, c1, r2, c2 = prng
 sv.model.sheet.ensure_size(r2 + 1, c2 + 1)
 sv.model.layoutChanged.emit()
 sv.set_current_cell(r1, c1)
 sel = QItemSelection()
 top_left = sv.proxy.mapFromSource(sv.model.index(r1, c1))
 bot_right = sv.proxy.mapFromSource(sv.model.index(r2, c2))
 if top_left.isValid() and bot_right.isValid():
 sel.select(top_left, bot_right)
 sv.view.selectionModel().select(sel, QItemSelectionModel.SelectionFlag.ClearAndSelect)
 return
 self.statusBar().showMessage("Name box expects A1 or A1:B3", 3000)
 def _commit_formula_bar(self):
 sv = self.current_sheet()
 cur = sv.current_source_cell()
 if not cur:
 return
 r, c = cur
 val = self.formula_edit.text()
 sidx = sv.model.index(r, c)
 sv.model.setData(sidx, val, Qt.ItemDataRole.EditRole)
 self._sync_formula_bar()
 def copy(self):
 sv = self.current_sheet()
 idxs = sv.view.selectionModel().selectedIndexes()
 if not idxs:
 return
 rows = sorted(set(i.row() for i in idxs))
 cols = sorted(set(i.column() for i in idxs))
 if not rows or not cols:
 return
 rmin, rmax = min(rows), max(rows)
 cmin, cmax = min(cols), max(cols)
 lines = []
 for rr in range(rmin, rmax + 1):
 parts = []
 for cc in range(cmin, cmax + 1):
 pidx = sv.proxy.index(rr, cc)
 s = sv.proxy.data(pidx, Qt.ItemDataRole.DisplayRole)
 parts.append("" if s is None else str(s))
 lines.append("\t".join(parts))
 QApplication.clipboard().setText("\n".join(lines))
 def cut(self):
 self.copy()
 self.current_sheet().clear_selection()
 def paste(self):
 sv = self.current_sheet()
 text = QApplication.clipboard().text()
 if not text:
 return
 cur = sv.current_source_cell()
 if not cur:
 return
 start_r, start_c = cur
 rows = [r.split("\t") for r in text.splitlines()]
 max_r = start_r + len(rows)
 max_c = start_c + max(len(r) for r in rows) if rows else start_c + 1
 sv.model.sheet.ensure_size(max_r, max_c)
 sv.model.layoutChanged.emit()
 for rr, row in enumerate(rows):
 for cc, val in enumerate(row):
 r = start_r + rr
 c = start_c + cc
 sidx = sv.model.index(r, c)
 sv.model.setData(sidx, val, Qt.ItemDataRole.EditRole)
 self._sync_formula_bar()
 def _apply_font_family(self, family: str):
 sv = self.current_sheet()
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "font_family", family))
 def _apply_font_size(self, size: int):
 sv = self.current_sheet()
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "font_size", int(size)))
 def _toggle_fmt(self, what: str, state: bool):
 sv = self.current_sheet()
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 def upd(fmt: CellFormat):
 setattr(fmt, what, bool(state))
 sv.model.apply_format_to_cells(cells, upd)
 def _pick_color(self, is_bg: bool):
 col = QColorDialog.getColor(parent=self)
 if not col.isValid():
 return
 hexv = col.name()
 sv = self.current_sheet()
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 if is_bg:
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "bg", hexv))
 else:
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "fg", hexv))
 def _set_align(self, align: str):
 sv = self.current_sheet()
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "align", align))
 def _toggle_wrap(self, state: bool):
 sv = self.current_sheet()
 sv.view.setWordWrap(bool(state))
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "wrap", bool(state)))
 def _set_numfmt(self, fmtname: str):
 sv = self.current_sheet()
 cells = sv.selected_source_cells() or ([sv.current_source_cell()] if sv.current_source_cell() else [])
 if not cells:
 return
 sv.model.apply_format_to_cells(cells, lambda fmt: setattr(fmt, "num_format", fmtname))
 sv.model.invalidate_all_caches()
 sv.model.dataChanged.emit(sv.model.index(0, 0), sv.model.index(sv.model.rowCount()-1, sv.model.columnCount()-1),
 [Qt.ItemDataRole.DisplayRole])
 def _insert_row(self):
 sv = self.current_sheet()
 cur = sv.current_source_cell()
 if not cur:
 return
 r, _ = cur
 sv.model.beginInsertRows(QModelIndex(), r, r)
 sv.model.sheet.rows += 1
 new_cells = {}
 for (rr, cc), cell in sv.model.sheet.cells.items():
 if rr >= r:
 new_cells[(rr + 1, cc)] = cell
 else:
 new_cells[(rr, cc)] = cell
 sv.model.sheet.cells = new_cells
 sv.model.endInsertRows()
 sv.model.invalidate_all_caches()
 def _delete_row(self):
 sv = self.current_sheet()
 cur = sv.current_source_cell()
 if not cur or sv.model.sheet.rows <= 1:
 return
 r, _ = cur
 sv.model.beginRemoveRows(QModelIndex(), r, r)
 sv.model.sheet.rows -= 1
 new_cells = {}
 for (rr, cc), cell in sv.model.sheet.cells.items():
 if rr == r:
 continue
 if rr > r:
 new_cells[(rr - 1, cc)] = cell
 else:
 new_cells[(rr, cc)] = cell
 sv.model.sheet.cells = new_cells
 sv.model.endRemoveRows()
 sv.model.invalidate_all_caches()
 def _insert_col(self):
 sv = self.current_sheet()
 cur = sv.current_source_cell()
 if not cur:
 return
 _, c = cur
 sv.model.beginInsertColumns(QModelIndex(), c, c)
 sv.model.sheet.cols += 1
 new_cells = {}
 for (rr, cc), cell in sv.model.sheet.cells.items():
 if cc >= c:
 new_cells[(rr, cc + 1)] = cell
 else:
 new_cells[(rr, cc)] = cell
 sv.model.sheet.cells = new_cells
 sv.model.endInsertColumns()
 sv.model.invalidate_all_caches()
 def _delete_col(self):
 sv = self.current_sheet()
 cur = sv.current_source_cell()
 if not cur or sv.model.sheet.cols <= 1:
 return
 _, c = cur
 sv.model.beginRemoveColumns(QModelIndex(), c, c)
 sv.model.sheet.cols -= 1
 new_cells = {}
 for (rr, cc), cell in sv.model.sheet.cells.items():
 if cc == c:
 continue
 if cc > c:
 new_cells[(rr, cc - 1)] = cell
 else:
 new_cells[(rr, cc)] = cell
 sv.model.sheet.cells = new_cells
 sv.model.endRemoveColumns()
 sv.model.invalidate_all_caches()
 def _sort_current(self, ascending: bool):
 sv = self.current_sheet()
 pidx = sv.view.currentIndex()
 if not pidx.isValid():
 return
 col = pidx.column()
 sv.view.sortByColumn(col, Qt.SortOrder.AscendingOrder if ascending else Qt.SortOrder.DescendingOrder)
 def _show_find(self):
 self.find_dialog.show()
 self.find_dialog.raise_()
 self.find_dialog.activateWindow()
 def _match(self, hay: str, needle: str, match_case: bool, whole: bool) -> bool:
 if not match_case:
 hay = hay.lower()
 needle = needle.lower()
 return hay == needle if whole else (needle in hay)
 def _find_next(self):
 sv = self.current_sheet()
 needle = self.find_dialog.find_text.text()
 if not needle:
 return
 match_case = self.find_dialog.match_case.isChecked()
 whole = self.find_dialog.whole_cell.isChecked()
 start = sv.view.currentIndex()
 start_row = start.row() if start.isValid() else 0
 start_col = start.column() if start.isValid() else 0
 rows = sv.proxy.rowCount()
 cols = sv.proxy.columnCount()
 def cell_text(r, c):
 v = sv.proxy.data(sv.proxy.index(r, c), Qt.ItemDataRole.DisplayRole)
 return "" if v is None else str(v)
 for rr in range(start_row, rows):
 for cc in range(start_col if rr == start_row else 0, cols):
 if self._match(cell_text(rr, cc), needle, match_case, whole):
 sv.view.setCurrentIndex(sv.proxy.index(rr, cc))
 sv.view.scrollTo(sv.proxy.index(rr, cc), QTableView.ScrollHint.PositionAtCenter)
 return
 for rr in range(0, start_row + 1):
 for cc in range(0, start_col if rr == start_row else cols):
 if self._match(cell_text(rr, cc), needle, match_case, whole):
 sv.view.setCurrentIndex(sv.proxy.index(rr, cc))
 sv.view.scrollTo(sv.proxy.index(rr, cc), QTableView.ScrollHint.PositionAtCenter)
 return
 self.statusBar().showMessage("No matches found.", 2000)
 def _replace_one(self):
 sv = self.current_sheet()
 needle = self.find_dialog.find_text.text()
 repl = self.find_dialog.replace_text.text()
 if not needle:
 return
 match_case = self.find_dialog.match_case.isChecked()
 whole = self.find_dialog.whole_cell.isChecked()
 pidx = sv.view.currentIndex()
 if not pidx.isValid():
 self._find_next()
 return
 text = sv.proxy.data(pidx, Qt.ItemDataRole.DisplayRole)
 text = "" if text is None else str(text)
 if not self._match(text, needle, match_case, whole):
 self._find_next()
 return
 sidx = sv.source_index(pidx)
 old = sv.model.data(sidx, Qt.ItemDataRole.EditRole)
 old = "" if old is None else str(old)
 if whole:
 new = repl
 else:
 if match_case:
 new = old.replace(needle, repl)
 else:
 new = re.sub(re.escape(needle), repl, old, flags=re.IGNORECASE)
 sv.model.setData(sidx, new, Qt.ItemDataRole.EditRole)
 self._find_next()
 def _replace_all(self):
 sv = self.current_sheet()
 needle = self.find_dialog.find_text.text()
 repl = self.find_dialog.replace_text.text()
 if not needle:
 return
 match_case = self.find_dialog.match_case.isChecked()
 whole = self.find_dialog.whole_cell.isChecked()
 count = 0
 for rr in range(sv.proxy.rowCount()):
 for cc in range(sv.proxy.columnCount()):
 pidx = sv.proxy.index(rr, cc)
 disp = sv.proxy.data(pidx, Qt.ItemDataRole.DisplayRole)
 disp = "" if disp is None else str(disp)
 if not self._match(disp, needle, match_case, whole):
 continue
 sidx = sv.source_index(pidx)
 old = sv.model.data(sidx, Qt.ItemDataRole.EditRole)
 old = "" if old is None else str(old)
 if whole:
 new = repl
 else:
 if match_case:
 new = old.replace(needle, repl)
 else:
 new = re.sub(re.escape(needle), repl, old, flags=re.IGNORECASE)
 sv.model.setData(sidx, new, Qt.ItemDataRole.EditRole)
 count += 1
 self.statusBar().showMessage(f"Replaced {count} cell(s).", 3000)
 def _autosum(self):
 sv = self.current_sheet()
 cells = sv.selected_source_cells()
 if not cells:
 self.statusBar().showMessage("Select a range to AutoSum.", 2000)
 return
 rows = [r for r, _ in cells]
 cols = [c for _, c in cells]
 r1, r2 = min(rows), max(rows)
 c1, c2 = min(cols), max(cols)
 rng = f"{col_to_name(c1)}{r1+1}:{col_to_name(c2)}{r2+1}"
 target_r = r2 + 1
 target_c = c2
 sv.model.sheet.ensure_size(target_r + 1, target_c + 1)
 sv.model.layoutChanged.emit()
 sidx = sv.model.index(target_r, target_c)
 sv.model.setData(sidx, f"=SUM({rng})", Qt.ItemDataRole.EditRole)
 sv.set_current_cell(target_r, target_c)
 def _toggle_grid(self, on: bool):
 sv = self.current_sheet()
 sv.view.setShowGrid(bool(on))
 def _set_zoom(self, pct: int):
 pct = clamp(int(pct), 50, 200)
 base = 11
 size = max(7, int(round(base * (pct / 100.0))))
 sv = self.current_sheet()
 sv.view.setFont(QFont("Calibri", size))
 def _update_title(self, path: Optional[str]):
 if path:
 self.setWindowTitle(f"ExcelFree — {path}")
 else:
 self.setWindowTitle("ExcelFree (PyQt6) — Spreadsheet")
 def new_workbook(self):
 self.workbook = Workbook(sheets=[Sheet("Sheet1")], active_index=0)
 self._init_sheets()
 self._update_title(None)
 def open_file(self):
 path, _ = QFileDialog.getOpenFileName(self, "Open", "", "Excel (*.xlsx);;CSV (*.csv)")
 if not path:
 return
 try:
 if path.lower().endswith(".csv"):
 self._open_csv(path)
 else:
 self._open_xlsx(path)
 self._update_title(path)
 except Exception as e:
 QMessageBox.critical(self, "Open Failed", str(e))
 def save_as(self):
 path, _ = QFileDialog.getSaveFileName(self, "Save As", "", "Excel (*.xlsx);;CSV (*.csv)")
 if not path:
 return
 try:
 if path.lower().endswith(".csv"):
 self._save_csv(path)
 else:
 if not path.lower().endswith(".xlsx"):
 path += ".xlsx"
 self._save_xlsx(path)
 self._update_title(path)
 self.statusBar().showMessage("Saved.", 2000)
 except Exception as e:
 QMessageBox.critical(self, "Save Failed", str(e))
 def _open_csv(self, path: str):
 import csv
 with open(path, "r", newline="", encoding="utf-8-sig") as f:
 rows = list(csv.reader(f))
 sh = Sheet("Sheet1", rows=max(200, len(rows)), cols=max(26, max((len(r) for r in rows), default=0)))
 for r, row in enumerate(rows):
 for c, val in enumerate(row):
 if val is None:
 continue
 cell = sh.cells.setdefault((r, c), Cell())
 cell.raw = str(val)
 cell.formula = ""
 self.workbook = Workbook(sheets=[sh], active_index=0)
 self._init_sheets()
 def _save_csv(self, path: str):
 import csv
 sv = self.current_sheet()
 sh = sv.model.sheet
 max_r = sh.rows
 max_c = sh.cols
 with open(path, "w", newline="", encoding="utf-8") as f:
 w = csv.writer(f)
 for r in range(max_r):
 row = []
 for c in range(max_c):
 cell = sh.cells.get((r, c))
 if cell is None:
 row.append("")
 else:
 if cell.formula:
 row.append("=" + cell.formula)
 else:
 row.append(cell.raw)
 w.writerow(row)
 def _open_xlsx(self, path: str):
 if openpyxl is None:
 raise RuntimeError("openpyxl is required to open .xlsx")
 wb = openpyxl.load_workbook(path, data_only=False)
 sheets = []
 for ws in wb.worksheets:
 max_row = max(200, ws.max_row or 1)
 max_col = max(26, ws.max_column or 1)
 sh = Sheet(ws.title, rows=max_row, cols=max_col)
 for row in ws.iter_rows(min_row=1, min_col=1, max_row=max_row, max_col=max_col):
 for cell in row:
 r = cell.row - 1
 c = cell.column - 1
 if cell.value is None:
 continue
 scell = sh.cells.setdefault((r, c), Cell())
 if isinstance(cell.value, str) and cell.value.startswith("="):
 scell.formula = cell.value[1:]
 scell.raw = ""
 else:
 scell.raw = str(cell.value)
 scell.formula = ""
 try:
 if cell.font:
 scell.fmt.bold = bool(cell.font.bold)
 scell.fmt.italic = bool(cell.font.italic)
 scell.fmt.underline = bool(cell.font.underline)
 if cell.font.name:
 scell.fmt.font_family = cell.font.name
 if cell.font.sz:
 scell.fmt.font_size = int(cell.font.sz)
 if cell.font.color and cell.font.color.type == "rgb" and cell.font.color.rgb:
 rgb = cell.font.color.rgb[-6:]
 scell.fmt.fg = "#" + rgb
 if cell.fill and getattr(cell.fill, "fgColor", None) and cell.fill.fgColor.type == "rgb" and cell.fill.fgColor.rgb:
 rgb = cell.fill.fgColor.rgb[-6:]
 scell.fmt.bg = "#" + rgb
 if cell.alignment:
 if cell.alignment.horizontal in ("center", "right", "left"):
 scell.fmt.align = cell.alignment.horizontal
 scell.fmt.wrap = bool(cell.alignment.wrap_text)
 if cell.number_format:
 # map loosely
 nf = cell.number_format.lower()
 if "0%" in nf or "%" in nf:
 scell.fmt.num_format = "Percent"
 elif "$" in nf:
 scell.fmt.num_format = "Currency"
 elif "yy" in nf or "dd" in nf or "mm" in nf:
 scell.fmt.num_format = "Date"
 else:
 scell.fmt.num_format = "General"
 except Exception:
 pass
 sheets.append(sh)
 if not sheets:
 sheets = [Sheet("Sheet1")]
 self.workbook = Workbook(sheets=sheets, active_index=0)
 self._init_sheets()
 def _save_xlsx(self, path: str):
 if openpyxl is None:
 raise RuntimeError("openpyxl is required to save .xlsx")
 wb = openpyxl.Workbook()
 while wb.worksheets:
 wb.remove(wb.worksheets[0])
 for sh in self.workbook.sheets:
 ws = wb.create_sheet(sh.name)
 max_r, max_c = sh.rows, sh.cols
 for r in range(1, max_r + 1):
 for c in range(1, max_c + 1):
 cell = sh.cells.get((r - 1, c - 1))
 if cell is None:
 continue
 xcell = ws.cell(row=r, column=c)
 if cell.formula:
 xcell.value = "=" + cell.formula
 else:
 v = cell.raw
 if is_numberish(v):
 try:
 xcell.value = float(v) if "." in v else int(float(v))
 except Exception:
 xcell.value = v
 else:
 xcell.value = v
 try:
 xcell.font = XLFont(
 name=cell.fmt.font_family,
 sz=cell.fmt.font_size,
 bold=cell.fmt.bold,
 italic=cell.fmt.italic,
 underline="single" if cell.fmt.underline else None,
 color=(cell.fmt.fg.replace("#", "") if cell.fmt.fg else None),
 )
 if cell.fmt.bg:
 xcell.fill = XLFill("solid", fgColor=cell.fmt.bg.replace("#", ""))
 align = cell.fmt.align if cell.fmt.align in ("left", "center", "right") else "left"
 xcell.alignment = XLAlignment(horizontal=align, wrap_text=cell.fmt.wrap)
 nf = cell.fmt.num_format
 if nf == "Number":
 xcell.number_format = "0.00"
 elif nf == "Currency":
 xcell.number_format = "$#,##0.00"
 elif nf == "Percent":
 xcell.number_format = "0.00%"
 elif nf == "Date":
 xcell.number_format = "yyyy-mm-dd"
 elif nf == "Time":
 xcell.number_format = "hh:mm:ss"
 else:
 xcell.number_format = "General"
 except Exception:
 pass
 wb.save(path)
 def _about(self):
 QMessageBox.information(
 self,
 "About ExcelFree",
 "ExcelFree is a PyQt6 spreadsheet-style app.\n\n"
 "Included: sheets, ribbon-ish UI, formula bar, basic formulas (SUM/IF/etc), "
 "formatting, sort/filter, find/replace, CSV/XLSX open/save, copy/paste, selection stats.\n\n"
 "Goal: Excel-like feel, free + hackable."
 )
def main():
 app = QApplication(sys.argv)
 w = ExcelFree()
 w._excelish_theme()
 w.show()
 sys.exit(app.exec())
if __name__ == "__main__":
 main()

import sys, math
from pathlib import Path
from PyQt6.QtWidgets import (
 QApplication,
 QMainWindow,
 QTextEdit,
 QFileDialog,
 QMessageBox,
 QToolBar,
 QStatusBar,
 QFontComboBox,
 QComboBox,
 QColorDialog,
 QDialog,
 QDialogButtonBox,
 QLabel,
 QSpinBox,
 QHBoxLayout,
 QVBoxLayout,
 QWidget,
 QScrollArea,
 QListWidget,
 QPushButton,
 QLineEdit,
 QTextBrowser,
)
from PyQt6.QtGui import (
 QAction,
 QKeySequence,
 QTextCharFormat,
 QTextCursor,
 QFont,
 QColor,
 QTextListFormat,
 QTextBlockFormat,
 QPainter,
 QPen,
)
from PyQt6.QtCore import Qt, QSizeF, QRect
from PyQt6.QtPrintSupport import QPrinter, QPrintPreviewDialog
from PyQt6.QtWidgets import QListWidgetItem
from PyQt6.QtGui import QPixmap, QIcon, QAbstractTextDocumentLayout
from PyQt6.QtCore import QSize, QTimer, QRectF
from docx import Document
class PageSetupDialog(QDialog):
 def __init__(self, margins_mm: dict, parent=None):
 super().__init__(parent)
 self.setWindowTitle("Page Setup - Margins")
 self.margins_mm = margins_mm.copy()
 self.top_spin = QSpinBox(self)
 self.top_spin.setRange(5, 100)
 self.top_spin.setValue(int(margins_mm["top"]))
 self.bottom_spin = QSpinBox(self)
 self.bottom_spin.setRange(5, 100)
 self.bottom_spin.setValue(int(margins_mm["bottom"]))
 self.left_spin = QSpinBox(self)
 self.left_spin.setRange(5, 100)
 self.left_spin.setValue(int(margins_mm["left"]))
 self.right_spin = QSpinBox(self)
 self.right_spin.setRange(5, 100)
 self.right_spin.setValue(int(margins_mm["right"]))
 row_top = QHBoxLayout()
 row_top.addWidget(QLabel("Top margin (mm):"))
 row_top.addWidget(self.top_spin)
 row_bottom = QHBoxLayout()
 row_bottom.addWidget(QLabel("Bottom margin (mm):"))
 row_bottom.addWidget(self.bottom_spin)
 row_left = QHBoxLayout()
 row_left.addWidget(QLabel("Left margin (mm):"))
 row_left.addWidget(self.left_spin)
 row_right = QHBoxLayout()
 row_right.addWidget(QLabel("Right margin (mm):"))
 row_right.addWidget(self.right_spin)
 buttons = QDialogButtonBox(
 QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel,
 parent=self,
 )
 buttons.accepted.connect(self.accept)
 buttons.rejected.connect(self.reject)
 layout = QVBoxLayout()
 layout.addLayout(row_top)
 layout.addLayout(row_bottom)
 layout.addLayout(row_left)
 layout.addLayout(row_right)
 layout.addWidget(buttons)
 self.setLayout(layout)
 def get_margins(self) -> dict:
 return {
 "top": float(self.top_spin.value()),
 "bottom": float(self.bottom_spin.value()),
 "left": float(self.left_spin.value()),
 "right": float(self.right_spin.value()),
 }
class PageContainer(QWidget):
 def __init__(self, editor: QTextEdit, parent=None):
 super().__init__(parent)
 self.editor = editor
 self.page_height_px = 800
 self.page_gap_px = 24
 def set_page_metrics(self, page_height_px: float, page_gap_px: float):
 self.page_height_px = page_height_px
 self.page_gap_px = page_gap_px
 self.update()
 def paintEvent(self, event):
 painter = QPainter(self)
 painter.fillRect(self.rect(), QColor("#D9D9D9"))
 geom = self.editor.geometry()
 if geom.isNull():
 return
 doc = self.editor.document()
 layout = doc.documentLayout()
 if layout is None:
 return
 size = layout.documentSize()
 doc_height_px = size.height()
 page_height = self.page_height_px if self.page_height_px > 0 else geom.height()
 if page_height <= 0:
 page_height = 1
 page_count = max(1, int(math.ceil(doc_height_px / page_height)))
 white = QColor("white")
 border_color = QColor("#B0B0B0")
 pen = QPen(border_color)
 painter.setPen(pen)
 left = int(geom.left())
 top0 = int(geom.top())
 width = int(geom.width())
 height = int(page_height)
 for i in range(page_count):
 y = int(top0 + i * (height + self.page_gap_px))
 r = QRect(left, y, width, height)
 painter.fillRect(r, white)
 painter.drawRect(r)
class WordLikeEditor(QMainWindow):
 def __init__(self):
 super().__init__()
 self.current_file: Path | None = None
 self.is_modified = False
 self._ignore_selection_change = False
 self.page_width_mm = 215.9
 self.page_height_mm = 279.4
 self.margins_mm = {
 "top": 25.4,
 "bottom": 25.4,
 "left": 25.4,
 "right": 25.4,
 }
 self.base_zoom = 0
 self.zoom_percent = 100
 self.page_gap_px = 24
 self._thumb_timer = QTimer(self)
 self._thumb_timer.setSingleShot(True)
 self._thumb_timer.timeout.connect(self.rebuild_page_thumbnails)
 self.init_ui()
 def init_ui(self):
 self.setWindowTitle("Free Word-like Editor - Document1")
 self.resize(1200, 750)
 self.editor = QTextEdit(self)
 self.editor.setAcceptRichText(True)
 self.editor.setLineWrapMode(QTextEdit.LineWrapMode.FixedPixelWidth)
 self.editor.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
 self.editor.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
 self.editor.textChanged.connect(self.on_text_changed)
 self.editor.cursorPositionChanged.connect(self.on_cursor_position_changed)
 self.editor.document().documentLayout().documentSizeChanged.connect(
 self.on_document_size_changed
 )
 self.page_container = PageContainer(self.editor)
 self.page_container.setObjectName("pageContainer")
 page_layout = QVBoxLayout(self.page_container)
 page_layout.setContentsMargins(40, 40, 40, 40)
 page_layout.addWidget(self.editor)
 self.page_viewport = QWidget()
 self.page_viewport.setObjectName("pageViewport")
 viewport_layout = QHBoxLayout(self.page_viewport)
 viewport_layout.setContentsMargins(0, 0, 0, 0)
 viewport_layout.setSpacing(0)
 viewport_layout.addStretch(1)
 viewport_layout.addWidget(self.page_container)
 viewport_layout.addStretch(1)
 self.scroll_area = QScrollArea(self)
 self.scroll_area.setWidgetResizable(True)
 self.scroll_area.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
 self.scroll_area.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 self.scroll_area.setWidget(self.page_viewport)
 self.page_preview = QListWidget(self)
 self.page_preview.setObjectName("pagePreview")
 self.page_preview.setFixedWidth(140)
 self.page_preview.itemSelectionChanged.connect(self.on_page_preview_selected)
 self.page_preview.setSpacing(10)
 self.page_preview.setIconSize(QSize(110, 150)) 
 self.ai_panel = QWidget(self)
 ai_layout = QVBoxLayout(self.ai_panel)
 ai_layout.setContentsMargins(8, 8, 8, 8)
 ai_layout.setSpacing(6)
 ai_title = QLabel("AI Helper (offline)")
 ai_title.setAlignment(Qt.AlignmentFlag.AlignCenter)
 ai_title.setStyleSheet("font-weight: bold;")
 self.ai_input = QLineEdit(self.ai_panel)
 self.ai_input.setPlaceholderText("Ask about this document...")
 self.ai_input.returnPressed.connect(self.handle_ai_question)
 self.ai_button = QPushButton("Ask", self.ai_panel)
 self.ai_button.clicked.connect(self.handle_ai_question)
 self.ai_output = QTextBrowser(self.ai_panel)
 self.ai_output.setMinimumHeight(150)
 self.ai_output.setOpenExternalLinks(True)
 ai_layout.addWidget(ai_title)
 ai_layout.addWidget(self.ai_input)
 ai_layout.addWidget(self.ai_button)
 ai_layout.addWidget(self.ai_output, 1)
 self.ai_panel.setFixedWidth(260)
 self.ai_panel.setObjectName("aiPanel")
 central = QWidget(self)
 central_layout = QHBoxLayout(central)
 central_layout.setContentsMargins(10, 10, 10, 10)
 central_layout.setSpacing(10)
 central_layout.addWidget(self.page_preview)
 central_layout.addWidget(self.scroll_area, 1)
 central_layout.addWidget(self.ai_panel)
 self.setCentralWidget(central)
 self.init_actions()
 self.init_menus()
 self.init_toolbar()
 self.init_statusbar()
 default_font = QFont("Calibri", 11)
 self.editor.setFont(default_font)
 self.setStyleSheet(
 """
 QMainWindow {
 background-color: #D9D9D9;
 }
 QScrollArea {
 background-color: #D9D9D9;
 border: none;
 }
 QWidget#pageViewport {
 background-color: #D9D9D9;
 }
 QWidget#pageContainer {
 background-color: white;
 border: 1px solid #B0B0B0;
 }
 QTextEdit {
 background-color: transparent;
 border: none;
 }
 QListWidget#pagePreview {
 background-color: #E5E5E5;
 border: 1px solid #B0B0B0;
 }
 QWidget#aiPanel {
 background-color: #F2F2F2;
 border: 1px solid #B0B0B0;
 }
 """
 )
 self.update_page_layout()
 self.apply_style("Normal")
 def mm_to_px(self, mm: float) -> float:
 dpi = self.logicalDpiX() or 96
 return mm * dpi / 25.4
 def schedule_page_thumbnails(self):
 self._thumb_timer.start(120)
 def _thumb_metrics(self):
 doc = self.editor.document()
 page = doc.pageSize()
 page_w = float(page.width())
 page_h = float(page.height())
 if page_w <= 1 or page_h <= 1:
 page_w = float(self.mm_to_px(self.page_width_mm))
 page_h = float(self.mm_to_px(self.page_height_mm))
 thumb_w = max(90, int(self.page_preview.viewport().width() - 24))
 scale = thumb_w / page_w
 thumb_h = max(1, int(page_h * scale))
 return thumb_w, thumb_h, scale, page_w, page_h
 def render_page_thumbnail(self, page_index: int) -> QPixmap:
 thumb_w, thumb_h, scale, page_w, page_h = self._thumb_metrics()
 pix = QPixmap(thumb_w, thumb_h)
 pix.fill(Qt.GlobalColor.white)
 p = QPainter(pix)
 p.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 p.setRenderHint(QPainter.RenderHint.TextAntialiasing, True)
 p.scale(scale, scale)
 p.setClipRect(QRectF(0, 0, page_w, page_h))
 p.translate(0, -page_index * page_h)
 ctx = QAbstractTextDocumentLayout.PaintContext()
 self.editor.document().documentLayout().draw(p, ctx)
 p.end()
 p2 = QPainter(pix)
 p2.setPen(QPen(QColor("#B0B0B0"), 1))
 p2.drawRect(pix.rect().adjusted(0, 0, -1, -1))
 p2.end()
 return pix
 def rebuild_page_thumbnails(self):
 _, page_count = self.get_page_info()
 if page_count <= 0:
 return
 thumb_w, thumb_h, *_ = self._thumb_metrics()
 self.page_preview.setIconSize(QSize(thumb_w, thumb_h))
 self.page_preview.blockSignals(True)
 if self.page_preview.count() != page_count:
 self.page_preview.clear()
 for i in range(page_count):
 it = QListWidgetItem(str(i + 1))
 it.setTextAlignment(Qt.AlignmentFlag.AlignHCenter)
 self.page_preview.addItem(it)
 for i in range(page_count):
 it = self.page_preview.item(i)
 pix = self.render_page_thumbnail(i)
 it.setIcon(QIcon(pix))
 it.setSizeHint(QSize(thumb_w + 18, thumb_h + 28))
 self.page_preview.blockSignals(False)
 def update_page_layout(self):
 content_width_mm = (
 self.page_width_mm - self.margins_mm["left"] - self.margins_mm["right"]
 )
 content_width_px = int(self.mm_to_px(content_width_mm))
 if content_width_px < 400:
 content_width_px = 400
 self.editor.setLineWrapColumnOrWidth(content_width_px)
 doc = self.editor.document()
 page_width_px = self.mm_to_px(self.page_width_mm)
 page_height_px = self.mm_to_px(self.page_height_mm)
 doc.setPageSize(QSizeF(page_width_px, page_height_px))
 root = doc.rootFrame()
 fmt = root.frameFormat()
 fmt.setLeftMargin(self.mm_to_px(self.margins_mm["left"]))
 fmt.setRightMargin(self.mm_to_px(self.margins_mm["right"]))
 fmt.setTopMargin(self.mm_to_px(self.margins_mm["top"]))
 fmt.setBottomMargin(self.mm_to_px(self.margins_mm["bottom"]))
 root.setFrameFormat(fmt)
 self.update_document_size()
 def update_document_size(self):
 doc = self.editor.document()
 layout = doc.documentLayout()
 if layout is None:
 return
 size = layout.documentSize()
 doc_height_px = size.height()
 page_width_px = self.mm_to_px(self.page_width_mm)
 editor_width = int(
 page_width_px
 - self.mm_to_px(self.margins_mm["left"] + self.margins_mm["right"])
 )
 if editor_width < 400:
 editor_width = 400
 page_height_px = self.mm_to_px(self.page_height_mm)
 if page_height_px <= 0:
 page_height_px = doc_height_px if doc_height_px > 0 else 800
 total_content_height = max(page_height_px, doc_height_px)
 page_count = max(1, int(math.ceil(total_content_height / page_height_px)))
 editor_height = int(page_count * page_height_px + (page_count - 1) * self.page_gap_px)
 self.editor.setFixedWidth(editor_width)
 self.editor.setMinimumHeight(editor_height)
 self.page_container.setFixedWidth(editor_width + 80)
 self.page_container.setMinimumHeight(editor_height + 80)
 self.page_container.set_page_metrics(page_height_px, self.page_gap_px)
 def on_document_size_changed(self, new_size: QSizeF):
 self.update_document_size()
 self.update_status_bar()
 self.schedule_page_thumbnails()
 def resizeEvent(self, event):
 super().resizeEvent(event)
 self.update_page_layout()
 def init_actions(self):
 self.new_action = QAction("New", self)
 self.new_action.setShortcut(QKeySequence.StandardKey.New)
 self.new_action.triggered.connect(self.new_file)
 self.open_action = QAction("Open...", self)
 self.open_action.setShortcut(QKeySequence.StandardKey.Open)
 self.open_action.triggered.connect(self.open_file)
 self.save_action = QAction("Save", self)
 self.save_action.setShortcut(QKeySequence.StandardKey.Save)
 self.save_action.triggered.connect(self.save_file)
 self.save_as_action = QAction("Save As...", self)
 self.save_as_action.setShortcut(QKeySequence.StandardKey.SaveAs)
 self.save_as_action.triggered.connect(self.save_file_as)
 self.export_pdf_action = QAction("Export as PDF...", self)
 self.export_pdf_action.triggered.connect(self.export_pdf)
 self.print_action = QAction("Print...", self)
 self.print_action.setShortcut(QKeySequence.StandardKey.Print)
 self.print_action.triggered.connect(self.print_document)
 self.page_setup_action = QAction("Page Setup...", self)
 self.page_setup_action.triggered.connect(self.show_page_setup)
 self.exit_action = QAction("Exit", self)
 self.exit_action.setShortcut(QKeySequence.StandardKey.Quit)
 self.exit_action.triggered.connect(self.close)
 self.undo_action = QAction("Undo", self)
 self.undo_action.setShortcut(QKeySequence.StandardKey.Undo)
 self.undo_action.triggered.connect(self.editor.undo)
 self.redo_action = QAction("Redo", self)
 self.redo_action.setShortcut(QKeySequence.StandardKey.Redo)
 self.redo_action.triggered.connect(self.editor.redo)
 self.cut_action = QAction("Cut", self)
 self.cut_action.setShortcut(QKeySequence.StandardKey.Cut)
 self.cut_action.triggered.connect(self.editor.cut)
 self.copy_action = QAction("Copy", self)
 self.copy_action.setShortcut(QKeySequence.StandardKey.Copy)
 self.copy_action.triggered.connect(self.editor.copy)
 self.paste_action = QAction("Paste", self)
 self.paste_action.setShortcut(QKeySequence.StandardKey.Paste)
 self.paste_action.triggered.connect(self.editor.paste)
 self.select_all_action = QAction("Select All", self)
 self.select_all_action.setShortcut(QKeySequence.StandardKey.SelectAll)
 self.select_all_action.triggered.connect(self.editor.selectAll)
 self.bold_action = QAction("B", self)
 self.bold_action.setCheckable(True)
 self.bold_action.setShortcut(QKeySequence("Ctrl+B"))
 self.bold_action.triggered.connect(self.toggle_bold)
 self.italic_action = QAction("I", self)
 self.italic_action.setCheckable(True)
 self.italic_action.setShortcut(QKeySequence("Ctrl+I"))
 self.italic_action.triggered.connect(self.toggle_italic)
 self.underline_action = QAction("U", self)
 self.underline_action.setCheckable(True)
 self.underline_action.setShortcut(QKeySequence("Ctrl+U"))
 self.underline_action.triggered.connect(self.toggle_underline)
 self.strike_action = QAction("abc", self)
 self.strike_action.setCheckable(True)
 self.strike_action.triggered.connect(self.toggle_strike)
 self.align_left_action = QAction("Left", self)
 self.align_left_action.setCheckable(True)
 self.align_left_action.setShortcut(QKeySequence("Ctrl+L"))
 self.align_left_action.triggered.connect(
 lambda: self.editor.setAlignment(Qt.AlignmentFlag.AlignLeft)
 )
 self.align_center_action = QAction("Center", self)
 self.align_center_action.setCheckable(True)
 self.align_center_action.setShortcut(QKeySequence("Ctrl+E"))
 self.align_center_action.triggered.connect(
 lambda: self.editor.setAlignment(Qt.AlignmentFlag.AlignHCenter)
 )
 self.align_right_action = QAction("Right", self)
 self.align_right_action.setCheckable(True)
 self.align_right_action.setShortcut(QKeySequence("Ctrl+R"))
 self.align_right_action.triggered.connect(
 lambda: self.editor.setAlignment(Qt.AlignmentFlag.AlignRight)
 )
 self.align_justify_action = QAction("Justify", self)
 self.align_justify_action.setCheckable(True)
 self.align_justify_action.setShortcut(QKeySequence("Ctrl+J"))
 self.align_justify_action.triggered.connect(
 lambda: self.editor.setAlignment(Qt.AlignmentFlag.AlignJustify)
 )
 self.bullet_list_action = QAction("• Bullets", self)
 self.bullet_list_action.triggered.connect(self.make_bullet_list)
 self.number_list_action = QAction("1. Numbering", self)
 self.number_list_action.triggered.connect(self.make_number_list)
 self.clear_format_action = QAction("Clear Formatting", self)
 self.clear_format_action.triggered.connect(self.clear_formatting)
 self.text_color_action = QAction("Text Color", self)
 self.text_color_action.triggered.connect(self.choose_text_color)
 self.highlight_action = QAction("Highlight", self)
 self.highlight_action.triggered.connect(self.choose_highlight_color)
 self.zoom_in_action = QAction("Zoom In", self)
 self.zoom_in_action.setShortcut(QKeySequence("Ctrl++"))
 self.zoom_in_action.triggered.connect(lambda: self.adjust_zoom(1))
 self.zoom_out_action = QAction("Zoom Out", self)
 self.zoom_out_action.setShortcut(QKeySequence("Ctrl+-"))
 self.zoom_out_action.triggered.connect(lambda: self.adjust_zoom(-1))
 self.zoom_reset_action = QAction("Reset Zoom", self)
 self.zoom_reset_action.triggered.connect(self.reset_zoom)
 self.insert_image_action = QAction("Insert Image...", self)
 self.insert_image_action.triggered.connect(self.insert_image)
 self.insert_datetime_action = QAction("Insert Date/Time", self)
 self.insert_datetime_action.triggered.connect(self.insert_datetime)
 self.single_space_action = QAction("Line spacing: 1.0", self)
 self.single_space_action.triggered.connect(
 lambda: self.set_line_spacing(1.0)
 )
 self.space_1_5_action = QAction("Line spacing: 1.5", self)
 self.space_1_5_action.triggered.connect(
 lambda: self.set_line_spacing(1.5)
 )
 self.double_space_action = QAction("Line spacing: 2.0", self)
 self.double_space_action.triggered.connect(
 lambda: self.set_line_spacing(2.0)
 )
 self.increase_indent_action = QAction("Increase Indent", self)
 self.increase_indent_action.triggered.connect(
 lambda: self.change_indent(20)
 )
 self.decrease_indent_action = QAction("Decrease Indent", self)
 self.decrease_indent_action.triggered.connect(
 lambda: self.change_indent(-20)
 )
 self.increase_paragraph_space_action = QAction("Increase Paragraph Spacing", self)
 self.increase_paragraph_space_action.triggered.connect(
 lambda: self.change_paragraph_spacing(4.0)
 )
 self.decrease_paragraph_space_action = QAction("Decrease Paragraph Spacing", self)
 self.decrease_paragraph_space_action.triggered.connect(
 lambda: self.change_paragraph_spacing(-4.0)
 )
 def init_menus(self):
 menubar = self.menuBar()
 file_menu = menubar.addMenu("&File")
 file_menu.addAction(self.new_action)
 file_menu.addAction(self.open_action)
 file_menu.addSeparator()
 file_menu.addAction(self.save_action)
 file_menu.addAction(self.save_as_action)
 file_menu.addAction(self.export_pdf_action)
 file_menu.addSeparator()
 file_menu.addAction(self.print_action)
 file_menu.addAction(self.page_setup_action)
 file_menu.addSeparator()
 file_menu.addAction(self.exit_action)
 edit_menu = menubar.addMenu("&Edit")
 edit_menu.addAction(self.undo_action)
 edit_menu.addAction(self.redo_action)
 edit_menu.addSeparator()
 edit_menu.addAction(self.cut_action)
 edit_menu.addAction(self.copy_action)
 edit_menu.addAction(self.paste_action)
 edit_menu.addAction(self.select_all_action)
 edit_menu.addSeparator()
 edit_menu.addAction(self.clear_format_action)
 format_menu = menubar.addMenu("F&ormat")
 format_menu.addAction(self.bold_action)
 format_menu.addAction(self.italic_action)
 format_menu.addAction(self.underline_action)
 format_menu.addAction(self.strike_action)
 format_menu.addSeparator()
 format_menu.addAction(self.text_color_action)
 format_menu.addAction(self.highlight_action)
 format_menu.addSeparator()
 format_menu.addAction(self.single_space_action)
 format_menu.addAction(self.space_1_5_action)
 format_menu.addAction(self.double_space_action)
 paragraph_menu = menubar.addMenu("&Paragraph")
 paragraph_menu.addAction(self.align_left_action)
 paragraph_menu.addAction(self.align_center_action)
 paragraph_menu.addAction(self.align_right_action)
 paragraph_menu.addAction(self.align_justify_action)
 paragraph_menu.addSeparator()
 paragraph_menu.addAction(self.bullet_list_action)
 paragraph_menu.addAction(self.number_list_action)
 paragraph_menu.addSeparator()
 paragraph_menu.addAction(self.increase_indent_action)
 paragraph_menu.addAction(self.decrease_indent_action)
 paragraph_menu.addSeparator()
 paragraph_menu.addAction(self.increase_paragraph_space_action)
 paragraph_menu.addAction(self.decrease_paragraph_space_action)
 insert_menu = menubar.addMenu("&Insert")
 insert_menu.addAction(self.insert_image_action)
 insert_menu.addAction(self.insert_datetime_action)
 view_menu = menubar.addMenu("&View")
 view_menu.addAction(self.zoom_in_action)
 view_menu.addAction(self.zoom_out_action)
 view_menu.addAction(self.zoom_reset_action)
 def init_toolbar(self):
 toolbar = QToolBar("Main Toolbar", self)
 toolbar.setMovable(False)
 self.addToolBar(toolbar)
 toolbar.addAction(self.new_action)
 toolbar.addAction(self.open_action)
 toolbar.addAction(self.save_action)
 toolbar.addAction(self.print_action)
 toolbar.addSeparator()
 toolbar.addAction(self.undo_action)
 toolbar.addAction(self.redo_action)
 toolbar.addSeparator()
 toolbar.addAction(self.cut_action)
 toolbar.addAction(self.copy_action)
 toolbar.addAction(self.paste_action)
 toolbar.addSeparator()
 self.font_combo = QFontComboBox(self)
 self.font_combo.currentFontChanged.connect(self.set_font_family)
 toolbar.addWidget(self.font_combo)
 self.size_combo = QComboBox(self)
 for size in [8, 9, 10, 11, 12, 14, 16, 18, 20, 22, 24, 28, 32, 36]:
 self.size_combo.addItem(str(size))
 self.size_combo.setCurrentText("11")
 self.size_combo.currentTextChanged.connect(self.set_font_size)
 toolbar.addWidget(self.size_combo)
 self.style_combo = QComboBox(self)
 self.style_combo.addItems(["Normal", "Heading 1", "Heading 2", "Title"])
 self.style_combo.currentTextChanged.connect(self.apply_style)
 toolbar.addWidget(self.style_combo)
 toolbar.addSeparator()
 toolbar.addAction(self.bold_action)
 toolbar.addAction(self.italic_action)
 toolbar.addAction(self.underline_action)
 toolbar.addAction(self.strike_action)
 toolbar.addSeparator()
 toolbar.addAction(self.align_left_action)
 toolbar.addAction(self.align_center_action)
 toolbar.addAction(self.align_right_action)
 toolbar.addAction(self.align_justify_action)
 toolbar.addSeparator()
 toolbar.addAction(self.bullet_list_action)
 toolbar.addAction(self.number_list_action)
 toolbar.addSeparator()
 toolbar.addAction(self.text_color_action)
 toolbar.addAction(self.highlight_action)
 toolbar.addSeparator()
 toolbar.addAction(self.zoom_in_action)
 toolbar.addAction(self.zoom_out_action)
 toolbar.addAction(self.zoom_reset_action)
 def init_statusbar(self):
 self.status = QStatusBar(self)
 self.setStatusBar(self.status)
 self.update_status_bar()
 def get_page_info(self):
 doc = self.editor.document()
 layout = doc.documentLayout()
 if layout is None:
 return 1, 1
 size = layout.documentSize()
 total_height = size.height()
 page_height_px = self.mm_to_px(self.page_height_mm)
 if page_height_px <= 0:
 return 1, 1
 page_count = max(1, int(math.ceil(total_height / page_height_px)))
 cursor = self.editor.textCursor()
 block_rect = layout.blockBoundingRect(cursor.block())
 y = block_rect.center().y()
 current_page = int(y // page_height_px) + 1
 if current_page < 1:
 current_page = 1
 if current_page > page_count:
 current_page = page_count
 return current_page, page_count
 def update_page_preview(self):
 current_page, page_count = self.get_page_info()
 if self.page_preview.count() != page_count:
 self.schedule_page_thumbnails()
 self.page_preview.blockSignals(True)
 self.page_preview.clear()
 for i in range(page_count):
 self.page_preview.addItem(f"Page {i + 1}")
 self.page_preview.blockSignals(False)
 if 0 <= current_page - 1 < self.page_preview.count():
 self.page_preview.blockSignals(True)
 self.page_preview.setCurrentRow(current_page - 1)
 self.page_preview.blockSignals(False)
 def on_page_preview_selected(self):
 row = self.page_preview.currentRow()
 if row < 0:
 return
 page_height_px = self.mm_to_px(self.page_height_mm)
 scroll = self.scroll_area.verticalScrollBar()
 target = int(row * (page_height_px + self.page_gap_px))
 scroll.setValue(target)
 def update_status_bar(self):
 text = self.editor.toPlainText()
 chars = len(text)
 words = len(text.split())
 if self.current_file:
 name = self.current_file.name
 else:
 name = "Document1"
 current_page, page_count = self.get_page_info()
 self.status.showMessage(
 f"{name} | Page {current_page} of {page_count} | {words} words, {chars} characters | Zoom: {self.zoom_percent}%"
 )
 self.update_page_preview()
 def on_text_changed(self):
 self.is_modified = True
 self.update_status_bar()
 self.schedule_page_thumbnails()
 def on_cursor_position_changed(self):
 if self._ignore_selection_change:
 return
 cursor = self.editor.textCursor()
 fmt = cursor.charFormat()
 self._ignore_selection_change = True
 self.bold_action.setChecked(fmt.fontWeight() == QFont.Weight.Bold)
 self.italic_action.setChecked(fmt.fontItalic())
 self.underline_action.setChecked(fmt.fontUnderline())
 self.strike_action.setChecked(fmt.fontStrikeOut())
 self._ignore_selection_change = False
 self.update_status_bar()
 def maybe_save(self) -> bool:
 if not self.is_modified:
 return True
 reply = QMessageBox.question(
 self,
 "Unsaved Changes",
 "The document has been modified. Do you want to save changes?",
 QMessageBox.StandardButton.Save
 | QMessageBox.StandardButton.Discard
 | QMessageBox.StandardButton.Cancel,
 )
 if reply == QMessageBox.StandardButton.Save:
 return self.save_file()
 if reply == QMessageBox.StandardButton.Cancel:
 return False
 return True
 def closeEvent(self, event):
 if self.maybe_save():
 event.accept()
 else:
 event.ignore()
 def new_file(self):
 if not self.maybe_save():
 return
 self.editor.clear()
 self.current_file = None
 self.is_modified = False
 self.setWindowTitle("Free Word-like Editor - Document1")
 self.style_combo.setCurrentText("Normal")
 self.apply_style("Normal")
 self.update_status_bar()
 def open_file(self):
 if not self.maybe_save():
 return
 path_str, _ = QFileDialog.getOpenFileName(
 self,
 "Open Document",
 "",
 "Documents (*.docx *.html *.htm *.txt);;All Files (*.*)",
 )
 if not path_str:
 return
 path = Path(path_str)
 try:
 if path.suffix.lower() == ".docx":
 self.load_docx(path)
 elif path.suffix.lower() in {".html", ".htm"}:
 self.load_html(path)
 else:
 self.load_txt(path)
 self.current_file = path
 self.is_modified = False
 self.setWindowTitle(f"Free Word-like Editor - {path.name}")
 self.update_status_bar()
 except Exception as e:
 QMessageBox.critical(self, "Error", f"Could not open file:\n{e}")
 def save_file(self) -> bool:
 if self.current_file is None:
 return self.save_file_as()
 try:
 self.save_to_path(self.current_file)
 self.is_modified = False
 self.update_status_bar()
 return True
 except Exception as e:
 QMessageBox.critical(self, "Error", f"Could not save file:\n{e}")
 return False
 def save_file_as(self) -> bool:
 path_str, selected_filter = QFileDialog.getSaveFileName(
 self,
 "Save Document As",
 str(self.current_file) if self.current_file else "",
 "Word document (*.docx);;HTML document (*.html);;Text file (*.txt)",
 )
 if not path_str:
 return False
 path = Path(path_str)
 if path.suffix == "":
 if "Word document" in selected_filter:
 path = path.with_suffix(".docx")
 elif "HTML document" in selected_filter:
 path = path.with_suffix(".html")
 else:
 path = path.with_suffix(".txt")
 try:
 self.save_to_path(path)
 self.current_file = path
 self.is_modified = False
 self.setWindowTitle(f"Free Word-like Editor - {path.name}")
 self.update_status_bar()
 return True
 except Exception as e:
 QMessageBox.critical(self, "Error", f"Could not save file:\n{e}")
 return False
 def save_to_path(self, path: Path):
 ext = path.suffix.lower()
 if ext == ".docx":
 self.save_docx(path)
 elif ext in {".html", ".htm"}:
 self.save_html(path)
 else:
 self.save_txt(path)
 def load_txt(self, path: Path):
 with path.open("r", encoding="utf-8", errors="ignore") as f:
 text = f.read()
 self.editor.setPlainText(text)
 def save_txt(self, path: Path):
 text = self.editor.toPlainText()
 with path.open("w", encoding="utf-8", errors="ignore") as f:
 f.write(text)
 def load_html(self, path: Path):
 with path.open("r", encoding="utf-8", errors="ignore") as f:
 html = f.read()
 self.editor.setHtml(html)
 def save_html(self, path: Path):
 html = self.editor.toHtml()
 with path.open("w", encoding="utf-8", errors="ignore") as f:
 f.write(html)
 def load_docx(self, path: Path):
 from html import escape
 doc = Document(str(path))
 html_parts = []
 for para in doc.paragraphs:
 if not para.runs:
 html_parts.append(" ")
 continue
 para_html = [""]
 for run in para.runs:
 text = escape(run.text)
 if not text:
 continue
 if run.bold:
 text = f"{text}"
 if run.italic:
 text = f"{text}"
 if run.underline:
 text = f"{text}"
 para_html.append(text)
 para_html.append("")
 html_parts.append("".join(para_html))
 html = "".join(html_parts) if html_parts else " "
 self.editor.setHtml(html)
 def save_docx(self, path: Path):
 text = self.editor.toPlainText()
 doc = Document()
 for line in text.splitlines():
 doc.add_paragraph(line)
 doc.save(str(path))
 def merge_format_on_selection(self, fmt: QTextCharFormat):
 cursor = self.editor.textCursor()
 if not cursor.hasSelection():
 cursor.select(QTextCursor.SelectionType.WordUnderCursor)
 cursor.mergeCharFormat(fmt)
 self.editor.mergeCurrentCharFormat(fmt)
 def toggle_bold(self):
 if self._ignore_selection_change:
 return
 fmt = QTextCharFormat()
 weight = QFont.Weight.Bold if self.bold_action.isChecked() else QFont.Weight.Normal
 fmt.setFontWeight(weight)
 self.merge_format_on_selection(fmt)
 def toggle_italic(self):
 if self._ignore_selection_change:
 return
 fmt = QTextCharFormat()
 fmt.setFontItalic(self.italic_action.isChecked())
 self.merge_format_on_selection(fmt)
 def toggle_underline(self):
 if self._ignore_selection_change:
 return
 fmt = QTextCharFormat()
 fmt.setFontUnderline(self.underline_action.isChecked())
 self.merge_format_on_selection(fmt)
 def toggle_strike(self):
 if self._ignore_selection_change:
 return
 fmt = QTextCharFormat()
 fmt.setFontStrikeOut(self.strike_action.isChecked())
 self.merge_format_on_selection(fmt)
 def set_font_family(self, font: QFont):
 fmt = QTextCharFormat()
 fmt.setFontFamily(font.family())
 self.merge_format_on_selection(fmt)
 def set_font_size(self, size_str: str):
 try:
 size = float(size_str)
 except ValueError:
 return
 fmt = QTextCharFormat()
 fmt.setFontPointSize(size)
 self.merge_format_on_selection(fmt)
 def make_bullet_list(self):
 cursor = self.editor.textCursor()
 fmt = QTextListFormat()
 fmt.setStyle(QTextListFormat.Style.ListDisc)
 cursor.createList(fmt)
 def make_number_list(self):
 cursor = self.editor.textCursor()
 fmt = QTextListFormat()
 fmt.setStyle(QTextListFormat.Style.ListDecimal)
 cursor.createList(fmt)
 def clear_formatting(self):
 cursor = self.editor.textCursor()
 cursor.beginEditBlock()
 if cursor.hasSelection():
 cursor.setCharFormat(QTextCharFormat())
 else:
 cursor.select(QTextCursor.SelectionType.BlockUnderCursor)
 cursor.setCharFormat(QTextCharFormat())
 cursor.endEditBlock()
 def choose_text_color(self):
 color = QColorDialog.getColor(self.editor.textColor(), self, "Select Text Color")
 if not color.isValid():
 return
 fmt = QTextCharFormat()
 fmt.setForeground(color)
 self.merge_format_on_selection(fmt)
 def choose_highlight_color(self):
 base_color = self.editor.palette().base().color()
 color = QColorDialog.getColor(base_color, self, "Select Highlight Color")
 if not color.isValid():
 return
 fmt = QTextCharFormat()
 fmt.setBackground(color)
 self.merge_format_on_selection(fmt)
 def set_line_spacing(self, factor: float):
 cursor = self.editor.textCursor()
 cursor.beginEditBlock()
 block_fmt = cursor.blockFormat()
 block_fmt.setLineHeight(
 int(100 * factor),
 1,
 )
 cursor.setBlockFormat(block_fmt)
 cursor.endEditBlock()
 def change_indent(self, delta_px: int):
 cursor = self.editor.textCursor()
 cursor.beginEditBlock()
 block_fmt = cursor.blockFormat()
 new_margin = max(0.0, block_fmt.leftMargin() + float(delta_px))
 block_fmt.setLeftMargin(new_margin)
 cursor.setBlockFormat(block_fmt)
 cursor.endEditBlock()
 def change_paragraph_spacing(self, delta_points: float):
 cursor = self.editor.textCursor()
 cursor.beginEditBlock()
 block_fmt = cursor.blockFormat()
 new_top = max(0.0, block_fmt.topMargin() + delta_points)
 new_bottom = max(0.0, block_fmt.bottomMargin() + delta_points)
 block_fmt.setTopMargin(new_top)
 block_fmt.setBottomMargin(new_bottom)
 cursor.setBlockFormat(block_fmt)
 cursor.endEditBlock()
 def adjust_zoom(self, delta: int):
 if delta > 0:
 self.editor.zoomIn(delta)
 elif delta < 0:
 self.editor.zoomOut(-delta)
 self.base_zoom += delta
 self.zoom_percent = max(30, min(500, self.zoom_percent + delta * 10))
 self.update_status_bar()
 def reset_zoom(self):
 if self.base_zoom > 0:
 self.editor.zoomOut(self.base_zoom)
 elif self.base_zoom < 0:
 self.editor.zoomIn(-self.base_zoom)
 self.base_zoom = 0
 self.zoom_percent = 100
 self.update_status_bar()
 def insert_image(self):
 path_str, _ = QFileDialog.getOpenFileName(
 self,
 "Insert Image",
 "",
 "Images (*.png *.jpg *.jpeg *.bmp *.gif);;All Files (*.*)",
 )
 if not path_str:
 return
 cursor = self.editor.textCursor()
 cursor.insertImage(path_str)
 def insert_datetime(self):
 from datetime import datetime
 now = datetime.now().strftime("%Y-%m-%d %H:%M")
 cursor = self.editor.textCursor()
 cursor.insertText(now)
 def print_document(self):
 printer = QPrinter(QPrinter.PrinterMode.HighResolution)
 preview = QPrintPreviewDialog(printer, self)
 preview.setWindowTitle("Print Preview")
 preview.paintRequested.connect(self.editor.print)
 preview.exec()
 def export_pdf(self):
 path_str, _ = QFileDialog.getSaveFileName(
 self,
 "Export as PDF",
 (str(self.current_file) + ".pdf") if self.current_file else "document.pdf",
 "PDF Files (*.pdf)",
 )
 if not path_str:
 return
 printer = QPrinter(QPrinter.PrinterMode.HighResolution)
 printer.setOutputFormat(QPrinter.OutputFormat.PdfFormat)
 printer.setOutputFileName(path_str)
 self.editor.document().print(printer)
 def show_page_setup(self):
 dlg = PageSetupDialog(self.margins_mm, self)
 if dlg.exec():
 self.margins_mm = dlg.get_margins()
 self.update_page_layout()
 def apply_style(self, style_name: str):
 cursor = self.editor.textCursor()
 block_fmt = cursor.blockFormat()
 char_fmt = QTextCharFormat()
 if style_name == "Normal":
 char_fmt.setFontPointSize(11)
 char_fmt.setFontWeight(QFont.Weight.Normal)
 block_fmt.setLineHeight(120, 1)
 elif style_name == "Heading 1":
 char_fmt.setFontPointSize(18)
 char_fmt.setFontWeight(QFont.Weight.Bold)
 block_fmt.setLineHeight(130, 1)
 block_fmt.setAlignment(Qt.AlignmentFlag.AlignLeft)
 elif style_name == "Heading 2":
 char_fmt.setFontPointSize(14)
 char_fmt.setFontWeight(QFont.Weight.Bold)
 block_fmt.setLineHeight(130, 1)
 block_fmt.setAlignment(Qt.AlignmentFlag.AlignLeft)
 elif style_name == "Title":
 char_fmt.setFontPointSize(24)
 char_fmt.setFontWeight(QFont.Weight.Bold)
 block_fmt.setLineHeight(140, 1)
 block_fmt.setAlignment(Qt.AlignmentFlag.AlignHCenter)

cursor.beginEditBlock()
 cursor.setBlockFormat(block_fmt)
 cursor.mergeCharFormat(char_fmt)
 cursor.endEditBlock()
 def handle_ai_question(self):
 question = self.ai_input.text().strip()
 if not question:
 return
 text = self.editor.toPlainText()
 words = len(text.split())
 chars = len(text)
 lines = len(text.splitlines()) if text else 0
 reading_time_min = words / 200.0 if words > 0 else 0.0
 lower_q = question.lower()
 parts = [f"Question: {question}"]
 if "word" in lower_q:
 parts.append(f"Words in document: {words}")
 if "char" in lower_q or "character" in lower_q:
 parts.append(f"Characters in document: {chars}")
 if "line" in lower_q:
 parts.append(f"Lines in document: {lines}")
 if "read" in lower_q or "time" in lower_q:
 parts.append(
 f"Estimated reading time (~200 wpm): {reading_time_min:.1f} minutes"
 )
 if len(parts) == 1:
 parts.append(
 "This offline helper can answer simple questions about this document "
 "(words, characters, lines, reading time). For more advanced AI, hook this panel to an API."
 )
 self.ai_output.setHtml(" ".join(parts))
 self.ai_input.selectAll()
def main():
 app = QApplication(sys.argv)
 win = WordLikeEditor()
 win.show()
 sys.exit(app.exec())
if __name__ == "__main__":
 main()

import sys, os, json, base64, io, re, math, uuid
from PyQt6.QtCore import Qt, QRectF, QPointF, QSize, QTimer, pyqtSignal
from PyQt6.QtGui import (QAction, QIcon, QKeySequence, QColor, QPainter, QPen, QBrush, QFont,
                         QTextDocument, QTextOption, QPixmap, QImage, QTransform)
from PyQt6.QtWidgets import (QApplication, QMainWindow, QWidget, QHBoxLayout, QVBoxLayout, QFileDialog,
                             QMessageBox, QGraphicsView, QGraphicsScene, QGraphicsObject, QStyle,
                             QListWidget, QListWidgetItem, QToolBar, QDockWidget, QLabel, QPushButton,
                             QFormLayout, QDoubleSpinBox, QSpinBox, QFontComboBox, QComboBox, QCheckBox,
                             QTextEdit, QColorDialog, QSplitter, QTabWidget, QScrollArea, QSizePolicy, QToolButton, QGroupBox, QGridLayout,
                             QFrame, QLineEdit, QMenu)

try:
 from pptx import Presentation
 from pptx.util import Emu
 from pptx.dml.color import RGBColor
 from pptx.enum.shapes import MSO_SHAPE
except Exception:
 Presentation = None
def qcol_to_rgba(c: QColor): return [c.red(), c.green(), c.blue(), c.alpha()]
def rgba_to_qcol(rgba):
 if not rgba: return QColor(0,0,0,255)
 r,g,b,*a = rgba
 return QColor(int(r),int(g),int(b),int(a[0]) if a else 255)
def clamp(v, lo, hi): return lo if v < lo else hi if v > hi else v
def safe_float(x, d=0.0):
 try: return float(x)
 except Exception: return d
def bytes_to_b64(b: bytes): return base64.b64encode(b).decode("utf-8")
def b64_to_bytes(s: str):
 try: return base64.b64decode(s.encode("utf-8"))
 except Exception: return b""
def strip_html(html: str):
 if not html: return ""
 html = re.sub(r"<br\s*/?>", "\n", html, flags=re.I)
 html = re.sub(r"</p\s*>", "\n", html, flags=re.I)
 html = re.sub(r"<[^>]+>", "", html)
 return html.replace(" "," ").replace("&","&").replace("<","<").replace(">",">")
def uid(): return uuid.uuid4().hex[:10]
def office_light_stylesheet():
 return """
* { font-family: "Segoe UI"; font-size: 10pt; }
QMainWindow { background: #f3f4f6; }
QMenuBar { background: #ffffff; border-bottom: 1px solid #d7dbe0; }
QMenuBar::item { padding: 7px 11px; background: transparent; border-radius: 8px; margin: 2px; }
QMenuBar::item:selected { background: #e9eef6; }
QMenu { background: #ffffff; border: 1px solid #d7dbe0; border-radius: 10px; padding: 6px; }
QMenu::item { padding: 7px 14px; border-radius: 8px; }
QMenu::item:selected { background: #e9eef6; }
#Ribbon {
 background: #ffffff;
 border: 1px solid #d7dbe0;
 border-radius: 12px;
}
#Ribbon QTabWidget::pane { border: none; background: transparent; }
#Ribbon QTabBar::tab {
 background: #f6f7f9;
 border: 1px solid #d7dbe0;
 border-bottom: none;
 padding: 8px 12px;
 margin-right: 4px;
 border-top-left-radius: 10px;
 border-top-right-radius: 10px;
 min-width: 86px;
}
#Ribbon QTabBar::tab:selected { background: #ffffff; }
QToolButton { padding: 6px 10px; border-radius: 10px; background: transparent; }
QToolButton:hover { background: #edf1f6; }
QToolButton:pressed { background: #e1e7f0; }
QPushButton { background: #ffffff; border: 1px solid #d7dbe0; border-radius: 10px; padding: 7px 12px; }
QPushButton:hover { background: #edf1f6; }
QPushButton:pressed { background: #e1e7f0; }
QLineEdit, QComboBox, QSpinBox, QDoubleSpinBox, QTextEdit, QFontComboBox {
 background: #ffffff;
 border: 1px solid #d7dbe0;
 border-radius: 10px;
 padding: 7px;
}
QComboBox::drop-down { border: none; padding-right: 8px; }
QGroupBox {
 border: 1px solid #d7dbe0;
 border-radius: 12px;
 margin-top: 12px;
 background: #ffffff;
}
QGroupBox::title { subcontrol-origin: margin; left: 10px; padding: 0 8px; color: #0f172a; }
#SlidesPane {
 background: #ffffff;
 border: 1px solid #d7dbe0;
 border-radius: 12px;
}
#SlidesPane QLabel { color: #0f172a; }
QListWidget { background: transparent; border: none; }
QListWidget::item {
 background: #ffffff;
 border: 1px solid #e5e7eb;
 border-radius: 12px;
 padding: 6px;
 margin: 4px;
}
QListWidget::item:selected {
 background: #e9eef6;
 border: 1px solid #c7d2fe;
}
QDockWidget { titlebar-close-icon: url(none); titlebar-normal-icon: url(none); }
QDockWidget::title { background: #ffffff; padding: 10px; border-bottom: 1px solid #d7dbe0; }
QScrollArea { background: transparent; border: none; }
QScrollBar:horizontal { height: 10px; background: transparent; margin: 0px 8px 0px 8px; }
QScrollBar::handle:horizontal { background: #cbd5e1; border-radius: 5px; min-width: 30px; }
QScrollBar::handle:horizontal:hover { background: #94a3b8; }
QScrollBar::add-line:horizontal, QScrollBar::sub-line:horizontal { width: 0px; }
QScrollBar::add-page:horizontal, QScrollBar::sub-page:horizontal { background: transparent; }
QSplitter::handle { background: #e2e8f0; }
"""
class ColorButton(QPushButton):
 colorChanged = pyqtSignal(QColor)
 def __init__(self, color=QColor(0,0,0,255), title="Pick color"):
 super().__init__()
 self._color = QColor(color)
 self._title = title
 self.setFixedHeight(26)
 self.clicked.connect(self._pick)
 self._sync()
 def color(self): return QColor(self._color)
 def setColor(self, c: QColor):
 if not c: return
 self._color = QColor(c)
 self._sync()
 self.colorChanged.emit(QColor(self._color))
 def _sync(self):
 c = self._color
 self.setText(f"#{c.red():02X}{c.green():02X}{c.blue():02X}")
 self.setStyleSheet(f"QPushButton{{background: rgba({c.red()},{c.green()},{c.blue()},{c.alpha()}); border:1px solid rgba(0,0,0,30); border-radius:8px;}}")
 def _pick(self):
 c = QColorDialog.getColor(self._color, self.window(), self._title)
 if c.isValid():
 self.setColor(c)
class SlideScene(QGraphicsScene):
 ping = pyqtSignal()
 selectionPing = pyqtSignal()
 def __init__(self, w=1280, h=720, bg=None):
 super().__init__()
 self.slide_w, self.slide_h = int(w), int(h)
 self._bg = QColor(255,255,255,255) if bg is None else QColor(bg)
 self.setSceneRect(0,0,self.slide_w,self.slide_h)
 self._ping_t = QTimer(); self._ping_t.setSingleShot(True); self._ping_t.timeout.connect(self.ping.emit)
 self._sel_t = QTimer(); self._sel_t.setSingleShot(True); self._sel_t.timeout.connect(self.selectionPing.emit)
 self.changed.connect(self._on_changed)
 self.selectionChanged.connect(self._on_sel)
 self.grid_enabled = True
 self.grid_size = 20
 self.snap_enabled = True
 self.show_guides = True
 self._guide_color = QColor(72, 135, 255, 120)
 self._grid_color = QColor(0,0,0,18)
 self._margin_color = QColor(0,0,0,20)
 self._margin = 60
 def setBackgroundColor(self, c: QColor):
 if not c:
 return
 c = QColor(c)
 if c == self._bg:
 return
 self._bg = c
 try:
 self.invalidate(self.sceneRect(), QGraphicsScene.SceneLayer.BackgroundLayer)
 except Exception:
 pass
 try:
 self.update(self.sceneRect())
 except Exception:
 self.update()
 if not self._ping_t.isActive():
 self._ping_t.start(60)
 def backgroundColor(self): return QColor(self._bg)
 def setGrid(self, enabled=None, size=None):
 if enabled is not None: self.grid_enabled = bool(enabled)
 if size is not None: self.grid_size = int(max(4, size))
 self.update()
 def setSnap(self, enabled=None):
 if enabled is not None: self.snap_enabled = bool(enabled)
 def setGuides(self, enabled=None):
 if enabled is not None: self.show_guides = bool(enabled)
 self.update()
 def snap_point(self, p: QPointF):
 if not self.snap_enabled or not self.grid_enabled:
 return p
 g = max(4, int(self.grid_size))
 x = round(p.x()/g)*g
 y = round(p.y()/g)*g
 return QPointF(x,y)
 def _on_changed(self, *_):
 if not self._ping_t.isActive(): self._ping_t.start(120)
 def _on_sel(self):
 if not self._sel_t.isActive(): self._sel_t.start(30)
 def drawBackground(self, painter: QPainter, rect: QRectF):
 painter.save()
 painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 painter.fillRect(self.sceneRect(), self._bg)
 if self.grid_enabled:
 g = max(4, int(self.grid_size))
 painter.setPen(QPen(self._grid_color, 1))
 r = self.sceneRect()
 x0 = int(r.left()) - (int(r.left()) % g)
 y0 = int(r.top()) - (int(r.top()) % g)
 for x in range(x0, int(r.right())+1, g):
 painter.drawLine(x, int(r.top()), x, int(r.bottom()))
 for y in range(y0, int(r.bottom())+1, g):
 painter.drawLine(int(r.left()), y, int(r.right()), y)
 if self.show_guides:
 m = int(self._margin)
 r = self.sceneRect()
 painter.setPen(QPen(self._margin_color, 1, Qt.PenStyle.DashLine))
 painter.drawRect(QRectF(r.left()+m, r.top()+m, r.width()-2*m, r.height()-2*m))
 painter.setPen(QPen(self._guide_color, 1, Qt.PenStyle.DashLine))
 painter.drawLine(QPointF(r.center().x(), r.top()), QPointF(r.center().x(), r.bottom()))
 painter.drawLine(QPointF(r.left(), r.center().y()), QPointF(r.right(), r.center().y()))
 painter.restore()
class SlideView(QGraphicsView):
 def __init__(self):
 super().__init__()
 self.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 self.setRenderHint(QPainter.RenderHint.SmoothPixmapTransform, True)
 self.setDragMode(QGraphicsView.DragMode.RubberBandDrag)
 self.setViewportUpdateMode(QGraphicsView.ViewportUpdateMode.FullViewportUpdate)
 self.setBackgroundBrush(QBrush(QColor(243,244,246)))
 self._panning = False
 self._pan_start = QPointF()
 def wheelEvent(self, e):
 if e.modifiers() & Qt.KeyboardModifier.ControlModifier:
 factor = 1.15 if e.angleDelta().y() > 0 else 1/1.15
 self.scale(factor, factor)
 e.accept()
 return
 super().wheelEvent(e)
 def mousePressEvent(self, e):
 if e.button() == Qt.MouseButton.MiddleButton:
 self._panning = True
 self._pan_start = e.position()
 self.setCursor(Qt.CursorShape.ClosedHandCursor)
 e.accept()
 return
 super().mousePressEvent(e)
 def mouseMoveEvent(self, e):
 if self._panning:
 delta = e.position() - self._pan_start
 self._pan_start = e.position()
 self.horizontalScrollBar().setValue(self.horizontalScrollBar().value() - int(delta.x()))
 self.verticalScrollBar().setValue(self.verticalScrollBar().value() - int(delta.y()))
 e.accept()
 return
 super().mouseMoveEvent(e)
 def mouseReleaseEvent(self, e):
 if e.button() == Qt.MouseButton.MiddleButton and self._panning:
 self._panning = False
 self.setCursor(Qt.CursorShape.ArrowCursor)
 e.accept()
 return
 super().mouseReleaseEvent(e)
class ElementItem(QGraphicsObject):
 def __init__(self, x=100, y=100, w=300, h=160):
 super().__init__()
 self.eid = uid()
 self._rect = QRectF(0,0,float(w),float(h))
 self.setPos(float(x), float(y))
 self.setRotation(0.0)
 self.setZValue(0)
 self.setFlags(self.GraphicsItemFlag.ItemIsSelectable | self.GraphicsItemFlag.ItemIsMovable | self.GraphicsItemFlag.ItemSendsGeometryChanges)
 self._handle = 7.0
 self._mode = None
 self._hidx = -1
 self._press_pos = QPointF()
 self._press_rect = QRectF()
 self._press_itempos = QPointF()
 self._aspect_lock = False
 self._min_w, self._min_h = 18.0, 18.0
 self.anim = {"name":"None","duration_ms":500,"delay_ms":0,"trigger":"OnClick"}
 def boundingRect(self):
 r = QRectF(self._rect)
 if self.isSelected():
 pad = self._handle + 2.0
 r = r.adjusted(-pad,-pad,pad,pad)
 return r
 def rect(self): return QRectF(self._rect)
 def setRect(self, w, h):
 w, h = float(w), float(h)
 w, h = max(self._min_w, w), max(self._min_h, h)
 if w == self._rect.width() and h == self._rect.height(): return
 self.prepareGeometryChange()
 self._rect = QRectF(0,0,w,h)
 self.update()
 if self.scene(): self.scene().update()
 def setAspectLock(self, v: bool): self._aspect_lock = bool(v)
 def aspectLock(self): return bool(self._aspect_lock)
 def _handles(self):
 r = self._rect; s = self._handle
 pts = [QPointF(r.left(), r.top()), QPointF(r.center().x(), r.top()), QPointF(r.right(), r.top()),
 QPointF(r.right(), r.center().y()), QPointF(r.right(), r.bottom()), QPointF(r.center().x(), r.bottom()),
 QPointF(r.left(), r.bottom()), QPointF(r.left(), r.center().y())]
 return [QRectF(p.x()-s, p.y()-s, 2*s, 2*s) for p in pts]
 def _hit_handle(self, p: QPointF):
 if not self.isSelected(): return -1
 for i, hr in enumerate(self._handles()):
 if hr.contains(p): return i
 return -1
 def _snap_pos(self, pos: QPointF):
 sc = self.scene()
 if isinstance(sc, SlideScene):
 return sc.snap_point(pos)
 return pos
 def mousePressEvent(self, e):
 if e.button() == Qt.MouseButton.LeftButton:
 p = e.pos()
 self._hidx = self._hit_handle(p)
 self._press_pos = p
 self._press_rect = QRectF(self._rect)
 self._press_itempos = QPointF(self.pos())
 if self._hidx >= 0:
 self._mode = "resize"
 e.accept(); return
 self._mode = "move"
 super().mousePressEvent(e)
 def mouseMoveEvent(self, e):
 if self._mode == "resize":
 dp = e.pos() - self._press_pos
 r = QRectF(self._press_rect)
 w0, h0 = r.width(), r.height()
 if self._hidx == 0: r.setTopLeft(r.topLeft()+dp)
 elif self._hidx == 1: r.setTop(r.top()+dp.y())
 elif self._hidx == 2: r.setTopRight(r.topRight()+dp)
 elif self._hidx == 3: r.setRight(r.right()+dp.x())
 elif self._hidx == 4: r.setBottomRight(r.bottomRight()+dp)
 elif self._hidx == 5: r.setBottom(r.bottom()+dp.y())
 elif self._hidx == 6: r.setBottomLeft(r.bottomLeft()+dp)
 elif self._hidx == 7: r.setLeft(r.left()+dp.x())
 neww, newh = max(self._min_w, r.width()), max(self._min_h, r.height())
 if self._aspect_lock and w0 > 0 and h0 > 0:
 ar = w0 / h0
 if abs(neww - w0) >= abs(newh - h0):
 newh = max(self._min_h, neww / ar)
 else:
 neww = max(self._min_w, newh * ar)
 dx, dy = r.left(), r.top()
 newpos = self._snap_pos(self._press_itempos + QPointF(dx, dy))
 self.setPos(newpos)
 self.setRect(neww, newh)
 if self.scene(): self.scene().update()
 e.accept()
 return
 super().mouseMoveEvent(e)
 if self._mode == "move":
 self.setPos(self._snap_pos(self.pos()))
 if self.scene(): self.scene().update()
 def mouseReleaseEvent(self, e):
 self._mode = None
 self._hidx = -1
 super().mouseReleaseEvent(e)
 def paint_selection(self, p: QPainter):
 if not self.isSelected(): return
 p.save()
 p.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 p.setPen(QPen(QColor(72,135,255,220), 1.3, Qt.PenStyle.DashLine))
 p.setBrush(Qt.BrushStyle.NoBrush)
 p.drawRect(self._rect)
 p.setPen(QPen(QColor(255,255,255,255), 1))
 p.setBrush(QBrush(QColor(72,135,255,220)))
 for hr in self._handles(): p.drawRect(hr)
 p.restore()
 def common_dict(self):
 return {"eid": self.eid, "x": float(self.pos().x()), "y": float(self.pos().y()),
 "w": float(self._rect.width()), "h": float(self._rect.height()),
 "rot": float(self.rotation()), "z": float(self.zValue()),
 "aspect": bool(self._aspect_lock), "anim": self.anim}
 def apply_common(self, d):
 self.eid = d.get("eid", uid())
 self.setPos(safe_float(d.get("x", 0)), safe_float(d.get("y", 0)))
 self.setRect(safe_float(d.get("w", 100)), safe_float(d.get("h", 80)))
 self.setRotation(safe_float(d.get("rot", 0)))
 self.setZValue(safe_float(d.get("z", 0)))
 self.setAspectLock(bool(d.get("aspect", False)))
 self.anim = d.get("anim", {"name":"None","duration_ms":500,"delay_ms":0,"trigger":"OnClick"})
 def to_dict(self): return {"type":"base", **self.common_dict()}
 @staticmethod
 def from_dict(d):
 t = d.get("type","")
 if t == "text":
 it = TextBoxItem(); it.from_dict(d); return it
 if t == "shape":
 it = ShapeItem(d.get("shape","rect")); it.from_dict(d); return it
 if t == "image":
 it = ImageItem(); it.from_dict(d); return it
 if t == "table":
 it = TableItem(); it.from_dict(d); return it
 return None
class ShapeItem(ElementItem):
 def __init__(self, shape="rect", x=140, y=140, w=320, h=200):
 super().__init__(x,y,w,h)
 self._shape = shape
 self._fill = QColor(245,245,245,255)
 self._stroke = QColor(30,30,30,255)
 self._stroke_w = 2
 def setFill(self, c: QColor): self._fill = QColor(c); self.update()
 def fill(self): return QColor(self._fill)
 def setStroke(self, c: QColor): self._stroke = QColor(c); self.update()
 def stroke(self): return QColor(self._stroke)
 def setStrokeWidth(self, w: int): self._stroke_w = int(w); self.update()
 def strokeWidth(self): return int(self._stroke_w)
 def shapeKind(self): return self._shape
 def paint(self, painter, option, widget=None):
 painter.save()
 painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 painter.setBrush(QBrush(self._fill))
 painter.setPen(QPen(self._stroke, float(self._stroke_w)))
 r = QRectF(self._rect)
 if self._shape == "rect": painter.drawRoundedRect(r, 8, 8)
 elif self._shape == "ellipse": painter.drawEllipse(r)
 elif self._shape == "line":
 painter.setBrush(Qt.BrushStyle.NoBrush)
 painter.drawLine(r.topLeft(), r.bottomRight())
 else: painter.drawRect(r)
 painter.restore()
 self.paint_selection(painter)
 def to_dict(self):
 return {"type":"shape","shape":self._shape, **self.common_dict(),
 "fill": qcol_to_rgba(self._fill), "stroke": qcol_to_rgba(self._stroke), "sw": int(self._stroke_w)}
 def from_dict(self, d):
 self.apply_common(d)
 self._shape = d.get("shape","rect")
 self._fill = rgba_to_qcol(d.get("fill",[245,245,245,255]))
 self._stroke = rgba_to_qcol(d.get("stroke",[30,30,30,255]))
 self._stroke_w = int(d.get("sw",2))
 self.update()
class TextBoxItem(ElementItem):
 def __init__(self, x=160, y=160, w=520, h=220):
 super().__init__(x,y,w,h)
 self._bg = QColor(255,255,255,0)
 self._stroke = QColor(30,30,30,0)
 self._stroke_w = 1
 self._text_color = QColor(10,10,10,255)
 self._font_family = "Calibri"
 self._font_size = 28
 self._bold = False
 self._italic = False
 self._align = int(Qt.AlignmentFlag.AlignLeft)
 self._html = "Double-click to edit"
 self._doc = QTextDocument()
 self._doc.setDefaultFont(QFont(self._font_family, self._font_size))
 self._sync_doc()
 def _sync_doc(self):
 f = QFont(self._font_family, int(self._font_size))
 f.setBold(bool(self._bold))
 f.setItalic(bool(self._italic))
 self._doc.setDefaultFont(f)
 opt = QTextOption()
 opt.setAlignment(Qt.AlignmentFlag(self._align))
 opt.setWrapMode(QTextOption.WrapMode.WordWrap)
 self._doc.setDefaultTextOption(opt)
 self._doc.setHtml(self._html or "")
 self._doc.setTextWidth(max(1.0, self._rect.width()))
 self.update()
 def setTextHtml(self, html: str):
 self._html = html if html is not None else ""
 self._sync_doc()
 def textHtml(self): return self._html
 def setTextColor(self, c: QColor):
 self._text_color = QColor(c)
 self._apply_color()
 self.update()
 def _apply_color(self):
 c = self._text_color
 html = self._html or ""
 if "<span" in html and "data-allcolor" in html:
 html = re.sub(r'data-allcolor="[^"]*"', f'data-allcolor="{c.name()}"', html)
 else:
 plain = strip_html(html)
 html = f'{plain}'
 self._html = html
 self._doc.setHtml(self._html)
 def textColor(self): return QColor(self._text_color)
 def setFontFamily(self, fam: str):
 self._font_family = fam or "Calibri"
 self._sync_doc()
 def fontFamily(self): return self._font_family
 def setFontSize(self, sz: int):
 self._font_size = int(sz)
 self._sync_doc()
 def fontSize(self): return int(self._font_size)
 def setBold(self, v: bool):
 self._bold = bool(v)
 self._sync_doc()
 def bold(self): return bool(self._bold)
 def setItalic(self, v: bool):
 self._italic = bool(v)
 self._sync_doc()
 def italic(self): return bool(self._italic)
 def setAlign(self, a):
 self._align = int(a)
 self._sync_doc()
 def align(self): return int(self._align)
 def setBackground(self, c: QColor): self._bg = QColor(c); self.update()
 def background(self): return QColor(self._bg)
 def setStroke(self, c: QColor): self._stroke = QColor(c); self.update()
 def stroke(self): return QColor(self._stroke)
 def setStrokeWidth(self, w: int): self._stroke_w = int(w); self.update()
 def strokeWidth(self): return int(self._stroke_w)
 def paint(self, painter, option, widget=None):
 painter.save()
 painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 painter.setBrush(QBrush(self._bg))
 painter.setPen(QPen(self._stroke, float(self._stroke_w)))
 painter.drawRoundedRect(self._rect, 6, 6)
 painter.setClipRect(self._rect.adjusted(6,6,-6,-6))
 painter.translate(6,6)
 self._doc.setTextWidth(max(1.0, self._rect.width()-12))
 self._doc.drawContents(painter, QRectF(0,0,self._rect.width()-12, self._rect.height()-12))
 painter.restore()
 self.paint_selection(painter)
 def mouseDoubleClickEvent(self, e):
 from PyQt6.QtWidgets import QDialog, QDialogButtonBox
 dlg = QDialog(self.window())
 dlg.setWindowTitle("Edit text")
 dlg.setMinimumSize(650, 460)
 lay = QVBoxLayout(dlg)
 ed = QTextEdit(); ed.setAcceptRichText(True); ed.setHtml(self._html or "")
 lay.addWidget(ed)
 bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
 lay.addWidget(bb)
 bb.accepted.connect(dlg.accept); bb.rejected.connect(dlg.reject)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 self.setTextHtml(ed.toHtml())
 if self.scene(): self.scene().update()
 super().mouseDoubleClickEvent(e)
 def to_dict(self):
 return {"type":"text", **self.common_dict(),
 "bg": qcol_to_rgba(self._bg), "stroke": qcol_to_rgba(self._stroke), "sw": int(self._stroke_w),
 "text_color": qcol_to_rgba(self._text_color), "font": self._font_family, "fs": int(self._font_size),
 "b": bool(self._bold), "i": bool(self._italic), "al": int(self._align), "html": self._html}
 def from_dict(self, d):
 self.apply_common(d)
 self._bg = rgba_to_qcol(d.get("bg",[255,255,255,0]))
 self._stroke = rgba_to_qcol(d.get("stroke",[30,30,30,0]))
 self._stroke_w = int(d.get("sw",1))
 self._text_color = rgba_to_qcol(d.get("text_color",[10,10,10,255]))
 self._font_family = d.get("font","Calibri")
 self._font_size = int(d.get("fs",28))
 self._bold = bool(d.get("b",False))
 self._italic = bool(d.get("i",False))
 self._align = int(d.get("al", int(Qt.AlignmentFlag.AlignLeft)))
 self._html = d.get("html","")
 self._doc = QTextDocument()
 self._sync_doc()
 self._apply_color()
class ImageItem(ElementItem):
 def __init__(self, x=180, y=180, w=420, h=280):
 super().__init__(x,y,w,h)
 self._pix = QPixmap()
 self._b64 = ""
 self._path = ""
 self._stroke = QColor(30,30,30,80)
 self._stroke_w = 1
 self._fit = True
 self.setAspectLock(True)
 def setImageBytes(self, b: bytes, path=""):
 self._b64 = bytes_to_b64(b) if b else ""
 self._path = path or ""
 img = QImage.fromData(b) if b else QImage()
 self._pix = QPixmap.fromImage(img) if not img.isNull() else QPixmap()
 self.update()
 def setImagePath(self, path: str):
 if not path or not os.path.exists(path): return
 with open(path, "rb") as f: b = f.read()
 self.setImageBytes(b, path=path)
 def imageBytes(self): return b64_to_bytes(self._b64) if self._b64 else b""
 def imageB64(self): return self._b64
 def imagePath(self): return self._path
 def setStroke(self, c: QColor): self._stroke = QColor(c); self.update()
 def stroke(self): return QColor(self._stroke)
 def setStrokeWidth(self, w: int): self._stroke_w = int(w); self.update()
 def strokeWidth(self): return int(self._stroke_w)
 def paint(self, painter, option, widget=None):
 painter.save()
 painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 painter.setBrush(QBrush(QColor(255,255,255,0)))
 painter.setPen(QPen(self._stroke, float(self._stroke_w)))
 painter.drawRoundedRect(self._rect, 6, 6)
 if not self._pix.isNull():
 r = self._rect.adjusted(2,2,-2,-2)
 if self._fit:
 pm = self._pix.scaled(int(r.width()), int(r.height()), Qt.AspectRatioMode.KeepAspectRatio, Qt.TransformationMode.SmoothTransformation)
 x = r.x() + (r.width() - pm.width())/2
 y = r.y() + (r.height() - pm.height())/2
 painter.drawPixmap(QPointF(x,y), pm)
 else:
 painter.drawPixmap(r.toRect(), self._pix)
 else:
 painter.setPen(QPen(QColor(120,120,120,180), 1, Qt.PenStyle.DashLine))
 painter.drawRect(self._rect.adjusted(10,10,-10,-10))
 painter.setPen(QPen(QColor(120,120,120,220), 1))
 painter.drawText(self._rect, Qt.AlignmentFlag.AlignCenter, "Image")
 painter.restore()
 self.paint_selection(painter)
 def mouseDoubleClickEvent(self, e):
 p, _ = QFileDialog.getOpenFileName(None, "Replace image", "", "Images (*.png *.jpg *.jpeg *.webp *.bmp)")
 if p: self.setImagePath(p)
 super().mouseDoubleClickEvent(e)
 def to_dict(self):
 return {"type":"image", **self.common_dict(),
 "b64": self._b64, "path": self._path, "stroke": qcol_to_rgba(self._stroke),
 "sw": int(self._stroke_w), "fit": bool(self._fit)}
 def from_dict(self, d):
 self.apply_common(d)
 self._b64 = d.get("b64","") or ""
 self._path = d.get("path","") or ""
 self._stroke = rgba_to_qcol(d.get("stroke",[30,30,30,80]))
 self._stroke_w = int(d.get("sw",1))
 self._fit = bool(d.get("fit", True))
 b = b64_to_bytes(self._b64) if self._b64 else b""
 if (not b) and self._path and os.path.exists(self._path):
 try:
 with open(self._path, "rb") as f: b = f.read()
 except Exception:
 b = b""
 self.setImageBytes(b, self._path)
class TableItem(ElementItem):
 def __init__(self, rows=3, cols=4, x=200, y=200, w=520, h=260):
 super().__init__(x,y,w,h)
 self.rows = int(rows); self.cols = int(cols)
 self.cell_text = [["" for _ in range(self.cols)] for __ in range(self.rows)]
 self._font_family = "Calibri"
 self._font_size = 16
 self._text_color = QColor(20,20,20,255)
 self._grid_color = QColor(50,50,50,180)
 self._fill = QColor(255,255,255,255)
 self._header_fill = QColor(242,244,248,255)
 self.header = True
 def setSizeRC(self, r, c):
 r = max(1,int(r)); c = max(1,int(c))
 old = self.cell_text
 self.rows, self.cols = r, c
 self.cell_text = [["" for _ in range(c)] for __ in range(r)]
 for i in range(min(len(old), r)):
 for j in range(min(len(old[0]) if old else 0, c)):
 self.cell_text[i][j] = old[i][j]
 self.update()
 def paint(self, painter, option, widget=None):
 painter.save()
 painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
 r = QRectF(self._rect)
 painter.setBrush(QBrush(self._fill))
 painter.setPen(QPen(QColor(0,0,0,30), 1))
 painter.drawRoundedRect(r, 6, 6)
 inner = r.adjusted(1,1,-1,-1)
 cw = inner.width() / max(1, self.cols)
 ch = inner.height() / max(1, self.rows)
 f = QFont(self._font_family, int(self._font_size))
 painter.setFont(f)
 for i in range(self.rows):
 for j in range(self.cols):
 cell = QRectF(inner.left()+j*cw, inner.top()+i*ch, cw, ch)
 if self.header and i == 0:
 painter.fillRect(cell, self._header_fill)
 painter.setPen(QPen(self._grid_color, 1))
 painter.drawRect(cell)
 painter.setPen(QPen(self._text_color, 1))
 txt = self.cell_text[i][j]
 painter.drawText(cell.adjusted(6,2,-6,-2), Qt.AlignmentFlag.AlignLeft | Qt.AlignmentFlag.AlignVCenter, txt)
 painter.restore()
 self.paint_selection(painter)
 def mouseDoubleClickEvent(self, e):
 from PyQt6.QtWidgets import QDialog, QDialogButtonBox
 dlg = QDialog(self.window()); dlg.setWindowTitle("Edit table (tab separates columns, newline separates rows)")
 dlg.setMinimumSize(700, 520)
 lay = QVBoxLayout(dlg)
 hint = QLabel("Paste or type rows. Use TAB between columns. Use ENTER for next row.")
 lay.addWidget(hint)
 ed = QTextEdit()
 lines = []
 for i in range(self.rows):
 lines.append("\t".join(self.cell_text[i]))
 ed.setPlainText("\n".join(lines))
 lay.addWidget(ed, 1)
 bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
 lay.addWidget(bb)
 bb.accepted.connect(dlg.accept); bb.rejected.connect(dlg.reject)
 if dlg.exec() == QDialog.DialogCode.Accepted:
 raw = ed.toPlainText().splitlines()
 parsed = [ln.split("\t") for ln in raw]
 r = max(1, len(parsed))
 c = max(1, max((len(x) for x in parsed), default=1))
 self.setSizeRC(r,c)
 for i in range(r):
 for j in range(c):
 self.cell_text[i][j] = parsed[i][j] if i < len(parsed) and j < len(parsed[i]) else ""
 self.update()
 super().mouseDoubleClickEvent(e)
 def to_dict(self):
 return {"type":"table", **self.common_dict(),
 "rows": self.rows, "cols": self.cols, "cells": self.cell_text,
 "font": self._font_family, "fs": int(self._font_size),
 "tc": qcol_to_rgba(self._text_color), "gc": qcol_to_rgba(self._grid_color),
 "fill": qcol_to_rgba(self._fill), "hfill": qcol_to_rgba(self._header_fill), "header": bool(self.header)}
 def from_dict(self, d):
 self.apply_common(d)
 self.rows = int(d.get("rows",3)); self.cols = int(d.get("cols",4))
 self.cell_text = d.get("cells", [["" for _ in range(self.cols)] for __ in range(self.rows)])
 self._font_family = d.get("font","Calibri")
 self._font_size = int(d.get("fs",16))
 self._text_color = rgba_to_qcol(d.get("tc",[20,20,20,255]))
 self._grid_color = rgba_to_qcol(d.get("gc",[50,50,50,180]))
 self._fill = rgba_to_qcol(d.get("fill",[255,255,255,255]))
 self._header_fill = rgba_to_qcol(d.get("hfill",[242,244,248,255]))
 self.header = bool(d.get("header", True))
 self.update()
class Slide:
 def __init__(self, w=1280, h=720, bg=None, title="Slide"):
 self.title = title
 self.notes = ""
 self.scene = SlideScene(w,h,bg=bg)
 def to_dict(self):
 els = []
 items = [it for it in self.scene.items() if isinstance(it, ElementItem)]
 items.sort(key=lambda it: float(it.zValue()))
 for it in items:
 els.append(it.to_dict())
 return {"title": self.title, "notes": self.notes,
 "bg": qcol_to_rgba(self.scene.backgroundColor()),
 "grid": {"enabled": self.scene.grid_enabled, "size": self.scene.grid_size, "snap": self.scene.snap_enabled, "guides": self.scene.show_guides},
 "elements": els}
 @staticmethod
 def from_dict(d, w, h):
 s = Slide(w,h, bg=rgba_to_qcol(d.get("bg",[255,255,255,255])), title=d.get("title","Slide"))
 s.notes = d.get("notes","") or ""
 gd = d.get("grid", {})
 s.scene.setGrid(gd.get("enabled", True), gd.get("size", 20))
 s.scene.setSnap(gd.get("snap", True))
 s.scene.setGuides(gd.get("guides", True))
 for ed in d.get("elements",[]):
 it = ElementItem.from_dict(ed)
 if it: s.scene.addItem(it)
 return s
class SlideShowWindow(QWidget):
 def __init__(self, main, start_index=0):
 super().__init__(None, Qt.WindowType.Window | Qt.WindowType.FramelessWindowHint)
 self._main = main
 self._idx = int(start_index)
 self._count = len(main.slides)
 self.setWindowTitle("Slideshow")
 self.setStyleSheet("background: black;")
 self._label = QLabel()
 self._label.setAlignment(Qt.AlignmentFlag.AlignCenter)
 self._label.setStyleSheet("background: black; color: white;")
 lay = QVBoxLayout(self)
 lay.setContentsMargins(0, 0, 0, 0)
 lay.addWidget(self._label, 1)
 self._render_timer = QTimer(self)
 self._render_timer.setSingleShot(True)
 self._render_timer.timeout.connect(self._render_now)
 def showEvent(self, e):
 super().showEvent(e)
 self._schedule_render()
 def resizeEvent(self, e):
 super().resizeEvent(e)
 self._schedule_render()
 def mousePressEvent(self, e):
 if e.button() == Qt.MouseButton.LeftButton:
 self.next_slide()
 super().mousePressEvent(e)
 def keyPressEvent(self, e):
 k = e.key()
 if k == Qt.Key.Key_Escape:
 self.close()
 e.accept()
 return
 if k in (Qt.Key.Key_Right, Qt.Key.Key_Down, Qt.Key.Key_Space, Qt.Key.Key_Return, Qt.Key.Key_Enter, Qt.Key.Key_PageDown):
 self.next_slide()
 e.accept()
 return
 if k in (Qt.Key.Key_Left, Qt.Key.Key_Up, Qt.Key.Key_Backspace, Qt.Key.Key_PageUp):
 self.prev_slide()
 e.accept()
 return
 if k == Qt.Key.Key_Home:
 self.goto(0)
 e.accept()
 return
 if k == Qt.Key.Key_End:
 self.goto(self._count - 1)
 e.accept()
 return
 super().keyPressEvent(e)
 def goto(self, idx: int):
 if self._count <= 0:
 return
 self._idx = int(clamp(idx, 0, self._count - 1))
 self._schedule_render()
 def next_slide(self):
 if self._idx < self._count - 1:
 self._idx += 1
 self._schedule_render()
 def prev_slide(self):
 if self._idx > 0:
 self._idx -= 1
 self._schedule_render()
 def _schedule_render(self):
 if not self._render_timer.isActive():
 self._render_timer.start(10)
 def _render_now(self):
 if self._count <= 0:
 return
 slide = self._main.slides[self._idx]
 dpr = self.devicePixelRatioF() if hasattr(self, "devicePixelRatioF") else 1.0
 tw = max(1, int(self.width() * dpr))
 th = max(1, int(self.height() * dpr))
 img = self._main._render_slide_image(slide, tw, th, pad_color=QColor(0, 0, 0))
 pm = QPixmap.fromImage(img)
 try:
 pm.setDevicePixelRatio(dpr)
 except Exception:
 pass
 self._label.setPixmap(pm)
class History:
 def __init__(self, maxlen=90):
 self._states = []; self._idx = -1; self._max = int(maxlen)
 def clear(self): self._states, self._idx = [], -1
 def can_undo(self): return self._idx > 0
 def can_redo(self): return self._idx >= 0 and self._idx < len(self._states)-1
 def push(self, s: str):
 if self._idx >= 0 and self._idx < len(self._states) and self._states[self._idx] == s: return
 if self._idx < len(self._states)-1: self._states = self._states[:self._idx+1]
 self._states.append(s)
 if len(self._states) > self._max:
 drop = len(self._states) - self._max
 self._states = self._states[drop:]
 self._idx = max(-1, self._idx - drop)
 self._idx = len(self._states)-1
 def undo(self):
 if not self.can_undo(): return None
 self._idx -= 1
 return self._states[self._idx]
 def redo(self):
 if not self.can_redo(): return None
 self._idx += 1
 return self._states[self._idx]
class SlidesMain(QMainWindow):
 def __init__(self):
 super().__init__()
 self.setWindowTitle("Slides (Free)")
 self.resize(1440, 880)
 self.slide_w, self.slide_h = 1280, 720
 self.slides = []
 self.cur = -1
 self.file_path = ""
 self.history = History(120)
 self._hist_t = QTimer(); self._hist_t.setSingleShot(True); self._hist_t.timeout.connect(self._push_hist)
 self._thumb_t = QTimer(); self._thumb_t.setSingleShot(True); self._thumb_t.timeout.connect(self._update_current_thumb)
 self._building = False
 self._clipboard_cache = None
 self._connected_scene = None
 self._clean_state = ""
 self._make_ui()
 self.new_deck()
 def _is_dirty(self):
 if not self._clean_state:
 return False
 try:
 return self.serialize_deck() != self._clean_state
 except Exception:
 return True
 def _update_title(self):
 name = os.path.basename(self.file_path) if self.file_path else "Untitled"
 star = " *" if self._is_dirty() else ""
 self.setWindowTitle(f"Slides (Free) — {name}{star}")
 def closeEvent(self, e):
 if not self._is_dirty():
 e.accept()
 return
 mb = QMessageBox(self)
 mb.setWindowTitle("Unsaved changes")
 mb.setText("You have unsaved changes. Save before closing?")
 mb.setIcon(QMessageBox.Icon.Warning)
 btn_save = mb.addButton("Save", QMessageBox.ButtonRole.AcceptRole)
 btn_discard = mb.addButton("Discard", QMessageBox.ButtonRole.DestructiveRole)
 btn_cancel = mb.addButton("Cancel", QMessageBox.ButtonRole.RejectRole)
 mb.setDefaultButton(btn_save)
 mb.exec()
 clicked = mb.clickedButton()
 if clicked == btn_save:
 prev_clean = self._clean_state
 prev_path = self.file_path
 self.save_file()
 if self._is_dirty() and self._clean_state == prev_clean and self.file_path == prev_path:
 e.ignore()
 else:
 e.accept()
 elif clicked == btn_discard:
 e.accept()
 else:
 e.ignore()
 def _make_ui(self):
 self.setDockNestingEnabled(True)
 self.setDockOptions(
 QMainWindow.DockOption.AnimatedDocks
 | QMainWindow.DockOption.AllowTabbedDocks
 | QMainWindow.DockOption.AllowNestedDocks
 | QMainWindow.DockOption.VerticalTabs
 )
 self.view = SlideView()
 self.slide_list = QListWidget()
 self.slide_list.setIconSize(QSize(150, 84))
 self.slide_list.setSpacing(6)
 self.slide_list.setMinimumWidth(200)
 self.slide_list.currentRowChanged.connect(self.goto_slide)
 self.slide_list.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
 self.slide_list.customContextMenuRequested.connect(self._slides_context_menu)
 btn_add = QPushButton("New")
 btn_dup = QPushButton("Duplicate")
 btn_del = QPushButton("Delete")
 btn_add.clicked.connect(self.add_slide)
 btn_dup.clicked.connect(self.dup_slide)
 btn_del.clicked.connect(self.del_slide)
 self._slides_last_w = 260
 left = QFrame()
 left.setObjectName("SlidesPane")
 left_l = QVBoxLayout(left)
 left_l.setContentsMargins(10, 10, 10, 10)
 left_l.setSpacing(8)
 header = QHBoxLayout()
 header.setContentsMargins(0, 0, 0, 0)
 header.setSpacing(8)
 lbl = QLabel("Slides")
 self.btn_toggle_slides = QToolButton()
 self.btn_toggle_slides.setText("⟨")
 self.btn_toggle_slides.setAutoRaise(True)
 self.btn_toggle_slides.setToolTip("Collapse slide thumbnails")
 self.btn_toggle_slides.clicked.connect(self._toggle_slides_pane)
 header.addWidget(lbl)
 header.addStretch(1)
 header.addWidget(self.btn_toggle_slides)
 left_l.addLayout(header)
 left_l.addWidget(self.slide_list, 1)
 r1 = QHBoxLayout()
 r1.setContentsMargins(0, 0, 0, 0)
 r1.setSpacing(8)
 r1.addWidget(btn_add)
 r1.addWidget(btn_dup)
 r1.addWidget(btn_del)
 left_l.addLayout(r1)
 self.ribbon = self._build_ribbon()
 self.ribbon.setObjectName("Ribbon")
 top = QWidget()
 top_l = QVBoxLayout(top)
 top_l.setContentsMargins(10, 10, 10, 10)
 top_l.setSpacing(10)
 top_l.addWidget(self.ribbon)
 self.editor_splitter = QSplitter(Qt.Orientation.Horizontal)
 self.editor_splitter.addWidget(left)
 self.editor_splitter.addWidget(self.view)
 self.editor_splitter.setStretchFactor(1, 1)
 self.editor_splitter.setCollapsible(0, True)
 self.editor_splitter.setCollapsible(1, False)
 self.editor_splitter.setChildrenCollapsible(False)
 self.editor_splitter.setHandleWidth(6)
 self.editor_splitter.setSizes([self._slides_last_w, 9999])
 top_l.addWidget(self.editor_splitter, 1)
 self.setCentralWidget(top)
 self._build_docks()
 self._build_menus()
 self._wire_shortcuts()
 self._update_title()
 self._apply_responsive_layout()
 def resizeEvent(self, e):
 super().resizeEvent(e)
 self._apply_responsive_layout()
 def _toggle_slides_pane(self):
 sizes = self.editor_splitter.sizes()
 slides_w = sizes[0] if sizes else self._slides_last_w
 if self.slide_list.isVisible():
 self._slides_last_w = max(160, slides_w)
 self.slide_list.setVisible(False)
 self.btn_toggle_slides.setText("⟩")
 self.btn_toggle_slides.setToolTip("Expand slide thumbnails")
 self.editor_splitter.setSizes([60, max(1, sizes[1])])
 else:
 self.slide_list.setVisible(True)
 self.btn_toggle_slides.setText("⟨")
 self.btn_toggle_slides.setToolTip("Collapse slide thumbnails")
 self.editor_splitter.setSizes([self._slides_last_w, max(1, sizes[1])])
 self._apply_responsive_layout()
 def _apply_responsive_layout(self):
 w = int(self.width())
 compact = w < 1180
 tiny = w < 980
 try:
 self.ribbon.tabBar().setUsesScrollButtons(True)
 except Exception:
 pass
 if tiny:
 self.slide_list.setIconSize(QSize(120, 68))
 self.slide_list.setMinimumWidth(175)
 elif compact:
 self.slide_list.setIconSize(QSize(140, 78))
 self.slide_list.setMinimumWidth(190)
 else:
 self.slide_list.setIconSize(QSize(150, 84))
 self.slide_list.setMinimumWidth(200)
 try:
 sizes = self.editor_splitter.sizes()
 if sizes and (compact or tiny):
 max_left = 230 if compact else 210
 if sizes[0] > max_left:
 self.editor_splitter.setSizes([max_left, max(1, sizes[1])])
 except Exception:
 pass
 def _build_ribbon(self):
 tabs = QTabWidget()
 tabs.setDocumentMode(True)
 tabs.setMovable(False)
 def page():
 sa = QScrollArea()
 sa.setWidgetResizable(True)
 sa.setFrameShape(QFrame.Shape.NoFrame)
 sa.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff)
 sa.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded)
 w = QWidget()
 lay = QHBoxLayout(w)
 lay.setContentsMargins(10, 10, 10, 10)
 lay.setSpacing(10)
 sa.setWidget(w)
 return sa, lay
 def group(title):
 gb = QGroupBox(title)
 gb.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Fixed)
 lay = QHBoxLayout(gb)
 lay.setContentsMargins(10, 14, 10, 10)
 lay.setSpacing(8)
 return gb, lay
 def toolbtn(text, fn):
 b = QPushButton(text)
 b.setMinimumHeight(34)
 b.clicked.connect(fn)
 return b
 home, home_l = page()
 g1, l1 = group("Clipboard")
 l1.addWidget(toolbtn("Copy", self.copy_sel))
 l1.addWidget(toolbtn("Cut", self.cut_sel))
 l1.addWidget(toolbtn("Paste", self.paste_sel))
 home_l.addWidget(g1)
 g2, l2 = group("Font")
 self.rb_font = QFontComboBox(); self.rb_font.setMinimumWidth(170)
 self.rb_fs = QSpinBox(); self.rb_fs.setRange(6, 240); self.rb_fs.setValue(28)
 self.rb_b = QCheckBox("Bold"); self.rb_i = QCheckBox("Italic")
 self.rb_txt = ColorButton(QColor(10,10,10,255), "Text color")
 self.rb_align = QComboBox(); self.rb_align.addItems(["Left","Center","Right"])
 for w in [self.rb_font, self.rb_fs, self.rb_b, self.rb_i, self.rb_txt, self.rb_align]:
 l2.addWidget(w)
 self.rb_font.currentFontChanged.connect(lambda _: self._apply_ribbon_text_style())
 self.rb_fs.valueChanged.connect(lambda _: self._apply_ribbon_text_style())
 self.rb_b.stateChanged.connect(lambda _: self._apply_ribbon_text_style())
 self.rb_i.stateChanged.connect(lambda _: self._apply_ribbon_text_style())
 self.rb_txt.colorChanged.connect(lambda _: self._apply_ribbon_text_style())
 self.rb_align.currentIndexChanged.connect(lambda _: self._apply_ribbon_text_style())
 home_l.addWidget(g2)
 g3, l3 = group("Arrange")
 l3.addWidget(toolbtn("Bring Front", lambda: self.bump_z(+1)))
 l3.addWidget(toolbtn("Send Back", lambda: self.bump_z(-1)))
 l3.addWidget(toolbtn("Align Left", lambda: self.align_sel("l")))
 l3.addWidget(toolbtn("Align Center", lambda: self.align_sel("c")))
 l3.addWidget(toolbtn("Align Right", lambda: self.align_sel("r")))
 l3.addWidget(toolbtn("Distribute H", lambda: self.distribute_sel("h")))
 l3.addWidget(toolbtn("Distribute V", lambda: self.distribute_sel("v")))
 home_l.addWidget(g3)
 g4, l4 = group("Slide")
 self.rb_bg = ColorButton(QColor(255,255,255,255), "Background")
 self.rb_grid = QCheckBox("Grid"); self.rb_grid.setChecked(True)
 self.rb_grid_size = QSpinBox(); self.rb_grid_size.setRange(4, 200); self.rb_grid_size.setValue(20)
 self.rb_snap = QCheckBox("Snap"); self.rb_snap.setChecked(True)
 self.rb_guides = QCheckBox("Guides"); self.rb_guides.setChecked(True)
 l4.addWidget(self.rb_bg)
 l4.addWidget(self.rb_grid)
 l4.addWidget(QLabel("Size"))
 l4.addWidget(self.rb_grid_size)
 l4.addWidget(self.rb_snap)
 l4.addWidget(self.rb_guides)
 self.rb_bg.colorChanged.connect(lambda c: self.pick_slide_bg(color=c, from_btn=True))
 self.rb_grid.stateChanged.connect(lambda _: self._apply_grid_settings())
 self.rb_snap.stateChanged.connect(lambda _: self._apply_grid_settings())
 self.rb_guides.stateChanged.connect(lambda _: self._apply_grid_settings())
 self.rb_grid_size.valueChanged.connect(lambda _: self._apply_grid_settings())
 home_l.addWidget(g4)
 home_l.addStretch(1)
 tabs.addTab(home, "Home")
 insert, ins_l = page()
 gI, lI = group("Insert")
 lI.addWidget(toolbtn("Text Box", self.insert_text))
 lI.addWidget(toolbtn("Rectangle", lambda: self.insert_shape("rect")))
 lI.addWidget(toolbtn("Ellipse", lambda: self.insert_shape("ellipse")))
 lI.addWidget(toolbtn("Line", lambda: self.insert_shape("line")))
 lI.addWidget(toolbtn("Image", self.insert_image))
 lI.addWidget(toolbtn("Table", self.insert_table))
 ins_l.addWidget(gI)
 gT, lT = group("Theme")
 self.theme_bg = ColorButton(QColor(255,255,255,255), "Theme background")
 self.theme_accent = ColorButton(QColor(72,135,255,255), "Accent")
 self.theme_font = QFontComboBox(); self.theme_font.setMinimumWidth(170)
 lT.addWidget(self.theme_bg); lT.addWidget(self.theme_accent); lT.addWidget(self.theme_font)
 self.theme_bg.colorChanged.connect(lambda c: self._apply_theme())
 self.theme_accent.colorChanged.connect(lambda c: self._apply_theme())
 self.theme_font.currentFontChanged.connect(lambda _: self._apply_theme())
 ins_l.addWidget(gT)
 ins_l.addStretch(1)
 tabs.addTab(insert, "Insert")
 anim, anim_l = page()
 gA, lA = group("Animations")
 self.anim_name = QComboBox(); self.anim_name.addItems(["None","Fade","FlyIn","Zoom","Wipe","FloatUp"])
 self.anim_trigger = QComboBox(); self.anim_trigger.addItems(["OnClick","WithPrevious","AfterPrevious"])
 self.anim_dur = QSpinBox(); self.anim_dur.setRange(0, 20000); self.anim_dur.setValue(500)
 self.anim_delay = QSpinBox(); self.anim_delay.setRange(0, 20000); self.anim_delay.setValue(0)
 lA.addWidget(QLabel("Effect")); lA.addWidget(self.anim_name)
 lA.addWidget(QLabel("Trigger")); lA.addWidget(self.anim_trigger)
 lA.addWidget(QLabel("Dur(ms)")); lA.addWidget(self.anim_dur)
 lA.addWidget(QLabel("Delay(ms)")); lA.addWidget(self.anim_delay)
 applyA = QPushButton("Apply to Selection"); applyA.clicked.connect(self.apply_animation_to_sel)
 lA.addWidget(applyA)
 anim_l.addWidget(gA)
 anim_l.addStretch(1)
 tabs.addTab(anim, "Animations")
 view, v_l = page()
 gV, lV = group("Zoom / View")
 lV.addWidget(toolbtn("Fit", self._fit_view))
 lV.addWidget(toolbtn("100%", lambda: self.set_zoom(1.0)))
 lV.addWidget(toolbtn("Zoom In", lambda: self.zoom_by(1.15)))
 lV.addWidget(toolbtn("Zoom Out", lambda: self.zoom_by(1/1.15)))
 lV.addWidget(toolbtn("Slideshow (F5)", lambda: self.start_slideshow(from_begin=False)))
 lV.addWidget(toolbtn("From Start", lambda: self.start_slideshow(from_begin=True)))
 v_l.addWidget(gV)
 v_l.addStretch(1)
 tabs.addTab(view, "View")
 return tabs
 def _build_docks(self):
 if getattr(self, "_docks_built", False):
 return
 self._docks_built = True
 self._build_props_dock()
 self._build_master_dock()
 self._build_notes_dock()
 try:
 if hasattr(self, "dock_format") and hasattr(self, "dock_master"):
 self.tabifyDockWidget(self.dock_format, self.dock_master)
 self.dock_format.raise_()
 except Exception:
 pass
 try:
 if hasattr(self, "dock_notes"):
 self.resizeDocks([self.dock_notes], [220], Qt.Orientation.Vertical)
 except Exception:
 pass
 def _build_props_dock(self):
 dock = QDockWidget("Format", self)
 self.dock_format = dock
 dock.setAllowedAreas(Qt.DockWidgetArea.RightDockWidgetArea | Qt.DockWidgetArea.LeftDockWidgetArea)
 w = QWidget()
 f = QFormLayout(w)
 f.setContentsMargins(10,10,10,10)
 f.setRowWrapPolicy(QFormLayout.RowWrapPolicy.WrapLongRows)
 f.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
 f.setFormAlignment(Qt.AlignmentFlag.AlignTop)
 self.sp_x = QDoubleSpinBox(); self.sp_y = QDoubleSpinBox()
 self.sp_w = QDoubleSpinBox(); self.sp_h = QDoubleSpinBox()
 self.sp_rot = QDoubleSpinBox()
 for sp in [self.sp_x, self.sp_y, self.sp_w, self.sp_h]:
 sp.setRange(-99999, 99999); sp.setDecimals(1); sp.setSingleStep(1.0)
 self.sp_rot.setRange(-360, 360); self.sp_rot.setDecimals(1); self.sp_rot.setSingleStep(1.0)
 self.btn_fill = ColorButton(QColor(240,240,240,255), "Fill")
 self.btn_stroke = ColorButton(QColor(30,30,30,255), "Stroke")
 self.sp_sw = QSpinBox(); self.sp_sw.setRange(0, 60); self.sp_sw.setValue(2)
 self.chk_aspect = QCheckBox("Lock aspect")
 f.addRow(QLabel("Geometry"))
 f.addRow("X", self.sp_x); f.addRow("Y", self.sp_y)
 f.addRow("W", self.sp_w); f.addRow("H", self.sp_h)
 f.addRow("Rotation", self.sp_rot)
 f.addRow(QLabel("Shape/Image"))
 f.addRow("Fill", self.btn_fill)
 f.addRow("Stroke", self.btn_stroke)
 f.addRow("Stroke width", self.sp_sw)
 f.addRow(self.chk_aspect)
 dock.setWidget(w)
 self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock)
 for sp in [self.sp_x, self.sp_y, self.sp_w, self.sp_h, self.sp_rot]:
 sp.valueChanged.connect(self.apply_props)
 self.btn_fill.colorChanged.connect(lambda _: self.apply_props())
 self.btn_stroke.colorChanged.connect(lambda _: self.apply_props())
 self.sp_sw.valueChanged.connect(self.apply_props)
 self.chk_aspect.stateChanged.connect(self.apply_props)
 self.font_box = QFontComboBox()
 self.font_box.setFontFilters(QFontComboBox.FontFilter.ScalableFonts)
 def _build_notes_dock(self):
 dock = QDockWidget("Speaker Notes", self)
 self.dock_notes = dock
 dock.setAllowedAreas(Qt.DockWidgetArea.BottomDockWidgetArea | Qt.DockWidgetArea.TopDockWidgetArea)
 w = QWidget()
 l = QVBoxLayout(w); l.setContentsMargins(10,10,10,10)
 self.notes = QTextEdit()
 self.notes.textChanged.connect(self._notes_changed)
 l.addWidget(self.notes)
 dock.setWidget(w)
 self.addDockWidget(Qt.DockWidgetArea.BottomDockWidgetArea, dock)
 def _build_master_dock(self):
 dock = QDockWidget("Slide Master / Theme", self)
 self.dock_master = dock
 dock.setAllowedAreas(Qt.DockWidgetArea.LeftDockWidgetArea | Qt.DockWidgetArea.RightDockWidgetArea)
 w = QWidget(); lay = QVBoxLayout(w); lay.setContentsMargins(10,10,10,10); lay.setSpacing(10)
 gb = QGroupBox("Master (apply to all slides)")
 g = QFormLayout(gb); g.setContentsMargins(10,14,10,10)
 g.setRowWrapPolicy(QFormLayout.RowWrapPolicy.WrapLongRows)
 g.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
 g.setFormAlignment(Qt.AlignmentFlag.AlignTop)
 self.master_bg = ColorButton(QColor(255,255,255,255), "Master background")
 self.master_font = QFontComboBox(); self.master_font.setMinimumWidth(160)
 self.master_accent = ColorButton(QColor(72,135,255,255), "Accent")
 self.master_apply_bg = QPushButton("Apply BG to all"); self.master_apply_bg.clicked.connect(self.apply_master_bg_all)
 self.master_apply_font = QPushButton("Apply Font to text"); self.master_apply_font.clicked.connect(self.apply_master_font_all)
 g.addRow("Background", self.master_bg)
 g.addRow("Default font", self.master_font)
 g.addRow("Accent", self.master_accent)
 g.addRow(self.master_apply_bg)
 g.addRow(self.master_apply_font)
 lay.addWidget(gb)
 gb2 = QGroupBox("Selection (animations)")
 f2 = QFormLayout(gb2); f2.setContentsMargins(10,14,10,10)
 f2.setRowWrapPolicy(QFormLayout.RowWrapPolicy.WrapLongRows)
 f2.setFieldGrowthPolicy(QFormLayout.FieldGrowthPolicy.AllNonFixedFieldsGrow)
 f2.setFormAlignment(Qt.AlignmentFlag.AlignTop)
 self.sel_anim_label = QLabel("No selection")
 f2.addRow("Selected", self.sel_anim_label)
 lay.addWidget(gb2)
 lay.addStretch(1)
 dock.setWidget(w)
 self.addDockWidget(Qt.DockWidgetArea.RightDockWidgetArea, dock)
 self.master_bg.colorChanged.connect(lambda c: None)
 self.master_accent.colorChanged.connect(lambda c: self._apply_theme())
 self.master_font.currentFontChanged.connect(lambda _: self._apply_theme())
 def _build_menus(self):
 m = self.menuBar()
 fm = m.addMenu("File")
 im = m.addMenu("Import")
 em = m.addMenu("Export")
 sm = m.addMenu("Edit")
 vm = m.addMenu("View")
 a_new = QAction("New", self); a_new.setShortcut(QKeySequence.StandardKey.New)
 a_open = QAction("Open…", self); a_open.setShortcut(QKeySequence.StandardKey.Open)
 a_save = QAction("Save", self); a_save.setShortcut(QKeySequence.StandardKey.Save)
 a_saveas = QAction("Save As…", self); a_saveas.setShortcut(QKeySequence.StandardKey.SaveAs)
 a_quit = QAction("Quit", self); a_quit.setShortcut(QKeySequence.StandardKey.Quit)
 a_imp = QAction("Import PPTX…", self)
 a_exp_pptx = QAction("Export PPTX…", self)
 a_exp_pdf = QAction("Export PDF…", self)
 a_exp_png = QAction("Export PNGs…", self)
 a_undo = QAction("Undo", self); a_undo.setShortcut(QKeySequence.StandardKey.Undo)
 a_redo = QAction("Redo", self); a_redo.setShortcut(QKeySequence.StandardKey.Redo)
 a_cut = QAction("Cut", self); a_cut.setShortcut(QKeySequence.StandardKey.Cut)
 a_copy = QAction("Copy", self); a_copy.setShortcut(QKeySequence.StandardKey.Copy)
 a_paste = QAction("Paste", self); a_paste.setShortcut(QKeySequence.StandardKey.Paste)
 a_del = QAction("Delete", self); a_del.setShortcut(QKeySequence(Qt.Key.Key_Delete))
 a_fit = QAction("Fit to Window", self)
 a_zoom100 = QAction("Zoom 100%", self)
 a_toggle_grid = QAction("Toggle Grid", self)
 a_toggle_guides = QAction("Toggle Guides", self)
 a_toggle_snap = QAction("Toggle Snap", self)
 a_slideshow = QAction("Start Slideshow (F5)", self)
 a_slideshow.setShortcut(QKeySequence("F5"))
 a_slideshow_begin = QAction("Start Slideshow from Beginning (Shift+F5)", self)
 a_slideshow_begin.setShortcut(QKeySequence("Shift+F5"))
 fm.addActions([a_new, a_open, a_save, a_saveas]); fm.addSeparator(); fm.addAction(a_quit)
 im.addAction(a_imp)
 em.addActions([a_exp_pptx, a_exp_pdf, a_exp_png])
 sm.addActions([a_undo, a_redo]); sm.addSeparator(); sm.addActions([a_cut, a_copy, a_paste, a_del])
 vm.addActions([a_fit, a_zoom100]); vm.addSeparator(); vm.addActions([a_toggle_grid, a_toggle_guides, a_toggle_snap]); vm.addSeparator(); vm.addActions([a_slideshow, a_slideshow_begin])
 a_new.triggered.connect(self.new_deck)
 a_open.triggered.connect(self.open_file)
 a_save.triggered.connect(self.save_file)
 a_saveas.triggered.connect(lambda: self.save_file(as_new=True))
 a_quit.triggered.connect(self.close)
 a_imp.triggered.connect(self.import_pptx)
 a_exp_pptx.triggered.connect(self.export_pptx)
 a_exp_pdf.triggered.connect(self.export_pdf)
 a_exp_png.triggered.connect(self.export_pngs)
 a_undo.triggered.connect(self.undo)
 a_redo.triggered.connect(self.redo)
 a_cut.triggered.connect(self.cut_sel)
 a_copy.triggered.connect(self.copy_sel)
 a_paste.triggered.connect(self.paste_sel)
 a_del.triggered.connect(self.delete_sel)
 a_fit.triggered.connect(self._fit_view)
 a_zoom100.triggered.connect(lambda: self.set_zoom(1.0))
 a_toggle_grid.triggered.connect(lambda: self._toggle_scene_flag("grid"))
 a_toggle_guides.triggered.connect(lambda: self._toggle_scene_flag("guides"))
 a_toggle_snap.triggered.connect(lambda: self._toggle_scene_flag("snap"))
 a_slideshow.triggered.connect(lambda: self.start_slideshow(from_begin=False))
 a_slideshow_begin.triggered.connect(lambda: self.start_slideshow(from_begin=True))
 def _wire_shortcuts(self):
 shortcuts = [
 ("Ctrl+G", lambda: self._toggle_scene_flag("grid")),
 ("Ctrl+L", lambda: self._toggle_scene_flag("guides")),
 ("Ctrl+Shift+S", lambda: self._toggle_scene_flag("snap")),
 ("Ctrl+0", lambda: self.set_zoom(1.0)),
 ("Ctrl+1", self._fit_view),
 ]
 for seq, fn in shortcuts:
 act = QAction(self)
 act.setShortcut(QKeySequence(seq))
 act.triggered.connect(fn)
 self.addAction(act)
 def _toggle_scene_flag(self, which):
 sc = self.current_scene()
 if not sc: return
 if which == "grid":
 sc.setGrid(enabled=not sc.grid_enabled)
 elif which == "guides":
 sc.setGuides(enabled=not sc.show_guides)
 elif which == "snap":
 sc.setSnap(enabled=not sc.snap_enabled)
 self._sync_ribbon_from_scene()
 self._schedule_hist()
 def _slides_context_menu(self, pos):
 menu = QMenu(self)
 a_ren = menu.addAction("Rename…")
 a_up = menu.addAction("Move Up")
 a_dn = menu.addAction("Move Down")
 a = menu.exec(self.slide_list.mapToGlobal(pos))
 if not a: return
 r = self.slide_list.currentRow()
 if a == a_ren:
 from PyQt6.QtWidgets import QInputDialog
 s = self.current_slide()
 if not s: return
 text, ok = QInputDialog.getText(self, "Rename slide", "Title:", text=s.title)
 if ok and text.strip():
 s.title = text.strip()
 self._rebuild_slide_list()
 self._schedule_hist()
 elif a == a_up and r > 0:
 self.slides[r-1], self.slides[r] = self.slides[r], self.slides[r-1]
 self._rebuild_slide_list(); self.slide_list.setCurrentRow(r-1); self._schedule_hist()
 elif a == a_dn and r < len(self.slides)-1:
 self.slides[r+1], self.slides[r] = self.slides[r], self.slides[r+1]
 self._rebuild_slide_list(); self.slide_list.setCurrentRow(r+1); self._schedule_hist()
 def current_scene(self):
 if self.cur < 0 or self.cur >= len(self.slides): return None
 return self.slides[self.cur].scene
 def current_slide(self):
 if self.cur < 0 or self.cur >= len(self.slides): return None
 return self.slides[self.cur]
 def new_deck(self):
 self.file_path = ""
 self.slides = [Slide(self.slide_w, self.slide_h, bg=QColor(255,255,255,255), title="Slide 1")]
 self._apply_master_to_slide(self.slides[0])
 self.cur = 0
 self._rebuild_slide_list()
 self.goto_slide(0)
 self.history.clear()
 self.history.push(self.serialize_deck())
 self._clean_state = self.serialize_deck()
 self._update_title()
 def add_slide(self):
 n = len(self.slides) + 1
 bg = self.current_scene().backgroundColor() if self.current_scene() else QColor(255,255,255,255)
 s = Slide(self.slide_w, self.slide_h, bg=bg, title=f"Slide {n}")
 self._apply_master_to_slide(s)
 self.slides.append(s)
 self._rebuild_slide_list()
 self.slide_list.setCurrentRow(len(self.slides)-1)
 self._schedule_hist()
 def dup_slide(self):
 cs = self.current_slide()
 if not cs: return
 d = cs.to_dict()
 d["title"] = f"{cs.title} copy"
 s = Slide.from_dict(d, self.slide_w, self.slide_h)
 self.slides.insert(self.cur+1, s)
 self._rebuild_slide_list()
 self.slide_list.setCurrentRow(self.cur+1)
 self._schedule_hist()
 def del_slide(self):
 if len(self.slides) <= 1: return
 r = self.cur
 self.slides.pop(r)
 self.cur = max(0, min(r, len(self.slides)-1))
 self._rebuild_slide_list()
 self.slide_list.setCurrentRow(self.cur)
 self._schedule_hist()
 def goto_slide(self, idx):
 if idx < 0 or idx >= len(self.slides):
 return
 if self._connected_scene is not None:
 try: self._connected_scene.ping.disconnect(self._on_scene_ping)
 except Exception: pass
 try: self._connected_scene.selectionPing.disconnect(self._on_selection_ping)
 except Exception: pass
 self.cur = idx
 sc = self.slides[idx].scene
 self._connected_scene = sc
 self.view.setScene(sc)
 self.view.setSceneRect(sc.sceneRect())
 sc.ping.connect(self._on_scene_ping)
 sc.selectionPing.connect(self._on_selection_ping)
 self.notes.blockSignals(True)
 self.notes.setPlainText(self.slides[idx].notes or "")
 self.notes.blockSignals(False)
 self._sync_ribbon_from_scene()
 self._fit_view()
 self._sync_props()
 self._sync_anim_panel()
 self._update_title()
 def _sync_ribbon_from_scene(self):
 sc = self.current_scene()
 if not sc: return
 self.rb_bg.blockSignals(True); self.rb_bg.setColor(sc.backgroundColor()); self.rb_bg.blockSignals(False)
 self.rb_grid.blockSignals(True); self.rb_grid.setChecked(sc.grid_enabled); self.rb_grid.blockSignals(False)
 self.rb_grid_size.blockSignals(True); self.rb_grid_size.setValue(int(sc.grid_size)); self.rb_grid_size.blockSignals(False)
 self.rb_snap.blockSignals(True); self.rb_snap.setChecked(sc.snap_enabled); self.rb_snap.blockSignals(False)
 self.rb_guides.blockSignals(True); self.rb_guides.setChecked(sc.show_guides); self.rb_guides.blockSignals(False)
 def _apply_grid_settings(self):
 sc = self.current_scene()
 if not sc: return
 sc.setGrid(self.rb_grid.isChecked(), self.rb_grid_size.value())
 sc.setSnap(self.rb_snap.isChecked())
 sc.setGuides(self.rb_guides.isChecked())
 self._schedule_hist()
 def _fit_view(self):
 self.view.resetTransform()
 self.view.fitInView(self.view.sceneRect(), Qt.AspectRatioMode.KeepAspectRatio)
 self._update_current_thumb()
 def start_slideshow(self, from_begin=False):
 if not self.slides:
 return
 start = 0 if from_begin else max(0, int(self.cur))
 try:
 if hasattr(self, "_slideshow_win") and self._slideshow_win is not None:
 self._slideshow_win.close()
 except Exception:
 pass
 self._slideshow_win = SlideShowWindow(self, start_index=start)
 self._slideshow_win.showFullScreen()
 def set_zoom(self, z: float):
 self.view.resetTransform()
 self.view.scale(float(z), float(z))
 self._update_current_thumb()
 def zoom_by(self, f: float):
 self.view.scale(float(f), float(f))
 self._update_current_thumb()
 def _center_point(self):
 sc = self.current_scene()
 if not sc:
 return QPointF(100, 100)
 vr = self.view.mapToScene(self.view.viewport().rect()).boundingRect()
 c = vr.center()
 c.setX(clamp(c.x(), 0, sc.slide_w - 1))
 c.setY(clamp(c.y(), 0, sc.slide_h - 1))
 return c
 def _next_z(self):
 sc = self.current_scene()
 if not sc:
 return 0
 z = 0.0
 for it in sc.items():
 if isinstance(it, ElementItem):
 z = max(z, it.zValue())
 return z + 1.0
 def insert_text(self):
 sc = self.current_scene()
 if not sc:
 return
 c = self._center_point()
 it = TextBoxItem(x=c.x() - 260, y=c.y() - 110, w=520, h=220)
 it.setZValue(self._next_z())
 sc.addItem(it)
 self._schedule_hist()
 def insert_shape(self, kind):
 sc = self.current_scene()
 if not sc:
 return
 c = self._center_point()
 it = ShapeItem(kind, x=c.x() - 160, y=c.y() - 110, w=320, h=220)
 if kind == "line":
 it.setFill(QColor(255, 255, 255, 0))
 it.setStrokeWidth(4)
 it.setZValue(self._next_z())
 sc.addItem(it)
 self._schedule_hist()
 def insert_image(self):
 sc = self.current_scene()
 if not sc:
 return
 p, _ = QFileDialog.getOpenFileName(self, "Insert image", "", "Images (*.png *.jpg *.jpeg *.webp *.bmp)")
 if not p:
 return
 c = self._center_point()
 it = ImageItem(x=c.x() - 220, y=c.y() - 140, w=440, h=280)
 it.setImagePath(p)
 it.setZValue(self._next_z())
 sc.addItem(it)
 self._schedule_hist()
 def insert_table(self):
 sc = self.current_scene()
 if not sc:
 return
 from PyQt6.QtWidgets import QDialog, QDialogButtonBox
 dlg = QDialog(self); dlg.setWindowTitle("Insert Table"); dlg.setMinimumSize(360, 220)
 lay = QFormLayout(dlg)
 r = QSpinBox(); r.setRange(1, 40); r.setValue(3)
 c = QSpinBox(); c.setRange(1, 20); c.setValue(4)
 lay.addRow("Rows", r); lay.addRow("Columns", c)
 bb = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
 lay.addRow(bb)
 bb.accepted.connect(dlg.accept); bb.rejected.connect(dlg.reject)
 if dlg.exec() != QDialog.DialogCode.Accepted:
 return
 cp = self._center_point()
 it = TableItem(rows=r.value(), cols=c.value(), x=cp.x() - 280, y=cp.y() - 140, w=560, h=280)
 it.setZValue(self._next_z())
 sc.addItem(it)
 self._schedule_hist()
 def pick_slide_bg(self, color=None, from_btn=False):
 sc = self.current_scene()
 if not sc:
 return
 c = color if (from_btn and isinstance(color, QColor)) else QColorDialog.getColor(sc.backgroundColor(), self, "Slide background")
 if c and c.isValid():
 sc.setBackgroundColor(c)
 self.rb_bg.blockSignals(True); self.rb_bg.setColor(c); self.rb_bg.blockSignals(False)
 self._schedule_hist()
 try:
 self.view.viewport().update()
 except Exception:
 pass
 def selected_items(self):
 sc = self.current_scene()
 if not sc:
 return []
 return [it for it in sc.selectedItems() if isinstance(it, ElementItem)]
 def bump_z(self, delta):
 its = self.selected_items()
 if not its:
 return
 step = 10.0 if delta > 0 else -10.0
 for it in its:
 it.setZValue(it.zValue() + step)
 self._schedule_hist()
 self._sync_props()
 def align_sel(self, mode):
 its = self.selected_items()
 if not its:
 return
 xs = [it.pos().x() for it in its]
 ws = [it.rect().width() for it in its]
 if mode == "l":
 x = min(xs)
 for it in its:
 it.setPos(x, it.pos().y())
 elif mode == "c":
 left = min(xs)
 right = max([xs[i] + ws[i] for i in range(len(its))])
 cx = (left + right) / 2
 for it in its:
 it.setPos(cx - it.rect().width() / 2, it.pos().y())
 elif mode == "r":
 r = max([xs[i] + ws[i] for i in range(len(its))])
 for it in its:
 it.setPos(r - it.rect().width(), it.pos().y())
 self._schedule_hist()
 self._sync_props()
 def distribute_sel(self, axis):
 its = self.selected_items()
 if len(its) < 3:
 return
 if axis == "h":
 its.sort(key=lambda it: it.pos().x())
 left = its[0].pos().x()
 right = its[-1].pos().x() + its[-1].rect().width()
 total_w = sum(it.rect().width() for it in its)
 space = (right - left - total_w) / (len(its) - 1) if len(its) > 1 else 0
 x = left
 for it in its:
 it.setPos(x, it.pos().y())
 x += it.rect().width() + space
 else:
 its.sort(key=lambda it: it.pos().y())
 top = its[0].pos().y()
 bottom = its[-1].pos().y() + its[-1].rect().height()
 total_h = sum(it.rect().height() for it in its)
 space = (bottom - top - total_h) / (len(its) - 1) if len(its) > 1 else 0
 y = top
 for it in its:
 it.setPos(it.pos().x(), y)
 y += it.rect().height() + space
 self._schedule_hist()
 self._sync_props()
 def delete_sel(self):
 sc = self.current_scene()
 if not sc:
 return
 for it in self.selected_items():
 sc.removeItem(it)
 self._schedule_hist()
 self._sync_props()
 def copy_sel(self):
 its = self.selected_items()
 if not its:
 return
 d = [it.to_dict() for it in its]
 QApplication.clipboard().setText(json.dumps(d, ensure_ascii=False))
 def paste_sel(self):
 sc = self.current_scene()
 if not sc:
 return
 txt = QApplication.clipboard().text() or ""
 try:
 arr = json.loads(txt)
 if not isinstance(arr, list):
 return
 except Exception:
 return
 c = self._center_point()
 bb = None
 items = []
 for d in arr:
 it = ElementItem.from_dict(d)
 if it:
 sc.addItem(it)
 items.append(it)
 it.setZValue(self._next_z())
 r = QRectF(it.pos().x(), it.pos().y(), it.rect().width(), it.rect().height())
 bb = r if bb is None else bb.united(r)
 if items and bb:
 dx = c.x() - (bb.x() + bb.width() / 2)
 dy = c.y() - (bb.y() + bb.height() / 2)
 for it in items:
 it.setPos(it.pos().x() + dx, it.pos().y() + dy)
 if items:
 sc.clearSelection()
 for it in items:
 it.setSelected(True)
 self._schedule_hist()
 def cut_sel(self):
 self.copy_sel()
 self.delete_sel()
 def _notes_changed(self):
 cs = self.current_slide()
 if not cs:
 return
 cs.notes = self.notes.toPlainText()
 self._schedule_hist()
 def _on_scene_ping(self):
 self._schedule_hist()
 if not self._thumb_t.isActive():
 self._thumb_t.start(120)
 def _on_selection_ping(self):
 self._sync_props()
 self._sync_anim_panel()
 self._sync_ribbon_text_controls()
 def _schedule_hist(self):
 if self._building:
 return
 if not self._hist_t.isActive():
 self._hist_t.start(240)
 def _push_hist(self):
 self.history.push(self.serialize_deck())
 self._update_title()
 def undo(self):
 s = self.history.undo()
 if s:
 self.deserialize_deck(s)
 def redo(self):
 s = self.history.redo()
 if s:
 self.deserialize_deck(s)
 def _render_slide_image(self, slide: Slide, tw: int, th: int, pad_color=QColor(0, 0, 0)):
 sc = slide.scene
 tw, th = int(max(1, tw)), int(max(1, th))
 img = QImage(tw, th, QImage.Format.Format_ARGB32)
 img.fill(QColor(pad_color))
 sw, sh = float(sc.slide_w), float(sc.slide_h)
 if sw <= 0 or sh <= 0:
 return img
 target_ar = tw / th
 slide_ar = sw / sh
 if slide_ar >= target_ar:
 rw = tw
 rh = int(round(tw / slide_ar))
 else:
 rh = th
 rw = int(round(th * slide_ar))
 ox = (tw - rw) / 2
 oy = (th - rh) / 2
 p = QPainter(img)
 p.fillRect(QRectF(0, 0, tw, th), QColor(pad_color))
 sc.render(p, target=QRectF(ox, oy, rw, rh), source=sc.sceneRect())
 p.end()
 return img
 def _render_slide_pixmap(self, slide: Slide, maxw=160, maxh=90):
 sc = slide.scene
 tw, th = int(maxw), int(maxh)
 img = QImage(tw, th, QImage.Format.Format_ARGB32)
 img.fill(QColor(255, 255, 255, 0))
 sw, sh = float(sc.slide_w), float(sc.slide_h)
 if sw <= 0 or sh <= 0:
 return QPixmap.fromImage(img)
 target_ar = tw / th
 slide_ar = sw / sh
 if slide_ar >= target_ar:
 rw = tw
 rh = int(round(tw / slide_ar))
 else:
 rh = th
 rw = int(round(th * slide_ar))
 ox = (tw - rw) / 2
 oy = (th - rh) / 2
 p = QPainter(img)
 p.fillRect(QRectF(0, 0, tw, th), QColor(243, 244, 246))
 sc.render(p, target=QRectF(ox, oy, rw, rh), source=sc.sceneRect())
 p.end()
 return QPixmap.fromImage(img)
 def _rebuild_slide_list(self):
 self.slide_list.blockSignals(True)
 self.slide_list.clear()
 for i, s in enumerate(self.slides):
 it = QListWidgetItem(f"{i + 1}. {s.title}")
 it.setIcon(QIcon(self._render_slide_pixmap(s)))
 self.slide_list.addItem(it)
 self.slide_list.blockSignals(False)
 if 0 <= self.cur < self.slide_list.count():
 self.slide_list.setCurrentRow(self.cur)
 def _update_current_thumb(self):
 if self.cur < 0 or self.cur >= len(self.slides):
 return
 it = self.slide_list.item(self.cur)
 if not it:
 return
 it.setIcon(QIcon(self._render_slide_pixmap(self.slides[self.cur])))
 def _sync_props(self):
 its = self.selected_items()
 if not its:
 self._set_props_enabled(False)
 return
 self._set_props_enabled(True)
 it = its[0]
 self._building = True
 self.sp_x.setValue(it.pos().x()); self.sp_y.setValue(it.pos().y())
 self.sp_w.setValue(it.rect().width()); self.sp_h.setValue(it.rect().height())
 self.sp_rot.setValue(it.rotation())
 self.chk_aspect.setChecked(it.aspectLock())
 if isinstance(it, ShapeItem):
 self.btn_fill.setColor(it.fill()); self.btn_stroke.setColor(it.stroke()); self.sp_sw.setValue(it.strokeWidth())
 elif isinstance(it, TextBoxItem):
 self.btn_fill.setColor(it.background()); self.btn_stroke.setColor(it.stroke()); self.sp_sw.setValue(it.strokeWidth())
 elif isinstance(it, ImageItem):
 self.btn_fill.setColor(QColor(255, 255, 255, 0)); self.btn_stroke.setColor(it.stroke()); self.sp_sw.setValue(it.strokeWidth())
 elif isinstance(it, TableItem):
 self.btn_fill.setColor(QColor(255, 255, 255, 0)); self.btn_stroke.setColor(QColor(60, 60, 60, 180)); self.sp_sw.setValue(1)
 self._building = False
 def _set_props_enabled(self, on: bool):
 for w in [self.sp_x, self.sp_y, self.sp_w, self.sp_h, self.sp_rot, self.btn_fill, self.btn_stroke, self.sp_sw, self.chk_aspect]:
 w.setEnabled(bool(on))
 def apply_props(self):
 if self._building:
 return
 its = self.selected_items()
 if not its:
 return
 self._building = True
 x, y = self.sp_x.value(), self.sp_y.value()
 w, h = self.sp_w.value(), self.sp_h.value()
 rot = self.sp_rot.value()
 for it in its:
 it.setPos(x, y)
 it.setRect(w, h)
 it.setRotation(rot)
 it.setAspectLock(self.chk_aspect.isChecked())
 if isinstance(it, ShapeItem):
 it.setFill(self.btn_fill.color()); it.setStroke(self.btn_stroke.color()); it.setStrokeWidth(self.sp_sw.value())
 elif isinstance(it, TextBoxItem):
 it.setBackground(self.btn_fill.color()); it.setStroke(self.btn_stroke.color()); it.setStrokeWidth(self.sp_sw.value())
 elif isinstance(it, ImageItem):
 it.setStroke(self.btn_stroke.color()); it.setStrokeWidth(self.sp_sw.value())
 self._building = False
 self._schedule_hist()
 self._update_current_thumb()
 def _sync_ribbon_text_controls(self):
 its = self.selected_items()
 if not its or not isinstance(its[0], TextBoxItem):
 return
 it = its[0]
 self._building = True
 self.rb_font.setCurrentFont(QFont(it.fontFamily()))
 self.rb_fs.setValue(it.fontSize())
 self.rb_b.setChecked(it.bold())
 self.rb_i.setChecked(it.italic())
 self.rb_txt.blockSignals(True); self.rb_txt.setColor(it.textColor()); self.rb_txt.blockSignals(False)
 al = it.align()
 self.rb_align.setCurrentIndex(0 if al == int(Qt.AlignmentFlag.AlignLeft) else 1 if al == int(Qt.AlignmentFlag.AlignHCenter) else 2)
 self._building = False
 def _apply_ribbon_text_style(self):
 if self._building:
 return
 its = self.selected_items()
 if not its:
 return
 for it in its:
 if isinstance(it, TextBoxItem):
 it.setFontFamily(self.rb_font.currentFont().family())
 it.setFontSize(self.rb_fs.value())
 it.setBold(self.rb_b.isChecked())
 it.setItalic(self.rb_i.isChecked())
 it.setTextColor(self.rb_txt.color())
 idx = self.rb_align.currentIndex()
 it.setAlign(int(Qt.AlignmentFlag.AlignLeft if idx == 0 else Qt.AlignmentFlag.AlignHCenter if idx == 1 else Qt.AlignmentFlag.AlignRight))
 self._schedule_hist()
 self._update_current_thumb()
 def _sync_anim_panel(self):
 its = self.selected_items()
 if not its:
 self.sel_anim_label.setText("No selection")
 return
 it = its[0]
 self.sel_anim_label.setText(f"{it.eid} ({it.__class__.__name__})")
 self._building = True
 self.anim_name.setCurrentText(it.anim.get("name", "None"))
 self.anim_trigger.setCurrentText(it.anim.get("trigger", "OnClick"))
 self.anim_dur.setValue(int(it.anim.get("duration_ms", 500)))
 self.anim_delay.setValue(int(it.anim.get("delay_ms", 0)))
 self._building = False
 def apply_animation_to_sel(self):
 if self._building:
 return
 its = self.selected_items()
 if not its:
 return
 for it in its:
 it.anim = {"name": self.anim_name.currentText(),
 "trigger": self.anim_trigger.currentText(),
 "duration_ms": int(self.anim_dur.value()),
 "delay_ms": int(self.anim_delay.value())}
 self._schedule_hist()
 def _apply_theme(self):
 bg = self.master_bg.color() if hasattr(self, "master_bg") else self.theme_bg.color()
 accent = self.master_accent.color() if hasattr(self, "master_accent") else self.theme_accent.color()
 base_font = self.master_font.currentFont().family() if hasattr(self, "master_font") else self.theme_font.currentFont().family()
 self.theme_bg.blockSignals(True); self.theme_bg.setColor(bg); self.theme_bg.blockSignals(False)
 self.theme_accent.blockSignals(True); self.theme_accent.setColor(accent); self.theme_accent.blockSignals(False)
 self.theme_font.blockSignals(True); self.theme_font.setCurrentFont(QFont(base_font)); self.theme_font.blockSignals(False)
 for s in self.slides:
 s.scene._guide_color = QColor(accent.red(), accent.green(), accent.blue(), 120)
 s.scene._grid_color = QColor(0, 0, 0, 18)
 self._schedule_hist()
 def _apply_master_to_slide(self, slide: Slide):
 if hasattr(self, "master_bg"):
 slide.scene.setBackgroundColor(self.master_bg.color())
 if hasattr(self, "master_accent"):
 slide.scene._guide_color = QColor(self.master_accent.color().red(), self.master_accent.color().green(), self.master_accent.color().blue(), 120)
 def apply_master_bg_all(self):
 c = self.master_bg.color()
 for s in self.slides:
 s.scene.setBackgroundColor(c)
 self._sync_ribbon_from_scene()
 try:
 sc = self.current_scene()
 if sc:
 sc.update(sc.sceneRect())
 self.view.viewport().update()
 except Exception:
 pass
 self._schedule_hist()
 def apply_master_font_all(self):
 fam = self.master_font.currentFont().family()
 for s in self.slides:
 for it in s.scene.items():
 if isinstance(it, TextBoxItem):
 it.setFontFamily(fam)
 self._schedule_hist()
 def keyPressEvent(self, e):
 if e.key() == Qt.Key.Key_Delete:
 self.delete_sel(); e.accept(); return
 super().keyPressEvent(e)
 def serialize_deck(self):
 return json.dumps({"v": 2, "size": [self.slide_w, self.slide_h],
 "theme": {"bg": qcol_to_rgba(self.master_bg.color()),
 "accent": qcol_to_rgba(self.master_accent.color()),
 "font": self.master_font.currentFont().family()},
 "slides": [s.to_dict() for s in self.slides]}, ensure_ascii=False)
 def deserialize_deck(self, s: str):
 try:
 d = json.loads(s)
 size = d.get("size", [1280, 720])
 w, h = int(size[0]), int(size[1])
 slides = d.get("slides", [])
 except Exception:
 return
 self._building = True
 self.slide_w, self.slide_h = w, h
 th = d.get("theme", {})
 if th:
 self.master_bg.blockSignals(True); self.master_bg.setColor(rgba_to_qcol(th.get("bg", [255, 255, 255, 255]))); self.master_bg.blockSignals(False)
 self.master_accent.blockSignals(True); self.master_accent.setColor(rgba_to_qcol(th.get("accent", [72, 135, 255, 255]))); self.master_accent.blockSignals(False)
 self.master_font.setCurrentFont(QFont(th.get("font", "Calibri")))
 self.slides = [Slide.from_dict(sd, w, h) for sd in slides] if slides else [Slide(w, h)]
 self.cur = int(clamp(self.cur if self.cur >= 0 else 0, 0, len(self.slides) - 1))
 self._rebuild_slide_list()
 self.goto_slide(self.cur if self.cur >= 0 else 0)
 self._apply_theme()
 self._building = False
 self._update_title()
 def open_file(self):
 p, _ = QFileDialog.getOpenFileName(self, "Open", "", "Slides JSON (*.json *.slides.json);;All files (*.*)")
 if not p:
 return
 try:
 with open(p, "r", encoding="utf-8") as f:
 s = f.read()
 self.deserialize_deck(s)
 self.file_path = p
 self.history.clear()
 self.history.push(self.serialize_deck())
 self._clean_state = self.serialize_deck()
 self._update_title()
 except Exception as ex:
 QMessageBox.critical(self, "Open failed", str(ex))
 def save_file(self, as_new=False):
 p = self.file_path if (self.file_path and not as_new) else ""
 if not p:
 p, _ = QFileDialog.getSaveFileName(self, "Save", "deck.slides.json", "Slides JSON (*.slides.json *.json)")
 if not p:
 return
 if not p.lower().endswith(".json"):
 p += ".slides.json"
 try:
 with open(p, "w", encoding="utf-8") as f:
 f.write(self.serialize_deck())
 self.file_path = p
 self._clean_state = self.serialize_deck()
 self._update_title()
 except Exception as ex:
 QMessageBox.critical(self, "Save failed", str(ex))
 def export_pngs(self):
 out = QFileDialog.getExistingDirectory(self, "Export PNGs to folder")
 if not out:
 return
 try:
 for i, s in enumerate(self.slides, start=1):
 img = QImage(s.scene.slide_w, s.scene.slide_h, QImage.Format.Format_ARGB32)
 img.fill(s.scene.backgroundColor())
 p = QPainter(img)
 s.scene.render(p, target=QRectF(0, 0, s.scene.slide_w, s.scene.slide_h), source=s.scene.sceneRect())
 p.end()
 img.save(os.path.join(out, f"slide_{i:03d}.png"))
 except Exception as ex:
 QMessageBox.critical(self, "Export failed", str(ex))
 def export_pdf(self):
 from PyQt6.QtGui import QPdfWriter, QPageSize
 p, _ = QFileDialog.getSaveFileName(self, "Export PDF", "deck.pdf", "PDF (*.pdf)")
 if not p:
 return
 if not p.lower().endswith(".pdf"):
 p += ".pdf"
 try:
 pdf = QPdfWriter(p)
 pdf.setResolution(144)
 page_w = 960
 page_h = int(page_w * (self.slide_h / self.slide_w))
 pdf.setPageSize(QPageSize(QSize(page_w, page_h), QPageSize.Unit.Point))
 painter = QPainter(pdf)
 for i, s in enumerate(self.slides):
 img = QImage(s.scene.slide_w, s.scene.slide_h, QImage.Format.Format_ARGB32)
 img.fill(s.scene.backgroundColor())
 p2 = QPainter(img)
 s.scene.render(p2, target=QRectF(0, 0, s.scene.slide_w, s.scene.slide_h), source=s.scene.sceneRect())
 p2.end()
 painter.drawImage(QRectF(0, 0, page_w, page_h), img)
 if i != len(self.slides) - 1:
 pdf.newPage()
 painter.end()
 except Exception as ex:
 QMessageBox.critical(self, "Export failed", str(ex))
 def export_pptx(self):
 if Presentation is None:
 QMessageBox.warning(self, "Missing dependency", "python-pptx is not installed.\n\npip install python-pptx")
 return
 p, _ = QFileDialog.getSaveFileName(self, "Export PPTX", "deck.pptx", "PowerPoint (*.pptx)")
 if not p:
 return
 if not p.lower().endswith(".pptx"):
 p += ".pptx"
 try:
 prs = Presentation()
 sw = int(prs.slide_width); sh = int(prs.slide_height)
 blank = prs.slide_layouts[6] if len(prs.slide_layouts) > 6 else prs.slide_layouts[0]
 for s in self.slides:
 sl = prs.slides.add_slide(blank)
 bg = s.scene.backgroundColor()
 try:
 sl.background.fill.solid()
 sl.background.fill.fore_color.rgb = RGBColor(bg.red(), bg.green(), bg.blue())
 except Exception:
 pass
 items = [it for it in s.scene.items() if isinstance(it, ElementItem)]
 items.sort(key=lambda it: float(it.zValue()))
 for it in items:
 x = int(it.pos().x() / self.slide_w * sw)
 y = int(it.pos().y() / self.slide_h * sh)
 w = int(it.rect().width() / self.slide_w * sw)
 h = int(it.rect().height() / self.slide_h * sh)
 meta = json.dumps({"eid": it.eid, "anim": it.anim}, ensure_ascii=False)
 if isinstance(it, TextBoxItem):
 tx = sl.shapes.add_textbox(Emu(x), Emu(y), Emu(w), Emu(h))
 tf = tx.text_frame
 tf.clear()
 tf.word_wrap = True
 text = strip_html(it.textHtml())
 p0 = tf.paragraphs[0]
 p0.text = text
 run = p0.runs[0] if p0.runs else p0.add_run()
 run.font.name = it.fontFamily()
 try:
 run.font.bold = it.bold()
 run.font.italic = it.italic()
 except Exception:
 pass
 c = it.textColor()
 try:
 run.font.color.rgb = RGBColor(c.red(), c.green(), c.blue())
 except Exception:
 pass
 try:
 tx.name = f"Text_{it.eid}"
 except Exception:
 pass
 try:
 tx._element.set("descr", meta)
 except Exception:
 pass
 try:
 tx.rotation = float(it.rotation())
 except Exception:
 pass
 elif isinstance(it, ShapeItem):
 if it.shapeKind() == "rect":
 shp = sl.shapes.add_shape(MSO_SHAPE.RECTANGLE, Emu(x), Emu(y), Emu(w), Emu(h))
 elif it.shapeKind() == "ellipse":
 shp = sl.shapes.add_shape(MSO_SHAPE.OVAL, Emu(x), Emu(y), Emu(w), Emu(h))
 elif it.shapeKind() == "line":
 shp = sl.shapes.add_shape(MSO_SHAPE.LINE, Emu(x), Emu(y), Emu(w), Emu(h))
 else:
 shp = sl.shapes.add_shape(MSO_SHAPE.RECTANGLE, Emu(x), Emu(y), Emu(w), Emu(h))
 fc = it.fill(); sc = it.stroke()
 try:
 shp.fill.solid(); shp.fill.fore_color.rgb = RGBColor(fc.red(), fc.green(), fc.blue())
 except Exception:
 pass
 try:
 shp.line.color.rgb = RGBColor(sc.red(), sc.green(), sc.blue())
 except Exception:
 pass
 try:
 shp.name = f"Shape_{it.eid}"
 shp._element.set("descr", meta)
 except Exception:
 pass
 try:
 shp.rotation = float(it.rotation())
 except Exception:
 pass
 elif isinstance(it, ImageItem):
 b = it.imageBytes()
 if b:
 bio = io.BytesIO(b)
 pic = sl.shapes.add_picture(bio, Emu(x), Emu(y), Emu(w), Emu(h))
 try:
 pic.name = f"Image_{it.eid}"
 pic._element.set("descr", meta)
 except Exception:
 pass
 try:
 pic.rotation = float(it.rotation())
 except Exception:
 pass
 elif isinstance(it, TableItem):
 tx = sl.shapes.add_textbox(Emu(x), Emu(y), Emu(w), Emu(h))
 tf = tx.text_frame; tf.clear(); tf.word_wrap = True
 lines = ["\t".join(row) for row in it.cell_text]
 tf.paragraphs[0].text = "\n".join(lines)
 try:
 tx.name = f"Table_{it.eid}"
 tx._element.set("descr", meta)
 except Exception:
 pass
 try:
 tx.rotation = float(it.rotation())
 except Exception:
 pass
 prs.save(p)
 except Exception as ex:
 QMessageBox.critical(self, "Export failed", str(ex))
 def import_pptx(self):
 if Presentation is None:
 QMessageBox.warning(self, "Missing dependency", "python-pptx is not installed.\n\npip install python-pptx")
 return
 p, _ = QFileDialog.getOpenFileName(self, "Import PPTX", "", "PowerPoint (*.pptx)")
 if not p:
 return
 try:
 prs = Presentation(p)
 sw = int(prs.slide_width); sh = int(prs.slide_height)
 self.slide_w = 1280
 self.slide_h = int(self.slide_w * (sh / sw)) if sw > 0 else 720
 new_slides = []
 for i, sl in enumerate(prs.slides, start=1):
 s = Slide(self.slide_w, self.slide_h, bg=QColor(255, 255, 255, 255), title=f"Slide {i}")
 for shp in sl.shapes:
 try:
 x = float(shp.left) / sw * self.slide_w
 y = float(shp.top) / sh * self.slide_h
 w = float(shp.width) / sw * self.slide_w
 h = float(shp.height) / sh * self.slide_h
 except Exception:
 continue
 meta = None
 try:
 meta = shp._element.get("descr")
 if meta:
 meta = json.loads(meta)
 except Exception:
 meta = None
 if getattr(shp, "has_text_frame", False):
 tx = TextBoxItem(x=x, y=y, w=w, h=h)
 txt = ""
 try:
 txt = "\n".join([p.text for p in shp.text_frame.paragraphs])
 except Exception:
 txt = ""
 tx.setTextHtml(txt)
 if meta and "eid" in meta:
 tx.eid = meta["eid"]
 if meta and "anim" in meta:
 tx.anim = meta["anim"]
 tx.setZValue(self._next_z())
 s.scene.addItem(tx)
 elif hasattr(shp, "image"):
 try:
 b = shp.image.blob
 im = ImageItem(x=x, y=y, w=w, h=h)
 im.setImageBytes(b, path="")
 if meta and "eid" in meta:
 im.eid = meta["eid"]
 if meta and "anim" in meta:
 im.anim = meta["anim"]
 im.setZValue(self._next_z())
 s.scene.addItem(im)
 except Exception:
 pass
 else:
 try:
 at = getattr(shp, "auto_shape_type", None)
 kind = "rect"
 if at is not None:
 if str(at).endswith("OVAL"):
 kind = "ellipse"
 if str(at).endswith("LINE"):
 kind = "line"
 sh_it = ShapeItem(kind, x=x, y=y, w=w, h=h)
 if meta and "eid" in meta:
 sh_it.eid = meta["eid"]
 if meta and "anim" in meta:
 sh_it.anim = meta["anim"]
 s.scene.addItem(sh_it)
 except Exception:
 pass
 new_slides.append(s)
 if not new_slides:
 QMessageBox.warning(self, "Import", "No slides found.")
 return
 self._building = True
 self.file_path = ""
 self.slides = new_slides
 self.cur = 0
 self._rebuild_slide_list()
 self.goto_slide(0)
 self.history.clear()
 self.history.push(self.serialize_deck())
 self._building = False
 self._clean_state = self.serialize_deck()
 self._update_title()
 except Exception as ex:
 QMessageBox.critical(self, "Import failed", str(ex))
os.environ["QT_LOGGING_RULES"] = (os.environ.get("QT_LOGGING_RULES","") + ";qt.qpa.fonts.warning=false").lstrip(";")
def main():
 app = QApplication(sys.argv)
 app.setStyleSheet(office_light_stylesheet())
 w = SlidesMain()
 w.show()
 sys.exit(app.exec())
if __name__ == "__main__":
 main()

import sys, os, fitz, platform
from PyQt6.QtCore import Qt, QRectF, QPointF
from PyQt6.QtGui import QAction, QPixmap, QImage, QPainter, QColor, QIcon, QKeySequence
from PyQt6.QtWidgets import (
    QApplication, QMainWindow, QFileDialog, QLabel, QToolBar, QSpinBox,
    QStatusBar, QMessageBox, QInputDialog, QWidget, QVBoxLayout, QPushButton,
    QScrollArea, QColorDialog, QFontComboBox, QToolButton, QHBoxLayout
)

APP_NAME = "PDF Tool"
APP_PROGID = "PDFTool.Viewer"

def pil2qpixmap(img_bytes_w, img_h, img_w, stride, fmt=QImage.Format.Format_RGBA8888):
    qimg = QImage(img_bytes_w, img_w, img_h, stride, fmt)
    return QPixmap.fromImage(qimg)

def qcolor_to_rgb01(c: QColor):
    return (c.red() / 255.0, c.green() / 255.0, c.blue() / 255.0)

def resolve_fontname(family: str, bold: bool, italic: bool):
    f = family.lower()
    base = "helv"
    if "cour" in f or "mono" in f or "consolas" in f or "code" in f:
        base = "cour"
    elif "times" in f or "georgia" in f or "serif" in f:
        base = "times"
    name = base
    if bold and italic:
        name += "bi"
    elif bold:
        name += "b"
    elif italic:
        name += "i"
    return name

class PageCanvas(QLabel):
    def __init__(self, parent=None):
        super().__init__(parent)
        self.setAlignment(Qt.AlignmentFlag.AlignTop | Qt.AlignmentFlag.AlignLeft)
        self.setMouseTracking(True)
        self._dragging = False
        self._drag_start = None
        self._drag_end = None
        self._drawing = False
        self._path = []
        self._hand_panning = False
        self._hand_last_pos = None
        self.scroll_area = None
        self.mode = "hand"
        self.scale = 1.0
        self.page = None
        self.page_pixmap = None
        self.doc = None
        self.pen_color = QColor(0, 0, 255)
        self.text_color = QColor(0, 0, 0)
        self.pen_width = 2
        self.text_font_family = "Helvetica"
        self.text_font_size = 14
        self.text_bold = False
        self.text_italic = False
        self.selected_annot = None
        self._selected_annot_rect_page = None
        self._selected_view_rect = None
        self._moving_annot = False
        self._move_start_view = None
        self._move_delta_view = QPointF(0, 0)
        self.owner = None

def set_page(self, doc, page, scale, pixmap):
        self.doc = doc
        self.page = page
        self.scale = scale
        self.page_pixmap = pixmap
        self.setPixmap(pixmap)
        self.setFixedSize(pixmap.size())
        self.selected_annot = None
        self._selected_annot_rect_page = None
        self._selected_view_rect = None
        self._moving_annot = False
        self._move_start_view = None
        self._move_delta_view = QPointF(0, 0)

def mousePressEvent(self, e):
        if not self.page:
            return

if self.mode == "hand" and e.button() == Qt.MouseButton.LeftButton and self.scroll_area:
            self._hand_panning = True
            self._hand_last_pos = e.globalPosition()
            self.setCursor(Qt.CursorShape.ClosedHandCursor)
            return

if self.mode == "select" and e.button() == Qt.MouseButton.LeftButton:
            view_pt = e.position()
            page_pt = self._view_to_page_point(view_pt)
            if not page_pt:
                return
            hit_annot = None
            annot = self.page.first_annot
            while annot:
                if annot.rect.contains(page_pt):
                    hit_annot = annot
                    break
                annot = annot.next
            if hit_annot:
                self.selected_annot = hit_annot
                self._selected_annot_rect_page = hit_annot.rect
                self._selected_view_rect = self._page_rect_to_view_rect(hit_annot.rect)
                self._move_start_view = view_pt
                self._move_delta_view = QPointF(0, 0)
                self._moving_annot = True
                self.update()
            else:
                self.selected_annot = None
                self._selected_annot_rect_page = None
                self._selected_view_rect = None
                self._moving_annot = False
                self._move_start_view = None
                self._move_delta_view = QPointF(0, 0)
                self.update()
            return

if self.mode == "highlight" and e.button() == Qt.MouseButton.LeftButton:
            self._dragging = True
            self._drag_start = e.position()
            self._drag_end = e.position()
            self.update()

elif self.mode == "note" and e.button() == Qt.MouseButton.LeftButton:
            pos = e.position()
            self._add_text_annot_at_view(pos)

elif self.mode == "type" and e.button() == Qt.MouseButton.LeftButton:
            self._dragging = True
            self._drag_start = e.position()
            self._drag_end = e.position()
            self.update()

elif self.mode == "draw" and e.button() == Qt.MouseButton.LeftButton:
            self._drawing = True
            self._path = [e.position()]
            self.update()

else:
            super().mousePressEvent(e)

def _page_rect_to_view_rect(self, rect: fitz.Rect) -> QRectF:
        x = rect.x0 * self.scale
        y = rect.y0 * self.scale
        w = (rect.x1 - rect.x0) * self.scale
        h = (rect.y1 - rect.y0) * self.scale
        return QRectF(x, y, w, h)

def mouseMoveEvent(self, e):
        if self._hand_panning and self.scroll_area:
            delta = e.globalPosition() - self._hand_last_pos
            self._hand_last_pos = e.globalPosition()
            hbar = self.scroll_area.horizontalScrollBar()
            vbar = self.scroll_area.verticalScrollBar()
            hbar.setValue(hbar.value() - int(delta.x()))
            vbar.setValue(vbar.value() - int(delta.y()))
            return

if self.mode == "select" and self._moving_annot and self._selected_view_rect is not None:
            self._move_delta_view = e.position() - self._move_start_view
            self.update()
            return

if self._dragging and (self.mode in ("highlight", "type")):
            self._drag_end = e.position()
            self.update()

elif self._drawing and self.mode == "draw":
            self._path.append(e.position())
            self.update()

else:
            super().mouseMoveEvent(e)

def mouseReleaseEvent(self, e):
        if self._hand_panning and e.button() == Qt.MouseButton.LeftButton:
            self._hand_panning = False
            self.setCursor(Qt.CursorShape.OpenHandCursor)
            return

if self.mode == "select" and self._moving_annot and e.button() == Qt.MouseButton.LeftButton:
            self._moving_annot = False
            if self.selected_annot and self._selected_annot_rect_page and self._move_delta_view is not None:
                dx_page = self._move_delta_view.x() / self.scale
                dy_page = self._move_delta_view.y() / self.scale
                r = self._selected_annot_rect_page
                new_rect = fitz.Rect(
                    r.x0 + dx_page,
                    r.y0 + dy_page,
                    r.x1 + dx_page,
                    r.y1 + dy_page,
                )
                if self.owner:
                    self.owner.push_undo_state()
                try:
                    self.selected_annot.set_rect(new_rect)
                    self.selected_annot.update()
                except Exception:
                    pass
                self._selected_annot_rect_page = new_rect
                self._selected_view_rect = self._page_rect_to_view_rect(new_rect)
                self._move_start_view = None
                self._move_delta_view = QPointF(0, 0)
                self._refresh_raster()
            return

if self._dragging and self.mode == "highlight":
            self._dragging = False
            rect = QRectF(self._drag_start, self._drag_end).normalized()
            if rect.width() > 5 and rect.height() > 5:
                self._add_rect_highlight_annot(rect)
            self._drag_start = self._drag_end = None
            self.update()

elif self._dragging and self.mode == "type":
            self._dragging = False
            rect = QRectF(self._drag_start, self._drag_end).normalized()
            self._drag_start = self._drag_end = None
            if rect.width() > 10 and rect.height() > 10:
                self._add_freetext_annot(rect)
            self.update()

elif self._drawing and self.mode == "draw":
            self._drawing = False
            if len(self._path) >= 2:
                self._commit_ink_path(self._path)
            self._path = []
            self.update()

else:
            super().mouseReleaseEvent(e)

def paintEvent(self, event):
        super().paintEvent(event)

if self._dragging and self._drag_start and self._drag_end and self.mode in ("highlight", "type"):
            painter = QPainter(self)
            painter.setPen(Qt.GlobalColor.yellow if self.mode == "highlight" else Qt.GlobalColor.black)
            painter.drawRect(QRectF(self._drag_start, self._drag_end).normalized())
            painter.end()

if self._drawing and len(self._path) >= 2:
            painter = QPainter(self)
            pen = painter.pen()
            pen.setColor(self.pen_color)
            pen.setWidth(self.pen_width)
            painter.setPen(pen)
            for i in range(len(self._path) - 1):
                painter.drawLine(self._path[i], self._path[i + 1])
            painter.end()

if self.selected_annot and self._selected_view_rect is not None:
            painter = QPainter(self)
            pen = painter.pen()
            pen.setColor(QColor(0, 120, 215))
            pen.setWidth(2)
            pen.setStyle(Qt.PenStyle.DashLine)
            painter.setPen(pen)
            rect = self._selected_view_rect
            if self._moving_annot:
                rect = rect.translated(self._move_delta_view)
            painter.drawRect(rect)
            painter.end()

def _view_to_page_point(self, pt: QPointF):
        if not self.page_pixmap:
            return None
        x = pt.x() / self.scale
        y = pt.y() / self.scale
        return fitz.Point(x, y)

def _view_rect_to_page_rect(self, rect: QRectF):
        p1 = self._view_to_page_point(rect.topLeft())
        p2 = self._view_to_page_point(rect.bottomRight())
        if not p1 or not p2:
            return None
        return fitz.Rect(p1, p2)

def _add_rect_highlight_annot(self, view_rect: QRectF):
        page_rect = self._view_rect_to_page_rect(view_rect)
        if not page_rect:
            return
        if self.owner:
            self.owner.push_undo_state()
        annot = self.page.add_rect_annot(page_rect)
        annot.set_colors(stroke=(1, 1, 0), fill=(1, 1, 0))
        annot.set_opacity(0.30)
        annot.update()
        self._refresh_raster()

def _add_text_annot_at_view(self, view_pt: QPointF):
        page_pt = self._view_to_page_point(view_pt)
        if not page_pt:
            return
        text, ok = QInputDialog.getText(self, "Add Note", "Note text:")
        if not ok or not text.strip():
            return
        if self.owner:
            self.owner.push_undo_state()
        self.page.add_text_annot(page_pt, text.strip())
        self._refresh_raster()

def _add_freetext_annot(self, view_rect: QRectF):
        page_rect = self._view_rect_to_page_rect(view_rect)
        if not page_rect:
            return
        text, ok = QInputDialog.getMultiLineText(self, "Type Text", "Text:")
        if not ok or not text.strip():
            return
        fontname = resolve_fontname(self.text_font_family, self.text_bold, self.text_italic)
        if self.owner:
            self.owner.push_undo_state()
        try:
            annot = self.page.add_freetext_annot(
                page_rect,
                text.strip(),
                fontsize=self.text_font_size,
                fontname=fontname,
                text_color=qcolor_to_rgb01(self.text_color),
                fill_color=None,
                align=0,
            )
            annot.set_border(width=0.0)
            annot.update()
        except Exception:
            self.page.insert_textbox(
                page_rect,
                text.strip(),
                fontsize=self.text_font_size,
                color=qcolor_to_rgb01(self.text_color),
                fontname="helv",
                align=0,
                render_mode=0,
            )
        self._refresh_raster()

def _commit_ink_path(self, pts):
 if not pts or self.page is None:
 return
 pg_pts = []
 for p in pts:
 page_pt = self._view_to_page_point(p)
 if page_pt is None:
 continue
 x = float(getattr(page_pt, "x", page_pt[0]))
 y = float(getattr(page_pt, "y", page_pt[1]))
 pg_pts.append((x, y))
 if len(pg_pts) < 2:
 return
 ink_list = [pg_pts]
 if self.owner:
 self.owner.push_undo_state()
 annot = self.page.add_ink_annot(ink_list)
 annot.set_colors(stroke=qcolor_to_rgb01(self.pen_color))
 try:
 annot.set_border(width=max(0.5, float(self.pen_width)))
 except Exception:
 pass
 annot.update()
 self._refresh_raster()

def _refresh_raster(self):
        if not self.page:
            return
        mat = fitz.Matrix(self.scale, self.scale)
        pm = self.page.get_pixmap(matrix=mat, alpha=True)
        qpm = pil2qpixmap(pm.samples, pm.h, pm.w, pm.stride)
        self.page_pixmap = qpm
        self.setPixmap(qpm)
        self.setFixedSize(qpm.size())

class PDFWindow(QMainWindow):
    def __init__(self):
        super().__init__()
        self.setWindowTitle(APP_NAME)
        self.resize(1200, 850)
        self.doc = None
        self.path = None
        self.page_index = 0
        self.scale = 1.5
        self.undo_stack = []
        self.redo_stack = []
        self.max_history = 20
        self._in_undo_redo = False
        self.scroll = QScrollArea()
        self.scroll.setWidgetResizable(True)
        self.canvas = PageCanvas()
        self.canvas.scroll_area = self.scroll
        wrapper = QWidget()
        v = QVBoxLayout(wrapper)
        v.setContentsMargins(10, 10, 10, 10)
        v.addWidget(self.canvas)
        self.scroll.setWidget(wrapper)

self.preview_panel = QWidget()
        self.preview_panel.setFixedWidth(200)
        self.preview_layout = QVBoxLayout(self.preview_panel)
        self.preview_layout.setContentsMargins(4, 4, 4, 4)
        self.preview_layout.setSpacing(8)
        self.preview_title = QLabel("Next pages")
        self.preview_title.setAlignment(Qt.AlignmentFlag.AlignHCenter)
        self.preview_layout.addWidget(self.preview_title)
        self.preview_layout.addStretch()
        self.preview_labels = []
        central = QWidget()
        h = QHBoxLayout(central)
        h.setContentsMargins(0, 0, 0, 0)
        h.setSpacing(0)
        h.addWidget(self.scroll, 1)
        h.addWidget(self.preview_panel)
        self.setCentralWidget(central)
        self._make_toolbar()
        self.status = QStatusBar(self)
        self.setStatusBar(self.status)
        self.canvas_doc_link()

def canvas_doc_link(self):
        self.canvas.doc = self.doc

def push_undo_state(self):
        if self._in_undo_redo:
            return
        if not self.doc:
            return
        try:
            state = self.doc.tobytes()
        except Exception:
            return
        self.undo_stack.append((state, self.page_index))
        if len(self.undo_stack) > self.max_history:
            self.undo_stack.pop(0)
        self.redo_stack.clear()

def undo(self):
        if not self.undo_stack:
            return
        if self.doc:
            try:
                current_state = self.doc.tobytes()
            except Exception:
                current_state = None
            if current_state is not None:
                self.redo_stack.append((current_state, self.page_index))
                if len(self.redo_stack) > self.max_history:
                    self.redo_stack.pop(0)
        state, page_index = self.undo_stack.pop()
        self._in_undo_redo = True
        if self.doc:
            try:
                self.doc.close()
            except Exception:
                pass
        self.doc = fitz.open(stream=state, filetype="pdf")
        self.canvas.doc = self.doc
        self.page_index = min(page_index, len(self.doc) - 1)
        self._render_current_page()
        self._in_undo_redo = False

def redo(self):
        if not self.redo_stack:
            return
        if self.doc:
            try:
                current_state = self.doc.tobytes()
            except Exception:
                current_state = None
            if current_state is not None:
                self.undo_stack.append((current_state, self.page_index))
                if len(self.undo_stack) > self.max_history:
                    self.undo_stack.pop(0)
        state, page_index = self.redo_stack.pop()
        self._in_undo_redo = True
        if self.doc:
            try:
                self.doc.close()
            except Exception:
                pass
        self.doc = fitz.open(stream=state, filetype="pdf")
        self.canvas.doc = self.doc
        self.page_index = min(page_index, len(self.doc) - 1)
        self._render_current_page()
        self._in_undo_redo = False

def _make_toolbar(self):
        tb = QToolBar("Main")
        self.addToolBar(tb)

act_open = QAction("Open", self)
        act_open.triggered.connect(self.open_pdf)
        act_save = QAction("Save", self)
        act_save.triggered.connect(self.save_pdf)
        act_saveas = QAction("Save As", self)
        act_saveas.triggered.connect(self.save_as_pdf)
        act_export = QAction("Export PNG", self)
        act_export.triggered.connect(self.export_png)

act_undo = QAction("↶", self)
        act_undo.setToolTip("Undo (Ctrl+Z)")
        act_undo.setShortcut(QKeySequence("Ctrl+Z"))
        act_undo.triggered.connect(self.undo)

act_redo = QAction("↷", self)
        act_redo.setToolTip("Redo (Ctrl+Y)")
        act_redo.setShortcut(QKeySequence("Ctrl+Y"))
        act_redo.triggered.connect(self.redo)

tb.addAction(act_open)
        tb.addAction(act_save)
        tb.addAction(act_saveas)
        tb.addAction(act_export)
        tb.addSeparator()
        tb.addAction(act_undo)
        tb.addAction(act_redo)
        tb.addSeparator()

self.zoom_box = QSpinBox()
        self.zoom_box.setRange(25, 600)
        self.zoom_box.setSuffix("%")
        self.zoom_box.setValue(int(self.scale * 100))
        self.zoom_box.valueChanged.connect(self.on_zoom_changed)
        tb.addWidget(self.zoom_box)

tb.addSeparator()
        self.btn_prev = QPushButton("◀ Prev")
        self.btn_next = QPushButton("Next ▶")
        self.btn_prev.clicked.connect(self.prev_page)
        self.btn_next.clicked.connect(self.next_page)
        tb.addWidget(self.btn_prev)
        tb.addWidget(self.btn_next)

tb.addSeparator()
        act_select = QAction("Select", self)
        act_select.triggered.connect(lambda: self.set_mode("select"))
        act_hand = QAction("Hand", self)
        act_hand.triggered.connect(lambda: self.set_mode("hand"))
        act_hl = QAction("Highlight", self)
        act_hl.triggered.connect(lambda: self.set_mode("highlight"))
        act_note = QAction("Note", self)
        act_note.triggered.connect(lambda: self.set_mode("note"))
        act_draw = QAction("Draw", self)
        act_draw.triggered.connect(lambda: self.set_mode("draw"))
        act_type = QAction("Type", self)
        act_type.triggered.connect(lambda: self.set_mode("type"))
        tb.addAction(act_select)
        tb.addAction(act_hand)
        tb.addAction(act_hl)
        tb.addAction(act_note)
        tb.addAction(act_draw)

self.pen_color_btn = QToolButton()
        self.pen_color_btn.setText("🖊")
        self.pen_color_btn.setToolTip("Pen Color")
        self.pen_color_btn.clicked.connect(self.pick_pen_color)
        tb.addWidget(self.pen_color_btn)

tb.addAction(act_type)

tb2 = QToolBar("Format")
        self.addToolBar(tb2)

self.font_combo = QFontComboBox()
        self.font_combo.setMaximumWidth(220)
        self.font_combo.currentFontChanged.connect(lambda f: setattr(self.canvas, "text_font_family", f.family()))
        tb2.addWidget(self.font_combo)

self.size_box = QSpinBox()
        self.size_box.setRange(6, 96)
        self.size_box.setValue(14)
        self.size_box.valueChanged.connect(lambda v: setattr(self.canvas, "text_font_size", v))
        tb2.addWidget(self.size_box)

self.btn_bold = QToolButton()
        self.btn_bold.setText("B")
        self.btn_bold.setCheckable(True)
        self.btn_bold.setToolTip("Bold")
        self.btn_bold.clicked.connect(lambda s: setattr(self.canvas, "text_bold", s))
        tb2.addWidget(self.btn_bold)

self.btn_italic = QToolButton()
        self.btn_italic.setText("I")
        self.btn_italic.setCheckable(True)
        self.btn_italic.setToolTip("Italic")
        self.btn_italic.clicked.connect(lambda s: setattr(self.canvas, "text_italic", s))
        tb2.addWidget(self.btn_italic)

self.color_btn = QToolButton()
        self.color_btn.setText("Text Color")
        self.color_btn.clicked.connect(self.pick_text_color)
        tb2.addWidget(self.color_btn)

self.pen_w_box = QSpinBox()
        self.pen_w_box.setRange(1, 20)
        self.pen_w_box.setValue(2)
        self.pen_w_box.valueChanged.connect(lambda v: setattr(self.canvas, "pen_width", v))
        tb2.addWidget(self.pen_w_box)

tb.addSeparator()
        act_register = QAction("Register Default", self)
        act_register.triggered.connect(self.register_open_with)
        act_set_default_help = QAction("Help", self)
        act_set_default_help.triggered.connect(self.show_default_help)
        tb.addAction(act_register)
        tb.addAction(act_set_default_help)

def set_mode(self, m):
        self.canvas.mode = m
        if m == "hand":
            self.canvas.setCursor(Qt.CursorShape.OpenHandCursor)
        else:
            self.canvas.setCursor(Qt.CursorShape.ArrowCursor)
        self.status.showMessage(f"Mode: {m}", 3000)

def pick_text_color(self):
        c = QColorDialog.getColor(self.canvas.text_color, self, "Choose Text Color")
        if c.isValid():
            self.canvas.text_color = c

def pick_pen_color(self):
        c = QColorDialog.getColor(self.canvas.pen_color, self, "Choose Pen Color")
        if c.isValid():
            self.canvas.pen_color = c

def open_pdf(self):
        fn, _ = QFileDialog.getOpenFileName(self, "Open PDF", "", "PDF Files (*.pdf)")
        if not fn:
            return
        try:
            self._load_doc(fn)
        except Exception as e:
            QMessageBox.critical(self, "Open failed", str(e))

def _load_doc(self, path):
        if self.doc:
            self.doc.close()
        self.doc = fitz.open(path)
        self.path = path
        self.page_index = 0
        self.canvas.doc = self.doc
        self.undo_stack.clear()
        self.redo_stack.clear()
        self._render_current_page()
        self.setWindowTitle(f"{APP_NAME} — {os.path.basename(path)}  ({self.page_index+1}/{len(self.doc)})")

def _render_current_page(self):
        if not self.doc:
            return
        page = self.doc.load_page(self.page_index)
        mat = fitz.Matrix(self.scale, self.scale)
        pm = page.get_pixmap(matrix=mat, alpha=True)
        qpm = pil2qpixmap(pm.samples, pm.h, pm.w, pm.stride)
        self.canvas.set_page(self.doc, page, self.scale, qpm)
        self.setWindowTitle(f"{APP_NAME} — {os.path.basename(self.path)}  ({self.page_index+1}/{len(self.doc)})")
        self._update_previews()

def _update_previews(self):
        if not self.doc:
            self.preview_panel.setVisible(False)
            return

total = len(self.doc)
 if total <= 1:
 self.preview_panel.setVisible(False)
 return

self.preview_panel.setVisible(True)

for lbl in self.preview_labels:
            self.preview_layout.removeWidget(lbl)
            lbl.deleteLater()
        self.preview_labels.clear()

max_preview = 4
        start = self.page_index + 1
        end = min(total, start + max_preview)
        if start >= end:
            return

max_width = 140

for i in range(start, end):
            page = self.doc.load_page(i)
            mat = fitz.Matrix(0.4, 0.4)
            pm = page.get_pixmap(matrix=mat, alpha=True)
            qpm = pil2qpixmap(pm.samples, pm.h, pm.w, pm.stride)
            thumb = qpm.scaledToWidth(max_width, Qt.TransformationMode.SmoothTransformation)

lbl = QLabel()
            lbl.setPixmap(thumb)
            lbl.setAlignment(Qt.AlignmentFlag.AlignCenter)
            lbl.setToolTip(f"Page {i+1}")

self.preview_layout.insertWidget(self.preview_layout.count() - 1, lbl)
            self.preview_labels.append(lbl)

def save_pdf(self):
        if not self.doc or not self.path:
            return self.save_as_pdf()
        try:
            self.doc.saveIncr()
            self.status.showMessage("Saved.", 3000)
        except Exception:
            tmp = self.path + ".tmp.pdf"
            self.doc.save(tmp)
            os.replace(tmp, self.path)
            self.status.showMessage("Saved (full).", 3000)

def save_as_pdf(self):
        if not self.doc:
            return
        fn, _ = QFileDialog.getSaveFileName(self, "Save As", self.path or "document.pdf", "PDF Files (*.pdf)")
        if not fn:
            return
        if not fn.lower().endswith(".pdf"):
            fn += ".pdf"
        self.doc.save(fn)
        self.path = fn
        self.status.showMessage(f"Saved to {fn}", 3000)
        self.setWindowTitle(f"{APP_NAME} — {os.path.basename(self.path)}  ({self.page_index+1}/{len(self.doc)})")

def export_png(self):
        if not self.doc:
            return
        page = self.doc.load_page(self.page_index)
        pm = page.get_pixmap(matrix=fitz.Matrix(self.scale, self.scale), alpha=True)
        fn, _ = QFileDialog.getSaveFileName(self, "Export Page as PNG", f"page-{self.page_index+1}.png", "PNG Files (*.png)")
        if not fn:
            return
        if not fn.lower().endswith(".png"):
            fn += ".png"
        pm.save(fn)
        self.status.showMessage(f"Exported {fn}", 3000)

def on_zoom_changed(self, val):
        self.scale = max(0.25, min(6.0, val / 100.0))
        if self.doc:
            self._render_current_page()

def prev_page(self):
        if not self.doc:
            return
        if self.page_index > 0:
            self.page_index -= 1
            self._render_current_page()

def next_page(self):
 if not self.doc:
 return
 if self.page_index < len(self.doc) - 1:
 self.page_index += 1
 self._render_current_page()

def register_open_with(self):
        if platform.system() != "Windows":
            QMessageBox.information(self, "Not Windows", "Registration is Windows-only.")
            return
        try:
            import winreg
            exe = sys.executable
            if getattr(sys, "frozen", False):
                exe = sys.argv[0]
                cmd = f"\"{exe}\" \"%1\""
            else:
                script = os.path.abspath(sys.argv[0])
                cmd = f"\"{sys.executable}\" \"{script}\" \"%1\""
            with winreg.CreateKey(winreg.HKEY_CURRENT_USER, rf"Software\Classes\{APP_PROGID}") as k:
                winreg.SetValueEx(k, None, 0, winreg.REG_SZ, APP_NAME)
                with winreg.CreateKey(k, r"shell\open\command") as kc:
                    winreg.SetValueEx(kc, None, 0, winreg.REG_SZ, cmd)
            with winreg.CreateKey(winreg.HKEY_CURRENT_USER, r"Software\Classes\.pdf\OpenWithProgids") as k2:
                winreg.SetValueEx(k2, APP_PROGID, 0, winreg.REG_DWORD, 0)
            QMessageBox.information(self, "Registered", "Added to 'Open with' for .pdf.")
        except Exception as e:
            QMessageBox.critical(self, "Registration failed", str(e))

def show_default_help(self):
        msg = (
            "To set this app as the default PDF viewer:\n"
            "1) Right-click any .pdf → Open with → Choose another app.\n"
            f"2) Select “{APP_NAME}” → check ‘Always use this app to open .pdf files’ → OK.\n\n"
            "Or open Settings → Apps → Default apps → search ‘.pdf’ and select this app.\n"
        )
        QMessageBox.information(self, "Set Default", msg)

def main():
    app = QApplication(sys.argv)
    w = PDFWindow()
    w.show()
    if len(sys.argv) >= 2 and os.path.isfile(sys.argv[-1]) and sys.argv[-1].lower().endswith(".pdf"):
        try:
            w._load_doc(sys.argv[-1])
        except Exception as e:
            QMessageBox.critical(w, "Open failed", str(e))
    sys.exit(app.exec())

if __name__ == "__main__":
    main()