supervertaler 1.9.173__py3-none-any.whl → 1.9.190__py3-none-any.whl

modules/project_tm.py

@@ -0,0 +1,320 @@
+"""
+ProjectTM - In-memory TM for instant grid lookups (Total Recall architecture)
+
+This module implements a lightweight in-memory Translation Memory that extracts
+relevant segments from the full TM database on project load. This makes grid
+navigation instant while keeping the full TM for concordance searches.
+
+Inspired by CafeTran's "Total Recall" feature.
+"""
+
+import sqlite3
+import threading
+from difflib import SequenceMatcher
+from typing import Dict, List, Optional, Callable
+import re
+
+
+class ProjectTM:
+    """
+    Lightweight in-memory TM extracted from the main TM database.
+
+    On project load, extracts segments that are relevant to the current project
+    (fuzzy matches above threshold) into an in-memory SQLite database for
+    instant lookups during grid navigation.
+
+    Usage:
+        project_tm = ProjectTM()
+        project_tm.extract_from_database(
+            db_manager,
+            project_segments,
+            tm_ids=['tm1', 'tm2'],
+            threshold=0.75,
+            progress_callback=lambda cur, total: print(f"{cur}/{total}")
+        )
+
+        # Fast lookup during grid navigation
+        matches = project_tm.search("source text to translate")
+    """
+
+    def __init__(self):
+        """Initialize in-memory SQLite database for ProjectTM"""
+        self.conn = sqlite3.connect(":memory:", check_same_thread=False)
+        self.conn.row_factory = sqlite3.Row
+        self.lock = threading.Lock()
+        self.is_built = False
+        self.segment_count = 0
+
+        # Create the schema
+        self._create_schema()
+
+    def _create_schema(self):
+        """Create the in-memory database schema"""
+        with self.lock:
+            cursor = self.conn.cursor()
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS segments (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    source_text TEXT NOT NULL,
+                    target_text TEXT NOT NULL,
+                    source_lower TEXT NOT NULL,
+                    tm_id TEXT,
+                    tm_name TEXT,
+                    similarity REAL,
+                    original_id INTEGER
+                )
+            """)
+            # Index for fast exact match lookups
+            cursor.execute("CREATE INDEX IF NOT EXISTS idx_source_lower ON segments(source_lower)")
+            # FTS5 for fuzzy text search
+            cursor.execute("""
+                CREATE VIRTUAL TABLE IF NOT EXISTS segments_fts USING fts5(
+                    source_text,
+                    content=segments,
+                    content_rowid=id
+                )
+            """)
+            self.conn.commit()
+
+    def clear(self):
+        """Clear all segments from the ProjectTM"""
+        with self.lock:
+            cursor = self.conn.cursor()
+            cursor.execute("DELETE FROM segments")
+            cursor.execute("DELETE FROM segments_fts")
+            self.conn.commit()
+            self.is_built = False
+            self.segment_count = 0
+
+    def extract_from_database(
+        self,
+        db_manager,
+        project_segments: List,
+        tm_ids: List[str] = None,
+        source_lang: str = None,
+        target_lang: str = None,
+        threshold: float = 0.75,
+        progress_callback: Optional[Callable[[int, int], None]] = None,
+        log_callback: Optional[Callable[[str], None]] = None
+    ) -> int:
+        """
+        Extract relevant segments from the main TM database into ProjectTM.
+
+        For each unique source text in the project, searches the TM for fuzzy
+        matches above the threshold and stores them in memory.
+
+        Args:
+            db_manager: The main database manager with TM data
+            project_segments: List of project segments to find matches for
+            tm_ids: List of TM IDs to search (None = all active TMs)
+            source_lang: Source language filter
+            target_lang: Target language filter
+            threshold: Minimum similarity threshold (0.0-1.0)
+            progress_callback: Optional callback(current, total) for progress
+            log_callback: Optional callback(message) for logging
+
+        Returns:
+            Number of TM segments extracted
+        """
+        def log(msg):
+            if log_callback:
+                log_callback(msg)
+            else:
+                print(msg)
+
+        self.clear()
+
+        if not project_segments or not db_manager:
+            log(f"[ProjectTM] Early exit: segments={bool(project_segments)}, db={bool(db_manager)}")
+            return 0
+
+        # Get unique source texts from project
+        unique_sources = {}
+        for seg in project_segments:
+            # Try both 'source' and 'source_text' attributes (different segment types use different names)
+            source = getattr(seg, 'source', None) or getattr(seg, 'source_text', None)
+            if source and source.strip():
+                # Normalize: strip and lowercase for deduplication
+                key = source.strip().lower()
+                if key not in unique_sources:
+                    unique_sources[key] = source.strip()
+
+        total = len(unique_sources)
+        log(f"[ProjectTM] Found {total} unique source texts from {len(project_segments)} segments")
+        if total == 0:
+            return 0
+
+        extracted_count = 0
+        seen_sources = set()  # Deduplicate TM entries
+
+        cursor = self.conn.cursor()
+
+        log(f"[ProjectTM] Searching TMs: {tm_ids}, threshold={threshold}, langs={source_lang}->{target_lang}")
+
+        for i, (key, source_text) in enumerate(unique_sources.items()):
+            if progress_callback and i % 10 == 0:
+                progress_callback(i, total)
+
+            try:
+                # Search main TM database for fuzzy matches
+                matches = db_manager.search_fuzzy_matches(
+                    source_text,
+                    tm_ids=tm_ids,
+                    threshold=threshold,
+                    max_results=10,  # Keep top 10 matches per source
+                    source_lang=source_lang,
+                    target_lang=target_lang,
+                    bidirectional=True
+                )
+
+                # Debug: log first search
+                if i == 0:
+                    log(f"[ProjectTM] First search '{source_text[:50]}...' returned {len(matches)} matches")
+
+                for match in matches:
+                    match_source = match.get('source_text', '')
+                    match_target = match.get('target_text', '')
+
+                    if not match_source or not match_target:
+                        continue
+
+                    # Deduplicate by source text
+                    source_key = match_source.strip().lower()
+                    if source_key in seen_sources:
+                        continue
+                    seen_sources.add(source_key)
+
+                    # Insert into ProjectTM
+                    cursor.execute("""
+                        INSERT INTO segments (source_text, target_text, source_lower,
+                                            tm_id, tm_name, similarity, original_id)
+                        VALUES (?, ?, ?, ?, ?, ?, ?)
+                    """, (
+                        match_source,
+                        match_target,
+                        source_key,
+                        match.get('tm_id'),
+                        match.get('tm_name', 'Unknown TM'),
+                        match.get('similarity', 0),
+                        match.get('id')
+                    ))
+                    extracted_count += 1
+
+            except Exception as e:
+                # Log but continue - don't fail extraction for one bad segment
+                pass
+
+        # Commit all inserts
+        self.conn.commit()
+
+        # Rebuild FTS5 index
+        try:
+            cursor.execute("INSERT INTO segments_fts(segments_fts) VALUES('rebuild')")
+            self.conn.commit()
+        except Exception:
+            pass  # FTS rebuild may fail if no data, that's OK
+
+        if progress_callback:
+            progress_callback(total, total)
+
+        self.is_built = True
+        self.segment_count = extracted_count
+
+        return extracted_count
+
+    def search(self, source_text: str, max_results: int = 5) -> List[Dict]:
+        """
+        Search ProjectTM for matches (instant lookup).
+
+        First checks for exact matches, then falls back to fuzzy search.
+
+        Args:
+            source_text: Source text to search for
+            max_results: Maximum number of results to return
+
+        Returns:
+            List of match dictionaries with source_text, target_text, similarity, etc.
+        """
+        if not self.is_built or not source_text:
+            return []
+
+        source_lower = source_text.strip().lower()
+        results = []
+
+        with self.lock:
+            cursor = self.conn.cursor()
+
+            # 1. Check for exact match first (fastest)
+            cursor.execute("""
+                SELECT * FROM segments WHERE source_lower = ? LIMIT 1
+            """, (source_lower,))
+            exact = cursor.fetchone()
+
+            if exact:
+                results.append({
+                    'source_text': exact['source_text'],
+                    'target_text': exact['target_text'],
+                    'tm_id': exact['tm_id'],
+                    'tm_name': exact['tm_name'],
+                    'similarity': 1.0,  # Exact match
+                    'match_pct': 100,
+                    'id': exact['original_id']
+                })
+                return results  # Exact match - no need to search further
+
+            # 2. FTS5 fuzzy search
+            try:
+                # Tokenize query for FTS5
+                clean_text = re.sub(r'[^\w\s]', ' ', source_text)
+                search_terms = [t for t in clean_text.split() if len(t) > 2]
+
+                if search_terms:
+                    fts_query = ' OR '.join(f'"{term}"' for term in search_terms[:10])
+
+                    cursor.execute("""
+                        SELECT s.*, bm25(segments_fts) as rank
+                        FROM segments s
+                        JOIN segments_fts ON s.id = segments_fts.rowid
+                        WHERE segments_fts MATCH ?
+                        ORDER BY rank
+                        LIMIT ?
+                    """, (fts_query, max_results * 3))  # Get more candidates for re-ranking
+
+                    candidates = cursor.fetchall()
+
+                    # Re-rank by actual similarity
+                    for row in candidates:
+                        similarity = self._calculate_similarity(source_text, row['source_text'])
+                        if similarity >= 0.5:  # Lower threshold for ProjectTM (pre-filtered)
+                            results.append({
+                                'source_text': row['source_text'],
+                                'target_text': row['target_text'],
+                                'tm_id': row['tm_id'],
+                                'tm_name': row['tm_name'],
+                                'similarity': similarity,
+                                'match_pct': int(similarity * 100),
+                                'id': row['original_id']
+                            })
+
+                    # Sort by similarity and limit
+                    results.sort(key=lambda x: x['similarity'], reverse=True)
+                    results = results[:max_results]
+
+            except Exception:
+                pass  # FTS search may fail, return what we have
+
+        return results
+
+    def _calculate_similarity(self, text1: str, text2: str) -> float:
+        """Calculate similarity ratio between two texts"""
+        # Strip HTML/XML tags for comparison
+        clean1 = re.sub(r'<[^>]+>', '', text1).lower()
+        clean2 = re.sub(r'<[^>]+>', '', text2).lower()
+        return SequenceMatcher(None, clean1, clean2).ratio()
+
+    def get_stats(self) -> Dict:
+        """Get statistics about the ProjectTM"""
+        return {
+            'is_built': self.is_built,
+            'segment_count': self.segment_count
+        }

modules/superbrowser.py

@@ -160,6 +160,20 @@ class ChatColumn(QWidget):
         """Update URL bar when page changes"""
         self.url_input.setText(url.toString())
 
+    def cleanup(self):
+        """Clean up web engine resources before deletion"""
+        try:
+            from PyQt6.QtCore import QUrl
+            if hasattr(self, 'web_view'):
+                self.web_view.stop()
+                self.web_view.setPage(None)
+                self.web_view.setUrl(QUrl('about:blank'))
+                self.web_view.deleteLater()
+            if hasattr(self, 'profile'):
+                self.profile.deleteLater()
+        except:
+            pass
+
 
 class SuperbrowserWidget(QWidget):
     """
