supervertaler 1.9.185__py3-none-any.whl → 1.9.196__py3-none-any.whl

Supervertaler.py

@@ -32,9 +32,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.185"
+__version__ = "1.9.196"
 __phase__ = "0.9"
-__release_date__ = "2026-02-01"
+__release_date__ = "2026-02-02"
 __edition__ = "Qt"
 
 import sys
@@ -2298,10 +2298,15 @@ class ReadOnlyGridTextEditor(QTextEdit):
         
         # Superlookup search action
         if self.textCursor().hasSelection():
-            superlookup_action = QAction("🔍 Search in Superlookup (Ctrl+K)", self)
+            superlookup_action = QAction("🔍 Search in SuperLookup (Ctrl+K)", self)
             superlookup_action.triggered.connect(self._handle_superlookup_search)
             menu.addAction(superlookup_action)
-            menu.addSeparator()
+
+        # MT Quick Lookup action
+        mt_lookup_action = QAction("⚡ QuickTrans (Ctrl+M)", self)
+        mt_lookup_action.triggered.connect(self._handle_mt_quick_lookup)
+        menu.addAction(mt_lookup_action)
+        menu.addSeparator()
 
         # QuickMenu (prompt-based actions)
         try:
@@ -2355,7 +2360,7 @@ class ReadOnlyGridTextEditor(QTextEdit):
         """Handle Ctrl+Alt+N: Add selected text to active non-translatable list(s)"""
         # Get selected text
         selected_text = self.textCursor().selectedText().strip()
-        
+
         if not selected_text:
             from PyQt6.QtWidgets import QMessageBox
             QMessageBox.warning(
@@ -2364,14 +2369,14 @@ class ReadOnlyGridTextEditor(QTextEdit):
                 "Please select text in the Source cell before adding to non-translatables."
             )
             return
-        
+
         # Find main window and call add_to_nt method
         table = self.table_ref if hasattr(self, 'table_ref') else self.parent()
         if table:
             main_window = table.parent()
             while main_window and not hasattr(main_window, 'add_text_to_non_translatables'):
                 main_window = main_window.parent()
-            
+
             if main_window and hasattr(main_window, 'add_text_to_non_translatables'):
                 main_window.add_text_to_non_translatables(selected_text)
             else:
@@ -2382,6 +2387,16 @@ class ReadOnlyGridTextEditor(QTextEdit):
                     "Non-translatables functionality not available."
                 )
 
