easypyui 2.2.0__py3-none-any.whl

easypyui/core.py

@@ -0,0 +1,1192 @@
+import tkinter as tk
+from tkinter import ttk, messagebox, filedialog, colorchooser, simpledialog
+
+
+class Value:
+    def __init__(self, variable, widget=None):
+        self.var = variable
+        self.widget = widget
+        self.tk = widget
+
+    def get(self):
+        return self.var.get()
+
+    def set(self, value):
+        self.var.set(value)
+        return self
+
+    def __str__(self):
+        return str(self.get())
+
+    def __bool__(self):
+        return bool(self.get())
+
+
+class Widget:
+    def __init__(self, widget):
+        self.widget = widget
+        self.tk = widget
+
+    def get(self):
+        w = self.widget
+        if isinstance(w, tk.Text):
+            return w.get("1.0", "end-1c")
+        if isinstance(w, tk.Listbox):
+            sel = w.curselection()
+            return w.get(sel[0]) if sel else None
+        try:
+            return w.get()
+        except Exception:
+            return None
+
+    def set(self, value):
+        w = self.widget
+        if isinstance(w, tk.Text):
+            w.delete("1.0", "end")
+            w.insert("1.0", value)
+        elif isinstance(w, tk.Listbox):
+            w.delete(0, "end")
+            if isinstance(value, (list, tuple)):
+                for item in value:
+                    w.insert("end", item)
+            else:
+                w.insert("end", value)
+        else:
+            try:
+                w.delete(0, "end")
+                w.insert(0, value)
+            except Exception:
+                try:
+                    w.configure(text=value)
+                except Exception:
+                    pass
+        return self
+
+    def text(self, value=None):
+        if value is None:
+            try:
+                return self.widget.cget("text")
+            except Exception:
+                return None
+        self.widget.configure(text=value)
+        return self
+
+    def config(self, **kwargs):
+        self.widget.configure(**kwargs)
+        return self
+
+    configure = config
+
+    def enable(self):
+        try:
+            self.widget.configure(state="normal")
+        except Exception:
+            pass
+        return self
+
+    def disable(self):
+        try:
+            self.widget.configure(state="disabled")
+        except Exception:
+            pass
+        return self
+
+    def focus(self):
+        self.widget.focus_set()
+        return self
+
+    def destroy(self):
+        self.widget.destroy()
+
+    def hide(self):
+        manager = self.widget.winfo_manager()
+        if manager == "grid":
+            self.widget.grid_remove()
+        elif manager == "place":
+            self.widget.place_forget()
+        else:
+            self.widget.pack_forget()
+        return self
+
+    def show(self, **kwargs):
+        self.widget.pack(**kwargs)
+        return self
+
+    def pack(self, **kwargs):
+        self.widget.pack(**kwargs)
+        return self
+
+    def grid(self, row=0, column=0, **kwargs):
+        self.widget.grid(row=row, column=column, **kwargs)
+        return self
+
+    def place(self, x=None, y=None, **kwargs):
+        if x is not None:
+            kwargs["x"] = x
+        if y is not None:
+            kwargs["y"] = y
+        self.widget.place(**kwargs)
+        return self
+
+    def on(self, event, func, add=None):
+        self.widget.bind(event, func, add)
+        return self
+
+    def on_click(self, func, button=1):
+        self.widget.bind(f"<Button-{button}>", func)
+        return self
+
+    def tooltip(self, text, delay=400):
+        Tooltip(self.widget, text, delay)
+        return self
+
+    def context_menu(self, items):
+        attach_context_menu(self.widget, items)
+        return self
+
+
+class Table(Widget):
+    def add(self, values, parent="", index="end", iid=None):
+        return self.widget.insert(parent, index, iid=iid, values=values)
+
+    insert = add
+
+    def selected_id(self):
+        sel = self.widget.selection()
+        return sel[0] if sel else None
+
+    def selected(self):
+        iid = self.selected_id()
+        return self.widget.item(iid, "values") if iid else None
+
+    def update(self, iid=None, values=None, **kwargs):
+        iid = iid or self.selected_id()
+        if iid:
+            if values is not None:
+                kwargs["values"] = values
+            self.widget.item(iid, **kwargs)
+        return self
+
+    def delete(self, iid=None):
+        iid = iid or self.selected_id()
+        if iid:
+            self.widget.delete(iid)
+        return self
+
+    def clear(self):
+        for iid in self.widget.get_children():
+            self.widget.delete(iid)
+        return self
+
+    def rows(self):
+        return [self.widget.item(iid, "values") for iid in self.widget.get_children()]
+
+    def heading(self, column, text=None, command=None):
+        opts = {}
+        if text is not None:
+            opts["text"] = text
+        if command is not None:
+            opts["command"] = command
+        self.widget.heading(column, **opts)
+        return self
+
+    def column(self, column, **kwargs):
+        self.widget.column(column, **kwargs)
+        return self
+
+
+class Canvas(Widget):
+    def line(self, x1, y1, x2, y2, **kwargs):
+        return self.widget.create_line(x1, y1, x2, y2, **kwargs)
+
+    def rect(self, x1, y1, x2, y2, **kwargs):
+        return self.widget.create_rectangle(x1, y1, x2, y2, **kwargs)
+
+    rectangle = rect
+
+    def oval(self, x1, y1, x2, y2, **kwargs):
+        return self.widget.create_oval(x1, y1, x2, y2, **kwargs)
+
+    def text_at(self, x, y, text, **kwargs):
+        return self.widget.create_text(x, y, text=text, **kwargs)
+
+    def polygon(self, *points, **kwargs):
+        return self.widget.create_polygon(*points, **kwargs)
+
+    def delete(self, item="all"):
+        self.widget.delete(item)
+        return self
+
+    clear = delete
+
+    def move(self, item, dx, dy):
+        self.widget.move(item, dx, dy)
+        return self
+
+    def coords(self, item, *coords):
+        if coords:
+            self.widget.coords(item, *coords)
+            return self
+        return self.widget.coords(item)
+
+
+class Tooltip:
+    def __init__(self, widget, text, delay=400):
+        self.widget = widget
+        self.text = text
+        self.delay = delay
+        self._after = None
+        self._tip = None
+        widget.bind("<Enter>", self._schedule, add="+")
+        widget.bind("<Leave>", self._hide, add="+")
+        widget.bind("<ButtonPress>", self._hide, add="+")
+
+    def _schedule(self, _event=None):
+        self._cancel()
+        self._after = self.widget.after(self.delay, self._show)
+
+    def _cancel(self):
+        if self._after:
+            self.widget.after_cancel(self._after)
+            self._after = None
+
+    def _show(self):
+        if self._tip or not self.widget.winfo_exists():
+            return
+        x = self.widget.winfo_rootx() + 18
+        y = self.widget.winfo_rooty() + self.widget.winfo_height() + 4
+        self._tip = win = tk.Toplevel(self.widget)
+        win.wm_overrideredirect(True)
+        win.wm_geometry(f"+{x}+{y}")
+        label = tk.Label(
+            win, text=self.text, justify="left",
+            relief="solid", borderwidth=1, padx=6, pady=3
+        )
+        label.pack()
+
+    def _hide(self, _event=None):
+        self._cancel()
+        if self._tip:
+            self._tip.destroy()
+            self._tip = None
+
+
+def attach_context_menu(widget, items):
+    menu = tk.Menu(widget, tearoff=0)
+    for item in items:
+        if item is None:
+            menu.add_separator()
+        elif len(item) == 2:
+            menu.add_command(label=item[0], command=item[1])
+        else:
+            menu.add_command(label=item[0], command=item[1], state=item[2])
+
+    def popup(event):
+        menu.tk_popup(event.x_root, event.y_root)
+        menu.grab_release()
+
+    widget.bind("<Button-3>", popup, add="+")
+    return menu
+
+
+class _Builder:
+    def __init__(self, app, parent):
+        self.app = app
+        self._parent = parent
+        self.tk = parent
+
+    def _wrap_and_layout(self, widget, layout="pack", **layout_opts):
+        wrapped = Widget(widget)
+        if layout == "none":
+            return wrapped
+        if layout == "grid":
+            widget.grid(**layout_opts)
+        elif layout == "place":
+            widget.place(**layout_opts)
+        else:
+            defaults = {"fill": "x", "pady": 4}
+            defaults.update(layout_opts)
+            widget.pack(**defaults)
+        return wrapped
+
+    def text(self, text="", size=12, bold=False, layout="pack", **kwargs):
+        font_family = kwargs.pop("font_family", "Arial")
+        font = kwargs.pop("font", (font_family, size, "bold" if bold else "normal"))
+        layout_opts = kwargs.pop("layout_opts", {})
+        return self._wrap_and_layout(
+            ttk.Label(self._parent, text=text, font=font, **kwargs),
+            layout, **layout_opts
+        )
+
+    def button(self, text, action=None, layout="pack", **kwargs):
+        layout_opts = kwargs.pop("layout_opts", {})
+        return self._wrap_and_layout(
+            ttk.Button(self._parent, text=text, command=action, **kwargs),
+            layout, **layout_opts
+        )
+
+    def input(self, label=None, password=False, default="", layout="pack", **kwargs):
+        if label:
+            self.text(label, size=10)
+        layout_opts = kwargs.pop("layout_opts", {})
+        v = tk.StringVar(value=default)
+        w = ttk.Entry(self._parent, textvariable=v, show="*" if password else "", **kwargs)
+        wrapped = self._wrap_and_layout(w, layout, **layout_opts)
+        return Value(v, wrapped.tk)
+
+    def password(self, label="密碼", **kwargs):
+        return self.input(label=label, password=True, **kwargs)
+
+    def textbox(self, height=6, width=None, scroll=True, layout="pack", **kwargs):
+        layout_opts = kwargs.pop("layout_opts", {})
+        if scroll:
+            frame = ttk.Frame(self._parent)
+            text = tk.Text(frame, height=height, width=width, **kwargs)
+            sy = ttk.Scrollbar(frame, orient="vertical", command=text.yview)
+            text.configure(yscrollcommand=sy.set)
+            text.pack(side="left", fill="both", expand=True)
+            sy.pack(side="right", fill="y")
+            if layout == "grid":
+                frame.grid(**layout_opts)
+            elif layout == "place":
+                frame.place(**layout_opts)
+            else:
+                defaults = {"fill": "both", "expand": True, "pady": 4}
+                defaults.update(layout_opts)
+                frame.pack(**defaults)
+            return Widget(text)
+        w = tk.Text(self._parent, height=height, width=width, **kwargs)
+        return self._wrap_and_layout(w, layout, **layout_opts)
+
+    def check(self, text, checked=False, action=None, layout="pack", **kwargs):
+        layout_opts = kwargs.pop("layout_opts", {})
+        v = tk.BooleanVar(value=checked)
+        w = ttk.Checkbutton(self._parent, text=text, variable=v, command=action, **kwargs)
+        self._wrap_and_layout(w, layout, **layout_opts)
+        return Value(v, w)
+
+    checkbox = check
+
+    def radio(self, options, default=None, horizontal=False):
+        options = list(options)
+        v = tk.StringVar(value=default if default is not None else (str(options[0]) if options else ""))
+        holder = ttk.Frame(self._parent)
+        holder.pack(fill="x", pady=4)
+        for item in options:
+            w = ttk.Radiobutton(holder, text=str(item), value=str(item), variable=v)
+            w.pack(side="left" if horizontal else "top", anchor="w", padx=3, pady=2)
+        return Value(v, holder)
+
+    def select(self, items, default=None, readonly=True, layout="pack", **kwargs):
+        items = list(items)
+        v = tk.StringVar(value=default if default is not None else (items[0] if items else ""))
+        layout_opts = kwargs.pop("layout_opts", {})
+        w = ttk.Combobox(
+            self._parent, values=items, textvariable=v,
+            state="readonly" if readonly else "normal", **kwargs
+        )
+        self._wrap_and_layout(w, layout, **layout_opts)
+        return Value(v, w)
+
+    def slider(self, start=0, end=100, default=0, action=None, layout="pack", **kwargs):
+        v = tk.DoubleVar(value=default)
+        layout_opts = kwargs.pop("layout_opts", {})
+        w = ttk.Scale(self._parent, from_=start, to=end, variable=v, command=action, **kwargs)
+        self._wrap_and_layout(w, layout, **layout_opts)
+        return Value(v, w)
+
+    def spin(self, start=0, end=100, default=0, layout="pack", **kwargs):
+        v = tk.IntVar(value=default)
+        layout_opts = kwargs.pop("layout_opts", {})
+        w = ttk.Spinbox(self._parent, from_=start, to=end, textvariable=v, **kwargs)
+        self._wrap_and_layout(w, layout, **layout_opts)
+        return Value(v, w)
+
+    def progress(self, value=0, maximum=100, mode="determinate", layout="pack", **kwargs):
+        v = tk.DoubleVar(value=value)
+        layout_opts = kwargs.pop("layout_opts", {})
+        w = ttk.Progressbar(self._parent, maximum=maximum, variable=v, mode=mode, **kwargs)
+        self._wrap_and_layout(w, layout, **layout_opts)
+        return Value(v, w)
+
+    def listbox(self, items=(), height=6, scroll=True, layout="pack", **kwargs):
+        layout_opts = kwargs.pop("layout_opts", {})
+        if scroll:
+            frame = ttk.Frame(self._parent)
+            w = tk.Listbox(frame, height=height, **kwargs)
+            sy = ttk.Scrollbar(frame, orient="vertical", command=w.yview)
+            w.configure(yscrollcommand=sy.set)
+            w.pack(side="left", fill="both", expand=True)
+            sy.pack(side="right", fill="y")
+            if layout == "grid":
+                frame.grid(**layout_opts)
+            elif layout == "place":
+                frame.place(**layout_opts)
+            else:
+                defaults = {"fill": "both", "expand": True, "pady": 4}
+                defaults.update(layout_opts)
+                frame.pack(**defaults)
+        else:
+            w = tk.Listbox(self._parent, height=height, **kwargs)
+            self._wrap_and_layout(w, layout, **layout_opts)
+        for x in items:
+            w.insert("end", x)
+        return Widget(w)
+
+    def table(self, columns, rows=(), headings=None, height=8, scroll=True, layout="pack", **kwargs):
+        cols = list(columns)
+        headings = headings or cols
+        layout_opts = kwargs.pop("layout_opts", {})
+
+        holder = ttk.Frame(self._parent) if scroll else self._parent
+        w = ttk.Treeview(holder, columns=cols, show="headings", height=height, **kwargs)
+        for c, h in zip(cols, headings):
+            w.heading(c, text=h)
+            w.column(c, anchor="w")
+        for row in rows:
+            w.insert("", "end", values=row)
+
+        if scroll:
+            sy = ttk.Scrollbar(holder, orient="vertical", command=w.yview)
+            sx = ttk.Scrollbar(holder, orient="horizontal", command=w.xview)
+            w.configure(yscrollcommand=sy.set, xscrollcommand=sx.set)
+            w.grid(row=0, column=0, sticky="nsew")
+            sy.grid(row=0, column=1, sticky="ns")
+            sx.grid(row=1, column=0, sticky="ew")
+            holder.rowconfigure(0, weight=1)
+            holder.columnconfigure(0, weight=1)
+            if layout == "grid":
+                holder.grid(**layout_opts)
+            elif layout == "place":
+                holder.place(**layout_opts)
+            else:
+                defaults = {"fill": "both", "expand": True, "pady": 4}
+                defaults.update(layout_opts)
+                holder.pack(**defaults)
+        else:
+            self._wrap_and_layout(w, layout, **layout_opts)
+
+        return Table(w)
+
+    def canvas(self, width=400, height=250, scroll=False, layout="pack", **kwargs):
+        layout_opts = kwargs.pop("layout_opts", {})
+        if scroll:
+            holder = ttk.Frame(self._parent)
+            w = tk.Canvas(holder, width=width, height=height, **kwargs)
+            sy = ttk.Scrollbar(holder, orient="vertical", command=w.yview)
+            sx = ttk.Scrollbar(holder, orient="horizontal", command=w.xview)
+            w.configure(yscrollcommand=sy.set, xscrollcommand=sx.set)
+            w.grid(row=0, column=0, sticky="nsew")
+            sy.grid(row=0, column=1, sticky="ns")
+            sx.grid(row=1, column=0, sticky="ew")
+            holder.rowconfigure(0, weight=1)
+            holder.columnconfigure(0, weight=1)
+            if layout == "grid":
+                holder.grid(**layout_opts)
+            elif layout == "place":
+                holder.place(**layout_opts)
+            else:
+                defaults = {"fill": "both", "expand": True, "pady": 4}
+                defaults.update(layout_opts)
+                holder.pack(**defaults)
+        else:
+            w = tk.Canvas(self._parent, width=width, height=height, **kwargs)
+            self._wrap_and_layout(w, layout, **layout_opts)
+        return Canvas(w)
+
+    def image(self, path, layout="pack", **layout_opts):
+        img = tk.PhotoImage(file=path)
+        w = ttk.Label(self._parent, image=img)
+        w.image = img
+        return self._wrap_and_layout(w, layout, **layout_opts)
+
+    def separator(self, orient="horizontal"):
+        return self._wrap_and_layout(ttk.Separator(self._parent, orient=orient))
+
+    def group(self, title="", **kwargs):
+        frame = ttk.LabelFrame(self._parent, text=title, padding=kwargs.pop("padding", 8))
+        frame.pack(fill=kwargs.pop("fill", "both"), expand=kwargs.pop("expand", False),
+                   padx=kwargs.pop("padx", 0), pady=kwargs.pop("pady", 4))
+        return Container(self.app, frame)
+
+    def row(self, **kwargs):
+        frame = ttk.Frame(self._parent)
+        frame.pack(fill=kwargs.pop("fill", "x"), expand=kwargs.pop("expand", False),
+                   padx=kwargs.pop("padx", 0), pady=kwargs.pop("pady", 3))
+        return Row(self.app, frame)
+
+    def frame(self, layout="pack", **kwargs):
+        layout_opts = kwargs.pop("layout_opts", {})
+        f = ttk.Frame(self._parent, **kwargs)
+        self._wrap_and_layout(f, layout, **layout_opts)
+        return Container(self.app, f)
+
+    def scroll_area(self, height=300):
+        outer = ttk.Frame(self._parent)
+        outer.pack(fill="both", expand=True)
+        canvas = tk.Canvas(outer, height=height, highlightthickness=0)
+        scrollbar = ttk.Scrollbar(outer, orient="vertical", command=canvas.yview)
+        content = ttk.Frame(canvas)
+        content.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
+        window_id = canvas.create_window((0, 0), window=content, anchor="nw")
+        canvas.bind("<Configure>", lambda e: canvas.itemconfigure(window_id, width=e.width))
+        canvas.configure(yscrollcommand=scrollbar.set)
+        canvas.pack(side="left", fill="both", expand=True)
+        scrollbar.pack(side="right", fill="y")
+        return Container(self.app, content)
+
+    def context_menu(self, items):
+        return attach_context_menu(self._parent, items)
+
+
+class Row(_Builder):
+    def _wrap_and_layout(self, widget, layout="pack", **layout_opts):
+        if layout == "none":
+            return Widget(widget)
+        if layout == "grid":
+            widget.grid(**layout_opts)
+        elif layout == "place":
+            widget.place(**layout_opts)
+        else:
+            defaults = {"side": "left", "padx": 3, "pady": 3}
+            defaults.update(layout_opts)
+            widget.pack(**defaults)
+        return Widget(widget)
+
+
+class Container(_Builder):
+    def __init__(self, app, frame, window=None):
+        super().__init__(app, frame)
+        self.frame = frame
+        self.window = window
+
+    def close(self):
+        if self.window:
+            self.window.destroy()
+        else:
+            self.frame.destroy()
+
+
+class App(_Builder):
+    def __init__(self, title="EasyPyUI", width=500, height=400, resizable=True, theme=None):
+        self.root = tk.Tk()
+        self.root.title(title)
+        self.root.geometry(f"{width}x{height}")
+        self.root.resizable(resizable, resizable)
+        self.style = ttk.Style(self.root)
+        if theme:
+            self.theme(theme)
+        self.body = ttk.Frame(self.root, padding=12)
+        self.body.pack(fill="both", expand=True)
+        super().__init__(self, self.body)
+        self.tk = self.root
+
+    def title(self, text):
+        self.root.title(text)
+        return self
+
+    def size(self, width, height):
+        self.root.geometry(f"{width}x{height}")
+        return self
+
+    def min_size(self, width, height):
+        self.root.minsize(width, height)
+        return self
+
+    def max_size(self, width, height):
+        self.root.maxsize(width, height)
+        return self
+
+    def position(self, x, y):
+        self.root.geometry(f"+{x}+{y}")
+        return self
+
+    def center(self):
+        self.root.update_idletasks()
+        w = self.root.winfo_width()
+        h = self.root.winfo_height()
+        sw = self.root.winfo_screenwidth()
+        sh = self.root.winfo_screenheight()
+        self.root.geometry(f"+{(sw-w)//2}+{(sh-h)//2}")
+        return self
+
+    def icon(self, path):
+        self.root.iconbitmap(path)
+        return self
+
+    def topmost(self, yes=True):
+        self.root.attributes("-topmost", yes)
+        return self
+
+    def fullscreen(self, yes=True):
+        self.root.attributes("-fullscreen", yes)
+        return self
+
+    def opacity(self, value=1.0):
+        self.root.attributes("-alpha", value)
+        return self
+
+    def resizable(self, width=True, height=True):
+        self.root.resizable(width, height)
+        return self
+
+    def theme(self, name=None):
+        if name is None:
+            return self.style.theme_use()
+        self.style.theme_use(name)
+        return self
+
+    def themes(self):
+        return self.style.theme_names()
+
+    def style_widget(self, name, **kwargs):
+        self.style.configure(name, **kwargs)
+        return self
+
+    def map_style(self, name, **kwargs):
+        self.style.map(name, **kwargs)
+        return self
+
+    def grid_config(self, rows=None, columns=None, weight=1):
+        if rows:
+            for r in rows:
+                self.body.rowconfigure(r, weight=weight)
+        if columns:
+            for c in columns:
+                self.body.columnconfigure(c, weight=weight)
+        return self
+
+    def tabs(self, names):
+        notebook = ttk.Notebook(self._parent)
+        notebook.pack(fill="both", expand=True)
+        result = {}
+        for name in names:
+            f = ttk.Frame(notebook, padding=8)
+            notebook.add(f, text=name)
+            result[name] = Container(self, f)
+        result["_notebook"] = Widget(notebook)
+        return result
+
+    def menu(self, structure):
+        bar = tk.Menu(self.root)
+        for title, items in structure.items():
+            m = tk.Menu(bar, tearoff=0)
+            for item in items:
+                if item is None:
+                    m.add_separator()
+                elif isinstance(item, dict):
+                    sub = tk.Menu(m, tearoff=0)
+                    for label, command in item.items():
+                        sub.add_command(label=label, command=command)
+                    m.add_cascade(label=title, menu=sub)
+                else:
+                    m.add_command(label=item[0], command=item[1])
+            bar.add_cascade(label=title, menu=m)
+        self.root.config(menu=bar)
+        return bar
+
+    def context_menu(self, items):
+        return attach_context_menu(self.root, items)
+
+    def alert(self, text, title="提示"):
+        return messagebox.showinfo(title, text, parent=self.root)
+
+    def error(self, text, title="錯誤"):
+        return messagebox.showerror(title, text, parent=self.root)
+
+    def warning(self, text, title="警告"):
+        return messagebox.showwarning(title, text, parent=self.root)
+
+    def ask(self, text, title="確認"):
+        return messagebox.askyesno(title, text, parent=self.root)
+
+    def ask_ok(self, text, title="確認"):
+        return messagebox.askokcancel(title, text, parent=self.root)
+
+    def ask_retry(self, text, title="重試"):
+        return messagebox.askretrycancel(title, text, parent=self.root)
+
+    def prompt(self, text, title="輸入", default=None):
+        return simpledialog.askstring(title, text, initialvalue=default, parent=self.root)
+
+    def prompt_int(self, text, title="輸入", default=None, min=None, max=None):
+        return simpledialog.askinteger(
+            title, text, initialvalue=default, minvalue=min, maxvalue=max, parent=self.root
+        )
+
+    def prompt_float(self, text, title="輸入", default=None, min=None, max=None):
+        return simpledialog.askfloat(
+            title, text, initialvalue=default, minvalue=min, maxvalue=max, parent=self.root
+        )
+
+    def open_file(self, **kwargs):
+        return filedialog.askopenfilename(parent=self.root, **kwargs)
+
+    def open_files(self, **kwargs):
+        return filedialog.askopenfilenames(parent=self.root, **kwargs)
+
+    def save_file(self, **kwargs):
+        return filedialog.asksaveasfilename(parent=self.root, **kwargs)
+
+    def folder(self, **kwargs):
+        return filedialog.askdirectory(parent=self.root, **kwargs)
+
+    def pick_color(self):
+        return colorchooser.askcolor(parent=self.root)[1]
+
+    def clipboard(self, text=None):
+        if text is None:
+            try:
+                return self.root.clipboard_get()
+            except tk.TclError:
+                return ""
+        self.root.clipboard_clear()
+        self.root.clipboard_append(str(text))
+        return self
+
+    def later(self, ms, func):
+        return self.root.after(ms, func)
+
+    def every(self, ms, func):
+        state = {"active": True, "id": None}
+
+        def tick():
+            if not state["active"]:
+                return
+            func()
+            state["id"] = self.root.after(ms, tick)
+
+        state["id"] = self.root.after(ms, tick)
+        return state
+
+    def cancel(self, timer):
+        if isinstance(timer, dict):
+            timer["active"] = False
+            if timer.get("id"):
+                try:
+                    self.root.after_cancel(timer["id"])
+                except Exception:
+                    pass
+        else:
+            self.root.after_cancel(timer)
+        return self
+
+    def on(self, event, func, add=None):
+        self.root.bind(event, func, add)
+        return self
+
+    def on_key(self, key, func):
+        self.root.bind(f"<{key}>", func)
+        return self
+
+    def on_close(self, func):
+        self.root.protocol("WM_DELETE_WINDOW", func)
+        return self
+
+    def clear(self):
+        for widget in self.body.winfo_children():
+            widget.destroy()
+        return self
+
+    def new_window(self, title="視窗", width=400, height=300, modal=False):
+        win = tk.Toplevel(self.root)
+        win.title(title)
+        win.geometry(f"{width}x{height}")
+        frame = ttk.Frame(win, padding=12)
+        frame.pack(fill="both", expand=True)
+        if modal:
+            win.transient(self.root)
+            win.grab_set()
+        return Container(self, frame, window=win)
+
+    def close(self):
+        self.root.destroy()
+
+    def run(self):
+        self.root.mainloop()
+
+
+
+class ModernCard(Container):
+    def __init__(self, app, parent, title=None, padding=12):
+        outer = ttk.Frame(parent, padding=padding, relief="solid", borderwidth=1)
+        outer.pack(fill="x", pady=6)
+        if title:
+            ttk.Label(outer, text=title, font=("Arial", 12, "bold")).pack(anchor="w", pady=(0, 6))
+        body = ttk.Frame(outer)
+        body.pack(fill="both", expand=True)
+        super().__init__(app, body)
+        self.outer = outer
+
+
+class StatusBar:
+    def __init__(self, parent, text="Ready"):
+        self.var = tk.StringVar(value=text)
+        self.widget = ttk.Label(parent, textvariable=self.var, relief="sunken", anchor="w")
+        self.widget.pack(side="bottom", fill="x")
+
+    def set(self, text):
+        self.var.set(text)
+        return self
+
+    def get(self):
+        return self.var.get()
+
+    def clear(self):
+        self.var.set("")
+        return self
+
+
+class LoadingOverlay:
+    def __init__(self, app, text="Loading..."):
+        self.app = app
+        self.top = tk.Toplevel(app.root)
+        self.top.transient(app.root)
+        self.top.overrideredirect(True)
+        self.top.attributes("-topmost", True)
+
+        frame = ttk.Frame(self.top, padding=16, relief="solid", borderwidth=1)
+        frame.pack(fill="both", expand=True)
+
+        ttk.Label(frame, text=text, font=("Arial", 11, "bold")).pack(pady=(0, 8))
+        self.bar = ttk.Progressbar(frame, mode="indeterminate", length=180)
+        self.bar.pack()
+        self.bar.start(12)
+
+        self.top.update_idletasks()
+        w = self.top.winfo_reqwidth()
+        h = self.top.winfo_reqheight()
+        x = app.root.winfo_rootx() + max(0, (app.root.winfo_width() - w)//2)
+        y = app.root.winfo_rooty() + max(0, (app.root.winfo_height() - h)//2)
+        self.top.geometry(f"+{x}+{y}")
+
+    def close(self):
+        try:
+            self.bar.stop()
+            self.top.destroy()
+        except Exception:
+            pass
+
+
+def _modern_methods():
+    def switch(self, text="", checked=False, action=None, layout="pack", **kwargs):
+        return self.check(text, checked=checked, action=action, layout=layout, **kwargs)
+
+    def card(self, title=None, padding=12):
+        return ModernCard(self.app if hasattr(self, "app") else self, self._parent, title, padding)
+
+    def badge(self, text, layout="pack"):
+        lbl = tk.Label(
+            self._parent,
+            text=text,
+            padx=8,
+            pady=2,
+            relief="groove",
+            borderwidth=1,
+            font=("Arial", 9, "bold")
+        )
+        return self._wrap_and_layout(lbl, layout)
+
+    def navbar(self, items):
+        frame = ttk.Frame(self._parent)
+        frame.pack(fill="x", pady=(0, 8))
+        for label, command in items:
+            ttk.Button(frame, text=label, command=command).pack(side="left", padx=3)
+        return Container(self.app if hasattr(self, "app") else self, frame)
+
+    def sidebar(self, items, width=160):
+        frame = ttk.Frame(self._parent, width=width)
+        frame.pack(side="left", fill="y", padx=(0, 8))
+        frame.pack_propagate(False)
+        for label, command in items:
+            ttk.Button(frame, text=label, command=command).pack(fill="x", pady=3)
+        return Container(self.app if hasattr(self, "app") else self, frame)
+
+    _Builder.switch = switch
+    _Builder.card = card
+    _Builder.badge = badge
+    _Builder.navbar = navbar
+    _Builder.sidebar = sidebar
+
+_modern_methods()
+
+
+def _app_modern_methods():
+    def toast(self, text, duration=2000, title=None):
+        win = tk.Toplevel(self.root)
+        win.overrideredirect(True)
+        win.attributes("-topmost", True)
+
+        frame = ttk.Frame(win, padding=10, relief="solid", borderwidth=1)
+        frame.pack(fill="both", expand=True)
+
+        if title:
+            ttk.Label(frame, text=title, font=("Arial", 10, "bold")).pack(anchor="w")
+        ttk.Label(frame, text=text).pack(anchor="w")
+
+        win.update_idletasks()
+        w = win.winfo_reqwidth()
+        h = win.winfo_reqheight()
+        x = self.root.winfo_rootx() + self.root.winfo_width() - w - 20
+        y = self.root.winfo_rooty() + self.root.winfo_height() - h - 40
+        win.geometry(f"+{max(0,x)}+{max(0,y)}")
+        self.root.after(duration, lambda: win.winfo_exists() and win.destroy())
+        return win
+
+    def loading(self, text="Loading..."):
+        return LoadingOverlay(self, text)
+
+    def statusbar(self, text="Ready"):
+        return StatusBar(self.root, text)
+
+    def page(self):
+        frame = ttk.Frame(self.body)
+        frame.pack(fill="both", expand=True)
+        return Container(self, frame)
+
+    def clear_body(self):
+        for widget in self.body.winfo_children():
+            widget.destroy()
+        return self
+
+    App.toast = toast
+    App.loading = loading
+    App.statusbar = statusbar
+    App.page = page
+    App.clear_body = clear_body
+
+_app_modern_methods()
+
+
+
+# =========================
+# EasyPyUI 2.0 extensions
+# =========================
+
+import threading
+import traceback
+
+
+THEMES = {
+    "light": {
+        "bg": "#f5f5f5",
+        "surface": "#ffffff",
+        "text": "#111111",
+        "muted": "#666666",
+        "accent": "#2563eb",
+    },
+    "dark": {
+        "bg": "#181818",
+        "surface": "#242424",
+        "text": "#f5f5f5",
+        "muted": "#b0b0b0",
+        "accent": "#60a5fa",
+    },
+}
+
+
+class Router:
+    def __init__(self, app):
+        self.app = app
+        self.pages = {}
+        self.current = None
+
+    def add(self, name, builder):
+        self.pages[name] = builder
+        return self
+
+    def go(self, name):
+        if name not in self.pages:
+            raise KeyError(f"找不到頁面: {name}")
+        self.app.clear_body()
+        self.current = name
+        self.pages[name](self.app)
+        return self
+
+    def back_to(self, name):
+        return self.go(name)
+
+
+class Switch(Value):
+    def __init__(self, parent, text="", checked=False, action=None):
+        self.var = tk.BooleanVar(value=checked)
+        self.frame = ttk.Frame(parent)
+        self.label = ttk.Label(self.frame, text=text)
+        self.label.pack(side="left", padx=(0, 8))
+
+        self.button = ttk.Checkbutton(
+            self.frame,
+            variable=self.var,
+            command=action
+        )
+        self.button.pack(side="left")
+        self.widget = self.button
+        self.tk = self.button
+
+    def pack(self, **kwargs):
+        self.frame.pack(**kwargs)
+        return self
+
+    def grid(self, **kwargs):
+        self.frame.grid(**kwargs)
+        return self
+
+    def place(self, **kwargs):
+        self.frame.place(**kwargs)
+        return self
+
+
+def _builder_switch_v2(self, text="", checked=False, action=None, layout="pack", **kwargs):
+    sw = Switch(self._parent, text=text, checked=checked, action=action)
+    layout_opts = kwargs.pop("layout_opts", {})
+    if layout == "grid":
+        sw.grid(**layout_opts)
+    elif layout == "place":
+        sw.place(**layout_opts)
+    elif layout != "none":
+        defaults = {"fill": "x", "pady": 4}
+        defaults.update(layout_opts)
+        sw.pack(**defaults)
+    return sw
+
+
+_Builder.switch = _builder_switch_v2
+
+
+def _app_theme2(self, name="light", accent=None):
+    if name not in THEMES:
+        raise ValueError(f"未知主題: {name}. 可用: {', '.join(THEMES)}")
+
+    palette = dict(THEMES[name])
+    if accent:
+        palette["accent"] = accent
+
+    self._theme_name = name
+    self._palette = palette
+
+    self.root.configure(bg=palette["bg"])
+    try:
+        self.body.configure(style="Easy.TFrame")
+    except Exception:
+        pass
+
+    self.style.configure("Easy.TFrame", background=palette["bg"])
+    self.style.configure(
+        "EasyCard.TFrame",
+        background=palette["surface"],
+        relief="flat"
+    )
+    self.style.configure(
+        "Easy.TLabel",
+        background=palette["bg"],
+        foreground=palette["text"]
+    )
+    self.style.configure(
+        "EasyMuted.TLabel",
+        background=palette["bg"],
+        foreground=palette["muted"]
+    )
+    self.style.configure(
+        "Accent.TButton",
+        padding=8
+    )
+    return self
+
+
+def _app_palette(self, key=None):
+    palette = getattr(self, "_palette", THEMES["light"])
+    return palette.get(key) if key else dict(palette)
+
+
+def _app_router(self):
+    if not hasattr(self, "_router"):
+        self._router = Router(self)
+    return self._router
+
+
+def _app_route(self, name, builder=None):
+    router = self.router()
+    if builder is not None:
+        router.add(name, builder)
+        return self
+    return router.go(name)
+
+
+def _app_run_task(self, func, done=None, error=None, loading_text=None):
+    loader = self.loading(loading_text) if loading_text else None
+
+    def worker():
+        try:
+            result = func()
+        except Exception as exc:
+            tb = traceback.format_exc()
+            def fail():
+                if loader:
+                    loader.close()
+                if error:
+                    error(exc)
+                else:
+                    self.error(tb, title="背景任務錯誤")
+            self.root.after(0, fail)
+            return
+
+        def finish():
+            if loader:
+                loader.close()
+            if done:
+                done(result)
+
+        self.root.after(0, finish)
+
+    threading.Thread(target=worker, daemon=True).start()
+    return self
+
+
+def _app_confirm(self, text, yes=None, no=None, title="確認"):
+    result = self.ask(text, title=title)
+    if result and yes:
+        yes()
+    elif not result and no:
+        no()
+    return result
+
+
+def _app_notify(self, text, title=None, duration=2500):
+    return self.toast(text, title=title, duration=duration)
+
+
+def _app_set_status(self, text):
+    if not hasattr(self, "_statusbar2"):
+        self._statusbar2 = self.statusbar(text)
+    else:
+        self._statusbar2.set(text)
+    return self._statusbar2
+
+
+App.theme2 = _app_theme2
+App.palette = _app_palette
+App.router = _app_router
+App.route = _app_route
+App.run_task = _app_run_task
+App.confirm = _app_confirm
+App.notify = _app_notify
+App.set_status = _app_set_status
+
+
+# Patch App.__init__ so a modern theme can be selected with appearance=
+_old_app_init = App.__init__
+
+def _new_app_init(self, title="EasyPyUI", width=500, height=400,
+                  resizable=True, theme=None, appearance="light", accent=None):
+    _old_app_init(self, title, width, height, resizable, theme)
+    self.theme2(appearance, accent=accent)
+
+App.__init__ = _new_app_init
+
+
+# EasyPyUI 2.1 modern drawing widgets
+from .modern import install_modern_api
+install_modern_api(App, _Builder)
+
+from .animation import install_animation_api
+install_animation_api(App, _Builder)