supervertaler 1.9.116__py3-none-any.whl → 1.9.130__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.130"
 __phase__ = "0.9"
-__release_date__ = "2026-01-18"
+__release_date__ = "2026-01-19"
 __edition__ = "Qt"
 
 import sys
@@ -123,7 +123,7 @@ 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
@@ -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,24 @@ 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)
+    
+    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 refresh_shortcut_enabled_states(self):
         """Refresh enabled/disabled states and key bindings of all global shortcuts from shortcut manager.
@@ -10836,6 +10863,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 +14015,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 +14198,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 +17197,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 +17257,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 +28307,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 +28342,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 +28387,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 +31157,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 +31625,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 +31644,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 +31678,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 +31997,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 +32070,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 +37734,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 +37763,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 +37950,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 +44543,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 +44555,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 +44568,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 +44579,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 +44591,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):