feat: implement lazy loading for tab content in GUI windows

Implemented a lazy loading mechanism for tabs in PromptEditorWindow and SettingsWindow to improve initial window loading performance. Tab contents are now rendered only when a tab is first selected, reducing startup overhead.

- Added `_tab_configs` to track initialization state and creation methods for each tab
- Integrated `_on_tab_changed` callback with CustomTkinter's Tabview
- Modified window initialization to only load the default active tab immediately
- Added helper methods `_load_tab_content` to handle safe on-demand rendering

Author: zaxx-q

CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## [4.1.1] - 2026-02-10
+
+### Improvements
+
+- **Performance**: Implemented lazy loading for tabs in Settings and Prompt Editor windows, rendering content only upon selection to improve window opening speed.
+
 ## [4.1.0] - 2026-02-09
 
 ### New Features
@@ -13,7 +19,7 @@
 
 ### Build & Deployment
 
-- **Launchers**: Replaced C# launchers with Python-based cx_Freeze implementations to eliminate AV false positives and to simplify and centralize logi.
+- **Launchers**: Replaced C# launchers with Python-based cx_Freeze implementations to eliminate AV false positives and to simplify and centralize logic.
 
 ## [4.0.1] - 2026-02-08
 

src/gui/windows/prompt_editor.py

@@ -659,25 +659,31 @@ def _create_main_content(self, parent):
                 segmented_button_unselected_color=self.colors.surface0,
                 segmented_button_unselected_hover_color=self.colors.surface1,
                 text_color=self.colors.fg,
-                corner_radius=8
+                corner_radius=8,
+                command=self._on_tab_changed
             )
             self.tabview.pack(fill="both", expand=True, pady=(0, 2))
 
-            # Create tabs
-            self.tabview.add("⚡ Actions")
-            self.tabview.add("📁 Groups")
-            self.tabview.add("⚙️ Settings")
-            self.tabview.add("🎛️ Modifiers")
-            self.tabview.add("🧪 Playground")
+            # Lazy loading configuration
+            # Format: "Tab Name": ("method_name", is_loaded_bool)
+            self._tab_configs = {
+                "⚡ Actions": ("_create_actions_tab", False),
+                "📁 Groups": ("_create_groups_tab", False),
+                "⚙️ Settings": ("_create_settings_tab", False),
+                "🎛️ Modifiers": ("_create_modifiers_tab", False),
+                "🧪 Playground": ("_create_playground_tab", False)
+            }
+            
+            # Create tabs (empty initially)
+            for tab_name in self._tab_configs.keys():
+                self.tabview.add(tab_name)
 
             # Upgrade tabs with images and larger font
             upgrade_tabview_with_icons(self.tabview)
 
-            self._create_actions_tab(self.tabview.tab("⚡ Actions"))
-            self._create_groups_tab(self.tabview.tab("📁 Groups"))
-            self._create_settings_tab(self.tabview.tab("⚙️ Settings"))
-            self._create_modifiers_tab(self.tabview.tab("🎛️ Modifiers"))
-            self._create_playground_tab(self.tabview.tab("🧪 Playground"))
+            # Load the first tab immediately
+            first_tab = "⚡ Actions"
+            self._load_tab_content(first_tab)
         else:
             # Fallback to ttk.Notebook
             from tkinter import ttk
@@ -704,6 +710,40 @@ def _create_main_content(self, parent):
             self._create_modifiers_tab(modifiers_frame)
             self._create_playground_tab(playground_frame)
 
+    def _on_tab_changed(self):
+        """Handle tab change event - lazy load tab content."""
+        if not self.use_ctk or not hasattr(self, '_tab_configs'):
+            return
+            
+        current_tab = self.tabview.get()
+        self._load_tab_content(current_tab)
+        
+    def _load_tab_content(self, tab_name: str):
+        """Load content for a tab if not already loaded."""
+        if not hasattr(self, '_tab_configs') or tab_name not in self._tab_configs:
+            return
+            
+        method_name, is_loaded = self._tab_configs[tab_name]
+        
+        if is_loaded:
+            return  # Already loaded
+            
+        # Mark as loaded first to prevent re-entry
+        self._tab_configs[tab_name] = (method_name, True)
+        
+        # Get tab frame
+        tab_frame = self.tabview.tab(tab_name)
+        
+        # Call creation method
+        create_method = getattr(self, method_name, None)
+        if create_method and callable(create_method):
+            try:
+                create_method(tab_frame)
+            except Exception as e:
+                print(f"[PromptEditor] Error loading tab '{tab_name}': {e}")
+                import traceback
+                traceback.print_exc()
+
     def _refresh_action_list(self):
         """Refresh the action scrollable list based on current tool."""
         if not self.action_listbox:

src/gui/windows/settings_window.py

