supervertaler 1.9.116__py3-none-any.whl → 1.9.131__py3-none-any.whl

Supervertaler.py

@@ -3,7 +3,7 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.116 (Fix all tab navigation + startup tab)
+Version: 1.9.123 (QuickMenu now supports generic AI tasks)
 Release Date: January 19, 2026
 Framework: PyQt6
 
@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.116"
+__version__ = "1.9.131"
 __phase__ = "0.9"
-__release_date__ = "2026-01-18"
+__release_date__ = "2026-01-19"
 __edition__ = "Qt"
 
 import sys
@@ -123,10 +123,10 @@ try:
         QButtonGroup, QDialogButtonBox, QTabWidget, QGroupBox, QGridLayout, QCheckBox,
         QProgressBar, QProgressDialog, QFormLayout, QTabBar, QPlainTextEdit, QAbstractItemDelegate,
         QFrame, QListWidget, QListWidgetItem, QStackedWidget, QTreeWidget, QTreeWidgetItem,
-        QScrollArea, QSizePolicy, QSlider, QToolButton
+        QScrollArea, QSizePolicy, QSlider, QToolButton, QAbstractItemView
     )
     from PyQt6.QtCore import Qt, QSize, QTimer, pyqtSignal, QObject, QUrl
-    from PyQt6.QtGui import QFont, QAction, QKeySequence, QIcon, QTextOption, QColor, QDesktopServices, QTextCharFormat, QTextCursor, QBrush, QSyntaxHighlighter, QPalette, QTextBlockFormat
+    from PyQt6.QtGui import QFont, QAction, QKeySequence, QIcon, QTextOption, QColor, QDesktopServices, QTextCharFormat, QTextCursor, QBrush, QSyntaxHighlighter, QPalette, QTextBlockFormat, QCursor
     from PyQt6.QtWidgets import QStyleOptionViewItem, QStyle
     from PyQt6.QtCore import QRectF
     from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -170,11 +170,11 @@ def cleanup_ahk_process():
         try:
             _ahk_process.terminate()
             _ahk_process.wait(timeout=1)
-            print("[Superlookup] AHK process terminated on exit")
+            print("[Hotkeys] AHK process terminated on exit")
         except:
             try:
                 _ahk_process.kill()
-                print("[Superlookup] AHK process killed on exit")
+                print("[Hotkeys] AHK process killed on exit")
             except:
                 pass
 
@@ -910,6 +910,7 @@ class _CtrlReturnEventFilter(QObject):
 
         return False
 
+
 class GridTableEventFilter:
     """Mixin to pass keyboard shortcuts from editor to table"""
     pass
@@ -2559,7 +2560,7 @@ class EditableGridTextEditor(QTextEdit):
                     menu.addSeparator()
                 
                 # Add to dictionary action
-                add_to_dict_action = QAction(f"📖 Add '{misspelled_word}' to Dictionary", self)
+                add_to_dict_action = QAction(f"📖 Add '{misspelled_word}' to Dictionary (Alt+D)", self)
                 add_to_dict_action.triggered.connect(
                     lambda checked, w=misspelled_word: self._add_to_dictionary(w)
                 )
@@ -5592,6 +5593,11 @@ class SupervertalerQt(QMainWindow):
         self.termview_shortcuts = []
         self._termview_last_key = None  # Track last key for double-tap detection
         self._termview_last_time = 0    # Track timing for double-tap
+        
+        # Double-tap Shift detection for context menu
+        self._shift_last_press_time = 0
+        self._shift_double_tap_threshold = 0.35  # 350ms window
+        
         for i in range(0, 10):  # 0-9
             shortcut_id = f"termview_insert_{i}"
             default_key = f"Alt+{i}"
@@ -5635,6 +5641,9 @@ class SupervertalerQt(QMainWindow):
             self._ctrl_return_event_filter = _CtrlReturnEventFilter(self)
             QApplication.instance().installEventFilter(self._ctrl_return_event_filter)
         
+        # Note: Double-tap Shift for context menu is handled by AutoHotkey (double_shift_menu.ahk)
+        # Qt's event system makes reliable double-tap detection difficult in Python
+        
         # Ctrl+Shift+Enter - Always confirm all selected segments
         create_shortcut("editor_confirm_selected", "Ctrl+Shift+Return", self.confirm_selected_segments)
         
@@ -5668,6 +5677,84 @@ class SupervertalerQt(QMainWindow):
         
         # Ctrl+Shift+2 - Quick add term with Priority 2
         create_shortcut("editor_quick_add_priority_2", "Ctrl+Shift+2", lambda: self._quick_add_term_with_priority(2))
