flextool 4.0.0__py3-none-any.whl

flextool/gui/dialogs/project_dialog.py

@@ -0,0 +1,426 @@
+from __future__ import annotations
+
+import logging
+import shutil
+import tkinter as tk
+import tkinter.font as tkfont
+from tkinter import ttk, messagebox
+
+from flextool.gui.project_utils import (
+    create_project,
+    get_projects_dir,
+    list_projects,
+    rename_project,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class ProjectDialog(tk.Toplevel):
+    """Modal dialog for creating, selecting, renaming, and deleting projects.
+
+    After the dialog closes:
+      * ``self.result`` holds the selected project name (Open clicked) or
+        ``None`` if the user cancelled.
+      * ``self.deleted_names`` lists projects that were deleted while the
+        dialog was open.  The caller can use it to check whether the
+        currently-open project was removed.
+    """
+
+    def __init__(self, parent: tk.Misc, current_project: str | None = None) -> None:
+        super().__init__(parent)
+        self.title("Project menu")
+        self.result: str | None = None
+        self.deleted_names: list[str] = []
+        self._current_project = current_project
+
+        # ── Modal behaviour ─────────────────────────────────────────
+        self.transient(parent)
+        self.grab_set()
+
+        # ── Font metrics for DPI-aware sizing ──────────────────────
+        from flextool.gui.ui_metrics import get_metrics
+        _metrics = get_metrics(self)
+        cw: int = _metrics.cw
+        lh: int = _metrics.lh
+
+        # ── Dialog size ─────────────────────────────────────────────
+        self.geometry(f"{cw * 70}x{lh * 30}")
+        self.minsize(cw * 50, lh * 20)
+
+        self._rename_entry: tk.Entry | None = None
+
+        self._build_widgets()
+        self._populate_projects()
+
+        # Close via window-manager "X"
+        self.protocol("WM_DELETE_WINDOW", self._on_cancel)
+
+        # Centre on parent
+        self.update_idletasks()
+        px = parent.winfo_rootx()
+        py = parent.winfo_rooty()
+        pw = parent.winfo_width()
+        ph = parent.winfo_height()
+        w = self.winfo_width()
+        h = self.winfo_height()
+        x = px + (pw - w) // 2
+        y = py + (ph - h) // 2
+        self.geometry(f"+{x}+{y}")
+
+        # Block until closed
+        parent.wait_window(self)
+
+    # ── Widget construction ─────────────────────────────────────────
+
+    def _build_widgets(self) -> None:
+        pad = dict(padx=10, pady=5)
+
+        # -- New project section --
+        new_frame = ttk.LabelFrame(self, text="Create an empty project", padding=8)
+        new_frame.pack(fill="x", **pad)
+
+        entry_row = ttk.Frame(new_frame)
+        entry_row.pack(fill="x")
+
+        ttk.Label(entry_row, text="Name:").pack(side="left")
+        self._new_name_var = tk.StringVar()
+        self._new_name_entry = ttk.Entry(entry_row, textvariable=self._new_name_var, width=30)
+        self._new_name_entry.pack(side="left", padx=(5, 0), fill="x", expand=True)
+
+        self._create_btn = ttk.Button(new_frame, text="Create", command=self._on_create)
+        self._create_btn.pack(anchor="w", pady=(5, 0))
+
+        # Allow Enter in the entry to create
+        self._new_name_entry.bind("<Return>", lambda _e: self._on_create())
+
+        # -- Existing projects section --
+        existing_frame = ttk.LabelFrame(self, text="Existing projects", padding=8)
+        existing_frame.pack(fill="both", expand=True, **pad)
+
+        list_frame = ttk.Frame(existing_frame)
+        list_frame.pack(fill="both", expand=True)
+        list_frame.columnconfigure(0, weight=1)
+        list_frame.rowconfigure(0, weight=1)
+
+        self._project_listbox = tk.Listbox(list_frame, selectmode="browse", activestyle="dotbox")
+        self._project_listbox.grid(row=0, column=0, sticky="nsew")
+
+        scrollbar = ttk.Scrollbar(list_frame, orient="vertical", command=self._project_listbox.yview)
+        self._project_listbox.configure(yscrollcommand=scrollbar.set)
+        scrollbar.grid(row=0, column=1, sticky="ns")
+
+        # Double-click opens
+        self._project_listbox.bind("<Double-Button-1>", lambda _e: self._on_open())
+        # F2 triggers inline rename
+        self._project_listbox.bind("<F2>", lambda _e: self._start_inline_rename())
+
+        # Enable/disable Ok when listbox selection changes
+        self._project_listbox.bind("<<ListboxSelect>>", lambda _e: self._update_ok_state())
+
+        # -- Bottom buttons --
+        btn_frame = ttk.Frame(self)
+        btn_frame.pack(fill="x", **pad)
+
+        self._open_btn = ttk.Button(btn_frame, text="Open the selected project", command=self._on_open, state="disabled")
+        self._open_btn.pack(side="left")
+
+        self._delete_btn = ttk.Button(
+            btn_frame,
+            text="Delete",
+            command=self._on_delete_clicked,
+            state="disabled",
+        )
+        self._delete_btn.pack(side="left", padx=(10, 0))
+
+        self._cancel_btn = ttk.Button(btn_frame, text="Cancel", command=self._on_cancel)
+        self._cancel_btn.pack(side="right")
+
+    # ── Helpers ──────────────────────────────────────────────────────
+
+    def _update_ok_state(self) -> None:
+        """Enable Open/Delete buttons when a project is selected."""
+        if self._project_listbox.curselection():
+            self._open_btn.configure(state="normal")
+            self._delete_btn.configure(state="normal")
+        else:
+            self._open_btn.configure(state="disabled")
+            self._delete_btn.configure(state="disabled")
+
+    def _populate_projects(self) -> None:
+        """Refresh the listbox with the current project list."""
+        self._project_listbox.delete(0, "end")
+        for name in list_projects():
+            self._project_listbox.insert("end", name)
+
+    def _selected_project(self) -> str | None:
+        """Return the currently selected project name, or None."""
+        sel = self._project_listbox.curselection()
+        if not sel:
+            return None
+        return self._project_listbox.get(sel[0])
+
+    # ── Event handlers ──────────────────────────────────────────────
+
+    def _on_create(self) -> None:
+        name = self._new_name_var.get().strip()
+        if not name:
+            messagebox.showwarning("Invalid name", "Please enter a project name.", parent=self)
+            return
+        # Disallow names with path separators or other problematic chars
+        if "/" in name or "\\" in name:
+            messagebox.showwarning(
+                "Invalid name",
+                "Project name must not contain '/' or '\\'.",
+                parent=self,
+            )
+            return
+        # Check for duplicate before creating
+        if (get_projects_dir() / name).exists():
+            messagebox.showwarning(
+                "Already exists",
+                f"A project named '{name}' already exists.",
+                parent=self,
+            )
+            return
+        try:
+            create_project(name)
+        except OSError as exc:
+            messagebox.showerror("Error", str(exc), parent=self)
+            return
+
+        self._populate_projects()
+        # Select the newly created project in the listbox
+        items = self._project_listbox.get(0, "end")
+        try:
+            idx = list(items).index(name)
+            self._project_listbox.selection_clear(0, "end")
+            self._project_listbox.selection_set(idx)
+            self._project_listbox.see(idx)
+        except ValueError:
+            pass
+        self._new_name_var.set("")
+        self._update_ok_state()
+
+    def _on_open(self) -> None:
+        name = self._selected_project()
+        if name is None:
+            messagebox.showinfo("No selection", "Please select a project first.", parent=self)
+            return
+        self.result = name
+        self.grab_release()
+        self.destroy()
+
+    def _on_cancel(self) -> None:
+        self.result = None
+        self.grab_release()
+        self.destroy()
+
+    # ── Delete project ──────────────────────────────────────────────
+
+    def _on_delete_clicked(self) -> None:
+        """Confirm and recursively delete the selected project directory."""
+        name = self._selected_project()
+        if name is None:
+            return
+        if not self._confirm_delete(name):
+            return
+
+        project_path = get_projects_dir() / name
+        try:
+            shutil.rmtree(project_path)
+        except OSError as exc:
+            logger.warning("Failed to delete project %r", name, exc_info=True)
+            messagebox.showerror(
+                "Delete failed",
+                f"Could not delete project '{name}':\n\n{exc}",
+                parent=self,
+            )
+            return
+
+        self.deleted_names.append(name)
+        self._populate_projects()
+        self._update_ok_state()
+
+    def _confirm_delete(self, name: str) -> bool:
+        """Show a custom confirmation dialog; return True if user confirms.
+
+        The confirmation uses a capital-letters warning line and a
+        regular-text explanation that the deletion is recursive
+        (including any imported input databases).  Default focus is
+        Cancel so an accidental Enter doesn't trigger deletion.
+        """
+        dlg = tk.Toplevel(self)
+        dlg.title("Delete project")
+        dlg.transient(self)
+        dlg.grab_set()
+        dlg.resizable(False, False)
+
+        # Sizing — match the parent dialog's DPI-aware metric helper.
+        from flextool.gui.ui_metrics import get_metrics
+        _m = get_metrics(dlg)
+        cw, lh = _m.cw, _m.lh
+        wrap_px = cw * 60
+
+        confirmed = {"value": False}
+
+        body = ttk.Frame(dlg, padding=(cw * 2, lh))
+        body.pack(fill="both", expand=True)
+
+        warning_font = tkfont.Font(font="TkDefaultFont")
+        warning_font.configure(weight="bold", size=warning_font.cget("size") + 2)
+
+        ttk.Label(
+            body,
+            text="ALL PROJECT DATA WILL BE PERMANENTLY DELETED",
+            font=warning_font,
+            foreground="#b00020",
+            wraplength=wrap_px,
+            justify="left",
+        ).pack(anchor="w", pady=(0, lh))
+
+        ttk.Label(
+            body,
+            text=(
+                "This includes input databases (Excel, SQLite) that were "
+                "copied or imported into the project folder, as well as "
+                "all output results, plots, settings, and any other files "
+                "under the project directory."
+            ),
+            wraplength=wrap_px,
+            justify="left",
+        ).pack(anchor="w")
+
+        ttk.Label(
+            body,
+            text=f"Project: {name}",
+            wraplength=wrap_px,
+            justify="left",
+        ).pack(anchor="w", pady=(lh, 0))
+
+        # -- Buttons --
+        btn_row = ttk.Frame(dlg, padding=(cw * 2, 0, cw * 2, lh))
+        btn_row.pack(fill="x")
+
+        def _do_delete() -> None:
+            confirmed["value"] = True
+            dlg.grab_release()
+            dlg.destroy()
+
+        def _do_cancel() -> None:
+            confirmed["value"] = False
+            dlg.grab_release()
+            dlg.destroy()
+
+        # Try to use a danger style if the theme defines one; fall back
+        # silently to the default button style.
+        delete_btn = ttk.Button(btn_row, text="Delete", command=_do_delete)
+        try:
+            ttk.Style().configure("Danger.TButton", foreground="#b00020")
+            delete_btn.configure(style="Danger.TButton")
+        except tk.TclError:
+            pass
+        delete_btn.pack(side="left")
+
+        cancel_btn = ttk.Button(btn_row, text="Cancel", command=_do_cancel)
+        cancel_btn.pack(side="right")
+
+        dlg.protocol("WM_DELETE_WINDOW", _do_cancel)
+        dlg.bind("<Escape>", lambda _e: _do_cancel())
+        # Default focus = Cancel (defensive — Enter should not delete).
+        cancel_btn.focus_set()
+
+        # Centre on parent dialog.
+        dlg.update_idletasks()
+        px = self.winfo_rootx()
+        py = self.winfo_rooty()
+        pw = self.winfo_width()
+        ph = self.winfo_height()
+        w = dlg.winfo_width()
+        h = dlg.winfo_height()
+        x = px + (pw - w) // 2
+        y = py + (ph - h) // 2
+        dlg.geometry(f"+{x}+{y}")
+
+        self.wait_window(dlg)
+        return confirmed["value"]
+
+    # ── Inline rename ───────────────────────────────────────────────
+
+    def _start_inline_rename(self) -> None:
+        """Overlay an Entry widget on the selected listbox item for renaming."""
+        sel = self._project_listbox.curselection()
+        if not sel:
+            return
+        index = sel[0]
+        old_name = self._project_listbox.get(index)
+
+        # Cancel any previous rename entry
+        self._cancel_inline_rename()
+
+        # Position the entry over the listbox item
+        bbox = self._project_listbox.bbox(index)
+        if bbox is None:
+            return
+        x, y, width, height = bbox
+
+        entry = tk.Entry(self._project_listbox, width=0)
+        entry.place(x=x, y=y, width=max(width, self._project_listbox.winfo_width()), height=height)
+        entry.insert(0, old_name)
+        entry.select_range(0, "end")
+        entry.focus_set()
+
+        self._rename_entry = entry
+        self._rename_index = index
+        self._rename_old_name = old_name
+
+        entry.bind("<Return>", lambda _e: self._finish_inline_rename())
+        entry.bind("<Escape>", lambda _e: self._cancel_inline_rename())
+        entry.bind("<FocusOut>", lambda _e: self._cancel_inline_rename())
+
+    def _finish_inline_rename(self) -> None:
+        if self._rename_entry is None:
+            return
+        new_name = self._rename_entry.get().strip()
+        old_name = self._rename_old_name
+        self._rename_entry.destroy()
+        self._rename_entry = None
+
+        if not new_name or new_name == old_name:
+            return
+
+        try:
+            rename_project(old_name, new_name)
+        except FileExistsError:
+            messagebox.showwarning(
+                "Already exists",
+                f"A project named '{new_name}' already exists.",
+                parent=self,
+            )
+            return
+        except FileNotFoundError:
+            messagebox.showerror(
+                "Not found",
+                f"Project '{old_name}' no longer exists.",
+                parent=self,
+            )
+            return
+        except OSError as exc:
+            messagebox.showerror("Error", str(exc), parent=self)
+            return
+
+        self._populate_projects()
+        # Re-select the renamed project
+        items = self._project_listbox.get(0, "end")
+        try:
+            idx = list(items).index(new_name)
+            self._project_listbox.selection_clear(0, "end")
+            self._project_listbox.selection_set(idx)
+            self._project_listbox.see(idx)
+        except ValueError:
+            pass
+
+    def _cancel_inline_rename(self) -> None:
+        if self._rename_entry is not None:
+            self._rename_entry.destroy()
+            self._rename_entry = None

flextool/gui/dialogs/update_dialog.py

@@ -0,0 +1,212 @@
+"""Modal dialog for the in-app "Update FlexTool" action."""
+from __future__ import annotations
+
+import threading
+import tkinter as tk
+from collections.abc import Callable
+from tkinter import ttk
+
+
+class UpdateDialog(tk.Toplevel):
+    """Ask the user to confirm a FlexTool self-update.
+
+    Exposes these attributes after it closes:
+
+      - ``proceed`` -- ``True`` if the user clicked Update.
+      - ``include_toolbox`` -- ``True`` if Spine Toolbox should be installed
+        alongside FlexTool (the ``[toolbox]`` extra).
+      - ``check_on_startup`` -- the (possibly changed) "check for updates on
+        startup" preference; persisted whether or not the user updated.
+      - ``update_available`` -- the latest known availability (possibly
+        refreshed by the in-dialog Check button); ``None`` if never determined.
+
+    The **Update** button is disabled when we know there is no update; the
+    **Check** button re-queries on demand (useful when the startup check is
+    off) and re-enables Update if the situation changed.
+
+    Show it by constructing it and calling ``parent.wait_window(self)``.
+    """
+
+    def __init__(
+        self,
+        parent: tk.Misc,
+        *,
+        install_description: str,
+        is_git: bool,
+        default_toolbox: bool,
+        check_on_startup: bool,
+        update_available: bool | None,
+        check_fn: Callable[[], bool],
+        post_to_main: Callable[..., None],
+    ) -> None:
+        super().__init__(parent)
+        self.title("Update FlexTool")
+        self.transient(parent)
+        self.resizable(False, False)
+
+        self.proceed: bool = False
+        self.include_toolbox: bool = default_toolbox
+        self.check_on_startup: bool = check_on_startup
+        self.update_available: bool | None = update_available
+        self._initial_check_on_startup: bool = check_on_startup
+        self._check_fn = check_fn
+        self._post_to_main = post_to_main
+
+        self._toolbox_var = tk.BooleanVar(value=default_toolbox)
+        self._check_startup_var = tk.BooleanVar(value=check_on_startup)
+        self._status_var = tk.StringVar()
+
+        body = ttk.Frame(self, padding=16)
+        body.pack(fill="both", expand=True)
+
+        ttk.Label(
+            body,
+            text="Update FlexTool to the latest version.",
+            font=("TkDefaultFont", 11, "bold"),
+        ).pack(anchor="w")
+
+        method = (
+            "git pull + editable reinstall" if is_git else "pip upgrade from PyPI"
+        )
+        ttk.Label(
+            body,
+            text=f"Current install: {install_description}\nUpdate method: {method}.",
+            wraplength=440,
+            justify="left",
+        ).pack(anchor="w", pady=(8, 8))
+
+        ttk.Label(
+            body, textvariable=self._status_var, wraplength=440, justify="left",
+        ).pack(anchor="w", pady=(0, 8))
+
+        ttk.Checkbutton(
+            body, text="Install Spine Toolbox", variable=self._toolbox_var,
+        ).pack(anchor="w")
+        ttk.Label(
+            body,
+            text=(
+                "Spine Toolbox is a large optional dependency. It is required "
+                "to open .sqlite input sources in the Spine DB Editor. Leave "
+                "unchecked if you do not need it."
+            ),
+            wraplength=440,
+            justify="left",
+            foreground="#888888",
+        ).pack(anchor="w", padx=(24, 0), pady=(0, 8))
+
+        ttk.Label(
+            body,
+            text=(
+                "FlexTool must be restarted after an update. Progress is shown "
+                "in the Execution window."
+            ),
+            wraplength=440,
+            justify="left",
+        ).pack(anchor="w", pady=(0, 8))
+
+        ttk.Separator(body, orient="horizontal").pack(fill="x", pady=(0, 8))
+        ttk.Checkbutton(
+            body,
+            text="Check for updates on startup",
+            variable=self._check_startup_var,
+        ).pack(anchor="w", pady=(0, 8))
+
+        btns = ttk.Frame(body)
+        btns.pack(fill="x", pady=(4, 0))
+        # Check on the left; right-aligned left→right: Update | OK | Cancel.
+        # Update = save settings and upgrade; OK = save settings only; Cancel =
+        # close without changing anything.
+        self._check_btn = ttk.Button(btns, text="Check", command=self._on_check)
+        self._check_btn.pack(side="left")
+        ttk.Button(btns, text="Cancel", command=self._on_cancel).pack(side="right")
+        ttk.Button(btns, text="OK", command=self._on_ok).pack(
+            side="right", padx=(0, 8)
+        )
+        self._update_btn = ttk.Button(btns, text="Update", command=self._on_update)
+        self._update_btn.pack(side="right", padx=(0, 8))
+
+        self._render_availability()
+
+        self.protocol("WM_DELETE_WINDOW", self._on_cancel)
+        self.bind("<Escape>", lambda _e: self._on_cancel())
+
+        self.grab_set()
+        self.update_idletasks()
+        pw, ph = parent.winfo_width(), parent.winfo_height()
+        px, py = parent.winfo_rootx(), parent.winfo_rooty()
+        dw, dh = self.winfo_width(), self.winfo_height()
+        self.geometry(f"+{px + (pw - dw) // 2}+{py + (ph - dh) // 2}")
+
+    # ── Availability state ──────────────────────────────────────────
+
+    def _render_availability(self) -> None:
+        """Reflect ``update_available`` in the status label and Update button."""
+        if self.update_available is True:
+            self._status_var.set("Status: a newer version is available.")
+            self._set_update_enabled(True)
+        elif self.update_available is False:
+            self._status_var.set("Status: you are up to date.")
+            self._set_update_enabled(False)
+        else:
+            self._status_var.set(
+                "Status: not checked — click Check to look for updates."
+            )
+            self._set_update_enabled(True)
+
+    def _set_update_enabled(self, enabled: bool) -> None:
+        try:
+            self._update_btn.configure(state="normal" if enabled else "disabled")
+        except tk.TclError:
+            pass
+
+    def _on_check(self) -> None:
+        """Query for an update off the UI thread; update state when it returns."""
+        self._check_btn.configure(state="disabled")
+        self._status_var.set("Status: checking…")
+
+        def _worker() -> None:
+            try:
+                available = bool(self._check_fn())
+            except Exception:
+                available = False
+            self._post_to_main(self._apply_check_result, available)
+
+        threading.Thread(target=_worker, daemon=True).start()
+
+    def _apply_check_result(self, available: bool) -> None:
+        """Apply a Check result on the main thread."""
+        if not self.winfo_exists():
+            return
+        self.update_available = available
+        self._render_availability()
+        try:
+            self._check_btn.configure(state="normal")
+        except tk.TclError:
+            pass
+
+    # ── Button handlers ─────────────────────────────────────────────
+
+    def _on_update(self) -> None:
+        self.proceed = True
+        self.include_toolbox = bool(self._toolbox_var.get())
+        self.check_on_startup = bool(self._check_startup_var.get())
+        self._close()
+
+    def _on_ok(self) -> None:
+        """Save the settings (e.g. the startup-check toggle) without updating."""
+        self.proceed = False
+        self.check_on_startup = bool(self._check_startup_var.get())
+        self._close()
+
+    def _on_cancel(self) -> None:
+        """Close without applying any change (discard the toggle edits)."""
+        self.proceed = False
+        self.check_on_startup = self._initial_check_on_startup
+        self._close()
+
+    def _close(self) -> None:
+        try:
+            self.grab_release()
+        except tk.TclError:
+            pass
+        self.destroy()