pomera-ai-commander 1.2.8 → 1.2.10

package/core/load_presets_dialog.py

@@ -0,0 +1,460 @@
+"""
+Load Presets Dialog Module
+
+Provides a dialog for users to view and reset tool settings to their defaults.
+Shows all registered tools from SettingsDefaultsRegistry and allows selective reset.
+
+Author: Pomera AI Commander Team
+"""
+
+import tkinter as tk
+from tkinter import ttk, messagebox
+import logging
+from typing import Dict, Any, List, Optional
+
+
+class LoadPresetsDialog:
+    """
+    Dialog for loading/resetting tool presets to defaults.
+    
+    Features:
+    - Lists all registered tools from SettingsDefaultsRegistry
+    - Shows current vs default values preview
+    - Allows selective reset of individual tools
+    - Confirmation dialog before reset
+    """
+    
+    def __init__(self, parent, settings_manager, logger=None, dialog_manager=None):
+        """
+        Initialize the Load Presets Dialog.
+        
+        Args:
+            parent: Parent window
+            settings_manager: Settings manager instance (database or file-based)
+            logger: Logger instance
+            dialog_manager: Optional DialogManager for consistent dialogs
+        """
+        self.parent = parent
+        self.settings_manager = settings_manager
+        self.logger = logger or logging.getLogger(__name__)
+        self.dialog_manager = dialog_manager
+        
+        # Get registry
+        try:
+            from core.settings_defaults_registry import get_registry
+            self.registry = get_registry()
+        except ImportError:
+            self.registry = None
+            self.logger.error("SettingsDefaultsRegistry not available")
+        
+        # Dialog window
+        self.dialog = None
+        self.tree = None
+        self.preview_text = None
+        self.selected_tools = set()
+    
+    def show(self):
+        """Show the Load Presets dialog."""
+        if not self.registry:
+            self._show_error("Error", "Settings registry not available.")
+            return
+        
+        self.dialog = tk.Toplevel(self.parent)
+        self.dialog.title("Load Presets - Reset Tool Settings")
+        self.dialog.geometry("800x550")
+        self.dialog.transient(self.parent)
+        self.dialog.grab_set()
+        
+        # Make dialog modal
+        self.dialog.focus_set()
+        
+        # Create main layout
+        self._create_widgets()
+        
+        # Populate tools list
+        self._populate_tools_list()
+        
+        # Center on parent
+        self._center_on_parent()
+    
+    def _center_on_parent(self):
+        """Center dialog on parent window."""
+        self.dialog.update_idletasks()
+        parent_x = self.parent.winfo_x()
+        parent_y = self.parent.winfo_y()
+        parent_w = self.parent.winfo_width()
+        parent_h = self.parent.winfo_height()
+        
+        dialog_w = self.dialog.winfo_width()
+        dialog_h = self.dialog.winfo_height()
+        
+        x = parent_x + (parent_w - dialog_w) // 2
+        y = parent_y + (parent_h - dialog_h) // 2
+        
+        self.dialog.geometry(f"+{x}+{y}")
+    
+    def _create_widgets(self):
+        """Create the dialog widgets."""
+        main_frame = ttk.Frame(self.dialog, padding="10")
+        main_frame.pack(fill=tk.BOTH, expand=True)
+        
+        # Title and description
+        title_label = ttk.Label(
+            main_frame, 
+            text="Reset Tool Settings to Defaults",
+            font=("TkDefaultFont", 12, "bold")
+        )
+        title_label.pack(anchor="w", pady=(0, 5))
+        
+        desc_label = ttk.Label(
+            main_frame,
+            text="Select tools to reset to their default settings. Current settings will be replaced.",
+            foreground="gray"
+        )
+        desc_label.pack(anchor="w", pady=(0, 10))
+        
+        # Split pane: left=tools list, right=preview
+        paned = ttk.PanedWindow(main_frame, orient=tk.HORIZONTAL)
+        paned.pack(fill=tk.BOTH, expand=True, pady=(0, 10))
+        
+        # Left side: Tools list with checkboxes
+        left_frame = ttk.LabelFrame(paned, text="Tools with Defaults", padding="5")
+        paned.add(left_frame, weight=1)
+        
+        # Select All / Deselect All buttons
+        btn_frame = ttk.Frame(left_frame)
+        btn_frame.pack(fill=tk.X, pady=(0, 5))
+        
+        ttk.Button(btn_frame, text="Select All", command=self._select_all, width=12).pack(side=tk.LEFT, padx=(0, 5))
+        ttk.Button(btn_frame, text="Deselect All", command=self._deselect_all, width=12).pack(side=tk.LEFT)
+        
+        # Treeview for tools
+        tree_frame = ttk.Frame(left_frame)
+        tree_frame.pack(fill=tk.BOTH, expand=True)
+        
+        self.tree = ttk.Treeview(
+            tree_frame,
+            columns=("selected", "description"),
+            show="tree headings",
+            selectmode="browse"
+        )
+        
+        self.tree.heading("#0", text="Tool Name")
+        self.tree.heading("selected", text="Reset?")
+        self.tree.heading("description", text="Description")
+        
+        self.tree.column("#0", width=180, minwidth=150)
+        self.tree.column("selected", width=60, minwidth=50, anchor="center")
+        self.tree.column("description", width=150, minwidth=100)
+        
+        # Scrollbar
+        scrollbar = ttk.Scrollbar(tree_frame, orient="vertical", command=self.tree.yview)
+        self.tree.configure(yscrollcommand=scrollbar.set)
+        
+        self.tree.pack(side=tk.LEFT, fill=tk.BOTH, expand=True)
+        scrollbar.pack(side=tk.RIGHT, fill=tk.Y)
+        
+        # Bind selection and toggle
+        self.tree.bind("<<TreeviewSelect>>", self._on_tool_select)
+        self.tree.bind("<Double-1>", self._toggle_tool_selection)
+        self.tree.bind("<space>", self._toggle_tool_selection)
+        
+        # Right side: Preview panel
+        right_frame = ttk.LabelFrame(paned, text="Settings Preview", padding="5")
+        paned.add(right_frame, weight=1)
+        
+        self.preview_text = tk.Text(
+            right_frame,
+            wrap=tk.WORD,
+            font=("Consolas", 9),
+            state="disabled",
+            bg="#f5f5f5"
+        )
+        self.preview_text.pack(fill=tk.BOTH, expand=True)
+        
+        # Bottom buttons
+        button_frame = ttk.Frame(main_frame)
+        button_frame.pack(fill=tk.X, pady=(10, 0))
+        
+        # Left: Info about selected count
+        self.selected_count_label = ttk.Label(button_frame, text="0 tools selected for reset")
+        self.selected_count_label.pack(side=tk.LEFT)
+        
+        # Right: Action buttons
+        ttk.Button(
+            button_frame, 
+            text="Cancel", 
+            command=self.dialog.destroy
+        ).pack(side=tk.RIGHT, padx=(5, 0))
+        
+        self.reset_button = ttk.Button(
+            button_frame,
+            text="Reset Selected Tools",
+            command=self._reset_selected_tools,
+            style="Accent.TButton"
+        )
+        self.reset_button.pack(side=tk.RIGHT)
+        self.reset_button.config(state="disabled")
+        
+        # Add Edit Defaults File button
+        ttk.Button(
+            button_frame,
+            text="Edit Defaults File",
+            command=self._open_defaults_file
+        ).pack(side=tk.RIGHT, padx=(0, 10))
+    
+    def _populate_tools_list(self):
+        """Populate the tools treeview from registry."""
+        if not self.registry:
+            return
+        
+        registered_tools = self.registry.get_registered_tools()
+        
+        for tool_name in sorted(registered_tools):
+            spec = self.registry.get_tool_spec(tool_name)
+            description = spec.description if spec else ""
+            
+            self.tree.insert(
+                "",
+                "end",
+                iid=tool_name,
+                text=tool_name,
+                values=("☐", description)
+            )
+    
+    def _on_tool_select(self, event=None):
+        """Handle tool selection - show preview."""
+        selection = self.tree.selection()
+        if not selection:
+            return
+        
+        tool_name = selection[0]
+        self._show_preview(tool_name)
+    
+    def _toggle_tool_selection(self, event=None):
+        """Toggle the selection checkbox for a tool."""
+        selection = self.tree.selection()
+        if not selection:
+            return
+        
+        tool_name = selection[0]
+        
+        if tool_name in self.selected_tools:
+            self.selected_tools.discard(tool_name)
+            self.tree.set(tool_name, "selected", "☐")
+        else:
+            self.selected_tools.add(tool_name)
+            self.tree.set(tool_name, "selected", "☑")
+        
+        self._update_selected_count()
+    
+    def _select_all(self):
+        """Select all tools for reset."""
+        for item in self.tree.get_children():
+            self.selected_tools.add(item)
+            self.tree.set(item, "selected", "☑")
+        self._update_selected_count()
+    
+    def _deselect_all(self):
+        """Deselect all tools."""
+        self.selected_tools.clear()
+        for item in self.tree.get_children():
+            self.tree.set(item, "selected", "☐")
+        self._update_selected_count()
+    
+    def _update_selected_count(self):
+        """Update the selected count label and button state."""
+        count = len(self.selected_tools)
+        self.selected_count_label.config(text=f"{count} tool(s) selected for reset")
+        
+        if count > 0:
+            self.reset_button.config(state="normal")
+        else:
+            self.reset_button.config(state="disabled")
+    
+    def _show_preview(self, tool_name: str):
+        """Show current vs default settings preview for a tool."""
+        self.preview_text.config(state="normal")
+        self.preview_text.delete("1.0", tk.END)
+        
+        try:
+            # Get defaults from registry
+            defaults = self.registry.get_tool_defaults(tool_name)
+            
+            # Get current settings
+            current = {}
+            if hasattr(self.settings_manager, 'get_tool_settings'):
+                current = self.settings_manager.get_tool_settings(tool_name)
+            elif hasattr(self.settings_manager, 'settings'):
+                tool_settings = self.settings_manager.settings.get("tool_settings", {})
+                current = tool_settings.get(tool_name, {})
+            
+            # Format preview
+            preview = f"=== {tool_name} ===\n\n"
+            preview += "--- DEFAULTS (will be applied) ---\n"
+            
+            for key, value in sorted(defaults.items()):
+                # Truncate long values
+                value_str = str(value)
+                if len(value_str) > 50:
+                    value_str = value_str[:50] + "..."
+                preview += f"  {key}: {value_str}\n"
+            
+            if current:
+                preview += "\n--- CURRENT VALUES ---\n"
+                for key, value in sorted(current.items()):
+                    value_str = str(value)
+                    if len(value_str) > 50:
+                        value_str = value_str[:50] + "..."
+                    # Highlight differences
+                    if key in defaults and defaults[key] != value:
+                        preview += f"  {key}: {value_str} ⟵ differs\n"
+                    else:
+                        preview += f"  {key}: {value_str}\n"
+            
+            self.preview_text.insert("1.0", preview)
+            
+        except Exception as e:
+            self.preview_text.insert("1.0", f"Error loading preview: {e}")
+            self.logger.error(f"Error showing preview for {tool_name}: {e}")
+        
+        self.preview_text.config(state="disabled")
+    
+    def _reset_selected_tools(self):
+        """Reset selected tools to defaults after confirmation."""
+        if not self.selected_tools:
+            return
+        
+        # Build confirmation message
+        tools_list = "\n".join(f"  • {name}" for name in sorted(self.selected_tools))
+        message = (
+            f"The following {len(self.selected_tools)} tool(s) will have their "
+            f"settings reset to defaults:\n\n{tools_list}\n\n"
+            "This action cannot be undone. Continue?"
+        )
+        
+        # Show confirmation
+        if not self._ask_yes_no("Confirm Reset", message):
+            return
+        
+        # Perform reset
+        reset_count = 0
+        errors = []
+        
+        for tool_name in self.selected_tools:
+            try:
+                defaults = self.registry.get_tool_defaults(tool_name)
+                
+                # Apply defaults to settings manager
+                if hasattr(self.settings_manager, 'update_tool_settings'):
+                    self.settings_manager.update_tool_settings(tool_name, defaults)
+                elif hasattr(self.settings_manager, 'set_tool_settings'):
+                    self.settings_manager.set_tool_settings(tool_name, defaults)
+                elif hasattr(self.settings_manager, 'settings'):
+                    if "tool_settings" not in self.settings_manager.settings:
+                        self.settings_manager.settings["tool_settings"] = {}
+                    self.settings_manager.settings["tool_settings"][tool_name] = defaults.copy()
+                
+                reset_count += 1
+                self.logger.info(f"Reset '{tool_name}' to defaults")
+                
+            except Exception as e:
+                errors.append(f"{tool_name}: {e}")
+                self.logger.error(f"Error resetting {tool_name}: {e}")
+        
+        # Save settings
+        try:
+            if hasattr(self.settings_manager, 'save_settings'):
+                self.settings_manager.save_settings()
+        except Exception as e:
+            self.logger.error(f"Error saving settings: {e}")
+        
+        # Show result
+        if errors:
+            self._show_warning(
+                "Partial Reset",
+                f"Reset {reset_count} tool(s) successfully.\n\n"
+                f"Errors occurred for:\n" + "\n".join(errors)
+            )
+        else:
+            self._show_info(
+                "Reset Complete",
+                f"Successfully reset {reset_count} tool(s) to defaults.\n\n"
+                "Please restart affected tools for changes to take effect."
+            )
+        
+        # Close dialog
+        self.dialog.destroy()
+    
+    def _show_info(self, title: str, message: str) -> bool:
+        """Show info dialog."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_info(title, message, parent=self.dialog)
+        else:
+            messagebox.showinfo(title, message, parent=self.dialog)
+            return True
+    
+    def _show_warning(self, title: str, message: str) -> bool:
+        """Show warning dialog."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_warning(title, message, parent=self.dialog)
+        else:
+            messagebox.showwarning(title, message, parent=self.dialog)
+            return True
+    
+    def _show_error(self, title: str, message: str) -> bool:
+        """Show error dialog."""
+        if self.dialog_manager:
+            return self.dialog_manager.show_error(title, message, parent=self.parent)
+        else:
+            messagebox.showerror(title, message, parent=self.parent)
+            return True
+    
+    def _ask_yes_no(self, title: str, message: str) -> bool:
+        """Show yes/no confirmation dialog."""
+        if self.dialog_manager:
+            return self.dialog_manager.ask_yes_no(title, message, parent=self.dialog)
+        else:
+            return messagebox.askyesno(title, message, parent=self.dialog)
+    
+    def _open_defaults_file(self):
+        """Open the defaults.json file in the system default editor."""
+        import os
+        import subprocess
+        import platform
+        
+        try:
+            # Get path from registry
+            json_path = self.registry.get_json_defaults_path() if self.registry else None
+            
+            if not json_path:
+                # Try default location
+                json_path = os.path.join(os.path.dirname(__file__), "..", "defaults.json")
+            
+            if not os.path.exists(json_path):
+                self._show_error(
+                    "File Not Found",
+                    f"defaults.json not found at:\n{json_path}\n\n"
+                    "The file will be created when you restart the app."
+                )
+                return
+            
+            # Open in system default editor
+            if platform.system() == "Windows":
+                os.startfile(json_path)
+            elif platform.system() == "Darwin":  # macOS
+                subprocess.run(["open", json_path])
+            else:  # Linux
+                subprocess.run(["xdg-open", json_path])
+            
+            self.logger.info(f"Opened defaults.json: {json_path}")
+            
+        except Exception as e:
+            self._show_error("Error", f"Could not open defaults.json:\n{e}")
+            self.logger.error(f"Error opening defaults.json: {e}")
+
+
+def get_registry():
+    """Get the settings defaults registry singleton."""
+    from core.settings_defaults_registry import SettingsDefaultsRegistry
+    return SettingsDefaultsRegistry()