+        
+        # Alt+D - Add word at cursor to dictionary
+        create_shortcut("editor_add_to_dictionary", "Alt+D", self.add_word_to_dictionary_shortcut)
+        
+        # Ctrl+N - Focus Segment Note tab
+        create_shortcut("editor_focus_notes", "Ctrl+N", self.focus_segment_notes)
+        
+        # Alt+K - Open QuickMenu directly
+        create_shortcut("editor_open_quickmenu", "Alt+K", self.open_quickmenu)
+    
+    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, 'bottom_tabs'):
+            return
+        
+        # Switch to Segment note tab (index 1)
+        self.bottom_tabs.setCurrentIndex(1)
+        
+        # Focus the notes editor so user can start typing
+        if hasattr(self, 'bottom_notes_edit'):
+            self.bottom_notes_edit.setFocus()
+    
+    def open_quickmenu(self):
+        """Open QuickMenu popup at current cursor position for quick AI prompt selection.
+        
+        User can navigate with arrow keys and press Enter to select a prompt.
+        """
+        try:
+            # Get QuickMenu items from prompt library
+            quickmenu_items = []
+            if hasattr(self, 'prompt_manager_qt') and self.prompt_manager_qt:
+                lib = getattr(self.prompt_manager_qt, 'library', None)
+                if lib and hasattr(lib, 'get_quickmenu_grid_prompts'):
+                    quickmenu_items = lib.get_quickmenu_grid_prompts() or []
+            
+            if not quickmenu_items:
+                self.log("⚠️ No QuickMenu prompts available. Add prompts with 'Show in Supervertaler QuickMenu' enabled.")
+                return
+            
+            # Find the currently focused widget (source or target cell)
+            focus_widget = QApplication.focusWidget()
+            
+            # Build the menu
+            menu = QMenu(self)
+            menu.setTitle("⚡ QuickMenu")
+            
+            for rel_path, label in sorted(quickmenu_items, key=lambda x: (x[1] or x[0]).lower()):
+                prompt_menu = menu.addMenu(label or rel_path)
+                
+                run_show = QAction("▶ Run (show response)…", self)
+                run_show.triggered.connect(
+                    lambda checked=False, p=rel_path, w=focus_widget: self.run_grid_quickmenu_prompt(p, origin_widget=w, behavior="show")
+                )
+                prompt_menu.addAction(run_show)
+                
+                run_replace = QAction("↺ Run and replace target selection", self)
+                run_replace.triggered.connect(
+                    lambda checked=False, p=rel_path, w=focus_widget: self.run_grid_quickmenu_prompt(p, origin_widget=w, behavior="replace")
+                )
+                prompt_menu.addAction(run_replace)
+            
+            # Show menu at cursor position (or center of focused widget)
+            if focus_widget:
+                # Get cursor rectangle if it's a text editor
+                if hasattr(focus_widget, 'cursorRect'):
+                    cursor_rect = focus_widget.cursorRect()
+                    pos = focus_widget.mapToGlobal(cursor_rect.bottomLeft())
+                else:
+                    # Fallback to center of widget
+                    pos = focus_widget.mapToGlobal(focus_widget.rect().center())
+            else:
+                # Fallback to mouse cursor position
+                pos = QCursor.pos()
+            
+            menu.exec(pos)
+            
+        except Exception as e:
+            self.log(f"❌ Error opening QuickMenu: {e}")
     
     def refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
@@ -10836,6 +10923,38 @@ class SupervertalerQt(QMainWindow):
             self._play_sound_effect('glossary_term_error')
             self.statusBar().showMessage(f"Error adding term: {e}", 3000)
 
+    def add_word_to_dictionary_shortcut(self):
+        """Add word at cursor position to custom dictionary (Alt+D shortcut)
+        
+        Finds the misspelled word at the current cursor position and adds it to the
+        custom dictionary. Works when focus is in a grid target cell.
+        """
+        # Get currently focused widget
+        focused_widget = QApplication.focusWidget()
+        
+        # Check if we're in an editable grid cell
+        if not isinstance(focused_widget, EditableGridTextEditor):
+            self.statusBar().showMessage("Alt+D: Place cursor on a misspelled word in the target cell first", 3000)
+            return
+        
+        # Get cursor position
+        cursor = focused_widget.textCursor()
+        
+        # Try to find misspelled word at cursor
+        word_info = focused_widget._get_misspelled_word_at_cursor(cursor)
+        
+        if word_info[0] is None:
+            # No misspelled word found at cursor
+            self.statusBar().showMessage("No misspelled word at cursor position", 3000)
+            return
+        
+        word, start_pos, end_pos = word_info
+        
+        # Add to dictionary
+        focused_widget._add_to_dictionary(word)
+        
+        # Status message already shown by _add_to_dictionary
+
     def add_text_to_non_translatables(self, text: str):
         """Add selected text to active non-translatable list(s)"""
         if not text or not text.strip():
@@ -13956,6 +14075,45 @@ class SupervertalerQt(QMainWindow):
         full_context_cb.stateChanged.connect(lambda: context_slider.setEnabled(full_context_cb.isChecked()))
         update_context_label(context_window_size)
         
+        prefs_layout.addSpacing(10)
+        
+        # QuickMenu document context
+        quickmenu_context_label = QLabel("<b>QuickMenu Document Context:</b>")
+        prefs_layout.addWidget(quickmenu_context_label)
+        
+        quickmenu_context_percent = general_prefs.get('quickmenu_context_percent', 50)
+        quickmenu_context_layout = QHBoxLayout()
+        quickmenu_context_layout.addWidget(QLabel("  Document context size:"))
+        quickmenu_context_slider = QSlider(Qt.Orientation.Horizontal)
+        quickmenu_context_slider.setMinimum(0)
+        quickmenu_context_slider.setMaximum(100)
+        quickmenu_context_slider.setValue(quickmenu_context_percent)
+        quickmenu_context_slider.setTickPosition(QSlider.TickPosition.TicksBelow)
+        quickmenu_context_slider.setTickInterval(10)
+        quickmenu_context_layout.addWidget(quickmenu_context_slider)
+        quickmenu_context_value_label = QLabel(f"{quickmenu_context_percent}%")
+        quickmenu_context_value_label.setMinimumWidth(60)
+        quickmenu_context_layout.addWidget(quickmenu_context_value_label)
+        quickmenu_context_layout.addStretch()
+        prefs_layout.addLayout(quickmenu_context_layout)
+        
+        quickmenu_context_info = QLabel(
+            "  ⓘ When using {{SOURCE+TARGET_CONTEXT}} or {{SOURCE_CONTEXT}} placeholders in QuickMenu prompts.\n"
+            "  0% = disabled, 50% = half the document (default), 100% = entire document.\n"
+            "  Limit: maximum 100 segments for performance."
+        )
+        quickmenu_context_info.setStyleSheet("font-size: 9pt; color: #666; padding-left: 20px;")
+        quickmenu_context_info.setWordWrap(True)
+        prefs_layout.addWidget(quickmenu_context_info)
+        
+        def update_quickmenu_context_label(value):
+            if value == 0:
+                quickmenu_context_value_label.setText("0% (disabled)")
+            else:
+                quickmenu_context_value_label.setText(f"{value}%")
+        
+        quickmenu_context_slider.valueChanged.connect(update_quickmenu_context_label)
+        
         prefs_layout.addSpacing(5)
         
         # Check TM before API call
@@ -14100,7 +14258,8 @@ class SupervertalerQt(QMainWindow):
             batch_size_spin, surrounding_spin, full_context_cb, context_slider,
             check_tm_cb, auto_propagate_cb, delay_spin,
             ollama_keepwarm_cb,
-            llm_matching_cb, auto_markdown_cb, llm_spin
+            llm_matching_cb, auto_markdown_cb, llm_spin,
+            quickmenu_context_slider
         ))
         layout.addWidget(save_btn)
         
@@ -17098,7 +17257,8 @@ class SupervertalerQt(QMainWindow):
                                    batch_size_spin, surrounding_spin, full_context_cb, context_slider,
                                    check_tm_cb, auto_propagate_cb, delay_spin,
                                    ollama_keepwarm_cb,
-                                   llm_matching_cb, auto_markdown_cb, llm_spin):
+                                   llm_matching_cb, auto_markdown_cb, llm_spin,
+                                   quickmenu_context_slider):
         """Save all AI settings from the unified AI Settings tab"""
         # Determine selected provider
         if openai_radio.isChecked():
@@ -17157,6 +17317,7 @@ class SupervertalerQt(QMainWindow):
         general_prefs['surrounding_segments'] = surrounding_spin.value()
         general_prefs['use_full_context'] = full_context_cb.isChecked()
         general_prefs['context_window_size'] = context_slider.value()
+        general_prefs['quickmenu_context_percent'] = quickmenu_context_slider.value()
         general_prefs['check_tm_before_api'] = check_tm_cb.isChecked()
         general_prefs['auto_propagate_100'] = auto_propagate_cb.isChecked()
         general_prefs['lookup_delay'] = delay_spin.value()
