| import ctypes |
| import os |
|
|
| import psutil |
| from i18n import t |
| from PyQt6.QtCore import QPoint, Qt, QTimer, pyqtSignal, pyqtSlot |
| from PyQt6.QtGui import QCursor, QFont |
| from PyQt6.QtWidgets import ( |
| QApplication, |
| QCheckBox, |
| QComboBox, |
| QHBoxLayout, |
| QLabel, |
| QMenu, |
| QProgressBar, |
| QPushButton, |
| QScrollArea, |
| QSizeGrip, |
| QVBoxLayout, |
| QWidget, |
| ) |
|
|
| _GWL_EXSTYLE = -20 |
| _WS_EX_TRANSPARENT = 0x20 |
|
|
| DEFAULT_STYLE = { |
| "preset": "default", |
| "bg_color": "#000000", |
| "bg_opacity": 240, |
| "header_color": "#1a1a2e", |
| "header_opacity": 230, |
| "border_radius": 8, |
| "original_font_family": "Microsoft YaHei", |
| "translation_font_family": "Microsoft YaHei", |
| "original_font_size": 11, |
| "translation_font_size": 14, |
| "original_color": "#cccccc", |
| "translation_color": "#ffffff", |
| "timestamp_color": "#888899", |
| "window_opacity": 95, |
| } |
|
|
| _BASE = DEFAULT_STYLE |
|
|
| STYLE_PRESETS = { |
| "default": dict(_BASE), |
| "transparent": {**_BASE, "preset": "transparent", |
| "bg_opacity": 120, "header_opacity": 120, "window_opacity": 70}, |
| "compact": {**_BASE, "preset": "compact", |
| "original_font_size": 9, "translation_font_size": 11}, |
| "light": {**_BASE, "preset": "light", |
| "bg_color": "#e8e8f0", "bg_opacity": 230, "header_color": "#c8c8d8", |
| "header_opacity": 220, "original_color": "#333333", |
| "translation_color": "#111111", "timestamp_color": "#666688"}, |
| "dracula": {**_BASE, "preset": "dracula", |
| "bg_color": "#282a36", "bg_opacity": 235, "header_color": "#44475a", |
| "header_opacity": 230, "original_color": "#f8f8f2", |
| "translation_color": "#f8f8f2", "timestamp_color": "#6272a4"}, |
| "nord": {**_BASE, "preset": "nord", |
| "bg_color": "#2e3440", "bg_opacity": 235, "header_color": "#3b4252", |
| "header_opacity": 230, "original_color": "#d8dee9", |
| "translation_color": "#eceff4", "timestamp_color": "#4c566a"}, |
| "monokai": {**_BASE, "preset": "monokai", |
| "bg_color": "#272822", "bg_opacity": 235, "header_color": "#3e3d32", |
| "header_opacity": 230, "original_color": "#f8f8f2", |
| "translation_color": "#f8f8f2", "timestamp_color": "#75715e"}, |
| "solarized": {**_BASE, "preset": "solarized", |
| "bg_color": "#002b36", "bg_opacity": 235, "header_color": "#073642", |
| "header_opacity": 230, "original_color": "#839496", |
| "translation_color": "#eee8d5", "timestamp_color": "#586e75"}, |
| "gruvbox": {**_BASE, "preset": "gruvbox", |
| "bg_color": "#282828", "bg_opacity": 235, "header_color": "#3c3836", |
| "header_opacity": 230, "original_color": "#ebdbb2", |
| "translation_color": "#fbf1c7", "timestamp_color": "#928374"}, |
| "tokyo_night": {**_BASE, "preset": "tokyo_night", |
| "bg_color": "#1a1b26", "bg_opacity": 235, "header_color": "#24283b", |
| "header_opacity": 230, "original_color": "#a9b1d6", |
| "translation_color": "#c0caf5", "timestamp_color": "#565f89"}, |
| "catppuccin": {**_BASE, "preset": "catppuccin", |
| "bg_color": "#1e1e2e", "bg_opacity": 235, "header_color": "#313244", |
| "header_opacity": 230, "original_color": "#cdd6f4", |
| "translation_color": "#cdd6f4", "timestamp_color": "#6c7086"}, |
| "one_dark": {**_BASE, "preset": "one_dark", |
| "bg_color": "#282c34", "bg_opacity": 235, "header_color": "#3e4452", |
| "header_opacity": 230, "original_color": "#abb2bf", |
| "translation_color": "#e5c07b", "timestamp_color": "#636d83"}, |
| "everforest": {**_BASE, "preset": "everforest", |
| "bg_color": "#2d353b", "bg_opacity": 235, "header_color": "#343f44", |
| "header_opacity": 230, "original_color": "#d3c6aa", |
| "translation_color": "#d3c6aa", "timestamp_color": "#859289"}, |
| "kanagawa": {**_BASE, "preset": "kanagawa", |
| "bg_color": "#1f1f28", "bg_opacity": 235, "header_color": "#2a2a37", |
| "header_opacity": 230, "original_color": "#dcd7ba", |
| "translation_color": "#dcd7ba", "timestamp_color": "#54546d"}, |
| } |
|
|
|
|
| def _hex_to_rgba(hex_color: str, opacity: int) -> str: |
| hex_color = hex_color.lstrip("#") |
| r, g, b = int(hex_color[0:2], 16), int(hex_color[2:4], 16), int(hex_color[4:6], 16) |
| return f"rgba({r},{g},{b},{opacity})" |
|
|
|
|
| class ChatMessage(QWidget): |
| """Single chat message widget with original + async translation.""" |
|
|
| _current_style = DEFAULT_STYLE |
|
|
| def __init__( |
| self, |
| msg_id: int, |
| timestamp: str, |
| original: str, |
| source_lang: str, |
| asr_ms: float, |
| parent=None, |
| ): |
| super().__init__(parent) |
| self.msg_id = msg_id |
| self._original = original |
| self._translated = "" |
| self._timestamp = timestamp |
| self._source_lang = source_lang |
| self._asr_ms = asr_ms |
| self._translate_ms = 0.0 |
| self._layout = QVBoxLayout(self) |
| self._layout.setContentsMargins(8, 4, 8, 4) |
| self._layout.setSpacing(2) |
|
|
| s = self._current_style |
| self._header_label = QLabel(self._build_header_html(s)) |
| self._header_label.setFont(QFont(s["original_font_family"], s["original_font_size"])) |
| self._header_label.setTextFormat(Qt.TextFormat.RichText) |
| self._header_label.setWordWrap(True) |
| self._header_label.setStyleSheet("background: transparent;") |
| self._layout.addWidget(self._header_label) |
|
|
| self._trans_label = QLabel( |
| f'<span style="color:#999; font-style:italic;">{t("translating")}</span>' |
| ) |
| self._trans_label.setFont(QFont(s["translation_font_family"], s["translation_font_size"])) |
| self._trans_label.setTextFormat(Qt.TextFormat.RichText) |
| self._trans_label.setWordWrap(True) |
| self._trans_label.setStyleSheet("background: transparent;") |
| self._layout.addWidget(self._trans_label) |
|
|
| def _build_header_html(self, s): |
| return ( |
| f'<span style="color:{s["timestamp_color"]};">[{self._timestamp}]</span> ' |
| f'<span style="color:#6cf;">[{self._source_lang}]</span> ' |
| f'<span style="color:{s["original_color"]};">{_escape(self._original)}</span> ' |
| f'<span style="color:#8b8; font-size:9pt;">ASR {self._asr_ms:.0f}ms</span>' |
| ) |
|
|
| def set_translation(self, translated: str, translate_ms: float): |
| self._translated = translated or "" |
| self._translate_ms = translate_ms |
| s = self._current_style |
| if translated: |
| self._trans_label.setText( |
| f'<span style="color:{s["translation_color"]};">> {_escape(translated)}</span> ' |
| f'<span style="color:#db8; font-size:9pt;">TL {translate_ms:.0f}ms</span>' |
| ) |
| else: |
| self._trans_label.setText( |
| f'<span style="color:#aaa; font-style:italic;">> {t("same_language")}</span>' |
| ) |
|
|
| def apply_style(self, s: dict): |
| self._header_label.setText(self._build_header_html(s)) |
| self._header_label.setFont(QFont(s["original_font_family"], s["original_font_size"])) |
| self._trans_label.setFont(QFont(s["translation_font_family"], s["translation_font_size"])) |
| if self._translated: |
| self._trans_label.setText( |
| f'<span style="color:{s["translation_color"]};">> {_escape(self._translated)}</span> ' |
| f'<span style="color:#db8; font-size:9pt;">TL {self._translate_ms:.0f}ms</span>' |
| ) |
|
|
| def contextMenuEvent(self, event): |
| menu = QMenu(self) |
| menu.setStyleSheet(""" |
| QMenu { background: #2a2a3a; color: #ddd; border: 1px solid #555; } |
| QMenu::item:selected { background: #444; } |
| """) |
| copy_orig = menu.addAction(t("copy_original")) |
| copy_trans = menu.addAction(t("copy_translation")) |
| copy_all = menu.addAction(t("copy_all")) |
| action = menu.exec(event.globalPos()) |
| if action == copy_orig: |
| QApplication.clipboard().setText(self._original) |
| elif action == copy_trans: |
| QApplication.clipboard().setText(self._translated) |
| elif action == copy_all: |
| QApplication.clipboard().setText(f"{self._original}\n{self._translated}") |
|
|
|
|
| def _escape(text: str) -> str: |
| return text.replace("&", "&").replace("<", "<").replace(">", ">") |
|
|
|
|
| _BTN_CSS = """ |
| QPushButton { |
| background: rgba(255,255,255,20); |
| border: 1px solid rgba(255,255,255,40); |
| border-radius: 3px; |
| color: #aaa; |
| font-size: 11px; |
| padding: 0 6px; |
| } |
| QPushButton:hover { |
| background: rgba(255,255,255,40); |
| color: #ddd; |
| } |
| """ |
|
|
| _BAR_CSS_TPL = """ |
| QProgressBar {{ |
| background: rgba(255,255,255,15); |
| border: 1px solid rgba(255,255,255,30); |
| border-radius: 3px; |
| text-align: center; |
| font-size: 8pt; |
| color: #aaa; |
| }} |
| QProgressBar::chunk {{ |
| background: {color}; |
| border-radius: 2px; |
| }} |
| """ |
|
|
|
|
| class MonitorBar(QWidget): |
| """Compact system monitor displayed in the overlay.""" |
|
|
| def __init__(self, parent=None): |
| super().__init__(parent) |
| self.setStyleSheet("background: transparent;") |
|
|
| layout = QVBoxLayout(self) |
| layout.setContentsMargins(8, 4, 8, 4) |
| layout.setSpacing(2) |
|
|
| row1 = QHBoxLayout() |
| row1.setSpacing(6) |
|
|
| rms_lbl = QLabel("RMS") |
| rms_lbl.setFixedWidth(28) |
| rms_lbl.setFont(QFont("Consolas", 8)) |
| rms_lbl.setStyleSheet("color: #888; background: transparent;") |
| row1.addWidget(rms_lbl) |
|
|
| self._rms_bar = QProgressBar() |
| self._rms_bar.setRange(0, 100) |
| self._rms_bar.setFixedHeight(14) |
| self._rms_bar.setTextVisible(True) |
| self._rms_bar.setFormat("%v%") |
| self._rms_bar.setStyleSheet(_BAR_CSS_TPL.format(color="#4ec9b0")) |
| row1.addWidget(self._rms_bar) |
|
|
| vad_lbl = QLabel("VAD") |
| vad_lbl.setFixedWidth(28) |
| vad_lbl.setFont(QFont("Consolas", 8)) |
| vad_lbl.setStyleSheet("color: #888; background: transparent;") |
| row1.addWidget(vad_lbl) |
|
|
| self._vad_bar = QProgressBar() |
| self._vad_bar.setRange(0, 100) |
| self._vad_bar.setFixedHeight(14) |
| self._vad_bar.setTextVisible(True) |
| self._vad_bar.setFormat("%v%") |
| self._vad_bar.setStyleSheet(_BAR_CSS_TPL.format(color="#dcdcaa")) |
| row1.addWidget(self._vad_bar) |
|
|
| layout.addLayout(row1) |
|
|
| self._stats_label = QLabel() |
| self._stats_label.setFont(QFont("Consolas", 8)) |
| self._stats_label.setStyleSheet("color: #888; background: transparent;") |
| self._stats_label.setTextFormat(Qt.TextFormat.RichText) |
| layout.addWidget(self._stats_label) |
|
|
| self._cpu = 0 |
| self._ram_mb = 0.0 |
| self._gpu_text = "N/A" |
| self._asr_device = "" |
| self._asr_count = 0 |
| self._tl_count = 0 |
| self._prompt_tokens = 0 |
| self._completion_tokens = 0 |
|
|
| self._sys_timer = QTimer(self) |
| self._sys_timer.timeout.connect(self._update_system) |
| self._sys_timer.start(1000) |
| self._update_system() |
| self._refresh_stats() |
|
|
| def update_audio(self, rms: float, vad: float): |
| self._rms_bar.setValue(min(100, int(rms * 500))) |
| self._vad_bar.setValue(min(100, int(vad * 100))) |
|
|
| def update_asr_device(self, device: str): |
| self._asr_device = device |
| self._refresh_stats() |
|
|
| def update_pipeline_stats( |
| self, asr_count, tl_count, prompt_tokens, completion_tokens |
| ): |
| self._asr_count = asr_count |
| self._tl_count = tl_count |
| self._prompt_tokens = prompt_tokens |
| self._completion_tokens = completion_tokens |
| self._refresh_stats() |
|
|
| def _update_system(self): |
| try: |
| proc = psutil.Process(os.getpid()) |
| self._cpu = int(proc.cpu_percent(interval=0)) |
| self._ram_mb = proc.memory_info().rss / 1024 / 1024 |
| except Exception: |
| pass |
| try: |
| import torch |
|
|
| if torch.cuda.is_available(): |
| alloc = torch.cuda.memory_allocated() / 1024 / 1024 |
| self._gpu_text = f"{alloc:.0f}MB" |
| else: |
| self._gpu_text = "N/A" |
| except Exception: |
| self._gpu_text = "N/A" |
| self._refresh_stats() |
|
|
| def _refresh_stats(self): |
| total = self._prompt_tokens + self._completion_tokens |
| tokens_str = f"{total / 1000:.1f}k" if total >= 1000 else str(total) |
| dev_str = "" |
| if self._asr_device: |
| dev_color = "#4ec9b0" if "cuda" in self._asr_device.lower() else "#dcdcaa" |
| dev_str = ( |
| f'<span style="color:{dev_color};">{self._asr_device}</span> ' |
| f'<span style="color:#555;">|</span> ' |
| ) |
| self._stats_label.setText( |
| f"{dev_str}" |
| f'<span style="color:#6cf;">CPU</span> {self._cpu}% ' |
| f'<span style="color:#6cf;">RAM</span> {self._ram_mb:.0f}MB ' |
| f'<span style="color:#6cf;">GPU</span> {self._gpu_text} ' |
| f'<span style="color:#555;">|</span> ' |
| f'<span style="color:#8b8;">ASR</span> {self._asr_count} ' |
| f'<span style="color:#db8;">TL</span> {self._tl_count} ' |
| f'<span style="color:#c9c;">Tok</span> {tokens_str} ' |
| f'<span style="color:#666;">({self._prompt_tokens}\u2191{self._completion_tokens}\u2193)</span>' |
| ) |
|
|
|
|
| class _DragArea(QWidget): |
| """Small draggable area (title + grip).""" |
|
|
| def __init__(self, parent=None): |
| super().__init__(parent) |
| self.setCursor(QCursor(Qt.CursorShape.SizeAllCursor)) |
| self._drag_pos = None |
|
|
| def mousePressEvent(self, event): |
| if event.button() == Qt.MouseButton.LeftButton: |
| self._drag_pos = ( |
| event.globalPosition().toPoint() |
| - self.window().frameGeometry().topLeft() |
| ) |
|
|
| def mouseMoveEvent(self, event): |
| if self._drag_pos and event.buttons() & Qt.MouseButton.LeftButton: |
| self.window().move(event.globalPosition().toPoint() - self._drag_pos) |
|
|
| def mouseReleaseEvent(self, event): |
| self._drag_pos = None |
|
|
|
|
| _COMBO_CSS = """ |
| QComboBox { |
| background: rgba(255,255,255,20); |
| border: 1px solid rgba(255,255,255,40); |
| border-radius: 3px; |
| color: #aaa; |
| font-size: 11px; |
| padding: 0 4px; |
| } |
| QComboBox:hover { background: rgba(255,255,255,40); color: #ddd; } |
| QComboBox::drop-down { border: none; width: 14px; } |
| QComboBox::down-arrow { image: none; border: none; } |
| QComboBox QAbstractItemView { |
| background: #2a2a3a; color: #ccc; selection-background-color: #444; |
| } |
| """ |
|
|
| _CHECK_CSS = ( |
| "QCheckBox { color: #888; background: transparent; spacing: 3px; }" |
| "QCheckBox::indicator { width: 12px; height: 12px; }" |
| ) |
|
|
|
|
| class DragHandle(QWidget): |
| """Top bar: row1=title+buttons, row2=checkboxes+combos.""" |
|
|
| settings_clicked = pyqtSignal() |
| monitor_toggled = pyqtSignal(bool) |
| click_through_toggled = pyqtSignal(bool) |
| topmost_toggled = pyqtSignal(bool) |
| auto_scroll_toggled = pyqtSignal(bool) |
| target_language_changed = pyqtSignal(str) |
| model_changed = pyqtSignal(int) |
| start_clicked = pyqtSignal() |
| stop_clicked = pyqtSignal() |
| clear_clicked = pyqtSignal() |
| quit_clicked = pyqtSignal() |
|
|
| def __init__(self, parent=None): |
| super().__init__(parent) |
| self.setFixedHeight(48) |
| self.setStyleSheet("background: rgba(60, 60, 80, 200); border-radius: 4px;") |
|
|
| outer = QVBoxLayout(self) |
| outer.setContentsMargins(0, 0, 0, 0) |
| outer.setSpacing(0) |
|
|
| |
| row1 = QHBoxLayout() |
| row1.setContentsMargins(0, 0, 4, 0) |
| row1.setSpacing(3) |
|
|
| drag = _DragArea() |
| drag.setStyleSheet("background: transparent;") |
| drag_layout = QHBoxLayout(drag) |
| drag_layout.setContentsMargins(10, 0, 6, 0) |
| drag_layout.setSpacing(6) |
|
|
| title = QLabel("\u2630 LiveTrans") |
| title.setFont(QFont("Consolas", 9, QFont.Weight.Bold)) |
| title.setStyleSheet("color: #aaa; background: transparent;") |
| drag_layout.addWidget(title) |
| drag_layout.addStretch() |
| row1.addWidget(drag, 1) |
|
|
| def _btn(text, tip=None): |
| b = QPushButton(text) |
| b.setFixedHeight(20) |
| b.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) |
| b.setFont(QFont("Consolas", 8)) |
| b.setStyleSheet(_BTN_CSS) |
| if tip: |
| b.setToolTip(tip) |
| return b |
|
|
| self._running = False |
| self._start_stop_btn = _btn(t("paused")) |
| self._start_stop_btn.setFixedWidth(56) |
| self._start_stop_btn.clicked.connect(self._on_start_stop) |
| row1.addWidget(self._start_stop_btn) |
|
|
| clear_btn = _btn(t("clear")) |
| clear_btn.clicked.connect(self.clear_clicked.emit) |
| row1.addWidget(clear_btn) |
|
|
| settings_btn = _btn(t("settings")) |
| settings_btn.clicked.connect(self.settings_clicked.emit) |
| row1.addWidget(settings_btn) |
|
|
| self._monitor_expanded = True |
| self._monitor_btn = _btn(t("monitor")) |
| self._monitor_btn.clicked.connect(self._toggle_monitor) |
| row1.addWidget(self._monitor_btn) |
|
|
| quit_btn = _btn(t("quit")) |
| quit_btn.setStyleSheet( |
| _BTN_CSS.replace("rgba(255,255,255,20)", "rgba(200,60,60,40)").replace( |
| "rgba(255,255,255,40)", "rgba(200,60,60,80)" |
| ) |
| ) |
| quit_btn.clicked.connect(self.quit_clicked.emit) |
| row1.addWidget(quit_btn) |
|
|
| outer.addLayout(row1) |
|
|
| |
| row2 = QHBoxLayout() |
| row2.setContentsMargins(10, 0, 4, 2) |
| row2.setSpacing(6) |
|
|
| self._ct_check = QCheckBox(t("click_through")) |
| self._ct_check.setFont(QFont("Consolas", 8)) |
| self._ct_check.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) |
| self._ct_check.setStyleSheet(_CHECK_CSS) |
| self._ct_check.toggled.connect(self.click_through_toggled.emit) |
| row2.addWidget(self._ct_check) |
|
|
| self._topmost_check = QCheckBox(t("top_most")) |
| self._topmost_check.setFont(QFont("Consolas", 8)) |
| self._topmost_check.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) |
| self._topmost_check.setStyleSheet(_CHECK_CSS) |
| self._topmost_check.setChecked(True) |
| self._topmost_check.toggled.connect(self.topmost_toggled.emit) |
| row2.addWidget(self._topmost_check) |
|
|
| self._auto_scroll = QCheckBox(t("auto_scroll")) |
| self._auto_scroll.setFont(QFont("Consolas", 8)) |
| self._auto_scroll.setCursor(QCursor(Qt.CursorShape.PointingHandCursor)) |
| self._auto_scroll.setStyleSheet(_CHECK_CSS) |
| self._auto_scroll.setChecked(True) |
| self._auto_scroll.toggled.connect(self.auto_scroll_toggled.emit) |
| row2.addWidget(self._auto_scroll) |
|
|
| row2.addStretch() |
|
|
| model_lbl = QLabel(t("model_label")) |
| model_lbl.setFont(QFont("Consolas", 8)) |
| model_lbl.setStyleSheet("color: #888; background: transparent;") |
| row2.addWidget(model_lbl) |
|
|
| self._model_combo = QComboBox() |
| self._model_combo.setFixedHeight(18) |
| self._model_combo.setMinimumWidth(140) |
| self._model_combo.setFont(QFont("Consolas", 8)) |
| self._model_combo.setStyleSheet(_COMBO_CSS) |
| self._model_combo.currentIndexChanged.connect(self.model_changed.emit) |
| row2.addWidget(self._model_combo) |
|
|
| tgt_lbl = QLabel(t("target_label")) |
| tgt_lbl.setFont(QFont("Consolas", 8)) |
| tgt_lbl.setStyleSheet("color: #888; background: transparent;") |
| row2.addWidget(tgt_lbl) |
|
|
| self._target_lang = QComboBox() |
| self._target_lang.setFixedHeight(18) |
| self._target_lang.setFixedWidth(42) |
| self._target_lang.setFont(QFont("Consolas", 8)) |
| self._target_lang.setStyleSheet(_COMBO_CSS) |
| self._target_lang.addItems(["zh", "en", "ja", "ko", "fr", "de", "es", "ru"]) |
| self._target_lang.currentTextChanged.connect(self.target_language_changed.emit) |
| row2.addWidget(self._target_lang) |
|
|
| outer.addLayout(row2) |
|
|
| def _on_start_stop(self): |
| if self._running: |
| self.stop_clicked.emit() |
| else: |
| self.start_clicked.emit() |
|
|
| _PAUSED_CSS = _BTN_CSS.replace( |
| "rgba(255,255,255,20)", "rgba(220,180,60,50)" |
| ).replace("color: #aaa", "color: #ddb") |
|
|
| def set_target_language(self, lang: str): |
| idx = self._target_lang.findText(lang) |
| if idx >= 0: |
| self._target_lang.setCurrentIndex(idx) |
|
|
| def set_models(self, models: list, active_index: int = 0): |
| self._model_combo.blockSignals(True) |
| self._model_combo.clear() |
| for m in models: |
| self._model_combo.addItem(m.get("name", m.get("model", "?"))) |
| if 0 <= active_index < self._model_combo.count(): |
| self._model_combo.setCurrentIndex(active_index) |
| self._model_combo.blockSignals(False) |
|
|
|
|
|
|
| @property |
| def auto_scroll(self) -> bool: |
| return self._auto_scroll.isChecked() |
|
|
| def set_running(self, running: bool): |
| self._running = running |
| if running: |
| self._start_stop_btn.setText(t("running")) |
| self._start_stop_btn.setStyleSheet(_BTN_CSS) |
| else: |
| self._start_stop_btn.setText(t("paused")) |
| self._start_stop_btn.setStyleSheet(self._PAUSED_CSS) |
|
|
| def _toggle_monitor(self): |
| self._monitor_expanded = not self._monitor_expanded |
| self.monitor_toggled.emit(self._monitor_expanded) |
|
|
|
|
| class SubtitleOverlay(QWidget): |
| """Chat-style overlay window for displaying live transcription.""" |
|
|
| add_message_signal = pyqtSignal(int, str, str, str, float) |
| update_translation_signal = pyqtSignal(int, str, float) |
| clear_signal = pyqtSignal() |
| |
| update_monitor_signal = pyqtSignal(float, float) |
| update_stats_signal = pyqtSignal(int, int, int, int) |
| update_asr_device_signal = pyqtSignal(str) |
|
|
| settings_requested = pyqtSignal() |
| target_language_changed = pyqtSignal(str) |
| model_switch_requested = pyqtSignal(int) |
| start_requested = pyqtSignal() |
| stop_requested = pyqtSignal() |
| quit_requested = pyqtSignal() |
|
|
| def __init__(self, config): |
| super().__init__() |
| self._config = config |
| self._messages = {} |
| self._max_messages = 50 |
| self._click_through = False |
| self._setup_ui() |
|
|
| self.add_message_signal.connect(self._on_add_message) |
| self.update_translation_signal.connect(self._on_update_translation) |
| self.clear_signal.connect(self._on_clear) |
| self.update_monitor_signal.connect(self._on_update_monitor) |
| self.update_stats_signal.connect(self._on_update_stats) |
| self.update_asr_device_signal.connect(self._on_update_asr_device) |
|
|
| def _setup_ui(self): |
| self.setWindowFlags( |
| Qt.WindowType.FramelessWindowHint |
| | Qt.WindowType.WindowStaysOnTopHint |
| | Qt.WindowType.Tool |
| ) |
| self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground) |
| self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating) |
|
|
| screen = QApplication.primaryScreen() |
| geo = screen.geometry() |
| width = 620 |
| height = 500 |
| x = geo.width() - width - 20 |
| y = geo.height() - height - 60 |
| self.setGeometry(x, y, width, height) |
| self.setMinimumSize(480, 280) |
|
|
| main_layout = QVBoxLayout(self) |
| main_layout.setContentsMargins(0, 0, 0, 0) |
| main_layout.setSpacing(0) |
|
|
| self._container = QWidget() |
| self._container.setStyleSheet( |
| "background-color: rgba(15, 15, 25, 200); border-radius: 8px;" |
| ) |
|
|
| container_layout = QVBoxLayout(self._container) |
| container_layout.setContentsMargins(4, 4, 4, 4) |
| container_layout.setSpacing(0) |
|
|
| |
| self._handle = DragHandle() |
| self._handle.settings_clicked.connect(self.settings_requested.emit) |
| self._handle.monitor_toggled.connect(self._on_monitor_toggled) |
| self._handle.click_through_toggled.connect(self._set_click_through) |
| self._handle.topmost_toggled.connect(self._set_topmost) |
| self._handle.target_language_changed.connect(self.target_language_changed.emit) |
| self._handle.model_changed.connect(self.model_switch_requested.emit) |
| self._handle.start_clicked.connect(self.start_requested.emit) |
| self._handle.stop_clicked.connect(self.stop_requested.emit) |
| self._handle.clear_clicked.connect(self._on_clear) |
| self._handle.quit_clicked.connect(self.quit_requested.emit) |
| container_layout.addWidget(self._handle) |
|
|
| |
| self._monitor = MonitorBar() |
| container_layout.addWidget(self._monitor) |
|
|
| |
| self._scroll = QScrollArea() |
| self._scroll.setWidgetResizable(True) |
| self._scroll.setHorizontalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAlwaysOff) |
| self._scroll.setVerticalScrollBarPolicy(Qt.ScrollBarPolicy.ScrollBarAsNeeded) |
| self._scroll.setStyleSheet(""" |
| QScrollArea { border: none; background: transparent; } |
| QScrollBar:vertical { |
| width: 6px; background: transparent; |
| } |
| QScrollBar::handle:vertical { |
| background: rgba(255,255,255,60); border-radius: 3px; |
| min-height: 20px; |
| } |
| QScrollBar::add-line:vertical, QScrollBar::sub-line:vertical { |
| height: 0; |
| } |
| """) |
|
|
| self._msg_container = QWidget() |
| self._msg_container.setStyleSheet("background: transparent;") |
| self._msg_layout = QVBoxLayout(self._msg_container) |
| self._msg_layout.setContentsMargins(0, 0, 0, 0) |
| self._msg_layout.setSpacing(2) |
| self._msg_layout.addStretch() |
|
|
| self._scroll.setWidget(self._msg_container) |
| container_layout.addWidget(self._scroll) |
|
|
| grip_row = QHBoxLayout() |
| grip_row.addStretch() |
| self._grip = QSizeGrip(self) |
| self._grip.setFixedSize(16, 16) |
| self._grip.setStyleSheet("background: transparent;") |
| grip_row.addWidget(self._grip) |
| container_layout.addLayout(grip_row) |
|
|
| main_layout.addWidget(self._container) |
|
|
| self._ct_timer = QTimer(self) |
| self._ct_timer.timeout.connect(self._check_click_through) |
| self._ct_timer.start(50) |
|
|
| def set_running(self, running: bool): |
| self._handle.set_running(running) |
|
|
| def _set_topmost(self, enabled: bool): |
| flags = self.windowFlags() |
| if enabled: |
| flags |= Qt.WindowType.WindowStaysOnTopHint |
| else: |
| flags &= ~Qt.WindowType.WindowStaysOnTopHint |
| self.setWindowFlags(flags) |
| self.show() |
|
|
| def _set_click_through(self, enabled: bool): |
| self._click_through = enabled |
| if not enabled: |
| hwnd = int(self.winId()) |
| style = ctypes.windll.user32.GetWindowLongW(hwnd, _GWL_EXSTYLE) |
| if style & _WS_EX_TRANSPARENT: |
| ctypes.windll.user32.SetWindowLongW( |
| hwnd, _GWL_EXSTYLE, style & ~_WS_EX_TRANSPARENT |
| ) |
|
|
| def _check_click_through(self): |
| if not self._click_through: |
| return |
| cursor = QCursor.pos() |
| local = self.mapFromGlobal(cursor) |
| hwnd = int(self.winId()) |
| style = ctypes.windll.user32.GetWindowLongW(hwnd, _GWL_EXSTYLE) |
|
|
| scroll_top = self._scroll.mapTo(self, QPoint(0, 0)).y() |
| in_header = 0 <= local.x() <= self.width() and 0 <= local.y() < scroll_top |
|
|
| if in_header: |
| if style & _WS_EX_TRANSPARENT: |
| ctypes.windll.user32.SetWindowLongW( |
| hwnd, _GWL_EXSTYLE, style & ~_WS_EX_TRANSPARENT |
| ) |
| else: |
| if not (style & _WS_EX_TRANSPARENT): |
| ctypes.windll.user32.SetWindowLongW( |
| hwnd, _GWL_EXSTYLE, style | _WS_EX_TRANSPARENT |
| ) |
|
|
| def _on_monitor_toggled(self, expanded: bool): |
| self._monitor.setVisible(expanded) |
|
|
| @pyqtSlot(float, float) |
| def _on_update_monitor(self, rms: float, vad_conf: float): |
| self._monitor.update_audio(rms, vad_conf) |
|
|
| @pyqtSlot(int, int, int, int) |
| def _on_update_stats(self, asr_count, tl_count, prompt_tokens, completion_tokens): |
| self._monitor.update_pipeline_stats( |
| asr_count, tl_count, prompt_tokens, completion_tokens |
| ) |
|
|
| @pyqtSlot(str) |
| def _on_update_asr_device(self, device: str): |
| self._monitor.update_asr_device(device) |
|
|
| @pyqtSlot(int, str, str, str, float) |
| def _on_add_message(self, msg_id, timestamp, original, source_lang, asr_ms): |
| msg = ChatMessage(msg_id, timestamp, original, source_lang, asr_ms) |
| self._messages[msg_id] = msg |
| self._msg_layout.addWidget(msg) |
|
|
| if len(self._messages) > self._max_messages: |
| oldest_id = min(self._messages.keys()) |
| old_msg = self._messages.pop(oldest_id) |
| self._msg_layout.removeWidget(old_msg) |
| old_msg.deleteLater() |
|
|
| QTimer.singleShot(50, self._scroll_to_bottom) |
|
|
| @pyqtSlot(int, str, float) |
| def _on_update_translation(self, msg_id, translated, translate_ms): |
| msg = self._messages.get(msg_id) |
| if msg: |
| msg.set_translation(translated, translate_ms) |
| QTimer.singleShot(50, self._scroll_to_bottom) |
|
|
| @pyqtSlot() |
| def _on_clear(self): |
| for msg in self._messages.values(): |
| self._msg_layout.removeWidget(msg) |
| msg.deleteLater() |
| self._messages.clear() |
|
|
| def _scroll_to_bottom(self): |
| if not self._handle.auto_scroll: |
| return |
| sb = self._scroll.verticalScrollBar() |
| sb.setValue(sb.maximum()) |
|
|
| def apply_style(self, style: dict): |
| s = {**DEFAULT_STYLE, **style} |
| |
| if "font_family" in s and "original_font_family" not in style: |
| s["original_font_family"] = s["font_family"] |
| s["translation_font_family"] = s["font_family"] |
| |
| bg_rgba = _hex_to_rgba(s["bg_color"], s["bg_opacity"]) |
| self._container.setStyleSheet( |
| f"background-color: {bg_rgba}; border-radius: {s['border_radius']}px;" |
| ) |
| |
| hdr_rgba = _hex_to_rgba(s["header_color"], s["header_opacity"]) |
| self._handle.setStyleSheet(f"background: {hdr_rgba}; border-radius: 4px;") |
| |
| self.setWindowOpacity(s["window_opacity"] / 100.0) |
| |
| ChatMessage._current_style = s |
| for msg in self._messages.values(): |
| msg.apply_style(s) |
|
|
| |
| def add_message(self, msg_id, timestamp, original, source_lang, asr_ms): |
| self.add_message_signal.emit(msg_id, timestamp, original, source_lang, asr_ms) |
|
|
| def update_translation(self, msg_id, translated, translate_ms): |
| self.update_translation_signal.emit(msg_id, translated, translate_ms) |
|
|
| def update_monitor(self, rms, vad_conf): |
| self.update_monitor_signal.emit(rms, vad_conf) |
|
|
| def update_stats(self, asr_count, tl_count, prompt_tokens, completion_tokens): |
| self.update_stats_signal.emit( |
| asr_count, tl_count, prompt_tokens, completion_tokens |
| ) |
|
|
| def update_asr_device(self, device: str): |
| self.update_asr_device_signal.emit(device) |
|
|
| def set_target_language(self, lang: str): |
| self._handle.set_target_language(lang) |
|
|
| def set_models(self, models: list, active_index: int = 0): |
| self._handle.set_models(models, active_index) |
|
|
| def clear(self): |
| self.clear_signal.emit() |
|
|