@@ -304,6 +318,14 @@ class SuperbrowserWidget(QWidget):
         self.claude_column.go_home()
         self.gemini_column.go_home()
 
+    def cleanup(self):
+        """Clean up all web engine resources before widget deletion"""
+        try:
+            for column in self.chat_columns:
+                column.cleanup()
+        except:
+            pass
+
 
 # ============================================================================
 # STANDALONE USAGE

modules/termbase_manager.py

@@ -409,7 +409,111 @@ class TermbaseManager:
         except Exception as e:
             self.log(f"✗ Error setting termbase read_only: {e}")
             return False
-    
+
+    def get_termbase_ai_inject(self, termbase_id: int) -> bool:
+        """Get whether termbase terms should be injected into LLM prompts"""
+        try:
+            cursor = self.db_manager.cursor
+            cursor.execute("SELECT ai_inject FROM termbases WHERE id = ?", (termbase_id,))
+            result = cursor.fetchone()
+            return bool(result[0]) if result and result[0] else False
+        except Exception as e:
+            self.log(f"✗ Error getting termbase ai_inject: {e}")
+            return False
+
+    def set_termbase_ai_inject(self, termbase_id: int, ai_inject: bool) -> bool:
+        """Set whether termbase terms should be injected into LLM prompts"""
+        try:
+            cursor = self.db_manager.cursor
+            cursor.execute("""
+                UPDATE termbases SET ai_inject = ? WHERE id = ?
+            """, (1 if ai_inject else 0, termbase_id))
+            self.db_manager.connection.commit()
+            status = "enabled" if ai_inject else "disabled"
+            self.log(f"✓ AI injection {status} for termbase {termbase_id}")
+            return True
+        except Exception as e:
+            self.log(f"✗ Error setting termbase ai_inject: {e}")
+            return False
+
+    def get_ai_inject_termbases(self, project_id: Optional[int] = None) -> List[Dict]:
+        """
+        Get all termbases with ai_inject enabled that are active for the given project.
+
+        Args:
+            project_id: Project ID (0 or None for global)
+
+        Returns:
+            List of termbase dictionaries with all terms
+        """
+        try:
+            cursor = self.db_manager.cursor
+            proj_id = project_id if project_id else 0
+
+            cursor.execute("""
+                SELECT t.id, t.name, t.source_lang, t.target_lang
+                FROM termbases t
+                LEFT JOIN termbase_activation ta ON t.id = ta.termbase_id AND ta.project_id = ?
+                WHERE t.ai_inject = 1
+                AND (ta.is_active = 1 OR (t.is_global = 1 AND ta.is_active IS NULL))
+                ORDER BY ta.priority ASC, t.name ASC
+            """, (proj_id,))
+
+            termbases = []
+            for row in cursor.fetchall():
+                termbases.append({
+                    'id': row[0],
+                    'name': row[1],
+                    'source_lang': row[2],
+                    'target_lang': row[3]
+                })
+            return termbases
+        except Exception as e:
+            self.log(f"✗ Error getting AI inject termbases: {e}")
+            return []
+
+    def get_ai_inject_terms(self, project_id: Optional[int] = None) -> List[Dict]:
+        """
+        Get all terms from AI-inject-enabled termbases for the given project.
+
+        Args:
+            project_id: Project ID (0 or None for global)
+
+        Returns:
+            List of term dictionaries with source_term, target_term, forbidden, termbase_name
+        """
+        try:
+            # First get all AI-inject termbases
+            ai_termbases = self.get_ai_inject_termbases(project_id)
+            if not ai_termbases:
+                return []
+
+            all_terms = []
+            cursor = self.db_manager.cursor
+
+            for tb in ai_termbases:
+                cursor.execute("""
+                    SELECT source_term, target_term, forbidden, priority
+                    FROM termbase_terms
+                    WHERE termbase_id = ?
+                    ORDER BY priority ASC, source_term ASC
+                """, (tb['id'],))
+
+                for row in cursor.fetchall():
+                    all_terms.append({
+                        'source_term': row[0],
+                        'target_term': row[1],
+                        'forbidden': bool(row[2]) if row[2] else False,
+                        'priority': row[3] or 99,
+                        'termbase_name': tb['name']
+                    })
+
+            self.log(f"📚 Retrieved {len(all_terms)} terms from {len(ai_termbases)} AI-inject glossar{'y' if len(ai_termbases) == 1 else 'ies'}")
+            return all_terms
+        except Exception as e:
+            self.log(f"✗ Error getting AI inject terms: {e}")
+            return []
+
     def set_termbase_priority(self, termbase_id: int, project_id: int, priority: int) -> bool:
         """
         Set manual priority for a termbase in a specific project.
@@ -505,7 +609,6 @@ class TermbaseManager:
             """, (project_id,))
             
             active_ids = [row[0] for row in cursor.fetchall()]
