talks-reducer 0.6.1__py3-none-any.whl → 0.7.0__py3-none-any.whl

talks_reducer/{gui.py → gui/__init__.py}

@@ -10,9 +10,7 @@ import re
 import subprocess
 import sys
 import threading
-import urllib.error
-import urllib.parse
-import urllib.request
+import time
 from pathlib import Path
 from typing import (
     TYPE_CHECKING,
@@ -30,14 +28,30 @@ if TYPE_CHECKING:
     from tkinter import filedialog, messagebox, ttk
 
 try:
-    from .cli import gather_input_files
-    from .cli import main as cli_main
-    from .discovery import discover_servers
-    from .ffmpeg import FFmpegNotFoundError
-    from .models import ProcessingOptions, default_temp_folder
-    from .pipeline import speed_up_video
-    from .progress import ProgressHandle, SignalProgressReporter
-    from .version_utils import resolve_version
+    from ..cli import gather_input_files
+    from ..cli import main as cli_main
+    from ..ffmpeg import FFmpegNotFoundError
+    from ..models import ProcessingOptions
+    from ..pipeline import ProcessingAborted, speed_up_video
+    from ..progress import ProgressHandle, SignalProgressReporter
+    from ..version_utils import resolve_version
+    from .preferences import GUIPreferences, determine_config_path
+    from .remote import (
+        check_remote_server_for_gui,
+        format_server_host,
+        normalize_server_url,
+        ping_server,
+        process_files_via_server,
+    )
+    from .theme import (
+        DARK_THEME,
+        LIGHT_THEME,
+        STATUS_COLORS,
+        apply_theme,
+        detect_system_theme,
+        read_windows_theme_registry,
+        run_defaults_command,
+    )
 except ImportError:  # pragma: no cover - handled at runtime
     if __package__ not in (None, ""):
         raise
@@ -48,10 +62,26 @@ except ImportError:  # pragma: no cover - handled at runtime
 
     from talks_reducer.cli import gather_input_files
     from talks_reducer.cli import main as cli_main
-    from talks_reducer.discovery import discover_servers
     from talks_reducer.ffmpeg import FFmpegNotFoundError
-    from talks_reducer.models import ProcessingOptions, default_temp_folder
-    from talks_reducer.pipeline import speed_up_video
+    from talks_reducer.gui.preferences import GUIPreferences, determine_config_path
+    from talks_reducer.gui.remote import (
+        check_remote_server_for_gui,
+        format_server_host,
+        normalize_server_url,
+        ping_server,
+        process_files_via_server,
+    )
+    from talks_reducer.gui.theme import (
+        DARK_THEME,
+        LIGHT_THEME,
+        STATUS_COLORS,
+        apply_theme,
+        detect_system_theme,
+        read_windows_theme_registry,
+        run_defaults_command,
+    )
+    from talks_reducer.models import ProcessingOptions
+    from talks_reducer.pipeline import ProcessingAborted, speed_up_video
     from talks_reducer.progress import ProgressHandle, SignalProgressReporter
     from talks_reducer.version_utils import resolve_version
 
@@ -133,42 +163,8 @@ except ModuleNotFoundError:  # pragma: no cover - runtime dependency
     TkinterDnD = None  # type: ignore[assignment]
 
 
-STATUS_COLORS = {
-    "idle": "#9ca3af",
-    "waiting": "#9ca3af",
-    "processing": "#af8e0e",
-    "success": "#178941",
-    "error": "#ad4f4f",
-    "aborted": "#6d727a",
-}
-
-LIGHT_THEME = {
-    "background": "#f5f5f5",
-    "foreground": "#1f2933",
-    "accent": "#2563eb",
-    "surface": "#ffffff",
-    "border": "#cbd5e1",
-    "hover": "#efefef",
-    "hover_text": "#000000",
-    "selection_background": "#2563eb",
-    "selection_foreground": "#ffffff",
-}
-
-DARK_THEME = {
-    "background": "#1e1e28",
-    "foreground": "#f3f4f6",
-    "accent": "#60a5fa",
-    "surface": "#2b2b3c",
-    "border": "#4b5563",
-    "hover": "#333333",
-    "hover_text": "#ffffff",
-    "selection_background": "#333333",
-    "selection_foreground": "#f3f4f6",
-}
-
-
-_TRAY_LOCK = threading.Lock()
-_TRAY_PROCESS: Optional[subprocess.Popen[Any]] = None
+from . import discovery as discovery_helpers
+from . import layout as layout_helpers
 
 
 def _default_remote_destination(input_file: Path, *, small: bool) -> Path:
@@ -190,34 +186,6 @@ def _default_remote_destination(input_file: Path, *, small: bool) -> Path:
     return input_file.with_name(new_name)
 
 
-def _ensure_server_tray_running(extra_args: Optional[Sequence[str]] = None) -> None:
-    """Start the server tray in a background process if one is not active."""
-
-    global _TRAY_PROCESS
-
-    with _TRAY_LOCK:
-        if _TRAY_PROCESS is not None and _TRAY_PROCESS.poll() is None:
-            return
-
-        package_name = __package__ or "talks_reducer"
-
-        if getattr(sys, "frozen", False):
-            command = [sys.executable, "--server"]
-        else:
-            command = [sys.executable, "-m", f"{package_name}.server_tray"]
-
-        if extra_args:
-            command.extend(extra_args)
-
-        try:
-            _TRAY_PROCESS = subprocess.Popen(command)
-        except Exception as exc:  # pragma: no cover - best-effort fallback
-            _TRAY_PROCESS = None
-            sys.stderr.write(
-                f"Warning: failed to launch Talks Reducer server tray: {exc}\n"
-            )
-
-
 def _parse_ratios_from_summary(summary: str) -> Tuple[Optional[float], Optional[float]]:
     """Extract time and size ratios from a Markdown *summary* string."""
 
@@ -288,9 +256,12 @@ class _TkProgressReporter(SignalProgressReporter):
         self,
         log_callback: Callable[[str], None],
         process_callback: Optional[Callable] = None,
+        *,
+        stop_callback: Optional[Callable[[], bool]] = None,
     ) -> None:
         self._log_callback = log_callback
         self.process_callback = process_callback
+        self._stop_callback = stop_callback
 
     def log(self, message: str) -> None:
         self._log_callback(message)
@@ -302,6 +273,13 @@ class _TkProgressReporter(SignalProgressReporter):
         del total, unit
         return _GuiProgressHandle(self._log_callback, desc)
 
+    def stop_requested(self) -> bool:
+        """Return ``True`` when the GUI has asked to cancel processing."""
+
+        if self._stop_callback is None:
+            return False
+        return bool(self._stop_callback())
+
 
 class TalksReducerGUI:
     """Tkinter application mirroring the CLI options with form controls."""
@@ -312,72 +290,14 @@ class TalksReducerGUI:
     MIN_AUDIO_INTERVAL_MS = 10
     DEFAULT_AUDIO_INTERVAL_MS = 200
 
-    def _determine_config_path(self) -> Path:
-        if sys.platform == "win32":
-            appdata = os.environ.get("APPDATA")
-            base = Path(appdata) if appdata else Path.home() / "AppData" / "Roaming"
-        elif sys.platform == "darwin":
-            base = Path.home() / "Library" / "Application Support"
-        else:
-            xdg_config = os.environ.get("XDG_CONFIG_HOME")
-            base = Path(xdg_config) if xdg_config else Path.home() / ".config"
-        return base / "talks-reducer" / "settings.json"
-
-    def _load_settings(self) -> dict[str, object]:
-        try:
-            with self._config_path.open("r", encoding="utf-8") as handle:
-                data = json.load(handle)
-            if isinstance(data, dict):
-                return data
-        except FileNotFoundError:
-            return {}
-        except (OSError, json.JSONDecodeError):
-            return {}
-        return {}
-
-    def _save_settings(self) -> None:
-        try:
-            self._config_path.parent.mkdir(parents=True, exist_ok=True)
-            with self._config_path.open("w", encoding="utf-8") as handle:
-                json.dump(self._settings, handle, indent=2, sort_keys=True)
-        except OSError:
-            pass
-
-    def _get_setting(self, key: str, default: object) -> object:
-        value = self._settings.get(key, default)
-        if key not in self._settings:
-            self._settings[key] = value
-        return value
-
-    def _get_float_setting(self, key: str, default: float) -> float:
-        """Return *key* as a float, coercing stored strings when necessary."""
-
-        raw_value = self._get_setting(key, default)
-        try:
-            number = float(raw_value)
-        except (TypeError, ValueError):
-            number = float(default)
-
-        if self._settings.get(key) != number:
-            self._settings[key] = number
-            self._save_settings()
-
-        return number
-
-    def _update_setting(self, key: str, value: object) -> None:
-        if self._settings.get(key) == value:
-            return
-        self._settings[key] = value
-        self._save_settings()
-
     def __init__(
         self,
         initial_inputs: Optional[Sequence[str]] = None,
         *,
         auto_run: bool = False,
     ) -> None:
-        self._config_path = self._determine_config_path()
-        self._settings = self._load_settings()
+        self._config_path = determine_config_path()
+        self.preferences = GUIPreferences(self._config_path)
 
         # Import tkinter here to avoid loading it at module import time
         import tkinter as tk
@@ -412,6 +332,8 @@ class TalksReducerGUI:
         self._last_output: Optional[Path] = None
         self._last_time_ratio: Optional[float] = None
         self._last_size_ratio: Optional[float] = None
+        self._last_progress_seconds: Optional[int] = None
+        self._run_start_time: Optional[float] = None
         self._status_state = "Idle"
         self.status_var = tk.StringVar(value=self._status_state)
         self._status_animation_job: Optional[str] = None
@@ -427,32 +349,34 @@ class TalksReducerGUI:
         self.progress_var = tk.IntVar(value=0)
         self._ffmpeg_process: Optional[subprocess.Popen] = None
         self._stop_requested = False
+        self._ping_worker_stop_requested = False
+        self._current_remote_mode = False
 
         self.input_files: List[str] = []
 
         self._dnd_available = TkinterDnD is not None and DND_FILES is not None
 
         self.simple_mode_var = tk.BooleanVar(
-            value=self._get_setting("simple_mode", True)
+            value=self.preferences.get("simple_mode", True)
         )
         self.run_after_drop_var = tk.BooleanVar(value=True)
-        self.small_var = tk.BooleanVar(value=self._get_setting("small_video", True))
+        self.small_var = tk.BooleanVar(value=self.preferences.get("small_video", True))
         self.open_after_convert_var = tk.BooleanVar(
-            value=self._get_setting("open_after_convert", True)
+            value=self.preferences.get("open_after_convert", True)
         )
-        stored_mode = str(self._get_setting("processing_mode", "local"))
+        stored_mode = str(self.preferences.get("processing_mode", "local"))
         if stored_mode not in {"local", "remote"}:
             stored_mode = "local"
         self.processing_mode_var = tk.StringVar(value=stored_mode)
         self.processing_mode_var.trace_add("write", self._on_processing_mode_change)
-        self.theme_var = tk.StringVar(value=self._get_setting("theme", "os"))
+        self.theme_var = tk.StringVar(value=self.preferences.get("theme", "os"))
         self.theme_var.trace_add("write", self._on_theme_change)
         self.small_var.trace_add("write", self._on_small_video_change)
         self.open_after_convert_var.trace_add(
             "write", self._on_open_after_convert_change
         )
         self.server_url_var = tk.StringVar(
-            value=str(self._get_setting("server_url", ""))
+            value=str(self.preferences.get("server_url", ""))
         )
         self.server_url_var.trace_add("write", self._on_server_url_change)
         self._discovery_thread: Optional[threading.Thread] = None
@@ -465,50 +389,38 @@ class TalksReducerGUI:
         self._build_layout()
         self._apply_simple_mode(initial=True)
         self._apply_status_style(self._status_state)
-        self._apply_theme()
-        self._save_settings()
+        self._refresh_theme()
+        self.preferences.save()
         self._hide_stop_button()
 
         # Ping server on startup if in remote mode
         if (
             self.processing_mode_var.get() == "remote"
             and self.server_url_var.get().strip()
-            and hasattr(self, "_ping_server")
         ):
             server_url = self.server_url_var.get().strip()
-            host_label = self._format_server_host(server_url)
 
             def ping_worker() -> None:
                 try:
-                    if self._ping_server(server_url):
-                        self._set_status("Idle", f"Server {host_label} is ready")
-                        self._notify(
-                            lambda: self._append_log(f"Server {host_label} ready")
-                        )
-                    else:
-                        self._set_status(
-                            "Error", f"Server {host_label} is not reachable"
-                        )
-                        self._notify(
-                            lambda: self._append_log(
-                                f"Server {host_label} is not reachable"
-                            )
-                        )
-                        ping_worker()
-                except Exception as exc:
-                    self._set_status(
-                        "Idle", f"Error pinging server {host_label}: {exc}"
+                    self._check_remote_server(
+                        server_url,
+                        success_status="Idle",
+                        waiting_status="Error",
+                        failure_status="Error",
+                        stop_check=lambda: self._ping_worker_stop_requested,
+                        switch_to_local_on_failure=True,
                     )
-                    self._notify(
-                        lambda: self._append_log(
-                            f"Error pinging server {host_label}: {exc}"
-                        )
+                except Exception as exc:  # pragma: no cover - defensive safeguard
+                    host_label = self._format_server_host(server_url)
+                    message = f"Error pinging server {host_label}: {exc}"
+                    self._schedule_on_ui_thread(
+                        lambda msg=message: self._append_log(msg)
+                    )
+                    self._schedule_on_ui_thread(
+                        lambda msg=message: self._set_status("Idle", msg)
                     )
 
-            import threading
-
-            ping_thread = threading.Thread(target=ping_worker, daemon=True)
-            ping_thread.start()
+            threading.Thread(target=ping_worker, daemon=True).start()
 
         if not self._dnd_available:
             self._append_log(
@@ -518,459 +430,144 @@ class TalksReducerGUI:
         if initial_inputs:
             self._populate_initial_inputs(initial_inputs, auto_run=auto_run)
 
-    # ------------------------------------------------------------------ UI --
-    def _apply_window_icon(self) -> None:
-        """Configure the application icon when the asset is available."""
-
-        base_path = Path(
-            getattr(sys, "_MEIPASS", Path(__file__).resolve().parent.parent)
-        )
-
-        icon_candidates: list[tuple[Path, str]] = []
-        if sys.platform.startswith("win"):
-            icon_candidates.append((base_path / "docs" / "assets" / "icon.ico", "ico"))
-        icon_candidates.append((base_path / "docs" / "assets" / "icon.png", "png"))
-
-        for icon_path, icon_type in icon_candidates:
-            if not icon_path.is_file():
-                continue
-
-            try:
-                if icon_type == "ico" and sys.platform.startswith("win"):
-                    # On Windows, iconbitmap works better without the 'default' parameter
-                    self.root.iconbitmap(str(icon_path))
-                else:
-                    self.root.iconphoto(False, self.tk.PhotoImage(file=str(icon_path)))
-                # If we got here without exception, icon was set successfully
-                return
-            except (self.tk.TclError, Exception) as e:
-                # Missing Tk image support or invalid icon format - try next candidate
-                continue
-
-    def _build_layout(self) -> None:
-        main = self.ttk.Frame(self.root, padding=self.PADDING)
-        main.grid(row=0, column=0, sticky="nsew")
-        self.root.columnconfigure(0, weight=1)
-        self.root.rowconfigure(0, weight=1)
-
-        # Input selection frame
-        input_frame = self.ttk.Frame(main, padding=self.PADDING)
-        input_frame.grid(row=0, column=0, sticky="nsew")
-        main.rowconfigure(0, weight=1)
-        main.columnconfigure(0, weight=1)
-        input_frame.columnconfigure(0, weight=1)
-        input_frame.rowconfigure(0, weight=1)
-
-        self.drop_zone = self.tk.Label(
-            input_frame,
-            text="Drop video here",
-            relief=self.tk.FLAT,
-            borderwidth=0,
-            padx=self.PADDING,
-            pady=self.PADDING,
-            highlightthickness=0,
-        )
-        self.drop_zone.grid(row=0, column=0, sticky="nsew")
-        self._configure_drop_targets(self.drop_zone)
-        self.drop_zone.configure(cursor="hand2", takefocus=1)
-        self.drop_zone.bind("<Button-1>", self._on_drop_zone_click)
-        self.drop_zone.bind("<Return>", self._on_drop_zone_click)
-        self.drop_zone.bind("<space>", self._on_drop_zone_click)
-
-        # Options frame
-        self.options_frame = self.ttk.Frame(main, padding=self.PADDING)
-        self.options_frame.grid(row=2, column=0, pady=(0, 0), sticky="ew")
-        self.options_frame.columnconfigure(0, weight=1)
-
-        checkbox_frame = self.ttk.Frame(self.options_frame)
-        checkbox_frame.grid(row=0, column=0, columnspan=2, sticky="w")
-
-        self.ttk.Checkbutton(
-            checkbox_frame,
-            text="Small video",
-            variable=self.small_var,
-        ).grid(row=0, column=0, sticky="w")
-
-        self.ttk.Checkbutton(
-            checkbox_frame,
-            text="Open after convert",
-            variable=self.open_after_convert_var,
-        ).grid(row=0, column=1, sticky="w", padx=(12, 0))
-
-        self.simple_mode_check = self.ttk.Checkbutton(
-            checkbox_frame,
-            text="Simple mode",
-            variable=self.simple_mode_var,
-            command=self._toggle_simple_mode,
-        )
-        self.simple_mode_check.grid(
-            row=1, column=0, columnspan=3, sticky="w", pady=(8, 0)
-        )
-
-        self.advanced_visible = self.tk.BooleanVar(value=False)
-
-        basic_label_container = self.ttk.Frame(self.options_frame)
-        basic_label = self.ttk.Label(basic_label_container, text="Basic options")
-        basic_label.pack(side=self.tk.LEFT)
-
-        self.reset_basic_button = self.ttk.Button(
-            basic_label_container,
-            text="Reset to defaults",
-            command=self._reset_basic_defaults,
-            state=self.tk.DISABLED,
-            style="Link.TButton",
-        )
-
-        self.basic_options_frame = self.ttk.Labelframe(
-            self.options_frame, padding=0, labelwidget=basic_label_container
-        )
-        self.basic_options_frame.grid(
-            row=2, column=0, columnspan=2, sticky="ew", pady=(12, 0)
-        )
-        self.basic_options_frame.columnconfigure(1, weight=1)
-
-        self._reset_button_visible = False
-
-        self.silent_speed_var = self.tk.DoubleVar(
-            value=min(max(self._get_float_setting("silent_speed", 4.0), 1.0), 10.0)
-        )
-        self._add_slider(
-            self.basic_options_frame,
-            "Silent speed",
-            self.silent_speed_var,
-            row=0,
-            setting_key="silent_speed",
-            minimum=1.0,
-            maximum=10.0,
-            resolution=0.5,
-            display_format="{:.1f}×",
-            default_value=4.0,
-        )
-
-        self.sounded_speed_var = self.tk.DoubleVar(
-            value=min(max(self._get_float_setting("sounded_speed", 1.0), 0.75), 2.0)
-        )
-        self._add_slider(
-            self.basic_options_frame,
-            "Sounded speed",
-            self.sounded_speed_var,
-            row=1,
-            setting_key="sounded_speed",
-            minimum=0.75,
-            maximum=2.0,
-            resolution=0.25,
-            display_format="{:.2f}×",
-            default_value=1.0,
-        )
-
-        self.silent_threshold_var = self.tk.DoubleVar(
-            value=min(max(self._get_float_setting("silent_threshold", 0.05), 0.0), 1.0)
-        )
-        self._add_slider(
-            self.basic_options_frame,
-            "Silent threshold",
-            self.silent_threshold_var,
-            row=2,
-            setting_key="silent_threshold",
-            minimum=0.0,
-            maximum=1.0,
-            resolution=0.01,
-            display_format="{:.2f}",
-            default_value=0.05,
-        )
-
-        self.ttk.Label(self.basic_options_frame, text="Server URL").grid(
-            row=3, column=0, sticky="w", pady=4
-        )
-        stored_server_url = str(
-            self._get_setting("server_url", "http://localhost:9005")
-        )
-        if not stored_server_url:
-            stored_server_url = "http://localhost:9005"
-            self._update_setting("server_url", stored_server_url)
-        self.server_url_var.set(stored_server_url)
-        self.server_url_entry = self.ttk.Entry(
-            self.basic_options_frame, textvariable=self.server_url_var, width=30
-        )
-        self.server_url_entry.grid(row=3, column=1, sticky="w", pady=4)
-        self.server_discover_button = self.ttk.Button(
-            self.basic_options_frame, text="Discover", command=self._start_discovery
-        )
-        self.server_discover_button.grid(row=3, column=2, padx=(8, 0))
-
-        self.ttk.Label(self.basic_options_frame, text="Processing mode").grid(
-            row=4, column=0, sticky="w", pady=4
-        )
-        mode_choice = self.ttk.Frame(self.basic_options_frame)
-        mode_choice.grid(row=4, column=1, columnspan=2, sticky="w", pady=4)
-        self.ttk.Radiobutton(
-            mode_choice,
-            text="Local",
-            value="local",
-            variable=self.processing_mode_var,
-        ).pack(side=self.tk.LEFT, padx=(0, 8))
-        self.remote_mode_button = self.ttk.Radiobutton(
-            mode_choice,
-            text="Remote",
-            value="remote",
-            variable=self.processing_mode_var,
-        )
-        self.remote_mode_button.pack(side=self.tk.LEFT, padx=(0, 8))
-
-        self.ttk.Label(self.basic_options_frame, text="Theme").grid(
-            row=5, column=0, sticky="w", pady=(8, 0)
-        )
-        theme_choice = self.ttk.Frame(self.basic_options_frame)
-        theme_choice.grid(row=5, column=1, columnspan=2, sticky="w", pady=(8, 0))
-        for value, label in ("os", "OS"), ("light", "Light"), ("dark", "Dark"):
-            self.ttk.Radiobutton(
-                theme_choice,
-                text=label,
-                value=value,
-                variable=self.theme_var,
-                command=self._apply_theme,
-            ).pack(side=self.tk.LEFT, padx=(0, 8))
-
-        self.advanced_button = self.ttk.Button(
-            self.options_frame,
-            text="Advanced",
-            command=self._toggle_advanced,
-        )
-        self.advanced_button.grid(
-            row=3, column=0, columnspan=2, sticky="w", pady=(12, 0)
-        )
-
-        self.advanced_frame = self.ttk.Frame(self.options_frame, padding=0)
-        self.advanced_frame.grid(row=4, column=0, columnspan=2, sticky="nsew")
-        self.advanced_frame.columnconfigure(1, weight=1)
-
-        self.output_var = self.tk.StringVar()
-        self._add_entry(
-            self.advanced_frame, "Output file", self.output_var, row=0, browse=True
-        )
-
-        self.temp_var = self.tk.StringVar(value=str(default_temp_folder()))
-        self._add_entry(
-            self.advanced_frame, "Temp folder", self.temp_var, row=1, browse=True
-        )
+    def _start_run(self) -> None:
+        if self._processing_thread and self._processing_thread.is_alive():
+            self.messagebox.showinfo("Processing", "A job is already running.")
+            return
 
-        self.sample_rate_var = self.tk.StringVar(value="48000")
-        self._add_entry(self.advanced_frame, "Sample rate", self.sample_rate_var, row=2)
+        if not self.input_files:
+            self.messagebox.showwarning(
+                "Missing input", "Please add at least one file or folder."
+            )
+            return
 
-        frame_margin_setting = self._get_setting("frame_margin", 2)
         try:
-            frame_margin_default = int(frame_margin_setting)
-        except (TypeError, ValueError):
-            frame_margin_default = 2
-            self._update_setting("frame_margin", frame_margin_default)
+            args = self._collect_arguments()
+        except ValueError as exc:
+            self.messagebox.showerror("Invalid value", str(exc))
+            return
 
-        self.frame_margin_var = self.tk.StringVar(value=str(frame_margin_default))
-        self._add_entry(
-            self.advanced_frame, "Frame margin", self.frame_margin_var, row=3
-        )
+        self._append_log("Starting processing…")
+        self._stop_requested = False
+        self.stop_button.configure(text="Stop")
+        self._run_start_time = time.monotonic()
+        self._ping_worker_stop_requested = True
+        open_after_convert = bool(self.open_after_convert_var.get())
+        server_url = self.server_url_var.get().strip()
+        remote_mode = self.processing_mode_var.get() == "remote"
+        if remote_mode and not server_url:
+            self.messagebox.showerror(
+                "Missing server URL", "Remote mode requires a server URL."
+            )
+        remote_mode = remote_mode and bool(server_url)
 
-        self._toggle_advanced(initial=True)
-        self._update_processing_mode_state()
-        self._update_basic_reset_state()
-
-        # Action buttons and log output
-        status_frame = self.ttk.Frame(main, padding=self.PADDING)
-        status_frame.grid(row=1, column=0, sticky="ew")
-        status_frame.columnconfigure(0, weight=0)
-        status_frame.columnconfigure(1, weight=1)
-        status_frame.columnconfigure(2, weight=0)
-        self.status_frame = status_frame
-
-        self.ttk.Label(status_frame, text="Status:").grid(row=0, column=0, sticky="w")
-        self.status_label = self.tk.Label(
-            status_frame, textvariable=self.status_var, anchor="e"
-        )
-        self.status_label.grid(row=0, column=1, sticky="e")
-
-        # Progress bar
-        self.progress_bar = self.ttk.Progressbar(
-            status_frame,
-            variable=self.progress_var,
-            maximum=100,
-            mode="determinate",
-            style="Idle.Horizontal.TProgressbar",
-        )
-        self.progress_bar.grid(row=1, column=0, columnspan=3, sticky="ew", pady=(0, 0))
+        # Store remote_mode for use after thread starts
+        self._current_remote_mode = remote_mode
 
-        self.stop_button = self.ttk.Button(
-            status_frame, text="Stop", command=self._stop_processing
-        )
-        self.stop_button.grid(
-            row=2, column=0, columnspan=3, sticky="ew", pady=self.PADDING
-        )
-        self.stop_button.grid_remove()  # Hidden by default
+        def worker() -> None:
+            def set_process(proc: subprocess.Popen) -> None:
+                self._ffmpeg_process = proc
 
-        self.open_button = self.ttk.Button(
-            status_frame,
-            text="Open last",
-            command=self._open_last_output,
-            state=self.tk.DISABLED,
-        )
-        self.open_button.grid(
-            row=2, column=0, columnspan=3, sticky="ew", pady=self.PADDING
-        )
-        self.open_button.grid_remove()
+            try:
+                files = gather_input_files(self.input_files)
+                if not files:
+                    self._schedule_on_ui_thread(
+                        lambda: self.messagebox.showwarning(
+                            "No files", "No supported media files were found."
+                        )
+                    )
+                    self._set_status("Idle")
+                    return
 
-        # Button shown when no other action buttons are visible
-        self.drop_hint_button = self.ttk.Button(
-            status_frame,
-            text="Drop video to convert",
-            state=self.tk.DISABLED,
-        )
-        self.drop_hint_button.grid(
-            row=2, column=0, columnspan=3, sticky="ew", pady=self.PADDING
-        )
-        self.drop_hint_button.grid_remove()  # Hidden by default
-        self._configure_drop_targets(self.drop_hint_button)
+                if self._current_remote_mode:
+                    success = self._process_files_via_server(
+                        files,
+                        args,
+                        server_url,
+                        open_after_convert=open_after_convert,
+                    )
+                    if success:
+                        self._schedule_on_ui_thread(self._hide_stop_button)
+                        return
+                    # If server processing failed, fall back to local processing
+                    # The _process_files_via_server function already switched to local mode
+                    # Update remote_mode variable to reflect the change
+                    self._current_remote_mode = False
 
-        self.log_frame = self.ttk.Frame(main, padding=self.PADDING)
-        self.log_frame.grid(row=3, column=0, pady=(16, 0), sticky="nsew")
-        main.rowconfigure(4, weight=1)
-        self.log_frame.columnconfigure(0, weight=1)
-        self.log_frame.rowconfigure(0, weight=1)
+                reporter = _TkProgressReporter(
+                    self._append_log,
+                    process_callback=set_process,
+                    stop_callback=lambda: self._stop_requested,
+                )
+                for index, file in enumerate(files, start=1):
+                    self._append_log(f"Processing: {os.path.basename(file)}")
+                    options = self._create_processing_options(Path(file), args)
+                    result = speed_up_video(options, reporter=reporter)
+                    self._last_output = result.output_file
+                    self._last_time_ratio = result.time_ratio
+                    self._last_size_ratio = result.size_ratio
 
-        self.log_text = self.tk.Text(
-            self.log_frame, wrap="word", height=10, state=self.tk.DISABLED
-        )
-        self.log_text.grid(row=0, column=0, sticky="nsew")
-        log_scroll = self.ttk.Scrollbar(
-            self.log_frame, orient=self.tk.VERTICAL, command=self.log_text.yview
-        )
-        log_scroll.grid(row=0, column=1, sticky="ns")
-        self.log_text.configure(yscrollcommand=log_scroll.set)
+                    # Create completion message with ratios if available
+                    completion_msg = f"Completed: {result.output_file}"
+                    if result.time_ratio is not None and result.size_ratio is not None:
+                        completion_msg += f" (Time: {result.time_ratio:.2%}, Size: {result.size_ratio:.2%})"
 
-    def _add_entry(
-        self,
-        parent,  # type: tk.Misc
-        label: str,
-        variable,  # type: tk.StringVar
-        *,
-        row: int,
-        browse: bool = False,
-    ) -> None:
-        self.ttk.Label(parent, text=label).grid(row=row, column=0, sticky="w", pady=4)
-        entry = self.ttk.Entry(parent, textvariable=variable)
-        entry.grid(row=row, column=1, sticky="ew", pady=4)
-        if browse:
-            button = self.ttk.Button(
-                parent,
-                text="Browse",
-                command=lambda var=variable: self._browse_path(var, label),
-            )
-            button.grid(row=row, column=2, padx=(8, 0))
+                    self._append_log(completion_msg)
+                    if open_after_convert:
+                        self._schedule_on_ui_thread(
+                            lambda path=result.output_file: self._open_in_file_manager(
+                                path
+                            )
+                        )
 
-    def _add_slider(
-        self,
-        parent,  # type: tk.Misc
-        label: str,
-        variable,  # type: tk.DoubleVar
-        *,
-        row: int,
-        setting_key: str,
-        minimum: float,
-        maximum: float,
-        resolution: float,
-        display_format: str,
-        default_value: float,
-    ) -> None:
-        self.ttk.Label(parent, text=label).grid(row=row, column=0, sticky="w", pady=4)
-
-        value_label = self.ttk.Label(parent)
-        value_label.grid(row=row, column=2, sticky="e", pady=4)
-
-        def update(value: str) -> None:
-            numeric = float(value)
-            clamped = max(minimum, min(maximum, numeric))
-            steps = round((clamped - minimum) / resolution)
-            quantized = minimum + steps * resolution
-            if abs(variable.get() - quantized) > 1e-9:
-                variable.set(quantized)
-            value_label.configure(text=display_format.format(quantized))
-            self._update_setting(setting_key, float(f"{quantized:.6f}"))
-            self._update_basic_reset_state()
-
-        slider = self.tk.Scale(
-            parent,
-            variable=variable,
-            from_=minimum,
-            to=maximum,
-            orient=self.tk.HORIZONTAL,
-            resolution=resolution,
-            showvalue=False,
-            command=update,
-            length=240,
-            highlightthickness=0,
-        )
-        slider.grid(row=row, column=1, sticky="ew", pady=4, padx=(0, 8))
+                self._append_log("All jobs finished successfully.")
+                self._schedule_on_ui_thread(
+                    lambda: self.open_button.configure(state=self.tk.NORMAL)
+                )
+                self._schedule_on_ui_thread(self._clear_input_files)
+            except FFmpegNotFoundError as exc:
+                self._schedule_on_ui_thread(
+                    lambda: self.messagebox.showerror("FFmpeg not found", str(exc))
+                )
+                self._set_status("Error")
+            except ProcessingAborted:
+                self._append_log("Processing aborted by user.")
+                self._set_status("Aborted")
+            except Exception as exc:  # pragma: no cover - GUI level safeguard
+                # If stop was requested, don't show error (FFmpeg termination is expected)
+                if self._stop_requested:
+                    self._append_log("Processing aborted by user.")
+                    self._set_status("Aborted")
+                else:
+                    error_msg = f"Processing failed: {exc}"
+                    self._append_log(error_msg)
+                    print(error_msg, file=sys.stderr)  # Also output to console
+                    self._schedule_on_ui_thread(
+                        lambda: self.messagebox.showerror("Error", error_msg)
+                    )
+                    self._set_status("Error")
+            finally:
+                self._run_start_time = None
+                self._schedule_on_ui_thread(self._hide_stop_button)
 
-        update(str(variable.get()))
+        self._processing_thread = threading.Thread(target=worker, daemon=True)
+        self._processing_thread.start()
 
-        self._slider_updaters[setting_key] = update
-        self._basic_defaults[setting_key] = default_value
-        self._basic_variables[setting_key] = variable
-        variable.trace_add("write", lambda *_: self._update_basic_reset_state())
-        self._sliders.append(slider)
+        # Show Stop button when processing starts regardless of mode
+        self.stop_button.grid()
 
-    def _update_basic_reset_state(self) -> None:
-        """Enable or disable the reset control based on slider values."""
+    # ------------------------------------------------------------------ UI --
+    def _apply_window_icon(self) -> None:
+        layout_helpers.apply_window_icon(self)
 
-        if not hasattr(self, "reset_basic_button"):
-            return
+    def _build_layout(self) -> None:
+        layout_helpers.build_layout(self)
 
-        should_enable = False
-        for key, default_value in self._basic_defaults.items():
-            variable = self._basic_variables.get(key)
-            if variable is None:
-                continue
-            try:
-                current_value = float(variable.get())
-            except (TypeError, ValueError):
-                should_enable = True
-                break
-            if abs(current_value - default_value) > 1e-9:
-                should_enable = True
-                break
-
-        if should_enable:
-            if not getattr(self, "_reset_button_visible", False):
-                self.reset_basic_button.pack(side=self.tk.LEFT, padx=(8, 0))
-                self._reset_button_visible = True
-            self.reset_basic_button.configure(state=self.tk.NORMAL)
-        else:
-            if getattr(self, "_reset_button_visible", False):
-                self.reset_basic_button.pack_forget()
-                self._reset_button_visible = False
-            self.reset_basic_button.configure(state=self.tk.DISABLED)
+    def _update_basic_reset_state(self) -> None:
+        layout_helpers.update_basic_reset_state(self)
 
     def _reset_basic_defaults(self) -> None:
-        """Restore the basic numeric controls to their default values."""
-
-        for key, default_value in self._basic_defaults.items():
-            variable = self._basic_variables.get(key)
-            if variable is None:
-                continue
-
-            try:
-                current_value = float(variable.get())
-            except (TypeError, ValueError):
-                current_value = default_value
-
-            if abs(current_value - default_value) <= 1e-9:
-                continue
-
-            variable.set(default_value)
-            updater = self._slider_updaters.get(key)
-            if updater is not None:
-                updater(str(default_value))
-            else:
-                self._update_setting(key, float(f"{default_value:.6f}"))
-
-        self._update_basic_reset_state()
+        layout_helpers.reset_basic_defaults(self)
 
     def _update_processing_mode_state(self) -> None:
         has_url = bool(self.server_url_var.get().strip())
@@ -983,202 +580,76 @@ class TalksReducerGUI:
             self.remote_mode_button.configure(state=state)
 
     def _normalize_server_url(self, server_url: str) -> str:
-        parsed = urllib.parse.urlsplit(server_url)
-        if not parsed.scheme:
-            parsed = urllib.parse.urlsplit(f"http://{server_url}")
-
-        netloc = parsed.netloc or parsed.path
-        if not netloc:
-            return server_url
-
-        path = parsed.path if parsed.netloc else ""
-        normalized_path = path or "/"
-        return urllib.parse.urlunsplit((parsed.scheme, netloc, normalized_path, "", ""))
+        return normalize_server_url(server_url)
 
     def _format_server_host(self, server_url: str) -> str:
-        parsed = urllib.parse.urlsplit(server_url)
-        if not parsed.scheme:
-            parsed = urllib.parse.urlsplit(f"http://{server_url}")
-
-        host = parsed.netloc or parsed.path or server_url
-        if parsed.netloc and parsed.path and parsed.path not in {"", "/"}:
-            host = f"{parsed.netloc}{parsed.path}"
-
-        host = host.rstrip("/").split(":")[0]
-        return host or server_url
+        return format_server_host(server_url)
 
-    def _ping_server(self, server_url: str, *, timeout: float = 5.0) -> bool:
-        normalized = self._normalize_server_url(server_url)
-        request = urllib.request.Request(
-            normalized,
-            headers={"User-Agent": "talks-reducer-gui"},
-            method="GET",
+    def _check_remote_server(
+        self,
+        server_url: str,
+        *,
+        success_status: str,
+        waiting_status: str,
+        failure_status: str,
+        success_message: Optional[str] = None,
+        waiting_message_template: str = "Waiting server {host} (attempt {attempt}/{max_attempts})",
+        failure_message: Optional[str] = None,
+        stop_check: Optional[Callable[[], bool]] = None,
+        on_stop: Optional[Callable[[], None]] = None,
+        switch_to_local_on_failure: bool = False,
+        alert_on_failure: bool = False,
+        warning_title: str = "Server unavailable",
+        warning_message: Optional[str] = None,
+        max_attempts: int = 5,
+        delay: float = 1.0,
+    ) -> bool:
+        return check_remote_server_for_gui(
+            self,
+            server_url,
+            success_status=success_status,
+            waiting_status=waiting_status,
+            failure_status=failure_status,
+            success_message=success_message,
+            waiting_message_template=waiting_message_template,
+            failure_message=failure_message,
+            stop_check=stop_check,
+            on_stop=on_stop,
+            switch_to_local_on_failure=switch_to_local_on_failure,
+            alert_on_failure=alert_on_failure,
+            warning_title=warning_title,
+            warning_message=warning_message,
+            max_attempts=max_attempts,
+            delay=delay,
         )
 
-        try:
-            with urllib.request.urlopen(request, timeout=timeout) as response:
-                status = getattr(response, "status", None)
-                if status is None:
-                    status = response.getcode()
-                if status is None:
-                    return False
-                return 200 <= int(status) < 500
-        except (urllib.error.URLError, ValueError):
-            return False
+    def _ping_server(self, server_url: str, *, timeout: float = 5.0) -> bool:
+        return ping_server(server_url, timeout=timeout)
 
     def _start_discovery(self) -> None:
-        """Search the local network for running Talks Reducer servers."""
-
-        if self._discovery_thread and self._discovery_thread.is_alive():
-            return
-
-        self.server_discover_button.configure(
-            state=self.tk.DISABLED, text="Discovering…"
-        )
-        self._append_log("Discovering Talks Reducer servers on port 9005…")
-
-        def worker() -> None:
-            try:
-                urls = discover_servers(
-                    progress_callback=lambda current, total: self._notify(
-                        lambda c=current, t=total: self._on_discovery_progress(c, t)
-                    )
-                )
-            except Exception as exc:  # pragma: no cover - network failure safeguard
-                self._notify(lambda: self._on_discovery_failed(exc))
-                return
-            self._notify(lambda: self._on_discovery_complete(urls))
-
-        self._discovery_thread = threading.Thread(target=worker, daemon=True)
-        self._discovery_thread.start()
+        discovery_helpers.start_discovery(self)
 
     def _on_discovery_failed(self, exc: Exception) -> None:
-        self.server_discover_button.configure(state=self.tk.NORMAL, text="Discover")
-        message = f"Discovery failed: {exc}"
-        self._append_log(message)
-        self.messagebox.showerror("Discovery failed", message)
+        discovery_helpers.on_discovery_failed(self, exc)
 
     def _on_discovery_progress(self, current: int, total: int) -> None:
-        if total > 0:
-            bounded = max(0, min(current, total))
-            label = f"{bounded} / {total}"
-        else:
-            label = "Discovering…"
-        self.server_discover_button.configure(text=label)
+        discovery_helpers.on_discovery_progress(self, current, total)
 
     def _on_discovery_complete(self, urls: List[str]) -> None:
-        self.server_discover_button.configure(state=self.tk.NORMAL, text="Discover")
-        if not urls:
-            self._append_log("No Talks Reducer servers were found.")
-            self.messagebox.showinfo(
-                "No servers found",
-                "No Talks Reducer servers responded on port 9005.",
-            )
-            return
-
-        self._append_log(
-            f"Discovered {len(urls)} server{'s' if len(urls) != 1 else ''}."
-        )
-
-        if len(urls) == 1:
-            self.server_url_var.set(urls[0])
-            return
-
-        self._show_discovery_results(urls)
+        discovery_helpers.on_discovery_complete(self, urls)
 
     def _show_discovery_results(self, urls: List[str]) -> None:
-        dialog = self.tk.Toplevel(self.root)
-        dialog.title("Select server")
-        dialog.transient(self.root)
-        dialog.grab_set()
-
-        self.ttk.Label(dialog, text="Select a Talks Reducer server:").grid(
-            row=0, column=0, columnspan=2, sticky="w", padx=self.PADDING, pady=(12, 4)
-        )
-
-        listbox = self.tk.Listbox(
-            dialog,
-            height=min(10, len(urls)),
-            selectmode=self.tk.SINGLE,
-        )
-        listbox.grid(
-            row=1,
-            column=0,
-            columnspan=2,
-            padx=self.PADDING,
-            sticky="nsew",
-        )
-        dialog.columnconfigure(0, weight=1)
-        dialog.columnconfigure(1, weight=1)
-        dialog.rowconfigure(1, weight=1)
-
-        for url in urls:
-            listbox.insert(self.tk.END, url)
-        listbox.select_set(0)
-
-        def choose(_: object | None = None) -> None:
-            selection = listbox.curselection()
-            if not selection:
-                return
-            index = selection[0]
-            self.server_url_var.set(urls[index])
-            dialog.grab_release()
-            dialog.destroy()
-
-        def cancel() -> None:
-            dialog.grab_release()
-            dialog.destroy()
-
-        listbox.bind("<Double-Button-1>", choose)
-        listbox.bind("<Return>", choose)
-
-        button_frame = self.ttk.Frame(dialog)
-        button_frame.grid(row=2, column=0, columnspan=2, pady=(8, 12))
-        self.ttk.Button(button_frame, text="Use server", command=choose).pack(
-            side=self.tk.LEFT, padx=(0, 8)
-        )
-        self.ttk.Button(button_frame, text="Cancel", command=cancel).pack(
-            side=self.tk.LEFT
-        )
-        dialog.protocol("WM_DELETE_WINDOW", cancel)
+        discovery_helpers.show_discovery_results(self, urls)
 
     def _toggle_simple_mode(self) -> None:
-        self._update_setting("simple_mode", self.simple_mode_var.get())
+        self.preferences.update("simple_mode", self.simple_mode_var.get())
         self._apply_simple_mode()
 
     def _apply_simple_mode(self, *, initial: bool = False) -> None:
-        simple = self.simple_mode_var.get()
-        if simple:
-            self.basic_options_frame.grid_remove()
-            self.log_frame.grid_remove()
-            self.stop_button.grid_remove()
-            self.advanced_button.grid_remove()
-            self.advanced_frame.grid_remove()
-            self.run_after_drop_var.set(True)
-            self._apply_window_size(simple=True)
-        else:
-            self.basic_options_frame.grid()
-            self.log_frame.grid()
-            self.advanced_button.grid()
-            if self.advanced_visible.get():
-                self.advanced_frame.grid()
-            self._apply_window_size(simple=False)
-
-        if initial and simple:
-            # Ensure the hidden widgets do not retain focus outlines on start.
-            self.drop_zone.focus_set()
+        layout_helpers.apply_simple_mode(self, initial=initial)
 
     def _apply_window_size(self, *, simple: bool) -> None:
-        width, height = self._simple_size if simple else self._full_size
-        self.root.update_idletasks()
-        self.root.minsize(width, height)
-        if simple:
-            self.root.geometry(f"{width}x{height}")
-        else:
-            current_width = self.root.winfo_width()
-            current_height = self.root.winfo_height()
-            if current_width < width or current_height < height:
-                self.root.geometry(f"{width}x{height}")
+        layout_helpers.apply_window_size(self, simple=simple)
 
     def _toggle_advanced(self, *, initial: bool = False) -> None:
         if not initial:
@@ -1192,14 +663,14 @@ class TalksReducerGUI:
             self.advanced_button.configure(text="Advanced")
 
     def _on_theme_change(self, *_: object) -> None:
-        self._update_setting("theme", self.theme_var.get())
-        self._apply_theme()
+        self.preferences.update("theme", self.theme_var.get())
+        self._refresh_theme()
 
     def _on_small_video_change(self, *_: object) -> None:
-        self._update_setting("small_video", bool(self.small_var.get()))
+        self.preferences.update("small_video", bool(self.small_var.get()))
 
     def _on_open_after_convert_change(self, *_: object) -> None:
-        self._update_setting(
+        self.preferences.update(
             "open_after_convert", bool(self.open_after_convert_var.get())
         )
 
@@ -1208,216 +679,63 @@ class TalksReducerGUI:
         if value not in {"local", "remote"}:
             self.processing_mode_var.set("local")
             return
-        self._update_setting("processing_mode", value)
+        self.preferences.update("processing_mode", value)
         self._update_processing_mode_state()
 
+        if self.processing_mode_var.get() == "remote":
+            server_url = self.server_url_var.get().strip()
+            if not server_url:
+                return
+
+            def ping_remote_mode() -> None:
+                self._check_remote_server(
+                    server_url,
+                    success_status="Idle",
+                    waiting_status="Error",
+                    failure_status="Error",
+                    failure_message="Server {host} is unreachable. Switching to local mode.",
+                    switch_to_local_on_failure=True,
+                    alert_on_failure=True,
+                    warning_message="Server {host} is unreachable. Switching to local mode.",
+                )
+
+            threading.Thread(target=ping_remote_mode, daemon=True).start()
+
     def _on_server_url_change(self, *_: object) -> None:
         value = self.server_url_var.get().strip()
-        self._update_setting("server_url", value)
+        self.preferences.update("server_url", value)
         self._update_processing_mode_state()
 
-    def _apply_theme(self) -> None:
+    def _resolve_theme_mode(self) -> str:
         preference = self.theme_var.get().lower()
         if preference not in {"light", "dark"}:
-            mode = self._detect_system_theme()
-        else:
-            mode = preference
-
-        palette = LIGHT_THEME if mode == "light" else DARK_THEME
-
-        self.root.configure(bg=palette["background"])
-        self.style.theme_use("clam")
-        self.style.configure(
-            ".", background=palette["background"], foreground=palette["foreground"]
-        )
-        self.style.configure("TFrame", background=palette["background"])
-        self.style.configure(
-            "TLabelframe",
-            background=palette["background"],
-            foreground=palette["foreground"],
-            borderwidth=0,
-            relief="flat",
-        )
-        self.style.configure(
-            "TLabelframe.Label",
-            background=palette["background"],
-            foreground=palette["foreground"],
-        )
-        self.style.configure(
-            "TLabel", background=palette["background"], foreground=palette["foreground"]
-        )
-        self.style.configure(
-            "TCheckbutton",
-            background=palette["background"],
-            foreground=palette["foreground"],
-        )
-        self.style.map(
-            "TCheckbutton",
-            background=[("active", palette.get("hover", palette["background"]))],
-        )
-        self.style.configure(
-            "TRadiobutton",
-            background=palette["background"],
-            foreground=palette["foreground"],
-        )
-        self.style.map(
-            "TRadiobutton",
-            background=[("active", palette.get("hover", palette["background"]))],
-        )
-        self.style.configure(
-            "Link.TButton",
-            background=palette["background"],
-            foreground=palette["accent"],
-            borderwidth=0,
-            relief="flat",
-            highlightthickness=0,
-            padding=2,
-            font=("TkDefaultFont", 8, "underline"),
-        )
-        self.style.map(
-            "Link.TButton",
-            background=[
-                ("active", palette.get("hover", palette["background"])),
-                ("disabled", palette["background"]),
-            ],
-            foreground=[
-                ("active", palette.get("accent", palette["foreground"])),
-                ("disabled", palette["foreground"]),
-            ],
-        )
-        self.style.configure(
-            "TButton",
-            background=palette["surface"],
-            foreground=palette["foreground"],
-            padding=4,
-            font=("TkDefaultFont", 8),
-        )
-        self.style.map(
-            "TButton",
-            background=[
-                ("active", palette.get("hover", palette["accent"])),
-                ("disabled", palette["surface"]),
-            ],
-            foreground=[
-                ("active", palette.get("hover_text", "#000000")),
-                ("disabled", palette["foreground"]),
-            ],
-        )
-        self.style.configure(
-            "TEntry",
-            fieldbackground=palette["surface"],
-            foreground=palette["foreground"],
-        )
-        self.style.configure(
-            "TCombobox",
-            fieldbackground=palette["surface"],
-            foreground=palette["foreground"],
-        )
-
-        # Configure progress bar styles for different states
-        self.style.configure(
-            "Idle.Horizontal.TProgressbar",
-            background=STATUS_COLORS["idle"],
-            troughcolor=palette["surface"],
-            borderwidth=0,
-            thickness=20,
-        )
-        self.style.configure(
-            "Processing.Horizontal.TProgressbar",
-            background=STATUS_COLORS["processing"],
-            troughcolor=palette["surface"],
-            borderwidth=0,
-            thickness=20,
-        )
-        self.style.configure(
-            "Success.Horizontal.TProgressbar",
-            background=STATUS_COLORS["success"],
-            troughcolor=palette["surface"],
-            borderwidth=0,
-            thickness=20,
-        )
-        self.style.configure(
-            "Error.Horizontal.TProgressbar",
-            background=STATUS_COLORS["error"],
-            troughcolor=palette["surface"],
-            borderwidth=0,
-            thickness=20,
-        )
-        self.style.configure(
-            "Aborted.Horizontal.TProgressbar",
-            background=STATUS_COLORS["aborted"],
-            troughcolor=palette["surface"],
-            borderwidth=0,
-            thickness=20,
-        )
-
-        self.drop_zone.configure(
-            bg=palette["surface"],
-            fg=palette["foreground"],
-            highlightthickness=0,
-        )
-
-        slider_relief = self.tk.FLAT if mode == "dark" else self.tk.RAISED
-        active_background = (
-            palette.get("accent", palette["surface"])
-            if mode == "dark"
-            else palette.get("hover", palette["surface"])
-        )
-        for slider in getattr(self, "_sliders", []):
-            slider.configure(
-                # background=palette["background"],
-                # foreground=palette["foreground"],
-                troughcolor=palette["surface"],
-                # activebackground=active_background,
-                # highlightbackground=palette["background"],
-                highlightcolor=palette["background"],
-                sliderrelief=slider_relief,
-                bd=0,
+            return detect_system_theme(
+                os.environ,
+                sys.platform,
+                read_windows_theme_registry,
+                run_defaults_command,
             )
-        self.log_text.configure(
-            bg=palette["surface"],
-            fg=palette["foreground"],
-            insertbackground=palette["foreground"],
-            highlightbackground=palette["border"],
-            highlightcolor=palette["border"],
-        )
-        self.status_label.configure(bg=palette["background"])
-
-        self._apply_status_style(self._status_state)
-
-    def _detect_system_theme(self) -> str:
-        if sys.platform.startswith("win"):
-            try:
-                import winreg  # type: ignore
-
-                with winreg.OpenKey(
-                    winreg.HKEY_CURRENT_USER,
-                    r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize",
-                ) as key:
-                    value, _ = winreg.QueryValueEx(key, "AppsUseLightTheme")
-                return "light" if int(value) else "dark"
-            except OSError:
-                return "light"
-        if sys.platform == "darwin":
-            try:
-                result = subprocess.run(
-                    ["defaults", "read", "-g", "AppleInterfaceStyle"],
-                    capture_output=True,
-                    text=True,
-                    check=False,
-                )
-                if result.returncode == 0 and result.stdout.strip().lower() == "dark":
-                    return "dark"
-            except Exception:
-                pass
-            return "light"
-
-        theme = os.environ.get("GTK_THEME", "").lower()
-        if "dark" in theme:
-            return "dark"
-        return "light"
+        return preference
 
-    def _configure_drop_targets(self, widget) -> None:  # type: tk.Widget
+    def _refresh_theme(self) -> None:
+        mode = self._resolve_theme_mode()
+        palette = LIGHT_THEME if mode == "light" else DARK_THEME
+        apply_theme(
+            self.style,
+            palette,
+            {
+                "root": self.root,
+                "drop_zone": getattr(self, "drop_zone", None),
+                "log_text": getattr(self, "log_text", None),
+                "status_label": getattr(self, "status_label", None),
+                "sliders": getattr(self, "_sliders", []),
+                "tk": self.tk,
+                "apply_status_style": self._apply_status_style,
+                "status_state": self._status_state,
+            },
+        )
+
+    def _configure_drop_targets(self, widget) -> None:
         if not self._dnd_available:
             return
         widget.drop_target_register(DND_FILES)  # type: ignore[arg-type]
@@ -1509,124 +827,16 @@ class TalksReducerGUI:
         if result:
             variable.set(result)
 
-    def _start_run(self) -> None:
-        if self._processing_thread and self._processing_thread.is_alive():
-            self.messagebox.showinfo("Processing", "A job is already running.")
-            return
-
-        if not self.input_files:
-            self.messagebox.showwarning(
-                "Missing input", "Please add at least one file or folder."
-            )
-            return
-
-        try:
-            args = self._collect_arguments()
-        except ValueError as exc:
-            self.messagebox.showerror("Invalid value", str(exc))
-            return
-
-        self._append_log("Starting processing…")
-        self._stop_requested = False
-        open_after_convert = bool(self.open_after_convert_var.get())
-        server_url = self.server_url_var.get().strip()
-        remote_mode = self.processing_mode_var.get() == "remote"
-        if remote_mode and not server_url:
-            self.messagebox.showerror(
-                "Missing server URL", "Remote mode requires a server URL."
-            )
-            return
-        remote_mode = remote_mode and bool(server_url)
-
-        def worker() -> None:
-            def set_process(proc: subprocess.Popen) -> None:
-                self._ffmpeg_process = proc
-
-            try:
-                files = gather_input_files(self.input_files)
-                if not files:
-                    self._notify(
-                        lambda: self.messagebox.showwarning(
-                            "No files", "No supported media files were found."
-                        )
-                    )
-                    self._set_status("Idle")
-                    return
-
-                if remote_mode:
-                    success = self._process_files_via_server(
-                        files,
-                        args,
-                        server_url,
-                        open_after_convert=open_after_convert,
-                    )
-                    if success:
-                        self._notify(self._hide_stop_button)
-                    return
-
-                reporter = _TkProgressReporter(
-                    self._append_log, process_callback=set_process
-                )
-                for index, file in enumerate(files, start=1):
-                    self._append_log(
-                        f"Processing {index}/{len(files)}: {os.path.basename(file)}"
-                    )
-                    options = self._build_options(Path(file), args)
-                    result = speed_up_video(options, reporter=reporter)
-                    self._last_output = result.output_file
-                    self._last_time_ratio = result.time_ratio
-                    self._last_size_ratio = result.size_ratio
-
-                    # Create completion message with ratios if available
-                    completion_msg = f"Completed: {result.output_file}"
-                    if result.time_ratio is not None and result.size_ratio is not None:
-                        completion_msg += f" (Time: {result.time_ratio:.2%}, Size: {result.size_ratio:.2%})"
-
-                    self._append_log(completion_msg)
-                    if open_after_convert:
-                        self._notify(
-                            lambda path=result.output_file: self._open_in_file_manager(
-                                path
-                            )
-                        )
-
-                self._append_log("All jobs finished successfully.")
-                self._notify(lambda: self.open_button.configure(state=self.tk.NORMAL))
-                self._notify(self._clear_input_files)
-            except FFmpegNotFoundError as exc:
-                self._notify(
-                    lambda: self.messagebox.showerror("FFmpeg not found", str(exc))
-                )
-                self._set_status("Error")
-            except Exception as exc:  # pragma: no cover - GUI level safeguard
-                # If stop was requested, don't show error (FFmpeg termination is expected)
-                if self._stop_requested:
-                    self._append_log("Processing aborted by user.")
-                    self._set_status("Aborted")
-                else:
-                    error_msg = f"Processing failed: {exc}"
-                    self._append_log(error_msg)
-                    print(error_msg, file=sys.stderr)  # Also output to console
-                    self._notify(lambda: self.messagebox.showerror("Error", error_msg))
-                    self._set_status("Error")
-            finally:
-                self._notify(self._hide_stop_button)
-
-        self._processing_thread = threading.Thread(target=worker, daemon=True)
-        self._processing_thread.start()
-
-        # Show Stop button when processing starts
-        if remote_mode:
-            self.stop_button.grid_remove()
-        else:
-            self.stop_button.grid()
-
     def _stop_processing(self) -> None:
         """Stop the currently running processing by terminating FFmpeg."""
         import signal
 
         self._stop_requested = True
-        if self._ffmpeg_process and self._ffmpeg_process.poll() is None:
+        # Update button text to indicate stopping state
+        self.stop_button.configure(text="Stopping...")
+        if self._current_remote_mode:
+            self._append_log("Cancelling remote job...")
+        elif self._ffmpeg_process and self._ffmpeg_process.poll() is None:
             self._append_log("Stopping FFmpeg process...")
             try:
                 # Send SIGTERM to FFmpeg process
@@ -1693,101 +903,15 @@ class TalksReducerGUI:
     ) -> bool:
         """Send *files* to the configured server for processing."""
 
-        try:
-            service_module = importlib.import_module("talks_reducer.service_client")
-        except ModuleNotFoundError as exc:
-            self._append_log(f"Server client unavailable: {exc}")
-            self._notify(
-                lambda: self.messagebox.showerror(
-                    "Server unavailable",
-                    "Remote processing requires the gradio_client package.",
-                )
-            )
-            self._notify(lambda: self._set_status("Error"))
-            return False
-
-        host_label = self._format_server_host(server_url)
-        self._notify(
-            lambda: self._set_status("waiting", f"Waiting server {host_label}...")
+        return process_files_via_server(
+            self,
+            files,
+            args,
+            server_url,
+            open_after_convert=open_after_convert,
+            default_remote_destination=_default_remote_destination,
+            parse_summary=_parse_ratios_from_summary,
         )
-        if not self._ping_server(server_url):
-            self._append_log(f"Server unreachable: {server_url}")
-            self._notify(
-                lambda: self._set_status("Error", f"Server {host_label} unreachable")
-            )
-            return False
-
-        self._notify(lambda: self._set_status("waiting", f"Server {host_label} ready"))
-
-        output_override = args.get("output_file") if len(files) == 1 else None
-        ignored = [key for key in args if key not in {"output_file", "small"}]
-        if ignored:
-            ignored_options = ", ".join(sorted(ignored))
-            self._append_log(
-                f"Server mode ignores the following options: {ignored_options}"
-            )
-
-        small_mode = bool(args.get("small", False))
-
-        for index, file in enumerate(files, start=1):
-            basename = os.path.basename(file)
-            self._append_log(
-                f"Uploading {index}/{len(files)}: {basename} to {server_url}"
-            )
-            input_path = Path(file)
-
-            if output_override is not None:
-                output_path = Path(output_override)
-                if output_path.is_dir():
-                    output_path = (
-                        output_path
-                        / _default_remote_destination(input_path, small=small_mode).name
-                    )
-            else:
-                output_path = _default_remote_destination(input_path, small=small_mode)
-
-            try:
-                destination, summary, log_text = service_module.send_video(
-                    input_path=input_path,
-                    output_path=output_path,
-                    server_url=server_url,
-                    small=small_mode,
-                    stream_updates=True,
-                    log_callback=self._append_log,
-                    # progress_callback=self._handle_service_progress,
-                )
-            except Exception as exc:  # pragma: no cover - network safeguard
-                error_detail = f"{exc.__class__.__name__}: {exc}"
-                error_msg = f"Processing failed: {error_detail}"
-                self._append_log(error_msg)
-                self._notify(lambda: self._set_status("Error"))
-                self._notify(
-                    lambda: self.messagebox.showerror(
-                        "Server error",
-                        f"Failed to process {basename}: {error_detail}",
-                    )
-                )
-                return False
-
-            self._last_output = Path(destination)
-            time_ratio, size_ratio = _parse_ratios_from_summary(summary)
-            self._last_time_ratio = time_ratio
-            self._last_size_ratio = size_ratio
-            for line in summary.splitlines():
-                self._append_log(line)
-            if log_text.strip():
-                self._append_log("Server log:")
-                for line in log_text.splitlines():
-                    self._append_log(line)
-            if open_after_convert:
-                self._notify(
-                    lambda path=self._last_output: self._open_in_file_manager(path)
-                )
-
-        self._append_log("All jobs finished successfully.")
-        self._notify(lambda: self.open_button.configure(state=self.tk.NORMAL))
-        self._notify(self._clear_input_files)
-        return True
 
     def _parse_float(self, value: str, label: str) -> float:
         try:
@@ -1795,7 +919,7 @@ class TalksReducerGUI:
         except ValueError as exc:  # pragma: no cover - input validation
             raise ValueError(f"{label} must be a number.") from exc
 
-    def _build_options(
+    def _create_processing_options(
         self, input_file: Path, args: dict[str, object]
     ) -> ProcessingOptions:
         options = dict(args)
@@ -1840,7 +964,7 @@ class TalksReducerGUI:
     def _update_status_from_message(self, message: str) -> None:
         normalized = message.strip().lower()
         metadata_match = re.search(
-            r"source metadata [—-] duration:\s*([\d.]+)s",
+            r"source metadata: duration:\s*([\d.]+)s",
             message,
             re.IGNORECASE,
         )
@@ -1850,18 +974,48 @@ class TalksReducerGUI:
             except ValueError:
                 self._source_duration_seconds = None
         if "all jobs finished successfully" in normalized:
-            # Create status message with ratios if available
-            status_msg = "Success"
+            status_components: List[str] = []
+            if self._run_start_time is not None:
+                finish_time = time.monotonic()
+                runtime_seconds = max(0.0, finish_time - self._run_start_time)
+                duration_str = self._format_progress_time(runtime_seconds)
+                status_components.append(f"{duration_str}")
+            else:
+                finished_seconds = next(
+                    (
+                        value
+                        for value in (
+                            self._last_progress_seconds,
+                            self._encode_target_duration_seconds,
+                            self._video_duration_seconds,
+                        )
+                        if value is not None
+                    ),
+                    None,
+                )
+
+                if finished_seconds is not None:
+                    duration_str = self._format_progress_time(finished_seconds)
+                    status_components.append(f"{duration_str}")
+                else:
+                    status_components.append("Finished")
+
             if self._last_time_ratio is not None and self._last_size_ratio is not None:
-                status_msg = f"Time: {self._last_time_ratio:.0%}, Size: {self._last_size_ratio:.0%}"
+                status_components.append(
+                    f"time: {self._last_time_ratio:.0%}, size: {self._last_size_ratio:.0%}"
+                )
+
+            status_msg = ", ".join(status_components)
 
             self._reset_audio_progress_state(clear_source=True)
             self._set_status("success", status_msg)
             self._set_progress(100)  # 100% on success
+            self._run_start_time = None
             self._video_duration_seconds = None  # Reset for next video
             self._encode_target_duration_seconds = None
             self._encode_total_frames = None
             self._encode_current_frame = None
+            self._last_progress_seconds = None
         elif normalized.startswith("extracting audio"):
             self._reset_audio_progress_state(clear_source=False)
             self._set_status("processing", "Extracting audio...")
@@ -1870,6 +1024,7 @@ class TalksReducerGUI:
             self._encode_target_duration_seconds = None
             self._encode_total_frames = None
             self._encode_current_frame = None
+            self._last_progress_seconds = None
             self._start_audio_progress()
         elif normalized.startswith("uploading"):
             self._set_status("processing", "Uploading...")
@@ -1881,6 +1036,7 @@ class TalksReducerGUI:
             self._encode_target_duration_seconds = None
             self._encode_total_frames = None
             self._encode_current_frame = None
+            self._last_progress_seconds = None
         elif normalized.startswith("processing"):
             is_new_job = bool(re.match(r"processing \d+/\d+:", normalized))
             should_reset = self._status_state.lower() != "processing" or is_new_job
@@ -1890,6 +1046,7 @@ class TalksReducerGUI:
                 self._encode_target_duration_seconds = None
                 self._encode_total_frames = None
                 self._encode_current_frame = None
+                self._last_progress_seconds = None
             if is_new_job:
                 self._reset_audio_progress_state(clear_source=True)
             self._set_status("processing", "Processing")
@@ -1962,6 +1119,8 @@ class TalksReducerGUI:
             time_str = self._format_progress_time(current_seconds)
             speed_str = speed_match.group(1)
 
+            self._last_progress_seconds = current_seconds
+
             total_seconds = (
                 self._encode_target_duration_seconds or self._video_duration_seconds
             )
@@ -2010,7 +1169,7 @@ class TalksReducerGUI:
                 interval_ms, self._advance_audio_progress
             )
 
-        self._notify(_start)
+        self._schedule_on_ui_thread(_start)
 
     def _advance_audio_progress(self) -> None:
         self._audio_progress_job = None
@@ -2047,7 +1206,7 @@ class TalksReducerGUI:
                 self._audio_progress_job = None
             self._audio_progress_interval_ms = None
 
-        self._notify(_cancel)
+        self._schedule_on_ui_thread(_cancel)
 
     def _reset_audio_progress_state(self, *, clear_source: bool) -> None:
         if clear_source:
@@ -2069,7 +1228,7 @@ class TalksReducerGUI:
                 if current_value < self.AUDIO_PROGRESS_STEPS:
                     self._set_progress(self.AUDIO_PROGRESS_STEPS)
 
-        self._notify(_complete)
+        self._schedule_on_ui_thread(_complete)
 
     def _apply_status_style(self, status: str) -> None:
         color = STATUS_COLORS.get(status.lower())
@@ -2081,7 +1240,10 @@ class TalksReducerGUI:
             status_lower = status.lower()
             if (
                 "extracting audio" in status_lower
-                or re.search(r"\d+:\d{2}(?: / \d+:\d{2})?.*\d+\.?\d*x", status)
+                or re.search(
+                    r"\d+:\d{2}(?::\d{2})?(?: / \d+:\d{2}(?::\d{2})?)?.*\d+\.?\d*x",
+                    status,
+                )
                 or ("time:" in status_lower and "size:" in status_lower)
             ):
                 if "time:" in status_lower and "size:" in status_lower:
@@ -2132,7 +1294,7 @@ class TalksReducerGUI:
         self.root.after(0, apply)
 
     def _format_progress_time(self, total_seconds: float) -> str:
-        """Format a duration in seconds as h:mm or m:ss for status display."""
+        """Format a duration in seconds as h:mm:ss or m:ss for status display."""
 
         try:
             rounded_seconds = max(0, int(round(total_seconds)))
@@ -2143,7 +1305,7 @@ class TalksReducerGUI:
         minutes, seconds = divmod(remainder, 60)
 
         if hours > 0:
-            return f"{hours}:{minutes:02d}"
+            return f"{hours}:{minutes:02d}:{seconds:02d}"
 
         total_minutes = rounded_seconds // 60
         return f"{total_minutes}:{seconds:02d}"
@@ -2193,7 +1355,7 @@ class TalksReducerGUI:
             # Update color based on percentage gradient
             color = self._calculate_gradient_color(percentage, 0.5)
             palette = (
-                LIGHT_THEME if self._detect_system_theme() == "light" else DARK_THEME
+                LIGHT_THEME if self._resolve_theme_mode() == "light" else DARK_THEME
             )
             if self.theme_var.get().lower() in {"light", "dark"}:
                 palette = (
@@ -2244,7 +1406,7 @@ class TalksReducerGUI:
 
         self.root.after(0, updater)
 
-    def _notify(self, callback: Callable[[], None]) -> None:
+    def _schedule_on_ui_thread(self, callback: Callable[[], None]) -> None:
         self.root.after(0, callback)
 
     def run(self) -> None:
@@ -2265,24 +1427,34 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
 
     parser = argparse.ArgumentParser(add_help=False)
     parser.add_argument(
-        "--no-tray",
+        "--server",
         action="store_true",
-        help="Do not start the Talks Reducer server tray alongside the GUI.",
+        help="Launch the Talks Reducer server tray instead of the desktop GUI.",
     )
     parser.add_argument(
-        "--server",
+        "--no-tray",
         action="store_true",
-        help="Launch the Talks Reducer server tray instead of the desktop GUI.",
+        help="Deprecated: the GUI no longer starts the server tray automatically.",
     )
 
     parsed_args, remaining = parser.parse_known_args(argv)
-    no_tray = parsed_args.no_tray
     if parsed_args.server:
         package_name = __package__ or "talks_reducer"
-        tray_module = importlib.import_module(f"{package_name}.server_tray")
+        module_name = f"{package_name}.server_tray"
+        try:
+            tray_module = importlib.import_module(module_name)
+        except ModuleNotFoundError as exc:
+            if exc.name != module_name:
+                raise
+            root_package = package_name.split(".")[0] or "talks_reducer"
+            tray_module = importlib.import_module(f"{root_package}.server_tray")
         tray_main = getattr(tray_module, "main")
         tray_main(remaining)
         return False
+    if parsed_args.no_tray:
+        sys.stderr.write(
+            "Warning: --no-tray is deprecated; the GUI no longer starts the server tray automatically.\n"
+        )
     argv = remaining
 
     if argv:
@@ -2298,8 +1470,6 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
         if launch_gui:
             try:
                 app = TalksReducerGUI(argv, auto_run=True)
-                if not no_tray:
-                    _ensure_server_tray_running()
                 app.run()
                 return True
             except Exception:
@@ -2361,8 +1531,6 @@ def main(argv: Optional[Sequence[str]] = None) -> bool:
     # Catch and report any errors during GUI initialization
     try:
         app = TalksReducerGUI()
-        if not no_tray:
-            _ensure_server_tray_running()
         app.run()
         return True
     except Exception as e: