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

Supervertaler.py

@@ -3,8 +3,8 @@ Supervertaler
 =============
 The Ultimate Translation Workbench.
 Modern PyQt6 interface with specialised modules to handle any problem.
-Version: 1.9.123 (QuickMenu now supports generic AI tasks)
-Release Date: January 19, 2026
+Version: 1.9.136 (Glossary matching fix for punctuation)
+Release Date: January 20, 2026
 Framework: PyQt6
 
 This is the modern edition of Supervertaler using PyQt6 framework.
@@ -34,9 +34,9 @@ License: MIT
 """
 
 # Version Information.
-__version__ = "1.9.132"
+__version__ = "1.9.146"
 __phase__ = "0.9"
-__release_date__ = "2026-01-19"
+__release_date__ = "2026-01-20"
 __edition__ = "Qt"
 
 import sys
@@ -59,6 +59,24 @@ def get_resource_path(relative_path: str) -> Path:
         # Running in development
         base_path = Path(__file__).parent
     return base_path / relative_path
+
+
+def get_user_data_path() -> Path:
+    """
+    Get the path to user data directory.
+    
+    In frozen builds (EXE): 'user_data' folder next to the EXE
+    In development: 'user_data' folder next to the script
+    
+    The build process copies user_data directly next to the EXE for easy access.
+    """
+    if getattr(sys, 'frozen', False):
+        # Frozen build: user_data is next to the EXE (copied by build script)
+        return Path(sys.executable).parent / "user_data"
+    else:
+        # Development: user_data next to script
+        return Path(__file__).parent / "user_data"
+
 import threading
 import time  # For delays in Superlookup
 import re
@@ -126,7 +144,7 @@ try:
         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, QCursor
+    from PyQt6.QtGui import QFont, QAction, QKeySequence, QIcon, QTextOption, QColor, QDesktopServices, QTextCharFormat, QTextCursor, QBrush, QSyntaxHighlighter, QPalette, QTextBlockFormat, QCursor, QFontMetrics
     from PyQt6.QtWidgets import QStyleOptionViewItem, QStyle
     from PyQt6.QtCore import QRectF
     from PyQt6.QtNetwork import QNetworkAccessManager, QNetworkRequest, QNetworkReply
@@ -5146,9 +5164,26 @@ class SupervertalerQt(QMainWindow):
         # Superlookup detached window
         self.lookup_detached_window = None
         
-        # Database Manager for Termbases
+        # ============================================================================
+        # USER DATA PATH INITIALIZATION
+        # ============================================================================
+        # Set up user data paths - handles both development and frozen (EXE) builds
+        # In frozen builds, user_data is copied directly next to the EXE by the build script.
         from modules.database_manager import DatabaseManager
-        self.user_data_path = Path("user_data_private" if ENABLE_PRIVATE_FEATURES else "user_data")
+        
+        if ENABLE_PRIVATE_FEATURES:
+            # Developer mode: use private folder (git-ignored)
+            self.user_data_path = Path(__file__).parent / "user_data_private"
+        else:
+            # Normal mode: use the helper function
+            self.user_data_path = get_user_data_path()
+        
+        # Ensure user_data directory exists (creates empty folder if missing)
+        self.user_data_path.mkdir(parents=True, exist_ok=True)
+        
+        print(f"[Data Paths] User data: {self.user_data_path}")
+        
+        # Database Manager for Termbases
         self.db_manager = DatabaseManager(
             db_path=str(self.user_data_path / "Translation_Resources" / "supervertaler.db"),
             log_callback=self.log
@@ -5331,21 +5366,11 @@ class SupervertalerQt(QMainWindow):
                         self.settings_tabs.setCurrentIndex(i)
                         break
             
-            # Save the preference to ui_preferences.json (where load_general_settings reads from)
+            # Save the preference to general_settings.json (where load_general_settings reads from)
             if dont_show_checkbox.isChecked():
-                prefs_file = self.user_data_path / "ui_preferences.json"
-                prefs = {}
-                if prefs_file.exists():
-                    try:
-                        with open(prefs_file, 'r') as f:
-                            prefs = json.load(f)
-                    except:
-                        pass
-                if 'general_settings' not in prefs:
-                    prefs['general_settings'] = {}
-                prefs['general_settings']['first_run_completed'] = True
-                with open(prefs_file, 'w', encoding='utf-8') as f:
-                    json.dump(prefs, f, indent=2)
+                settings = self.load_general_settings()
+                settings['first_run_completed'] = True
+                self.save_general_settings(settings)
                 self.log("✅ First-run welcome completed (won't show again)")
             else:
                 self.log("✅ First-run welcome shown (will show again next time)")
@@ -10488,6 +10513,111 @@ class SupervertalerQt(QMainWindow):
                     f"Error testing segmentation:\n\n{e}"
                 )
     
+    def _refresh_termbase_display_for_current_segment(self):
+        """Refresh only termbase/glossary display for the current segment.
+        
+        This is a targeted refresh that does NOT trigger a TM search.
+        Use this after adding a term to a glossary to update the display
+        without the overhead of re-searching translation memories.
+        """
+        current_row = self.table.currentRow()
+        if current_row < 0 or not self.current_project:
+            return
+        
+        # Get the segment from the grid (use ID from cell, not row index)
+        id_item = self.table.item(current_row, 0)
+        if not id_item:
+            return
+        
+        try:
+            segment_id = int(id_item.text())
+        except (ValueError, AttributeError):
+            return
+        
+        segment = next((seg for seg in self.current_project.segments if seg.id == segment_id), None)
+        if not segment:
+            return
+        
+        # Clear only the termbase cache for this segment (NOT the TM cache)
+        with self.termbase_cache_lock:
+            if segment.id in self.termbase_cache:
+                del self.termbase_cache[segment.id]
+                self.log(f"🗑️ Cleared termbase cache for segment {segment.id}")
+        
+        # Search for fresh termbase matches
+        termbase_matches = self.find_termbase_matches_in_source(segment.source)
+        
+        # Update termbase cache
+        with self.termbase_cache_lock:
+            self.termbase_cache[segment.id] = termbase_matches
+        
+        # Update TermView widget
+        if hasattr(self, 'termview_widget') and self.termview_widget:
+            try:
+                # Convert termbase matches to list format for termview
+                # Note: find_termbase_matches_in_source returns dict with 'source' and 'translation' keys
+                termbase_list = [
+                    {
+                        'source_term': match.get('source', ''),  # 'source' not 'source_term'
+                        'target_term': match.get('translation', ''),  # 'translation' not 'target_term'
+                        'termbase_name': match.get('termbase_name', ''),
+                        'ranking': match.get('ranking', 99),
+                        'is_project_termbase': match.get('is_project_termbase', False),
+                        'term_id': match.get('term_id'),
+                        'termbase_id': match.get('termbase_id'),
+                        'notes': match.get('notes', '')
+                    }
+                    for match in termbase_matches.values() if isinstance(match, dict)
+                ] if isinstance(termbase_matches, dict) else []
+                
+                # Get NT matches
+                nt_matches = self.find_nt_matches_in_source(segment.source)
+                self.termview_widget.update_with_matches(segment.source, termbase_list, nt_matches)
+            except Exception as e:
+                self.log(f"Error updating termview: {e}")
+        
+        # Update Translation Results panel termbase section (without touching TM)
+        if hasattr(self, 'results_panels'):
+            for panel in self.results_panels:
+                try:
+                    # Get the existing matches from the panel and update only Termbases
+                    if hasattr(panel, 'current_matches') and panel.current_matches:
+                        # Convert termbase matches to TranslationMatch format
+                        # Note: find_termbase_matches_in_source returns 'source' and 'translation' keys
+                        from modules.translation_results_panel import TranslationMatch
+                        tb_matches = []
+                        for match_data in termbase_matches.values():
+                            if isinstance(match_data, dict):
+                                tb_match = TranslationMatch(
+                                    source=match_data.get('source', ''),  # 'source' not 'source_term'
+                                    target=match_data.get('translation', ''),  # 'translation' not 'target_term'
+                                    relevance=100.0,
+                                    match_type='Termbase',
+                                    provider=match_data.get('termbase_name', 'Glossary'),
+                                    metadata={
+                                        'termbase_name': match_data.get('termbase_name', ''),
+                                        'ranking': match_data.get('ranking', 99),
+                                        'is_project_termbase': match_data.get('is_project_termbase', False),
+                                        'term_id': match_data.get('term_id'),
+                                        'termbase_id': match_data.get('termbase_id'),
+                                        'notes': match_data.get('notes', '')
+                                    }
+                                )
+                                tb_matches.append(tb_match)
+                        
+                        # Update just the Termbases section
+                        panel.current_matches['Termbases'] = tb_matches
+                        panel.set_matches(panel.current_matches)
+                except Exception as e:
+                    self.log(f"Error updating results panel termbases: {e}")
+        
+        # Re-highlight termbase matches in the source cell
+        source_widget = self.table.cellWidget(current_row, 2)
+        if source_widget and hasattr(source_widget, 'rehighlight'):
+            source_widget.rehighlight()
+        
+        self.log(f"🔄 Refreshed termbase display for segment {segment.id} (TM untouched)")
+    
     def add_term_pair_to_termbase(self, source_text: str, target_text: str):
         """Add a term pair to active termbase(s) with metadata dialog"""
         # Check if we have a current project
@@ -10628,26 +10758,8 @@ class SupervertalerQt(QMainWindow):
 
             QMessageBox.information(self, "Term Added", f"Successfully added term pair to {success_count} glossary(s):\\n\\nSource: {source_text}\\nTarget: {target_text}\\n\\nDomain: {metadata['domain'] or '(none)'}")
             
-            # Refresh translation results to show new termbase match immediately
-            current_row = self.table.currentRow()
-            if current_row >= 0 and current_row < len(self.current_project.segments):
-                segment = self.current_project.segments[current_row]
-                
-                # Clear BOTH caches for this segment to force refresh
-                with self.translation_matches_cache_lock:
-                    if segment.id in self.translation_matches_cache:
-                        del self.translation_matches_cache[segment.id]
-                        self.log(f"🗑️ Cleared translation matches cache for segment {segment.id}")
-                
-                with self.termbase_cache_lock:
-                    if segment.id in self.termbase_cache:
-                        del self.termbase_cache[segment.id]
-                        self.log(f"🗑️ Cleared termbase cache for segment {segment.id}")
-                
-                # Trigger lookup refresh by simulating segment change
-                self._last_selected_row = -1  # Reset to force refresh
-                self.on_cell_selected(current_row, self.table.currentColumn(), -1, -1)
-                self.log(f"🔄 Triggered refresh for segment {segment.id}")
+            # Refresh termbase display (NOT TM - that would be wasteful)
+            self._refresh_termbase_display_for_current_segment()
             
             # IMPORTANT: Refresh the termbase list UI if it's currently open to update term counts
             # Find the termbase tab and call its refresh function
@@ -10767,23 +10879,8 @@ class SupervertalerQt(QMainWindow):
                 else:
                     self.statusBar().showMessage(f"✓ Added: {source_text} → {target_text} (to {success_count} termbases)", 3000)
             
-            # Refresh translation results to show new termbase match immediately
-            current_row = self.table.currentRow()
-            if current_row >= 0 and current_row < len(self.current_project.segments):
-                segment = self.current_project.segments[current_row]
-                
-                # Clear BOTH caches for this segment to force refresh
-                with self.translation_matches_cache_lock:
-                    if segment.id in self.translation_matches_cache:
-                        del self.translation_matches_cache[segment.id]
-                
-                with self.termbase_cache_lock:
-                    if segment.id in self.termbase_cache:
-                        del self.termbase_cache[segment.id]
-                
-                # Trigger lookup refresh by simulating segment change
-                self._last_selected_row = -1  # Reset to force refresh
-                self.on_cell_selected(current_row, self.table.currentColumn(), -1, -1)
+            # Refresh termbase display (NOT TM - that would be wasteful)
+            self._refresh_termbase_display_for_current_segment()
             
             # Refresh termbase list UI if open
             if hasattr(self, 'termbase_tab_refresh_callback') and self.termbase_tab_refresh_callback:
@@ -10902,17 +10999,8 @@ class SupervertalerQt(QMainWindow):
                 self.log(f"✓ Added to '{target_termbase['name']}': {source_text} → {target_text}")
                 self.statusBar().showMessage(f"✓ Added to '{target_termbase['name']}': {source_text} → {target_text}", 3000)
                 
-                # Refresh caches and display
-                if current_row < len(self.current_project.segments):
-                    segment = self.current_project.segments[current_row]
-                    with self.translation_matches_cache_lock:
-                        if segment.id in self.translation_matches_cache:
-                            del self.translation_matches_cache[segment.id]
-                    with self.termbase_cache_lock:
-                        if segment.id in self.termbase_cache:
-                            del self.termbase_cache[segment.id]
-                    self._last_selected_row = -1
-                    self.on_cell_selected(current_row, self.table.currentColumn(), -1, -1)
+                # Refresh termbase display (NOT TM - that would be wasteful)
+                self._refresh_termbase_display_for_current_segment()
                 
                 if hasattr(self, 'termbase_tab_refresh_callback') and self.termbase_tab_refresh_callback:
                     self.termbase_tab_refresh_callback()
@@ -14484,6 +14572,21 @@ class SupervertalerQt(QMainWindow):
         sound_event_combos['glossary_term_error'] = make_sound_combo(default_term_error)
         event_rows.addRow("Glossary add error:", sound_event_combos['glossary_term_error'])
 
+        # Segment confirmed (Ctrl+Enter)
+        default_segment_confirmed = sound_effects_map.get('segment_confirmed', 'none')
+        sound_event_combos['segment_confirmed'] = make_sound_combo(default_segment_confirmed)
+        event_rows.addRow("Segment confirmed:", sound_event_combos['segment_confirmed'])
+
+        # 100% TM match found
+        default_tm_100_match = sound_effects_map.get('tm_100_percent_match', 'none')
+        sound_event_combos['tm_100_percent_match'] = make_sound_combo(default_tm_100_match)
+        event_rows.addRow("100% TM match alert:", sound_event_combos['tm_100_percent_match'])
+
+        # Fuzzy TM match found (< 100%)
+        default_tm_fuzzy_match = sound_effects_map.get('tm_fuzzy_match', 'none')
+        sound_event_combos['tm_fuzzy_match'] = make_sound_combo(default_tm_fuzzy_match)
+        event_rows.addRow("Fuzzy TM match found:", sound_event_combos['tm_fuzzy_match'])
+
         sound_layout.addLayout(event_rows)
 
         sound_note = QLabel("💡 Uses Windows system beeps (no audio files).")
@@ -16139,7 +16242,7 @@ class SupervertalerQt(QMainWindow):
         # Update status bar indicator (always visible when active)
         if hasattr(self, 'alwayson_indicator_label'):
             if status == "listening" or status == "waiting":
-                self.alwayson_indicator_label.setText("🎤 VOICE ON")
+                self.alwayson_indicator_label.setText("🎤 VOICE COMMANDS ON")
                 self.alwayson_indicator_label.setStyleSheet("font-size: 11px; font-weight: bold; color: #2E7D32; background-color: #C8E6C9; padding: 2px 6px; border-radius: 3px;")
                 self.alwayson_indicator_label.setToolTip("Always-on voice listening ACTIVE\nClick to stop")
                 self.alwayson_indicator_label.show()
@@ -16159,7 +16262,7 @@ class SupervertalerQt(QMainWindow):
         # Update grid toolbar button (if exists)
         if hasattr(self, 'grid_alwayson_btn'):
             if status == "listening" or status == "waiting":
-                self.grid_alwayson_btn.setText("🎧 Voice ON")
+                self.grid_alwayson_btn.setText("🎧 Voice Commands ON")
                 self.grid_alwayson_btn.setChecked(True)
                 self.grid_alwayson_btn.setStyleSheet("""
                     QPushButton {
@@ -16202,7 +16305,7 @@ class SupervertalerQt(QMainWindow):
                     }
                 """)
             else:  # stopped or other
-                self.grid_alwayson_btn.setText("🎧 Voice OFF")
+                self.grid_alwayson_btn.setText("🎧 Voice Commands OFF")
                 self.grid_alwayson_btn.setChecked(False)
                 self.grid_alwayson_btn.setStyleSheet("""
                     QPushButton {
@@ -18264,14 +18367,14 @@ class SupervertalerQt(QMainWindow):
         preview_prompt_btn.clicked.connect(self._preview_combined_prompt_from_grid)
         toolbar_layout.addWidget(preview_prompt_btn)
         
-        dictate_btn = QPushButton("🎤 Dictate")
+        dictate_btn = QPushButton("🎤 Dictation")
         dictate_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold; padding: 4px 8px; 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)
         
         # Always-On Voice toggle button