@@ -28206,6 +28367,20 @@ class SupervertalerQt(QMainWindow):
         # Full processing for non-arrow-key navigation (click, etc.)
         self._on_cell_selected_full(current_row, current_col, previous_row, previous_col)
     
+    def _center_row_in_viewport(self, row: int):
+        """Center the given row vertically in the visible table viewport.
+        
+        Uses Qt's built-in scrollTo() with PositionAtCenter hint.
+        """
+        if row < 0 or row >= self.table.rowCount():
+            return
+        
+        # Get the model index for any cell in this row (use column 0)
+        index = self.table.model().index(row, 0)
+        if index.isValid():
+            # Use Qt's built-in centering - PositionAtCenter puts the item in the center of the viewport
+            self.table.scrollTo(index, QAbstractItemView.ScrollHint.PositionAtCenter)
+    
     def _on_cell_selected_minimal(self, current_row, previous_row):
         """Minimal UI update for fast arrow key navigation - just highlight and scroll"""
         try:
@@ -28227,7 +28402,7 @@ class SupervertalerQt(QMainWindow):
                 
                 # Auto-center if enabled
                 if getattr(self, 'auto_center_active_segment', False) and not getattr(self, 'filtering_active', False):
-                    self.table.scrollToItem(current_id_item, QTableWidget.ScrollHint.PositionAtCenter)
+                    self._center_row_in_viewport(current_row)
         except Exception as e:
             if self.debug_mode_enabled:
                 self.log(f"Error in minimal cell selection: {e}")
@@ -28272,7 +28447,7 @@ class SupervertalerQt(QMainWindow):
                     current_id_item.setForeground(QColor("white"))
                 
                 if getattr(self, 'auto_center_active_segment', False) and not getattr(self, 'filtering_active', False):
-                    self.table.scrollToItem(current_id_item, QTableWidget.ScrollHint.PositionAtCenter)
+                    self._center_row_in_viewport(current_row)
             
             if not self.current_project or current_row < 0:
                 return
@@ -31042,11 +31217,18 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         normalized_source = clean_source_lower
                         for quote_char in '\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A':
                             normalized_source = normalized_source.replace(quote_char, ' ')
+                        
+                        # CRITICAL FIX: Strip trailing punctuation from glossary term before matching
+                        # This allows entries like "De huidige uitvinding...problemen." (with period)
+                        # to match source text "...problemen." where tokenization strips the period
+                        # Strip from both ends to handle quotes and trailing punctuation
+                        normalized_term = source_term.lower().rstrip(PUNCT_CHARS).lstrip(PUNCT_CHARS)
+                        
                         # Check if term has punctuation - use different pattern
-                        if any(char in source_term for char in ['.', '%', ',', '-', '/']):
-                            pattern = re.compile(r'(?<!\w)' + re.escape(source_term.lower()) + r'(?!\w)')
+                        if any(char in normalized_term for char in ['.', '%', ',', '-', '/']):
+                            pattern = re.compile(r'(?<!\w)' + re.escape(normalized_term) + r'(?!\w)')
                         else:
-                            pattern = re.compile(r"\b" + re.escape(source_term.lower()) + r"\b")
+                            pattern = re.compile(r"\b" + re.escape(normalized_term) + r"\b")
                         
                         # Try matching on normalized (tag-stripped, quote-stripped) text first, 
                         # then tag-stripped, then original with tags
@@ -31503,7 +31685,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         self.case_sensitive_cb.setChecked(op.case_sensitive)
     
     def _fr_run_set_batch(self, fr_set: FindReplaceSet):
-        """Run all enabled operations in a F&R Set as a batch."""
+        """Run all enabled operations in a F&R Set as a batch (optimized for speed)."""
         enabled_ops = [op for op in fr_set.operations if op.enabled and op.find_text]
         
         if not enabled_ops:
@@ -31522,17 +31704,32 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if reply != QMessageBox.StandardButton.Yes:
             return
         
-        # Run each operation
-        total_replaced = 0
-        for op in enabled_ops:
-            count = self._execute_single_fr_operation(op)
-            total_replaced += count
-            self.log(f"  '{op.find_text}' → '{op.replace_text}': {count} replacement(s)")
+        # OPTIMIZATION: Disable UI updates during batch processing
+        self.table.setUpdatesEnabled(False)
         
