supervertaler 1.9.146__py3-none-any.whl → 1.9.149__py3-none-any.whl

Supervertaler.py

@@ -13,7 +13,7 @@ For the classic tkinter edition, see Supervertaler_tkinter.py
 Key Features:
 - Complete Translation Matching: Termbase + TM + MT + Multi-LLM
 - Project Termbases: Dedicated terminology per project with automatic extraction
-- Supervoice: AI-powered voice dictation (100+ languages via OpenAI Whisper)
+- Supervoice: AI-enhanced voice dictation (100+ languages via OpenAI Whisper)
 - Superimage: Extract images from DOCX files with preview
 - Google Cloud Translation API integration
 - Multi-LLM Support: OpenAI GPT, Claude, Google Gemini
@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.146"
+__version__ = "1.9.149-beta"
 __phase__ = "0.9"
-__release_date__ = "2026-01-20"
+__release_date__ = "2026-01-21"
 __edition__ = "Qt"
 
 import sys
@@ -61,21 +61,148 @@ def get_resource_path(relative_path: str) -> Path:
     return base_path / relative_path
 
 
+def get_config_pointer_path() -> Path:
+    """
+    Get path to the config pointer file that stores the user's chosen data location.
+    
+    This is stored in a standard config location:
+    - Windows: %APPDATA%/Supervertaler/config.json
+    - macOS:   ~/Library/Application Support/Supervertaler/config.json
+    - Linux:   ~/.config/Supervertaler/config.json
+    
+    This small file just contains a pointer to where the real data lives.
+    """
+    if sys.platform == 'win32':
+        # Windows: %APPDATA% (Roaming, syncs across machines on domain)
+        appdata = os.environ.get('APPDATA', os.path.expanduser('~'))
+        return Path(appdata) / "Supervertaler" / "config.json"
+    elif sys.platform == 'darwin':
+        # macOS: ~/Library/Application Support/
+        return Path.home() / "Library" / "Application Support" / "Supervertaler" / "config.json"
+    else:
+        # Linux/BSD: ~/.config/ (XDG_CONFIG_HOME)
+        xdg_config = os.environ.get('XDG_CONFIG_HOME', os.path.expanduser('~/.config'))
+        return Path(xdg_config) / "Supervertaler" / "config.json"
+
+
+def get_default_user_data_path() -> Path:
+    """
+    Get the DEFAULT user data path (visible in home folder).
+    
+    - Windows: C:/Users/Username/Supervertaler/
+    - macOS:   ~/Supervertaler/
+    - Linux:   ~/Supervertaler/
+    
+    This is intentionally a visible, easily-accessible location.
+    """
+    return Path.home() / "Supervertaler"
+
+
+def save_user_data_path(path: Path) -> None:
+    """Save the user's chosen data path to the config pointer file."""
+    pointer_path = get_config_pointer_path()
+    pointer_path.parent.mkdir(parents=True, exist_ok=True)
+    
+    config = {"user_data_path": str(path)}
+    with open(pointer_path, 'w', encoding='utf-8') as f:
+        json.dump(config, f, indent=2)
+
+
+def load_user_data_path_from_config() -> Optional[Path]:
+    """
+    Load the user's chosen data path from config pointer file.
+    Returns None if no config exists or path is invalid.
+    """
+    pointer_path = get_config_pointer_path()
+    
+    if not pointer_path.exists():
+        return None
+    
+    try:
+        with open(pointer_path, 'r', encoding='utf-8') as f:
+            config = json.load(f)
+        
+        path_str = config.get('user_data_path')
+        if path_str:
+            return Path(path_str)
+    except (json.JSONDecodeError, OSError):
+        pass
+    
+    return None
+
+
 def get_user_data_path() -> Path:
     """
     Get the path to user data directory.
     
-    In frozen builds (EXE): 'user_data' folder next to the EXE
-    In development: 'user_data' folder next to the script
+    Resolution order:
+    1. Check config pointer file for user's saved preference
+    2. If pointer missing, check if default location has data (auto-recover)
+    3. If nothing found, return default (first-run dialog will be shown later)
+    
+    All users (EXE, pip, dev) use the same unified system:
+    - Default: ~/Supervertaler/ (visible in home folder)
+    - User can choose custom location on first run
+    - Config pointer remembers their choice
     
-    The build process copies user_data directly next to the EXE for easy access.
+    This ensures data survives pip upgrades, EXE updates, and is easy to find/backup.
     """
-    if getattr(sys, 'frozen', False):
-        # Frozen build: user_data is next to the EXE (copied by build script)
-        return Path(sys.executable).parent / "user_data"
-    else:
-        # Development: user_data next to script
-        return Path(__file__).parent / "user_data"
+    # 1. Check if user has a saved preference
+    saved_path = load_user_data_path_from_config()
+    if saved_path and saved_path.exists():
+        return saved_path
+    
+    # 2. Check if default location has data (auto-recovery if pointer deleted)
+    default_path = get_default_user_data_path()
+    if default_path.exists():
+        # Check if it has actual content
+        has_content = False
+        try:
+            for item in default_path.iterdir():
+                if item.is_file() or (item.is_dir() and any(item.iterdir())):
+                    has_content = True
+                    break
+        except OSError:
+            pass
+        
+        if has_content:
+            # Auto-recover: recreate the pointer file
+            save_user_data_path(default_path)
+            print(f"[Data Paths] Auto-recovered config pointer to: {default_path}")
+            return default_path
+    
+    # 3. Return default path (first-run dialog will be shown by MainWindow)
+    # Don't create folder yet - let the dialog handle that
+    return default_path
+
+
+def needs_first_run_data_dialog() -> bool:
+    """
+    Check if we need to show the first-run data location dialog.
+    
+    Returns True if:
+    - No config pointer file exists, AND
+    - Default data location doesn't have existing content
+    
+    This means it's truly a fresh install.
+    """
+    # If config pointer exists, user has already chosen a location
+    pointer_path = get_config_pointer_path()
+    if pointer_path.exists():
+        return False
+    
+    # If default location has content, we auto-recovered (no dialog needed)
+    default_path = get_default_user_data_path()
+    if default_path.exists():
+        try:
+            for item in default_path.iterdir():
+                if item.is_file() or (item.is_dir() and any(item.iterdir())):
+                    return False  # Has content, no dialog needed
+        except OSError:
+            pass
+    
+    # Truly a fresh install - need to show dialog
+    return True
 
 import threading
 import time  # For delays in Superlookup