-        alwayson_btn = QPushButton("🎧 Voice OFF")
+        alwayson_btn = QPushButton("🎧 Voice Commands OFF")
         alwayson_btn.setCheckable(True)
         alwayson_btn.setChecked(False)
         alwayson_btn.setStyleSheet("""
@@ -18542,9 +18645,11 @@ class SupervertalerQt(QMainWindow):
     def _apply_pagination_to_grid(self):
         """Show/hide rows based on current page, optionally constrained by active filters.
 
-        IMPORTANT: QTableWidget has only one hidden flag per row. Pagination and filtering
-        must be combined into a single visibility decision; otherwise switching pages can
-        accidentally unhide rows that filters intended to hide.
+        IMPORTANT: When a text filter is active (Filter Source/Target boxes), we show ALL
+        matching rows across the entire document, ignoring pagination. This ensures users
+        can find content regardless of which page they're on.
+        
+        When no filter is active, normal pagination applies.
         """
         if not self.current_project or not self.current_project.segments:
             return
@@ -18556,28 +18661,38 @@ class SupervertalerQt(QMainWindow):
         if not hasattr(self, 'grid_page_size'):
             self.grid_page_size = 50
         
-        # Calculate which rows should be visible
-        if self.grid_page_size >= 999999:
-            # "All" mode - show everything
-            start_row = 0
-            end_row = total_segments
-        else:
-            start_row = self.grid_current_page * self.grid_page_size
-            end_row = min(start_row + self.grid_page_size, total_segments)
-        
         # If a text filter (Filter Source/Target) is active, it will populate an allowlist
         # of row indices that are allowed to be visible.
         filter_allowlist = getattr(self, '_active_text_filter_rows', None)
-
-        # Batch show/hide for performance
-        self.table.setUpdatesEnabled(False)
-        try:
-            for row in range(total_segments):
-                in_page = start_row <= row < end_row
-                allowed_by_filter = True if filter_allowlist is None else (row in filter_allowlist)
-                self.table.setRowHidden(row, not (in_page and allowed_by_filter))
-        finally:
-            self.table.setUpdatesEnabled(True)
+        
+        # When a filter is active, show ALL matching rows (ignore pagination)
+        # When no filter is active, apply normal pagination
+        if filter_allowlist is not None:
+            # Filter mode: show all matching rows across the entire document
+            self.table.setUpdatesEnabled(False)
+            try:
+                for row in range(total_segments):
+                    self.table.setRowHidden(row, row not in filter_allowlist)
+            finally:
+                self.table.setUpdatesEnabled(True)
+        else:
+            # Normal pagination mode
+            if self.grid_page_size >= 999999:
+                # "All" mode - show everything
+                start_row = 0
+                end_row = total_segments
+            else:
+                start_row = self.grid_current_page * self.grid_page_size
+                end_row = min(start_row + self.grid_page_size, total_segments)
+            
+            # Batch show/hide for performance
+            self.table.setUpdatesEnabled(False)
+            try:
+                for row in range(total_segments):
+                    in_page = start_row <= row < end_row
+                    self.table.setRowHidden(row, not in_page)
+            finally:
+                self.table.setUpdatesEnabled(True)
         
         # Update pagination UI
         self._update_pagination_ui()
@@ -18860,11 +18975,12 @@ class SupervertalerQt(QMainWindow):
         header.setStretchLastSection(False)  # Don't auto-stretch last section (we use Stretch mode for Source/Target)
         
         # Set initial column widths - give Source and Target equal space
-        self.table.setColumnWidth(0, 40)   # ID - compact, fits up to 3 digits comfortably
+        # ID column width will be auto-adjusted by _update_segment_column_width() after segments load
+        self.table.setColumnWidth(0, 35)   # ID - temporary, auto-adjusts to fit content
         self.table.setColumnWidth(1, 40)   # Type - narrower
         self.table.setColumnWidth(2, 400)  # Source
         self.table.setColumnWidth(3, 400)  # Target
-        self.table.setColumnWidth(4, 70)   # Status
+        self.table.setColumnWidth(4, 60)   # Status - compact
         
         # Enable word wrap in cells (both display and edit mode)
         self.table.setWordWrap(True)
@@ -19162,7 +19278,7 @@ class SupervertalerQt(QMainWindow):
         clear_btn.clicked.connect(self.clear_tab_target)
 
         # Voice dictation button
-        dictate_btn = QPushButton("🎤 Dictate (F9)")
+        dictate_btn = QPushButton("🎤 Dictation (F9)")
         dictate_btn.setStyleSheet("background-color: #4CAF50; color: white; font-weight: bold;")
         dictate_btn.clicked.connect(self.start_voice_dictation)
         dictate_btn.setToolTip("Click or press F9 to start/stop voice dictation")
@@ -26998,33 +27114,65 @@ class SupervertalerQt(QMainWindow):
         self.set_compare_panel_matches(segment_id, current_source, tm_matches, mt_matches)
     
     def _set_compare_panel_text_with_diff(self, text_edit: QTextEdit, current: str, tm_source: str):
-        """Set text with diff highlighting (deletions in red, additions in green)"""
+        """
+        Set text with diff highlighting using memoQ-style track changes view:
+        - Normal text: identical to current
+        - Red underline: text added in current (insertion)
+        - Red strikethrough: text removed from TM (deletion)
+        
+        This displays the TM source annotated with tracked changes.
+        """
         import difflib
         
         text_edit.clear()
         cursor = text_edit.textCursor()
         
-        # Create formatters
+        # Create formatters - memoQ track changes style
         normal_format = QTextCharFormat()
+        
+        # Red strikethrough for deletions (text in TM but not in current)
         delete_format = QTextCharFormat()
-        delete_format.setBackground(QColor("#ffcccc"))  # Light red for deletions
-        delete_format.setForeground(QColor("#cc0000"))
+        delete_format.setForeground(QColor("#cc0000"))  # Red text
+        delete_format.setFontStrikeOut(True)
+        
+        # Red underline for insertions (text in current but not in TM)
+        add_format = QTextCharFormat()
+        add_format.setForeground(QColor("#cc0000"))  # Red text
+        add_format.setFontUnderline(True)
         
-        # Use SequenceMatcher to find differences
-        matcher = difflib.SequenceMatcher(None, current, tm_source)
+        # Use SequenceMatcher at word level for better readability
+        current_words = current.split()
+        tm_words = tm_source.split()
         
+        matcher = difflib.SequenceMatcher(None, current_words, tm_words)
+        
+        result_parts = []
         for tag, i1, i2, j1, j2 in matcher.get_opcodes():
             if tag == 'equal':
-                cursor.insertText(tm_source[j1:j2], normal_format)
+                # Same in both - show normally
+                result_parts.append(('normal', ' '.join(tm_words[j1:j2])))
             elif tag == 'replace':
-                # Show the TM text (what's different from current)
-                cursor.insertText(tm_source[j1:j2], delete_format)
+                # Different text - show TM version strikethrough, then current version underlined
+                result_parts.append(('delete', ' '.join(tm_words[j1:j2])))
+                result_parts.append(('add', ' '.join(current_words[i1:i2])))
             elif tag == 'insert':
-                # Text in TM but not in current
-                cursor.insertText(tm_source[j1:j2], delete_format)
+                # Text in TM but not in current - strikethrough (it was "deleted" from current's perspective)
+                result_parts.append(('delete', ' '.join(tm_words[j1:j2])))
             elif tag == 'delete':
-                # Text in current but not in TM - don't show in TM source box
-                pass
+                # Text in current but not in TM - underline (it was "inserted" in current)
+                result_parts.append(('add', ' '.join(current_words[i1:i2])))
+        
+        # Render the parts with proper spacing
+        for i, (part_type, text) in enumerate(result_parts):
+            if i > 0:
+                cursor.insertText(' ', normal_format)  # Space between parts
+            
+            if part_type == 'normal':
+                cursor.insertText(text, normal_format)
+            elif part_type == 'delete':
+                cursor.insertText(text, delete_format)
+            elif part_type == 'add':
+                cursor.insertText(text, add_format)
         
         text_edit.setTextCursor(cursor)
     
@@ -27642,6 +27790,37 @@ class SupervertalerQt(QMainWindow):
                 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()
+    
+    def _update_segment_column_width(self):
+        """Adjust segment number column width to fit the largest segment number.
+        
+        Uses font metrics to calculate exact width needed for the highest segment number.
+        """
+        if not hasattr(self, 'table') or not self.table:
+            return
+        
+        # Get the highest segment number we need to display
+        max_segment = self.table.rowCount()
+        if max_segment == 0:
+            max_segment = 1
+        
+        # Use font metrics to calculate exact width needed
+        font = QFont(self.default_font_family, self.default_font_size)
+        fm = QFontMetrics(font)
+        
+        # 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)
+        
+        self.table.setColumnWidth(0, new_width)
     
     def set_font_family(self, family_name: str):
         """Set font family from menu"""
@@ -28599,12 +28778,22 @@ class SupervertalerQt(QMainWindow):
                                     if best_match:
                                         self.log(f"✨ CACHE: Auto-inserting 100% TM match into segment {segment.id} at row {current_row}")
                                         self._auto_insert_tm_match(segment, best_match.target, current_row)
+                                        # Play 100% TM match alert sound
+                                        self._play_sound_effect('tm_100_percent_match')
                                     else:
                                         relevances = [(tm.relevance, type(tm.relevance).__name__) for tm in cached_matches.get("TM", [])]
                                         self.log(f"⚠️ CACHE: No 100% match found. All relevances: {relevances}")
                                 else:
                                     self.log(f"⚠️ CACHE: Target not empty ('{segment.target}') - skipping auto-insert")
                             
+                            # 🔊 Play fuzzy match sound if fuzzy matches found from cache (but not 100%)
+                            if tm_count > 0:
+                                tm_matches = cached_matches.get("TM", [])
+                                has_100_match = any(float(tm.relevance) >= 99.5 for tm in tm_matches)
+                                has_fuzzy_match = any(float(tm.relevance) < 99.5 and float(tm.relevance) >= 50 for tm in tm_matches)
+                                if has_fuzzy_match and not has_100_match:
+                                    self._play_sound_effect('tm_fuzzy_match')
+                            
                             # Skip the slow lookup below, we already have everything
                             # Continue to prefetch trigger at the end
                             matches_dict = cached_matches  # Set for later use
@@ -28634,29 +28823,29 @@ class SupervertalerQt(QMainWindow):
                                 # Store in cache for future access (thread-safe) - EVEN IF EMPTY
                                 with self.termbase_cache_lock:
                                     self.termbase_cache[segment_id] = stored_matches
-                                    
-                                # Update Termview with the newly cached matches
-                                if stored_matches and hasattr(self, 'termview_widget') and self.current_project:
-                                    try:
-                                        # Convert dict format to list format
-                                        termbase_matches = [
-                                            {
-                                                'source_term': match_data.get('source', ''),
-                                                'target_term': match_data.get('translation', ''),
-                                                'termbase_name': match_data.get('termbase_name', ''),
-                                                'ranking': match_data.get('ranking', 99),
-                                                'is_project_termbase': match_data.get('is_project_termbase', False),
-                                                'term_id': match_data.get('term_id'),
-                                                'termbase_id': match_data.get('termbase_id'),
-                                                'notes': match_data.get('notes', '')
-                                            }
-                                            for match_data in stored_matches.values()
-                                        ]
-                                        # Also get NT matches
-                                        nt_matches = self.find_nt_matches_in_source(segment.source)
-                                        self.termview_widget.update_with_matches(segment.source, termbase_matches, nt_matches)
-                                    except Exception as e:
-                                        self.log(f"Error refreshing termview: {e}")
+                            
+                            # CRITICAL FIX: Always update Termview (even with empty results) - show "No matches" state
+                            if hasattr(self, 'termview_widget') and self.current_project:
+                                try:
+                                    # Convert dict format to list format
+                                    termbase_matches = [
+                                        {
+                                            'source_term': match_data.get('source', ''),
+                                            'target_term': match_data.get('translation', ''),
+                                            'termbase_name': match_data.get('termbase_name', ''),
+                                            'ranking': match_data.get('ranking', 99),
+                                            'is_project_termbase': match_data.get('is_project_termbase', False),
+                                            'term_id': match_data.get('term_id'),
+                                            'termbase_id': match_data.get('termbase_id'),
+                                            'notes': match_data.get('notes', '')
+                                        }
+                                        for match_data in stored_matches.values()
+                                    ] if stored_matches else []
+                                    # Also get NT matches
+                                    nt_matches = self.find_nt_matches_in_source(segment.source)
+                                    self.termview_widget.update_with_matches(segment.source, termbase_matches, nt_matches)
+                                except Exception as e:
+                                    self.log(f"Error refreshing termview: {e}")
 
                             # Store in widget for backwards compatibility
                             if source_widget and hasattr(source_widget, 'termbase_matches'):
@@ -29625,12 +29814,13 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             from modules.llm_clients import LLMClient
             
             # Get appropriate API key for provider
+            # Note: api_keys is normalized so both 'gemini' and 'google' exist if either is set
             if provider == 'openai':
                 api_key = api_keys.get('openai', '')
-            elif provider == 'anthropic':
+            elif provider == 'claude':
                 api_key = api_keys.get('claude', '')
-            elif provider == 'google':
-                api_key = api_keys.get('google', '')
+            elif provider == 'gemini':
+                api_key = api_keys.get('gemini', '')
             elif provider == 'ollama':
                 api_key = ''  # Ollama doesn't need an API key
             else:
@@ -31168,8 +31358,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             
             # Comprehensive set of quote and punctuation characters to strip
             # Includes: straight quotes, curly quotes (left/right), German quotes, guillemets, single quotes
+            # ALSO includes parentheses, brackets, and braces for terms like "(typisch)" or "[example]"
             # Using explicit characters to avoid encoding issues
-            PUNCT_CHARS = '.,!?;:\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A'
+            PUNCT_CHARS = '.,!?;:\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A()[]{}' 
             
             for word in words:
                 # Remove punctuation including quotes (preserve internal punctuation like "gew.%")
@@ -31184,13 +31375,26 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                 # Get project ID for termbase priority lookup
                 project_id = self.current_project.id if self.current_project and hasattr(self.current_project, 'id') else None
                 
-                termbase_results = self.db_manager.search_termbases(
-                    clean_word,
-                    source_lang=source_lang_code,
-                    target_lang=target_lang_code,
-                    project_id=project_id,
-                    min_length=2
-                )
+                # CRITICAL FIX: Search for BOTH the cleaned word AND the original word with punctuation
+                # This allows glossary entries like "ca." to match source text "ca." where
+                # the tokenized/cleaned version is "ca" but the glossary entry has the period
+                words_to_search = [clean_word]
+                # Also try searching with trailing punctuation (for entries like "ca.", "gew.%")
+                original_word_stripped_leading = word.lstrip(PUNCT_CHARS)
+                if original_word_stripped_leading != clean_word and len(original_word_stripped_leading) >= 2:
+                    words_to_search.append(original_word_stripped_leading)
+                
+                termbase_results = []
+                for search_word in words_to_search:
+                    results = self.db_manager.search_termbases(
+                        search_word,
+                        source_lang=source_lang_code,
+                        target_lang=target_lang_code,
+                        project_id=project_id,
+                        min_length=2
+                    )
+                    if results:
+                        termbase_results.extend(results)
                 
                 if termbase_results:
                     for result in termbase_results:
@@ -35650,6 +35854,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
 
         self.update_progress_stats()
 
+        # Play sound effect for segment confirmation
+        self._play_sound_effect('segment_confirmed')
+
         if segment.target and segment.target.strip():
             try:
                 self.save_segment_to_activated_tms(segment.source, segment.target)
@@ -35857,17 +36064,15 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             )
             
             if reply == QMessageBox.StandardButton.Yes:
-                if self.db_manager:
+                if self.termbase_mgr:
                     try:
-                        conn = self.db_manager.get_connection()
-                        cursor = conn.cursor()
-                        cursor.execute("DELETE FROM termbase_terms WHERE id = ?", (term_id,))
-                        conn.commit()
-                        
-                        self.log(f"✓ Deleted glossary entry: {source_term} → {target_term}")
-                        
-                        # Refresh termview and translation results
-                        self._refresh_current_segment_matches()
+                        if self.termbase_mgr.delete_term(term_id):
+                            self.log(f"✓ Deleted glossary entry: {source_term} → {target_term}")
+                            
+                            # Refresh termview and translation results
+                            self._refresh_current_segment_matches()
+                        else:
+                            self.log(f"✗ Failed to delete glossary entry")
                     except Exception as e:
                         self.log(f"✗ Error deleting glossary entry from database: {e}")
         except Exception as e:
@@ -35876,23 +36081,8 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
     def _refresh_current_segment_matches(self):
         """Refresh termbase matches for the current segment (after edit/delete)"""
         try:
-            current_row = self.table.currentRow()
-            if current_row >= 0 and self.current_project and self.current_project.segments:
-                # Get the actual segment index
-                segment_idx = current_row
-                if hasattr(self, 'current_page') and hasattr(self, 'items_per_page'):
-                    segment_idx = (self.current_page - 1) * self.items_per_page + current_row
-                
-                if 0 <= segment_idx < len(self.current_project.segments):
-                    segment = self.current_project.segments[segment_idx]
-                    
-                    # Clear termbase cache for this segment
-                    segment_id = id(segment)
-                    if hasattr(self, 'termbase_cache') and segment_id in self.termbase_cache:
-                        del self.termbase_cache[segment_id]
-                    
-                    # Trigger refresh by re-selecting the cell
-                    self.on_cell_selected(current_row, 2)
+            # Use the targeted refresh method that doesn't trigger TM search
+            self._refresh_termbase_display_for_current_segment()
         except Exception as e:
             self.log(f"✗ Error refreshing segment matches: {e}")
     
@@ -35999,41 +36189,8 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                 except Exception as e:
                     self.log(f"Error updating tabbed panel: {e}")
         
-        # Update Termview widget - pass termbase matches from Translation Results
-        if hasattr(self, 'termview_widget') and self.current_project:
-            try:
-                # Get termbase matches from the segment's cached data if available
-                termbase_matches = []
-                if hasattr(self, 'termbase_cache') and segment_id in self.termbase_cache:
-                    cached_matches = self.termbase_cache[segment_id]
-                    
-                    # Convert dict format to list format expected by Termview
-                    if isinstance(cached_matches, dict):
-                        termbase_matches = [
-                            {
-                                'source_term': source_key,  # Use dict key as source term
-                                'target_term': match_data.get('translation', ''),
-                                'termbase_name': match_data.get('termbase_name', ''),
-                                'ranking': match_data.get('ranking', 99),
-                                'is_project_termbase': match_data.get('is_project_termbase', False),
-                                'target_synonyms': match_data.get('target_synonyms', []),
-                                'term_id': match_data.get('term_id'),
-                                'termbase_id': match_data.get('termbase_id')
-                            }
-                            for source_key, match_data in cached_matches.items()
-                        ]
-                    else:
-                        # Already in list format (shouldn't happen, but handle it)
-                        termbase_matches = cached_matches
-                
-                # Also get NT matches
-                nt_matches = self.find_nt_matches_in_source(source_text)
-                
-                self.termview_widget.update_with_matches(source_text, termbase_matches, nt_matches)
-            except Exception as e:
-                self.log(f"Error updating termview: {e}")
-                import traceback
-                self.log(f"Traceback: {traceback.format_exc()}")
+        # NOTE: Termview is updated AFTER termbase search completes in _on_cell_selected_full
+        # Do NOT update Termview here - the cache may not be populated yet
     
     # ========================================================================
     # UTILITY
@@ -37440,7 +37597,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                 return
             
             # Check if API key exists for selected provider
-            if provider not in api_keys:
+            # Note: 'gemini' and 'google' are aliases for the same API key
+            has_api_key = provider in api_keys or (provider == 'gemini' and 'google' in api_keys)
+            if not has_api_key:
                 reply = QMessageBox.question(
                     self, f"{provider.title()} API Key Missing",
                     f"{provider.title()} API key not found in api_keys.txt\n\n"
@@ -37519,8 +37678,10 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             # Use modular LLM client with user's settings
             from modules.llm_clients import LLMClient
             
+            # Get API key (handle gemini/google alias)
+            api_key = api_keys.get(provider) or (api_keys.get('google') if provider == 'gemini' else None)
             client = LLMClient(
-                api_key=api_keys[provider],
+                api_key=api_key,
                 provider=provider,
                 model=model
             )
@@ -38512,7 +38673,8 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                         "Please configure your API keys in Settings first."
                     )
                     return
-                elif llm_provider not in api_keys:
+                # Note: 'gemini' and 'google' are aliases for the same API key
+                elif llm_provider not in api_keys and not (llm_provider == 'gemini' and 'google' in api_keys):
                     QMessageBox.critical(
                         self, f"{llm_provider.title()} API Key Missing",
                         f"Please configure your {llm_provider.title()} API key in Settings."
@@ -38761,8 +38923,10 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
 
             if translation_provider_type == 'LLM':
                 from modules.llm_clients import LLMClient
+                # Handle gemini/google alias
+                api_key = api_keys.get(translation_provider_name) or (api_keys.get('google') if translation_provider_name == 'gemini' else None)
                 client = LLMClient(
-                    api_key=api_keys[translation_provider_name],
+                    api_key=api_key,
                     provider=translation_provider_name,
                     model=model
                 )
@@ -39288,7 +39452,9 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
             "gemini": "gemini"
         }
         api_key_name = provider_key_map.get(provider)
-        if not api_keys.get(api_key_name):
+        # Handle gemini/google alias
+        api_key_value = api_keys.get(api_key_name) or (api_keys.get('google') if provider == 'gemini' else None)
+        if not api_key_value:
             return  # No API key for selected provider
         
         # Get model based on provider
@@ -39310,7 +39476,7 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                 from modules.translation_results_panel import TranslationMatch
                 
                 client = LLMClient(
-                    api_key=api_keys[api_key_name],
+                    api_key=api_key_value,
                     provider=provider,
                     model=model
                 )
@@ -39800,6 +39966,13 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
         except Exception as e:
             self.log(f"⚠ Error loading API keys: {str(e)}")
         
+        # Normalize gemini/google aliases - users can use either name
+        # This allows downstream code to just use api_keys.get('gemini') directly
+        if api_keys.get('google') and not api_keys.get('gemini'):
+            api_keys['gemini'] = api_keys['google']
+        elif api_keys.get('gemini') and not api_keys.get('google'):
+            api_keys['google'] = api_keys['gemini']
+        
         return api_keys
     
     def ensure_example_api_keys(self):
@@ -40447,6 +40620,14 @@ OUTPUT ONLY THE SEGMENT MARKERS. DO NOT ADD EXPLANATIONS BEFORE OR AFTER."""
                                 
                                 if best_match:
                                     self._auto_insert_tm_match(segment, best_match.target, None)  # Let function find row
+                                    # Play 100% TM match alert sound
+                                    self._play_sound_effect('tm_100_percent_match')
+                        
+                        # 🔊 Play fuzzy match sound if fuzzy matches found (but not 100%)
+                        has_100_match = any(float(tm.relevance) >= 99.5 for tm in matches_dict["TM"])
+                        has_fuzzy_match = any(float(tm.relevance) < 99.5 and float(tm.relevance) >= 50 for tm in matches_dict["TM"])
+                        if has_fuzzy_match and not has_100_match:
+                            self._play_sound_effect('tm_fuzzy_match')
                 except Exception as e:
                     self.log(f"Error in delayed TM search: {e}")
             

modules/database_manager.py

@@ -1312,6 +1312,10 @@ class DatabaseManager:
         # Note: termbase_id is stored as TEXT in termbase_terms but INTEGER in termbases
         # Use CAST to ensure proper comparison
         # IMPORTANT: Join with termbase_activation to get the ACTUAL priority for this project
+        # CRITICAL FIX: Also match when search_term starts with the glossary term
+        # This handles cases like searching for "ca." when glossary has "ca." 
+        # AND searching for "ca" when glossary has "ca."
+        # We also strip trailing punctuation from glossary terms for comparison
         query = """
             SELECT 
                 t.id, t.source_term, t.target_term, t.termbase_id, t.priority, 
@@ -1329,19 +1333,30 @@ class DatabaseManager:
                 LOWER(t.source_term) = LOWER(?) OR 
                 LOWER(t.source_term) LIKE LOWER(?) OR 
                 LOWER(t.source_term) LIKE LOWER(?) OR 
-                LOWER(t.source_term) LIKE LOWER(?)
+                LOWER(t.source_term) LIKE LOWER(?) OR
+                LOWER(RTRIM(t.source_term, '.!?,;:')) = LOWER(?) OR
+                LOWER(?) LIKE LOWER(t.source_term) || '%' OR
+                LOWER(?) = LOWER(RTRIM(t.source_term, '.!?,;:'))
             )
             AND (ta.is_active = 1 OR tb.is_project_termbase = 1)
         """
-        # Exact match, word at start, word at end, word in middle
-        # Use LOWER() for case-insensitive matching (handles "Edelmetalen" = "edelmetalen")
-        # IMPORTANT: project_id must be first param for the LEFT JOIN ta.project_id = ? above
+        # Matching patterns:
+        # 1. Exact match: source_term = search_term
+        # 2. Glossary term starts with search: source_term LIKE "search_term %"
+        # 3. Glossary term ends with search: source_term LIKE "% search_term"
+        # 4. Glossary term contains search: source_term LIKE "% search_term %"
+        # 5. Glossary term (stripped) = search_term: RTRIM(source_term) = search_term (handles "ca." = "ca")
+        # 6. Search starts with glossary term: search_term LIKE source_term || '%' 
+        # 7. Search = glossary term stripped: search_term = RTRIM(source_term)
         params = [
             project_id if project_id else 0,  # Use 0 if no project (won't match any activation records)
             search_term,
             f"{search_term} %",
             f"% {search_term}",
-            f"% {search_term} %"
+            f"% {search_term} %",
+            search_term,  # For RTRIM comparison
+            search_term,  # For reverse LIKE
+            search_term   # For reverse RTRIM comparison
         ]
         
         # Language filters - if term has no language, use termbase language for filtering

modules/termview_widget.py

@@ -750,7 +750,10 @@ class TermviewWidget(QWidget):
                 if not source_term or not target_term:
                     continue
                 
-                key = source_term.lower()
+                # Strip punctuation from key to match lookup normalization
+                # This ensures "ca." in glossary matches "ca." token stripped to "ca"
+                PUNCT_CHARS_FOR_KEY = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A()[]'
+                key = source_term.lower().strip(PUNCT_CHARS_FOR_KEY)
                 if key not in matches_dict:
                     matches_dict[key] = []
                 
@@ -803,7 +806,8 @@ class TermviewWidget(QWidget):
         
         # Comprehensive set of quote and punctuation characters to strip
         # Using Unicode escapes to avoid encoding issues
-        PUNCT_CHARS = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A'
+        # Include brackets for terms like "(typisch)" to match "typisch"
+        PUNCT_CHARS = '.,;:!?\"\'\u201C\u201D\u201E\u00AB\u00BB\u2018\u2019\u201A\u2039\u203A()[]'
         
         # Track which terms have already been assigned shortcuts (avoid duplicates)
         assigned_shortcuts = set()

{supervertaler-1.9.132.dist-info → supervertaler-1.9.146.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: supervertaler
-Version: 1.9.132
+Version: 1.9.146
 Summary: Professional AI-powered translation workbench with multi-LLM support, glossary system, TM, spellcheck, voice commands, and PyQt6 interface. Batteries included (core).
 Home-page: https://supervertaler.com
 Author: Michael Beijer
@@ -71,7 +71,7 @@ Dynamic: home-page
 Dynamic: license-file
 Dynamic: requires-python
 
-# 🚀 Supervertaler v1.9.128
+# 🚀 Supervertaler v1.9.146
 
 [![PyPI version](https://badge.fury.io/py/supervertaler.svg)](https://pypi.org/project/Supervertaler/)
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
@@ -79,7 +79,27 @@ Dynamic: requires-python
 
 AI-enhanced CAT tool with multi-LLM support (GPT-4, Claude, Gemini, Ollama), innovative Superlookup concordance system offering access to multiple terminology sources (TMs, glossaries, web resources, etc.), and seamless CAT tool integration (memoQ, Trados, CafeTran, Phrase).
 
-**Current Version:** v1.9.132 (January 20, 2026)
+**Current Version:** v1.9.146 (January 21, 2026)
+
+### FIXED in v1.9.146 - 🔑 Gemini/Google API Key Alias
+
+**Bug Fix:** Fixed "Gemini API Key Missing" error when users had `google=...` instead of `gemini=...` in their api_keys.txt. Both names now work identically thanks to automatic normalization at load time.
+
+### FIXED in v1.9.140 - 🐛 Glossary Add No Longer Triggers TM Search
+
+**Performance Fix ([#118](https://github.com/michaelbeijer/Supervertaler/issues/118)):** Adding a term to a glossary was unnecessarily triggering a full TM search. Now uses targeted refresh that only updates glossary display - TM results stay cached.
+
+**Also:** Renamed "Voice OFF" → "Voice Commands OFF" and "Dictate" → "Dictation" for clarity.
+
+### FIXED in v1.9.138 - 🏷️ Termview Punctuated Terms & Auto-Sizing Columns
+
+**Termview Fix:** Glossary terms with punctuation (like "ca." or "(typisch)") now correctly appear in the Termview pane. Previously they were found but not displayed due to a key normalization mismatch.
+
+**Grid UX:** Segment number column now auto-sizes based on font size and segment count - no more truncated numbers!
+
+### FIXED in v1.9.137 - 🔧 Termview Race Condition
+
+**Glossary terms now appear immediately:** Fixed timing bug where Termview showed "No glossary matches" until you pressed F5. Now updates correctly when navigating segments.
 
 ### ENHANCED in v1.9.128 - 📝 Placeholders Tab Layout Optimization
 

{supervertaler-1.9.132.dist-info → supervertaler-1.9.146.dist-info}/RECORD

@@ -1,4 +1,4 @@
-Supervertaler.py,sha256=9qsQbd5hEWk77Ai__NsBxX8hVkwa9f6sJG2knb-Otic,2143966
+Supervertaler.py,sha256=vNxA4ZPfXTerYIDaHRsbz842S9TbC634rraFSPV6VZI,2153239
 modules/__init__.py,sha256=G58XleS-EJ2sX4Kehm-3N2m618_W2Es0Kg8CW_eBG7g,327
 modules/ai_actions.py,sha256=i5MJcM-7Y6CAvKUwxmxrVHeoZAVtAP7aRDdWM5KLkO0,33877
 modules/ai_attachment_manager.py,sha256=mA5ISI22qN9mH3DQFF4gOTciDyBt5xVR7sHTkgkTIlw,11361
@@ -6,7 +6,7 @@ modules/ai_file_viewer_dialog.py,sha256=lKKqUUlOEVgHmmu6aRxqH7P6ds-7dRLk4ltDyjCw
 modules/autofingers_engine.py,sha256=eJ7tBi7YJvTToe5hYTfnyGXB-qme_cHrOPZibaoR2Xw,17061
 modules/cafetran_docx_handler.py,sha256=_F7Jh0WPVaDnMhdxEsVSXuD1fN9r-S_V6i0gr86Pdfc,14076
 modules/config_manager.py,sha256=kurQ56_o4IzxvKkIKB6YFg69nti01LWWoyVt_JlCWkU,17971
-modules/database_manager.py,sha256=qpTiNzahrt6kTLplxB2lE-dxBxdPeeY2k6VmdwYdDxU,72181
+modules/database_manager.py,sha256=kVZilnvjHkThMwVgqTnQ6-OL2Sbi8R6g8_iYOzSV5ts,73166
 modules/database_migrations.py,sha256=Y1onFsLDV_6vzJLOpNy3WCZDohBZ2jc4prM-g2_RwLE,14085
 modules/dejavurtf_handler.py,sha256=8NZPPYtHga40SZCypHjPoJPmZTvm9rD-eEUUab7mjtg,28156
 modules/document_analyzer.py,sha256=t1rVvqLaTcpQTEja228C7zZnh8dXshK4wA9t1E9aGVk,19524
@@ -59,7 +59,7 @@ modules/term_extractor.py,sha256=qPvKNCVXFTGEGwXNvvC0cfCmdb5c3WhzE38EOgKdKUI,112
 modules/termbase_entry_editor.py,sha256=iWO9CgLjMomGAqBXDsGAX7TFJvDOp2s_taS4gBL1rZY,35818
 modules/termbase_import_export.py,sha256=16IAY04IS_rgt0GH5UOUzUI5NoqAli4JMfMquxmFBm0,23552
 modules/termbase_manager.py,sha256=-PlGF6fIA7KYCteoQ8FZ_0SQZNRRBFAtLimHPbmhQ6w,44544
-modules/termview_widget.py,sha256=KNzgQ7dEFW5ANcbCsUPHJ268MYwBmV5MQG-9GQJoobY,52745
+modules/termview_widget.py,sha256=Imflzotv1raLH-tL4l3MquCL2Pwb56oLIfds4hg7A20,53125
 modules/theme_manager.py,sha256=EOI_5pM2bXAadw08bbl92TLN-w28lbw4Zi1E8vQ-kM0,16694
 modules/tm_editor_dialog.py,sha256=AzGwq4QW641uFJdF8DljLTRRp4FLoYX3Pe4rlTjQWNg,3517
 modules/tm_manager_qt.py,sha256=h2bvXkRuboHf_RRz9-5FX35GVRlpXgRDWeXyj1QWtPs,54406
@@ -77,9 +77,9 @@ modules/unified_prompt_manager_qt.py,sha256=kpR-Tk1xmVyJGHnZdHm6NbGQPTZ1jB8t4tI_
 modules/voice_commands.py,sha256=iBb-gjWxRMLhFH7-InSRjYJz1EIDBNA2Pog8V7TtJaY,38516
 modules/voice_dictation.py,sha256=QmitXfkG-vRt5hIQATjphHdhXfqmwhzcQcbXB6aRzIg,16386
 modules/voice_dictation_lite.py,sha256=jorY0BmWE-8VczbtGrWwt1zbnOctMoSlWOsQrcufBcc,9423
-supervertaler-1.9.132.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
-supervertaler-1.9.132.dist-info/METADATA,sha256=3TgEBK08En64IJMCwc9ea5VUYzJ3vJ4_mpiaOmgCKjs,42458
-supervertaler-1.9.132.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-supervertaler-1.9.132.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
-supervertaler-1.9.132.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
-supervertaler-1.9.132.dist-info/RECORD,,
+supervertaler-1.9.146.dist-info/licenses/LICENSE,sha256=m28u-4qL5nXIWnJ6xlQVw__H30rWFtRK3pCOais2OuY,1092
+supervertaler-1.9.146.dist-info/METADATA,sha256=cPeDrCE6z6Kbfb2_vdQFxORfwE-WJQim-v6YFBxmgPs,43796
+supervertaler-1.9.146.dist-info/WHEEL,sha256=qELbo2s1Yzl39ZmrAibXA2jjPLUYfnVhUNTlyF1rq0Y,92
+supervertaler-1.9.146.dist-info/entry_points.txt,sha256=NP4hiCvx-_30YYKqgr-jfJYQvHr1qTYBMfoVmKIXSM8,53
+supervertaler-1.9.146.dist-info/top_level.txt,sha256=9tUHBYUSfaE4S2E4W3eavJsDyYymkwLfeWAHHAPT6Dk,22
+supervertaler-1.9.146.dist-info/RECORD,,

{supervertaler-1.9.132.dist-info → supervertaler-1.9.146.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (80.9.0)
+Generator: setuptools (80.10.1)
 Root-Is-Purelib: true
 Tag: py3-none-any