app.py

"""Perfect Pixel Studio — native Windows desktop interface."""

from __future__ import annotations

import ctypes
from pathlib import Path
import os
import queue
import sys
import threading
import tkinter as tk
from tkinter import colorchooser, filedialog, messagebox, ttk

try:
    import winreg
except ImportError:  # pragma: no cover - only used outside Windows
    winreg = None

import numpy as np
from PIL import Image, ImageGrab, ImageOps, ImageTk
from tkinterdnd2 import COPY, DND_FILES, REFUSE_DROP, TkinterDnD

from perfect_pixel_core import (
    ProcessResult,
    ProcessSettings,
    array_to_png_bytes,
    create_result_zip,
    process_image,
    suggested_names,
)


APP_NAME = "Perfect Pixel"
APP_VERSION = "2.2"
UI_FONT = "Microsoft YaHei UI"
SUPPORTED_IMAGE_SUFFIXES = {
    ".png",
    ".jpg",
    ".jpeg",
    ".webp",
    ".gif",
    ".bmp",
    ".tif",
    ".tiff",
}

DARK_COLORS = {
    "bg": "#0B1014",
    "sidebar": "#0F161B",
    "surface": "#121B21",
    "surface_hover": "#18242B",
    "surface_active": "#203139",
    "preview": "#0A0E11",
    "line": "#26343C",
    "line_soft": "#1C282F",
    "text": "#F2F7F7",
    "text_soft": "#C8D2D6",
    "muted": "#87969E",
    "accent": "#42D7C2",
    "accent_hover": "#64E5D2",
    "accent_dark": "#082B28",
    "error": "#FF8A80",
    "checker_a": "#10171B",
    "checker_b": "#182126",
}

LIGHT_COLORS = {
    "bg": "#F5F7F6",
    "sidebar": "#EEF2F1",
    "surface": "#FFFFFF",
    "surface_hover": "#E5ECEA",
    "surface_active": "#D8F1EC",
    "preview": "#E7ECEA",
    "line": "#C3CECA",
    "line_soft": "#DCE4E1",
    "text": "#13201D",
    "text_soft": "#344943",
    "muted": "#6C7C76",
    "accent": "#087F70",
    "accent_hover": "#0A9684",
    "accent_dark": "#D6F0EB",
    "error": "#B42318",
    "checker_a": "#EBEFED",
    "checker_b": "#DDE4E1",
}

COLORS = dict(DARK_COLORS)


def resource_path(relative: str) -> Path:
    base = Path(getattr(sys, "_MEIPASS", Path(__file__).resolve().parent))
    return base / relative


def enable_high_dpi() -> None:
    if sys.platform != "win32":
        return
    try:
        ctypes.windll.shcore.SetProcessDpiAwareness(1)
    except Exception:
        try:
            ctypes.windll.user32.SetProcessDPIAware()
        except Exception:
            pass
    try:
        ctypes.windll.shell32.SetCurrentProcessExplicitAppUserModelID(
            "PerfectPixel.Studio.2"
        )
    except Exception:
        pass


def windows_theme() -> str:
    """Return the Windows application theme as ``light`` or ``dark``."""
    if sys.platform != "win32" or winreg is None:
        return "dark"
    try:
        path = r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize"
        with winreg.OpenKey(winreg.HKEY_CURRENT_USER, path) as key:
            value, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
        return "light" if int(value) else "dark"
    except OSError:
        return "dark"


class HoverButton(tk.Label):
    """A compact flat button with predictable hover/disabled states."""

    def __init__(
        self,
        master,
        text: str,
        command=None,
        *,
        primary: bool = False,
        small: bool = False,
        width: int | None = None,
        anchor: str = "center",
    ):
        self.command = command
        self.primary = primary
        self.enabled = True
        self.selected = False
        self.normal_bg = COLORS["accent"] if primary else COLORS["surface"]
        self.hover_bg = COLORS["accent_hover"] if primary else COLORS["surface_hover"]
        self.active_bg = COLORS["accent_dark"] if not primary else COLORS["accent_hover"]
        self.normal_fg = COLORS["bg"] if primary else COLORS["text_soft"]
        kwargs = {
            "text": text,
            "bg": self.normal_bg,
            "fg": self.normal_fg,
            "activebackground": self.hover_bg,
            "activeforeground": self.normal_fg,
            "font": (UI_FONT, 9 if small else 10, "bold"),
            "cursor": "hand2",
            "padx": 12 if small else 18,
            "pady": 7 if small else 11,
            "anchor": anchor,
            "takefocus": True,
            "highlightthickness": 1,
            "highlightbackground": COLORS["line"],
            "highlightcolor": COLORS["accent"],
        }
        if width is not None:
            kwargs["width"] = width
        super().__init__(master, **kwargs)
        self.bind("<Enter>", self._enter)
        self.bind("<Leave>", self._leave)
        self.bind("<Button-1>", self._click)
        self.bind("<Return>", self._click)
        self.bind("<space>", self._click)

    def _enter(self, _event=None):
        if self.enabled:
            self.configure(bg=self.hover_bg)

    def _leave(self, _event=None):
        if self.enabled:
            self.configure(bg=self.active_bg if self.selected else self.normal_bg)

    def _click(self, _event=None):
        if self.enabled and self.command:
            self.command()

    def set_enabled(self, enabled: bool):
        self.enabled = enabled
        self.configure(
            cursor="hand2" if enabled else "arrow",
            bg=(self.active_bg if self.selected else self.normal_bg)
            if enabled
            else COLORS["surface"],
            fg=self.normal_fg if enabled else COLORS["muted"],
        )

    def set_selected(self, selected: bool):
        self.selected = selected
        if self.enabled:
            self.configure(
                bg=self.active_bg if selected else self.normal_bg,
                fg=COLORS["accent"] if selected and not self.primary else self.normal_fg,
                highlightbackground=COLORS["accent"] if selected else COLORS["line"],
            )


class ScrollFrame(tk.Frame):
    def __init__(self, master, **kwargs):
        super().__init__(master, **kwargs)
        self.canvas = tk.Canvas(
            self,
            bg=self["bg"],
            highlightthickness=0,
            borderwidth=0,
        )
        self.scrollbar = ttk.Scrollbar(
            self, orient="vertical", command=self.canvas.yview
        )
        self.content = tk.Frame(self.canvas, bg=self["bg"])
        self.window_id = self.canvas.create_window(
            (0, 0), window=self.content, anchor="nw"
        )
        self.canvas.configure(yscrollcommand=self.scrollbar.set)
        self.canvas.pack(side="left", fill="both", expand=True)
        self.scrollbar.pack(side="right", fill="y")
        self.content.bind("<Configure>", self._content_resized)
        self.canvas.bind("<Configure>", self._canvas_resized)
        self.canvas.bind("<Enter>", lambda _e: self._bind_wheel(True))
        self.canvas.bind("<Leave>", lambda _e: self._bind_wheel(False))

    def _content_resized(self, _event=None):
        self.canvas.configure(scrollregion=self.canvas.bbox("all"))

    def _canvas_resized(self, event):
        self.canvas.itemconfigure(self.window_id, width=event.width)

    def _bind_wheel(self, bind: bool):
        if bind:
            self.canvas.bind_all("<MouseWheel>", self._wheel)
        else:
            self.canvas.unbind_all("<MouseWheel>")

    def _wheel(self, event):
        self.canvas.yview_scroll(int(-event.delta / 120), "units")


