picview 0.0.1__py3-none-any.whl

picview/__init__.py

@@ -0,0 +1,3 @@
+"""PicView image viewer."""
+
+__version__ = "0.0.1"

picview/__main__.py

@@ -0,0 +1,3 @@
+from .qt_app import main
+
+main()

picview/app.py

@@ -0,0 +1,264 @@
+from __future__ import annotations
+
+import tkinter as tk
+import locale
+from pathlib import Path
+from tkinter import filedialog, messagebox, ttk
+import customtkinter as ctk
+
+try:
+    from tkinterdnd2 import DND_FILES, TkinterDnD
+except ImportError:  # Allows unit-level imports if optional UI dependency is absent.
+    DND_FILES = "DND_Files"
+    TkinterDnD = None
+
+from .image_pane import ImagePane
+from .settings import load_settings, save_settings
+from .thumbnail_pane import ThumbnailPane
+from .utils import image_files
+from .ui import TEXT, IconButton, configure_flat_style
+
+
+class PicViewApp:
+    def __init__(self, root: tk.Tk) -> None:
+        self.root = root
+        self.settings = load_settings()
+        self.folder: Path | None = None
+        self.files: list[Path] = []
+        self.orientation = self.settings["orientation"]
+        # A maximized pane is a transient viewing mode. Restoring it before a
+        # ttk PanedWindow has completed geometry produces an orphaned sash and
+        # hides the other pane, so startup always restores the normal layout.
+        self.maximized_pane = ""
+        self.sash_fraction = float(self.settings["sash_fraction"])
+        self.language_mode = self.settings["language"]
+        system_language = (locale.getlocale()[0] or "en").lower()
+        self.language = "zh" if self.language_mode == "system" and system_language.startswith("zh") else (self.language_mode if self.language_mode in TEXT else "en")
+        self.labels = TEXT[self.language]
+        self._build_window()
+        self._restore_state()
+
+    def _build_window(self) -> None:
+        self.root.title("PicView")
+        self.root.minsize(720, 500)
+        self.root.geometry("1100x780")
+        configure_flat_style(self.root)
+        icon_path = Path(__file__).parent / "assets" / "picview-icon.png"
+        if icon_path.exists():
+            self.icon_image = tk.PhotoImage(file=icon_path)
+            self.root.iconphoto(True, self.icon_image)
+        self.root.protocol("WM_DELETE_WINDOW", self.close)
+        self.root.drop_target_register(DND_FILES)
+        self.root.dnd_bind("<<Drop>>", self._on_drop)
+
+        ctk.set_appearance_mode("system")
+        ctk.set_default_color_theme("blue")
+        toolbar = ctk.CTkFrame(self.root, height=48, corner_radius=0, fg_color=("#eaf1f4", "#16232c"))
+        toolbar.pack(fill="x")
+        toolbar.pack_propagate(False)
+        self._icon_button(toolbar, "folder", "open", self.choose_folder).pack(side="left")
+        ctk.CTkFrame(toolbar, width=1, fg_color=("#c9d8dd", "#36505d")).pack(side="left", fill="y", pady=9, padx=8)
+        self._icon_button(toolbar, "split_h", "vertical", lambda: self.set_orientation("vertical")).pack(side="left")
+        self._icon_button(toolbar, "split_v", "horizontal", lambda: self.set_orientation("horizontal")).pack(side="left", padx=2)
+        ctk.CTkFrame(toolbar, width=1, fg_color=("#c9d8dd", "#36505d")).pack(side="left", fill="y", pady=9, padx=8)
+        self._icon_button(toolbar, "En" if self.language == "zh" else "文", "language", self.toggle_language).pack(side="left")
+
+        self.pane_host = ctk.CTkFrame(self.root, corner_radius=0, fg_color=("#dce7eb", "#101820"))
+        self.pane_host.pack(fill="both", expand=True, padx=8, pady=8)
+        self._create_panes()
+
+    def _create_panes(self) -> None:
+        old_thumbnail_size = int(self.settings["thumbnail_size"])
+        old_image_zoom = float(self.settings["image_zoom"])
+        selected = None
+        if hasattr(self, "thumbnails"):
+            old_thumbnail_size = self.thumbnails.thumbnail_size
+            old_image_zoom = self.image.zoom_var.get()
+            selected = self.thumbnails.selected
+            self.paned.destroy()
+        orient = tk.VERTICAL if self.orientation == "vertical" else tk.HORIZONTAL
+        self.paned = ttk.Panedwindow(self.pane_host, orient=orient)
+        self.paned.pack(fill="both", expand=True)
+        self.thumbnails = ThumbnailPane(self.paned, self.select_image, self.labels, self.toggle_maximize, old_thumbnail_size)
+        self.image = ImagePane(self.paned, self.labels, self.toggle_maximize, old_image_zoom)
+        self.paned.add(self.thumbnails, weight=1)
+        self.paned.add(self.image, weight=2)
+        self.thumbnails.set_files(self.files, selected)
+        if self.maximized_pane:
+            self.root.after_idle(lambda: self._apply_maximized(self.maximized_pane))
+        else:
+            self.root.after_idle(self._restore_sash)
+
+    def choose_folder(self) -> None:
+        chosen = filedialog.askdirectory(parent=self.root, title="Open image folder", initialdir=str(self.folder) if self.folder else None)
+        if chosen:
+            self.open_folder(Path(chosen))
+
+    def open_folder(self, folder: Path, selected: Path | None = None) -> None:
+        try:
+            folder = folder.resolve()
+            if not folder.is_dir():
+                raise OSError
+        except OSError:
+            messagebox.showerror("PicView", "That folder cannot be opened.", parent=self.root)
+            return
+        self.folder = folder
+        self.files = image_files(folder)
+        self._create_panes()
+        target = selected if selected in self.files else (self.files[0] if self.files else None)
+        if target:
+            self.thumbnails.select(target)
+        else:
+            self.image.load_empty()
+        self._update_title()
+
+    def select_image(self, path: Path) -> None:
+        self.image.load(path)
+
+    def current_selection(self) -> Path | None:
+        return getattr(self, "thumbnails", None).selected if hasattr(self, "thumbnails") else None
+
+    def set_orientation(self, orientation: str) -> None:
+        if orientation == self.orientation:
+            return
+        # Layout switches are always two-pane layouts; do not route through
+        # the maximize restore path, which can leave a stale sash in ttk.
+        self.sash_fraction = self._current_sash_fraction()
+        self.maximized_pane = ""
+        self.orientation = orientation
+        self._create_panes()
+        self.root.after(40, self._ensure_two_panes)
+
+    def _ensure_two_panes(self) -> None:
+        """Repair a deferred ttk PanedWindow layout after orientation changes."""
+        if self.maximized_pane:
+            return
+        current = set(self.paned.panes())
+        wanted = {str(self.thumbnails), str(self.image)}
+        if current != wanted:
+            for pane in current:
+                self.paned.forget(pane)
+            self.paned.add(self.thumbnails, weight=1)
+            self.paned.add(self.image, weight=2)
+        self.thumbnails.set_maximized(False)
+        self.image.set_maximized(False)
+        self._restore_sash()
+
+    def toggle_maximize(self, pane: str) -> None:
+        if pane == self.maximized_pane or not pane:
+            self.maximized_pane = ""
+            self._apply_maximized("")
+        else:
+            if self.maximized_pane:
+                self.maximized_pane = ""
+                self._apply_maximized("")
+            self.sash_fraction = self._current_sash_fraction()
+            self.maximized_pane = pane
+            self._apply_maximized(pane)
+
+    def _apply_maximized(self, pane: str) -> None:
+        panes = list(self.paned.panes())
+        target = str(self.thumbnails if pane == "thumbnails" else self.image)
+        if pane:
+            for item in panes:
+                if item != target:
+                    self.paned.forget(item)
+            self.thumbnails.set_maximized(pane == "thumbnails")
+            self.image.set_maximized(pane == "image")
+        else:
+            for item in panes:
+                self.paned.forget(item)
+            self.paned.add(self.thumbnails, weight=1)
+            self.paned.add(self.image, weight=2)
+            self.thumbnails.set_maximized(False)
+            self.image.set_maximized(False)
+            self.root.after(20, self._restore_sash)
+
+    def _restore_sash(self, attempts: int = 0) -> None:
+        if not self.paned.panes() or self.maximized_pane:
+            return
+        try:
+            dimension = self.paned.winfo_height() if self.orientation == "vertical" else self.paned.winfo_width()
+            # `after_idle` can run before the PanedWindow receives its final
+            # geometry (dimension == 1). Setting sashpos then collapses the
+            # first pane to zero, which looks like a false maximized image.
+            if dimension <= 1 and attempts < 10:
+                self.root.after(50, lambda: self._restore_sash(attempts + 1))
+                return
+            if dimension <= 1:
+                return
+            self.paned.sashpos(0, int(dimension * self.sash_fraction))
+        except tk.TclError:
+            pass
+
+    def _on_drop(self, event: tk.Event) -> str:
+        items = self.root.tk.splitlist(event.data)
+        if not items:
+            return "break"
+        path = Path(items[0])
+        if path.is_dir():
+            self.open_folder(path)
+        elif path.is_file():
+            self.open_folder(path.parent, path)
+        return "break"
+
+    def _restore_state(self) -> None:
+        folder = Path(self.settings["folder"]) if self.settings["folder"] else None
+        if folder and folder.is_dir():
+            saved = Path(self.settings["selected_file"])
+            self.open_folder(folder, saved if saved.is_file() else None)
+
+    def _update_title(self) -> None:
+        self.root.title(f"PicView — {self.folder}" if self.folder else "PicView")
+
+    def close(self) -> None:
+        sash_fraction = self._current_sash_fraction()
+        selected = self.current_selection()
+        save_settings({
+            "folder": str(self.folder) if self.folder else "",
+            "selected_file": str(selected) if selected else "",
+            "orientation": self.orientation,
+            "sash_fraction": sash_fraction,
+            "maximized_pane": "",
+            "thumbnail_size": self.thumbnails.thumbnail_size,
+            "image_zoom": self.image.zoom_var.get(),
+            "language": self.language_mode,
+        })
+        self.image.close_fullscreen()
+        self.root.destroy()
+
+    def _current_sash_fraction(self) -> float:
+        if self.maximized_pane or not self.paned.panes():
+            return self.sash_fraction
+        try:
+            dimension = self.paned.winfo_height() if self.orientation == "vertical" else self.paned.winfo_width()
+            return self.paned.sashpos(0) / dimension if dimension else self.sash_fraction
+        except tk.TclError:
+            return self.sash_fraction
+
+    def toggle_language(self) -> None:
+        selected = self.current_selection()
+        thumbnail_size = self.thumbnails.thumbnail_size
+        image_zoom = self.image.zoom_var.get()
+        self.language_mode = "en" if self.language == "zh" else "zh"
+        self.language = self.language_mode
+        self.labels = TEXT[self.language]
+        self.settings["thumbnail_size"] = thumbnail_size
+        self.settings["image_zoom"] = image_zoom
+        for child in self.root.winfo_children():
+            child.destroy()
+        del self.thumbnails, self.image, self.paned, self.pane_host
+        self._build_window()
+        if selected:
+            self.thumbnails.select(selected)
+
+    def _icon_button(self, parent: tk.Misc, icon: str, label_key: str, command) -> ttk.Button:
+        return IconButton(parent, icon, self.labels[label_key], command)
+
+
+def main() -> None:
+    if TkinterDnD is None:
+        raise RuntimeError("tkinterdnd2 is required. Run `uv sync` before launching PicView.")
+    root = TkinterDnD.Tk()
+    PicViewApp(root)
+    root.mainloop()