@@ -5167,35 +5294,48 @@ class SupervertalerQt(QMainWindow):
         # ============================================================================
         # USER DATA PATH INITIALIZATION
         # ============================================================================
-        # Set up user data paths - handles both development and frozen (EXE) builds
-        # In frozen builds, user_data is copied directly next to the EXE by the build script.
+        # ALL users (EXE, pip, dev) now use a unified system:
+        # - Default location: ~/Supervertaler/ (visible in home folder)
+        # - User can choose custom location on first run
+        # - Config pointer stores their choice at standard config location
+        # - Auto-recovery if pointer is deleted but data exists at default location
         from modules.database_manager import DatabaseManager
         
+        # Check if this is first run BEFORE getting the path
+        # (so we know whether to show the data location dialog later)
+        self._needs_data_location_dialog = needs_first_run_data_dialog()
+        
         if ENABLE_PRIVATE_FEATURES:
             # Developer mode: use private folder (git-ignored)
             self.user_data_path = Path(__file__).parent / "user_data_private"
+            self._needs_data_location_dialog = False  # Dev mode doesn't need dialog
         else:
-            # Normal mode: use the helper function
+            # Normal mode: use unified system (same for pip, EXE, etc.)
             self.user_data_path = get_user_data_path()
         
         # Ensure user_data directory exists (creates empty folder if missing)
-        self.user_data_path.mkdir(parents=True, exist_ok=True)
+        # BUT only if we're not going to show the dialog (which will create the chosen folder)
+        if not self._needs_data_location_dialog:
+            self.user_data_path.mkdir(parents=True, exist_ok=True)
         
         print(f"[Data Paths] User data: {self.user_data_path}")
         
         # Database Manager for Termbases
         self.db_manager = DatabaseManager(
-            db_path=str(self.user_data_path / "Translation_Resources" / "supervertaler.db"),
+            db_path=str(self.user_data_path / "resources" / "supervertaler.db"),
             log_callback=self.log
         )
-        self.db_manager.connect()
+        # Only connect if we're not showing the dialog (which will create the folder)
+        # If dialog is needed, we'll connect after user chooses location
+        if not self._needs_data_location_dialog:
+            self.db_manager.connect()
         
         # TM Database - Initialize early so Superlookup works without a project loaded
         from modules.translation_memory import TMDatabase
         self.tm_database = TMDatabase(
             source_lang=None,  # Will be set when project is loaded
             target_lang=None,  # Will be set when project is loaded
-            db_path=str(self.user_data_path / "Translation_Resources" / "supervertaler.db"),
+            db_path=str(self.user_data_path / "resources" / "supervertaler.db"),
             log_callback=self.log
         )
         
@@ -5312,11 +5452,184 @@ class SupervertalerQt(QMainWindow):
             from PyQt6.QtCore import QTimer
             QTimer.singleShot(2000, lambda: self._check_for_new_models(force=False))  # 2 second delay
         
-        # First-run check - show Features tab to new users
-        if not general_settings.get('first_run_completed', False):
+        # First-run check - show data location dialog, then Features tab
+        if self._needs_data_location_dialog:
+            from PyQt6.QtCore import QTimer
+            QTimer.singleShot(300, self._show_data_location_dialog)
+        elif not general_settings.get('first_run_completed', False):
             from PyQt6.QtCore import QTimer
             QTimer.singleShot(500, self._show_first_run_welcome)
     