class LabeledScale(tk.Frame):
    def __init__(
        self,
        master,
        label: str,
        variable,
        minimum: float,
        maximum: float,
        *,
        resolution: float = 1,
        suffix: str = "",
        formatter=None,
    ):
        super().__init__(master, bg=master["bg"])
        self.variable = variable
        self.suffix = suffix
        self.formatter = formatter
        top = tk.Frame(self, bg=self["bg"])
        top.pack(fill="x")
        tk.Label(
            top,
            text=label,
            bg=self["bg"],
            fg=COLORS["text_soft"],
            font=(UI_FONT, 9),
        ).pack(side="left")
        self.value_label = tk.Label(
            top,
            bg=self["bg"],
            fg=COLORS["accent"],
            font=(UI_FONT, 9, "bold"),
        )
        self.value_label.pack(side="right")
        self.scale = tk.Scale(
            self,
            from_=minimum,
            to=maximum,
            resolution=resolution,
            orient="horizontal",
            variable=variable,
            showvalue=False,
            bg=self["bg"],
            fg=COLORS["text"],
            troughcolor=COLORS["line"],
            activebackground=COLORS["accent_hover"],
            highlightthickness=0,
            borderwidth=0,
            sliderlength=16,
            sliderrelief="flat",
            length=260,
            command=lambda _value: self._update_value(),
        )
        self.scale.pack(fill="x", pady=(2, 0))
        self._update_value()

    def _update_value(self):
        value = self.variable.get()
        text = self.formatter(value) if self.formatter else f"{value:g}"
        self.value_label.configure(text=f"{text}{self.suffix}")


class CollapsibleSection(tk.Frame):
    def __init__(self, master, title: str, *, open_by_default: bool = False):
        super().__init__(master, bg=master["bg"])
        self.open = open_by_default
        self.header = tk.Frame(self, bg=self["bg"], cursor="hand2")
        self.header.pack(fill="x", pady=(6, 0))
        self.chevron = tk.Label(
            self.header,
            text="−" if self.open else "+",
            bg=self["bg"],
            fg=COLORS["accent"],
            font=(UI_FONT, 12, "bold"),
            width=2,
        )
        self.chevron.pack(side="right")
        self.title = tk.Label(
            self.header,
            text=title,
            bg=self["bg"],
            fg=COLORS["text"],
            font=(UI_FONT, 10, "bold"),
        )
        self.title.pack(side="left")
        self.body = tk.Frame(self, bg=self["bg"])
        if self.open:
            self.body.pack(fill="x", pady=(10, 4))
        for widget in (self.header, self.title, self.chevron):
            widget.bind("<Button-1>", self.toggle)
        tk.Frame(self, bg=COLORS["line_soft"], height=1).pack(
            fill="x", pady=(10, 0)
        )

    def toggle(self, _event=None):
        self.open = not self.open
        self.chevron.configure(text="−" if self.open else "+")
        if self.open:
            self.body.pack(fill="x", pady=(10, 4), before=self.winfo_children()[-1])
        else:
            self.body.pack_forget()