-            self.log(f"📋 Found {len(active_ids)} active termbases for project {project_id}: {active_ids}")
             return active_ids
         except Exception as e:
             self.log(f"✗ Error getting active termbase IDs: {e}")

modules/termview_widget.py

@@ -172,7 +172,7 @@ class TermBlock(QWidget):
         # Get theme colors
         is_dark = self.theme_manager and self.theme_manager.current_theme.name == "Dark"
         separator_color = "#555555" if is_dark else "#CCCCCC"
-        source_text_color = "#E0E0E0" if is_dark else "#333"
+        source_text_color = "#FFFFFF" if is_dark else "#333"
         no_match_color = "#666666" if is_dark else "#ddd"
         no_match_bg = "#2A2A2A" if is_dark else "#F5F5F5"
         
@@ -224,10 +224,17 @@ class TermBlock(QWidget):
         if self.translations:
             target_text = primary_translation.get('target_term', primary_translation.get('target', ''))
             termbase_name = primary_translation.get('termbase_name', '')
-            
-            # Background color based on termbase type
-            bg_color = "#FFE5F0" if self.is_effective_project else "#D6EBFF"  # Pink for project, light blue for regular
-            hover_color = "#FFD0E8" if self.is_effective_project else "#BBDEFB"  # Slightly darker on hover
+
+            # Background color based on termbase type (theme-aware)
+            is_dark = self.theme_manager and self.theme_manager.current_theme.name == "Dark"
+            if is_dark:
+                # Dark mode: darker backgrounds
+                bg_color = "#4A2D3A" if self.is_effective_project else "#2D3E4A"  # Dark pink/blue
+                hover_color = "#5A3D4A" if self.is_effective_project else "#3D4E5A"  # Lighter on hover
+            else:
+                # Light mode: original colors
+                bg_color = "#FFE5F0" if self.is_effective_project else "#D6EBFF"  # Pink for project, light blue for regular
+                hover_color = "#FFD0E8" if self.is_effective_project else "#BBDEFB"  # Slightly darker on hover
             
             # Create horizontal layout for target + shortcut badge
             # Apply background to container so it covers both text and badge
