supervertaler 1.9.172__py3-none-any.whl → 1.9.180__py3-none-any.whl

Supervertaler.py

@@ -3,8 +3,6 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.153 (Tab Layout Reorganization)
-Release Date: January 23, 2026
 Framework: PyQt6
 
 This is the modern edition of Supervertaler using PyQt6 framework.
@@ -34,7 +32,7 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.172"
+__version__ = "1.9.180"
 __phase__ = "0.9"
 __release_date__ = "2026-01-28"
 __edition__ = "Qt"
@@ -753,7 +751,83 @@ def get_wrapping_tag_pair(source_text: str, target_text: str) -> tuple:
         opening, closing = get_tag_pair(num)
         if opening not in target_tags or closing not in target_tags:
             return (opening, closing)
-    
+
+    return (None, None)
+
+
+def get_html_wrapping_tag_pair(source_text: str, target_text: str) -> tuple:
+    """
+    Get the next available HTML tag pair for wrapping selected text.
+
+    Finds paired HTML tags (opening + closing) from source that are not yet
+    complete in target. Supports common formatting tags: b, i, u, em, strong,
+    span, li, p, a, sub, sup, etc.
+
+    Args:
+        source_text: Source segment text with HTML tags
+        target_text: Current target text
+
+    Returns:
+        Tuple of (opening_tag, closing_tag) or (None, None) if no pairs available
+    """
+    import re
+
+    # Find all HTML tags in source
+    # Match: <tag>, <tag attr="...">, </tag>
+    tag_pattern = r'<(/?)([a-zA-Z][a-zA-Z0-9-]*)(?:\s+[^>]*)?>'
+    source_matches = re.findall(tag_pattern, source_text)
+    target_matches = re.findall(tag_pattern, target_text)
+
+    if not source_matches:
+        return (None, None)
+
+    # Build lists of opening and closing tags in source
+    source_opening = []  # [(full_tag, tag_name), ...]
+    source_closing = []
+
+    for match in re.finditer(tag_pattern, source_text):
+        is_closing = match.group(1) == '/'
+        tag_name = match.group(2).lower()
+        full_tag = match.group(0)
+
+        if is_closing:
+            source_closing.append((full_tag, tag_name))
+        else:
+            source_opening.append((full_tag, tag_name))
+
+    # Build sets of tag names already in target
+    target_opening_names = set()
+    target_closing_names = set()
+
+    for is_closing, tag_name in target_matches:
+        if is_closing == '/':
+            target_closing_names.add(tag_name.lower())
+        else:
+            target_opening_names.add(tag_name.lower())
+
+    # Find first tag pair where both opening and closing exist in source
+    # but at least one is missing from target
+    seen_tags = set()
+    for full_tag, tag_name in source_opening:
+        if tag_name in seen_tags:
+            continue
+        seen_tags.add(tag_name)
+
+        # Check if there's a matching closing tag in source
+        has_closing = any(name == tag_name for _, name in source_closing)
+        if not has_closing:
+            continue
+
+        # Check if pair is incomplete in target
+        opening_in_target = tag_name in target_opening_names
+        closing_in_target = tag_name in target_closing_names
+
+        if not opening_in_target or not closing_in_target:
+            # Find the actual opening and closing tags from source
+            opening_tag = full_tag
+            closing_tag = f"</{tag_name}>"
+            return (opening_tag, closing_tag)
+
     return (None, None)
 
 
@@ -1148,48 +1222,48 @@ class GridTextEditor(QTextEdit):
     def _insert_next_tag_or_wrap_selection(self):
         """
         Insert the next memoQ tag, HTML tag, or CafeTran pipe symbol from source, or wrap selection.
-        
+
         Behavior:
-        - If text is selected: Wrap it with the next available tag pair [N}selection{N] or |selection|
+        - If text is selected: Wrap it with the next available tag pair [N}selection{N] or <tag>selection</tag> or |selection|
         - If no selection: Insert the next unused tag/pipe from source at cursor position
-        
+
         Supports:
         - memoQ tags: [1}, {1], [2}, {2], etc.
         - HTML/XML tags: <li>, </li>, <b>, </b>, <i>, </i>, etc.
         - CafeTran pipe symbols: |
-        
+
         Shortcut: Ctrl+, (comma)
         """
         # Get the main window and current segment
         if not self.table_widget or self.current_row is None:
             return
-        
+
         # Navigate up to find main window
         main_window = self.table_widget.parent()
         while main_window and not hasattr(main_window, 'current_project'):
             main_window = main_window.parent()
-        
+
         if not main_window or not hasattr(main_window, 'current_project'):
             return
-        
+
         if not main_window.current_project or self.current_row >= len(main_window.current_project.segments):
             return
-        
+
         segment = main_window.current_project.segments[self.current_row]
         source_text = segment.source
         current_target = self.toPlainText()
-        
+
         # Check what type of tags are in the source
         has_memoq_tags = bool(extract_memoq_tags(source_text))
         has_html_tags = bool(extract_html_tags(source_text))
         has_any_tags = has_memoq_tags or has_html_tags
         has_pipe_symbols = '|' in source_text
-        
+
         # Check if there's a selection
         cursor = self.textCursor()
         if cursor.hasSelection():
             selected_text = cursor.selectedText()
-            
+
             # Try memoQ tag pair first
             if has_memoq_tags:
                 opening_tag, closing_tag = get_wrapping_tag_pair(source_text, current_target)
@@ -1199,7 +1273,17 @@ class GridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Wrapped selection with {opening_tag}...{closing_tag}")
                     return
-            
+
+            # Try HTML tag pairs (e.g., <b>...</b>, <i>...</i>)
+            if has_html_tags:
+                opening_tag, closing_tag = get_html_wrapping_tag_pair(source_text, current_target)
+                if opening_tag and closing_tag:
+                    wrapped_text = f"{opening_tag}{selected_text}{closing_tag}"
+                    cursor.insertText(wrapped_text)
+                    if hasattr(main_window, 'log'):
+                        main_window.log(f"🏷️ Wrapped selection with {opening_tag}...{closing_tag}")
+                    return
+
             # Try CafeTran pipe symbols
             if has_pipe_symbols:
                 pipes_needed = get_next_pipe_count_needed(source_text, current_target)
@@ -1210,12 +1294,12 @@ class GridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Wrapped selection with |...|")
                     return
-            
+
             if hasattr(main_window, 'log'):
                 main_window.log("⚠️ No tag pairs available from source")
         else:
             # No selection - insert next unused tag or pipe at cursor
-            
+
             # Try memoQ tags and HTML tags (find_next_unused_tag handles both)
             if has_any_tags:
                 next_tag = find_next_unused_tag(source_text, current_target)
@@ -1224,7 +1308,7 @@ class GridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Inserted tag: {next_tag}")
                     return
-            
+
             # Try CafeTran pipe symbols
             if has_pipe_symbols:
                 pipes_needed = get_next_pipe_count_needed(source_text, current_target)
@@ -1233,7 +1317,7 @@ class GridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Inserted pipe symbol (|)")
                     return
-            
+
             if hasattr(main_window, 'log'):
                 main_window.log("✓ All tags from source already in target")
 
@@ -2080,16 +2164,27 @@ class ReadOnlyGridTextEditor(QTextEdit):
         # Use stored table reference and row number
         if self.table_ref and self.row >= 0:
             try:
-                self.table_ref.selectRow(self.row)
-                self.table_ref.setCurrentCell(self.row, 2)
-
-                # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
-                # Find the main window and call the method directly
-                main_window = self.table_ref.parent()
-                while main_window and not hasattr(main_window, 'on_cell_selected'):
-                    main_window = main_window.parent()
-                if main_window and hasattr(main_window, 'on_cell_selected'):
-                    main_window.on_cell_selected(self.row, 2, -1, -1)
+                # Check for Shift or Ctrl modifier - let Qt handle native multi-selection
+                modifiers = event.modifiers()
+                is_shift = modifiers & Qt.KeyboardModifier.ShiftModifier
+                is_ctrl = modifiers & Qt.KeyboardModifier.ControlModifier
+
+                if is_shift or is_ctrl:
+                    # For Shift+click (range) or Ctrl+click (toggle), just set current cell
+                    # but don't call selectRow() which would clear the selection
+                    self.table_ref.setCurrentCell(self.row, 2)
+                else:
+                    # Normal click - select just this row
+                    self.table_ref.selectRow(self.row)
+                    self.table_ref.setCurrentCell(self.row, 2)
+
+                    # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
+                    # Find the main window and call the method directly
+                    main_window = self.table_ref.parent()
+                    while main_window and not hasattr(main_window, 'on_cell_selected'):
+                        main_window = main_window.parent()
+                    if main_window and hasattr(main_window, 'on_cell_selected'):
+                        main_window.on_cell_selected(self.row, 2, -1, -1)
             except Exception as e:
                 print(f"Error triggering manual cell selection: {e}")
 
@@ -2166,20 +2261,32 @@ class ReadOnlyGridTextEditor(QTextEdit):
         """Select text when focused for easy copying and trigger row selection"""
         super().focusInEvent(event)
         # Don't auto-select - let user select manually
-        
+
         # Use stored table reference and row number
         if self.table_ref and self.row >= 0:
             try:
-                self.table_ref.selectRow(self.row)
-                self.table_ref.setCurrentCell(self.row, 2)
-                
-                # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
-                # Find the main window and call the method directly
-                main_window = self.table_ref.parent()
-                while main_window and not hasattr(main_window, 'on_cell_selected'):
-                    main_window = main_window.parent()
-                if main_window and hasattr(main_window, 'on_cell_selected'):
-                    main_window.on_cell_selected(self.row, 2, -1, -1)
+                # Check for Shift or Ctrl modifier - let Qt handle native multi-selection
+                from PyQt6.QtWidgets import QApplication
+                modifiers = QApplication.keyboardModifiers()
+                is_shift = modifiers & Qt.KeyboardModifier.ShiftModifier
+                is_ctrl = modifiers & Qt.KeyboardModifier.ControlModifier
+
+                if is_shift or is_ctrl:
+                    # For Shift+click (range) or Ctrl+click (toggle), just set current cell
+                    # but don't call selectRow() which would clear the selection
+                    self.table_ref.setCurrentCell(self.row, 2)
+                else:
+                    # Normal focus - select just this row
+                    self.table_ref.selectRow(self.row)
+                    self.table_ref.setCurrentCell(self.row, 2)
+
+                    # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
+                    # Find the main window and call the method directly
+                    main_window = self.table_ref.parent()
+                    while main_window and not hasattr(main_window, 'on_cell_selected'):
+                        main_window = main_window.parent()
+                    if main_window and hasattr(main_window, 'on_cell_selected'):
+                        main_window.on_cell_selected(self.row, 2, -1, -1)
             except Exception as e:
                 print(f"Error triggering manual cell selection: {e}")
 
@@ -3026,19 +3133,30 @@ class EditableGridTextEditor(QTextEdit):
         super().mousePressEvent(event)
         # Auto-select the row when clicking in the target cell
         if self.table and self.row >= 0:
-            self.table.selectRow(self.row)
-            self.table.setCurrentCell(self.row, 3)  # Column 3 is Target
+            # Check for Shift or Ctrl modifier - let Qt handle native multi-selection
+            modifiers = event.modifiers()
+            is_shift = modifiers & Qt.KeyboardModifier.ShiftModifier
+            is_ctrl = modifiers & Qt.KeyboardModifier.ControlModifier
+
+            if is_shift or is_ctrl:
+                # For Shift+click (range) or Ctrl+click (toggle), just set current cell
+                # but don't call selectRow() which would clear the selection
+                self.table.setCurrentCell(self.row, 3)  # Column 3 is Target
+            else:
+                # Normal click - select just this row
+                self.table.selectRow(self.row)
+                self.table.setCurrentCell(self.row, 3)  # Column 3 is Target
 