class PerfectPixelApp:
    PRESETS = {
        "智能优化": {
            "sample_method": "中心取样",
            "max_colors": 0,
            "posterize_enabled": False,
            "morph_cleanup": False,
            "background_enabled": False,
            "alpha_binarize": False,
        },
        "保留原色": {
            "sample_method": "中位数",
            "max_colors": 0,
            "posterize_enabled": False,
            "morph_cleanup": False,
            "background_enabled": False,
            "alpha_binarize": False,
        },
        "复古限色": {
            "sample_method": "多数色",
            "max_colors": 16,
            "posterize_enabled": True,
            "posterize_bits": 5,
            "morph_cleanup": True,
            "background_enabled": False,
            "alpha_binarize": False,
        },
        "透明背景": {
            "sample_method": "中心取样",
            "max_colors": 0,
            "posterize_enabled": False,
            "morph_cleanup": False,
            "background_enabled": True,
            "background_transparent": True,
            "alpha_binarize": True,
        },
    }

    def __init__(self, root: tk.Tk):
        self.root = root
        self.theme_mode = "跟随系统"
        self.effective_theme = windows_theme()
        COLORS.clear()
        COLORS.update(
            LIGHT_COLORS if self.effective_theme == "light" else DARK_COLORS
        )
        self.source_array: np.ndarray | None = None
        self.source_path: Path | None = None
        self.source_name = "pixel_art.png"
        self.result: ProcessResult | None = None
        self.current_view = "source"
        self.last_export_folder: Path | None = None
        self.preview_photo = None
        self.preview_resize_job = None
        self.busy = False
        self.current_preset = "智能优化"
        self.status_text = "准备就绪"
        self.status_kind = "normal"
        self.events: queue.Queue = queue.Queue()
        self.vars: dict[str, tk.Variable] = {}
        self.view_buttons: dict[str, HoverButton] = {}
        self.export_buttons: list[HoverButton] = []

        self._setup_window()
        self._setup_styles()
        self._create_variables()
        self._build_layout()
        self._bind_shortcuts()
        self.root.after(60, self._poll_events)
        self.root.after(80, self._fade_in)
        self.root.after(120, self._apply_titlebar_theme)
        self.root.after(2000, self._check_system_theme)

    def _setup_window(self):
        self.root.title(f"{APP_NAME} — 像素画精修工作台")
        self.root.configure(bg=COLORS["bg"])
        self.root.minsize(1100, 700)
        screen_width = self.root.winfo_screenwidth()
        screen_height = self.root.winfo_screenheight()
        width = min(1320, max(1100, screen_width - 80))
        height = min(840, max(700, screen_height - 100))
        x = max(0, (screen_width - width) // 2)
        y = max(0, (screen_height - height) // 2)
        self.root.geometry(f"{width}x{height}+{x}+{y}")
        self.root.option_add("*tearOff", False)
        self.root.attributes("-alpha", 0.0)
        icon = resource_path("assets/perfect_pixel.ico")
        if icon.exists():
            try:
                self.root.iconbitmap(default=str(icon))
            except tk.TclError:
                pass

    def _setup_styles(self):
        style = ttk.Style(self.root)
        try:
            style.theme_use("clam")
        except tk.TclError:
            pass
        style.configure(
            "TScrollbar",
            background=COLORS["line"],
            troughcolor=COLORS["sidebar"],
            bordercolor=COLORS["sidebar"],
            arrowcolor=COLORS["muted"],
            width=9,
        )
        style.configure(
            "TCombobox",
            fieldbackground=COLORS["surface"],
            background=COLORS["surface"],
            foreground=COLORS["text"],
            arrowcolor=COLORS["accent"],
            bordercolor=COLORS["line"],
            lightcolor=COLORS["line"],
            darkcolor=COLORS["line"],
            padding=8,
        )
        style.map(
            "TCombobox",
            fieldbackground=[("readonly", COLORS["surface"])],
            foreground=[("readonly", COLORS["text"])],
            selectbackground=[("readonly", COLORS["surface"])],
            selectforeground=[("readonly", COLORS["text"])],
        )
        style.configure(
            "Accent.Horizontal.TProgressbar",
            troughcolor=COLORS["line_soft"],
            background=COLORS["accent"],
            bordercolor=COLORS["line_soft"],
            lightcolor=COLORS["accent"],
            darkcolor=COLORS["accent"],
            thickness=3,
        )

    def _create_variables(self):
        defaults = {
            "sample_method": (tk.StringVar, "中心取样"),
            "processing_order": (tk.StringVar, "先对齐，再量化"),
            "scale_factor": (tk.IntVar, 8),
            "max_colors": (tk.IntVar, 0),
            "color_space": (tk.StringVar, "OKLab"),
            "posterize_enabled": (tk.BooleanVar, False),
            "posterize_bits": (tk.IntVar, 5),
            "grid_width": (tk.StringVar, "0"),
            "grid_height": (tk.StringVar, "0"),
            "min_pixel_size": (tk.DoubleVar, 4.0),
            "peak_width": (tk.IntVar, 6),
            "refine_intensity": (tk.DoubleVar, 0.25),
            "fix_square": (tk.BooleanVar, True),
            "dominant_enabled": (tk.BooleanVar, False),
            "dominant_threshold": (tk.DoubleVar, 0.5),
            "morph_cleanup": (tk.BooleanVar, False),
            "antialias_cleanup": (tk.BooleanVar, False),
            "antialias_threshold": (tk.IntVar, 30),
            "background_enabled": (tk.BooleanVar, False),
            "background_color": (tk.StringVar, "#ffffff"),
            "background_tolerance": (tk.IntVar, 30),
            "background_transparent": (tk.BooleanVar, True),
            "alpha_binarize": (tk.BooleanVar, False),
            "alpha_threshold": (tk.IntVar, 128),
        }
        self.vars = {name: kind(value=value) for name, (kind, value) in defaults.items()}

    def _build_layout(self):
        self._build_header()
        body = tk.Frame(self.root, bg=COLORS["bg"])
        body.pack(fill="both", expand=True)
        self.sidebar = ScrollFrame(body, bg=COLORS["sidebar"], width=350)
        self.sidebar.pack(side="left", fill="y")
        self.sidebar.pack_propagate(False)
        tk.Frame(body, bg=COLORS["line_soft"], width=1).pack(side="left", fill="y")
        self.main = tk.Frame(body, bg=COLORS["bg"])
        self.main.pack(side="left", fill="both", expand=True)
        self._build_sidebar()
        self._build_workspace()
        self._register_file_drop()

    def _build_header(self):
        header = tk.Frame(self.root, bg=COLORS["bg"], height=72)
        header.pack(fill="x")
        header.pack_propagate(False)
        brand = tk.Frame(header, bg=COLORS["bg"])
        brand.pack(side="left", padx=(24, 0), pady=13)
        mark = tk.Canvas(
            brand, width=38, height=38, bg=COLORS["bg"], highlightthickness=0
        )
        mark.pack(side="left", padx=(0, 12))
        mark.create_rectangle(2, 2, 17, 17, fill=COLORS["accent"], outline="")
        mark.create_rectangle(21, 2, 36, 17, fill=COLORS["line"], outline="")
        mark.create_rectangle(2, 21, 17, 36, fill=COLORS["line"], outline="")
        mark.create_rectangle(21, 21, 36, 36, fill=COLORS["accent"], outline="")
        names = tk.Frame(brand, bg=COLORS["bg"])
        names.pack(side="left")
        tk.Label(
            names,
            text="PERFECT PIXEL",
            bg=COLORS["bg"],
            fg=COLORS["text"],
            font=(UI_FONT, 14, "bold"),
        ).pack(anchor="w")
        self.header_status = tk.Label(
            header,
            text=self.status_text,
            bg=COLORS["accent_dark"],
            fg=COLORS["accent"],
            font=(UI_FONT, 9, "bold"),
            padx=12,
            pady=6,
        )
        self.header_status.pack(side="right", padx=24)
        self.theme_button = tk.Menubutton(
            header,
            text=f"主题  {self.theme_mode}  ▾",
            bg=COLORS["surface"],
            fg=COLORS["text_soft"],
            activebackground=COLORS["surface_hover"],
            activeforeground=COLORS["text"],
            relief="flat",
            borderwidth=0,
            highlightthickness=1,
            highlightbackground=COLORS["line"],
            cursor="hand2",
            font=(UI_FONT, 9, "bold"),
            padx=12,
            pady=6,
        )
        theme_menu = tk.Menu(
            self.theme_button,
            tearoff=False,
            bg=COLORS["surface"],
            fg=COLORS["text"],
            activebackground=COLORS["accent_dark"],
            activeforeground=COLORS["text"],
            borderwidth=1,
            relief="flat",
            font=(UI_FONT, 9),
        )
        for mode in ("跟随系统", "浅色", "深色"):
            theme_menu.add_command(
                label=("✓  " if self.theme_mode == mode else "    ") + mode,
                command=lambda selected=mode: self.set_theme_mode(selected),
            )
        self.theme_button.configure(menu=theme_menu)
        self.theme_button.pack(side="right")
        tk.Frame(self.root, bg=COLORS["line_soft"], height=1).pack(fill="x")

    def _build_sidebar(self):
        content = self.sidebar.content
        inner = tk.Frame(content, bg=COLORS["sidebar"])
        inner.pack(fill="both", expand=True, padx=20, pady=20)

        self.drop_frame = tk.Frame(
            inner,
            bg=COLORS["surface"],
            highlightthickness=1,
            highlightbackground=COLORS["line"],
            cursor="hand2",
        )
        self.drop_frame.pack(fill="x")
        self.drop_frame.bind("<Button-1>", lambda _e: self.open_image())
        drop_content = tk.Frame(self.drop_frame, bg=COLORS["surface"])
        drop_content.pack(fill="x", padx=16, pady=16)
        drop_content.bind("<Button-1>", lambda _e: self.open_image())
        tk.Label(
            drop_content,
            text="导入图片",
            bg=COLORS["surface"],
            fg=COLORS["text"],
            font=(UI_FONT, 11, "bold"),
        ).pack(anchor="w")
        self.source_label = tk.Label(
            drop_content,
            text="拖入图片到窗口任意位置\n也可以点击选择或按 Ctrl + V",
            bg=COLORS["surface"],
            fg=COLORS["muted"],
            justify="left",
            font=(UI_FONT, 9),
            pady=7,
            wraplength=260,
        )
        self.source_label.pack(anchor="w")
        self.source_label.bind("<Button-1>", lambda _e: self.open_image())
        actions = tk.Frame(drop_content, bg=COLORS["surface"])
        actions.pack(fill="x", pady=(4, 0))
        HoverButton(actions, "选择图片", self.open_image, small=True).pack(side="left")
        HoverButton(actions, "粘贴", self.paste_image, small=True).pack(
            side="left", padx=(8, 0)
        )

        self._section_heading(inner, "快速预设", top=20)
        presets = tk.Frame(inner, bg=COLORS["sidebar"])
        presets.pack(fill="x")
        self.preset_buttons = {}
        for index, name in enumerate(self.PRESETS):
            button = HoverButton(
                presets,
                name,
                command=lambda selected=name: self.apply_preset(selected),
                small=True,
            )
            button.grid(
                row=index // 2,
                column=index % 2,
                sticky="ew",
                padx=(0, 5) if index % 2 == 0 else (5, 0),
                pady=(0, 8),
            )
            presets.grid_columnconfigure(index % 2, weight=1)
            self.preset_buttons[name] = button
        if self.current_preset in self.preset_buttons:
            self.preset_buttons[self.current_preset].set_selected(True)

        self._section_heading(inner, "核心设置", top=12)
        self._dropdown(
            inner,
            "采样方式",
            self.vars["sample_method"],
            ("中心取样", "中位数", "多数色"),
        )
        self._dropdown(
            inner,
            "处理顺序",
            self.vars["processing_order"],
            ("先对齐，再量化", "先量化，再对齐"),
        )
        LabeledScale(
            inner,
            "输出放大倍数",
            self.vars["scale_factor"],
            1,
            32,
            suffix="x",
        ).pack(fill="x", pady=(10, 0))
        self.process_button = HoverButton(
            inner, "开始精修", self.start_processing, primary=True
        )
        self.process_button.pack(fill="x", pady=(18, 8))
        tk.Label(
            inner,
            text="快捷键  Ctrl + Enter",
            bg=COLORS["sidebar"],
            fg=COLORS["muted"],
            font=(UI_FONT, 8),
        ).pack()

        color_section = CollapsibleSection(inner, "颜色处理", open_by_default=True)
        color_section.pack(fill="x", pady=(12, 0))
        LabeledScale(
            color_section.body,
            "保留颜色数量",
            self.vars["max_colors"],
            0,
            256,
            formatter=lambda value: "不限" if int(value) == 0 else str(int(value)),
        ).pack(fill="x")
        self._dropdown(
            color_section.body,
            "量化色彩空间",
            self.vars["color_space"],
            ("OKLab", "RGB"),
        )
        self._check(
            color_section.body, "启用色阶降低", self.vars["posterize_enabled"]
        )
        LabeledScale(
            color_section.body,
            "每通道位数",
            self.vars["posterize_bits"],
            1,
            7,
            suffix=" bit",
        ).pack(fill="x", pady=(8, 0))

        grid_section = CollapsibleSection(inner, "网格检测")
        grid_section.pack(fill="x")
        self._grid_entries(grid_section.body)
        LabeledScale(
            grid_section.body,
            "最小像素尺寸",
            self.vars["min_pixel_size"],
            1,
            20,
            resolution=0.5,
            suffix=" px",
        ).pack(fill="x", pady=(8, 0))
        LabeledScale(
            grid_section.body,
            "检测峰宽",
            self.vars["peak_width"],
            1,
            20,
        ).pack(fill="x", pady=(8, 0))
        LabeledScale(
            grid_section.body,
            "网格修正强度",
            self.vars["refine_intensity"],
            0,
            1,
            resolution=0.05,
            formatter=lambda value: f"{float(value):.2f}",
        ).pack(fill="x", pady=(8, 0))
        self._check(
            grid_section.body,
            "自动检测时修正近似正方形",
            self.vars["fix_square"],
        )
        self._check(grid_section.body, "使用主导色阈值采样", self.vars["dominant_enabled"])
        LabeledScale(
            grid_section.body,
            "主导色阈值",
            self.vars["dominant_threshold"],
            0.1,
            1,
            resolution=0.05,
            formatter=lambda value: f"{float(value):.2f}",
        ).pack(fill="x", pady=(8, 0))

        cleanup_section = CollapsibleSection(inner, "边缘清理")
        cleanup_section.pack(fill="x")
        self._check(cleanup_section.body, "清理孤立杂色像素", self.vars["morph_cleanup"])
        self._check(cleanup_section.body, "清理抗锯齿残留", self.vars["antialias_cleanup"])
        LabeledScale(
            cleanup_section.body,
            "抗锯齿阈值",
            self.vars["antialias_threshold"],
            5,
            100,
        ).pack(fill="x", pady=(8, 0))

        background_section = CollapsibleSection(inner, "透明背景")
        background_section.pack(fill="x")
        self._check(
            background_section.body,
            "处理指定背景色",
            self.vars["background_enabled"],
        )
        self._color_input(background_section.body)
        LabeledScale(
            background_section.body,
            "背景色容差",
            self.vars["background_tolerance"],
            0,
            128,
        ).pack(fill="x", pady=(8, 0))
        self._check(
            background_section.body,
            "替换为透明",
            self.vars["background_transparent"],
        )
        self._check(
            background_section.body,
            "透明度二值化",
            self.vars["alpha_binarize"],
        )
        LabeledScale(
            background_section.body,
            "透明度阈值",
            self.vars["alpha_threshold"],
            0,
            255,
        ).pack(fill="x", pady=(8, 0))

        tk.Label(
            inner,
            text=f"Perfect Pixel Studio  v{APP_VERSION}",
            bg=COLORS["sidebar"],
            fg=COLORS["muted"],
            font=(UI_FONT, 8),
        ).pack(anchor="w", pady=(22, 8))

    def _build_workspace(self):
        self.view_buttons = {}
        self.export_buttons = []
        toolbar = tk.Frame(self.main, bg=COLORS["bg"], height=64)
        toolbar.pack(fill="x", padx=24)
        toolbar.pack_propagate(False)
        tabs = tk.Frame(toolbar, bg=COLORS["bg"])
        tabs.pack(side="left", pady=12)
        for key, text in (
            ("source", "原图"),
            ("scaled", "放大预览"),
            ("original", "原始像素"),
        ):
            button = HoverButton(
                tabs,
                text,
                command=lambda view=key: self.set_view(view),
                small=True,
                width=9,
            )
            button.pack(side="left", padx=(0, 8))
            self.view_buttons[key] = button
        self.view_buttons["source"].set_selected(True)
        self.file_meta = tk.Label(
            toolbar,
            text="尚未导入图片",
            bg=COLORS["bg"],
            fg=COLORS["muted"],
            font=(UI_FONT, 9),
        )
        self.file_meta.pack(side="right")

        self.preview_canvas = tk.Canvas(
            self.main,
            bg=COLORS["preview"],
            highlightthickness=1,
            highlightbackground=COLORS["line_soft"],
        )
        self.preview_canvas.pack(fill="both", expand=True, padx=24)
        self.preview_canvas.bind("<Configure>", self._schedule_preview)
        self.preview_canvas.bind("<Double-Button-1>", lambda _e: self.open_image())
        self._draw_empty_preview()

        result_panel = tk.Frame(self.main, bg=COLORS["bg"], height=174)
        result_panel.pack(fill="x", padx=24, pady=(0, 18))
        result_panel.pack_propagate(False)
        self.progress = ttk.Progressbar(
            result_panel,
            mode="determinate",
            maximum=100,
            style="Accent.Horizontal.TProgressbar",
        )
        self.progress.pack(fill="x")
        info_row = tk.Frame(result_panel, bg=COLORS["bg"])
        info_row.pack(fill="x", pady=(14, 12))
        self.metric_values = {}
        for index, (key, label) in enumerate(
            (
                ("grid", "像素网格"),
                ("size", "放大尺寸"),
                ("colors", "实际颜色"),
                ("format", "输出格式"),
            )
        ):
            metric = tk.Frame(info_row, bg=COLORS["bg"])
            metric.pack(side="left", fill="x", expand=True)
            if index:
                tk.Frame(metric, bg=COLORS["line_soft"], width=1).pack(
                    side="left", fill="y", padx=(0, 18)
                )
            tk.Label(
                metric,
                text=label,
                bg=COLORS["bg"],
                fg=COLORS["muted"],
                font=(UI_FONT, 8),
            ).pack(anchor="w")
            value = tk.Label(
                metric,
                text="—",
                bg=COLORS["bg"],
                fg=COLORS["text"],
                font=(UI_FONT, 11, "bold"),
            )
            value.pack(anchor="w", pady=(3, 0))
            self.metric_values[key] = value

        export_row = tk.Frame(result_panel, bg=COLORS["bg"])
        export_row.pack(fill="x")
        for text, command, primary in (
            ("保存原尺寸 PNG", lambda: self.save_image("original"), False),
            ("保存放大 PNG", lambda: self.save_image("scaled"), False),
            ("导出全部 ZIP", self.save_zip, True),
        ):
            button = HoverButton(export_row, text, command, primary=primary)
            button.pack(side="left", padx=(0, 10))
            button.set_enabled(False)
            self.export_buttons.append(button)
        self.open_folder_button = HoverButton(
            export_row, "打开导出目录", self.open_export_folder
        )
        self.open_folder_button.pack(side="right")
        self.open_folder_button.set_enabled(False)

    def _section_heading(self, master, text: str, *, top: int = 0):
        tk.Label(
            master,
            text=text.upper(),
            bg=master["bg"],
            fg=COLORS["muted"],
            font=(UI_FONT, 8, "bold"),
        ).pack(anchor="w", pady=(top, 9))

    def _dropdown(self, master, label: str, variable, values):
        frame = tk.Frame(master, bg=master["bg"])
        frame.pack(fill="x", pady=(0, 10))
        tk.Label(
            frame,
            text=label,
            bg=master["bg"],
            fg=COLORS["text_soft"],
            font=(UI_FONT, 9),
        ).pack(anchor="w", pady=(0, 5))
        ttk.Combobox(
            frame,
            textvariable=variable,
            values=values,
            state="readonly",
            font=(UI_FONT, 9),
        ).pack(fill="x")

    def _check(self, master, text: str, variable):
        check = tk.Checkbutton(
            master,
            text=text,
            variable=variable,
            bg=master["bg"],
            fg=COLORS["text_soft"],
            activebackground=master["bg"],
            activeforeground=COLORS["text"],
            selectcolor=COLORS["surface_active"],
            font=(UI_FONT, 9),
            cursor="hand2",
            anchor="w",
            padx=0,
            pady=4,
            highlightthickness=0,
        )
        check.pack(fill="x", pady=(2, 0))
        return check

    def _grid_entries(self, master):
        row = tk.Frame(master, bg=master["bg"])
        row.pack(fill="x")
        for index, (label, key) in enumerate(
            (("手动网格宽", "grid_width"), ("手动网格高", "grid_height"))
        ):
            field = tk.Frame(row, bg=master["bg"])
            field.pack(
                side="left",
                fill="x",
                expand=True,
                padx=(0, 5) if index == 0 else (5, 0),
            )
            tk.Label(
                field,
                text=label,
                bg=master["bg"],
                fg=COLORS["text_soft"],
                font=(UI_FONT, 8),
            ).pack(anchor="w", pady=(0, 5))
            tk.Entry(
                field,
                textvariable=self.vars[key],
                bg=COLORS["surface"],
                fg=COLORS["text"],
                insertbackground=COLORS["accent"],
                relief="flat",
                highlightthickness=1,
                highlightbackground=COLORS["line"],
                highlightcolor=COLORS["accent"],
                font=(UI_FONT, 9),
            ).pack(fill="x", ipady=7)
        tk.Label(
            master,
            text="填写后严格输出该宽高；均为 0 时自动检测",
            bg=master["bg"],
            fg=COLORS["muted"],
            font=(UI_FONT, 8),
        ).pack(anchor="w", pady=(5, 0))

    def _color_input(self, master):
        row = tk.Frame(master, bg=master["bg"])
        row.pack(fill="x", pady=(8, 0))
        tk.Entry(
            row,
            textvariable=self.vars["background_color"],
            bg=COLORS["surface"],
            fg=COLORS["text"],
            insertbackground=COLORS["accent"],
            relief="flat",
            highlightthickness=1,
            highlightbackground=COLORS["line"],
            highlightcolor=COLORS["accent"],
            font=("Consolas", 9),
        ).pack(side="left", fill="x", expand=True, ipady=7)
        HoverButton(row, "选色", self.choose_background_color, small=True).pack(
            side="left", padx=(8, 0)
        )

    def _bind_shortcuts(self):
        self.root.bind("<Control-o>", lambda _e: self.open_image())
        self.root.bind("<Control-v>", lambda _e: self.paste_image())
        self.root.bind("<Control-Return>", lambda _e: self.start_processing())
        self.root.bind("<Control-s>", lambda _e: self.save_image("scaled"))
        self.root.bind("<Escape>", lambda _e: self.root.focus_set())

    def _register_file_drop(self):
        """Make the complete window a native file-drop target."""
        self.root.drop_target_register(DND_FILES)
        self.root.dnd_bind("<<DropEnter>>", self._drop_enter)
        self.root.dnd_bind("<<DropPosition>>", self._drop_position)
        self.root.dnd_bind("<<DropLeave>>", self._drop_leave)
        self.root.dnd_bind("<<Drop>>", self._drop_files)

    def _drop_enter(self, _event=None):
        if self.busy:
            return REFUSE_DROP
        self.drop_frame.configure(
            bg=COLORS["surface_active"],
            highlightbackground=COLORS["accent"],
            highlightthickness=2,
        )
        self.source_label.configure(text="松开鼠标即可导入", fg=COLORS["accent"])
        self._set_status("已识别拖入操作，松开即可导入图片")
        return COPY

    def _drop_position(self, _event=None):
        return REFUSE_DROP if self.busy else COPY

    def _drop_leave(self, _event=None):
        self._restore_drop_area()
        return COPY

    def _restore_drop_area(self):
        self.drop_frame.configure(
            bg=COLORS["surface"],
            highlightbackground=COLORS["line"],
            highlightthickness=1,
        )
        self.source_label.configure(fg=COLORS["muted"])
        if self.source_array is None:
            self.source_label.configure(
                text="拖入图片到窗口任意位置\n也可以点击选择或按 Ctrl + V"
            )
        else:
            height, width = self.source_array.shape[:2]
            mode = "RGBA" if self.source_array.shape[2] == 4 else "RGB"
            self.source_label.configure(
                text=f"{self.source_name}\n{width} × {height}  ·  {mode}"
            )

    def _drop_files(self, event):
        self._restore_drop_area()
        if self.busy:
            self._set_status("正在处理当前图片，请稍后再拖入", error=True)
            return REFUSE_DROP
        try:
            raw_paths = self.root.tk.splitlist(event.data)
        except (tk.TclError, TypeError):
            raw_paths = ()
        paths = [Path(value) for value in raw_paths]
        supported = [
            path
            for path in paths
            if path.is_file() and path.suffix.lower() in SUPPORTED_IMAGE_SUFFIXES
        ]
        if not supported:
            self._set_status("拖入的文件不是受支持的图片", error=True)
            messagebox.showwarning(
                "无法导入",
                "请拖入 PNG、JPG、WEBP、GIF、BMP 或 TIFF 图片文件。",
                parent=self.root,
            )
            return REFUSE_DROP
        loaded = self._load_image(supported[0])
        if not loaded:
            return REFUSE_DROP
        if len(supported) > 1:
            self._set_status(
                f"已导入 {supported[0].name}；一次只处理一张图片"
            )
        else:
            self._set_status(f"已拖入：{supported[0].name}")
        return COPY

    def set_theme_mode(self, mode: str):
        if mode not in ("跟随系统", "浅色", "深色"):
            return
        self.theme_mode = mode
        effective = (
            windows_theme()
            if mode == "跟随系统"
            else ("light" if mode == "浅色" else "dark")
        )
        self._apply_theme(effective, force=True)

    def _apply_theme(self, effective: str, *, force: bool = False):
        if not force and effective == self.effective_theme:
            return
        self.effective_theme = effective
        COLORS.clear()
        COLORS.update(LIGHT_COLORS if effective == "light" else DARK_COLORS)
        self.root.configure(bg=COLORS["bg"])
        for child in self.root.winfo_children():
            child.destroy()
        self._setup_styles()
        self._build_layout()
        self._sync_workspace_state()
        self.root.after(40, self._apply_titlebar_theme)

    def _apply_titlebar_theme(self):
        if sys.platform != "win32":
            return
        try:
            hwnd = self.root.winfo_id()
            while ctypes.windll.user32.GetParent(hwnd):
                hwnd = ctypes.windll.user32.GetParent(hwnd)
            enabled = ctypes.c_int(1 if self.effective_theme == "dark" else 0)
            for attribute in (20, 19):
                result = ctypes.windll.dwmapi.DwmSetWindowAttribute(
                    hwnd,
                    attribute,
                    ctypes.byref(enabled),
                    ctypes.sizeof(enabled),
                )
                if result == 0:
                    break
        except Exception:
            pass

    def _check_system_theme(self):
        if self.theme_mode == "跟随系统":
            self._apply_theme(windows_theme())
        self.root.after(2000, self._check_system_theme)

    def _sync_workspace_state(self):
        self._apply_status_visual()
        if self.source_array is None:
            self._draw_empty_preview()
        else:
            height, width = self.source_array.shape[:2]
            mode = "RGBA" if self.source_array.shape[2] == 4 else "RGB"
            self.source_label.configure(
                text=f"{self.source_name}\n{width} × {height}  ·  {mode}"
            )
            self.file_meta.configure(text=f"{self.source_name}   {width} × {height}")
            if self.result:
                result = self.result
                self.progress["value"] = 100
                self.metric_values["grid"].configure(text=result.original_size_text)
                self.metric_values["size"].configure(text=result.scaled_size_text)
                self.metric_values["colors"].configure(text=f"{result.color_count} 种")
                self.metric_values["format"].configure(
                    text="PNG · RGBA" if result.has_alpha else "PNG · RGB"
                )
                for button in self.export_buttons:
                    button.set_enabled(not self.busy)
            if self.busy:
                self.process_button.configure(text="正在精修…")
                self.process_button.set_enabled(False)
                self.progress.configure(mode="indeterminate")
                self.progress.start(12)
            self._refresh_view_buttons()
            self.root.after_idle(self._render_preview)
        if self.last_export_folder:
            self.open_folder_button.set_enabled(True)

    def _fade_in(self, alpha=0.0):
        alpha = min(1.0, alpha + 0.12)
        self.root.attributes("-alpha", alpha)
        if alpha < 1.0:
            self.root.after(18, lambda: self._fade_in(alpha))

    def apply_preset(self, name: str):
        for key, value in self.PRESETS[name].items():
            self.vars[key].set(value)
        for preset, button in self.preset_buttons.items():
            button.set_selected(preset == name)
        self.current_preset = name
        self._set_status(f"已应用“{name}”预设")

    def choose_background_color(self):
        selected = colorchooser.askcolor(
            self.vars["background_color"].get(),
            title="选择要处理的背景色",
            parent=self.root,
        )[1]
        if selected:
            self.vars["background_color"].set(selected)

    def open_image(self):
        if self.busy:
            return
        path = filedialog.askopenfilename(
            parent=self.root,
            title="选择像素画图片",
            filetypes=(
                ("支持的图片", "*.png *.jpg *.jpeg *.webp *.gif *.bmp *.tif *.tiff"),
                ("PNG 图片", "*.png"),
                ("所有文件", "*.*"),
            ),
        )
        if path:
            self._load_image(Path(path))

    def paste_image(self):
        if self.busy:
            return
        try:
            clipboard = ImageGrab.grabclipboard()
            if isinstance(clipboard, list) and clipboard:
                self._load_image(Path(clipboard[0]))
                return
            if isinstance(clipboard, Image.Image):
                self._set_source_image(clipboard, None, "clipboard.png")
                return
            messagebox.showinfo(
                "剪贴板中没有图片",
                "请先复制一张图片或图片文件，再按 Ctrl + V。",
                parent=self.root,
            )
        except Exception as error:
            messagebox.showerror("无法粘贴", str(error), parent=self.root)

    def _load_image(self, path: Path):
        try:
            with Image.open(path) as opened:
                image = ImageOps.exif_transpose(opened)
                image.seek(0)
                image.load()
                self._set_source_image(image, path, path.name)
            return True
        except Exception as error:
            messagebox.showerror(
                "无法打开图片",
                f"文件可能已损坏或格式不受支持。\n\n{error}",
                parent=self.root,
            )
            return False

    def _set_source_image(self, image: Image.Image, path: Path | None, name: str):
        mode = (
            "RGBA"
            if "A" in image.getbands() or "transparency" in image.info
            else "RGB"
        )
        converted = image.convert(mode)
        self.source_array = np.asarray(converted, dtype=np.uint8).copy()
        self.source_path = path
        self.source_name = name
        self.result = None
        self.current_view = "source"
        width, height = converted.size
        self.source_label.configure(text=f"{name}\n{width} × {height}  ·  {mode}")
        self.file_meta.configure(text=f"{name}   {width} × {height}")
        self.progress["value"] = 0
        for value in self.metric_values.values():
            value.configure(text="—")
        for button in self.export_buttons:
            button.set_enabled(False)
        self._refresh_view_buttons()
        self._render_preview()
        self._set_status("图片已就绪，点击“开始精修”")

    def _collect_settings(self) -> ProcessSettings:
        try:
            grid_width = int(self.vars["grid_width"].get() or 0)
            grid_height = int(self.vars["grid_height"].get() or 0)
        except ValueError as error:
            raise ValueError("手动网格宽和高必须是整数。") from error
        if grid_width < 0 or grid_height < 0:
            raise ValueError("手动网格宽和高不能小于 0。")
        sample_map = {"中心取样": "center", "中位数": "median", "多数色": "majority"}
        return ProcessSettings(
            sample_method=sample_map[self.vars["sample_method"].get()],
            processing_order=(
                "align_first"
                if self.vars["processing_order"].get() == "先对齐，再量化"
                else "quantize_first"
            ),
            scale_factor=int(self.vars["scale_factor"].get()),
            max_colors=int(self.vars["max_colors"].get()),
            color_space=self.vars["color_space"].get(),
            posterize_enabled=bool(self.vars["posterize_enabled"].get()),
            posterize_bits=int(self.vars["posterize_bits"].get()),
            grid_width=grid_width,
            grid_height=grid_height,
            min_pixel_size=float(self.vars["min_pixel_size"].get()),
            peak_width=int(self.vars["peak_width"].get()),
            refine_intensity=float(self.vars["refine_intensity"].get()),
            fix_square=bool(self.vars["fix_square"].get()),
            dominant_enabled=bool(self.vars["dominant_enabled"].get()),
            dominant_threshold=float(self.vars["dominant_threshold"].get()),
            morph_cleanup=bool(self.vars["morph_cleanup"].get()),
            antialias_cleanup=bool(self.vars["antialias_cleanup"].get()),
            antialias_threshold=float(self.vars["antialias_threshold"].get()),
            background_enabled=bool(self.vars["background_enabled"].get()),
            background_color=self.vars["background_color"].get(),
            background_tolerance=float(self.vars["background_tolerance"].get()),
            background_transparent=bool(self.vars["background_transparent"].get()),
            alpha_binarize=bool(self.vars["alpha_binarize"].get()),
            alpha_threshold=int(self.vars["alpha_threshold"].get()),
        )

    def start_processing(self):
        if self.busy:
            return
        if self.source_array is None:
            messagebox.showinfo(
                "请先导入图片",
                "选择或粘贴一张图片后，就可以开始精修。",
                parent=self.root,
            )
            return
        try:
            settings = self._collect_settings()
        except ValueError as error:
            messagebox.showwarning("参数需要调整", str(error), parent=self.root)
            return
        source = self.source_array.copy()
        self.busy = True
        self.process_button.set_enabled(False)
        self.process_button.configure(text="正在精修…")
        for button in self.export_buttons:
            button.set_enabled(False)
        self.progress.configure(mode="indeterminate")
        self.progress.start(12)
        self._set_status("正在分析像素网格…", working=True)

        def worker():
            try:
                result = process_image(
                    source,
                    settings,
                    progress_callback=lambda percent, text: self.events.put(
                        ("progress", percent, text)
                    ),
                )
                self.events.put(("result", result))
            except Exception as error:
                self.events.put(("error", str(error)))

        threading.Thread(target=worker, daemon=True, name="pixel-processor").start()

    def _poll_events(self):
        try:
            while True:
                event = self.events.get_nowait()
                if event[0] == "progress":
                    self._set_status(event[2], working=True)
                elif event[0] == "result":
                    self._finish_processing(event[1])
                elif event[0] == "error":
                    self._processing_failed(event[1])
        except queue.Empty:
            pass
        self.root.after(60, self._poll_events)

    def _finish_processing(self, result: ProcessResult):
        self.busy = False
        self.result = result
        self.progress.stop()
        self.progress.configure(mode="determinate")
        self.progress["value"] = 100
        self.process_button.configure(text="重新精修")
        self.process_button.set_enabled(True)
        for button in self.export_buttons:
            button.set_enabled(True)
        self.metric_values["grid"].configure(text=result.original_size_text)
        self.metric_values["size"].configure(text=result.scaled_size_text)
        self.metric_values["colors"].configure(text=f"{result.color_count} 种")
        self.metric_values["format"].configure(
            text="PNG · RGBA" if result.has_alpha else "PNG · RGB"
        )
        self.current_view = "scaled"
        self._refresh_view_buttons()
        self._render_preview(animate=True)
        self._set_status("精修完成，可以保存 PNG 或导出 ZIP")

    def _processing_failed(self, text: str):
        self.busy = False
        self.progress.stop()
        self.progress.configure(mode="determinate")
        self.progress["value"] = 0
        self.process_button.configure(text="开始精修")
        self.process_button.set_enabled(True)
        self._set_status("处理失败，请调整参数", error=True)
        messagebox.showerror("处理失败", text, parent=self.root)

    def set_view(self, view: str):
        if view != "source" and self.result is None:
            self._set_status("先完成一次精修，才能查看结果")
            return
        self.current_view = view
        self._refresh_view_buttons()
        self._render_preview()

    def _refresh_view_buttons(self):
        for view, button in self.view_buttons.items():
            button.set_selected(view == self.current_view)
            button.set_enabled(view == "source" or self.result is not None)

    def _schedule_preview(self, _event=None):
        if self.preview_resize_job:
            self.root.after_cancel(self.preview_resize_job)
        self.preview_resize_job = self.root.after(50, self._render_preview)

    def _draw_checkerboard(self):
        canvas = self.preview_canvas
        canvas.delete("checker")
        width = max(canvas.winfo_width(), 1)
        height = max(canvas.winfo_height(), 1)
        tile = 24
        for y in range(0, height, tile):
            for x in range(0, width, tile):
                color = (
                    COLORS["checker_a"]
                    if (x // tile + y // tile) % 2 == 0
                    else COLORS["checker_b"]
                )
                canvas.create_rectangle(
                    x,
                    y,
                    x + tile,
                    y + tile,
                    fill=color,
                    outline="",
                    tags="checker",
                )
        canvas.tag_lower("checker")

    def _draw_empty_preview(self):
        canvas = self.preview_canvas
        canvas.delete("all")
        width = max(canvas.winfo_width(), 600)
        height = max(canvas.winfo_height(), 400)
        x, y = width // 2, height // 2
        canvas.create_text(
            x,
            y - 16,
            text="选择一张图片开始",
            fill=COLORS["text_soft"],
            font=(UI_FONT, 16, "bold"),
        )
        canvas.create_text(
            x,
            y + 18,
            text="支持 PNG / JPG / WEBP / GIF · 双击画布也能导入",
            fill=COLORS["muted"],
            font=(UI_FONT, 9),
        )

    def _render_preview(self, animate: bool = False):
        self.preview_resize_job = None
        if self.source_array is None:
            self._draw_empty_preview()
            return
        if self.current_view == "source":
            array = self.source_array
            interpolation = Image.Resampling.LANCZOS
        elif self.current_view == "original" and self.result:
            array = self.result.original
            interpolation = Image.Resampling.NEAREST
        elif self.result:
            array = self.result.scaled
            interpolation = Image.Resampling.NEAREST
        else:
            array = self.source_array
            interpolation = Image.Resampling.LANCZOS

        canvas = self.preview_canvas
        canvas.delete("all")
        self._draw_checkerboard()
        width = max(canvas.winfo_width() - 72, 100)
        height = max(canvas.winfo_height() - 72, 100)
        image = Image.fromarray(array, mode="RGBA" if array.shape[2] == 4 else "RGB")
        ratio = min(width / image.width, height / image.height)
        if self.current_view != "source" and ratio > 1:
            ratio = max(1, float(int(ratio)))
        display_size = (
            max(1, int(image.width * ratio)),
            max(1, int(image.height * ratio)),
        )
        display = image.resize(display_size, interpolation)
        self.preview_photo = ImageTk.PhotoImage(display)
        center_x = canvas.winfo_width() // 2
        center_y = canvas.winfo_height() // 2
        canvas.create_rectangle(
            center_x - display.width // 2 - 1,
            center_y - display.height // 2 - 1,
            center_x + display.width // 2 + 1,
            center_y + display.height // 2 + 1,
            outline=COLORS["line"],
            width=1,
            tags="picture",
        )
        canvas.create_image(
            center_x,
            center_y,
            image=self.preview_photo,
            anchor="center",
            tags="picture",
        )
        if animate:
            canvas.itemconfigure("picture", state="hidden")
            self.root.after(40, lambda: canvas.itemconfigure("picture", state="normal"))

    def save_image(self, kind: str):
        if not self.result:
            return
        names = suggested_names(self.source_name, self.result)
        path = filedialog.asksaveasfilename(
            parent=self.root,
            title="保存像素画 PNG",
            defaultextension=".png",
            initialfile=names[kind],
            initialdir=str(self.last_export_folder) if self.last_export_folder else None,
            filetypes=(("PNG 图片", "*.png"),),
        )
        if not path:
            return
        try:
            image = self.result.original if kind == "original" else self.result.scaled
            Path(path).write_bytes(array_to_png_bytes(image))
            self._export_succeeded(Path(path))
        except Exception as error:
            messagebox.showerror("保存失败", str(error), parent=self.root)

    def save_zip(self):
        if not self.result:
            return
        name = suggested_names(self.source_name, self.result)["zip"]
        path = filedialog.asksaveasfilename(
            parent=self.root,
            title="导出全部处理结果",
            defaultextension=".zip",
            initialfile=name,
            initialdir=str(self.last_export_folder) if self.last_export_folder else None,
            filetypes=(("ZIP 压缩包", "*.zip"),),
        )
        if not path:
            return
        try:
            Path(path).write_bytes(create_result_zip(self.result, self.source_name))
            self._export_succeeded(Path(path))
        except Exception as error:
            messagebox.showerror("导出失败", str(error), parent=self.root)

    def _export_succeeded(self, path: Path):
        self.last_export_folder = path.parent
        self.open_folder_button.set_enabled(True)
        self._set_status(f"已保存：{path.name}")

    def open_export_folder(self):
        if not self.last_export_folder:
            return
        try:
            if sys.platform == "win32":
                os.startfile(str(self.last_export_folder))
            elif sys.platform == "darwin":
                os.system(f'open "{self.last_export_folder}"')
            else:
                os.system(f'xdg-open "{self.last_export_folder}"')
        except Exception as error:
            messagebox.showerror("无法打开目录", str(error), parent=self.root)

    def _set_status(self, text: str, *, working: bool = False, error: bool = False):
        self.status_text = text
        self.status_kind = "error" if error else ("working" if working else "normal")
        self._apply_status_visual()

    def _apply_status_visual(self):
        if self.status_kind == "error":
            bg, fg = "#351B1B", COLORS["error"]
            if self.effective_theme == "light":
                bg = "#FCE8E6"
        elif self.status_kind == "working":
            bg, fg = COLORS["surface_active"], COLORS["text_soft"]
        else:
            bg, fg = COLORS["accent_dark"], COLORS["accent"]
        self.header_status.configure(text=self.status_text, bg=bg, fg=fg)


def main() -> None:
    enable_high_dpi()
    root = TkinterDnD.Tk()
    app = PerfectPixelApp(root)
    root.report_callback_exception = lambda _exc, value, _tb: messagebox.showerror(
        "程序遇到问题", str(value), parent=root
    )
    root.mainloop()


if __name__ == "__main__":
    main()