+    def _handle_mt_quick_lookup(self):
+        """Handle right-click: Open MT Quick Lookup popup for selected text or full source"""
+        # Get selected text (if any)
+        selected_text = self.textCursor().selectedText().strip() if self.textCursor().hasSelection() else None
+
+        # Find main window and call show_mt_quick_popup
+        main_window = self._get_main_window()
+        if main_window and hasattr(main_window, 'show_mt_quick_popup'):
+            main_window.show_mt_quick_popup(text_override=selected_text)
+
     def set_background_color(self, color: str):
         """Set the background color for this text editor (for alternating row colors)"""
         self.setStyleSheet(f"""
@@ -2991,10 +3006,15 @@ class EditableGridTextEditor(QTextEdit):
         
         # Superlookup search action
         if self.textCursor().hasSelection():
-            superlookup_action = QAction("🔍 Search in Superlookup (Ctrl+K)", self)
+            superlookup_action = QAction("🔍 Search in SuperLookup (Ctrl+K)", self)
             superlookup_action.triggered.connect(self._handle_superlookup_search)
             menu.addAction(superlookup_action)
-            menu.addSeparator()
+
+        # MT Quick Lookup action
+        mt_lookup_action = QAction("⚡ QuickTrans (Ctrl+M)", self)
+        mt_lookup_action.triggered.connect(self._handle_mt_quick_lookup)
+        menu.addAction(mt_lookup_action)
+        menu.addSeparator()
 
         # QuickMenu (prompt-based actions)
         try:
@@ -3507,6 +3527,24 @@ class EditableGridTextEditor(QTextEdit):
                     "Non-translatables functionality not available."
                 )
 
+    def _handle_mt_quick_lookup(self):
+        """Handle right-click: Open MT Quick Lookup popup for selected text or full source"""
+        # Get selected text (if any) - prefer from target, then try source
+        selected_text = self.textCursor().selectedText().strip() if self.textCursor().hasSelection() else None
+
+        if not selected_text and self.table and self.row >= 0:
+            # Try getting selected text from source cell
+            source_widget = self.table.cellWidget(self.row, 2)
+            if source_widget and hasattr(source_widget, 'textCursor'):
+                cursor = source_widget.textCursor()
+                if cursor.hasSelection():
+                    selected_text = cursor.selectedText().strip()
+
+        # Find main window and call show_mt_quick_popup
+        main_window = self._get_main_window()
+        if main_window and hasattr(main_window, 'show_mt_quick_popup'):
+            main_window.show_mt_quick_popup(text_override=selected_text)
+
     def _insert_next_tag_or_wrap_selection(self):
         """
         Insert the next memoQ tag, HTML tag, or CafeTran pipe symbol from source, or wrap selection.
@@ -6435,7 +6473,7 @@ class SupervertalerQt(QMainWindow):
         
         # Restore Termview under grid visibility state
         if hasattr(self, 'bottom_tabs'):
-            termview_visible = general_settings.get('termview_under_grid_visible', True)
+            termview_visible = general_settings.get('termview_under_grid_visible', False)
             self.bottom_tabs.setVisible(termview_visible)
             if hasattr(self, 'termview_visible_action'):
                 self.termview_visible_action.setChecked(termview_visible)
@@ -7283,7 +7321,12 @@ class SupervertalerQt(QMainWindow):
         
         # Alt+K - Open QuickMenu directly
         create_shortcut("editor_open_quickmenu", "Alt+K", self.open_quickmenu)
-    
+
+        # Ctrl+Shift+Q - MT Quick Lookup (GT4T-style popup)
+        mt_quick_shortcut = create_shortcut("mt_quick_lookup", "Ctrl+Shift+Q", self.show_mt_quick_popup)
+        # Use ApplicationShortcut context so it works even when focus is in QTextEdit widgets
+        mt_quick_shortcut.setContext(Qt.ShortcutContext.ApplicationShortcut)
+
     def focus_segment_notes(self):
         """Switch to Segment Note tab and focus the notes editor so user can start typing immediately"""
         if not hasattr(self, 'right_tabs'):
@@ -7355,7 +7398,105 @@ class SupervertalerQt(QMainWindow):
             
         except Exception as e:
             self.log(f"❌ Error opening QuickMenu: {e}")
-    
+
+    def show_mt_quick_popup(self, text_override: str = None):
+        """Show GT4T-style MT Quick Lookup popup with translations from all enabled MT engines.
+
+        Triggered by Ctrl+Shift+Q or right-click menu. Shows machine translation
+        suggestions from all configured and enabled MT providers in a popup window.
+
+        Args:
+            text_override: Optional text to translate. If None, uses selected text
+                          in the current cell, or falls back to the full source text.
+
+        Features:
+        - Displays source text at top
+        - Shows numbered list of MT suggestions from each provider
+        - Press 1-9 to quickly insert a translation
+        - Arrow keys to navigate, Enter to insert selected
+        - Escape to dismiss
+        """
+        try:
+            # Get current segment
+            current_row = self.table.currentRow()
+            if current_row < 0:
+                self.log("⚠️ No segment selected")
+                return
+
+            # Determine what text to translate
+            text_to_translate = text_override
+
+            if not text_to_translate:
+                # Check for selected text in the currently focused widget
+                focus_widget = QApplication.focusWidget()
+                if focus_widget and hasattr(focus_widget, 'textCursor'):
+                    cursor = focus_widget.textCursor()
+                    if cursor.hasSelection():
+                        text_to_translate = cursor.selectedText().strip()
+
+            if not text_to_translate:
+                # Fall back to full source text
+                source_widget = self.table.cellWidget(current_row, 2)
+                if not source_widget or not hasattr(source_widget, 'toPlainText'):
+                    self.log("⚠️ Could not get source text")
+                    return
+                text_to_translate = source_widget.toPlainText().strip()
+
+            if not text_to_translate:
+                self.log("⚠️ No text to translate")
+                return
+
+            # Import and create the popup
+            from modules.quicktrans import MTQuickPopup
+
+            # Create popup
+            popup = MTQuickPopup(
+                parent_app=self,
+                source_text=text_to_translate,
+                source_lang=getattr(self, 'source_language', 'en'),
+                target_lang=getattr(self, 'target_language', 'nl'),
+                parent=self
+            )
+
+            # Connect signal to insert translation into target cell
+            def insert_translation(translation: str):
+                # Get the target widget
+                target_widget = self.table.cellWidget(current_row, 3)
+                if not target_widget or not hasattr(target_widget, 'toPlainText'):
+                    return
+
+                # Check if there was a selection in the target - replace just that
+                focus_widget = QApplication.focusWidget()
+                if focus_widget == target_widget and hasattr(focus_widget, 'textCursor'):
+                    cursor = focus_widget.textCursor()
+                    if cursor.hasSelection():
+                        # Replace selection only
+                        cursor.insertText(translation)
+                        self.log(f"✅ Replaced selection with MT translation")
+                    else:
+                        # No selection in target, replace entire target
+                        target_widget.setPlainText(translation)
+                        self.log(f"✅ Inserted MT translation")
+                else:
+                    # Focus was elsewhere, replace entire target
+                    target_widget.setPlainText(translation)
+                    self.log(f"✅ Inserted MT translation")
+
+                # Mark segment as modified
+                if hasattr(self, 'segments') and current_row < len(self.segments):
+                    self.segments[current_row].target = target_widget.toPlainText()
+                    self.mark_segment_modified(current_row)
+
+            popup.translation_selected.connect(insert_translation)
+
+            # Show the popup (it positions itself near cursor)
+            popup.show()
+
+        except ImportError as e:
+            self.log(f"❌ MT Quick Popup module not found: {e}")
+        except Exception as e:
+            self.log(f"❌ Error showing MT Quick Popup: {e}")
+
     def refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
         
@@ -7991,7 +8132,7 @@ class SupervertalerQt(QMainWindow):
         edit_menu.addSeparator()
         
         # Superlookup
-        superlookup_action = QAction("🔍 &Superlookup...", self)
+        superlookup_action = QAction("🔍 &SuperLookup...", self)
         superlookup_action.setShortcut("Ctrl+Alt+L")
         # Tab indices: Grid=0, Project resources=1, Tools=2, Settings=3
         superlookup_action.triggered.connect(lambda: self._go_to_superlookup() if hasattr(self, 'main_tabs') else None)  # Navigate to Superlookup
@@ -8098,7 +8239,7 @@ class SupervertalerQt(QMainWindow):
         # Termview visibility toggle
         self.termview_visible_action = QAction("🔍 &Termview Under Grid", self)
         self.termview_visible_action.setCheckable(True)
-        self.termview_visible_action.setChecked(True)  # Default: visible
+        self.termview_visible_action.setChecked(False)  # Default: hidden (restored from settings if enabled)
         self.termview_visible_action.triggered.connect(self.toggle_termview_under_grid)
         self.termview_visible_action.setToolTip("Show/hide the Termview panel under the grid")
         view_menu.addAction(self.termview_visible_action)
@@ -10138,7 +10279,7 @@ class SupervertalerQt(QMainWindow):
             
             # Create detached window
             self.lookup_detached_window = QDialog(self)
-            self.lookup_detached_window.setWindowTitle("🔍 Superlookup - Supervertaler")
+            self.lookup_detached_window.setWindowTitle("🔍 SuperLookup - Supervertaler")
             self.lookup_detached_window.setMinimumSize(600, 700)
             self.lookup_detached_window.resize(700, 800)
             
@@ -10192,7 +10333,7 @@ class SupervertalerQt(QMainWindow):
             # Header with reattach button
             header_layout = QVBoxLayout()
             
-            header_title = QLabel("🔍 Superlookup")
+            header_title = QLabel("🔍 SuperLookup")
             header_title.setStyleSheet("font-size: 16px; font-weight: bold; color: #333;")
             header_layout.addWidget(header_title)
             
@@ -10346,7 +10487,7 @@ class SupervertalerQt(QMainWindow):
 
         lookup_tab = SuperlookupTab(self, user_data_path=self.user_data_path)
         self.lookup_tab = lookup_tab  # Store reference for later use
-        modules_tabs.addTab(lookup_tab, "🔍 Superlookup")
+        modules_tabs.addTab(lookup_tab, "🔍 SuperLookup")
 
         # Supervoice - Voice Commands & Dictation
         supervoice_tab = self._create_voice_dictation_settings_tab()
@@ -14995,7 +15136,7 @@ class SupervertalerQt(QMainWindow):
         
         # Delete selected term button
         delete_term_btn = QPushButton("🗑️ Delete Selected Term")
-        delete_term_btn.setStyleSheet("background-color: #f44336; color: white; font-weight: bold;")
+        delete_term_btn.setStyleSheet("background-color: #f44336; color: white; font-weight: bold; padding: 3px 5px;")
         def delete_selected_term():
             selected_row = terms_table.currentRow()
             if selected_row < 0:
@@ -15669,8 +15810,13 @@ class SupervertalerQt(QMainWindow):
         # ===== TAB 4: MT Settings =====
         mt_tab = self._create_mt_settings_tab()
         settings_tabs.addTab(scroll_area_wrapper(mt_tab), "🌐 MT Settings")
-        
-        # ===== TAB 5: View Settings =====
+
+        # ===== TAB 5: MT Quick Lookup Settings =====
+        mt_quick_tab = self._create_mt_quick_lookup_settings_tab()
+        settings_tabs.addTab(scroll_area_wrapper(mt_quick_tab), "⚡ QuickTrans")
+        self.mt_quick_lookup_tab_index = settings_tabs.count() - 1  # Store index for opening
+
+        # ===== TAB 6: View Settings =====
         view_tab = self._create_view_settings_tab()
         settings_tabs.addTab(scroll_area_wrapper(view_tab), "🔍 View Settings")
 
@@ -16478,9 +16624,199 @@ class SupervertalerQt(QMainWindow):
         layout.addWidget(save_btn)
         
         layout.addStretch()
-        
+
         return tab
-    
+
+    def _create_mt_quick_lookup_settings_tab(self):
+        """Create MT Quick Lookup settings tab content"""
+        from PyQt6.QtWidgets import QCheckBox, QGroupBox, QPushButton, QComboBox
+
+        tab = QWidget()
+        layout = QVBoxLayout(tab)
+        layout.setContentsMargins(20, 20, 20, 20)
+        layout.setSpacing(15)
+
+        # Load current settings
+        general_settings = self.load_general_settings()
+        mt_quick_settings = general_settings.get('mt_quick_lookup', {})
+        api_keys = self.load_api_keys()
+        enabled_providers = self.load_provider_enabled_states()
+
+        # Header info
+        header_info = QLabel(
+            "⚡ <b>QuickTrans</b> - Configure which providers appear in the QuickTrans popup (Ctrl+M / Ctrl+Alt+M).<br>"
+            "Enable MT engines and/or LLMs to get instant translation suggestions."
+        )
+        header_info.setTextFormat(Qt.TextFormat.RichText)
+        header_info.setStyleSheet("font-size: 9pt; color: #444; padding: 10px; background-color: #E3F2FD; border-radius: 4px;")
+        header_info.setWordWrap(True)
+        layout.addWidget(header_info)
+
+        # ===== MT Providers Group =====
+        mt_group = QGroupBox("🌐 Machine Translation Providers")
+        mt_layout = QVBoxLayout()
+
+        mt_info = QLabel("Select which MT engines to query. Only enabled providers with valid API keys are shown.")
+        mt_info.setWordWrap(True)
+        mt_info.setStyleSheet("font-size: 8pt; color: #666; padding-bottom: 8px;")
+        mt_layout.addWidget(mt_info)
+
+        # MT provider checkboxes
+        self._mtql_checkboxes = {}
+
+        mt_providers = [
+            ("gt", "Google Translate", "mt_google_translate", "google_translate"),
+            ("dl", "DeepL", "mt_deepl", "deepl"),
+            ("ms", "Microsoft Translator", "mt_microsoft", "microsoft_translate"),
+            ("at", "Amazon Translate", "mt_amazon", "amazon_translate"),
+            ("mmt", "ModernMT", "mt_modernmt", "modernmt"),
+            ("mm", "MyMemory (Free)", "mt_mymemory", None),
+        ]
+
+        for code, name, enabled_key, api_key_name in mt_providers:
+            # Check if provider is available (has API key or doesn't need one)
+            has_key = api_key_name is None or bool(api_keys.get(api_key_name))
+            is_enabled_globally = enabled_providers.get(enabled_key, True)
+
+            checkbox = CheckmarkCheckBox(name)
+            # Default: use global MT enabled state
+            checkbox.setChecked(mt_quick_settings.get(f"mtql_{code}", is_enabled_globally and has_key))
+            checkbox.setEnabled(has_key)
+
+            if not has_key:
+                checkbox.setToolTip(f"API key not configured for {name}")
+                checkbox.setStyleSheet("color: #999;")
+            else:
+                checkbox.setToolTip(f"Include {name} in QuickTrans results")
+
+            self._mtql_checkboxes[f"mtql_{code}"] = checkbox
+            mt_layout.addWidget(checkbox)
+
+        mt_group.setLayout(mt_layout)
+        layout.addWidget(mt_group)
+
+        # ===== LLM Providers Group =====
+        llm_group = QGroupBox("🤖 AI/LLM Providers")
+        llm_layout = QVBoxLayout()
+
+        llm_info = QLabel(
+            "Enable AI models for translation suggestions. LLMs may provide more context-aware translations but are slower.<br>"
+            "<b>Note:</b> LLM calls cost more than MT APIs. Use sparingly for quick lookups."
+        )
+        llm_info.setTextFormat(Qt.TextFormat.RichText)
+        llm_info.setWordWrap(True)
+        llm_info.setStyleSheet("font-size: 8pt; color: #666; padding-bottom: 8px;")
+        llm_layout.addWidget(llm_info)
+
+        # LLM provider checkboxes with model selection
+        self._mtql_llm_combos = {}
+
+        llm_providers = [
+            ("claude", "Claude", "claude", [
+                ("claude-sonnet-4-5-20250929", "Claude Sonnet 4.5 (Recommended)"),
+                ("claude-haiku-4-5-20251001", "Claude Haiku 4.5 (Fast)"),
+                ("claude-opus-4-1-20250924", "Claude Opus 4.1 (Premium)"),
+            ]),
+            ("openai", "OpenAI", "openai", [
+                ("gpt-4o", "GPT-4o (Recommended)"),
+                ("gpt-4o-mini", "GPT-4o Mini (Fast)"),
+                ("gpt-4-turbo", "GPT-4 Turbo"),
+                ("o1", "o1 (Reasoning)"),
+            ]),
+            ("gemini", "Gemini", "gemini", [
+                ("gemini-2.5-flash", "Gemini 2.5 Flash (Recommended)"),
+                ("gemini-2.5-pro", "Gemini 2.5 Pro"),
+                ("gemini-2.0-flash", "Gemini 2.0 Flash"),
+            ]),
+        ]
+
+        for code, name, api_key_name, models in llm_providers:
+            has_key = bool(api_keys.get(api_key_name))
+
+            # Container for checkbox and model combo
+            llm_row = QHBoxLayout()
+
+            checkbox = CheckmarkCheckBox(name)
+            # Default: disabled (LLMs are opt-in)
+            checkbox.setChecked(mt_quick_settings.get(f"mtql_{code}", False))
+            checkbox.setEnabled(has_key)
+
+            if not has_key:
+                checkbox.setToolTip(f"API key not configured for {name}. Add it in AI Settings.")
+                checkbox.setStyleSheet("color: #999;")
+            else:
+                checkbox.setToolTip(f"Include {name} translations in QuickTrans")
+
+            self._mtql_checkboxes[f"mtql_{code}"] = checkbox
+            llm_row.addWidget(checkbox)
+
+            # Model selection combo
+            model_combo = QComboBox()
+            model_combo.setMinimumWidth(200)
+            for model_id, model_name in models:
+                model_combo.addItem(model_name, model_id)
+
+            # Restore saved model selection
+            saved_model = mt_quick_settings.get(f"mtql_{code}_model")
+            if saved_model:
+                idx = model_combo.findData(saved_model)
+                if idx >= 0:
+                    model_combo.setCurrentIndex(idx)
+
+            model_combo.setEnabled(has_key)
+            self._mtql_llm_combos[f"mtql_{code}_model"] = model_combo
+            llm_row.addWidget(model_combo)
+
+            llm_row.addStretch()
+            llm_layout.addLayout(llm_row)
+
+        llm_group.setLayout(llm_layout)
+        layout.addWidget(llm_group)
+
+        # Save button
+        save_btn = QPushButton("💾 Save QuickTrans Settings")
+        save_btn.setStyleSheet("font-weight: bold; padding: 8px;")
+        save_btn.clicked.connect(self._save_mt_quick_lookup_settings)
+        layout.addWidget(save_btn)
+
+        layout.addStretch()
+
+        return tab
+
+    def _save_mt_quick_lookup_settings(self):
+        """Save MT Quick Lookup settings"""
+        general_settings = self.load_general_settings()
+
+        mt_quick_settings = {}
+
+        # Save MT provider states
+        for key, checkbox in self._mtql_checkboxes.items():
+            mt_quick_settings[key] = checkbox.isChecked()
+
+        # Save LLM model selections
+        for key, combo in self._mtql_llm_combos.items():
+            mt_quick_settings[key] = combo.currentData()
+
+        general_settings['mt_quick_lookup'] = mt_quick_settings
+        self.save_general_settings(general_settings)
+
+        self.log("✓ QuickTrans settings saved")
+        QMessageBox.information(self, "Settings Saved", "QuickTrans settings have been saved.")
+
+    def open_mt_quick_lookup_settings(self):
+        """Open Settings and navigate to MT Quick Lookup tab"""
+        # Switch to Settings tab
+        if hasattr(self, 'main_tabs'):
+            # Find Settings tab index
+            for i in range(self.main_tabs.count()):
+                if "Settings" in self.main_tabs.tabText(i):
+                    self.main_tabs.setCurrentIndex(i)
+                    break
+
+            # Navigate to MT Quick Lookup sub-tab
+            if hasattr(self, 'settings_tabs') and hasattr(self, 'mt_quick_lookup_tab_index'):
+                self.settings_tabs.setCurrentIndex(self.mt_quick_lookup_tab_index)
+
     def _find_autohotkey_for_settings(self):
         """Find AutoHotkey executable for settings display (doesn't modify state)"""
         # Standard installation paths
@@ -17971,14 +18307,15 @@ class SupervertalerQt(QMainWindow):
 
     def _create_voice_dictation_settings_tab(self):
         """Create Supervoice Settings tab content with Voice Commands"""
-        from PyQt6.QtWidgets import (QGroupBox, QPushButton, QComboBox, QSpinBox, 
+        from PyQt6.QtWidgets import (QGroupBox, QPushButton, QComboBox, QSpinBox,
                                      QTableWidget, QTableWidgetItem, QHeaderView,
-                                     QAbstractItemView, QCheckBox)
+                                     QAbstractItemView, QCheckBox, QSplitter)
+        from modules.keyboard_shortcuts_widget import CheckmarkCheckBox
 
         tab = QWidget()
-        layout = QVBoxLayout(tab)
-        layout.setContentsMargins(20, 20, 20, 20)
-        layout.setSpacing(15)
+        main_layout = QVBoxLayout(tab)
+        main_layout.setContentsMargins(20, 20, 20, 20)
+        main_layout.setSpacing(15)
 
         # Load current dictation settings
         dictation_settings = self.load_dictation_settings()
@@ -17991,19 +18328,33 @@ class SupervertalerQt(QMainWindow):
         header_info.setTextFormat(Qt.TextFormat.RichText)
         header_info.setStyleSheet("font-size: 9pt; color: #444; padding: 10px; background-color: #E3F2FD; border-radius: 4px;")
         header_info.setWordWrap(True)
-        layout.addWidget(header_info)
+        main_layout.addWidget(header_info)
 
-        # ===== Voice Commands Section =====
-        commands_group = QGroupBox("🗣️ Voice Commands (Talon-style)")
-        commands_layout = QVBoxLayout()
+        # ===== Two-column layout: Left = Settings, Right = Voice Commands Table =====
+        columns_layout = QHBoxLayout()
+        columns_layout.setSpacing(15)
 
-        # Enable voice commands checkbox
-        voice_cmd_enabled = QCheckBox("Enable voice commands (spoken phrases trigger actions)")
+        # --- LEFT COLUMN: Settings ---
+        left_column = QVBoxLayout()
+        left_column.setSpacing(15)
+
+        # Enable voice commands checkbox (green checkmark style)
+        voice_cmd_enabled = CheckmarkCheckBox("Enable voice commands (spoken phrases trigger actions)")
         voice_cmd_enabled.setChecked(dictation_settings.get('voice_commands_enabled', True))
         voice_cmd_enabled.setToolTip("When enabled, spoken phrases like 'confirm' or 'next segment' will execute commands instead of being inserted as text")
-        commands_layout.addWidget(voice_cmd_enabled)
+        left_column.addWidget(voice_cmd_enabled)
         self.voice_commands_enabled_checkbox = voice_cmd_enabled
 
+        # Create a layout variable for settings sections to be added below
+        layout = left_column
+
+        # --- RIGHT COLUMN: Voice Commands Table ---
+        right_column = QVBoxLayout()
+        right_column.setSpacing(10)
+
+        commands_group = QGroupBox("🗣️ Voice Commands (Talon-style)")
+        commands_layout = QVBoxLayout()
+
         commands_info = QLabel(
             "Voice commands let you control Supervertaler by voice. Say a phrase to execute an action.\n"
             "If no command matches, the spoken text is inserted as dictation."
@@ -18022,38 +18373,47 @@ class SupervertalerQt(QMainWindow):
         self.voice_commands_table.horizontalHeader().setSectionResizeMode(3, QHeaderView.ResizeMode.ResizeToContents)
         self.voice_commands_table.setSelectionBehavior(QAbstractItemView.SelectionBehavior.SelectRows)
         self.voice_commands_table.setEditTriggers(QAbstractItemView.EditTrigger.NoEditTriggers)
-        self.voice_commands_table.setMinimumHeight(200)
-        self.voice_commands_table.setMaximumHeight(300)
-        
+        self.voice_commands_table.setMinimumHeight(350)
+
         # Populate table with current commands
         self._populate_voice_commands_table()
         commands_layout.addWidget(self.voice_commands_table)
 
         # Command buttons
         cmd_btn_layout = QHBoxLayout()
-        
-        add_cmd_btn = QPushButton("➕ Add Command")
+
+        add_cmd_btn = QPushButton("➕ Add")
         add_cmd_btn.clicked.connect(self._add_voice_command)
         cmd_btn_layout.addWidget(add_cmd_btn)
-        
-        edit_cmd_btn = QPushButton("✏️ Edit Command")
+
+        edit_cmd_btn = QPushButton("✏️ Edit")
         edit_cmd_btn.clicked.connect(self._edit_voice_command)
         cmd_btn_layout.addWidget(edit_cmd_btn)
-        
-        remove_cmd_btn = QPushButton("🗑️ Remove Command")
+
+        remove_cmd_btn = QPushButton("🗑️ Remove")
         remove_cmd_btn.clicked.connect(self._remove_voice_command)
         cmd_btn_layout.addWidget(remove_cmd_btn)
-        
+
         cmd_btn_layout.addStretch()
-        
-        reset_cmd_btn = QPushButton("🔄 Reset to Defaults")
+
+        reset_cmd_btn = QPushButton("🔄 Reset")
         reset_cmd_btn.clicked.connect(self._reset_voice_commands)
         cmd_btn_layout.addWidget(reset_cmd_btn)
-        
+
         commands_layout.addLayout(cmd_btn_layout)
 
         commands_group.setLayout(commands_layout)
-        layout.addWidget(commands_group)
+        right_column.addWidget(commands_group)
+        right_column.addStretch()
+
+        # Add columns to the two-column layout
+        left_widget = QWidget()
+        left_widget.setLayout(left_column)
+        right_widget = QWidget()
+        right_widget.setLayout(right_column)
+
+        columns_layout.addWidget(left_widget, stretch=1)
+        columns_layout.addWidget(right_widget, stretch=1)
 
         # ===== Always-On Mode Section =====
         alwayson_group = QGroupBox("🎧 Always-On Listening Mode")
@@ -18216,7 +18576,13 @@ class SupervertalerQt(QMainWindow):
         ahk_group.setLayout(ahk_layout)
         layout.addWidget(ahk_group)
 
-        # Save button
+        # Add stretch to left column to push content up
+        layout.addStretch()
+
+        # Add two-column layout to main layout
+        main_layout.addLayout(columns_layout, stretch=1)
+
+        # Save button (full width, below the two columns)
         save_btn = QPushButton("💾 Save Supervoice Settings")
         save_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 10px; border: none; outline: none;")
         save_btn.clicked.connect(lambda: self._save_voice_settings(
@@ -18225,15 +18591,13 @@ class SupervertalerQt(QMainWindow):
             lang_combo.currentText(),
             voice_cmd_enabled.isChecked()
         ))
-        layout.addWidget(save_btn)
+        main_layout.addWidget(save_btn)
 
         # Store references
         self.dictation_model_combo = model_combo
         self.dictation_duration_spin = duration_spin
         self.dictation_lang_combo = lang_combo
 
-        layout.addStretch()
-
         return tab
 
     def _populate_voice_commands_table(self):
@@ -18487,7 +18851,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #2E7D32;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -18501,7 +18865,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #C62828;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -18515,7 +18879,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #F57C00;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -18530,7 +18894,7 @@ class SupervertalerQt(QMainWindow):
                         background-color: #757575;
                         color: white;
                         font-weight: bold;
-                        padding: 4px 8px;
+                        padding: 3px 5px;
                         border-radius: 3px;
                     }
                     QPushButton:checked {
@@ -19864,6 +20228,27 @@ class SupervertalerQt(QMainWindow):
                                      grid_font_family_combo=None, termview_font_family_combo=None, termview_font_spin=None, termview_bold_check=None,
                                      border_color_btn=None, border_thickness_spin=None, badge_text_color_btn=None, tabs_above_check=None):
         """Save view settings from UI"""
+        # CRITICAL: Suppress TM saves during view settings update
+        # Grid operations (setStyleSheet, rehighlight, etc.) can trigger textChanged events
+        # which would cause mass TM saves for all confirmed segments
+        previous_suppression = getattr(self, '_suppress_target_change_handlers', False)
+        self._suppress_target_change_handlers = True
+
+        try:
+            self._save_view_settings_from_ui_impl(
+                grid_spin, match_spin, compare_spin, show_tags_check, tag_color_btn,
+                alt_colors_check, even_color_btn, odd_color_btn, invisible_char_color_btn,
+                grid_font_family_combo, termview_font_family_combo, termview_font_spin, termview_bold_check,
+                border_color_btn, border_thickness_spin, badge_text_color_btn, tabs_above_check
+            )
+        finally:
+            self._suppress_target_change_handlers = previous_suppression
+
+    def _save_view_settings_from_ui_impl(self, grid_spin, match_spin, compare_spin, show_tags_check=None, tag_color_btn=None,
+                                     alt_colors_check=None, even_color_btn=None, odd_color_btn=None, invisible_char_color_btn=None,
+                                     grid_font_family_combo=None, termview_font_family_combo=None, termview_font_spin=None, termview_bold_check=None,
+                                     border_color_btn=None, border_thickness_spin=None, badge_text_color_btn=None, tabs_above_check=None):
+        """Implementation of save view settings (called with TM saves suppressed)"""
         general_settings = {
             'restore_last_project': self.load_general_settings().get('restore_last_project', False),
             'auto_propagate_exact_matches': self.auto_propagate_exact_matches,  # Keep existing value
@@ -20034,8 +20419,10 @@ class SupervertalerQt(QMainWindow):
         if invisible_char_color_btn and hasattr(self, 'table') and self.table is not None:
             invisible_char_color = invisible_char_color_btn.property('selected_color')
             if invisible_char_color:
-                # Update all cell highlighters
+                # Update all cell highlighters (with processEvents to keep UI responsive)
                 for row in range(self.table.rowCount()):
+                    if row % 50 == 0:
+                        QApplication.processEvents()
                     for col in [2, 3]:  # Source and target columns
                         widget = self.table.cellWidget(row, col)
                         if widget and hasattr(widget, 'highlighter'):
@@ -20047,8 +20434,10 @@ class SupervertalerQt(QMainWindow):
             border_color = EditableGridTextEditor.focus_border_color
             border_thickness = EditableGridTextEditor.focus_border_thickness
             self.log(f"Applying focus border: color={border_color}, thickness={border_thickness}px")
-            
+
             for row in range(self.table.rowCount()):
+                if row % 50 == 0:
+                    QApplication.processEvents()
                 widget = self.table.cellWidget(row, 3)  # Target column
                 if widget and isinstance(widget, EditableGridTextEditor):
                     # Update the stylesheet with new border settings
@@ -20154,7 +20543,7 @@ class SupervertalerQt(QMainWindow):
         filter_layout.setSpacing(10)
         
         # Source filter
-        source_filter_label = QLabel("Filter Source:")
+        source_filter_label = QLabel("Source:")
         self.source_filter = self._ensure_shared_filter(
             'source_filter',
             "Type to filter source segments...",
@@ -20163,7 +20552,7 @@ class SupervertalerQt(QMainWindow):
         )
         
         # Target filter
-        target_filter_label = QLabel("Filter Target:")
+        target_filter_label = QLabel("Target:")
         self.target_filter = self._ensure_shared_filter(
             'target_filter',
             "Type to filter target segments...",
@@ -20175,11 +20564,12 @@ class SupervertalerQt(QMainWindow):
         clear_filters_btn = QPushButton("Clear Filters")
         clear_filters_btn.clicked.connect(self.clear_filters)
         clear_filters_btn.setMaximumWidth(100)
+        clear_filters_btn.setStyleSheet("padding: 3px 5px;")
 
         # Show Invisibles button with dropdown menu
         show_invisibles_btn = QPushButton("¶ Show Invisibles")
         show_invisibles_btn.setMaximumWidth(140)
-        show_invisibles_btn.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold;")
+        show_invisibles_btn.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold; padding: 3px 5px;")
         show_invisibles_menu = QMenu(show_invisibles_btn)
 
         # Create checkable actions for each invisible character type
@@ -20304,7 +20694,7 @@ class SupervertalerQt(QMainWindow):
         filter_layout.setSpacing(10)
         
         # Source filter
-        source_filter_label = QLabel("Filter Source:")
+        source_filter_label = QLabel("Source:")
         self.source_filter = self._ensure_shared_filter(
             'source_filter',
             "Type to filter source segments... (Press Enter or click Filter)",
@@ -20312,7 +20702,7 @@ class SupervertalerQt(QMainWindow):
         )
         
         # Target filter
-        target_filter_label = QLabel("Filter Target:")
+        target_filter_label = QLabel("Target:")
         self.target_filter = self._ensure_shared_filter(
             'target_filter',
             "Type to filter target segments... (Press Enter or click Filter)",
@@ -20323,17 +20713,18 @@ class SupervertalerQt(QMainWindow):
         apply_filter_btn = QPushButton("Filter")
         apply_filter_btn.clicked.connect(self.apply_filters)
         apply_filter_btn.setMaximumWidth(80)
-        apply_filter_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
+        apply_filter_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px;")
         
         # Clear filters button
         clear_filters_btn = QPushButton("Clear Filters")
         clear_filters_btn.clicked.connect(self.clear_filters)
         clear_filters_btn.setMaximumWidth(100)
+        clear_filters_btn.setStyleSheet("padding: 3px 5px;")
         
         # Quick Filters dropdown menu
         quick_filter_btn = QPushButton("⚡ Quick Filters")
         quick_filter_btn.setMaximumWidth(130)
-        quick_filter_btn.setStyleSheet("background-color: #D84315; color: white; font-weight: bold;")
+        quick_filter_btn.setStyleSheet("background-color: #D84315; color: white; font-weight: bold; padding: 3px 5px;")
         quick_filter_menu = QMenu(self)
         quick_filter_menu.addAction("🔍 Empty segments", lambda: self.apply_quick_filter("empty"))
         quick_filter_menu.addAction("❌ Not translated", lambda: self.apply_quick_filter("not_translated"))
@@ -20347,8 +20738,69 @@ class SupervertalerQt(QMainWindow):
         advanced_filter_btn = QPushButton("⚙️ Advanced Filters")
         advanced_filter_btn.clicked.connect(self.show_advanced_filters_dialog)
         advanced_filter_btn.setMaximumWidth(160)
-        advanced_filter_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold;")
-        
+        advanced_filter_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 3px 5px;")
+
+        # Sort dropdown button (similar to memoQ)
+        sort_btn = QPushButton("⇅ Sort")
+        sort_btn.setMaximumWidth(100)
+        sort_btn.setStyleSheet("background-color: #FF9800; color: white; font-weight: bold; padding: 3px 5px;")
+        sort_menu = QMenu(self)
+
+        # Initialize sort state if not exists
+        if not hasattr(self, 'current_sort'):
+            self.current_sort = None  # None = document order
+
+        # Sort by source text
+        sort_menu.addAction("📝 Source A → Z", lambda: self.apply_sort('source_asc'))
+        sort_menu.addAction("📝 Source Z → A", lambda: self.apply_sort('source_desc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by target text
+        sort_menu.addAction("📄 Target A → Z", lambda: self.apply_sort('target_asc'))
+        sort_menu.addAction("📄 Target Z → A", lambda: self.apply_sort('target_desc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by text length
+        sort_menu.addAction("📏 Source (longer first)", lambda: self.apply_sort('source_length_desc'))
+        sort_menu.addAction("📏 Source (shorter first)", lambda: self.apply_sort('source_length_asc'))
+        sort_menu.addAction("📏 Target (longer first)", lambda: self.apply_sort('target_length_desc'))
+        sort_menu.addAction("📏 Target (shorter first)", lambda: self.apply_sort('target_length_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by match rate
+        sort_menu.addAction("🎯 Match Rate (higher first)", lambda: self.apply_sort('match_desc'))
+        sort_menu.addAction("🎯 Match Rate (lower first)", lambda: self.apply_sort('match_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by frequency
+        sort_menu.addAction("📊 Source Frequency (higher first)", lambda: self.apply_sort('source_freq_desc'))
+        sort_menu.addAction("📊 Source Frequency (lower first)", lambda: self.apply_sort('source_freq_asc'))
+        sort_menu.addAction("📊 Target Frequency (higher first)", lambda: self.apply_sort('target_freq_desc'))
+        sort_menu.addAction("📊 Target Frequency (lower first)", lambda: self.apply_sort('target_freq_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by last changed
+        sort_menu.addAction("🕒 Last Changed (newest first)", lambda: self.apply_sort('modified_desc'))
+        sort_menu.addAction("🕒 Last Changed (oldest first)", lambda: self.apply_sort('modified_asc'))
+
+        sort_menu.addSeparator()
+
+        # Sort by row status
+        sort_menu.addAction("🚦 Row Status", lambda: self.apply_sort('status'))
+
+        sort_menu.addSeparator()
+
+        # Reset to document order
+        sort_menu.addAction("↩️ Document Order (default)", lambda: self.apply_sort(None))
+
+        sort_btn.setMenu(sort_menu)
+        sort_btn.setToolTip("Sort segments by various criteria")
+
         # File filter dropdown (for multi-file projects)
         self.file_filter_combo = QComboBox()
         self.file_filter_combo.setMinimumWidth(150)
@@ -20361,7 +20813,7 @@ class SupervertalerQt(QMainWindow):
         # Show Invisibles button with dropdown menu
         show_invisibles_btn_home = QPushButton("¶ Show Invisibles")
         show_invisibles_btn_home.setMaximumWidth(140)
-        show_invisibles_btn_home.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold;")
+        show_invisibles_btn_home.setStyleSheet("background-color: #607D8B; color: white; font-weight: bold; padding: 3px 5px;")
         show_invisibles_menu_home = QMenu(show_invisibles_btn_home)
 
         # Use the same actions (they're stored as instance variables)
@@ -20442,6 +20894,7 @@ class SupervertalerQt(QMainWindow):
         filter_layout.addWidget(clear_filters_btn)
         filter_layout.addWidget(quick_filter_btn)
         filter_layout.addWidget(advanced_filter_btn)
+        filter_layout.addWidget(sort_btn)  # Sort dropdown
         filter_layout.addWidget(self.file_filter_combo)  # File filter for multi-file projects
         filter_layout.addWidget(show_invisibles_btn_home)
         filter_layout.addWidget(self.spellcheck_btn)
@@ -20565,30 +21018,80 @@ class SupervertalerQt(QMainWindow):
         tab_seg_info.setStyleSheet("font-weight: bold;")
         toolbar_layout.addWidget(tab_seg_info)
         
-        # Tag View toggle button
-        tag_view_btn = QPushButton("🏷️ Tags OFF")
-        tag_view_btn.setCheckable(True)
-        tag_view_btn.setChecked(False)  # Default: WYSIWYG mode (tags hidden)
-        tag_view_btn.setStyleSheet("""
+        # View mode segmented control (WYSIWYG / Tags)
+        from PyQt6.QtWidgets import QButtonGroup
+
+        view_mode_container = QWidget()
+        view_mode_layout = QHBoxLayout(view_mode_container)
+        view_mode_layout.setContentsMargins(0, 0, 0, 0)
+        view_mode_layout.setSpacing(0)
+
+        # Create button group to ensure only one is checked
+        view_mode_group = QButtonGroup(self)
+        view_mode_group.setExclusive(True)
+
+        # WYSIWYG button (left)
+        wysiwyg_btn = QPushButton("WYSIWYG")
+        wysiwyg_btn.setCheckable(True)
+        wysiwyg_btn.setChecked(False)
+        wysiwyg_btn.setToolTip("WYSIWYG View (Ctrl+Alt+T)\nShows formatted text without raw tags")
+        wysiwyg_btn.setStyleSheet("""
             QPushButton {
                 background-color: #757575;
                 color: white;
                 font-weight: bold;
-                padding: 4px 8px;
-                border-radius: 3px;
+                padding: 4px 12px;
+                border: none;
+                border-top-left-radius: 3px;
+                border-bottom-left-radius: 3px;
+            }
+            QPushButton:checked {
+                background-color: #9C27B0;
+            }
+            QPushButton:hover:!checked {
+                background-color: #858585;
+            }
+        """)
+        wysiwyg_btn.clicked.connect(lambda: self.toggle_tag_view(False, None))
+        view_mode_group.addButton(wysiwyg_btn, 0)
+        view_mode_layout.addWidget(wysiwyg_btn)
+
+        # Tags button (right)
+        tags_btn = QPushButton("Tags")
+        tags_btn.setCheckable(True)
+        tags_btn.setChecked(True)  # Default: Tags mode
+        tags_btn.setToolTip("Tag View (Ctrl+Alt+T)\nShows raw tags like <b>bold</b>")
+        tags_btn.setStyleSheet("""
+            QPushButton {
+                background-color: #757575;
+                color: white;
+                font-weight: bold;
+                padding: 4px 12px;
+                border: none;
+                border-top-right-radius: 3px;
+                border-bottom-right-radius: 3px;
             }
             QPushButton:checked {
                 background-color: #9C27B0;
             }
+            QPushButton:hover:!checked {
+                background-color: #858585;
+            }
         """)
-        tag_view_btn.setToolTip("Toggle Tag View (Ctrl+Alt+T)\n\nTags OFF: Shows formatted text (WYSIWYG)\nTags ON: Shows raw tags like <b>bold</b>")
-        tag_view_btn.clicked.connect(lambda checked: self.toggle_tag_view(checked, tag_view_btn))
-        toolbar_layout.addWidget(tag_view_btn)
-        self.tag_view_btn = tag_view_btn  # Store reference
+        tags_btn.clicked.connect(lambda: self.toggle_tag_view(True, None))
+        view_mode_group.addButton(tags_btn, 1)
+        view_mode_layout.addWidget(tags_btn)
+
+        toolbar_layout.addWidget(view_mode_container)
+
+        # Store references for keyboard shortcut and programmatic access
+        self.wysiwyg_btn = wysiwyg_btn
+        self.tags_btn = tags_btn
+        self.view_mode_group = view_mode_group
         
         # Initialize tag view state
         if not hasattr(self, 'show_tags'):
-            self.show_tags = False
+            self.show_tags = True  # Default: show tags
         
         # Status selector
         from modules.statuses import get_status, STATUSES
@@ -20606,12 +21109,12 @@ class SupervertalerQt(QMainWindow):
         
         preview_prompt_btn = QPushButton("🧪 Preview Prompts")
         preview_prompt_btn.setToolTip("Preview the complete assembled prompt\n(System Prompt + Custom Prompts + current segment)")
-        preview_prompt_btn.setStyleSheet("background-color: #9C27B0; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
+        preview_prompt_btn.setStyleSheet("background-color: #9C27B0; color: white; font-weight: bold; padding: 3px 5px; border: none; outline: none;")
         preview_prompt_btn.clicked.connect(self._preview_combined_prompt_from_grid)
         toolbar_layout.addWidget(preview_prompt_btn)
         
         dictate_btn = QPushButton("🎤 Dictation")
-        dictate_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
+        dictate_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px; border: none; outline: none;")
         dictate_btn.clicked.connect(self.start_voice_dictation)
         dictate_btn.setToolTip("Start/stop voice dictation (F9)")
         toolbar_layout.addWidget(dictate_btn)
@@ -20625,7 +21128,7 @@ class SupervertalerQt(QMainWindow):
                 background-color: #757575;
                 color: white;
                 font-weight: bold;
-                padding: 4px 8px;
+                padding: 3px 5px;
                 border-radius: 3px;
             }
             QPushButton:checked {
@@ -20640,7 +21143,7 @@ class SupervertalerQt(QMainWindow):
         toolbar_layout.addStretch()
         
         save_next_btn = QPushButton("✓ Confirm && Next")
-        save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 4px 8px; border: none; outline: none;")
+        save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 3px 5px; border: none; outline: none;")
         save_next_btn.clicked.connect(self.confirm_selected_or_next)
         save_next_btn.setToolTip("Confirm current segment and go to next unconfirmed (Ctrl+Enter)")
         toolbar_layout.addWidget(save_next_btn)
@@ -21249,9 +21752,21 @@ class SupervertalerQt(QMainWindow):
         # Configure columns
         self.table.setColumnCount(5)
         self.table.setHorizontalHeaderLabels(["#", "Type", "Source", "Target", "Status"])
-        
-        # Column widths - Source and Target columns stretch to fill space, others are interactive
+
+        # Explicitly set header font to normal weight (not bold)
         header = self.table.horizontalHeader()
+        header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Normal)
+        header.setFont(header_font)
+
+        # Also set font on individual header items through the model (extra insurance)
+        model = self.table.model()
+        if model:
+            for col in range(5):
+                item = model.headerData(col, Qt.Orientation.Horizontal, Qt.ItemDataRole.DisplayRole)
+                model.setHeaderData(col, Qt.Orientation.Horizontal, item, Qt.ItemDataRole.DisplayRole)
+                model.setHeaderData(col, Qt.Orientation.Horizontal, header_font, Qt.ItemDataRole.FontRole)
+
+        # Column widths - Source and Target columns stretch to fill space, others are interactive
         header.setSectionResizeMode(0, QHeaderView.ResizeMode.Interactive)  # ID
         header.setSectionResizeMode(1, QHeaderView.ResizeMode.Interactive)  # Type
         header.setSectionResizeMode(2, QHeaderView.ResizeMode.Stretch)  # Source - stretch to fill space
@@ -21265,7 +21780,7 @@ class SupervertalerQt(QMainWindow):
         self.table.setColumnWidth(1, 40)   # Type - narrower
         self.table.setColumnWidth(2, 400)  # Source
         self.table.setColumnWidth(3, 400)  # Target
-        self.table.setColumnWidth(4, 60)   # Status - compact
+        self.table.setColumnWidth(4, 50)   # Status - compact width
         
         # Enable word wrap in cells (both display and edit mode)
         self.table.setWordWrap(True)
@@ -21295,6 +21810,51 @@ class SupervertalerQt(QMainWindow):
             QTableWidget::item:last-child {
                 border-right: none;
             }
+
+            /* Narrower scrollbar with visible arrow buttons */
+            QScrollBar:vertical {
+                border: none;
+                background: #F0F0F0;
+                width: 12px;
+                margin: 12px 0 12px 0;
+            }
+            QScrollBar::handle:vertical {
+                background: #C0C0C0;
+                min-height: 20px;
+                border-radius: 2px;
+            }
+            QScrollBar::handle:vertical:hover {
+                background: #A0A0A0;
+            }
+            QScrollBar::add-line:vertical {
+                height: 12px;
+                background: #E0E0E0;
+                subcontrol-position: bottom;
+                subcontrol-origin: margin;
+            }
+            QScrollBar::add-line:vertical:hover {
+                background: #2196F3;
+            }
+            QScrollBar::sub-line:vertical {
+                height: 12px;
+                background: #E0E0E0;
+                subcontrol-position: top;
+                subcontrol-origin: margin;
+            }
+            QScrollBar::sub-line:vertical:hover {
+                background: #2196F3;
+            }
+            /* Arrow images */
+            QScrollBar::up-arrow:vertical {
+                image: url(assets/scrollbar_up.png);
+                width: 8px;
+                height: 8px;
+            }
+            QScrollBar::down-arrow:vertical {
+                image: url(assets/scrollbar_down.png);
+                width: 8px;
+                height: 8px;
+            }
         """)
         
         # Simplified editing: Double-click only (no F2 key) - companion tool philosophy
@@ -21317,8 +21877,8 @@ class SupervertalerQt(QMainWindow):
         # Debug: Confirm signal connections
         self.log("🔌 Table signals connected: currentCellChanged, itemClicked, cellDoubleClicked, itemSelectionChanged")
         
-        # Add precision scroll buttons (memoQ-style)
-        self.add_precision_scroll_buttons()
+        # Precision scroll buttons removed (user preference)
+        # self.add_precision_scroll_buttons()
     
     def add_precision_scroll_buttons(self):
         """Add precision scroll buttons at top/bottom of scrollbar (memoQ-style)"""
@@ -21544,10 +22104,10 @@ class SupervertalerQt(QMainWindow):
         editor_widget.dictate_btn = dictate_btn
 
         save_btn = QPushButton("💾 Save")
-        save_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
+        save_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px;")
         save_btn.clicked.connect(self.save_tab_segment)
         save_next_btn = QPushButton("✓ Confirm && Next (Ctrl+Enter)")
-        save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold;")
+        save_next_btn.setStyleSheet("background-color: #2196F3; color: white; font-weight: bold; padding: 3px 5px;")
         save_next_btn.clicked.connect(self.confirm_selected_or_next)
 
         button_layout.addWidget(copy_btn)
@@ -21891,6 +22451,10 @@ class SupervertalerQt(QMainWindow):
         # Update UI
         self.project_file_path = None
         self.project_modified = True  # Mark as modified since it hasn't been saved
+
+        # Store original segment order for "Document Order" sort reset
+        self._original_segment_order = self.current_project.segments.copy()
+
         self.update_window_title()
         self.load_segments_to_grid()
         self.initialize_tm_database()  # Initialize TM for this project
@@ -21919,16 +22483,16 @@ class SupervertalerQt(QMainWindow):
                 if hasattr(self.lookup_tab, '_ahk') and self.lookup_tab._ahk:
                     try:
                         self.lookup_tab._ahk.stop_hotkeys()
-                        print("[Superlookup] ahk library hotkeys stopped")
+                        print("[SuperLookup] ahk library hotkeys stopped")
                     except Exception as e:
-                        print(f"[Superlookup] Error stopping ahk library: {e}")
+                        print(f"[SuperLookup] Error stopping ahk library: {e}")
             
             # Terminate external AutoHotkey process if running (fallback method)
             if hasattr(self, 'lookup_tab') and hasattr(self.lookup_tab, 'ahk_process') and self.lookup_tab.ahk_process:
                 try:
                     self.lookup_tab.ahk_process.terminate()
                     self.lookup_tab.ahk_process.wait(timeout=2)
-                    print("[Superlookup] AHK process terminated")
+                    print("[SuperLookup] AHK process terminated")
                 except:
                     # Force kill if terminate doesn't work
                     try:
@@ -21936,7 +22500,7 @@ class SupervertalerQt(QMainWindow):
                     except:
                         pass
         except Exception as e:
-            print(f"[Superlookup] Error terminating AHK: {e}")
+            print(f"[SuperLookup] Error terminating AHK: {e}")
         
         # Accept the close event
         event.accept()
@@ -21972,6 +22536,12 @@ class SupervertalerQt(QMainWindow):
             self.project_file_path = file_path
             self.project_modified = False
 
+            # Store original segment order for "Document Order" sort reset
+            self._original_segment_order = self.current_project.segments.copy()
+
+            # Always reset sort state when loading - project should open in document order
+            self.current_sort = None
+
             # Sync global language settings with project languages
             if self.current_project.source_lang:
                 self.source_language = self.current_project.source_lang
@@ -23323,9 +23893,21 @@ class SupervertalerQt(QMainWindow):
             original_path = getattr(self, 'original_docx', None) or getattr(self, 'current_document_path', None)
             if original_path and os.path.exists(original_path):
                 self.current_project.original_docx_path = original_path
-            
+
+            # IMPORTANT: Always save segments in original document order, not sorted order
+            # Store current sort state and temporarily restore original order
+            current_sort_state = getattr(self, 'current_sort', None)
+            current_segments = self.current_project.segments.copy()  # Save current (possibly sorted) order
+
+            # Restore original order for saving
+            if hasattr(self, '_original_segment_order') and self._original_segment_order:
+                self.current_project.segments = self._original_segment_order.copy()
+
             with open(file_path, 'w', encoding='utf-8') as f:
                 json.dump(self.current_project.to_dict(), f, indent=2, ensure_ascii=False)
+
+            # Restore the current (sorted) order after saving
+            self.current_project.segments = current_segments
             
             self.project_modified = False
             self.update_window_title()
@@ -29040,7 +29622,11 @@ class SupervertalerQt(QMainWindow):
     def load_segments_to_grid(self):
         """Load segments into the grid with termbase highlighting"""
         self.log(f"🔄🔄🔄 load_segments_to_grid CALLED - this will RELOAD grid from segment data!")
-        
+
+        # Ensure original segment order is stored (for Document Order sort)
+        if self.current_project and not hasattr(self, '_original_segment_order'):
+            self._original_segment_order = self.current_project.segments.copy()
+
         # Clear row color settings cache to ensure fresh settings are loaded
         if hasattr(self, '_row_color_settings_cached'):
             delattr(self, '_row_color_settings_cached')
@@ -29117,7 +29703,7 @@ class SupervertalerQt(QMainWindow):
                 id_item.setForeground(QColor(segment_num_color))
                 id_item.setBackground(QColor())  # Default background from theme
                 # Smaller font for segment numbers
-                seg_num_font = QFont(self.default_font_family, max(8, self.default_font_size - 2))
+                seg_num_font = QFont(self.default_font_family, max(9, self.default_font_size - 1))
                 id_item.setFont(seg_num_font)
                 self.table.setItem(row, 0, id_item)
                 
@@ -29209,7 +29795,7 @@ class SupervertalerQt(QMainWindow):
                     type_item.setForeground(QColor("#388E3C"))  # Green for list items (works in both themes)
 
                 # Smaller font for type symbols
-                type_font = QFont(self.default_font_family, max(8, self.default_font_size - 2))
+                type_font = QFont(self.default_font_family, max(9, self.default_font_size - 1))
                 type_item.setFont(type_font)
 
                 self.table.setItem(row, 1, type_item)
@@ -29659,7 +30245,10 @@ class SupervertalerQt(QMainWindow):
             if shortcut_badge_tooltip:
                 badge_label.setToolTip(f"Press {shortcut_badge_tooltip} to insert")
             header_layout.addWidget(badge_label)
-        
+
+        # Add stretch to push navigation controls to the right (aligned with scrollbar)
+        header_layout.addStretch()
+
         nav_label = None
         nav_buttons = None
 
@@ -29725,8 +30314,7 @@ class SupervertalerQt(QMainWindow):
             self.theme_aware_arrows.extend([prev_btn, next_btn])
 
             nav_buttons = [prev_btn, next_btn]
-        
-        header_layout.addStretch()
+
         main_layout.addLayout(header_layout)
         
         # Text area
@@ -30649,19 +31237,24 @@ class SupervertalerQt(QMainWindow):
             widget.setToolTip(f"Notes: {segment.notes.strip()}")
             
         status_def = get_status(segment.status)
-        status_label = QLabel(status_def.icon)
+
+        # Status icons: ✔ (green) and ❌ (naturally red emoji)
+        icon_text = status_def.icon
+        if segment.status == "confirmed":
+            icon_html = f'<font color="#2e7d32" size="2">{icon_text}</font>'  # Green checkmark
+        else:
+            icon_html = f'<font size="2">{icon_text}</font>'  # Other icons (including ❌ emoji)
+
+        status_label = QLabel(icon_html)
+        status_label.setTextFormat(Qt.TextFormat.RichText)  # Enable HTML rendering
         status_label.setAlignment(Qt.AlignmentFlag.AlignVCenter | Qt.AlignmentFlag.AlignLeft)
+        status_label.setSizePolicy(QSizePolicy.Policy.Preferred, QSizePolicy.Policy.Expanding)  # Expand vertically to match row height
         status_label.setToolTip(status_def.label)
-        # Smaller red X for "not_started" to match green checkmark visual size
-        font_size = "8px" if segment.status == "not_started" else "13px"
-        # Make confirmed checkmark green
-        color = "color: #2e7d32;" if segment.status == "confirmed" else ""
-        
-        # Apply orange background highlight to status icon if segment has notes
+
+        # Add orange background if segment has notes (using stylesheet for background only)
         if has_notes:
-            status_label.setStyleSheet(f"font-size: {font_size}; {color} padding: 2px 4px; background-color: rgba(255, 152, 0, 0.35); border-radius: 3px;")
-        else:
-            status_label.setStyleSheet(f"font-size: {font_size}; {color} padding-right: 4px;")
+            status_label.setStyleSheet("padding: 2px 4px; background-color: rgba(255, 152, 0, 0.35); border-radius: 3px;")
+        # Note: No stylesheet for non-notes case to avoid interfering with HTML color
         layout.addWidget(status_label)
 
         # Only add match label if there's a match percentage
@@ -30773,14 +31366,17 @@ class SupervertalerQt(QMainWindow):
         """Auto-resize all rows to fit content - Compact version"""
         if not hasattr(self, 'table') or not self.table:
             return
-        
+
         # Reduce width slightly to account for padding and prevent text cut-off
         width_reduction = 8
-        
+
         # Manually calculate and set row heights for compact display
         for row in range(self.table.rowCount()):
+            # Keep UI responsive during large grid updates
+            if row % 50 == 0:
+                QApplication.processEvents()
             self._auto_resize_single_row(row, width_reduction)
-        
+
         self.log("✓ Auto-resized rows to fit content (compact)")
         self._enforce_status_row_heights()
     
@@ -30827,26 +31423,30 @@ class SupervertalerQt(QMainWindow):
     def apply_font_to_grid(self):
         """Apply selected font to all grid cells"""
         font = QFont(self.default_font_family, self.default_font_size)
-        
+
         self.table.setFont(font)
-        
-        # Also update header font - same size as grid content, just bold
-        header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Bold)
+
+        # Also update header font - same size as grid content, normal weight
+        header_font = QFont(self.default_font_family, self.default_font_size, QFont.Weight.Normal)
         self.table.horizontalHeader().setFont(header_font)
-        
+
         # Update fonts in QTextEdit widgets (source and target columns)
         if hasattr(self, 'table') and self.table:
             for row in range(self.table.rowCount()):
+                # Keep UI responsive during large grid updates
+                if row % 50 == 0:
+                    QApplication.processEvents()
+
                 # Source column (2) - ReadOnlyGridTextEditor
                 source_widget = self.table.cellWidget(row, 2)
                 if source_widget and isinstance(source_widget, ReadOnlyGridTextEditor):
                     source_widget.setFont(font)
-                
+
                 # Target column (3) - EditableGridTextEditor
                 target_widget = self.table.cellWidget(row, 3)
                 if target_widget and isinstance(target_widget, EditableGridTextEditor):
                     target_widget.setFont(font)
-        
+
         # Adjust segment number column width based on font size
         self._update_segment_column_width()
     
@@ -30870,12 +31470,12 @@ class SupervertalerQt(QMainWindow):
         # Measure the width of the largest number (as string)
         text_width = fm.horizontalAdvance(str(max_segment))
         
-        # Add padding (10px on each side = 20px total)
-        new_width = text_width + 20
-        
-        # Ensure minimum width for very small numbers
-        new_width = max(30, new_width)
-        
+        # Add padding (6px on each side = 12px total)
+        new_width = text_width + 12
+
+        # Ensure minimum width for very small numbers, cap at width for ~1000
+        new_width = max(30, min(new_width, 55))
+
         self.table.setColumnWidth(0, new_width)
     
     def set_font_family(self, family_name: str):
@@ -30907,14 +31507,18 @@ class SupervertalerQt(QMainWindow):
         """Refresh tag highlight colors in all grid cells"""
         if not hasattr(self, 'table') or not self.table:
             return
-        
+
         for row in range(self.table.rowCount()):
+            # Keep UI responsive during large grid updates
+            if row % 50 == 0:
+                QApplication.processEvents()
+
             # Source column (2) - ReadOnlyGridTextEditor
             source_widget = self.table.cellWidget(row, 2)
             if source_widget and isinstance(source_widget, ReadOnlyGridTextEditor):
                 if hasattr(source_widget, 'highlighter'):
                     source_widget.highlighter.set_tag_color(EditableGridTextEditor.tag_highlight_color)
-            
+
             # Target column (3) - EditableGridTextEditor
             target_widget = self.table.cellWidget(row, 3)
             if target_widget and isinstance(target_widget, EditableGridTextEditor):
@@ -30979,18 +31583,22 @@ class SupervertalerQt(QMainWindow):
         """Apply alternating row colors to all source and target cells in the grid"""
         if not hasattr(self, 'table') or not self.table:
             return
-        
+
         # Clear cached settings to force reload
         if hasattr(self, '_row_color_settings_cached'):
             delattr(self, '_row_color_settings_cached')
-        
+
         for row in range(self.table.rowCount()):
+            # Keep UI responsive during large grid updates
+            if row % 50 == 0:
+                QApplication.processEvents()
+
             source_widget = self.table.cellWidget(row, 2)
             target_widget = self.table.cellWidget(row, 3)
-            
+
             if source_widget and target_widget:
                 self._apply_row_color(row, source_widget, target_widget)
-        
+
         self.log("✓ Alternating row colors applied")
     
     def on_font_changed(self):
@@ -36864,9 +37472,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """Update spellcheck button style based on enabled state"""
         if hasattr(self, 'spellcheck_btn'):
             if self.spellcheck_enabled:
-                self.spellcheck_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
+                self.spellcheck_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 3px 5px;")
             else:
-                self.spellcheck_btn.setStyleSheet("background-color: #9E9E9E; color: white; font-weight: bold;")
+                self.spellcheck_btn.setStyleSheet("background-color: #9E9E9E; color: white; font-weight: bold; padding: 3px 5px;")
 
     def _toggle_spellcheck(self, checked=None):
         """Toggle spellcheck on/off"""
@@ -37566,7 +38174,154 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             self.table.setUpdatesEnabled(True)
         
         self.log(f"🔍 Advanced filters: showing {visible_count} of {len(self.current_project.segments)} segments")
-    
+
+    def apply_sort(self, sort_type: str = None):
+        """Sort segments by various criteria (similar to memoQ)"""
+        if not self.current_project or not hasattr(self, 'table') or self.table is None:
+            return
+
+        if not self.current_project.segments:
+            return
+
+        # Show progress dialog during sorting
+        from PyQt6.QtWidgets import QProgressDialog
+        from PyQt6.QtCore import Qt
+
+        progress = QProgressDialog("Sorting segments, please wait...", None, 0, 0, self)
+        progress.setWindowTitle("Sorting")
+        progress.setWindowModality(Qt.WindowModality.WindowModal)
+        progress.setMinimumDuration(0)  # Show immediately
+        progress.show()
+        QApplication.processEvents()  # Force UI update
+
+        try:
+            # Store original document order if not already stored
+            if not hasattr(self, '_original_segment_order'):
+                self._original_segment_order = self.current_project.segments.copy()
+
+            # Update current sort state
+            self.current_sort = sort_type
+
+            # If sort_type is None, restore document order
+            if sort_type is None:
+                # Restore document order by sorting by segment ID (original position)
+                # This works even if the stored original order is wrong
+                self.current_project.segments.sort(key=lambda seg: int(seg.id))
+
+                # Update stored original order to this correct order
+                self._original_segment_order = self.current_project.segments.copy()
+
+                # Set pagination to "All" to show all segments
+                if hasattr(self, 'page_size_combo') and self._widget_is_alive(self.page_size_combo):
+                    self.page_size_combo.blockSignals(True)
+                    self.page_size_combo.setCurrentText("All")
+                    self.page_size_combo.blockSignals(False)
+                    # Update the internal page size variable
+                    if hasattr(self, 'grid_page_size'):
+                        self.grid_page_size = 999999
+
+                self.load_segments_to_grid()
+                self.log("↩️ Restored document order (showing all segments)")
+                return
+
+            # Helper function to get text without tags for more accurate sorting
+            def strip_tags(text: str) -> str:
+                """Remove HTML/XML tags from text for sorting"""
+                import re
+                return re.sub(r'<[^>]+>', '', text).strip()
+
+            # Calculate frequency maps if needed
+            frequency_cache = {}
+            if 'freq' in sort_type:
+                from collections import Counter
+                if 'source' in sort_type:
+                    counter = Counter(strip_tags(seg.source).lower() for seg in self.current_project.segments)
+                    frequency_cache = {strip_tags(seg.source).lower(): counter[strip_tags(seg.source).lower()]
+                                     for seg in self.current_project.segments}
+                else:  # target frequency
+                    counter = Counter(strip_tags(seg.target).lower() for seg in self.current_project.segments if seg.target)
+                    frequency_cache = {strip_tags(seg.target).lower(): counter[strip_tags(seg.target).lower()]
+                                     for seg in self.current_project.segments if seg.target}
+
+            # Sort based on selected criterion
+            if sort_type == 'source_asc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.source).lower())
+                sort_name = "Source A → Z"
+            elif sort_type == 'source_desc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.source).lower(), reverse=True)
+                sort_name = "Source Z → A"
+            elif sort_type == 'target_asc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.target).lower() if s.target else "")
+                sort_name = "Target A → Z"
+            elif sort_type == 'target_desc':
+                self.current_project.segments.sort(key=lambda s: strip_tags(s.target).lower() if s.target else "", reverse=True)
+                sort_name = "Target Z → A"
+            elif sort_type == 'source_length_asc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.source)))
+                sort_name = "Source (shorter first)"
+            elif sort_type == 'source_length_desc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.source)), reverse=True)
+                sort_name = "Source (longer first)"
+            elif sort_type == 'target_length_asc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.target)) if s.target else 0)
+                sort_name = "Target (shorter first)"
+            elif sort_type == 'target_length_desc':
+                self.current_project.segments.sort(key=lambda s: len(strip_tags(s.target)) if s.target else 0, reverse=True)
+                sort_name = "Target (longer first)"
+            elif sort_type == 'match_asc':
+                self.current_project.segments.sort(key=lambda s: getattr(s, 'match_percent', 0) or 0)
+                sort_name = "Match Rate (lower first)"
+            elif sort_type == 'match_desc':
+                self.current_project.segments.sort(key=lambda s: getattr(s, 'match_percent', 0) or 0, reverse=True)
+                sort_name = "Match Rate (higher first)"
+            elif sort_type == 'source_freq_asc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.source).lower(), 0))
+                sort_name = "Source Frequency (lower first)"
+            elif sort_type == 'source_freq_desc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.source).lower(), 0), reverse=True)
+                sort_name = "Source Frequency (higher first)"
+            elif sort_type == 'target_freq_asc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.target).lower(), 0) if s.target else 0)
+                sort_name = "Target Frequency (lower first)"
+            elif sort_type == 'target_freq_desc':
+                self.current_project.segments.sort(key=lambda s: frequency_cache.get(strip_tags(s.target).lower(), 0) if s.target else 0, reverse=True)
+                sort_name = "Target Frequency (higher first)"
+            elif sort_type == 'modified_asc':
+                self.current_project.segments.sort(key=lambda s: s.modified_at if s.modified_at else "")
+                sort_name = "Last Changed (oldest first)"
+            elif sort_type == 'modified_desc':
+                self.current_project.segments.sort(key=lambda s: s.modified_at if s.modified_at else "", reverse=True)
+                sort_name = "Last Changed (newest first)"
+            elif sort_type == 'status':
+                # Sort by status in a logical order: not_started, draft, translated, confirmed
+                status_order = {'not_started': 0, 'draft': 1, 'translated': 2, 'confirmed': 3}
+                self.current_project.segments.sort(key=lambda s: status_order.get(s.status, 99))
+                sort_name = "Row Status"
+            else:
+                self.log(f"⚠️ Unknown sort type: {sort_type}")
+                return
+
+            # Set pagination to "All" to show all sorted segments
+            if hasattr(self, 'page_size_combo') and self._widget_is_alive(self.page_size_combo):
+                self.page_size_combo.blockSignals(True)
+                self.page_size_combo.setCurrentText("All")
+                self.page_size_combo.blockSignals(False)
+                # Update the internal page size variable
+                if hasattr(self, 'grid_page_size'):
+                    self.grid_page_size = 999999
+
+            # Reload grid to reflect new order
+            self.load_segments_to_grid()
+            self.log(f"⇅ Sorted by: {sort_name} (showing all segments)")
+
+        except Exception as e:
+            self.log(f"❌ Error sorting segments: {e}")
+            import traceback
+            traceback.print_exc()
+        finally:
+            # Close progress dialog
+            progress.close()
+
     # ========================================================================
     # TABBED SEGMENT EDITOR METHODS (for Grid view)
     # ========================================================================
@@ -39560,32 +40315,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
 
     def _toggle_tag_view_via_shortcut(self):
         """Toggle tag view using keyboard shortcut (Ctrl+Alt+T)"""
-        if hasattr(self, 'tag_view_btn'):
-            # Toggle the button state (which triggers toggle_tag_view)
-            new_state = not self.tag_view_btn.isChecked()
-            self.tag_view_btn.setChecked(new_state)
-            self.toggle_tag_view(new_state, self.tag_view_btn)
+        if hasattr(self, 'wysiwyg_btn') and hasattr(self, 'tags_btn'):
+            # Toggle between the two modes
+            new_state = not self.show_tags
+            self.toggle_tag_view(new_state, None)
 
     def _enable_tag_view_after_import(self):
         """Auto-enable Tag View after importing a document with formatting tags"""
-        if hasattr(self, 'tag_view_btn'):
-            self.tag_view_btn.setChecked(True)
-            self.toggle_tag_view(True, self.tag_view_btn)
+        if hasattr(self, 'tags_btn'):
+            self.toggle_tag_view(True, None)
             self.log("🏷️ Tag View auto-enabled (formatting tags detected in import)")
 
     def toggle_tag_view(self, checked: bool, button: QPushButton = None):
         """Toggle between Tag View (showing raw tags) and WYSIWYG View (formatted display)"""
         self.show_tags = checked
-        
-        # Update button text
-        if button:
+
+        # Update segmented control buttons if they exist
+        if hasattr(self, 'wysiwyg_btn') and hasattr(self, 'tags_btn'):
             if checked:
-                button.setText("🏷️ Tags ON")
+                self.tags_btn.setChecked(True)
             else:
-                button.setText("🏷️ Tags OFF")
-        
+                self.wysiwyg_btn.setChecked(True)
+
         self.log(f"{'🏷️ Tag View ENABLED - showing raw tags' if checked else '✨ WYSIWYG View ENABLED - showing formatted text'}")
-        
+
         # Refresh the grid to update display
         if hasattr(self, 'table') and self.current_project:
             self._refresh_grid_display_mode()
@@ -40958,45 +41711,12 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             event.accept()
     
     def _cleanup_web_views(self):
-        """Clean up WebEngine views to prevent 'Release of profile requested' warning"""
-        try:
-            # Close any SuperBrowser tabs
-            if hasattr(self, 'superbrowser_tabs'):
-                for tab in self.superbrowser_tabs.values():
-                    try:
-                        if hasattr(tab, 'web_view'):
-                            # Stop any loading/rendering
-                            tab.web_view.stop()
-                            # Clear page to release resources
-                            tab.web_view.setPage(None)
-                            tab.web_view.setUrl(QUrl('about:blank'))
-                            tab.web_view.deleteLater()
-                    except:
-                        pass
-            
-            # Close Superlookup web views (from Web Resources tab)
-            if hasattr(self, 'web_views'):
-                for resource_id, web_view in list(self.web_views.items()):
-                    try:
-                        web_view.stop()
-                        web_view.setPage(None)
-                        web_view.setUrl(QUrl('about:blank'))
-                        web_view.deleteLater()
-                    except:
-                        pass
-                self.web_views.clear()
-            
-            # Process events multiple times to ensure cleanup completes
-            from PyQt6.QtWidgets import QApplication
-            from PyQt6.QtCore import QUrl
-            for _ in range(3):
-                QApplication.processEvents()
-                
-            # Small delay to allow Qt to finish cleanup
-            import time
-            time.sleep(0.1)
-        except:
-            pass
+        """Clean up WebEngine views - DISABLED to prevent crash"""
+        # WebEngine cleanup has been disabled because it was causing Python crashes
+        # on program exit. Qt will handle WebEngine cleanup automatically, though
+        # you may see a "Release of profile requested" warning which is harmless.
+        print("[WebEngine Cleanup] Skipping manual cleanup - letting Qt handle it")
+        pass
     
     def _close_detached_log_windows(self):
         """Close all detached log windows when main window closes"""
@@ -43541,23 +44261,58 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         """Call DeepL API"""
         try:
             import deepl
-            
+
             if not api_key:
                 api_keys = self.load_api_keys()
                 api_key = api_keys.get("deepl")
-            
+
             if not api_key:
                 return "[DeepL requires API key]"
-            
+
             translator = deepl.Translator(api_key)
-            
-            # Convert language codes (DeepL uses uppercase)
+
+            # Convert source language code (DeepL uses uppercase, no variant needed for source)
             src_code = source_lang.split('-')[0].split('_')[0].upper()
-            tgt_code = target_lang.split('-')[0].split('_')[0].upper()
-            
+
+            # Convert target language code - DeepL requires variants for some languages
+            # Handle full codes like "en-US", "en-GB", "pt-BR", "pt-PT"
+            tgt_upper = target_lang.upper().replace('_', '-')
+
+            # DeepL target language mapping - some require specific variants
+            deepl_target_map = {
+                # English variants (EN alone is deprecated)
+                'EN': 'EN-US',      # Default to US English
+                'EN-US': 'EN-US',
+                'EN-GB': 'EN-GB',
+                'EN-AU': 'EN-GB',   # Map Australian to British
+                'EN-CA': 'EN-US',   # Map Canadian to US
+                # Portuguese variants
+                'PT': 'PT-PT',      # Default to European Portuguese
+                'PT-PT': 'PT-PT',
+                'PT-BR': 'PT-BR',
+                # Chinese variants
+                'ZH': 'ZH-HANS',    # Default to Simplified
+                'ZH-CN': 'ZH-HANS',
+                'ZH-TW': 'ZH-HANT',
+                'ZH-HANS': 'ZH-HANS',
+                'ZH-HANT': 'ZH-HANT',
+            }
+
+            # Check if full code matches first, then base code
+            if tgt_upper in deepl_target_map:
+                tgt_code = deepl_target_map[tgt_upper]
+            else:
+                # Extract base code and check
+                base_code = tgt_upper.split('-')[0]
+                if base_code in deepl_target_map:
+                    tgt_code = deepl_target_map[base_code]
+                else:
+                    # Use base code as-is for other languages
+                    tgt_code = base_code
+
             result = translator.translate_text(text, source_lang=src_code, target_lang=tgt_code)
             return result.text
-            
+
         except ImportError:
             return "[DeepL requires: pip install deepl]"
         except Exception as e:
@@ -44003,8 +44758,11 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             # Determine segment number color based on theme
             is_dark_theme = theme.name == "Dark"
             segment_num_color = theme.text if is_dark_theme else "black"
-            
+
             for row in range(self.table.rowCount()):
+                # Keep UI responsive during large grid updates
+                if row % 50 == 0:
+                    QApplication.processEvents()
                 id_item = self.table.item(row, 0)
                 if id_item:
                     # Don't change currently highlighted row (orange background)
@@ -45093,7 +45851,7 @@ class SuperlookupTab(QWidget):
         self.main_window = parent  # Store reference to main window for database access
         self.user_data_path = user_data_path  # Store user data path for web cache
         
-        print("[Superlookup] SuperlookupTab.__init__ called")
+        print("[SuperLookup] SuperlookupTab.__init__ called")
         
         # Get theme manager from main window (try parent first, then parent's parent for dialogs)
         self.theme_manager = getattr(parent, 'theme_manager', None)
@@ -45102,16 +45860,16 @@ class SuperlookupTab(QWidget):
             parent_parent = getattr(parent, 'parent', lambda: None)()
             if parent_parent:
                 self.theme_manager = getattr(parent_parent, 'theme_manager', None)
-        print(f"[Superlookup] theme_manager: {self.theme_manager is not None}")
+        print(f"[SuperLookup] theme_manager: {self.theme_manager is not None}")
         
         # Import lookup engine
         try:
             from modules.superlookup import SuperlookupEngine, LookupResult
             self.SuperlookupEngine = SuperlookupEngine
             self.LookupResult = LookupResult
-            print("[Superlookup] Successfully imported SuperlookupEngine")
+            print("[SuperLookup] Successfully imported SuperlookupEngine")
         except ImportError as e:
-            print(f"[Superlookup] IMPORT ERROR: {e}")
+            print(f"[SuperLookup] IMPORT ERROR: {e}")
             QMessageBox.critical(
                 self,
                 "Missing Module",
@@ -45193,7 +45951,7 @@ class SuperlookupTab(QWidget):
         if self.db_manager or self.termbase_mgr:
             self.populate_language_dropdowns()
             self._languages_populated = True
-            print("[Superlookup] Languages populated on first show")
+            print("[SuperLookup] Languages populated on first show")
     
     def init_ui(self):
         """Initialize the UI"""
@@ -45202,7 +45960,7 @@ class SuperlookupTab(QWidget):
         layout.setSpacing(5)  # Reduced from 10 to 5 for consistency
         
         # Header
-        header = QLabel("🔍 Superlookup")
+        header = QLabel("🔍 SuperLookup")
         header.setStyleSheet("font-size: 16pt; font-weight: bold; color: #1976D2;")
         layout.addWidget(header, 0)  # 0 = no stretch, stays compact
         
@@ -45696,7 +46454,7 @@ class SuperlookupTab(QWidget):
                     })
                     
             except Exception as e:
-                print(f"[Superlookup] MT error ({provider_name}): {e}")
+                print(f"[SuperLookup] MT error ({provider_name}): {e}")
                 results.append({
                     'provider': provider_name,
                     'translation': f"[Error: {str(e)}]",
@@ -45787,9 +46545,9 @@ class SuperlookupTab(QWidget):
             self.web_profile = QWebEngineProfile("SuperlookupProfile", self)
             self.web_profile.setPersistentStoragePath(storage_path)
             self.web_profile.setPersistentCookiesPolicy(QWebEngineProfile.PersistentCookiesPolicy.ForcePersistentCookies)
-            print(f"[Superlookup] QWebEngineView available - embedded browser enabled with persistent storage at {storage_path}")
+            print(f"[SuperLookup] QWebEngineView available - embedded browser enabled with persistent storage at {storage_path}")
         except ImportError:
-            print("[Superlookup] QWebEngineView not available - external browser only")
+            print("[SuperLookup] QWebEngineView not available - external browser only")
             self.QWebEngineView = None
             self.QWebEngineProfile = None
         
@@ -46241,7 +46999,7 @@ class SuperlookupTab(QWidget):
         self.web_view_stack.addWidget(web_view)
         self.web_views[resource['id']] = web_view
         
-        print(f"[Superlookup] Created web view for {resource['name']} (lazy load)")
+        print(f"[SuperLookup] Created web view for {resource['name']} (lazy load)")
     
     def _get_web_view_index(self, resource_id):
         """Get the stack index for a web view by resource ID"""
@@ -46258,7 +47016,7 @@ class SuperlookupTab(QWidget):
         
         self._update_web_view_for_mode()
         self._show_web_welcome_message()
-        print(f"[Superlookup] Web browser mode changed to: {self.web_browser_mode}")
+        print(f"[SuperLookup] Web browser mode changed to: {self.web_browser_mode}")
     
     def _update_web_view_for_mode(self):
         """Update the view stack based on current mode"""
@@ -46891,11 +47649,11 @@ class SuperlookupTab(QWidget):
         if index == 2:
             # Initialize Supermemory when tab is first viewed
             if not self.supermemory_engine:
-                print("[Superlookup] Supermemory tab viewed - initializing engine")
+                print("[SuperLookup] Supermemory tab viewed - initializing engine")
                 self.init_supermemory()
         # Settings tab is at index 5
         elif index == 5:
-            print("[Superlookup] Settings tab viewed - refreshing resource lists")
+            print("[SuperLookup] Settings tab viewed - refreshing resource lists")
             self.refresh_tm_list()
             self.refresh_termbase_list()
             self.populate_language_dropdowns()
@@ -46903,19 +47661,19 @@ class SuperlookupTab(QWidget):
     def on_tm_search_toggled(self, state):
         """Handle TM search checkbox toggle"""
         self.search_tm_enabled = (state == Qt.CheckState.Checked.value)
-        print(f"[Superlookup] TM search {'enabled' if self.search_tm_enabled else 'disabled'}")
+        print(f"[SuperLookup] TM search {'enabled' if self.search_tm_enabled else 'disabled'}")
     
     def on_termbase_search_toggled(self, state):
         """Handle termbase search checkbox toggle"""
         self.search_termbase_enabled = (state == Qt.CheckState.Checked.value)
-        print(f"[Superlookup] Termbase search {'enabled' if self.search_termbase_enabled else 'disabled'}")
+        print(f"[SuperLookup] Termbase search {'enabled' if self.search_termbase_enabled else 'disabled'}")
     
     def _on_web_resource_checkbox_changed(self, index: int, state: int):
         """Handle web resource checkbox change - show/hide corresponding sidebar button"""
         is_checked = (state == Qt.CheckState.Checked.value)
         if hasattr(self, 'web_resource_buttons') and index < len(self.web_resource_buttons):
             self.web_resource_buttons[index].setVisible(is_checked)
-            print(f"[Superlookup] Web resource {index} {'shown' if is_checked else 'hidden'}")
+            print(f"[SuperLookup] Web resource {index} {'shown' if is_checked else 'hidden'}")
             
             # If the hidden resource was selected, select the first visible one
             if not is_checked and hasattr(self, 'current_web_resource_index') and self.current_web_resource_index == index:
@@ -46933,18 +47691,18 @@ class SuperlookupTab(QWidget):
             checkbox.deleteLater()
         self.tm_checkboxes.clear()
         
-        print(f"[Superlookup] refresh_tm_list called")
-        print(f"[Superlookup]   main_window exists: {self.main_window is not None}")
+        print(f"[SuperLookup] refresh_tm_list called")
+        print(f"[SuperLookup]   main_window exists: {self.main_window is not None}")
         
         # Get TMs from main window's database
         if self.main_window and hasattr(self.main_window, 'db_manager') and self.main_window.db_manager:
             try:
-                print(f"[Superlookup]   db_manager found, querying TMs...")
+                print(f"[SuperLookup]   db_manager found, querying TMs...")
                 cursor = self.main_window.db_manager.cursor
                 cursor.execute("SELECT id, name, tm_id FROM translation_memories ORDER BY name")
                 tms = cursor.fetchall()
                 
-                print(f"[Superlookup]   Query returned {len(tms)} TMs")
+                print(f"[SuperLookup]   Query returned {len(tms)} TMs")
                 
                 for db_id, tm_name, tm_id_str in tms:
                     checkbox = CheckmarkCheckBox(f"{tm_name} (ID: {db_id})")
@@ -46955,13 +47713,13 @@ class SuperlookupTab(QWidget):
                     # Insert before the stretch at the end
                     self.tm_scroll_layout.insertWidget(len(self.tm_checkboxes) - 1, checkbox)
                 
-                print(f"[Superlookup] ✓ Loaded {len(tms)} TMs")
+                print(f"[SuperLookup] ✓ Loaded {len(tms)} TMs")
             except Exception as e:
-                print(f"[Superlookup] ✗ Error loading TMs: {e}")
+                print(f"[SuperLookup] ✗ Error loading TMs: {e}")
                 import traceback
                 traceback.print_exc()
         else:
-            print(f"[Superlookup]   db_manager not available")
+            print(f"[SuperLookup]   db_manager not available")
             # Add placeholder label
             placeholder = QLabel("No database connection - TMs unavailable")
             placeholder.setStyleSheet("color: #999; font-style: italic;")
@@ -46975,16 +47733,16 @@ class SuperlookupTab(QWidget):
             checkbox.deleteLater()
         self.tb_checkboxes.clear()
         
-        print(f"[Superlookup] refresh_termbase_list called")
-        print(f"[Superlookup]   main_window exists: {self.main_window is not None}")
+        print(f"[SuperLookup] refresh_termbase_list called")
+        print(f"[SuperLookup]   main_window exists: {self.main_window is not None}")
         
         # Try termbase_mgr first (preferred method)
         if self.main_window and hasattr(self.main_window, 'termbase_mgr') and self.main_window.termbase_mgr:
             try:
-                print(f"[Superlookup]   termbase_mgr found, querying termbases...")
+                print(f"[SuperLookup]   termbase_mgr found, querying termbases...")
                 termbases = self.main_window.termbase_mgr.get_all_termbases()
                 
-                print(f"[Superlookup]   get_all_termbases() returned {len(termbases)} termbases")
+                print(f"[SuperLookup]   get_all_termbases() returned {len(termbases)} termbases")
                 
                 for tb in termbases:
                     tb_id = tb.get('id')
@@ -46996,22 +47754,22 @@ class SuperlookupTab(QWidget):
                     # Insert before the stretch at the end
                     self.tb_scroll_layout.insertWidget(len(self.tb_checkboxes) - 1, checkbox)
                 
-                print(f"[Superlookup] ✓ Loaded {len(termbases)} termbases via termbase_mgr")
+                print(f"[SuperLookup] ✓ Loaded {len(termbases)} termbases via termbase_mgr")
                 return
             except Exception as e:
-                print(f"[Superlookup] ✗ Error loading termbases via termbase_mgr: {e}")
+                print(f"[SuperLookup] ✗ Error loading termbases via termbase_mgr: {e}")
                 import traceback
                 traceback.print_exc()
         
         # Fallback to direct database query
         if self.main_window and hasattr(self.main_window, 'db_manager') and self.main_window.db_manager:
             try:
-                print(f"[Superlookup]   db_manager found, querying termbases...")
+                print(f"[SuperLookup]   db_manager found, querying termbases...")
                 cursor = self.main_window.db_manager.cursor
                 cursor.execute("SELECT id, name FROM termbases ORDER BY name")
                 termbases = cursor.fetchall()
                 
-                print(f"[Superlookup]   Query returned {len(termbases)} termbases")
+                print(f"[SuperLookup]   Query returned {len(termbases)} termbases")
                 
                 for tb_id, tb_name in termbases:
                     checkbox = CheckmarkCheckBox(f"{tb_name} (ID: {tb_id})")
@@ -47021,13 +47779,13 @@ class SuperlookupTab(QWidget):
                     # Insert before the stretch at the end
                     self.tb_scroll_layout.insertWidget(len(self.tb_checkboxes) - 1, checkbox)
                 
-                print(f"[Superlookup] ✓ Loaded {len(termbases)} termbases via db_manager")
+                print(f"[SuperLookup] ✓ Loaded {len(termbases)} termbases via db_manager")
             except Exception as e:
-                print(f"[Superlookup] ✗ Error loading termbases via db_manager: {e}")
+                print(f"[SuperLookup] ✗ Error loading termbases via db_manager: {e}")
                 import traceback
                 traceback.print_exc()
         else:
-            print(f"[Superlookup]   Neither termbase_mgr nor db_manager available")
+            print(f"[SuperLookup]   Neither termbase_mgr nor db_manager available")
             # Add placeholder label
             placeholder = QLabel("No database connection - Glossaries unavailable")
             placeholder.setStyleSheet("color: #999; font-style: italic;")
@@ -47838,7 +48596,7 @@ class SuperlookupTab(QWidget):
                 self.status_label.setText(f"Navigated to glossary entry: {source_term}")
             
         except Exception as e:
-            print(f"[Superlookup] Error navigating to glossary: {e}")
+            print(f"[SuperLookup] Error navigating to glossary: {e}")
             self.status_label.setText(f"Error navigating to glossary: {e}")
     
     def _select_first_term_in_table(self, main):
@@ -47852,7 +48610,7 @@ class SuperlookupTab(QWidget):
                     if item:
                         table.scrollToItem(item)
         except Exception as e:
-            print(f"[Superlookup] Error selecting term: {e}")
+            print(f"[SuperLookup] Error selecting term: {e}")
 
     def display_mt_results(self, results):
         """Display MT results in the table"""
@@ -48387,7 +49145,7 @@ class SuperlookupTab(QWidget):
         if self.main_window and hasattr(self.main_window, 'general_settings'):
             saved_path = self.main_window.general_settings.get('autohotkey_path', '')
             if saved_path and os.path.exists(saved_path):
-                print(f"[Superlookup] Using saved AutoHotkey path: {saved_path}")
+                print(f"[SuperLookup] Using saved AutoHotkey path: {saved_path}")
                 return saved_path, 'saved'
         
         # Standard installation paths
@@ -48405,7 +49163,7 @@ class SuperlookupTab(QWidget):
         
         for path in ahk_paths:
             if os.path.exists(path):
-                print(f"[Superlookup] Detected AutoHotkey at: {path}")
+                print(f"[SuperLookup] Detected AutoHotkey at: {path}")
                 return path, 'detected'
         
         return None, None
@@ -48532,7 +49290,7 @@ class SuperlookupTab(QWidget):
             if self.main_window and hasattr(self.main_window, 'general_settings'):
                 self.main_window.general_settings['autohotkey_path'] = file_path
                 self.main_window.save_general_settings()
-                print(f"[Superlookup] Saved AutoHotkey path: {file_path}")
+                print(f"[SuperLookup] Saved AutoHotkey path: {file_path}")
             
             self._ahk_setup_status.setText(f"✓ Saved: {file_path}\n\nRestart Supervertaler to use this path.")
             
@@ -48553,11 +49311,11 @@ class SuperlookupTab(QWidget):
         Note: AutoHotkey is Windows-only, so skip on Linux/Mac.
         """
         global _ahk_process
-        print("[Superlookup] register_global_hotkey called")
+        print("[SuperLookup] register_global_hotkey called")
         
         # AutoHotkey is Windows-only - skip on other platforms
         if sys.platform != 'win32':
-            print("[Superlookup] Skipping AutoHotkey registration (not Windows)")
+            print("[SuperLookup] Skipping AutoHotkey registration (not Windows)")
             self.hotkey_registered = False
             return
         
@@ -48571,24 +49329,24 @@ class SuperlookupTab(QWidget):
         """
         try:
             from ahk import AHK
-            print("[Superlookup] ahk library available, attempting to use it...")
+            print("[SuperLookup] ahk library available, attempting to use it...")
             
             # Find AutoHotkey executable using shared function
             ahk_exe, source = self._find_autohotkey_executable()
             
             # Create AHK instance (with executable path if found)
             if ahk_exe:
-                print(f"[Superlookup] Using AutoHotkey at: {ahk_exe} (source: {source})")
+                print(f"[SuperLookup] Using AutoHotkey at: {ahk_exe} (source: {source})")
                 self._ahk = AHK(executable_path=ahk_exe)
             else:
                 # Let it try to find AHK on PATH (may fail)
                 self._ahk = AHK()
-            print(f"[Superlookup] AHK instance created: {self._ahk}")
+            print(f"[SuperLookup] AHK instance created: {self._ahk}")
             
             # Define hotkey callback
             def on_hotkey():
                 """Called when Ctrl+Alt+L is pressed"""
-                print("[Superlookup] Hotkey triggered via ahk library!")
+                print("[SuperLookup] Hotkey triggered via ahk library!")
                 try:
                     # Copy selection to clipboard
                     self._ahk.send('^c')  # Ctrl+C
@@ -48601,7 +49359,7 @@ class SuperlookupTab(QWidget):
                     try:
                         self._ahk.win_activate('Supervertaler')
                     except Exception as e:
-                        print(f"[Superlookup] win_activate error (non-critical): {e}")
+                        print(f"[SuperLookup] win_activate error (non-critical): {e}")
                     
                     # Trigger lookup in main thread
                     if text:
@@ -48609,22 +49367,22 @@ class SuperlookupTab(QWidget):
                         QTimer.singleShot(0, lambda: self.on_ahk_capture(text))
                         
                 except Exception as e:
-                    print(f"[Superlookup] Error in hotkey callback: {e}")
+                    print(f"[SuperLookup] Error in hotkey callback: {e}")
             
             # Register the hotkey
             self._ahk.add_hotkey('^!l', callback=on_hotkey)  # Ctrl+Alt+L
             self._ahk.start_hotkeys()
             
-            print("[Superlookup] ✓ Hotkey registered via ahk library: Ctrl+Alt+L")
+            print("[SuperLookup] ✓ Hotkey registered via ahk library: Ctrl+Alt+L")
             self.hotkey_registered = True
             self._using_ahk_library = True
             return True
             
         except ImportError:
-            print("[Superlookup] ahk library not installed (pip install ahk)")
+            print("[SuperLookup] ahk library not installed (pip install ahk)")
             return False
         except Exception as e:
-            print(f"[Superlookup] ahk library method failed: {e}")
+            print(f"[SuperLookup] ahk library method failed: {e}")
             # Clean up on failure
             if hasattr(self, '_ahk'):
                 try:
@@ -48705,11 +49463,13 @@ class SuperlookupTab(QWidget):
             self.hotkey_registered = False
     
     def start_file_watcher(self):
-        """Watch for signal file from AHK"""
+        """Watch for signal files from AHK (Superlookup and MT Quick Lookup)"""
         self.signal_file = Path(__file__).parent / "lookup_signal.txt"
         self.capture_file = Path(__file__).parent / "temp_capture.txt"
-        
-        print(f"[Superlookup] File watcher started, watching: {self.signal_file}")
+        self.mt_lookup_signal_file = Path(__file__).parent / "mt_lookup_signal.txt"
+
+        print(f"[SuperLookup] File watcher started, watching: {self.signal_file}")
+        print(f"[QuickTrans] File watcher started, watching: {self.mt_lookup_signal_file}")
         
         # Create timer to check for signal file
         self.file_check_timer = QTimer()
@@ -48718,27 +49478,57 @@ class SuperlookupTab(QWidget):
     
     def check_for_signal(self):
         """Check if AHK wrote a signal file"""
+        # Check for Superlookup signal
         if self.signal_file.exists():
-            print(f"[Superlookup] Signal file detected!")
+            print(f"[SuperLookup] Signal file detected!")
             try:
                 # Delete signal file
                 self.signal_file.unlink()
-                print(f"[Superlookup] Signal file deleted")
-                
+                print(f"[SuperLookup] Signal file deleted")
+
                 # Get text from clipboard (AHK already copied it)
                 time.sleep(0.1)  # Give clipboard a moment
                 text = pyperclip.paste()
-                
+
                 # Trigger lookup
                 if text:
                     self.on_ahk_capture(text)
             except Exception as e:
-                print(f"[Superlookup] Error reading capture: {e}")
+                print(f"[SuperLookup] Error reading capture: {e}")
+
+        # Check for MT Quick Lookup signal
+        if hasattr(self, 'mt_lookup_signal_file') and self.mt_lookup_signal_file.exists():
+            print(f"[QuickTrans] Signal file detected!")
+            try:
+                # Small delay to let AHK finish writing/close the file
+                time.sleep(0.05)
+
+                # Delete signal file with retry for file lock
+                for attempt in range(3):
+                    try:
+                        self.mt_lookup_signal_file.unlink()
+                        print(f"[QuickTrans] Signal file deleted")
+                        break
+                    except PermissionError:
+                        if attempt < 2:
+                            time.sleep(0.05)
+                        else:
+                            raise
+
+                # Get text from clipboard (AHK already copied it)
+                time.sleep(0.1)  # Give clipboard a moment
+                text = pyperclip.paste()
+
+                # Trigger MT Quick Lookup
+                if text:
+                    self.on_ahk_mt_lookup_capture(text)
+            except Exception as e:
+                print(f"[QuickTrans] Error reading capture: {e}")
     
     def on_ahk_capture(self, text):
         """Handle text captured by AHK"""
         try:
-            print(f"[Superlookup] on_ahk_capture called with text: {text[:50]}...")
+            print(f"[SuperLookup] on_ahk_capture called with text: {text[:50]}...")
             
             # Bring Supervertaler to foreground
             main_window = self.window()
@@ -48768,39 +49558,96 @@ class SuperlookupTab(QWidget):
             QTimer.singleShot(250, lambda: self.show_superlookup(text))
             
         except Exception as e:
-            print(f"[Superlookup] Error handling capture: {e}")
-    
+            print(f"[SuperLookup] Error handling capture: {e}")
+
+    def on_ahk_mt_lookup_capture(self, text):
+        """Handle MT Quick Lookup text captured by AHK (Ctrl+Alt+M)"""
+        try:
+            print(f"[QuickTrans] on_ahk_mt_lookup_capture called with text: {text[:50]}...")
+
+            # Show popup directly without bringing Supervertaler to foreground
+            # The popup has WindowStaysOnTopHint so it will appear over any app
+            QTimer.singleShot(100, lambda: self.show_mt_quick_lookup_from_ahk(text))
+
+        except Exception as e:
+            print(f"[QuickTrans] Error handling capture: {e}")
+
+    def show_mt_quick_lookup_from_ahk(self, text):
+        """Show MT Quick Lookup popup with text from AHK capture"""
+        try:
+            print(f"[QuickTrans] show_mt_quick_lookup_from_ahk called with text: {text[:50]}...")
+
+            # Get main window reference for settings access
+            main_window = self.main_window
+            if not main_window:
+                main_window = self.window()
+
+            if not main_window:
+                print("[QuickTrans] ERROR: Could not find main window")
+                return
+
+            # Get language settings
+            source_lang = getattr(main_window, 'source_language', 'English')
+            target_lang = getattr(main_window, 'target_language', 'Dutch')
+
+            # Import and show MT Quick Lookup popup
+            from modules.quicktrans import MTQuickPopup
+
+            # Create popup without Qt parent so it can appear independently over any app
+            # Pass main_window as parent_app for API access
+            popup = MTQuickPopup(
+                parent_app=main_window,
+                source_text=text,
+                source_lang=source_lang,
+                target_lang=target_lang,
+                parent=None  # No Qt parent - allows independent window
+            )
+
+            # Store reference to prevent garbage collection
+            self._ahk_mt_popup = popup
+
+            # Show and ensure it's on top
+            popup.show()
+            popup.raise_()
+            popup.activateWindow()
+            print(f"[QuickTrans] Popup shown for text: {text[:30]}...")
+
+        except Exception as e:
+            print(f"[QuickTrans] Error showing popup: {e}")
+            import traceback
+            traceback.print_exc()
+
     def show_superlookup(self, text):
         """Show Superlookup with pre-filled text"""
         try:
-            print(f"[Superlookup] show_superlookup called with text: {text[:50]}...")
+            print(f"[SuperLookup] show_superlookup called with text: {text[:50]}...")
             
             # Get main window reference
             main_window = self.main_window
             if not main_window:
                 main_window = self.window()
             
-            print(f"[Superlookup] Main window found: {main_window is not None}")
-            print(f"[Superlookup] Main window type: {type(main_window).__name__}")
-            print(f"[Superlookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
+            print(f"[SuperLookup] Main window found: {main_window is not None}")
+            print(f"[SuperLookup] Main window type: {type(main_window).__name__}")
+            print(f"[SuperLookup] Has main_tabs: {hasattr(main_window, 'main_tabs')}")
             
             # Switch to Tools tab (main_tabs index 3)
             # Tab structure: Grid=0, Resources=1, QuickMenu=2, Tools=3, Settings=4
             if hasattr(main_window, 'main_tabs'):
-                print(f"[Superlookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
+                print(f"[SuperLookup] Current main_tab index: {main_window.main_tabs.currentIndex()}")
                 main_window.main_tabs.setCurrentIndex(3)  # Tools tab
-                print(f"[Superlookup] Switched to Tools tab (index 2)")
+                print(f"[SuperLookup] Switched to Tools tab (index 2)")
                 QApplication.processEvents()  # Force GUI update
             else:
-                print(f"[Superlookup] WARNING: Main window has no main_tabs attribute!")
+                print(f"[SuperLookup] WARNING: Main window has no main_tabs attribute!")
             
             # Switch to Superlookup within modules_tabs
             if hasattr(main_window, 'modules_tabs'):
-                print(f"[Superlookup] Current modules_tab index: {main_window.modules_tabs.currentIndex()}")
+                print(f"[SuperLookup] Current modules_tab index: {main_window.modules_tabs.currentIndex()}")
                 for i in range(main_window.modules_tabs.count()):
                     if "Superlookup" in main_window.modules_tabs.tabText(i):
                         main_window.modules_tabs.setCurrentIndex(i)
-                        print(f"[Superlookup] Switched to Superlookup tab (index {i})")
+                        print(f"[SuperLookup] Switched to Superlookup tab (index {i})")
                         QApplication.processEvents()  # Force GUI update
                         break
             
@@ -48808,23 +49655,23 @@ class SuperlookupTab(QWidget):
             QTimer.singleShot(100, lambda: self._fill_and_search(text))
                     
         except Exception as e:
-            print(f"[Superlookup] Error showing lookup: {e}")
+            print(f"[SuperLookup] Error showing lookup: {e}")
     
     def _fill_and_search(self, text):
         """Fill in text and trigger search (called after tab switching completes)"""
         try:
-            print(f"[Superlookup] _fill_and_search called")
+            print(f"[SuperLookup] _fill_and_search called")
             # Fill in text and trigger lookup
             if hasattr(self, 'source_text'):
                 self.source_text.setCurrentText(text)
-                print(f"[Superlookup] Text filled in source_text field")
+                print(f"[SuperLookup] Text filled in source_text field")
                 # Trigger lookup by calling perform_lookup directly
                 self.perform_lookup()
-                print(f"[Superlookup] perform_lookup() called")
+                print(f"[SuperLookup] perform_lookup() called")
             else:
-                print(f"[Superlookup] ERROR: source_text widget not found!")
+                print(f"[SuperLookup] ERROR: source_text widget not found!")
         except Exception as e:
-            print(f"[Superlookup] Error in _fill_and_search: {e}")
+            print(f"[SuperLookup] Error in _fill_and_search: {e}")
             import traceback
             traceback.print_exc()