+    def _show_data_location_dialog(self):
+        """Show dialog to let user choose their data folder location on first run."""
+        try:
+            from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel, 
+                                         QPushButton, QLineEdit, QFileDialog, QDialogButtonBox)
+            
+            dialog = QDialog(self)
+            dialog.setWindowTitle("Choose Data Folder Location")
+            dialog.setMinimumWidth(550)
+            dialog.setModal(True)
+            
+            layout = QVBoxLayout(dialog)
+            layout.setSpacing(15)
+            
+            # Title
+            title_label = QLabel("<h2>📁 Choose Your Data Folder</h2>")
+            layout.addWidget(title_label)
+            
+            # Explanation
+            msg_label = QLabel(
+                "Supervertaler stores your data in a folder of your choice, which contains things like:<br><br>"
+                "• API keys<br>"
+                "• Translation memories<br>"
+                "• Glossaries<br>"
+                "• Prompts<br>"
+                "• Settings<br><br>"
+                "Choose a location that's easy to find and backup.<br>"
+                "You can change this later in Settings → General."
+            )
+            msg_label.setWordWrap(True)
+            layout.addWidget(msg_label)
+            
+            # Path input with browse button
+            path_layout = QHBoxLayout()
+            
+            path_edit = QLineEdit()
+            default_path = get_default_user_data_path()
+            path_edit.setText(str(default_path))
+            path_edit.setMinimumWidth(350)
+            path_layout.addWidget(path_edit)
+            
+            browse_btn = QPushButton("Browse...")
+            def browse_folder():
+                folder = QFileDialog.getExistingDirectory(
+                    dialog, 
+                    "Choose Data Folder",
+                    str(Path.home())
+                )
+                if folder:
+                    # Append "Supervertaler" if user didn't include it
+                    folder_path = Path(folder)
+                    if folder_path.name != "Supervertaler":
+                        folder_path = folder_path / "Supervertaler"
+                    path_edit.setText(str(folder_path))
+            
+            browse_btn.clicked.connect(browse_folder)
+            path_layout.addWidget(browse_btn)
+            
+            layout.addLayout(path_layout)
+            
+            # Tip
+            tip_label = QLabel(
+                "💡 <b>Tip:</b> The default location is in your home folder, "
+                "making it easy to find and backup."
+            )
+            tip_label.setWordWrap(True)
+            tip_label.setStyleSheet("color: #666;")
+            layout.addWidget(tip_label)
+            
+            # Buttons
+            button_layout = QHBoxLayout()
+            
+            default_btn = QPushButton("Use Default")
+            default_btn.clicked.connect(lambda: path_edit.setText(str(default_path)))
+            button_layout.addWidget(default_btn)
+            
+            button_layout.addStretch()
+            
+            ok_btn = QPushButton("OK")
+            ok_btn.setDefault(True)
+            ok_btn.clicked.connect(dialog.accept)
+            button_layout.addWidget(ok_btn)
+            
+            layout.addLayout(button_layout)
+            
+            # Show dialog
+            if dialog.exec() == QDialog.DialogCode.Accepted:
+                chosen_path = Path(path_edit.text())
+                
+                # Create the folder
+                chosen_path.mkdir(parents=True, exist_ok=True)
+                
+                # Save the choice to config pointer
+                save_user_data_path(chosen_path)
+                
+                # Update our path if different from what we initialized with
+                if chosen_path != self.user_data_path:
+                    self.user_data_path = chosen_path
+                    # Re-initialize managers with new path
+                    self._reinitialize_with_new_data_path()
+                else:
+                    # Same path, but we still need to connect database (it was deferred)
+                    if hasattr(self, 'db_manager') and self.db_manager and not self.db_manager.connection:
+                        self.db_manager.connect()
+                
+                self.log(f"📁 Data folder set to: {chosen_path}")
+                
+                # Now show the features welcome dialog
+                from PyQt6.QtCore import QTimer
+                QTimer.singleShot(300, self._show_first_run_welcome)
+            else:
+                # User cancelled - use default anyway
+                default_path.mkdir(parents=True, exist_ok=True)
+                save_user_data_path(default_path)
+                self.log(f"📁 Using default data folder: {default_path}")
+                
+        except Exception as e:
+            self.log(f"⚠️ Data location dialog error: {e}")
+            import traceback
+            traceback.print_exc()
+    
+    def _reinitialize_with_new_data_path(self):
+        """Re-initialize managers after user changes data path."""
+        try:
+            # Close existing database connection
+            if hasattr(self, 'db_manager') and self.db_manager:
+                self.db_manager.close()
+            
+            # Re-initialize database manager
+            from modules.database_manager import DatabaseManager
+            self.db_manager = DatabaseManager(
+                db_path=str(self.user_data_path / "resources" / "supervertaler.db"),
+                log_callback=self.log
+            )
+            self.db_manager.connect()
+            
+            # Re-initialize TM database
+            from modules.translation_memory import TMDatabase
+            self.tm_database = TMDatabase(
+                source_lang=None,
+                target_lang=None,
+                db_path=str(self.user_data_path / "resources" / "supervertaler.db"),
+                log_callback=self.log
+            )
+            
+            # Re-initialize TM metadata manager
+            from modules.tm_metadata_manager import TMMetadataManager
+            self.tm_metadata_mgr = TMMetadataManager(self.db_manager, self.log)
+            
+            # Update other managers
+            self.spellcheck_manager = get_spellcheck_manager(str(self.user_data_path))
+            self.fr_history = FindReplaceHistory(str(self.user_data_path))
+            self.shortcut_manager = ShortcutManager(Path(self.user_data_path) / "shortcuts.json")
+            self.voice_command_manager = VoiceCommandManager(self.user_data_path, main_window=self)
+            
+            # Update theme manager
+            from modules.theme_manager import ThemeManager
+            self.theme_manager = ThemeManager(self.user_data_path)
+            self.theme_manager.apply_theme(QApplication.instance())
+            
+            # Update recent projects file path
+            self.recent_projects_file = self.user_data_path / "recent_projects.json"
+            
+            self.log(f"✅ Re-initialized all managers with new data path")
+            
+        except Exception as e:
+            self.log(f"⚠️ Error re-initializing managers: {e}")
+            import traceback
+            traceback.print_exc()
+    
     def _show_first_run_welcome(self):
         """Show welcome message and Features tab on first run."""
         try:
@@ -5738,7 +6051,7 @@ class SupervertalerQt(QMainWindow):
                     quickmenu_items = lib.get_quickmenu_grid_prompts() or []
             
             if not quickmenu_items:
-                self.log("⚠️ No QuickMenu prompts available. Add prompts with 'Show in Supervertaler QuickMenu' enabled.")
+                self.log("⚠️ No QuickMenu prompts available. Add prompts with 'Show in QuickMenu' enabled.")
                 return
             
             # Find the currently focused widget (source or target cell)
@@ -6419,7 +6732,7 @@ class SupervertalerQt(QMainWindow):
         go_resources_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(1) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_resources_action)
         
-        go_prompt_manager_action = QAction("🤖 &Prompt Manager", self)
+        go_prompt_manager_action = QAction("⚡ &QuickMenu", self)
         go_prompt_manager_action.triggered.connect(lambda: self.main_tabs.setCurrentIndex(2) if hasattr(self, 'main_tabs') else None)
         nav_menu.addAction(go_prompt_manager_action)
         
@@ -6898,13 +7211,13 @@ class SupervertalerQt(QMainWindow):
         resources_tab = self.create_resources_tab()
         self.main_tabs.addTab(resources_tab, "🗂️ Resources")
         
-        # ===== 3. PROMPT MANAGER TAB =====
-        # Unified Prompt Library + AI Assistant
+        # ===== 3. QUICKMENU TAB =====
+        # Unified QuickMenu system: folder structure = menu hierarchy for in-app + global access
         from modules.unified_prompt_manager_qt import UnifiedPromptManagerQt
         prompt_widget = QWidget()
         self.prompt_manager_qt = UnifiedPromptManagerQt(self, standalone=False)
         self.prompt_manager_qt.create_tab(prompt_widget)
-        self.main_tabs.addTab(prompt_widget, "🤖 Prompt Manager")
+        self.main_tabs.addTab(prompt_widget, "⚡ QuickMenu")
         
         # Keep backward compatibility reference
         self.document_views_widget = self.main_tabs
@@ -6964,7 +7277,7 @@ class SupervertalerQt(QMainWindow):
         layout.addWidget(desc)
         
         # Initialize NT manager
-        nt_path = self.user_data_path / "Translation_Resources" / "Non-translatables"
+        nt_path = self.user_data_path / "resources" / "non_translatables"
         nt_path.mkdir(parents=True, exist_ok=True)
         self.nt_manager = NonTranslatablesManager(str(nt_path), self.log)
         
@@ -8308,7 +8621,7 @@ class SupervertalerQt(QMainWindow):
         from modules.superbrowser import SuperbrowserWidget
 
         # Create and return the Superbrowser widget
-        superbrowser_widget = SuperbrowserWidget(parent=self)
+        superbrowser_widget = SuperbrowserWidget(parent=self, user_data_path=self.user_data_path)
 
         return superbrowser_widget
 
@@ -8595,7 +8908,7 @@ class SupervertalerQt(QMainWindow):
             
             # Create new Superlookup instance for detached window
             # Or move the existing one - better to create new to avoid widget parenting issues
-            detached_lookup = SuperlookupTab(self.lookup_detached_window)
+            detached_lookup = SuperlookupTab(self.lookup_detached_window, user_data_path=self.user_data_path)
             
             # Explicitly copy theme_manager reference
             detached_lookup.theme_manager = self.theme_manager
@@ -8732,7 +9045,7 @@ class SupervertalerQt(QMainWindow):
         # Superdocs removed (online GitBook will be used instead)
 
         print("[DEBUG] About to create SuperlookupTab...")
-        lookup_tab = SuperlookupTab(self)
+        lookup_tab = SuperlookupTab(self, user_data_path=self.user_data_path)
         print("[DEBUG] SuperlookupTab created successfully")
         self.lookup_tab = lookup_tab  # Store reference for later use
         modules_tabs.addTab(lookup_tab, "🔍 Superlookup")
@@ -9176,58 +9489,139 @@ class SupervertalerQt(QMainWindow):
                     # Show progress dialog
                     from PyQt6.QtWidgets import QProgressDialog
                     from PyQt6.QtCore import Qt
+                    import time
                     
-                    progress = QProgressDialog("Importing TMX file...", None, 0, 0, self)
+                    # Create progress dialog with cancel button
+                    progress = QProgressDialog("Counting translation units...", "Cancel", 0, 100, self)
                     progress.setWindowTitle("TMX Import")
                     progress.setWindowModality(Qt.WindowModality.WindowModal)
                     progress.setMinimumDuration(0)
+                    progress.setAutoClose(False)
+                    progress.setAutoReset(False)
                     progress.setValue(0)
                     progress.show()
                     QApplication.processEvents()
                     
+                    # Track if user cancelled
+                    cancelled = False
+                    start_time = time.time()
+                    
+                    def update_progress(current, total, message):
+                        nonlocal cancelled
+                        if progress.wasCanceled():
+                            cancelled = True
+                            return
+                        
+                        if total > 0:
+                            percentage = int((current / total) * 100)
+                            progress.setValue(percentage)
+                            
+                            # Calculate time stats
+                            elapsed = time.time() - start_time
+                            if current > 0:
+                                rate = current / elapsed
+                                remaining = (total - current) / rate if rate > 0 else 0
+                                
+                                # Format message with stats
+                                time_info = f" (~{int(remaining/60)}m {int(remaining%60)}s remaining)" if remaining > 10 else ""
+                                progress.setLabelText(f"{message}\nRate: {int(rate):,} entries/sec{time_info}")
+                            else:
+                                progress.setLabelText(message)
+                        else:
+                            progress.setLabelText(message)
+                        
+                        QApplication.processEvents()
+                    
                     if choice == 'import_strip':
                         # Import with variant stripping
                         tm_id, count = self.tm_database.load_tmx_file(
                             file_path, source_lang, target_lang, 
-                            tm_name=None, read_only=False
+                            tm_name=None, read_only=False, progress_callback=update_progress
                         )
                         progress.close()