@@ -251,9 +258,11 @@ class TermBlock(QWidget):
             target_font.setBold(self.font_bold)
             target_label.setFont(target_font)
             target_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
+            # Theme-aware text color
+            target_text_color = "#B0C4DE" if is_dark else "#0052A3"  # Light blue in dark mode
             target_label.setStyleSheet(f"""
                 QLabel {{
-                    color: #0052A3;
+                    color: {target_text_color};
                     padding: 0px;
                     background-color: transparent;
                     border: none;
@@ -312,11 +321,12 @@ class TermBlock(QWidget):
                     if len(self.translations) > 1:
                         count_label = QLabel(f"+{len(self.translations) - 1}")
                         count_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-                        count_label.setStyleSheet("""
-                            QLabel {
-                                color: #999;
+                        count_color = "#AAA" if is_dark else "#999"  # Lighter in dark mode
+                        count_label.setStyleSheet(f"""
+                            QLabel {{
+                                color: {count_color};
                                 font-size: 7px;
-                            }
+                            }}
                         """)
                         layout.addWidget(count_label)
                     return
@@ -336,10 +346,13 @@ class TermBlock(QWidget):
                 badge_label = QLabel(badge_text)
                 badge_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
                 badge_label.setFixedSize(badge_width, 14)
+                # Theme-aware badge colors
+                badge_bg = "#4A90E2" if is_dark else "#1976D2"  # Lighter blue in dark mode
+                badge_text_color = "#FFFFFF" if is_dark else "white"
                 badge_label.setStyleSheet(f"""
                     QLabel {{
-                        background-color: #1976D2;
-                        color: white;
+                        background-color: {badge_bg};
+                        color: {badge_text_color};
                         font-size: 9px;
                         font-weight: bold;
                         border-radius: 7px;
@@ -352,16 +365,17 @@ class TermBlock(QWidget):
                 target_layout.addWidget(badge_label)
             
             layout.addWidget(target_container)
-            
+
             # Show count if multiple translations - very compact
             if len(self.translations) > 1:
                 count_label = QLabel(f"+{len(self.translations) - 1}")
                 count_label.setAlignment(Qt.AlignmentFlag.AlignCenter)
-                count_label.setStyleSheet("""
-                    QLabel {
-                        color: #999;
+                count_color = "#AAA" if is_dark else "#999"  # Lighter in dark mode
+                count_label.setStyleSheet(f"""
+                    QLabel {{
+                        color: {count_color};
                         font-size: 7px;
-                    }
+                    }}
                 """)
                 layout.addWidget(count_label)
         else:
@@ -439,7 +453,7 @@ class NTBlock(QWidget):
         
         # Get theme colors
         is_dark = self.theme_manager and self.theme_manager.current_theme.name == "Dark"
-        source_text_color = "#E0E0E0" if is_dark else "#5D4E37"
+        source_text_color = "#FFFFFF" if is_dark else "#5D4E37"
         
         # Pastel yellow border for non-translatables
         border_color = "#E6C200"  # Darker yellow for border
@@ -637,6 +651,17 @@ class TermviewWidget(QWidget):
             is_dark = theme.name == "Dark"
             info_label_color = "#909090" if is_dark else info_text
             self.info_label.setStyleSheet(f"color: {info_label_color}; font-size: 10px; padding: 5px;")
+
+        # Refresh term blocks to pick up new theme colors
+        if hasattr(self, '_last_termbase_matches') and hasattr(self, '_last_nt_matches') and hasattr(self, 'current_source'):
+            # Re-render with stored matches to apply new theme colors
+            if self.current_source:
+                self.update_with_matches(
+                    self.current_source,
+                    self._last_termbase_matches or [],
+                    self._last_nt_matches,
+                    self._status_hint if hasattr(self, '_status_hint') else None
+                )
     
     def set_font_settings(self, font_family: str = "Segoe UI", font_size: int = 10, bold: bool = False):
         """Update font settings for Termview
@@ -694,27 +719,31 @@ class TermviewWidget(QWidget):
                     font.setBold(self.current_font_bold)
                     block.source_label.setFont(font)
     
-    def update_with_matches(self, source_text: str, termbase_matches: List[Dict], nt_matches: List[Dict] = None):
+    def update_with_matches(self, source_text: str, termbase_matches: List[Dict], nt_matches: List[Dict] = None, status_hint: str = None):
         """
         Update the termview display with pre-computed termbase and NT matches
-        
+
         RYS-STYLE DISPLAY: Show source text as tokens with translations underneath
-        
+
         Args:
             source_text: Source segment text
             termbase_matches: List of termbase match dicts from Translation Results
             nt_matches: Optional list of NT match dicts with 'text', 'start', 'end', 'list_name' keys
+            status_hint: Optional hint about why there might be no matches (e.g., 'no_termbases_activated', 'wrong_language')
         """
         self.current_source = source_text
-        
+        # Store matches for theme refresh
+        self._last_termbase_matches = termbase_matches
+        self._last_nt_matches = nt_matches
+
         # Clear existing blocks and shortcut mappings
         self.clear_terms()
         self.shortcut_terms = {}  # Reset shortcut mappings
-        
+
         if not source_text or not source_text.strip():
             self.info_label.setText("No segment selected")
             return
-        
+
         # Strip HTML/XML tags from source text for display in TermView
         # This handles CAT tool tags like <b>, </b>, <i>, </i>, <u>, </u>, <bi>, <sub>, <sup>, <li-o>, <li-b>
         # as well as memoQ tags {1}, [2}, {3], Trados tags <1>, </1>, and Déjà Vu tags {00001}
@@ -725,17 +754,17 @@ class TermviewWidget(QWidget):
         display_text = re.sub(r'\[[^\[\]]*\}', '', display_text)  # Opening: [anything}
         display_text = re.sub(r'\{[^\{\}]*\]', '', display_text)  # Closing: {anything]
         display_text = display_text.strip()
-        
+
         # If stripping tags leaves nothing, fall back to original
         if not display_text:
             display_text = source_text
-        
+
         has_termbase = termbase_matches and len(termbase_matches) > 0
         has_nt = nt_matches and len(nt_matches) > 0
-        
-        if not has_termbase and not has_nt:
-            self.info_label.setText("No terminology or NT matches for this segment")
-            return
+
+        # Store status hint for info label (will be set at the end)
+        self._status_hint = status_hint
+        self._has_any_matches = has_termbase or has_nt
         
         # Convert termbase matches to dict for easy lookup: {source_term.lower(): [translations]}
         matches_dict = {}
@@ -867,11 +896,18 @@ class TermviewWidget(QWidget):
             info_parts.append(f"{blocks_with_translations} terms")
         if blocks_with_nt > 0:
             info_parts.append(f"{blocks_with_nt} NTs")
-        
+
         if info_parts:
             self.info_label.setText(f"✓ Found {', '.join(info_parts)} in {len(tokens)} words")
         else:
-            self.info_label.setText(f"No matches in {len(tokens)} words")
+            # Show appropriate message based on status hint when no matches
+            status_hint = getattr(self, '_status_hint', None)
+            if status_hint == 'no_termbases_activated':
+                self.info_label.setText(f"No glossaries activated ({len(tokens)} words)")
+            elif status_hint == 'wrong_language':
+                self.info_label.setText(f"Glossaries don't match language pair ({len(tokens)} words)")
+            else:
+                self.info_label.setText(f"No matches in {len(tokens)} words")
     
     def get_all_termbase_matches(self, text: str) -> Dict[str, List[Dict]]:
         """