-            # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
-            # Find the main window and call the method directly
-            try:
-                main_window = self.table.parent()
-                while main_window and not hasattr(main_window, 'on_cell_selected'):
-                    main_window = main_window.parent()
-                if main_window and hasattr(main_window, 'on_cell_selected'):
-                    main_window.on_cell_selected(self.row, 3, -1, -1)
-            except Exception as e:
-                print(f"Error triggering manual cell selection: {e}")
+                # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
+                # Find the main window and call the method directly
+                try:
+                    main_window = self.table.parent()
+                    while main_window and not hasattr(main_window, 'on_cell_selected'):
+                        main_window = main_window.parent()
+                    if main_window and hasattr(main_window, 'on_cell_selected'):
+                        main_window.on_cell_selected(self.row, 3, -1, -1)
+                except Exception as e:
+                    print(f"Error triggering manual cell selection: {e}")
 
     def mouseReleaseEvent(self, event):
         """Smart word selection - expand partial selections to full words
@@ -3108,19 +3226,31 @@ class EditableGridTextEditor(QTextEdit):
         self.show()
         # Auto-select the row when focusing the target cell
         if self.table and self.row >= 0:
-            self.table.selectRow(self.row)
-            self.table.setCurrentCell(self.row, 3)  # Column 3 is Target
-            
-            # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
-            # Find the main window and call the method directly
-            try:
-                main_window = self.table.parent()
-                while main_window and not hasattr(main_window, 'on_cell_selected'):
-                    main_window = main_window.parent()
-                if main_window and hasattr(main_window, 'on_cell_selected'):
-                    main_window.on_cell_selected(self.row, 3, -1, -1)
-            except Exception as e:
-                print(f"Error triggering manual cell selection: {e}")
+            # Check for Shift or Ctrl modifier - let Qt handle native multi-selection
+            from PyQt6.QtWidgets import QApplication
+            modifiers = QApplication.keyboardModifiers()
+            is_shift = modifiers & Qt.KeyboardModifier.ShiftModifier
+            is_ctrl = modifiers & Qt.KeyboardModifier.ControlModifier
+
+            if is_shift or is_ctrl:
+                # For Shift+click (range) or Ctrl+click (toggle), just set current cell
+                # but don't call selectRow() which would clear the selection
+                self.table.setCurrentCell(self.row, 3)  # Column 3 is Target
+            else:
+                # Normal focus - select just this row
+                self.table.selectRow(self.row)
+                self.table.setCurrentCell(self.row, 3)  # Column 3 is Target
+
+                # CRITICAL: Manually trigger on_cell_selected since signals aren't firing
+                # Find the main window and call the method directly
+                try:
+                    main_window = self.table.parent()
+                    while main_window and not hasattr(main_window, 'on_cell_selected'):
+                        main_window = main_window.parent()
+                    if main_window and hasattr(main_window, 'on_cell_selected'):
+                        main_window.on_cell_selected(self.row, 3, -1, -1)
+                except Exception as e:
+                    print(f"Error triggering manual cell selection: {e}")
     
     def keyPressEvent(self, event):
         """Handle Tab and Ctrl+E keys to cycle between source and target cells"""
@@ -3423,7 +3553,7 @@ class EditableGridTextEditor(QTextEdit):
         cursor = self.textCursor()
         if cursor.hasSelection():
             selected_text = cursor.selectedText()
-            
+
             # Try memoQ tag pair first
             if has_memoq_tags:
                 opening_tag, closing_tag = get_wrapping_tag_pair(source_text, current_target)
@@ -3433,7 +3563,17 @@ class EditableGridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Wrapped selection with {opening_tag}...{closing_tag}")
                     return
-            
+
+            # Try HTML tag pairs (e.g., <b>...</b>, <i>...</i>)
+            if has_html_tags:
+                opening_tag, closing_tag = get_html_wrapping_tag_pair(source_text, current_target)
+                if opening_tag and closing_tag:
+                    wrapped_text = f"{opening_tag}{selected_text}{closing_tag}"
+                    cursor.insertText(wrapped_text)
+                    if hasattr(main_window, 'log'):
+                        main_window.log(f"🏷️ Wrapped selection with {opening_tag}...{closing_tag}")
+                    return
+
             # Try CafeTran pipe symbols
             if has_pipe_symbols:
                 pipes_needed = get_next_pipe_count_needed(source_text, current_target)
@@ -3444,12 +3584,12 @@ class EditableGridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Wrapped selection with |...|")
                     return
-            
+
             if hasattr(main_window, 'log'):
                 main_window.log("⚠️ No tag pairs available from source")
         else:
             # No selection - insert next unused tag or pipe at cursor
-            
+
             # Try memoQ tags and HTML tags (find_next_unused_tag handles both)
             if has_any_tags:
                 next_tag = find_next_unused_tag(source_text, current_target)
@@ -3458,7 +3598,7 @@ class EditableGridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Inserted tag: {next_tag}")
                     return
-            
+
             # Try CafeTran pipe symbols
             if has_pipe_symbols:
                 pipes_needed = get_next_pipe_count_needed(source_text, current_target)
@@ -3467,10 +3607,10 @@ class EditableGridTextEditor(QTextEdit):
                     if hasattr(main_window, 'log'):
                         main_window.log(f"🏷️ Inserted pipe symbol (|)")
                     return
-            
+
             if hasattr(main_window, 'log'):
                 main_window.log("✓ All tags from source already in target")
-    
+
     def _copy_source_to_target(self):
         """
         Copy source text to target cell.
@@ -5179,12 +5319,14 @@ class AdvancedFiltersDialog(QDialog):
         
         self.status_not_started = CheckmarkCheckBox("Not started")
         self.status_edited = CheckmarkCheckBox("Edited")
+        self.status_pretranslated = CheckmarkCheckBox("Pre-translated")
         self.status_translated = CheckmarkCheckBox("Translated")
         self.status_confirmed = CheckmarkCheckBox("Confirmed")
         self.status_draft = CheckmarkCheckBox("Draft")
-        
+
         status_layout.addWidget(self.status_not_started)
         status_layout.addWidget(self.status_edited)
+        status_layout.addWidget(self.status_pretranslated)
         status_layout.addWidget(self.status_translated)
         status_layout.addWidget(self.status_confirmed)
         status_layout.addWidget(self.status_draft)
@@ -5257,6 +5399,7 @@ class AdvancedFiltersDialog(QDialog):
         
         self.status_not_started.setChecked(False)
         self.status_edited.setChecked(False)
+        self.status_pretranslated.setChecked(False)
         self.status_translated.setChecked(False)
         self.status_confirmed.setChecked(False)
         self.status_draft.setChecked(False)
@@ -5283,6 +5426,8 @@ class AdvancedFiltersDialog(QDialog):
             row_status.append('not_started')
         if self.status_edited.isChecked():
             row_status.append('edited')
+        if self.status_pretranslated.isChecked():
+            row_status.append('pretranslated')
         if self.status_translated.isChecked():
             row_status.append('translated')
         if self.status_confirmed.isChecked():
@@ -5598,7 +5743,7 @@ class PreTranslationWorker(QThread):
                     match = matches[0]
                     match_pct = match.get('match_pct', 0)
                     print(f"🔍 TM PRE-TRANSLATE: Best match pct: {match_pct}")
-                    if match_pct >= 70:  # Accept matches 70% and above
+                    if match_pct >= 75:  # Accept matches 75% and above
                         return match.get('target', '')
                 return None
         except Exception as e:
@@ -5647,11 +5792,14 @@ class PreTranslationWorker(QThread):
             custom_prompt = None
             if self.prompt_manager:
                 try:
+                    # Get glossary terms for AI injection
+                    glossary_terms = self.parent_app.get_ai_inject_glossary_terms() if hasattr(self.parent_app, 'get_ai_inject_glossary_terms') else []
                     full_prompt = self.prompt_manager.build_final_prompt(
                         source_text=segment.source,
                         source_lang=source_lang,
                         target_lang=target_lang,
-                        mode="single"
+                        mode="single",
+                        glossary_terms=glossary_terms
                     )
                     # Extract just the instruction part (without the source text section)
                     if "**SOURCE TEXT:**" in full_prompt:
@@ -5710,11 +5858,14 @@ class PreTranslationWorker(QThread):
             if self.prompt_manager and batch_segments:
                 try:
                     first_segment = batch_segments[0][1]
+                    # Get glossary terms for AI injection
+                    glossary_terms = self.parent_app.get_ai_inject_glossary_terms() if hasattr(self.parent_app, 'get_ai_inject_glossary_terms') else []
                     full_prompt = self.prompt_manager.build_final_prompt(
                         source_text=first_segment.source,
                         source_lang=source_lang,
                         target_lang=target_lang,
-                        mode="single"
+                        mode="single",
+                        glossary_terms=glossary_terms
                     )
                     # Extract just the instruction part
                     if "**SOURCE TEXT:**" in full_prompt:
@@ -6161,6 +6312,10 @@ class SupervertalerQt(QMainWindow):
         # TM Metadata Manager - needed for TM list in Superlookup
         from modules.tm_metadata_manager import TMMetadataManager
         self.tm_metadata_mgr = TMMetadataManager(self.db_manager, self.log)
+
+        # Termbase Manager - needed for glossary AI injection
+        from modules.termbase_manager import TermbaseManager
+        self.termbase_mgr = TermbaseManager(self.db_manager, self.log)
         
         # Spellcheck Manager for target language spell checking
         self.spellcheck_manager = get_spellcheck_manager(str(self.user_data_path))
@@ -6202,6 +6357,9 @@ class SupervertalerQt(QMainWindow):
         
         # Initialize theme manager and apply theme
         self.theme_manager = ThemeManager(self.user_data_path)
+        # Apply saved global UI font scale
+        saved_font_scale = self._get_global_ui_font_scale()
+        self.theme_manager.font_scale = saved_font_scale
         self.theme_manager.apply_theme(QApplication.instance())
         
         # Update widgets that were created before theme_manager existed
@@ -6278,13 +6436,10 @@ 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 data location dialog, then Features tab
-        if self._needs_data_location_dialog:
+        # First-run check - show unified setup wizard
+        if self._needs_data_location_dialog or not general_settings.get('first_run_completed', False):
             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)
+            QTimer.singleShot(300, lambda: self._show_setup_wizard(is_first_run=True))
     
     def _show_data_location_dialog(self):
         """Show dialog to let user choose their data folder location on first run."""
@@ -6444,6 +6599,9 @@ class SupervertalerQt(QMainWindow):
             # Update theme manager
             from modules.theme_manager import ThemeManager
             self.theme_manager = ThemeManager(self.user_data_path)
+            # Apply saved global UI font scale
+            saved_font_scale = self._get_global_ui_font_scale()
+            self.theme_manager.font_scale = saved_font_scale
             self.theme_manager.apply_theme(QApplication.instance())
             
             # Update recent projects file path
@@ -6515,7 +6673,273 @@ class SupervertalerQt(QMainWindow):
                 self.log("✅ First-run welcome shown (will show again next time)")
         except Exception as e:
             self.log(f"⚠️ First-run welcome error: {e}")