-        # Refresh grid
-        self.load_segments_to_grid()
-        self.project_modified = True
-        self.update_window_title()
+        try:
+            # Run each operation
+            total_replaced = 0
+            for op in enabled_ops:
+                count = self._execute_single_fr_operation(op)
+                total_replaced += count
+                self.log(f"  '{op.find_text}' → '{op.replace_text}': {count} replacement(s)")
+            
+            self.project_modified = True
+            self.update_window_title()
+            
+        finally:
+            # OPTIMIZATION: Re-enable UI updates and refresh only target column cells
+            self.table.setUpdatesEnabled(True)
+            # Update all target cells in-place (batch operations can affect many segments)
+            for row in range(len(self.current_project.segments)):
+                segment = self.current_project.segments[row]
+                target_widget = self.table.cellWidget(row, 3)
+                if target_widget and hasattr(target_widget, 'setPlainText'):
+                    target_widget.blockSignals(True)
+                    target_widget.setPlainText(segment.target)
+                    target_widget.blockSignals(False)
+            self.table.viewport().update()
         
         QMessageBox.information(
             self.find_replace_dialog,
@@ -31541,12 +31738,30 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         )
     
     def _execute_single_fr_operation(self, op: FindReplaceOperation) -> int:
-        """Execute a single F&R operation on all segments. Returns replacement count."""
+        """Execute a single F&R operation on all segments (optimized). Returns replacement count."""
         import re
         count = 0
         
+        # OPTIMIZATION: Pre-filter segments - only check segments that might contain the text
+        # Quick case-insensitive check to skip segments that definitely don't match
+        search_text_lower = op.find_text.lower() if not op.case_sensitive else None
+        
         for segment in self.current_project.segments:
             texts_to_check = []
+            
+            # Pre-filter: skip segments that can't possibly match
+            if not op.case_sensitive:
+                # Quick check: does the segment contain the search text at all?
+                skip_segment = True
+                if op.search_in in ("source", "both") and self.allow_replace_in_source:
+                    if search_text_lower in segment.source.lower():
+                        skip_segment = False
+                if op.search_in in ("target", "both"):
+                    if search_text_lower in segment.target.lower():
+                        skip_segment = False
+                if skip_segment:
+                    continue
+            
             if op.search_in in ("source", "both") and self.allow_replace_in_source:
                 texts_to_check.append(("source", segment.source))
             if op.search_in in ("target", "both"):
@@ -31842,7 +32057,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         self.find_next_match()
     
     def replace_all_matches(self):
-        """Replace all matches in target segments"""
+        """Replace all matches in target segments (optimized for speed)"""
         find_text = self.find_input.text()
         replace_text = self.replace_input.text()
         
@@ -31915,52 +32130,67 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if reply != QMessageBox.StandardButton.Yes:
             return
         
-        # Perform replacements
-        import re
-        replaced_count = 0
+        # OPTIMIZATION: Disable UI updates during batch replacement
+        self.table.setUpdatesEnabled(False)
         
-        for row, col in self.find_matches:
-            segment = self.current_project.segments[row]
-            
-            # Get the appropriate field
-            if col == 2:  # Source
-                old_text = segment.source
-            else:  # col == 3, Target
-                old_text = segment.target
+        try:
+            # Perform replacements
+            import re
+            replaced_count = 0
+            updated_rows = set()  # Track which rows need UI updates
             
-            # Perform replacement
-            if match_mode == 2:  # Entire segment
-                new_text = replace_text
-            else:
-                if case_sensitive:
-                    new_text = old_text.replace(find_text, replace_text)
-                else:
-                    pattern = re.escape(find_text)
-                    new_text = re.sub(pattern, replace_text, old_text, flags=re.IGNORECASE)
-            
-            if new_text != old_text:
-                replaced_count += 1
-                # Update the appropriate field
-                if col == 2:
-                    segment.source = new_text
+            for row, col in self.find_matches:
+                segment = self.current_project.segments[row]
+                
+                # Get the appropriate field
+                if col == 2:  # Source
+                    old_text = segment.source
+                else:  # col == 3, Target
+                    old_text = segment.target
+                
+                # Perform replacement
+                if match_mode == 2:  # Entire segment
+                    new_text = replace_text
                 else:
-                    old_target = segment.target
-                    old_status = segment.status
-                    segment.target = new_text
-                    # Record undo state for find/replace operation
-                    self.record_undo_state(segment.id, old_target, new_text, old_status, old_status)
+                    if case_sensitive:
+                        new_text = old_text.replace(find_text, replace_text)
+                    else:
+                        pattern = re.escape(find_text)
+                        new_text = re.sub(pattern, replace_text, old_text, flags=re.IGNORECASE)
                 