-                        self.log(f"Imported {count} entries (variants stripped: {compat['tmx_source']}, {compat['tmx_target']} → {source_lang}, {target_lang})")
-                        QMessageBox.information(
-                            self, "Import Complete",
-                            f"TMX imported successfully!\n\nEntries: {count}\n"
-                            f"Mapped: {compat['tmx_source']}, {compat['tmx_target']} → {source_lang}, {target_lang}"
-                        )
+                        
+                        if not cancelled:
+                            self.log(f"Imported {count} entries (variants stripped: {compat['tmx_source']}, {compat['tmx_target']} → {source_lang}, {target_lang})")
+                            QMessageBox.information(
+                                self, "Import Complete",
+                                f"TMX imported successfully!\n\nEntries: {count:,}\n"
+                                f"Mapped: {compat['tmx_source']}, {compat['tmx_target']} → {source_lang}, {target_lang}"
+                            )
+                        else:
+                            self.log("TMX import cancelled by user")
+                            QMessageBox.information(self, "Import Cancelled", f"Import stopped.\n\nPartial entries may have been imported: {count:,}")
                     elif choice == 'create_new':
                         # Create new TM with variant languages
                         tm_id, count = self.tm_database.load_tmx_file(
                             file_path, compat['tmx_source'], compat['tmx_target'],
-                            tm_name=None, read_only=False
+                            tm_name=None, read_only=False, progress_callback=update_progress
                         )
                         progress.close()
-                        self.log(f"Created new TM with variants: {compat['tmx_source']}, {compat['tmx_target']}")
-                        QMessageBox.information(
-                            self, "Import Complete", 
-                            f"New TM created!\n\nTM ID: {tm_id}\nEntries: {count}\n"
-                            f"Languages: {compat['tmx_source']}, {compat['tmx_target']}"
-                        )
+                        
+                        if not cancelled:
+                            self.log(f"Created new TM with variants: {compat['tmx_source']}, {compat['tmx_target']}")
+                            QMessageBox.information(
+                                self, "Import Complete", 
+                                f"New TM created!\n\nTM ID: {tm_id}\nEntries: {count:,}\n"
+                                f"Languages: {compat['tmx_source']}, {compat['tmx_target']}"
+                            )
+                        else:
+                            self.log("TMX import cancelled by user")
+                            QMessageBox.information(self, "Import Cancelled", f"Import stopped.\n\nPartial entries may have been imported: {count:,}")
                 else:
-                    # Exact match - proceed normally with progress
+                    # Exact match - proceed normally with real-time progress
                     from PyQt6.QtWidgets import QProgressDialog
                     from PyQt6.QtCore import Qt
+                    import time
                     
-                    progress = QProgressDialog("Importing TMX file...", None, 0, 0, self)
+                    progress = QProgressDialog("Counting translation units...", "Cancel", 0, 100, self)
                     progress.setWindowTitle("TMX Import")
                     progress.setWindowModality(Qt.WindowModality.WindowModal)
                     progress.setMinimumDuration(0)
+                    progress.setAutoClose(False)
+                    progress.setAutoReset(False)
                     progress.setValue(0)
                     progress.show()
                     QApplication.processEvents()
                     
-                    tm_id, count = self.tm_database.load_tmx_file(file_path, source_lang, target_lang)
+                    cancelled = False
+                    start_time = time.time()
+                    
+                    def update_progress(current, total, message):
+                        nonlocal cancelled
+                        if progress.wasCanceled():
+                            cancelled = True
+                            return
+                        
+                        if total > 0:
+                            percentage = int((current / total) * 100)
+                            progress.setValue(percentage)
+                            
+                            # Calculate time stats
+                            elapsed = time.time() - start_time
+                            if current > 0:
+                                rate = current / elapsed
+                                remaining = (total - current) / rate if rate > 0 else 0
+                                
+                                # Format message with stats
+                                time_info = f" (~{int(remaining/60)}m {int(remaining%60)}s remaining)" if remaining > 10 else ""
+                                progress.setLabelText(f"{message}\nRate: {int(rate):,} entries/sec{time_info}")
+                            else:
+                                progress.setLabelText(message)
+                        else:
+                            progress.setLabelText(message)
+                        
+                        QApplication.processEvents()
+                    
+                    tm_id, count = self.tm_database.load_tmx_file(file_path, source_lang, target_lang, progress_callback=update_progress)
                     progress.close()
-                    self.log(f"Successfully imported {count} entries from TMX file")
-                    QMessageBox.information(self, "Import Complete", f"TMX imported!\n\nEntries: {count}\nTM ID: {tm_id}")
+                    
+                    if not cancelled:
+                        self.log(f"Successfully imported {count} entries from TMX file")
+                        QMessageBox.information(self, "Import Complete", f"TMX imported!\n\nEntries: {count:,}\nTM ID: {tm_id}")
+                    else:
+                        self.log("TMX import cancelled by user")
+                        QMessageBox.information(self, "Import Cancelled", f"Import stopped.\n\nPartial entries may have been imported: {count:,}")
             
         except Exception as e:
             self.log(f"Error importing TMX file: {e}")
@@ -10359,7 +10753,7 @@ class SupervertalerQt(QMainWindow):
                 if reply2 == QMessageBox.StandardButton.Yes and self.tm_database:
                     # Clear TM entries
                     import sqlite3
