v0.8.0

- Add persistent saving for the custom exclusions

Author: Avaxerrr

main.py

@@ -14,6 +14,7 @@
 from core.exclusion_manager import ExclusionManager
 from utils.file_exporter import FileExporter
 from utils.theme_manager import ThemeManager
+from utils.exclusion_config import load_exclusion_config, save_exclusion_config
 import resources_rc
 
 class FileTreeGeneratorApp:
@@ -22,8 +23,6 @@ def __init__(self):
         self._set_app_icon()
 
         # ---- Global font setup (from qrc) ----
-        # Make sure the font is listed in your resources.qrc, e.g.:
-        # <file>resources/Sora-VariableFont_wght.ttf</file>
         font_id = QFontDatabase.addApplicationFont(":/resources/Sora-VariableFont_wght.ttf")
         if font_id != -1:
             families = QFontDatabase.applicationFontFamilies(font_id)
@@ -48,6 +47,9 @@ def __init__(self):
         # Initialize exclusion manager
         self.exclusion_manager = ExclusionManager()
 
+        # Load exclusion config and apply to panel/manager
+        self._load_and_apply_exclusion_config()
+
         # Connect signals
         self.window.address_bar.path_changed.connect(self.generate_tree)
         self.window.address_bar.refresh_requested.connect(self.refresh_tree)
@@ -56,7 +58,9 @@ def __init__(self):
         self.window.export_panel.export_requested.connect(self.export_tree)
         self.window.exclusion_panel.exclusions_changed.connect(self.update_exclusions)
 
-        # Initialize current path and tree data
+        # Ensure exclusion config is saved on app exit
+        self.app.aboutToQuit.connect(self._save_exclusion_config)
+
         self.current_path = ""
         self.tree_data = None
 
@@ -77,18 +81,44 @@ def process_command_line(self):
                 # Set the path in the address bar and generate tree
                 self.window.address_bar.set_path(folder_path)
 
+    def _load_and_apply_exclusion_config(self):
+        """Load exclusions and checkbox state from config.json and apply to panel/manager"""
+        config = load_exclusion_config()
+        patterns = config.get("patterns", [])
+        use_common = config.get("use_common", True)
+        # Set UI panel
+        self.window.exclusion_panel.set_exclusion_patterns(patterns)
+        self.window.exclusion_panel.set_use_common_exclusions(use_common)
+        # Set backend manager
+        self.exclusion_manager.clear_patterns()
+        for pattern in patterns:
+            self.exclusion_manager.add_pattern(pattern)
+        self.exclusion_manager.set_use_common_exclusions(use_common)
+
+    def _save_exclusion_config(self):
+        """Save current exclusions and checkbox state to config.json"""
+        patterns = self.window.exclusion_panel.get_exclusion_patterns()
+        use_common = self.window.exclusion_panel.use_common_exclusions()
+        print(f"[LOG] Saving exclusion config: {len(patterns)} patterns, use_common={use_common}")
+        save_exclusion_config(patterns, use_common)
+        print("[LOG] Exclusion config saved successfully.")
+
     def update_exclusions(self):
         """Update exclusion patterns from the UI and regenerate tree"""
         # Update exclusion manager from UI
         self.exclusion_manager.clear_patterns()
         patterns = self.window.exclusion_panel.get_exclusion_patterns()
+        print(f"[LOG] Updating exclusions: {len(patterns)} patterns")
         for pattern in patterns:
             self.exclusion_manager.add_pattern(pattern)
 
         # Set common exclusions setting
-        self.exclusion_manager.set_use_common_exclusions(
-            self.window.exclusion_panel.use_common_exclusions()
-        )
+        use_common = self.window.exclusion_panel.use_common_exclusions()
+        print(f"[LOG] Use common exclusions: {use_common}")
+        self.exclusion_manager.set_use_common_exclusions(use_common)
+
+        # Save exclusions immediately on change
+        self._save_exclusion_config()
 
         # Regenerate tree if we have a path
         if self.current_path:
@@ -107,7 +137,6 @@ def generate_tree(self, path: str):
 
             # Format and display the tree
             self.update_tree_format()
-
             self.window.set_status(f"Directory scanned successfully: {path}")
         except Exception as e:
             self.window.set_status(f"Error scanning directory: {str(e)}")

ui/components/exclusion_panel.py

@@ -117,3 +117,15 @@ def get_exclusion_patterns(self) -> list:
     def use_common_exclusions(self) -> bool:
         """Check if common exclusions should be used"""
         return self.common_exclusions_cb.isChecked()
+
+    def set_exclusion_patterns(self, patterns: list):
+        """Set the list of exclusion patterns in the UI."""
+        self.exclusion_list.clear()
+        for pattern in patterns:
+            self.exclusion_list.addItem(pattern)
+        self._on_exclusions_changed()  # Optionally emit signal if you want
+
+    def set_use_common_exclusions(self, use: bool):
+        """Set the state of the 'Use common exclusions' checkbox."""
+        self.common_exclusions_cb.setChecked(use)
+        # self._on_exclusions_changed()  # Not needed, as toggling the checkbox emits the signal

utils/exclusion_config.py

@@ -0,0 +1,43 @@
+import os
+import json
+import sys
+
+def get_config_path():
+    """Return the path to config.json in the executable's directory."""
+    if getattr(sys, 'frozen', False):
+        # Running as a packaged executable
+        base_dir = os.path.dirname(sys.executable)
+    else:
+        # Running as a script
+        base_dir = os.path.dirname(os.path.abspath(__file__))
+        # Go up to project root if in utils/
+        base_dir = os.path.abspath(os.path.join(base_dir, '..'))
+    return os.path.join(base_dir, "config.json")
+
+def load_exclusion_config():
+    """Load exclusion patterns and use_common flag from config.json"""
+    config_path = get_config_path()
+    if os.path.exists(config_path):
+        try:
+            with open(config_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+                patterns = data.get("patterns", [])
+                use_common = data.get("use_common", True)
+                return {"patterns": patterns, "use_common": use_common}
+        except Exception:
+            pass
+    # Defaults if not found or error
+    return {"patterns": [], "use_common": True}
+
+def save_exclusion_config(patterns, use_common):
+    """Save exclusion patterns and use_common flag to config.json"""
+    config_path = get_config_path()
+    data = {
+        "patterns": patterns,
+        "use_common": use_common
+    }
+    try:
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(data, f, indent=2)
+    except Exception as e:
+        print(f"Failed to save exclusion config: {e}")