picview/image_pane.py

@@ -0,0 +1,215 @@
+from __future__ import annotations
+
+import tkinter as tk
+from pathlib import Path
+import customtkinter as ctk
+
+from PIL import Image, ImageOps, ImageTk
+
+from .utils import fit_size
+from .ui import IconButton
+
+
+class ImagePane(ctk.CTkFrame):
+    """Image display with non-destructive view transforms and GIF playback."""
+
+    def __init__(self, parent: tk.Misc, labels: dict[str, str], on_toggle_maximize, zoom: float = 1.0) -> None:
+        super().__init__(parent, corner_radius=12, fg_color=("#f8fafc", "#1b2630"))
+        self.path: Path | None = None
+        self.source: Image.Image | None = None
+        self.frames: list[Image.Image] = []
+        self.frame_delays: list[int] = []
+        self.frame_index = 0
+        self.animation_id: str | None = None
+        self.rotation = 0
+        self.flip_horizontal = False
+        self.flip_vertical = False
+        self.photo: ImageTk.PhotoImage | None = None
+        self.zoom_var = tk.DoubleVar(value=zoom)
+        self.fullscreen: tk.Toplevel | None = None
+        self.fullscreen_label: ttk.Label | None = None
+        self.labels, self.on_toggle_maximize = labels, on_toggle_maximize
+
+        controls = ctk.CTkFrame(self, fg_color="transparent")
+        controls.pack(fill="x")
+        self._icon_button(controls, "rotate", labels["rotate"], self.rotate).pack(side="left")
+        self._icon_button(controls, "mirror_h", labels["flip_h"], self.mirror_horizontal).pack(side="left", padx=2)
+        self._icon_button(controls, "mirror_v", labels["flip_v"], self.mirror_vertical).pack(side="left")
+        self.max_button = self._icon_button(controls, "expand", labels["maximize"], lambda: on_toggle_maximize("image"))
+        self.max_button.pack(side="right", padx=(2, 0))
+        self._icon_button(controls, "fullscreen", labels["fullscreen"], self.open_fullscreen).pack(side="right")
+        ctk.CTkLabel(controls, text=labels["zoom"]).pack(side="right", padx=(0, 4))
+        self.zoom_scale = ctk.CTkSlider(controls, from_=0.1, to=4.0, variable=self.zoom_var, command=lambda _v: self.render(), width=160)
+        self.zoom_scale.pack(side="right", fill="x", expand=True, padx=(8, 8))
+
+        view = ctk.CTkFrame(self, fg_color="transparent")
+        view.pack(fill="both", expand=True)
+        self.canvas = tk.Canvas(view, background="#202020", highlightthickness=0)
+        self.xscroll = ctk.CTkScrollbar(view, orientation="horizontal", command=self.canvas.xview, height=12)
+        self.yscroll = ctk.CTkScrollbar(view, orientation="vertical", command=self.canvas.yview, width=12)
+        self.canvas.configure(xscrollcommand=self.xscroll.set, yscrollcommand=self.yscroll.set)
+        self.canvas.grid(row=0, column=0, sticky="nsew")
+        self.yscroll.grid(row=0, column=1, sticky="ns")
+        self.xscroll.grid(row=1, column=0, sticky="ew")
+        view.rowconfigure(0, weight=1); view.columnconfigure(0, weight=1)
+        self.image_item = self.canvas.create_image(0, 0, anchor="center")
+        self.empty_item = self.canvas.create_text(0, 0, fill="#d0d0d0", text=labels["empty"])
+        self.canvas.bind("<Configure>", lambda _event: self.render())
+        self.canvas.bind("<Enter>", self._bind_zoom_shortcuts)
+        self.canvas.bind("<Leave>", self._unbind_zoom_shortcuts)
+        self.canvas.bind("<MouseWheel>", self._wheel_scroll)
+
+    def load(self, path: Path) -> None:
+        self._stop_animation()
+        self.path = path
+        self.rotation = 0
+        self.flip_horizontal = False
+        self.flip_vertical = False
+        self.frame_index = 0
+        self.frames = []
+        self.frame_delays = []
+        try:
+            with Image.open(path) as opened:
+                frame_count = getattr(opened, "n_frames", 1)
+                for index in range(frame_count):
+                    opened.seek(index)
+                    self.frames.append(ImageOps.exif_transpose(opened).convert("RGBA").copy())
+                    self.frame_delays.append(max(20, int(opened.info.get("duration", 100))))
+            self.source = self.frames[0]
+        except (OSError, ValueError):
+            self.source = None
+        self.render()
+        if len(self.frames) > 1:
+            self._animate()
+
+    def load_empty(self) -> None:
+        self._stop_animation()
+        self.path = None
+        self.source = None
+        self.frames = []
+        self.render()
+
+    def rotate(self) -> None:
+        self.rotation = (self.rotation + 90) % 360
+        self.render()
+
+    def mirror_horizontal(self) -> None:
+        self.flip_horizontal = not self.flip_horizontal
+        self.render()
+
+    def mirror_vertical(self) -> None:
+        self.flip_vertical = not self.flip_vertical
+        self.render()
+
+    def reset_fit(self, _event: tk.Event | None = None) -> str | None:
+        self.zoom_var.set(1.0)
+        self.render()
+        return "break" if _event else None
+
+    def adjust_zoom(self, amount: float) -> None:
+        self.zoom_var.set(min(4.0, max(0.1, self.zoom_var.get() + amount)))
+        self.render()
+
+    def render(self) -> None:
+        if not self.source:
+            self.canvas.itemconfigure(self.empty_item, state="normal")
+            self.canvas.coords(self.empty_item, self.canvas.winfo_width() / 2, self.canvas.winfo_height() / 2)
+            return
+        self.canvas.itemconfigure(self.empty_item, state="hidden")
+        frame = self._transformed_frame()
+        size = fit_size(frame.size, (self.canvas.winfo_width() - 8, self.canvas.winfo_height() - 8), self.zoom_var.get())
+        image = frame.resize(size, Image.Resampling.LANCZOS)
+        self.photo = ImageTk.PhotoImage(image)
+        self.canvas.itemconfigure(self.image_item, image=self.photo)
+        width, height = size
+        viewport_w, viewport_h = self.canvas.winfo_width(), self.canvas.winfo_height()
+        scroll_w, scroll_h = max(viewport_w, width), max(viewport_h, height)
+        self.canvas.configure(scrollregion=(0, 0, scroll_w, scroll_h))
+        self.canvas.coords(self.image_item, scroll_w / 2, scroll_h / 2)
+        self._render_fullscreen(frame)
+
+    def open_fullscreen(self) -> None:
+        if self.fullscreen is not None or self.source is None:
+            return
+        window = tk.Toplevel(self)
+        window.attributes("-fullscreen", True)
+        window.configure(background="#101010")
+        window.bind("<Escape>", lambda _event: self.close_fullscreen())
+        window.protocol("WM_DELETE_WINDOW", self.close_fullscreen)
+        window.bind("<Configure>", lambda _event: self.render())
+        label = ctk.CTkLabel(window, text="", anchor="center")
+        label.pack(fill="both", expand=True)
+        ctk.CTkButton(window, text=self.labels["exit_full"], command=self.close_fullscreen, corner_radius=10).place(relx=0.5, rely=0.97, anchor="s")
+        self.fullscreen = window
+        self.fullscreen_label = label
+        self.render()
+
+    def close_fullscreen(self) -> None:
+        if self.fullscreen:
+            self.fullscreen.destroy()
+        self.fullscreen = None
+        self.fullscreen_label = None
+
+    def _render_fullscreen(self, frame: Image.Image) -> None:
+        if not self.fullscreen or not self.fullscreen_label or not self.fullscreen.winfo_exists():
+            return
+        size = fit_size(frame.size, (self.fullscreen.winfo_width() - 20, self.fullscreen.winfo_height() - 50), self.zoom_var.get())
+        photo = ImageTk.PhotoImage(frame.resize(size, Image.Resampling.LANCZOS))
+        self.fullscreen_label.configure(image=photo)
+        self.fullscreen_label.image = photo
+
+    def _transformed_frame(self) -> Image.Image:
+        frame = self.frames[self.frame_index] if self.frames else self.source
+        assert frame is not None
+        if self.rotation:
+            frame = frame.rotate(-self.rotation, expand=True)
+        if self.flip_horizontal:
+            frame = ImageOps.mirror(frame)
+        if self.flip_vertical:
+            frame = ImageOps.flip(frame)
+        return frame
+
+    def _animate(self) -> None:
+        if not self.winfo_exists() or len(self.frames) < 2:
+            return
+        self.frame_index = (self.frame_index + 1) % len(self.frames)
+        self.render()
+        self.animation_id = self.after(self.frame_delays[self.frame_index], self._animate)
+
+    def _stop_animation(self) -> None:
+        if self.animation_id:
+            self.after_cancel(self.animation_id)
+        self.animation_id = None
+
+    def _bind_zoom_shortcuts(self, _event: tk.Event) -> None:
+        self.canvas.bind_all("<Control-MouseWheel>", self._wheel_zoom)
+        self.canvas.bind_all("<plus>", lambda _e: self._key_zoom(0.1))
+        self.canvas.bind_all("<minus>", lambda _e: self._key_zoom(-0.1))
+        self.canvas.bind_all("<Key-0>", self.reset_fit)
+
+    def _unbind_zoom_shortcuts(self, _event: tk.Event) -> None:
+        self.canvas.unbind_all("<Control-MouseWheel>")
+        self.canvas.unbind_all("<plus>")
+        self.canvas.unbind_all("<minus>")
+        self.canvas.unbind_all("<Key-0>")
+
+    def _wheel_zoom(self, event: tk.Event) -> str:
+        self.adjust_zoom(0.1 if event.delta > 0 else -0.1)
+        return "break"
+
+    def _wheel_scroll(self, event: tk.Event) -> str:
+        """Plain wheel pans an enlarged image; Ctrl+wheel remains zoom."""
+        if event.state & 0x0004:
+            return self._wheel_zoom(event)
+        self.canvas.yview_scroll(-int(event.delta / 120), "units")
+        return "break"
+
+    def _key_zoom(self, amount: float) -> str:
+        self.adjust_zoom(amount)
+        return "break"
+
+    def _icon_button(self, parent: tk.Misc, icon: str, tooltip: str, command) -> IconButton:
+        return IconButton(parent, icon, tooltip, command)
+
+    def set_maximized(self, maximized: bool) -> None:
+        self.max_button.set_icon("shrink" if maximized else "expand", self.labels["restore"] if maximized else self.labels["maximize"])