-                # Update table
-                item = self.table.item(row, col)
-                if item:
-                    item.setText(new_text)
-        
-        self.project_modified = True
-        self.update_window_title()
-        
-        # Clear matches and reload
-        self.find_matches = []
-        self.load_segments_to_grid()
+                if new_text != old_text:
+                    replaced_count += 1
+                    updated_rows.add(row)
+                    
+                    # Update the appropriate field
+                    if col == 2:
+                        segment.source = new_text
+                    else:
+                        old_target = segment.target
+                        old_status = segment.status
+                        segment.target = new_text
+                        # Record undo state for find/replace operation
+                        self.record_undo_state(segment.id, old_target, new_text, old_status, old_status)
+                    
+                    # OPTIMIZATION: Update only the affected cell widget in-place
+                    cell_widget = self.table.cellWidget(row, col)
+                    if cell_widget and hasattr(cell_widget, 'setPlainText'):
+                        cell_widget.blockSignals(True)
+                        cell_widget.setPlainText(new_text)
+                        cell_widget.blockSignals(False)
+            
+            self.project_modified = True
+            self.update_window_title()
+            
+            # Clear matches
+            self.find_matches = []
+            
+        finally:
+            # OPTIMIZATION: Re-enable UI updates without full grid reload
+            self.table.setUpdatesEnabled(True)
+            # Trigger a repaint of updated rows only
+            for row in updated_rows:
+                self.table.viewport().update()
         
         QMessageBox.information(self.find_replace_dialog, "Replace All", f"Replaced {replaced_count} occurrence(s).")
         self.log(f"✓ Replaced {replaced_count} occurrence(s) of '{find_text}'")
@@ -37564,7 +37794,19 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         return text.strip()
 
     def _quickmenu_build_custom_prompt(self, prompt_relative_path: str, source_text: str, source_lang: str, target_lang: str) -> str:
-        """Build a complete translation prompt using the chosen QuickMenu prompt as PRIMARY instructions."""
+        """Build a prompt for QuickMenu using the selected prompt as instructions.
+        
+        This is a GENERIC prompt builder (not translation-specific) that allows QuickMenu prompts
+        to do anything: explain, define, search, translate, analyze, etc.
+        
+        Supports placeholders:
+        - {{SELECTION}} or {{SOURCE_TEXT}} - The selected text
+        - {{SOURCE_LANGUAGE}} - Source language name
+        - {{TARGET_LANGUAGE}} - Target language name
+        - {{SOURCE+TARGET_CONTEXT}} - Project segments with both source and target (for proofreading)
+        - {{SOURCE_CONTEXT}} - Project segments with source only (for translation questions)
+        - {{TARGET_CONTEXT}} - Project segments with target only (for consistency/style analysis)
+        """
         if not hasattr(self, 'prompt_manager_qt') or not self.prompt_manager_qt:
             raise RuntimeError("Prompt manager not available")
 
@@ -37581,25 +37823,114 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         if not prompt_content:
             raise RuntimeError("Prompt content is empty")
 