-                    db_path = self.user_data_path / "Translation_Resources" / "supervertaler.db"
+                    db_path = self.user_data_path / "resources" / "supervertaler.db"
                     conn = sqlite3.connect(str(db_path))
                     cursor = conn.cursor()
                     cursor.execute("DELETE FROM translation_units")
@@ -13458,29 +13852,66 @@ class SupervertalerQt(QMainWindow):
                     if reply != QMessageBox.StandardButton.Yes:
                         return
                 
-                # Import into existing TM with progress dialog
+                # Import into existing TM with real-time progress dialog
                 from PyQt6.QtWidgets import QProgressDialog
                 from PyQt6.QtCore import Qt
+                import time
                 
-                progress = QProgressDialog("Importing TMX file...", None, 0, 0, self)
+                progress = QProgressDialog("Counting translation units...", "Cancel", 0, 100, self)
                 progress.setWindowTitle("TMX Import")
                 progress.setWindowModality(Qt.WindowModality.WindowModal)
                 progress.setMinimumDuration(0)
+                progress.setAutoClose(False)
+                progress.setAutoReset(False)
                 progress.setValue(0)
                 progress.show()
                 QApplication.processEvents()
                 
+                cancelled = False
+                start_time = time.time()
+                
+                def update_progress(current, total, message):
+                    nonlocal cancelled
+                    if progress.wasCanceled():
+                        cancelled = True
+                        return
+                    
+                    if total > 0:
+                        percentage = int((current / total) * 100)
+                        progress.setValue(percentage)
+                        
+                        # Calculate time stats
+                        elapsed = time.time() - start_time
+                        if current > 0:
+                            rate = current / elapsed
+                            remaining = (total - current) / rate if rate > 0 else 0
+                            
+                            # Format message with stats
+                            time_info = f" (~{int(remaining/60)}m {int(remaining%60)}s remaining)" if remaining > 10 else ""
+                            progress.setLabelText(f"{message}\nRate: {int(rate):,} entries/sec{time_info}")
+                        else:
+                            progress.setLabelText(message)
+                    else:
+                        progress.setLabelText(message)
+                    
+                    QApplication.processEvents()
+                
                 count = self.tm_database._load_tmx_into_db(
-                    filepath, tm_src_lang, tm_tgt_lang, target_tm_id, strip_variants=strip_variants
+                    filepath, tm_src_lang, tm_tgt_lang, target_tm_id, 
+                    strip_variants=strip_variants, progress_callback=update_progress
                 )
                 
                 progress.close()
                 
-                # Update entry count
-                tm_metadata_mgr.update_entry_count(target_tm_id)
-                self.log(f"Imported {count} entries into TM '{target_tm_id}'")
-                
-                QMessageBox.information(self, "Success", f"TMX imported successfully into TM '{target_tm_id}'!\n\nEntries imported: {count}")
+                if not cancelled:
+                    # Update entry count
+                    tm_metadata_mgr.update_entry_count(target_tm_id)
+                    self.log(f"Imported {count} entries into TM '{target_tm_id}'")
+                    
+                    QMessageBox.information(self, "Success", f"TMX imported successfully into TM '{target_tm_id}'!\n\nEntries imported: {count:,}")
+                else:
+                    self.log(f"TMX import cancelled by user. Partial import: {count} entries")
+                    QMessageBox.information(self, "Import Cancelled", f"Import stopped.\n\nPartial entries imported: {count:,}")
                 refresh_callback()
             else:
                 QMessageBox.critical(self, "Error", "TM database not available")
@@ -14260,7 +14691,7 @@ class SupervertalerQt(QMainWindow):
         auto_markdown_cb.setChecked(general_settings.get('auto_generate_markdown', False))
         auto_markdown_cb.setToolTip(
             "Automatically convert imported documents to markdown format\n"
-            "for AI Assistant access in user_data_private/AI_Assistant/current_document/"
+            "for AI Assistant access in user_data_private/ai_assistant/current_document/"
         )
         behavior_layout.addWidget(auto_markdown_cb)
         
@@ -14472,7 +14903,7 @@ class SupervertalerQt(QMainWindow):
     
     def _create_general_settings_tab(self):
         """Create General Settings tab content"""
-        from PyQt6.QtWidgets import QCheckBox, QGroupBox, QPushButton
+        from PyQt6.QtWidgets import QCheckBox, QGroupBox, QPushButton, QLineEdit, QFileDialog
         
         tab = QWidget()
         layout = QVBoxLayout(tab)
@@ -14502,6 +14933,119 @@ class SupervertalerQt(QMainWindow):
         startup_group.setLayout(startup_layout)
         layout.addWidget(startup_group)
 