@@ -525,6 +525,10 @@ def show(self, initial_tab: str = None):
                 if not found:
                     print(f"[Settings] Could not find initial tab '{initial_tab}'")
 
+        # Ensure content for the active tab is loaded (since explicit .set() doesn't trigger command)
+        if self.use_ctk:
+            self._load_tab_content(self.tabview.get())
+        
         # Register and bind
         register_window(self.window_tag)
         self.root.protocol("WM_DELETE_WINDOW", self._close)
@@ -657,7 +661,7 @@ def _create_title_bar(self, parent):
                     bg=self.colors.bg, fg=self.colors.blockquote).pack(side="left", padx=(15, 0))
 
     def _create_notebook(self, parent):
-        """Create the tabbed notebook."""
+        """Create the tabbed notebook with lazy tab loading for performance."""
         if self.use_ctk:
             self.tabview = ctk.CTkTabview(
                 parent,
@@ -668,36 +672,40 @@ def _create_notebook(self, parent):
                 segmented_button_unselected_color=self.colors.surface0,
                 segmented_button_unselected_hover_color=self.colors.surface1,
                 text_color=self.colors.fg,
-                corner_radius=8
+                corner_radius=8,
+                command=self._on_tab_changed  # Lazy loading callback
             )
             self.tabview.pack(fill="both", expand=True, pady=(0, 2))
 
-            # Create tabs
-            self.tabview.add("⚙️ General")
-            self.tabview.add("🌐 Provider")
-            self.tabview.add("⚡ Streaming")
-            self.tabview.add("🔧 Tools")
-            self.tabview.add("🔑 API Keys")
-            self.tabview.add("🔗 Endpoints")
-            self.tabview.add("🎨 Theme")
+            # Define tab configurations for lazy loading
+            self._tab_configs = {
+                "⚙️ General": ("_create_general_tab", False),
+                "🌐 Provider": ("_create_provider_tab", False),
+                "⚡ Streaming": ("_create_streaming_tab", False),
+                "🔧 Tools": ("_create_tools_tab", False),
+                "🔑 API Keys": ("_create_keys_tab", False),
+                "🔗 Endpoints": ("_create_endpoints_tab", False),
+                "🎨 Theme": ("_create_theme_tab", False),
+            }
+            
+            # Create empty tabs
+            for tab_name in self._tab_configs.keys():
+                self.tabview.add(tab_name)
 
             # Upgrade tabs with images and larger font
             upgrade_tabview_with_icons(self.tabview)
 
-            self._create_general_tab(self.tabview.tab("⚙️ General"))
-            self._create_provider_tab(self.tabview.tab("🌐 Provider"))
-            self._create_streaming_tab(self.tabview.tab("⚡ Streaming"))
-            self._create_tools_tab(self.tabview.tab("🔧 Tools"))
-            self._create_keys_tab(self.tabview.tab("🔑 API Keys"))
-            self._create_endpoints_tab(self.tabview.tab("🔗 Endpoints"))
-            self._create_theme_tab(self.tabview.tab("🎨 Theme"))
+            # Only create the first tab's content immediately
+            first_tab = "⚙️ General"
+            self._load_tab_content(first_tab)
         else:
             from tkinter import ttk
             style = ttk.Style(self.root)
             style.theme_use('clam')
             self.tabview = ttk.Notebook(parent)
             self.tabview.pack(fill="both", expand=True, pady=(0, 2))
 
+            # For ttk.Notebook, we don't do lazy loading (simpler fallback)
             tabs = ["General", "Provider", "Streaming", "Tools", "API Keys", "Endpoints", "Theme"]
             frames = {}
             for tab_name in tabs:
@@ -713,6 +721,34 @@ def _create_notebook(self, parent):
             self._create_endpoints_tab(frames["Endpoints"])
             self._create_theme_tab(frames["Theme"])
 
+    def _on_tab_changed(self):
+        """Handle tab change event - lazy load tab content."""
+        if not self.use_ctk or not hasattr(self, '_tab_configs'):
+            return
+        
+        current_tab = self.tabview.get()
+        self._load_tab_content(current_tab)
+    
+    def _load_tab_content(self, tab_name: str):
+        """Load content for a tab if not already loaded."""
+        if not hasattr(self, '_tab_configs') or tab_name not in self._tab_configs:
+            return
+        
+        method_name, is_loaded = self._tab_configs[tab_name]
+        
+        if is_loaded:
+            return  # Already loaded
+        
+        # Mark as loaded before creating (to prevent re-entry)
+        self._tab_configs[tab_name] = (method_name, True)
+        
+        # Get the tab frame and call the creation method
+        tab_frame = self.tabview.tab(tab_name)
+        create_method = getattr(self, method_name, None)
+        
+        if create_method and callable(create_method):
+            create_method(tab_frame)
+    
     def _create_general_tab(self, frame):
         """Create the General settings tab."""
         content_parent = None