-        mode = getattr(pm, 'current_mode', None) or "single"
-        system_template = pm.get_system_template(mode)
-
-        system_template = system_template.replace("{{SOURCE_LANGUAGE}}", source_lang)
-        system_template = system_template.replace("{{TARGET_LANGUAGE}}", target_lang)
-        system_template = system_template.replace("{{SOURCE_TEXT}}", source_text)
-
-        library_prompts = "\n\n# PRIMARY INSTRUCTIONS\n\n" + prompt_content
-
-        # Keep any globally attached prompts as additional instructions
+        # Build document context if requested (three variants)
+        source_target_context = ""
+        source_only_context = ""
+        target_only_context = ""
+        
+        has_source_target = "{{SOURCE+TARGET_CONTEXT}}" in prompt_content
+        has_source_only = "{{SOURCE_CONTEXT}}" in prompt_content
+        has_target_only = "{{TARGET_CONTEXT}}" in prompt_content
+        
+        if (has_source_target or has_source_only or has_target_only) and hasattr(self, 'current_project') and self.current_project:
+            if has_source_target:
+                source_target_context = self._build_quickmenu_document_context(mode="both")
+                self.log(f"🔍 QuickMenu: Built SOURCE+TARGET context ({len(source_target_context)} chars)")
+            if has_source_only:
+                source_only_context = self._build_quickmenu_document_context(mode="source")
+                self.log(f"🔍 QuickMenu: Built SOURCE_ONLY context ({len(source_only_context)} chars)")
+            if has_target_only:
+                target_only_context = self._build_quickmenu_document_context(mode="target")
+                self.log(f"🔍 QuickMenu: Built TARGET_ONLY context ({len(target_only_context)} chars)")
+        else:
+            if has_source_target:
+                self.log("⚠️ QuickMenu: {{SOURCE+TARGET_CONTEXT}} requested but no project loaded")
+            if has_source_only:
+                self.log("⚠️ QuickMenu: {{SOURCE_CONTEXT}} requested but no project loaded")
+            if has_target_only:
+                self.log("⚠️ QuickMenu: {{TARGET_CONTEXT}} requested but no project loaded")
+
+        # Replace placeholders in the prompt content
+        prompt_content = prompt_content.replace("{{SOURCE_LANGUAGE}}", source_lang)
+        prompt_content = prompt_content.replace("{{TARGET_LANGUAGE}}", target_lang)
+        prompt_content = prompt_content.replace("{{SOURCE_TEXT}}", source_text)
+        prompt_content = prompt_content.replace("{{SELECTION}}", source_text)  # Alternative placeholder
+        prompt_content = prompt_content.replace("{{SOURCE+TARGET_CONTEXT}}", source_target_context)
+        prompt_content = prompt_content.replace("{{SOURCE_CONTEXT}}", source_only_context)
+        prompt_content = prompt_content.replace("{{TARGET_CONTEXT}}", target_only_context)
+        
+        # Debug: Log the final prompt being sent
+        self.log(f"📝 QuickMenu: Final prompt ({len(prompt_content)} chars):")
+        self.log("─" * 80)
+        self.log(prompt_content[:500] + ("..." if len(prompt_content) > 500 else ""))
+        self.log("─" * 80)
+        
+        # If the prompt doesn't contain the selection/text, append it
+        if "{{SOURCE_TEXT}}" not in prompt_data.get('content', '') and "{{SELECTION}}" not in prompt_data.get('content', ''):
+            prompt_content += f"\n\nText:\n{source_text}"
+        
+        return prompt_content
+    
+    def _build_quickmenu_document_context(self, mode: str = "both") -> str:
+        """Build document context for QuickMenu prompts.
+        
+        Args:
+            mode: One of:
+                - "both": Include both source and target text (for proofreading)
+                - "source": Include only source text (for translation/terminology questions)
+                - "target": Include only target text (for consistency/style analysis)
+        
+        Returns a formatted string with segments from the project for context.
+        Uses the 'quickmenu_context_segments' setting (default: 50% of total segments).
+        """
+        if not hasattr(self, 'current_project') or not self.current_project or not self.current_project.segments:
+            return "(No project context available)"
+        
         try:
-            for attached_content in lib.attached_prompts:
-                library_prompts += "\n\n# ADDITIONAL INSTRUCTIONS\n\n" + (attached_content or "")
-        except Exception:
-            pass
-
-        final_prompt = system_template + library_prompts
-        final_prompt += "\n\n**YOUR TRANSLATION (provide ONLY the translated text, no numbering or labels):**\n"
-        return final_prompt
+            # Get settings
+            general_prefs = self.load_general_settings()
+            context_percent = general_prefs.get('quickmenu_context_percent', 50)  # Default: 50%
+            max_context_segments = general_prefs.get('quickmenu_context_max', 100)  # Safety limit
+            
+            # Calculate how many segments to include
+            total_segments = len(self.current_project.segments)
+            num_segments = min(
+                int(total_segments * context_percent / 100),
+                max_context_segments
+            )
+            
+            if num_segments == 0:
+                return "(Document context disabled)"
+            
+            # Get segments (from start of document)
+            context_segments = self.current_project.segments[:num_segments]
+            
+            # Format segments based on mode
+            context_parts = []
+            mode_labels = {"both": "SOURCE + TARGET", "source": "SOURCE ONLY", "target": "TARGET ONLY"}
+            context_parts.append(f"=== DOCUMENT CONTEXT ({mode_labels.get(mode, 'UNKNOWN')}) ===")
+            context_parts.append(f"(Showing {num_segments} of {total_segments} segments - {context_percent}%)")
+            context_parts.append("")
+            
+            for seg in context_segments:
+                if mode == "both":
+                    # Source + Target
+                    context_parts.append(f"[{seg.id}] {seg.source}")
+                    if seg.target and seg.target.strip():
+                        context_parts.append(f"    → {seg.target}")
+                elif mode == "source":
+                    # Source only
+                    context_parts.append(f"[{seg.id}] {seg.source}")
+                elif mode == "target":
+                    # Target only (skip empty targets)
+                    if seg.target and seg.target.strip():
+                        context_parts.append(f"[{seg.id}] {seg.target}")
+                context_parts.append("")  # Blank line between segments
+            
+            return "\n".join(context_parts)
+            
+        except Exception as e:
+            return f"(Error building document context: {e})"
 
     def _quickmenu_show_result_dialog(self, title: str, output_text: str, apply_callback=None):
         from PyQt6.QtWidgets import QDialog, QVBoxLayout, QTextEdit, QDialogButtonBox, QPushButton, QApplication