+        # Data Folder Location group
+        data_folder_group = QGroupBox("📁 Data Folder Location")
+        data_folder_layout = QVBoxLayout()
+        
+        data_folder_info = QLabel(
+            "Your translation memories, glossaries, prompts, and settings are stored here:"
+        )
+        data_folder_info.setWordWrap(True)
+        data_folder_layout.addWidget(data_folder_info)
+        
+        # Path display with browse button
+        path_row = QHBoxLayout()
+        
+        data_path_edit = QLineEdit()
+        data_path_edit.setText(str(self.user_data_path))
+        data_path_edit.setReadOnly(True)
+        data_path_edit.setToolTip("Current data folder location")
+        path_row.addWidget(data_path_edit)
+        
+        change_path_btn = QPushButton("Change...")
+        change_path_btn.setToolTip("Choose a different location for your data folder")
+        
+        def change_data_path():
+            """Let user change their data folder location."""
+            from PyQt6.QtWidgets import QMessageBox
+            
+            folder = QFileDialog.getExistingDirectory(
+                self, 
+                "Choose New Data Folder Location",
+                str(Path.home())
+            )
+            if folder:
+                folder_path = Path(folder)
+                # Append "Supervertaler" if user didn't include it
+                if folder_path.name != "Supervertaler":
+                    folder_path = folder_path / "Supervertaler"
+                
+                # Warn if switching to a folder with existing data
+                if folder_path.exists() and folder_path != self.user_data_path:
+                    has_content = any(folder_path.iterdir())
+                    if has_content:
+                        reply = QMessageBox.question(
+                            self,
+                            "Existing Data Found",
+                            f"The folder already contains data:\n{folder_path}\n\n"
+                            "Do you want to use this existing data?",
+                            QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.Cancel
+                        )
+                        if reply != QMessageBox.StandardButton.Yes:
+                            return
+                
+                # Create the folder
+                folder_path.mkdir(parents=True, exist_ok=True)
+                
+                # Ask if they want to copy existing data
+                if self.user_data_path.exists() and self.user_data_path != folder_path:
+                    reply = QMessageBox.question(
+                        self,
+                        "Copy Existing Data?",
+                        f"Would you like to copy your existing data to the new location?\n\n"
+                        f"From: {self.user_data_path}\n"
+                        f"To: {folder_path}\n\n"
+                        "This will NOT delete the original data.",
+                        QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No
+                    )
+                    if reply == QMessageBox.StandardButton.Yes:
+                        import shutil
+                        try:
+                            for item in self.user_data_path.iterdir():
+                                dest = folder_path / item.name
+                                if item.is_dir():
+                                    shutil.copytree(item, dest, dirs_exist_ok=True)
+                                else:
+                                    shutil.copy2(item, dest)
+                            self.log(f"✅ Copied data to new location")
+                        except Exception as e:
+                            QMessageBox.warning(self, "Copy Error", f"Failed to copy data: {e}")
+                
+                # Save the new path
+                save_user_data_path(folder_path)
+                data_path_edit.setText(str(folder_path))
+                
+                # Update and reinitialize
+                self.user_data_path = folder_path
+                self._reinitialize_with_new_data_path()
+                
+                QMessageBox.information(
+                    self,
+                    "Data Folder Changed",
+                    f"Data folder changed to:\n{folder_path}\n\n"
+                    "All managers have been reinitialized."
+                )
+        
+        change_path_btn.clicked.connect(change_data_path)
+        path_row.addWidget(change_path_btn)
+        
+        open_folder_btn = QPushButton("Open")
+        open_folder_btn.setToolTip("Open this folder in your file manager")
+        open_folder_btn.clicked.connect(lambda: os.startfile(str(self.user_data_path)) if sys.platform == 'win32' 
+                                         else subprocess.run(['xdg-open' if sys.platform == 'linux' else 'open', str(self.user_data_path)]))
+        path_row.addWidget(open_folder_btn)
+        
+        data_folder_layout.addLayout(path_row)
+        
+        data_folder_tip = QLabel(
+            "💡 This folder persists across updates. Back it up regularly!"
+        )
+        data_folder_tip.setStyleSheet("color: #666; font-size: 9pt;")
+        data_folder_layout.addWidget(data_folder_tip)
+        
+        data_folder_group.setLayout(data_folder_layout)
+        layout.addWidget(data_folder_group)
+
         # Sound Effects group
         sound_group = QGroupBox("🔊 Sound Effects")
         sound_layout = QVBoxLayout()
@@ -16537,7 +17081,7 @@ class SupervertalerQt(QMainWindow):
             prompt_text = self.prompt_manager_qt.get_system_template(mode_key)
         else:
             # Fallback: load from JSON file
-            system_prompts_file = self.user_data_path / "Prompt_Library" / "system_prompts_layer1.json"
+            system_prompts_file = self.user_data_path / "prompt_library" / "system_prompts_layer1.json"
             if system_prompts_file.exists():
                 import json
                 with open(system_prompts_file, 'r', encoding='utf-8') as f:
@@ -16566,7 +17110,7 @@ class SupervertalerQt(QMainWindow):
 
         # Always save to JSON file
         import json
-        system_prompts_file = self.user_data_path / "Prompt_Library" / "system_prompts_layer1.json"
+        system_prompts_file = self.user_data_path / "prompt_library" / "system_prompts_layer1.json"
         system_prompts_file.parent.mkdir(parents=True, exist_ok=True)
 
         # Load existing prompts
@@ -29627,7 +30171,7 @@ class SupervertalerQt(QMainWindow):
         layout = QVBoxLayout(dialog)
         
         # Header
