344 lines
15 KiB
Python
344 lines
15 KiB
Python
"""Overlay de dictée : barre sombre arrondie posée en bas de l'écran (Qt).
|
|
|
|
Copie conforme de `interface/cocoa.py`, pour les plateformes sans Cocoa
|
|
(Windows aujourd'hui). Mêmes trois zones, de gauche à droite : un bouton stop
|
|
rond rouge-orange, une forme d'onde en barres verticales, une icône de micro.
|
|
Au-dessus, une bulle sombre affiche l'état en cours.
|
|
|
|
Qt natif (PySide6). Tout le dessin a lieu sur le thread principal via un
|
|
QTimer ; les niveaux audio arrivent d'un thread de fond par set_level(), et
|
|
l'historique qui alimente la forme d'onde est protégé par un verrou — même
|
|
disposition que Cocoa.
|
|
|
|
Repère : Qt place l'origine en HAUT à gauche (y croît vers le bas), alors que
|
|
Cocoa la place en BAS à gauche (y croît vers le haut). C'est la source
|
|
d'erreur la plus probable d'un portage Cocoa → Qt : décaler un signe à un
|
|
seul endroit du dessin fait sortir une forme du mauvais côté sans qu'aucun
|
|
test ne le révèle (cf. les 42 tests verts du 21/08 pendant qu'une icône
|
|
sortait en tache blanche — seule une capture d'écran l'a montré). On bascule
|
|
donc le repère une seule fois, ici, avant de dessiner les formes qui
|
|
raisonnent comme Cocoa ; le texte de la bulle est dessiné à part, hors de ce
|
|
repère basculé, pour ne pas sortir à l'envers.
|
|
"""
|
|
import threading
|
|
|
|
from PySide6.QtCore import QPointF, QRectF, Qt, QTimer
|
|
from PySide6.QtGui import QColor, QFontMetrics, QGuiApplication, QPainter, QPainterPath, QPen
|
|
from PySide6.QtWidgets import QApplication, QWidget
|
|
|
|
from audio_level import bar_heights, push_level
|
|
from core import CONFIG, bar_metrics
|
|
|
|
_BOTTOM_MARGIN = 80.0 # au-dessus de la barre des tâches
|
|
_BUBBLE_GAP = 12.0 # espace entre la bulle et la barre
|
|
_BUBBLE_PAD = 12.0 # marge intérieure de la bulle
|
|
_TAIL = 7.0 # demi-largeur de la pointe de la bulle
|
|
_BOTTOM_INSET = 8.0 # évite que l'arrondi bas de la barre touche le bord
|
|
|
|
|
|
def _qcolor(triplet, alpha=1.0):
|
|
r, g, b = triplet[:3]
|
|
c = QColor()
|
|
c.setRgbF(r, g, b, alpha)
|
|
return c
|
|
|
|
|
|
class VueOverlay(QWidget):
|
|
"""Dessine la barre, la forme d'onde et la bulle d'état.
|
|
|
|
Widget Qt top-level SANS PARENT : Qt n'exige pas, contrairement à Cocoa,
|
|
une fenêtre (NSWindow) séparée de sa vue de contenu (NSView) — un QWidget
|
|
sans parent EST déjà une fenêtre. Cette classe joue donc les deux rôles :
|
|
« vue qui dessine » ET « fenêtre affichée », la façade `OverlayQt`
|
|
n'ayant qu'à la montrer/masquer.
|
|
"""
|
|
|
|
def __init__(self):
|
|
super().__init__()
|
|
self._bars = []
|
|
self._status = ""
|
|
# Fenêtre sans cadre, toujours au-dessus, à fond transparent, et
|
|
# transparente aux clics : la souris doit traverser l'overlay jusqu'à
|
|
# l'application en dessous (Qt.WindowTransparentForInput).
|
|
self.setWindowFlags(
|
|
Qt.WindowType.FramelessWindowHint
|
|
| Qt.WindowType.WindowStaysOnTopHint
|
|
| Qt.WindowType.Tool
|
|
| Qt.WindowType.WindowTransparentForInput
|
|
)
|
|
self.setAttribute(Qt.WidgetAttribute.WA_TranslucentBackground)
|
|
self.setAttribute(Qt.WidgetAttribute.WA_ShowWithoutActivating, True)
|
|
|
|
def set_bars(self, bars):
|
|
self._bars = bars
|
|
|
|
def set_status(self, text):
|
|
self._status = text or ""
|
|
|
|
# --- morceaux de dessin (repère Cocoa : y croît vers le HAUT) ---------
|
|
def _draw_bar_background(self, painter, x, y, w, h):
|
|
painter.setBrush(_qcolor(CONFIG["bar_bg_rgba"], CONFIG["bar_bg_rgba"][3]))
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.drawRoundedRect(
|
|
QRectF(x, y, w, h), CONFIG["bar_radius"], CONFIG["bar_radius"]
|
|
)
|
|
|
|
def _draw_stop_button(self, painter, cx, cy, diametre):
|
|
painter.setBrush(_qcolor(CONFIG["stop_button_rgb"]))
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.drawEllipse(QPointF(cx, cy), diametre / 2, diametre / 2)
|
|
# carré arrondi blanc au centre = « arrêter »
|
|
side = diametre * 0.34
|
|
painter.setBrush(_qcolor(CONFIG["stop_glyph_rgb"]))
|
|
painter.drawRoundedRect(QRectF(cx - side / 2, cy - side / 2, side, side), 2.0, 2.0)
|
|
|
|
def _draw_waveform(self, painter, x0, cy, width):
|
|
bars = self._bars
|
|
if not bars:
|
|
return
|
|
n = len(bars)
|
|
step = width / float(n)
|
|
bw = max(2.0, step * 0.38)
|
|
half_max = CONFIG["bar_height"] * 0.30 # amplitude verticale max
|
|
painter.setBrush(_qcolor(CONFIG["waveform_rgb"]))
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
for i, level in enumerate(bars):
|
|
cxi = x0 + step * (i + 0.5)
|
|
half = max(bw / 2.0, level * half_max) # jamais moins qu'un point rond
|
|
painter.drawRoundedRect(
|
|
QRectF(cxi - bw / 2, cy - half, bw, half * 2), bw / 2, bw / 2
|
|
)
|
|
|
|
def _draw_mic(self, painter, cx, cy, m):
|
|
painter.setBrush(_qcolor(CONFIG["mic_rgb"]))
|
|
largeur = m["mic_largeur"]
|
|
body_h = m["mic_corps_hauteur"]
|
|
body_y = cy - body_h / 2 + body_h * 0.23
|
|
# capsule (le micro lui-même)
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.drawRoundedRect(
|
|
QRectF(cx - largeur / 2, body_y, largeur, body_h), largeur / 2, largeur / 2
|
|
)
|
|
# arceau en U qui passe SOUS la capsule. PIÈGE vérifié par capture
|
|
# d'écran (cf tâche) : `drawArc` mesure ses angles dans le repère
|
|
# ÉCRAN natif de Qt (0° = 3 h, sens visuellement anti-horaire), et ne
|
|
# tient PAS compte du basculement `scale(1, -1)` appliqué plus haut —
|
|
# contrairement aux formes remplies (rect, ellipse), qui suivent la
|
|
# transformation courante. Un premier essai avec les bornes de Cocoa
|
|
# telles quelles (195°→345°) donnait un arc reflété verticalement
|
|
# (ouvert vers le BAS, au-dessus de la capsule au lieu de dessous).
|
|
# On compense en reflétant l'angle : depart' = -(depart+etendue),
|
|
# etendue' = etendue.
|
|
rayon = m["mic_arceau_rayon"]
|
|
arc_cx, arc_cy = cx, body_y + body_h * 0.23
|
|
depart_cocoa, etendue_cocoa = 195, 345 - 195
|
|
depart = -(depart_cocoa + etendue_cocoa) % 360
|
|
# QPen neuf : `painter.pen()` aurait hérité le style NoPen laissé par
|
|
# le dessin de la capsule juste au-dessus — un pen NoPen ignore
|
|
# silencieusement couleur et épaisseur, l'arc ne se serait jamais vu.
|
|
pen = QPen(_qcolor(CONFIG["mic_rgb"]))
|
|
pen.setWidthF(max(1.0, body_h * 0.12))
|
|
pen.setCapStyle(Qt.PenCapStyle.RoundCap)
|
|
painter.setPen(pen)
|
|
painter.setBrush(Qt.BrushStyle.NoBrush)
|
|
rect_arc = QRectF(arc_cx - rayon, arc_cy - rayon, rayon * 2, rayon * 2)
|
|
painter.drawArc(rect_arc, depart * 16, etendue_cocoa * 16)
|
|
# pied vertical sous l'arceau
|
|
pied = max(1.2, largeur * 0.18)
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
painter.setBrush(_qcolor(CONFIG["mic_rgb"]))
|
|
painter.drawRoundedRect(
|
|
QRectF(cx - pied / 2, body_y - body_h * 0.62, pied, body_h * 0.31),
|
|
pied / 2, pied / 2,
|
|
)
|
|
|
|
def _bubble_box(self, bar_x, bar_top, bar_w):
|
|
"""Géométrie de la bulle (repère Cocoa), ou None si aucun texte."""
|
|
if not self._status:
|
|
return None
|
|
font = self.font()
|
|
font.setPointSizeF(CONFIG["bubble_font_size"])
|
|
metrics = QFontMetrics(font)
|
|
bounds = metrics.boundingRect(
|
|
QRectF(0, 0, CONFIG["bubble_max_width"], 400.0).toRect(),
|
|
int(Qt.TextFlag.TextWordWrap),
|
|
self._status,
|
|
)
|
|
tw, th = float(bounds.width()), float(bounds.height())
|
|
w, h = tw + 2 * _BUBBLE_PAD, th + 2 * _BUBBLE_PAD
|
|
x = bar_x + CONFIG["bar_height"] * 0.46 # alignée à gauche, comme la référence
|
|
y = bar_top + _BUBBLE_GAP
|
|
return {"x": x, "y": y, "w": w, "h": h, "tw": tw, "th": th, "font": font}
|
|
|
|
def _draw_bubble_shape(self, painter, box):
|
|
painter.setBrush(_qcolor(CONFIG["bar_bg_rgba"], CONFIG["bar_bg_rgba"][3]))
|
|
painter.setPen(Qt.PenStyle.NoPen)
|
|
x, y, w, h = box["x"], box["y"], box["w"], box["h"]
|
|
painter.drawRoundedRect(QRectF(x, y, w, h), 10.0, 10.0)
|
|
# petite pointe vers la barre, en bas à gauche
|
|
tail = QPainterPath()
|
|
tail.moveTo(x + 20.0 - _TAIL, y + 1.0)
|
|
tail.lineTo(x + 20.0 + _TAIL, y + 1.0)
|
|
tail.lineTo(x + 20.0, y - 7.0)
|
|
tail.closeSubpath()
|
|
painter.drawPath(tail)
|
|
|
|
def paintEvent(self, event):
|
|
# `with` ferme le QPainter (.end()) meme si une exception surgit en
|
|
# cours de dessin : sans ca, la fermeture ne tenait qu'au comptage de
|
|
# references de PySide6 — suffisant aujourd'hui, fragile demain.
|
|
with QPainter(self) as painter:
|
|
painter.setRenderHint(QPainter.RenderHint.Antialiasing, True)
|
|
|
|
w = CONFIG["bar_width"]
|
|
h = CONFIG["bar_height"]
|
|
x = (self.width() - w) / 2.0
|
|
y = _BOTTOM_INSET
|
|
cy = y + h / 2.0
|
|
|
|
m = bar_metrics(h)
|
|
pad, stop_d, mic_w, ecart = (
|
|
m["marge_laterale"], m["stop_diametre"], m["mic_largeur"], m["ecart_interne"]
|
|
)
|
|
bubble = self._bubble_box(x, y + h, w)
|
|
|
|
# Bascule de repère : à partir d'ici, y croît vers le HAUT comme dans
|
|
# Cocoa (voir docstring du module). On la retire (`restore`) avant de
|
|
# dessiner le texte de la bulle plus bas, pour qu'il ne sorte pas à
|
|
# l'envers.
|
|
painter.save()
|
|
painter.translate(0, self.height())
|
|
painter.scale(1, -1)
|
|
|
|
self._draw_bar_background(painter, x, y, w, h)
|
|
self._draw_stop_button(painter, x + pad + stop_d / 2, cy, stop_d)
|
|
self._draw_mic(painter, x + w - pad - mic_w / 2, cy, m)
|
|
wave_x = x + pad + stop_d + ecart
|
|
wave_w = (x + w - pad - mic_w - ecart) - wave_x
|
|
self._draw_waveform(painter, wave_x, cy, wave_w)
|
|
if bubble is not None:
|
|
self._draw_bubble_shape(painter, bubble)
|
|
|
|
painter.restore()
|
|
|
|
if bubble is not None:
|
|
# Repère Qt normal (y vers le bas) : on convertit le coin bas-gauche
|
|
# « repère Cocoa » de la bulle en un rectangle Qt haut-gauche.
|
|
text_top_qt = self.height() - (bubble["y"] + _BUBBLE_PAD + bubble["th"])
|
|
painter.setFont(bubble["font"])
|
|
painter.setPen(_qcolor(CONFIG["bubble_text_rgb"]))
|
|
painter.drawText(
|
|
QRectF(bubble["x"] + _BUBBLE_PAD, text_top_qt, bubble["tw"], bubble["th"]),
|
|
int(Qt.TextFlag.TextWordWrap),
|
|
self._status,
|
|
)
|
|
|
|
|
|
class OverlayQt:
|
|
"""Fenêtre flottante Qt : show(), hide(), set_level(), set_status(). Thread-safe.
|
|
|
|
Contrairement à `PulseWindow` (NSObject, exige `alloc().init()`), c'est une
|
|
classe Python ordinaire : `classe_overlay_pour("win32")()` suffit.
|
|
"""
|
|
|
|
def __init__(self):
|
|
self._history = []
|
|
self._status = ""
|
|
self._lock = threading.Lock()
|
|
self._view = None
|
|
self._timer = None
|
|
self._garde = None # ferme l'overlay quoi qu'il arrive (cf show)
|
|
|
|
def _window_size(self):
|
|
return (CONFIG["bar_width"] + 80.0,
|
|
CONFIG["bar_height"] + _BOTTOM_INSET + 140.0)
|
|
|
|
def _ensure_view(self):
|
|
if self._view is not None:
|
|
return
|
|
# PySide6 est déjà exigé dès l'IMPORT de ce module (QWidget, QTimer...
|
|
# ci-dessus) : le report réel n'est pas ici, mais dans la fabrique
|
|
# (interface/__init__.py::classe_overlay_pour), qui n'importe
|
|
# `interface.qt` que pour la branche win32 — jamais sur ce Mac, où
|
|
# Cocoa suffit.
|
|
if QApplication.instance() is None:
|
|
QApplication([])
|
|
|
|
ww, wh = self._window_size()
|
|
self._view = VueOverlay()
|
|
self._view.resize(int(ww), int(wh))
|
|
ecran = QGuiApplication.primaryScreen().geometry()
|
|
px = ecran.left() + (ecran.width() - ww) / 2.0
|
|
py = ecran.top() + ecran.height() - _BOTTOM_MARGIN - wh
|
|
self._view.move(int(px), int(py))
|
|
|
|
def set_level(self, level):
|
|
"""Pousse le dernier niveau audio (appelable depuis un thread de fond)."""
|
|
with self._lock:
|
|
self._history = push_level(self._history, level, CONFIG["waveform_bars"])
|
|
|
|
def set_status(self, text):
|
|
"""Texte affiché dans la bulle (thread de fond autorisé)."""
|
|
with self._lock:
|
|
self._status = text or ""
|
|
|
|
def _tick(self):
|
|
with self._lock:
|
|
history, status = list(self._history), self._status
|
|
if self._view is not None:
|
|
self._view.set_bars(
|
|
bar_heights(history, CONFIG["waveform_bars"], CONFIG["waveform_floor"])
|
|
)
|
|
self._view.set_status(status)
|
|
self._view.update()
|
|
|
|
def show(self):
|
|
"""Affiche la fenêtre et démarre l'animation. Thread principal."""
|
|
self._ensure_view()
|
|
with self._lock:
|
|
self._history = []
|
|
self._view.show()
|
|
self._timer = QTimer()
|
|
self._timer.timeout.connect(self._tick)
|
|
self._timer.start(int(1000.0 / float(CONFIG["fps"])))
|
|
# Garde-fou : la fenêtre porte sa propre durée de vie. Si le contrôleur
|
|
# échoue à la refermer — transcription bloquée, thread mort, bug en
|
|
# amont — elle se ferme seule plutôt que de rester figée à l'écran
|
|
# (même correctif que Cocoa, 2026-08-21).
|
|
self._garde = QTimer()
|
|
self._garde.setSingleShot(True)
|
|
self._garde.timeout.connect(self._expiration)
|
|
self._garde.start(int(float(CONFIG["duree_max_overlay_s"]) * 1000.0))
|
|
|
|
def rearmer_garde(self, duree_s):
|
|
"""Remplace la garde en cours par une plus courte. Thread principal.
|
|
|
|
Appelée au passage en transcription : la garde longue couvre un
|
|
enregistrement de 2 min, mais une fois l'enregistrement fini il ne
|
|
reste que quelques secondes de calcul — inutile de laisser un halo
|
|
trois minutes.
|
|
"""
|
|
if self._garde is not None:
|
|
self._garde.stop()
|
|
self._garde = QTimer()
|
|
self._garde.setSingleShot(True)
|
|
self._garde.timeout.connect(self._expiration)
|
|
self._garde.start(int(float(duree_s) * 1000.0))
|
|
|
|
def _expiration(self):
|
|
print("[garde] overlay ouvert trop longtemps — fermeture forcée")
|
|
self.hide()
|
|
|
|
def hide(self):
|
|
"""Arrête l'animation et masque la fenêtre. Thread principal."""
|
|
if self._timer is not None:
|
|
self._timer.stop()
|
|
self._timer = None
|
|
if self._garde is not None:
|
|
self._garde.stop()
|
|
self._garde = None
|
|
if self._view is not None:
|
|
self._view.hide()
|
|
with self._lock:
|
|
self._status = ""
|