-    
+
+    def _show_setup_wizard(self, is_first_run: bool = False):
+        """
+        Show unified setup wizard that combines data folder selection and features intro.
+
+        Args:
+            is_first_run: If True, this is an automatic first-run trigger. If False, user
+                          manually invoked from menu (skip data folder if already configured).
+        """
+        try:
+            from PyQt6.QtWidgets import (QDialog, QVBoxLayout, QHBoxLayout, QLabel,
+                                         QPushButton, QLineEdit, QFileDialog, QStackedWidget,
+                                         QWidget, QFrame, QCheckBox)
+            from PyQt6.QtCore import Qt
+
+            dialog = QDialog(self)
+            dialog.setWindowTitle("Supervertaler Setup Wizard")
+            dialog.setMinimumWidth(600)
+            dialog.setMinimumHeight(450)
+            dialog.setModal(True)
+
+            main_layout = QVBoxLayout(dialog)
+            main_layout.setSpacing(15)
+            main_layout.setContentsMargins(20, 20, 20, 20)
+
+            # Stacked widget for wizard pages
+            stacked = QStackedWidget()
+
+            # Determine if we need to show data folder page
+            show_data_folder_page = is_first_run and self._needs_data_location_dialog
+
+            # ==================== PAGE 1: Data Folder Selection ====================
+            page1 = QWidget()
+            page1_layout = QVBoxLayout(page1)
+            page1_layout.setSpacing(15)
+
+            # Step indicator
+            step1_indicator = QLabel("<span style='color: #888;'>Step 1 of 2</span>")
+            page1_layout.addWidget(step1_indicator)
+
+            # Title
+            page1_title = QLabel("<h2>📁 Choose Your Data Folder</h2>")
+            page1_layout.addWidget(page1_title)
+
+            # Explanation
+            page1_msg = QLabel(
+                "Supervertaler stores your data in a folder of your choice:<br><br>"
+                "• <b>API keys</b> – Your LLM provider credentials<br>"
+                "• <b>Translation memories</b> – Reusable translation pairs<br>"
+                "• <b>Glossaries</b> – Terminology databases<br>"
+                "• <b>Prompts</b> – Custom AI prompts<br>"
+                "• <b>Settings</b> – Application configuration<br><br>"
+                "Choose a location that's easy to find and backup."
+            )
+            page1_msg.setWordWrap(True)
+            page1_layout.addWidget(page1_msg)
+
+            # 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:
+                    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)
+            page1_layout.addLayout(path_layout)
+
+            # Tip
+            page1_tip = QLabel(
+                "💡 <b>Tip:</b> The default location is in your home folder, "
+                "making it easy to find and backup."
+            )
+            page1_tip.setWordWrap(True)
+            page1_tip.setStyleSheet("color: #666;")
+            page1_layout.addWidget(page1_tip)
+
+            page1_layout.addStretch()
+            stacked.addWidget(page1)
+
+            # ==================== PAGE 2: Features Introduction ====================
+            page2 = QWidget()
+            page2_layout = QVBoxLayout(page2)
+            page2_layout.setSpacing(15)
+
+            # Step indicator
+            step2_label = "Step 2 of 2" if show_data_folder_page else "Setup"
+            step2_indicator = QLabel(f"<span style='color: #888;'>{step2_label}</span>")
+            page2_layout.addWidget(step2_indicator)
+
+            # Data folder info (shown when skipping page 1)
+            if not show_data_folder_page:
+                from PyQt6.QtGui import QDesktopServices
+                from PyQt6.QtCore import QUrl
+
+                data_folder_path = str(self.user_data_path)
+                data_folder_info = QLabel(
+                    f"<b>📁 Data Folder:</b> <a href='file:///{data_folder_path}' "
+                    f"style='color: #3b82f6;'>{data_folder_path}</a><br>"
+                    "<span style='color: #666; font-size: 0.9em;'>"
+                    "Your settings, TMs, glossaries and prompts are stored here. "
+                    "Change in Settings → General.</span>"
+                )
+                data_folder_info.setWordWrap(True)
+                data_folder_info.setTextFormat(Qt.TextFormat.RichText)
+                data_folder_info.setOpenExternalLinks(False)  # Handle clicks ourselves
+                data_folder_info.linkActivated.connect(
+                    lambda url: QDesktopServices.openUrl(QUrl.fromLocalFile(data_folder_path))
+                )
+                data_folder_info.setStyleSheet(
+                    "background: #f0f4ff; padding: 12px; border-radius: 6px; "
+                    "border-left: 4px solid #3b82f6; margin-bottom: 10px;"
+                )
+                page2_layout.addWidget(data_folder_info)
+
+            # Title
+            page2_title = QLabel("<h2>✨ Modular Features</h2>")
+            page2_layout.addWidget(page2_title)
+
+            # Message
+            page2_msg = QLabel(
+                "Supervertaler uses a <b>modular architecture</b> – you can install "
+                "only the features you need.<br><br>"
+                "<b>Core features</b> (always available):<br>"
+                "• AI translation with OpenAI, Claude, Gemini, Ollama<br>"
+                "• Translation Memory and Glossaries<br>"
+                "• XLIFF, SDLXLIFF, memoQ support<br>"
+                "• Basic spellchecking<br><br>"
+                "<b>Optional features</b> (install via pip):<br>"
+                "• <code>openai-whisper</code> – Local voice dictation (no API needed)<br><br>"
+                "You can view and manage features in <b>Settings → Features</b>."
+            )
+            page2_msg.setWordWrap(True)
+            page2_msg.setTextFormat(Qt.TextFormat.RichText)
+            page2_layout.addWidget(page2_msg)
+
+            # Checkbox
+            dont_show_checkbox = CheckmarkCheckBox("Don't show this wizard on startup")
+            dont_show_checkbox.setChecked(True)
+            page2_layout.addWidget(dont_show_checkbox)
+
+            # Open Features tab checkbox
+            open_features_checkbox = CheckmarkCheckBox("Open Features tab after closing")
+            open_features_checkbox.setChecked(True)
+            page2_layout.addWidget(open_features_checkbox)
+
+            page2_layout.addStretch()
+            stacked.addWidget(page2)
+
+            main_layout.addWidget(stacked)
+
+            # ==================== Navigation Buttons ====================
+            nav_layout = QHBoxLayout()
+
+            back_btn = QPushButton("← Back")
+            back_btn.setVisible(False)  # Hidden on first page
+
+            next_btn = QPushButton("Next →")
+            finish_btn = QPushButton("Finish")
+            finish_btn.setVisible(False)
+            finish_btn.setDefault(True)
+
+            # Use Default button (only on page 1)
+            default_btn = QPushButton("Use Default")
+            default_btn.clicked.connect(lambda: path_edit.setText(str(default_path)))
+
+            nav_layout.addWidget(default_btn)
+            nav_layout.addStretch()
+            nav_layout.addWidget(back_btn)
+            nav_layout.addWidget(next_btn)
+            nav_layout.addWidget(finish_btn)
+
+            main_layout.addLayout(nav_layout)
+
+            # Track chosen path for later
+            chosen_path_holder = [None]
+
+            def go_to_page(page_index):
+                stacked.setCurrentIndex(page_index)
+                if page_index == 0:
+                    back_btn.setVisible(False)
+                    next_btn.setVisible(True)
+                    finish_btn.setVisible(False)
+                    default_btn.setVisible(True)
+                else:
+                    back_btn.setVisible(show_data_folder_page)
+                    next_btn.setVisible(False)
+                    finish_btn.setVisible(True)
+                    default_btn.setVisible(False)
+
+            def on_next():
+                # Save the data folder choice
+                chosen_path = Path(path_edit.text())
+                chosen_path_holder[0] = chosen_path
+
+                # Create the folder and save config
+                chosen_path.mkdir(parents=True, exist_ok=True)
+                save_user_data_path(chosen_path)
+
+                # Update our path if different
+                if chosen_path != self.user_data_path:
+                    self.user_data_path = chosen_path
+                    self._reinitialize_with_new_data_path()
+                else:
+                    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}")
+                go_to_page(1)
+
+            def on_back():
+                go_to_page(0)
+
+            def on_finish():
+                # Save first_run preference
+                if dont_show_checkbox.isChecked():
+                    settings = self.load_general_settings()
+                    settings['first_run_completed'] = True
+                    self.save_general_settings(settings)
+                    self.log("✅ Setup wizard completed (won't show again on startup)")
+                else:
+                    self.log("✅ Setup wizard shown (will show again next time)")
+
+                dialog.accept()
+
+                # Navigate to Features tab if checkbox is checked
+                if open_features_checkbox.isChecked():
+                    self.main_tabs.setCurrentIndex(4)  # Settings tab
+                    if hasattr(self, 'settings_tabs'):
+                        for i in range(self.settings_tabs.count()):
+                            if "Features" in self.settings_tabs.tabText(i):
+                                self.settings_tabs.setCurrentIndex(i)
+                                break
+
+            back_btn.clicked.connect(on_back)
+            next_btn.clicked.connect(on_next)
+            finish_btn.clicked.connect(on_finish)
+
+            # Start on appropriate page
+            if show_data_folder_page:
+                go_to_page(0)
+            else:
+                # Skip to features page if data folder already configured
+                go_to_page(1)
+                step2_indicator.setText("<span style='color: #888;'>Supervertaler Setup</span>")
+
+            dialog.exec()
+
+        except Exception as e:
+            self.log(f"⚠️ Setup wizard error: {e}")
+            import traceback
+            traceback.print_exc()
+
     def _check_for_new_models(self, force: bool = False):
         """
         Check for new LLM models from providers
@@ -7499,13 +7923,30 @@ class SupervertalerQt(QMainWindow):
         
         # Bulk Operations submenu
         bulk_menu = edit_menu.addMenu("Bulk &Operations")
-        
+
         confirm_selected_action = QAction("✅ &Confirm Selected Segments", self)
         confirm_selected_action.setShortcut("Ctrl+Shift+Return")
         confirm_selected_action.setToolTip("Confirm all selected segments (Ctrl+Shift+Enter)")
         confirm_selected_action.triggered.connect(self.confirm_selected_segments_from_menu)
         bulk_menu.addAction(confirm_selected_action)
-        
+
+        # Change Status submenu
+        status_submenu = bulk_menu.addMenu("🏷️ Change &Status")
+        user_statuses = [
+            ("not_started", "❌ &Not started"),
+            ("pretranslated", "🤖 &Pre-translated"),
+            ("translated", "✏️ &Translated"),
+            ("confirmed", "✔ &Confirmed"),
+            ("tr_confirmed", "🌟 T&R confirmed"),
+            ("proofread", "🟪 Proo&fread"),
+            ("approved", "⭐ &Approved"),
+            ("rejected", "🚫 Re&jected"),
+        ]
+        for status_key, label in user_statuses:
+            action = QAction(label, self)
+            action.triggered.connect(lambda checked, s=status_key: self.change_status_selected(s, from_menu=True))
+            status_submenu.addAction(action)
+
         clear_translations_action = QAction("🗑️ &Clear Translations", self)
         clear_translations_action.setToolTip("Clear translations for selected segments")
         clear_translations_action.triggered.connect(self.clear_selected_translations_from_menu)
@@ -7762,6 +8203,11 @@ class SupervertalerQt(QMainWindow):
         superdocs_action.triggered.connect(lambda: self._open_url("https://supervertaler.gitbook.io/superdocs/"))
         help_menu.addAction(superdocs_action)
 
+        setup_wizard_action = QAction("🚀 Setup Wizard...", self)
+        setup_wizard_action.setToolTip("Run the initial setup wizard (data folder location, features overview)")
+        setup_wizard_action.triggered.connect(lambda: self._show_setup_wizard(is_first_run=False))
+        help_menu.addAction(setup_wizard_action)
+
         help_menu.addSeparator()
 
         shortcuts_action = QAction("⌨️ Keyboard Shortcuts", self)
@@ -10180,7 +10626,11 @@ class SupervertalerQt(QMainWindow):
         button_layout = QHBoxLayout()
         
         create_btn = QPushButton("+ Create New TM")
-        create_btn.clicked.connect(lambda: self._show_create_tm_dialog(tm_metadata_mgr, refresh_tm_list, project_id))
+        # Get project_id dynamically - use 0 (global) when no project is loaded
+        create_btn.clicked.connect(lambda: self._show_create_tm_dialog(
+            tm_metadata_mgr, refresh_tm_list,
+            self.current_project.id if (hasattr(self, 'current_project') and self.current_project and hasattr(self.current_project, 'id')) else 0
+        ))
         button_layout.addWidget(create_btn)
         
         import_btn = QPushButton("📥 Import TMX")
@@ -12586,7 +13036,8 @@ class SupervertalerQt(QMainWindow):
             "💡 <b>Glossaries</b><br>"
             "• <b>Read</b> (green ✓): Glossary is used for terminology matching<br>"
             "• <b>Write</b> (blue ✓): Glossary is updated with new terms<br>"
-            "• <b>Priority</b>: Manually set 1-N (lower = higher priority). Multiple glossaries can share same priority. Priority #1 = Project Glossary."
+            "• <b>Priority</b>: Manually set 1-N (lower = higher priority). Priority #1 = Project Glossary.<br>"
+            "• <b>AI</b> (orange ✓): Send glossary terms to LLM with every translation (increases prompt size)"
         )
         help_msg.setWordWrap(True)
         help_msg.setStyleSheet("background-color: #e3f2fd; padding: 8px; border-radius: 4px; color: #1976d2;")
@@ -12608,8 +13059,8 @@ class SupervertalerQt(QMainWindow):
         # Termbase list with table
         termbase_table = QTableWidget()
         self.termbase_table = termbase_table  # Store for external access (Superlookup navigation)
-        termbase_table.setColumnCount(7)
-        termbase_table.setHorizontalHeaderLabels(["Type", "Name", "Languages", "Terms", "Read", "Write", "Priority"])
+        termbase_table.setColumnCount(8)
+        termbase_table.setHorizontalHeaderLabels(["Type", "Name", "Languages", "Terms", "Read", "Write", "Priority", "AI"])
         termbase_table.horizontalHeader().setStretchLastSection(False)
         termbase_table.setColumnWidth(0, 80)   # Type (Project/Background)
         termbase_table.setColumnWidth(1, 180)  # Name
@@ -12618,6 +13069,7 @@ class SupervertalerQt(QMainWindow):
         termbase_table.setColumnWidth(4, 50)   # Read checkbox
         termbase_table.setColumnWidth(5, 50)   # Write checkbox
         termbase_table.setColumnWidth(6, 60)   # Priority
+        termbase_table.setColumnWidth(7, 40)   # AI checkbox
         termbase_table.setSelectionBehavior(QTableWidget.SelectionBehavior.SelectRows)
         termbase_table.setSelectionMode(QTableWidget.SelectionMode.SingleSelection)
         termbase_table.setEditTriggers(QTableWidget.EditTrigger.NoEditTriggers)  # Disable inline editing
@@ -13311,7 +13763,43 @@ class SupervertalerQt(QMainWindow):
                     priority_item.setToolTip("No priority - glossary not readable")
                     priority_item.setFlags(priority_item.flags() & ~Qt.ItemFlag.ItemIsEditable)
                     termbase_table.setItem(row, 6, priority_item)
-            
+
+                # AI checkbox (purple/orange) - whether to inject terms into LLM prompts
+                ai_enabled = termbase_mgr.get_termbase_ai_inject(tb['id'])
+                ai_checkbox = OrangeCheckmarkCheckBox()
+                ai_checkbox.setChecked(ai_enabled)
+                ai_checkbox.setToolTip("AI: Send glossary terms to LLM with translation prompts")
+
+                def on_ai_toggle(checked, tb_id=tb['id'], tb_name=tb['name']):
+                    if checked:
+                        # Show warning when enabling
+                        from PyQt6.QtWidgets import QMessageBox
+                        msg = QMessageBox()
+                        msg.setWindowTitle("Enable AI Injection")
+                        msg.setText(f"Enable AI injection for '{tb_name}'?")
+                        msg.setInformativeText(
+                            "When enabled, ALL terms from this glossary will be sent to the LLM "
+                            "with every translation request.\n\n"
+                            "This helps the AI consistently use your preferred terminology "
+                            "throughout the translation.\n\n"
+                            "Recommended for small, curated glossaries (< 500 terms)."
+                        )
+                        msg.setStandardButtons(QMessageBox.StandardButton.Yes | QMessageBox.StandardButton.No)
+                        msg.setDefaultButton(QMessageBox.StandardButton.Yes)
+                        if msg.exec() != QMessageBox.StandardButton.Yes:
+                            # User cancelled - revert checkbox
+                            sender = termbase_table.cellWidget(termbase_table.currentRow(), 7)
+                            if sender:
+                                sender.blockSignals(True)
+                                sender.setChecked(False)
+                                sender.blockSignals(False)
+                            return
+                    termbase_mgr.set_termbase_ai_inject(tb_id, checked)
+                    self.log(f"{'✅ Enabled' if checked else '❌ Disabled'} AI injection for glossary: {tb_name}")
+
+                ai_checkbox.toggled.connect(on_ai_toggle)
+                termbase_table.setCellWidget(row, 7, ai_checkbox)
+
             # Update header checkbox states based on current selection
             tb_read_header_checkbox.blockSignals(True)
             tb_write_header_checkbox.blockSignals(True)
@@ -14494,8 +14982,8 @@ class SupervertalerQt(QMainWindow):
             )
             
             if result:
-                # Auto-activate for current project
-                if project_id:
+                # Auto-activate for current project (or global=0 if no project loaded)
+                if project_id is not None:
                     tm_metadata_mgr.activate_tm(result, project_id)
                 
                 QMessageBox.information(self, "Success", f"Translation Memory '{name}' created successfully!")
@@ -15069,11 +15557,11 @@ class SupervertalerQt(QMainWindow):
         layout.addWidget(settings_tabs)
         
         # Apply saved UI font scale on startup
-        saved_scale = self._get_settings_ui_font_scale()
+        saved_scale = self._get_global_ui_font_scale()
         if saved_scale != 100:
             # Defer application to ensure widgets are fully created
             from PyQt6.QtCore import QTimer
-            QTimer.singleShot(100, lambda: self._apply_settings_ui_font_scale(saved_scale))
+            QTimer.singleShot(100, lambda: self._apply_global_ui_font_scale(saved_scale))
         
         return tab
     
@@ -15408,7 +15896,57 @@ class SupervertalerQt(QMainWindow):
         
         model_group.setLayout(model_layout)
         layout.addWidget(model_group)
-        
+
+        # ========== SECTION 2b: Model Version Checker ==========
+        version_check_group = QGroupBox("🔄 Model Version Checker")
+        version_check_layout = QVBoxLayout()
+
+        version_check_info = QLabel(
+            "Automatically check for new LLM models from OpenAI, Anthropic, and Google.\n"
+            "Get notified when new models are available and easily add them to Supervertaler."
+        )
+        version_check_info.setWordWrap(True)
+        version_check_layout.addWidget(version_check_info)
+
+        # Auto-check setting
+        auto_check_models_cb = CheckmarkCheckBox("Enable automatic model checking (once per day on startup)")
+        auto_check_models_cb.setChecked(general_settings.get('auto_check_models', True))
+        auto_check_models_cb.setToolTip(
+            "When enabled, Supervertaler will check for new models once per day when you start the application.\n"
+            "You'll see a popup if new models are detected."
+        )
+        version_check_layout.addWidget(auto_check_models_cb)
+
+        # Manual check button
+        manual_check_btn = QPushButton("🔍 Check for New Models Now")
+        manual_check_btn.setToolTip("Manually check for new models from all providers")
+        manual_check_btn.clicked.connect(lambda: self._check_for_new_models(force=True))
+        version_check_layout.addWidget(manual_check_btn)
+
+        # Store reference for saving
+        self.auto_check_models_cb = auto_check_models_cb
+
+        version_check_group.setLayout(version_check_layout)
+        layout.addWidget(version_check_group)
+
+        # ========== SECTION 2c: API Keys ==========
+        api_keys_group = QGroupBox("🔑 API Keys")
+        api_keys_layout = QVBoxLayout()
+
+        api_keys_info = QLabel(
+            f"Configure your API keys in:<br>"
+            f"<code>{self.user_data_path / 'api_keys.txt'}</code>"
+        )
+        api_keys_info.setWordWrap(True)
+        api_keys_layout.addWidget(api_keys_info)
+
+        open_keys_btn = QPushButton("📝 Open API Keys File")
+        open_keys_btn.clicked.connect(lambda: self.open_api_keys_file())
+        api_keys_layout.addWidget(open_keys_btn)
+
+        api_keys_group.setLayout(api_keys_layout)
+        layout.addWidget(api_keys_group)
+
         # ========== SECTION 3: Enable/Disable LLM Providers ==========
         provider_enable_group = QGroupBox("✅ Enable/Disable LLM Providers")
         provider_enable_layout = QVBoxLayout()
@@ -15688,58 +16226,7 @@ class SupervertalerQt(QMainWindow):
         
         behavior_group.setLayout(behavior_layout)
         layout.addWidget(behavior_group)
-        
-        # ========== SECTION 7: API Keys ==========
-        # ========== MODEL VERSION CHECKER ==========
-        version_check_group = QGroupBox("🔄 Model Version Checker")
-        version_check_layout = QVBoxLayout()
-
-        version_check_info = QLabel(
-            "Automatically check for new LLM models from OpenAI, Anthropic, and Google.\n"
-            "Get notified when new models are available and easily add them to Supervertaler."
-        )
-        version_check_info.setWordWrap(True)
-        version_check_layout.addWidget(version_check_info)
-
-        # Auto-check setting
-        auto_check_models_cb = CheckmarkCheckBox("Enable automatic model checking (once per day on startup)")
-        auto_check_models_cb.setChecked(general_settings.get('auto_check_models', True))
-        auto_check_models_cb.setToolTip(
-            "When enabled, Supervertaler will check for new models once per day when you start the application.\n"
-            "You'll see a popup if new models are detected."
-        )
-        version_check_layout.addWidget(auto_check_models_cb)
-
-        # Manual check button
-        manual_check_btn = QPushButton("🔍 Check for New Models Now")
-        manual_check_btn.setToolTip("Manually check for new models from all providers")
-        manual_check_btn.clicked.connect(lambda: self._check_for_new_models(force=True))
-        version_check_layout.addWidget(manual_check_btn)
-
-        # Store reference for saving
-        self.auto_check_models_cb = auto_check_models_cb
 
-        version_check_group.setLayout(version_check_layout)
-        layout.addWidget(version_check_group)
-
-        # ========== API KEYS ==========
-        api_keys_group = QGroupBox("🔑 API Keys")
-        api_keys_layout = QVBoxLayout()
-
-        api_keys_info = QLabel(
-            f"Configure your API keys in:<br>"
-            f"<code>{self.user_data_path / 'api_keys.txt'}</code>"
-        )
-        api_keys_info.setWordWrap(True)
-        api_keys_layout.addWidget(api_keys_info)
-
-        open_keys_btn = QPushButton("📝 Open API Keys File")
-        open_keys_btn.clicked.connect(lambda: self.open_api_keys_file())
-        api_keys_layout.addWidget(open_keys_btn)
-
-        api_keys_group.setLayout(api_keys_layout)
-        layout.addWidget(api_keys_group)
-        
         # ========== SAVE BUTTON ==========
         save_btn = QPushButton("💾 Save AI Settings")
         save_btn.setStyleSheet("font-weight: bold; padding: 8px; outline: none;")
@@ -17236,26 +17723,27 @@ class SupervertalerQt(QMainWindow):
         termview_group.setLayout(termview_layout)
         layout.addWidget(termview_group)
         
-        # ===== UI Font Scale (for Settings panels) =====
-        ui_scale_group = QGroupBox("🖥️ Settings Panel Font Size")
+        # ===== Global UI Font Scale =====
+        ui_scale_group = QGroupBox("🖥️ Global UI Font Scale")
         ui_scale_layout = QVBoxLayout()
-        
+
         ui_scale_info = QLabel(
-            "Adjust the font size for all Settings panel text. Useful for high-DPI/4K displays.\n"
+            "Adjust the font size for the entire application UI. Useful for Linux/macOS users where\n"
+            "Qt applications may render with smaller fonts, or for high-DPI displays.\n"
             "Changes apply immediately. Default is 100%."
         )
         ui_scale_info.setWordWrap(True)
         ui_scale_layout.addWidget(ui_scale_info)
-        
+
         ui_scale_row = QHBoxLayout()
         ui_scale_row.addWidget(QLabel("UI Font Scale:"))
         ui_scale_spin = QSpinBox()
-        ui_scale_spin.setMinimum(80)
+        ui_scale_spin.setMinimum(50)
         ui_scale_spin.setMaximum(200)
-        ui_scale_spin.setValue(font_settings.get('settings_ui_font_scale', 100))
+        ui_scale_spin.setValue(font_settings.get('global_ui_font_scale', font_settings.get('settings_ui_font_scale', 100)))
         ui_scale_spin.setSuffix("%")
         ui_scale_spin.setSingleStep(10)
-        ui_scale_spin.setToolTip("Scale Settings panel text (80%-200%)")
+        ui_scale_spin.setToolTip("Scale entire application UI text (50%-200%)")
         ui_scale_spin.setMinimumHeight(28)
         ui_scale_spin.setMinimumWidth(90)
         ui_scale_spin.setStyleSheet("""