-        header = QLabel("<h3>✅ AI-Powered Translation Proofreading</h3>")
+        header = QLabel("<h3>✅ AI-Enhanced Translation Proofreading</h3>")
         layout.addWidget(header)
         
         info_label = QLabel(
@@ -36345,7 +36889,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             subtab_name: Name of the sub-tab to navigate to (e.g., "AI Settings")
         """
         if hasattr(self, 'main_tabs'):
-            # Main tabs: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            # Main tabs: Grid=0, Resources=1, QuickMenu=2, Tools=3, Settings=4
             self.main_tabs.setCurrentIndex(4)
             
             # Navigate to specific sub-tab if requested
@@ -36366,7 +36910,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
     def _go_to_superlookup(self):
         """Navigate to Superlookup in Tools tab"""
         if hasattr(self, 'main_tabs'):
-            # Main tabs: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            # Main tabs: Grid=0, Resources=1, QuickMenu=2, Tools=3, Settings=4
             self.main_tabs.setCurrentIndex(3)  # Switch to Tools tab
             # Then switch to Superlookup sub-tab
             if hasattr(self, 'modules_tabs'):
@@ -36379,7 +36923,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
     def _navigate_to_tool(self, tool_name: str):
         """Navigate to a specific tool in the Tools tab"""
         if hasattr(self, 'main_tabs'):
-            # Main tabs: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            # Main tabs: Grid=0, Resources=1, QuickMenu=2, Tools=3, Settings=4
             self.main_tabs.setCurrentIndex(3)  # Switch to Tools tab
             # Then switch to the specific tool sub-tab
             if hasattr(self, 'modules_tabs'):
@@ -36612,7 +37156,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             file_path, _ = QFileDialog.getOpenFileName(
                 dialog,
                 "Select TMX File",
-                str(self.user_data_path / "Translation_Resources"),
+                str(self.user_data_path / "resources"),
                 "TMX Files (*.tmx);;All Files (*.*)"
             )
             if file_path:
@@ -37398,7 +37942,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         layout.addWidget(title)
 
         # Description
-        desc = QLabel("<p><b>AI-powered tool for translators & writers</b></p>")
+        desc = QLabel("<p><b>AI-enhanced tool for translators & writers</b></p>")
         desc.setAlignment(Qt.AlignmentFlag.AlignCenter)
         layout.addWidget(desc)
 
@@ -41185,9 +41729,10 @@ class SuperlookupTab(QWidget):
     Works anywhere on your computer: in CAT tools, browsers, Word, any text box
     """
     
-    def __init__(self, parent=None):
+    def __init__(self, parent=None, user_data_path=None):
         super().__init__(parent)
         self.main_window = parent  # Store reference to main window for database access
+        self.user_data_path = user_data_path  # Store user data path for web cache
         
         print("[Superlookup] SuperlookupTab.__init__ called")
         
@@ -41359,31 +41904,10 @@ class SuperlookupTab(QWidget):
         
         layout.addLayout(search_row)
         
-        # Options row (direction + language filters) - compact single line
+        # Options row (language filters only) - compact single line
         options_layout = QHBoxLayout()
         options_layout.setSpacing(8)
         
-        # Search direction selector
-        direction_label = QLabel("Direction:")
-        direction_label.setStyleSheet("font-weight: bold; font-size: 9pt;")
-        options_layout.addWidget(direction_label)
-        
-        self.direction_both = CheckmarkRadioButton("Both")
-        self.direction_both.setChecked(True)  # Default
-        self.direction_both.setToolTip("Search in both source and target text (bidirectional)")
-        options_layout.addWidget(self.direction_both)
-        
-        self.direction_source = CheckmarkRadioButton("Source")
-        self.direction_source.setToolTip("Search only in source language text")
-        options_layout.addWidget(self.direction_source)
-        
-        self.direction_target = CheckmarkRadioButton("Target")
-        self.direction_target.setToolTip("Search only in target language text")
-        options_layout.addWidget(self.direction_target)
-        
-        # Spacer
-        options_layout.addSpacing(15)
-        
         # Language filter dropdowns
         from_label = QLabel("From:")
         from_label.setStyleSheet("font-weight: bold; font-size: 9pt;")
@@ -41895,7 +42419,11 @@ class SuperlookupTab(QWidget):
             self.web_engine_available = True
             
             # Create persistent profile for login/cookie storage
-            storage_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'user_data', 'web_cache')
+            if self.user_data_path:
+                storage_path = os.path.join(str(self.user_data_path), 'web_cache')
+            else:
+                # Fallback to script directory if user_data_path not provided
+                storage_path = os.path.join(os.path.dirname(os.path.abspath(__file__)), 'user_data', 'web_cache')
             os.makedirs(storage_path, exist_ok=True)
             self.web_profile = QWebEngineProfile("SuperlookupProfile", self)
             self.web_profile.setPersistentStoragePath(storage_path)
@@ -43159,17 +43687,10 @@ class SuperlookupTab(QWidget):
     def get_search_direction(self):
         """Get the current search direction setting.
         
-        Returns:
-            'both' - bidirectional search (source and target)
-            'source' - search source text only
-            'target' - search target text only
+        Always returns 'both' for maximum search coverage.
+        Smart language swapping ensures results are always shown in correct order.
         """
-        if hasattr(self, 'direction_source') and self.direction_source.isChecked():
-            return 'source'
-        elif hasattr(self, 'direction_target') and self.direction_target.isChecked():
-            return 'target'
-        else:
-            return 'both'
+        return 'both'
     
     def _on_language_changed(self):
         """Handle language dropdown change - update Web Resources info"""
@@ -44926,7 +45447,7 @@ class SuperlookupTab(QWidget):
             print(f"[Superlookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
             
             # Switch to Tools tab (main_tabs index 3)
-            # Tab structure: Grid=0, Resources=1, Prompt Manager=2, Tools=3, Settings=4
+            # Tab structure: Grid=0, Resources=1, QuickMenu=2, Tools=3, Settings=4
             if hasattr(main_window, 'main_tabs'):
                 print(f"[Superlookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
                 main_window.main_tabs.setCurrentIndex(3)  # Tools tab