@@ -37679,10 +38010,14 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             )
 
             client = LLMClient(api_key=api_key, provider=provider, model=model)
+            
+            # Use translate() with empty text and custom_prompt for generic AI completion
+            # This allows QuickMenu prompts to do anything (explain, define, search, etc.)
+            # not just translation. Same pattern as AI Assistant.
             output_text = client.translate(
-                text=input_text,
-                source_lang=source_lang,
-                target_lang=target_lang,
+                text="",  # Empty - we're using custom_prompt for everything
+                source_lang="en",  # Dummy values
+                target_lang="en",
                 custom_prompt=custom_prompt
             )
 
@@ -44268,7 +44603,7 @@ class SuperlookupTab(QWidget):
                 try:
                     # Use multiple methods to ensure cleanup
                     # Method 1: Kill by window title
-                    subprocess.run(['taskkill', '/F', '/FI', 'WINDOWTITLE eq superlookup_hotkey.ahk*'],
+                    subprocess.run(['taskkill', '/F', '/FI', 'WINDOWTITLE eq supervertaler_hotkeys.ahk*'],
                                  capture_output=True, creationflags=subprocess.CREATE_NO_WINDOW)
                     
                     # Method 2: Kill AutoHotkey processes more aggressively
@@ -44280,7 +44615,7 @@ class SuperlookupTab(QWidget):
                     try:
                         for proc in psutil.process_iter(['pid', 'name', 'cmdline']):
                             try:
-                                if 'superlookup_hotkey' in ' '.join(proc.cmdline() or []):
+                                if 'supervertaler_hotkeys' in ' '.join(proc.cmdline() or []):
                                     proc.kill()
                             except:
                                 pass
@@ -44293,8 +44628,8 @@ class SuperlookupTab(QWidget):
             ahk_exe, source = self._find_autohotkey_executable()
             
             if not ahk_exe:
-                print("[Superlookup] AutoHotkey not found.")
-                print("[Superlookup] Global hotkey (Ctrl+Alt+L) will not be available.")
+                print("[Hotkeys] AutoHotkey not found.")
+                print("[Hotkeys] Global hotkeys (Ctrl+Alt+L, Shift+Shift) will not be available.")
                 self.hotkey_registered = False
                 # Show setup dialog (deferred to avoid blocking startup) - unless user opted out
                 if self.main_window and hasattr(self.main_window, 'general_settings'):
@@ -44304,11 +44639,11 @@ class SuperlookupTab(QWidget):
                     QTimer.singleShot(2000, self._show_autohotkey_setup_dialog)
                 return
             
-            print(f"[Superlookup] Found AutoHotkey at: {ahk_exe} (source: {source})")
+            print(f"[Hotkeys] Found AutoHotkey at: {ahk_exe} (source: {source})")
             
-            ahk_script = Path(__file__).parent / "superlookup_hotkey.ahk"
-            print(f"[Superlookup] Looking for script at: {ahk_script}")
-            print(f"[Superlookup] Script exists: {ahk_script.exists()}")
+            ahk_script = Path(__file__).parent / "supervertaler_hotkeys.ahk"
+            print(f"[Hotkeys] Looking for script at: {ahk_script}")
+            print(f"[Hotkeys] Script exists: {ahk_script.exists()}")
             
             if ahk_script.exists():
                 # Start AHK script in background (hidden)
@@ -44316,16 +44651,16 @@ class SuperlookupTab(QWidget):
                                                    creationflags=subprocess.CREATE_NO_WINDOW if os.name == 'nt' else 0)
                 # Store in global variable for atexit cleanup
                 _ahk_process = self.ahk_process
-                print(f"[Superlookup] AHK hotkey registered: Ctrl+Alt+L")
+                print(f"[Hotkeys] AHK hotkeys registered (Ctrl+Alt+L, Shift+Shift)")
                 
                 # Start file watcher
                 self.start_file_watcher()
                 self.hotkey_registered = True
             else:
-                print(f"[Superlookup] AHK script not found: {ahk_script}")
+                print(f"[Hotkeys] AHK script not found: {ahk_script}")
                 self.hotkey_registered = False
         except Exception as e:
-            print(f"[Superlookup] Could not start AHK hotkey: {e}")
+            print(f"[Hotkeys] Could not start AHK hotkeys: {e}")
             self.hotkey_registered = False
     
     def start_file_watcher(self):