@@ -17272,11 +17760,11 @@ class SupervertalerQt(QMainWindow):
             }
         """)
         ui_scale_row.addWidget(ui_scale_spin)
-        
+
         # Apply button for immediate feedback
         apply_scale_btn = QPushButton("Apply")
         apply_scale_btn.setToolTip("Apply font scale immediately")
-        apply_scale_btn.clicked.connect(lambda: self._apply_settings_ui_font_scale(ui_scale_spin.value()))
+        apply_scale_btn.clicked.connect(lambda: self._apply_global_ui_font_scale(ui_scale_spin.value()))
         ui_scale_row.addWidget(apply_scale_btn)
         
         ui_scale_row.addStretch()
@@ -17316,7 +17804,7 @@ class SupervertalerQt(QMainWindow):
         def save_view_settings_with_scale():
             # Save the UI scale setting first
             if hasattr(self, '_ui_scale_spin'):
-                self._apply_settings_ui_font_scale(self._ui_scale_spin.value())
+                self._apply_global_ui_font_scale(self._ui_scale_spin.value())
             # Then save other view settings
             self._save_view_settings_from_ui(
                 grid_font_spin, match_font_spin, compare_font_spin, show_tags_check, tag_color_btn,
@@ -19444,72 +19932,51 @@ class SupervertalerQt(QMainWindow):
         msg.setStandardButtons(QMessageBox.StandardButton.Ok)
         msg.exec()
     
-    def _apply_settings_ui_font_scale(self, scale_percent: int):
-        """Apply font scale to all Settings panels for better readability on high-DPI displays"""
-        # Save the setting
+    def _apply_global_ui_font_scale(self, scale_percent: int):
+        """Apply font scale to the entire application UI"""
         general_settings = self.load_general_settings()
-        general_settings['settings_ui_font_scale'] = scale_percent
+        general_settings['global_ui_font_scale'] = scale_percent
+        # Remove old key if present (migration)
+        if 'settings_ui_font_scale' in general_settings:
+            del general_settings['settings_ui_font_scale']
         self.save_general_settings(general_settings)
-        
-        # Calculate base font size (default system font is typically 9-10pt)
-        base_size = 10  # Base font size in points
-        scaled_size = int(base_size * scale_percent / 100)
-        
-        # Create stylesheet for Settings panels
-        settings_stylesheet = f"""
-            QGroupBox {{
-                font-size: {scaled_size + 1}pt;
-                font-weight: bold;
-            }}
-            QGroupBox QLabel {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QCheckBox {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QRadioButton {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QComboBox {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QSpinBox {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QLineEdit {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QPushButton {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QTextEdit {{
-                font-size: {scaled_size}pt;
-            }}
-            QGroupBox QPlainTextEdit {{
-                font-size: {scaled_size}pt;
-            }}
-        """
-        
-        # Apply to settings_tabs if it exists
-        if hasattr(self, 'settings_tabs') and self.settings_tabs is not None:
-            self.settings_tabs.setStyleSheet(
-                "QTabBar::tab { outline: 0; font-size: " + str(scaled_size) + "pt; } "
-                "QTabBar::tab:focus { outline: none; } "
-                "QTabBar::tab:selected { border-bottom: 1px solid #2196F3; background-color: rgba(33, 150, 243, 0.08); }"
-            )
-            
-            # Apply to each tab's content
-            for i in range(self.settings_tabs.count()):
-                widget = self.settings_tabs.widget(i)
-                if widget:
-                    widget.setStyleSheet(settings_stylesheet)
-        
-        self.log(f"✓ Settings UI font scale set to {scale_percent}% (base: {scaled_size}pt)")
-    
-    def _get_settings_ui_font_scale(self) -> int:
-        """Get the current Settings UI font scale percentage"""
+
+        # Update ThemeManager and reapply theme
+        if hasattr(self, 'theme_manager') and self.theme_manager is not None:
+            self.theme_manager.font_scale = scale_percent
+            self.theme_manager.apply_theme(QApplication.instance())
+
+        # Update status bar and main tabs fonts
+        self._update_status_bar_fonts(scale_percent)
+        self._update_main_tabs_fonts(scale_percent)
+        self.log(f"✓ Global UI font scale set to {scale_percent}%")
+
+    def _update_status_bar_fonts(self, scale_percent: int):
+        """Update status bar label fonts based on scale percentage"""
+        base_size = int(9 * scale_percent / 100)
+        small_size = max(7, base_size)
+        style = f"font-size: {small_size}pt;"
+
+        # Update all status bar labels if they exist
+        for attr_name in ['segment_count_label', 'file_label', 'tm_status_label',
+                          'termbase_status_label', 'source_lang_label', 'target_lang_label']:
+            if hasattr(self, attr_name):
+                label = getattr(self, attr_name)
+                if label is not None:
+                    label.setStyleSheet(style)
+
+    def _update_main_tabs_fonts(self, scale_percent: int):
+        """Update main tab bar fonts based on scale percentage"""
+        base_size = int(10 * scale_percent / 100)
+        if hasattr(self, 'main_tabs') and self.main_tabs is not None:
+            self.main_tabs.tabBar().setStyleSheet(f"font-size: {base_size}pt;")
+
+    def _get_global_ui_font_scale(self) -> int:
+        """Get the current global UI font scale percentage"""
         general_settings = self.load_general_settings()
-        return general_settings.get('settings_ui_font_scale', 100)
+        # Check new key first, fall back to old key for migration
+        return general_settings.get('global_ui_font_scale',
+                                    general_settings.get('settings_ui_font_scale', 100))
     
     def create_grid_view_widget(self):
         """Create the Grid View widget (existing grid functionality)"""
@@ -19844,7 +20311,13 @@ class SupervertalerQt(QMainWindow):
             self.pagination_label = QLabel("Segments 1-50 of 0")
         self.pagination_label.setStyleSheet("color: #555;")
         pagination_layout.addWidget(self.pagination_label)
-        
+
+        # Tip label for Ctrl+, shortcut (subtle, helpful for new users)
+        tip_label = QLabel("💡 Tip: Ctrl+, inserts the next tag from source")
+        tip_label.setStyleSheet("color: #888; font-size: 9pt; margin-left: 20px;")
+        tip_label.setToolTip("Select text first to wrap it with a tag pair (e.g., <b>selection</b>)")
+        pagination_layout.addWidget(tip_label)
+
         pagination_layout.addStretch()
         
         # Pagination controls (right side)
@@ -19972,6 +20445,7 @@ class SupervertalerQt(QMainWindow):
         from modules.statuses import get_status, STATUSES
         status_label = QLabel("Status:")
         tab_status_combo = QComboBox()
+        tab_status_combo.setMinimumWidth(130)  # Ensure full status text is visible
         for status_key in STATUSES.keys():
             definition = get_status(status_key)
             tab_status_combo.addItem(definition.label, status_key)
@@ -20870,6 +21344,7 @@ class SupervertalerQt(QMainWindow):
         from modules.statuses import STATUSES
         status_label = QLabel("Status:")
         tab_status_combo = QComboBox()
+        tab_status_combo.setMinimumWidth(130)  # Ensure full status text is visible
         for status_key in STATUSES.keys():
             definition = get_status(status_key)
             tab_status_combo.addItem(definition.label, status_key)
@@ -21832,20 +22307,24 @@ class SupervertalerQt(QMainWindow):
         """
         Search termbases using a provided cursor (thread-safe for background threads).
         This method allows background workers to query the database without SQLite threading errors.
-        
+
+        Implements BIDIRECTIONAL matching: searches both source_term and target_term columns.
+        When a match is found on target_term, source and target are swapped in the result.
+        This matches memoQ/Trados behavior where a NL→EN termbase also works for EN→NL projects.
+
         Args:
             source_text: The source text to search for
             cursor: A database cursor from a thread-local connection
             source_lang: Source language code
             target_lang: Target language code
             project_id: Current project ID (required to filter by activated termbases)
-        
+
         Returns:
             Dictionary of {term: translation} matches
         """
         if not source_text or not cursor:
             return {}
-        
+
         try:
             # Convert language names to codes (match interactive search logic)
             source_lang_code = self._convert_language_to_code(source_lang) if source_lang else None
@@ -21865,20 +22344,26 @@ class SupervertalerQt(QMainWindow):
                 try:
                     # JOIN termbases AND termbase_activation to filter by activated termbases
                     # This matches the logic in database_manager.py search_termbases()
+                    # BIDIRECTIONAL: Search both source_term (forward) and target_term (reverse)
+                    # Using UNION to combine both directions
                     query = """
-                        SELECT 
-                            t.id, t.source_term, t.target_term, t.termbase_id, t.priority,
-                            t.domain, t.notes, t.project, t.client, t.forbidden,
-                            tb.is_project_termbase, tb.name as termbase_name, 
-                            COALESCE(ta.priority, tb.ranking) as ranking
-                        FROM termbase_terms t
-                        LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
-                        LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
-                        WHERE LOWER(t.source_term) LIKE ?
-                        AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
+                        SELECT * FROM (
+                            -- Forward match: search source_term
+                            SELECT
+                                t.id, t.source_term, t.target_term, t.termbase_id, t.priority,
+                                t.domain, t.notes, t.project, t.client, t.forbidden,
+                                tb.is_project_termbase, tb.name as termbase_name,
+                                COALESCE(ta.priority, tb.ranking) as ranking,
+                                'source' as match_direction
+                            FROM termbase_terms t
+                            LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
+                            LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
+                            WHERE LOWER(t.source_term) LIKE ?
+                            AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
                     """
                     params = [project_id if project_id else 0, f"%{clean_word.lower()}%"]
 
+                    # Language filters for forward query
                     if source_lang_code:
                         query += " AND (t.source_lang = ? OR (t.source_lang IS NULL AND tb.source_lang = ?) OR (t.source_lang IS NULL AND tb.source_lang IS NULL))"
                         params.extend([source_lang_code, source_lang_code])
@@ -21886,15 +22371,45 @@ class SupervertalerQt(QMainWindow):
                         query += " AND (t.target_lang = ? OR (t.target_lang IS NULL AND tb.target_lang = ?) OR (t.target_lang IS NULL AND tb.target_lang IS NULL))"
                         params.extend([target_lang_code, target_lang_code])
 
-                    # Limit raw hits per word to keep batch worker light
-                    query += " LIMIT 15"
+                    # Reverse match: search target_term, swap source/target in output
+                    query += """
+                            UNION ALL
+                            -- Reverse match: search target_term, swap columns
+                            SELECT
+                                t.id, t.target_term as source_term, t.source_term as target_term,
+                                t.termbase_id, t.priority,
+                                t.domain, t.notes, t.project, t.client, t.forbidden,
+                                tb.is_project_termbase, tb.name as termbase_name,
+                                COALESCE(ta.priority, tb.ranking) as ranking,
+                                'target' as match_direction
+                            FROM termbase_terms t
+                            LEFT JOIN termbases tb ON CAST(t.termbase_id AS INTEGER) = tb.id
+                            LEFT JOIN termbase_activation ta ON ta.termbase_id = tb.id AND ta.project_id = ? AND ta.is_active = 1
+                            WHERE LOWER(t.target_term) LIKE ?
+                            AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
+                    """
+                    params.extend([project_id if project_id else 0, f"%{clean_word.lower()}%"])
+
+                    # Language filters for reverse query (swapped)
+                    if source_lang_code:
+                        # For reverse: source_lang filters target_lang column
+                        query += " AND (t.target_lang = ? OR (t.target_lang IS NULL AND tb.target_lang = ?) OR (t.target_lang IS NULL AND tb.target_lang IS NULL))"
+                        params.extend([source_lang_code, source_lang_code])
+                    if target_lang_code:
+                        # For reverse: target_lang filters source_lang column
+                        query += " AND (t.source_lang = ? OR (t.source_lang IS NULL AND tb.source_lang = ?) OR (t.source_lang IS NULL AND tb.source_lang IS NULL))"
+                        params.extend([target_lang_code, target_lang_code])
+
+                    # Close UNION and limit
+                    query += ") combined LIMIT 30"
                     cursor.execute(query, params)
                     results = cursor.fetchall()
 
                     for row in results:
-                        # Uniform access
+                        # Uniform access (columns are already swapped for reverse matches)
                         source_term = row[1] if isinstance(row, tuple) else row['source_term']
                         target_term = row[2] if isinstance(row, tuple) else row['target_term']
+                        match_direction = row[13] if isinstance(row, tuple) else row.get('match_direction', 'source')
                         if not source_term or not target_term:
                             continue
 
@@ -21918,8 +22433,10 @@ class SupervertalerQt(QMainWindow):
                         existing = matches.get(source_term.strip())
                         # Deduplicate: keep numerically lowest ranking (highest priority)
                         # For project termbases, ranking is None so they always win
+                        # Also prefer 'source' matches over 'target' matches when equal
                         if existing:
                             existing_ranking = existing.get('ranking', None)
+                            existing_direction = existing.get('match_direction', 'source')
                             if is_project_tb:
                                 # Project termbase always wins
                                 pass
@@ -21928,8 +22445,12 @@ class SupervertalerQt(QMainWindow):
                                 continue
                             elif existing_ranking is not None and ranking is not None:
                                 # Both have rankings, keep lower (higher priority)
-                                if existing_ranking <= ranking:
+                                if existing_ranking < ranking:
                                     continue
+                                elif existing_ranking == ranking:
+                                    # Same ranking: prefer source match over target match
+                                    if existing_direction == 'source' and match_direction == 'target':
+                                        continue
 
                         matches[source_term.strip()] = {
                             'translation': target_term.strip(),
@@ -21944,15 +22465,18 @@ class SupervertalerQt(QMainWindow):
                             'forbidden': forbidden or False,
                             'is_project_termbase': bool(is_project_tb),
                             'termbase_name': termbase_name or '',
-                            'target_synonyms': []  # Will be populated below
+                            'target_synonyms': [],  # Will be populated below
+                            'match_direction': match_direction  # Track if this was a reverse match
                         }
-                        
+
                         # Fetch synonyms for this term
+                        # For reverse matches, fetch 'source' synonyms since they become targets
                         try:
+                            synonym_lang = 'source' if match_direction == 'target' else 'target'
                             cursor.execute("""
-                                SELECT synonym_text FROM termbase_synonyms 
-                                WHERE term_id = ? AND language = 'target' AND forbidden = 0
-                            """, (term_id,))
+                                SELECT synonym_text FROM termbase_synonyms
+                                WHERE term_id = ? AND language = ? AND forbidden = 0
+                            """, (term_id, synonym_lang))
                             synonym_rows = cursor.fetchall()
                             for syn_row in synonym_rows:
                                 synonym = syn_row[0] if isinstance(syn_row, tuple) else syn_row['synonym_text']
@@ -22319,27 +22843,31 @@ class SupervertalerQt(QMainWindow):
     def save_segment_to_activated_tms(self, source: str, target: str):
         """
         Save segment to all writable TMs for current project.
-        
+
         Note: Uses get_writable_tm_ids() which checks the Write checkbox (read_only=0),
         NOT get_active_tm_ids() which checks the Read checkbox (is_active=1).
-        
+
+        Respects tm_save_mode setting:
+        - 'latest': Overwrites existing entries with same source (keeps only newest translation)
+        - 'all': Keeps all translations with different targets (default SQLite behavior)
+
         Args:
             source: Source text
             target: Target text
         """
         if not self.current_project:
             return
-        
+
         if not hasattr(self.current_project, 'source_lang') or not hasattr(self.current_project, 'target_lang'):
             return
-        
+
         # Get WRITABLE TM IDs for this project (Write checkbox enabled)
         tm_ids = []
-        
+
         if hasattr(self, 'tm_metadata_mgr') and self.tm_metadata_mgr:
             if hasattr(self, 'current_project') and self.current_project:
                 project_id = self.current_project.id if hasattr(self.current_project, 'id') else None
-                
+
                 if project_id:
                     # Use get_writable_tm_ids() to find TMs with Write enabled
                     tm_ids = self.tm_metadata_mgr.get_writable_tm_ids(project_id)
@@ -22349,13 +22877,16 @@ class SupervertalerQt(QMainWindow):
                 self.log(f"⚠️ Cannot save to TM: No current project loaded!")
         else:
             self.log(f"⚠️ Cannot save to TM: TM metadata manager not available!")
-        
+
         # If no TMs have Write enabled, skip saving
         if not tm_ids:
             self.log("⚠️ No TMs with Write enabled - segment not saved to TM.")
             self.log(f"   - To fix: Go to Resources > Translation Memories > TM List and enable the Write checkbox")
             return
-        
+
+        # Check TM save mode: 'latest' = overwrite, 'all' = keep all variants
+        overwrite_mode = getattr(self, 'tm_save_mode', 'latest') == 'latest'
+
         # Save to each writable TM
         saved_count = 0
         for tm_id in tm_ids:
@@ -22365,14 +22896,16 @@ class SupervertalerQt(QMainWindow):
                     target=target,
                     source_lang=self.current_project.source_lang,
                     target_lang=self.current_project.target_lang,
-                    tm_id=tm_id
+                    tm_id=tm_id,
+                    overwrite=overwrite_mode
                 )
                 saved_count += 1
             except Exception as e:
                 self.log(f"⚠️ Could not save to TM '{tm_id}': {e}")
-        
+
         if saved_count > 0:
-            msg = f"💾 Saved segment to {saved_count} TM(s)"
+            mode_note = " (overwrite)" if overwrite_mode else ""
+            msg = f"💾 Saved segment to {saved_count} TM(s){mode_note}"
             self._queue_tm_save_log(msg)
             # Invalidate cache so prefetched segments get fresh TM matches
             self.invalidate_translation_cache()
@@ -26149,24 +26682,32 @@ class SupervertalerQt(QMainWindow):
                 )
                 return
             
-            # Extract segments
-            mqxliff_segments = handler.extract_source_segments()
-            
+            # Extract segments (including targets for pretranslated files)
+            mqxliff_segments = handler.extract_bilingual_segments()
+
             if not mqxliff_segments:
                 QMessageBox.warning(
                     self, "No Segments",
                     "No segments found in the memoQ XLIFF file."
                 )
                 return
-            
+
+            # Count pretranslated segments
+            pretranslated_count = sum(1 for s in mqxliff_segments if s.get('target', '').strip())
+
             # Convert to internal Segment format
             segments = []
             for i, mq_seg in enumerate(mqxliff_segments):
+                # Map status from mqxliff
+                status = mq_seg.get('status', 'not_started')
+                if status not in ['not_started', 'pre_translated', 'translated', 'confirmed', 'locked']:
+                    status = 'not_started'
+
                 segment = Segment(
                     id=i + 1,
-                    source=mq_seg.plain_text,
-                    target="",
-                    status=DEFAULT_STATUS.key,
+                    source=mq_seg.get('source', ''),
+                    target=mq_seg.get('target', ''),
+                    status=status,
                     notes="",
                 )
                 segments.append(segment)
@@ -26210,11 +26751,17 @@ class SupervertalerQt(QMainWindow):
             # Log success
             self.log(f"✓ Imported {len(segments)} segments from memoQ XLIFF: {Path(file_path).name}")
             self.log(f"  Source: {source_lang}, Target: {target_lang}")
-            
+            if pretranslated_count > 0:
+                self.log(f"  Pretranslated: {pretranslated_count} segments with target text")
+
+            # Build message with pretranslation info
+            msg = f"Successfully imported {len(segments)} segment(s) from memoQ XLIFF.\n\nLanguages: {source_lang} → {target_lang}"
+            if pretranslated_count > 0:
+                msg += f"\n\nPretranslated: {pretranslated_count} segment(s) with target text loaded."
+
             QMessageBox.information(
                 self, "Import Successful",
-                f"Successfully imported {len(segments)} segment(s) from memoQ XLIFF.\n\n"
-                f"Languages: {source_lang} → {target_lang}"
+                msg
             )
         except Exception as e:
             self.log(f"❌ Error importing memoQ XLIFF: {e}")
@@ -26623,7 +27170,19 @@ class SupervertalerQt(QMainWindow):
             source_row = QHBoxLayout()
             source_row.addWidget(QLabel("Source Language:"))
             source_combo = QComboBox()
-            source_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            # Full language list (same as New Project dialog)
+            available_languages = [
+                "Afrikaans", "Albanian", "Arabic", "Armenian", "Basque", "Bengali",
+                "Bulgarian", "Catalan", "Chinese (Simplified)", "Chinese (Traditional)",
+                "Croatian", "Czech", "Danish", "Dutch", "English", "Estonian",
+                "Finnish", "French", "Galician", "Georgian", "German", "Greek",
+                "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Irish",
+                "Italian", "Japanese", "Korean", "Latvian", "Lithuanian", "Macedonian",
+                "Malay", "Norwegian", "Persian", "Polish", "Portuguese", "Romanian",
+                "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili",
+                "Swedish", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
+            ]
+            source_combo.addItems(available_languages)
             # Try to match current UI selection
             current_source = self.source_lang_combo.currentText() if hasattr(self, 'source_lang_combo') else "English"
             source_idx = source_combo.findText(current_source)
@@ -26631,12 +27190,12 @@ class SupervertalerQt(QMainWindow):
                 source_combo.setCurrentIndex(source_idx)
             source_row.addWidget(source_combo)
             lang_group_layout.addLayout(source_row)
-            
+
             # Target language
             target_row = QHBoxLayout()
             target_row.addWidget(QLabel("Target Language:"))
             target_combo = QComboBox()
-            target_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            target_combo.addItems(available_languages)
             # Try to match current UI selection
             current_target = self.target_lang_combo.currentText() if hasattr(self, 'target_lang_combo') else "Dutch"
             target_idx = target_combo.findText(current_target)
@@ -26644,15 +27203,15 @@ class SupervertalerQt(QMainWindow):
                 target_combo.setCurrentIndex(target_idx)
             target_row.addWidget(target_combo)
             lang_group_layout.addLayout(target_row)
-            
+
             lang_layout.addWidget(lang_group)
-            
+
             # Buttons
             lang_buttons = QDialogButtonBox(QDialogButtonBox.StandardButton.Ok | QDialogButtonBox.StandardButton.Cancel)
             lang_buttons.accepted.connect(lang_dialog.accept)
             lang_buttons.rejected.connect(lang_dialog.reject)
             lang_layout.addWidget(lang_buttons)
-            
+
             if lang_dialog.exec() != QDialog.DialogCode.Accepted:
                 self.log("✗ User cancelled Trados import during language selection")
                 return
@@ -27303,7 +27862,19 @@ class SupervertalerQt(QMainWindow):
             source_row = QHBoxLayout()
             source_row.addWidget(QLabel("Source Language:"))
             source_combo = QComboBox()
-            source_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            # Full language list (same as New Project dialog)
+            available_languages = [
+                "Afrikaans", "Albanian", "Arabic", "Armenian", "Basque", "Bengali",
+                "Bulgarian", "Catalan", "Chinese (Simplified)", "Chinese (Traditional)",
+                "Croatian", "Czech", "Danish", "Dutch", "English", "Estonian",
+                "Finnish", "French", "Galician", "Georgian", "German", "Greek",
+                "Hebrew", "Hindi", "Hungarian", "Icelandic", "Indonesian", "Irish",
+                "Italian", "Japanese", "Korean", "Latvian", "Lithuanian", "Macedonian",
+                "Malay", "Norwegian", "Persian", "Polish", "Portuguese", "Romanian",
+                "Russian", "Serbian", "Slovak", "Slovenian", "Spanish", "Swahili",
+                "Swedish", "Thai", "Turkish", "Ukrainian", "Urdu", "Vietnamese", "Welsh"
+            ]
+            source_combo.addItems(available_languages)
             # Try to match current UI selection
             current_source = self.source_lang_combo.currentText() if hasattr(self, 'source_lang_combo') else "English"
             source_idx = source_combo.findText(current_source)
@@ -27316,7 +27887,7 @@ class SupervertalerQt(QMainWindow):
             target_row = QHBoxLayout()
             target_row.addWidget(QLabel("Target Language:"))
             target_combo = QComboBox()
-            target_combo.addItems(["English", "Dutch", "German", "French", "Spanish", "Italian", "Portuguese", "Polish", "Chinese", "Japanese", "Korean", "Russian"])
+            target_combo.addItems(available_languages)
             # Try to match current UI selection
             current_target = self.target_lang_combo.currentText() if hasattr(self, 'target_lang_combo') else "Dutch"
             target_idx = target_combo.findText(current_target)
@@ -31385,9 +31956,14 @@ class SupervertalerQt(QMainWindow):
         
         # Get source text
         source_text = current_segment.source
-        
+
+        # Get glossary terms for AI injection
+        glossary_terms = self.get_ai_inject_glossary_terms()
+
         # Build combined prompt
-        combined = self.prompt_manager_qt.build_final_prompt(source_text, source_lang, target_lang)
+        combined = self.prompt_manager_qt.build_final_prompt(
+            source_text, source_lang, target_lang, glossary_terms=glossary_terms
+        )
         
         # Check for figure/image context
         figure_info = ""
@@ -31414,11 +31990,14 @@ class SupervertalerQt(QMainWindow):
         composition_parts.append(f"📏 Total prompt: {len(combined):,} characters")
         
         if self.prompt_manager_qt.library.active_primary_prompt:
-            composition_parts.append(f"✓ Primary prompt attached")
+            composition_parts.append(f"✓ Custom prompt attached")
         
         if self.prompt_manager_qt.library.attached_prompts:
             composition_parts.append(f"✓ {len(self.prompt_manager_qt.library.attached_prompts)} additional prompt(s) attached")
-        
+
+        if glossary_terms:
+            composition_parts.append(f"📚 {len(glossary_terms)} glossary term(s) injected")
+
         if figure_info:
             composition_parts.append(figure_info)
         
@@ -31453,12 +32032,59 @@ class SupervertalerQt(QMainWindow):
             image_notice.setStyleSheet("padding: 10px; border-radius: 4px; margin-bottom: 10px; border-left: 4px solid #ff9800;")
             layout.addWidget(image_notice)
         
-        # Text editor for preview
+        # Text editor for preview with syntax highlighting
         text_edit = QTextEdit()
-        text_edit.setPlainText(combined)
         text_edit.setReadOnly(True)
         text_edit.setLineWrapMode(QTextEdit.LineWrapMode.WidgetWidth)
         text_edit.setStyleSheet("font-family: 'Consolas', 'Courier New', monospace; font-size: 9pt;")
+
+        # Format the prompt with color highlighting
+        import html
+        import re
+
+        # Escape HTML entities first
+        formatted_html = html.escape(combined)
+
+        # Replace newlines with <br> for HTML
+        formatted_html = formatted_html.replace('\n', '<br>')
+
+        # Make "# SYSTEM PROMPT" bold and red
+        formatted_html = re.sub(
+            r'(#\s*SYSTEM\s*PROMPT)',
+            r'<span style="color: #d32f2f; font-weight: bold; font-size: 11pt;">\1</span>',
+            formatted_html,
+            flags=re.IGNORECASE
+        )
+
+        # Make "# CUSTOM PROMPT" bold and red
+        formatted_html = re.sub(
+            r'(#\s*CUSTOM\s*PROMPT)',
+            r'<span style="color: #d32f2f; font-weight: bold; font-size: 11pt;">\1</span>',
+            formatted_html,
+            flags=re.IGNORECASE
+        )
+
+        # Make "# GLOSSARY" bold and orange
+        formatted_html = re.sub(
+            r'(#\s*GLOSSARY)',
+            r'<span style="color: #FF9800; font-weight: bold; font-size: 11pt;">\1</span>',
+            formatted_html,
+            flags=re.IGNORECASE
+        )
+
+        # Make source text section blue (pattern: "XX text:<br>..." until double line break or # header)
+        # Match language code + " text:" followed by content until "# " or end
+        formatted_html = re.sub(
+            r'(\w{2,5}\s+text:)(<br>)(.*?)(<br><br>(?:#|\*\*YOUR TRANSLATION)|$)',
+            r'<span style="color: #1565c0; font-weight: bold;">\1</span>\2<span style="color: #1565c0;">\3</span>\4',
+            formatted_html,
+            flags=re.DOTALL
+        )
+
+        # Wrap in pre-like styling div
+        formatted_html = f'<div style="font-family: Consolas, Courier New, monospace; white-space: pre-wrap;">{formatted_html}</div>'
+
+        text_edit.setHtml(formatted_html)
         layout.addWidget(text_edit, 1)
         
         # Close button
@@ -31476,25 +32102,43 @@ class SupervertalerQt(QMainWindow):
     def show_grid_context_menu(self, position):
         """Show context menu for grid view with bulk operations"""
         selected_segments = self.get_selected_segments_from_grid()
-        
+
         if not selected_segments:
             return
-        
+
         menu = QMenu(self)
-        
+
         # Confirm selected segments action
         if len(selected_segments) >= 1:
             confirm_action = menu.addAction(f"✅ Confirm {len(selected_segments)} Segment(s)")
             confirm_action.setToolTip(f"Confirm {len(selected_segments)} selected segment(s)")
             confirm_action.triggered.connect(self.confirm_selected_segments)
-        
+
+        # Change Status submenu
+        from modules.statuses import get_status
+        status_menu = menu.addMenu(f"🏷️ Change Status ({len(selected_segments)})")
+        # Common user-settable statuses (excluding TM-specific ones like pm, cm, tm_100, etc.)
+        user_statuses = [
+            ("not_started", "❌ Not started"),
+            ("pretranslated", "🤖 Pre-translated"),
+            ("translated", "✏️ Translated"),
+            ("confirmed", "✔ Confirmed"),
+            ("tr_confirmed", "🌟 TR confirmed"),
+            ("proofread", "🟪 Proofread"),
+            ("approved", "⭐ Approved"),
+            ("rejected", "🚫 Rejected"),
+        ]
+        for status_key, label in user_statuses:
+            action = status_menu.addAction(label)
+            action.triggered.connect(lambda checked, s=status_key: self.change_status_selected(s))
+
         # Clear translations action
         clear_action = menu.addAction("🗑️ Clear Translations")
         clear_action.setToolTip(f"Clear translations for {len(selected_segments)} selected segment(s)")
         clear_action.triggered.connect(lambda: self.clear_selected_translations(selected_segments, 'grid'))
-        
+
         menu.addSeparator()
-        
+
         # Clear proofreading notes (if any selected segment has proofreading notes)
         has_proofreading = any(seg.notes and "⚠️ PROOFREAD:" in seg.notes for seg in selected_segments)
         if has_proofreading:
@@ -31502,11 +32146,11 @@ class SupervertalerQt(QMainWindow):
             clear_proofread_action.setToolTip("Remove proofreading issues from selected segment(s)")
             clear_proofread_action.triggered.connect(lambda: self._clear_proofreading_from_selected(selected_segments))
             menu.addSeparator()
-        
+
         # Select all action
         select_all_action = menu.addAction("📋 Select All (Ctrl+A)")
         select_all_action.triggered.connect(lambda: self.table.selectAll())
-        
+
         menu.exec(self.table.viewport().mapToGlobal(position))
     
     def _clear_proofreading_from_selected(self, segments):
@@ -35182,7 +35826,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     primary_prompt_text = f"✅ {prompt_path}"
             attached_count = len(library.attached_prompt_paths) if library.attached_prompt_paths else 0
         
-        ai_layout.addWidget(QLabel(f"<b>Primary Prompt:</b> {primary_prompt_text}"))
+        ai_layout.addWidget(QLabel(f"<b>Custom Prompt:</b> {primary_prompt_text}"))
         if attached_count > 0:
             ai_layout.addWidget(QLabel(f"<b>Attached Prompts:</b> {attached_count}"))
         
@@ -38331,17 +38975,75 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if not self.current_project:
             QMessageBox.information(self, "Not Available", "Please load a project first.")
             return
-        
+
         if not hasattr(self, 'table') or not self.table:
             QMessageBox.information(self, "Not Available", "Grid view is not available.")
             return
-        
+
         selected_segments = self.get_selected_segments_from_grid()
         if selected_segments:
             self.confirm_selected_segments()
         else:
             QMessageBox.information(self, "No Selection", "Please select one or more segments to confirm.")
-    
+
+    def change_status_selected(self, new_status: str, from_menu: bool = False):
+        """Change status of all selected segments to the specified status.
+
+        Args:
+            new_status: The status key to set (e.g., 'translated', 'pretranslated')
+            from_menu: If True, show message boxes for errors (called from menu)
+        """
+        if not self.current_project:
+            if from_menu:
+                QMessageBox.information(self, "Not Available", "Please load a project first.")
+            else:
+                self.log("⚠️ No project loaded")
+            return
+
+        if not hasattr(self, 'table') or not self.table:
+            if from_menu:
+                QMessageBox.information(self, "Not Available", "Grid view is not available.")
+            return
+
+        selected_segments = self.get_selected_segments_from_grid()
+
+        if not selected_segments:
+            if from_menu:
+                QMessageBox.information(self, "No Selection", "Please select one or more segments to change.")
+            else:
+                self.log("⚠️ No segments selected")
+            return
+
+        # Sync all target text from grid widgets first
+        self._sync_grid_targets_to_segments(selected_segments)
+
+        # Get status definition for logging
+        from modules.statuses import get_status
+        status_def = get_status(new_status)
+
+        changed_count = 0
+        for segment in selected_segments:
+            # Skip if already has this status
+            if segment.status == new_status:
+                continue
+
+            segment.status = new_status
+            changed_count += 1
+
+            # Update grid status icon
+            row = self._find_row_for_segment(segment.id)
+            if row >= 0:
+                self.update_status_icon(row, new_status)
+
+        if changed_count > 0:
+            self.project_modified = True
+            self.update_window_title()
+            self.log(f"✅ Changed {changed_count} segment(s) to '{status_def.label}'")
+            # Update status bar progress stats
+            self.update_progress_stats()
+        else:
+            self.log(f"ℹ️ All {len(selected_segments)} selected segment(s) already have status '{status_def.label}'")
+
     def _sync_grid_targets_to_segments(self, segments):
         """Sync target text from grid widgets to segment objects.
         
@@ -40210,13 +40912,17 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         except Exception as e:
                             self.log(f"⚠ Could not add surrounding segments: {e}")
                     
+                    # Get glossary terms for AI injection
+                    glossary_terms = self.get_ai_inject_glossary_terms()
+
                     custom_prompt = self.prompt_manager_qt.build_final_prompt(
                         source_text=segment.source,
                         source_lang=self.current_project.source_lang,
                         target_lang=self.current_project.target_lang,
-                        mode="single"
+                        mode="single",
+                        glossary_terms=glossary_terms
                     )
-                    
+
                     # Add surrounding context before the translation delimiter
                     if surrounding_context:
                         # Insert before the "YOUR TRANSLATION" delimiter
@@ -41148,25 +41854,41 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             self.log(f"📖 Pre-translate from TM: Using activated TMs: {tm_ids}")
             
             # Create progress dialog for TM pre-translation
+            import time
+            start_time = time.time()
+            total_segments = len(segments_needing_translation)
+
             progress = QProgressDialog(
-                f"Pre-translating {len(segments_needing_translation)} segments from TM...",
-                "Cancel", 0, len(segments_needing_translation), self
+                f"Pre-translating {total_segments} segments from TM...",
+                "Cancel", 0, total_segments, self
             )
-            progress.setWindowTitle("TM Pre-Translation")
+            progress.setWindowTitle("🔍 TM Pre-Translation")
             progress.setWindowModality(Qt.WindowModality.WindowModal)
             progress.setMinimumDuration(0)  # Show immediately
+            progress.setMinimumWidth(450)  # Wider dialog for more info
             progress.show()
             QApplication.processEvents()
-            
+
             success_count = 0
             no_match_count = 0
-            
+
             for idx, (row_index, segment) in enumerate(segments_needing_translation):
                 if progress.wasCanceled():
                     break
-                
+
                 progress.setValue(idx)
-                progress.setLabelText(f"Searching TM for segment {idx + 1}/{len(segments_needing_translation)}...")
+
+                # Build informative progress label
+                elapsed = time.time() - start_time
+                elapsed_str = f"{int(elapsed // 60)}:{int(elapsed % 60):02d}"
+                source_preview = segment.source[:50] + "..." if len(segment.source) > 50 else segment.source
+                label_text = (
+                    f"Searching TM for segment {idx + 1} of {total_segments}...\n\n"
+                    f"Current: \"{source_preview}\"\n"
+                    f"Matches found: {success_count}  |  Elapsed: {elapsed_str}\n\n"
+                    f"ℹ️ This may take a while for large documents."
+                )
+                progress.setLabelText(label_text)
                 QApplication.processEvents()
                 
                 try:
@@ -41184,7 +41906,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         else:
                             no_match_count += 1
                     else:
-                        # Fuzzy matching enabled - get best match ≥70%
+                        # Fuzzy matching enabled - get best match ≥75%
                         matches = self.tm_database.search_all(
                             segment.source,
                             tm_ids=tm_ids,
@@ -41194,7 +41916,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         if matches and len(matches) > 0:
                             best_match = matches[0]
                             match_pct = best_match.get('match_pct', 0)
-                            if match_pct >= 70:
+                            if match_pct >= 75:
                                 segment.target = best_match.get('target', '')
                                 segment.status = "Translated"
                                 success_count += 1
@@ -41562,9 +42284,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                             match_pct = match.get('match_pct', 0)
                             tm_match = match.get('target', '')
                             
-                            if match_pct >= 70:  # Accept matches 70% and above
+                            if match_pct >= 75:  # Accept matches 75% and above
                                 segment.target = tm_match
-                                segment.status = "translated" if match_pct == 100 else "pre-translated"
+                                segment.status = "pretranslated"
                                 translated_count += 1
                                 
                                 # Update grid immediately
@@ -41678,7 +42400,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                                 if tm_match and len(tm_match) > 0:
                                     translation = tm_match[0]['target']
                                     segment.target = translation
-                                    segment.status = 'pre-translated'
+                                    segment.status = 'pretranslated'
                                     translated_count += 1
                                     self.log(f"  ✓ Segment {segment.id}: {segment.source[:40]}... → {translation[:40]}... (TM 100%)")
                                 else:
@@ -41725,7 +42447,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
 
                                 if translation and not translation.startswith('['):  # Skip error messages
                                     segment.target = translation
-                                    segment.status = 'pre-translated'
+                                    segment.status = 'pretranslated'
                                     translated_count += 1
                                     self.log(f"  ✓ Segment {segment.id}: {segment.source[:40]}... → {translation[:40]}...")
                                 else:
@@ -41751,11 +42473,14 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     if hasattr(self, 'prompt_manager_qt') and self.prompt_manager_qt and batch_segments:
                         try:
                             first_segment = batch_segments[0][1]
+                            # Get glossary terms for AI injection
+                            glossary_terms = self.get_ai_inject_glossary_terms()
                             base_prompt = self.prompt_manager_qt.build_final_prompt(
                                 source_text=first_segment.source,
                                 source_lang=source_lang,
                                 target_lang=target_lang,
-                                mode="single"
+                                mode="single",
+                                glossary_terms=glossary_terms
                             )
                             if "**SOURCE TEXT:**" in base_prompt:
                                 base_prompt = base_prompt.split("**SOURCE TEXT:**")[0].strip()
@@ -42183,11 +42908,14 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                     # Access parent through closure
                     parent = self
                     if hasattr(parent, 'prompt_manager_qt') and parent.prompt_manager_qt:
+                        # Get glossary terms for AI injection
+                        glossary_terms = parent.get_ai_inject_glossary_terms() if hasattr(parent, 'get_ai_inject_glossary_terms') else []
                         custom_prompt = parent.prompt_manager_qt.build_final_prompt(
                             source_text=source_text,
                             source_lang=source_lang,
                             target_lang=target_lang,
-                            mode="single"
+                            mode="single",
+                            glossary_terms=glossary_terms
                         )
                 except Exception as e:
                     self.log(f"⚠ Could not build LLM prompt from manager: {e}")
@@ -42670,7 +43398,22 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             api_keys['google'] = api_keys['gemini']
         
         return api_keys
-    
+
+    def get_ai_inject_glossary_terms(self) -> list:
+        """Get glossary terms from AI-inject-enabled termbases for the current project.
+
+        Returns:
+            List of term dictionaries with source_term, target_term, forbidden keys
+        """
+        if not hasattr(self, 'termbase_mgr') or not self.termbase_mgr:
+            return []
+
+        project_id = None
+        if hasattr(self, 'current_project') and self.current_project:
+            project_id = getattr(self.current_project, 'id', None)
+
+        return self.termbase_mgr.get_ai_inject_terms(project_id)
+
     def ensure_example_api_keys(self):
         """Create example API keys file on first launch for new users"""
         example_file = self.user_data_path / "api_keys.example.txt"
@@ -47985,7 +48728,87 @@ class BlueCheckmarkCheckBox(QCheckBox):
                 
                 painter.drawLine(QPointF(check_x2, check_y2), QPointF(check_x3, check_y3))
                 painter.drawLine(QPointF(check_x1, check_y1), QPointF(check_x2, check_y2))
-                
+
+                painter.end()
+
+
+class OrangeCheckmarkCheckBox(QCheckBox):
+    """Custom checkbox with orange background and white checkmark when checked (for AI injection)"""
+
+    def __init__(self, text="", parent=None):
+        super().__init__(text, parent)
+        self.setCheckable(True)
+        self.setEnabled(True)
+        self.setStyleSheet("""
+            QCheckBox {
+                font-size: 9pt;
+                spacing: 6px;
+            }
+            QCheckBox::indicator {
+                width: 16px;
+                height: 16px;
+                border: 2px solid #999;
+                border-radius: 3px;
+                background-color: white;
+            }
+            QCheckBox::indicator:checked {
+                background-color: #FF9800;
+                border-color: #FF9800;
+            }
+            QCheckBox::indicator:hover {
+                border-color: #666;
+            }
+            QCheckBox::indicator:checked:hover {
+                background-color: #F57C00;
+                border-color: #F57C00;
+            }
+        """)
+
+    def paintEvent(self, event):
+        """Override paint event to draw white checkmark when checked"""
+        super().paintEvent(event)
+
+        if self.isChecked():
+            from PyQt6.QtWidgets import QStyleOptionButton
+            from PyQt6.QtGui import QPainter, QPen, QColor
+            from PyQt6.QtCore import QPointF
+
+            opt = QStyleOptionButton()
+            self.initStyleOption(opt)
+            indicator_rect = self.style().subElementRect(
+                self.style().SubElement.SE_CheckBoxIndicator,
+                opt,
+                self
+            )
+
+            if indicator_rect.isValid():
+                painter = QPainter(self)
+                painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+                pen_width = max(2.0, min(indicator_rect.width(), indicator_rect.height()) * 0.12)
+                painter.setPen(QPen(QColor(255, 255, 255), pen_width, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap, Qt.PenJoinStyle.RoundJoin))
+                painter.setBrush(QColor(255, 255, 255))
+
+                x = indicator_rect.x()
+                y = indicator_rect.y()
+                w = indicator_rect.width()
+                h = indicator_rect.height()
+
+                padding = min(w, h) * 0.15
+                x += padding
+                y += padding
+                w -= padding * 2
+                h -= padding * 2
+
+                check_x1 = x + w * 0.10
+                check_y1 = y + h * 0.50
+                check_x2 = x + w * 0.35
+                check_y2 = y + h * 0.70
+                check_x3 = x + w * 0.90
+                check_y3 = y + h * 0.25
+
+                painter.drawLine(QPointF(check_x2, check_y2), QPointF(check_x3, check_y3))
+                painter.drawLine(QPointF(check_x1, check_y1), QPointF(check_x2, check_y2))
+
                 painter.end()