475 lines
20 KiB
Python
475 lines
20 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
AzaDiktatMixin – Diktat-Fenster (nur Transkription, keine KG).
|
||
"""
|
||
|
||
import os
|
||
import threading
|
||
import wave
|
||
import tkinter as tk
|
||
from tkinter import ttk, messagebox
|
||
from tkinter.scrolledtext import ScrolledText
|
||
|
||
from aza_persistence import (
|
||
load_diktat_geometry,
|
||
save_diktat_geometry,
|
||
save_to_ablage,
|
||
_win_clipboard_set,
|
||
sanitize_markdown_for_plain_text,
|
||
is_autocopy_after_diktat_enabled,
|
||
is_global_right_click_paste_enabled,
|
||
save_autocopy_prefs,
|
||
)
|
||
from aza_ui_helpers import (
|
||
center_window,
|
||
add_resize_grip,
|
||
add_font_scale_control,
|
||
add_text_font_size_control,
|
||
RoundedButton,
|
||
)
|
||
from aza_audio import AudioRecorder
|
||
|
||
|
||
class AzaDiktatMixin:
|
||
"""Mixin für das Diktat-Fenster (nur Aufnahme + Transkription)."""
|
||
|
||
def open_diktat_window(self):
|
||
"""Unabhängiges Fenster: nur Diktat aufnehmen und transkribieren (keine KG). Text wird automatisch kopiert."""
|
||
if not self.ensure_ready():
|
||
return
|
||
DIKTAT_MIN_W, DIKTAT_MIN_H = 420, 380
|
||
win = tk.Toplevel(self)
|
||
win.title("Diktat – nur Transkription")
|
||
win.minsize(DIKTAT_MIN_W, DIKTAT_MIN_H)
|
||
win.configure(bg="#B9ECFA")
|
||
win.attributes("-topmost", True)
|
||
self._diktat_window = win
|
||
self._register_window(win)
|
||
|
||
# Fensterposition: gespeichert laden oder zentrieren
|
||
saved_geom = load_diktat_geometry()
|
||
if saved_geom:
|
||
# Gespeicherte Position verwenden (Position wird beibehalten!)
|
||
win.geometry(saved_geom)
|
||
else:
|
||
# Keine gespeicherte Position → zentrieren
|
||
win.geometry("300x290")
|
||
center_window(win, 300, 290)
|
||
|
||
def on_diktat_close():
|
||
try:
|
||
geom = win.geometry()
|
||
save_diktat_geometry(geom)
|
||
except Exception:
|
||
pass
|
||
self._diktat_window = None
|
||
if hasattr(self, "_aza_windows"):
|
||
self._aza_windows.discard(win)
|
||
win.destroy()
|
||
if getattr(self, "_main_hidden", False):
|
||
try:
|
||
self.destroy()
|
||
except Exception:
|
||
pass
|
||
win.protocol("WM_DELETE_WINDOW", on_diktat_close)
|
||
|
||
# Speichere Position auch während Verschieben/Resize
|
||
_diktat_geom_after_id = [None]
|
||
def on_diktat_configure(e):
|
||
if e.widget is win and _diktat_geom_after_id[0]:
|
||
win.after_cancel(_diktat_geom_after_id[0])
|
||
if e.widget is win:
|
||
_diktat_geom_after_id[0] = win.after(400, lambda: save_diktat_geometry(win.geometry()))
|
||
win.bind("<Configure>", on_diktat_configure)
|
||
|
||
add_resize_grip(win, DIKTAT_MIN_W, DIKTAT_MIN_H)
|
||
add_font_scale_control(win)
|
||
|
||
# ─── Header mit Minimierungs-Button ───
|
||
diktat_header = tk.Frame(win, bg="#B9ECFA")
|
||
diktat_header.pack(fill="x")
|
||
tk.Label(diktat_header, text="🎙 Diktat", font=("Segoe UI", 12, "bold"),
|
||
bg="#B9ECFA", fg="#1a4d6d").pack(side="left", padx=10, pady=6)
|
||
|
||
_dik_minimized = [False]
|
||
_dik_geom_before = [None]
|
||
_dik_restoring = [False]
|
||
|
||
# Mini buttons + status (shown when minimized)
|
||
_mini_rec_btn = [None]
|
||
_mini_neu_btn = [None]
|
||
_mini_status_lbl = [None]
|
||
|
||
def _mini_toggle_record():
|
||
"""Start/Stop Aufnahme im minimierten Zustand."""
|
||
toggle_diktat()
|
||
if _mini_rec_btn[0]:
|
||
if is_recording[0]:
|
||
_mini_rec_btn[0].configure(text="⏹", fg="#D04040")
|
||
else:
|
||
_mini_rec_btn[0].configure(text="⏺", fg="#5A90B0")
|
||
|
||
def _mini_new_diktat():
|
||
"""Neu: Text leeren, laufende Aufnahme verwerfen, sofort neue Aufnahme starten."""
|
||
do_neu()
|
||
if _mini_rec_btn[0]:
|
||
if is_recording[0]:
|
||
_mini_rec_btn[0].configure(text="⏹", fg="#D04040")
|
||
else:
|
||
_mini_rec_btn[0].configure(text="⏺", fg="#5A90B0")
|
||
|
||
def _restore_diktat_content():
|
||
if not _dik_minimized[0]:
|
||
return
|
||
_dik_restoring[0] = True
|
||
if _mini_rec_btn[0]:
|
||
_mini_rec_btn[0].pack_forget()
|
||
if _mini_neu_btn[0]:
|
||
_mini_neu_btn[0].pack_forget()
|
||
if _mini_status_lbl[0]:
|
||
_mini_status_lbl[0]._parent_bar.pack_forget()
|
||
main_f.pack(fill="both", expand=True)
|
||
btn_minimize_dik.configure(text="—")
|
||
_dik_minimized[0] = False
|
||
win.minsize(DIKTAT_MIN_W, DIKTAT_MIN_H)
|
||
win.after(200, lambda: _dik_restoring.__setitem__(0, False))
|
||
|
||
def _toggle_minimize_diktat():
|
||
if _dik_minimized[0]:
|
||
_restore_diktat_content()
|
||
if _dik_geom_before[0]:
|
||
try:
|
||
win.geometry(_dik_geom_before[0])
|
||
except Exception:
|
||
pass
|
||
else:
|
||
_dik_geom_before[0] = win.geometry()
|
||
main_f.pack_forget()
|
||
btn_minimize_dik.configure(text="□")
|
||
_dik_minimized[0] = True
|
||
win.minsize(200, 74)
|
||
w_cur = win.winfo_width()
|
||
win.geometry(f"{w_cur}x74")
|
||
# Show mini record button
|
||
rec_text = "⏹" if is_recording[0] else "⏺"
|
||
rec_fg = "#D04040" if is_recording[0] else "#5A90B0"
|
||
if not _mini_rec_btn[0]:
|
||
_mini_rec_btn[0] = tk.Label(diktat_header, text=rec_text, font=("Segoe UI", 14, "bold"),
|
||
bg="#B9ECFA", fg=rec_fg, cursor="hand2", padx=4)
|
||
_mini_rec_btn[0].bind("<Button-1>", lambda e: _mini_toggle_record())
|
||
_mini_rec_btn[0].bind("<Enter>", lambda e: _mini_rec_btn[0].configure(fg="#1a4d6d"))
|
||
_mini_rec_btn[0].bind("<Leave>", lambda e: _mini_rec_btn[0].configure(
|
||
fg="#D04040" if is_recording[0] else "#5A90B0"))
|
||
else:
|
||
_mini_rec_btn[0].configure(text=rec_text, fg=rec_fg)
|
||
_mini_rec_btn[0].pack(side="left", padx=(0, 4))
|
||
if not _mini_neu_btn[0]:
|
||
_mini_neu_btn[0] = tk.Label(diktat_header, text="Neu", font=("Segoe UI", 9),
|
||
bg="#B9ECFA", fg="#5A90B0", cursor="hand2", padx=4)
|
||
_mini_neu_btn[0].bind("<Button-1>", lambda e: _mini_new_diktat())
|
||
_mini_neu_btn[0].bind("<Enter>", lambda e: _mini_neu_btn[0].configure(fg="#1a4d6d"))
|
||
_mini_neu_btn[0].bind("<Leave>", lambda e: _mini_neu_btn[0].configure(fg="#5A90B0"))
|
||
_mini_neu_btn[0].pack(side="left", padx=(0, 4))
|
||
# Show mini status bar below header
|
||
if not _mini_status_lbl[0]:
|
||
_mini_status_bar = tk.Frame(win, bg="#FFE4CC", height=22, padx=6, pady=2)
|
||
_mini_status_lbl[0] = tk.Label(
|
||
_mini_status_bar, textvariable=status_var,
|
||
fg="#BD4500", bg="#FFE4CC",
|
||
font=("Segoe UI", 8), anchor="w",
|
||
)
|
||
_mini_status_lbl[0].pack(side="left", fill="x", expand=True)
|
||
_mini_status_lbl[0]._parent_bar = _mini_status_bar
|
||
_mini_status_lbl[0]._parent_bar.pack(fill="x")
|
||
_mini_status_lbl[0].pack(side="left", fill="x", expand=True)
|
||
|
||
def _on_dik_configure(e):
|
||
if e.widget is not win:
|
||
return
|
||
if _dik_minimized[0] and not _dik_restoring[0] and e.height > 95:
|
||
_restore_diktat_content()
|
||
|
||
win.bind("<Configure>", _on_dik_configure, add="+")
|
||
|
||
btn_minimize_dik = tk.Label(diktat_header, text="—", font=("Segoe UI", 12, "bold"),
|
||
bg="#B9ECFA", fg="#5A90B0", cursor="hand2", padx=6)
|
||
btn_minimize_dik.pack(side="right", padx=(0, 8))
|
||
btn_minimize_dik.bind("<Button-1>", lambda e: _toggle_minimize_diktat())
|
||
btn_minimize_dik.bind("<Enter>", lambda e: btn_minimize_dik.configure(fg="#1a4d6d"))
|
||
btn_minimize_dik.bind("<Leave>", lambda e: btn_minimize_dik.configure(fg="#5A90B0"))
|
||
|
||
win._aza_minimize = _toggle_minimize_diktat
|
||
win._aza_is_minimized = lambda: _dik_minimized[0]
|
||
if hasattr(self, "_aza_windows"):
|
||
self._aza_windows.add(win)
|
||
|
||
main_f = ttk.Frame(win, padding=12)
|
||
main_f.pack(fill="both", expand=True)
|
||
|
||
# Label + Schriftgrößen-Steuerung
|
||
label_frame = ttk.Frame(main_f)
|
||
label_frame.pack(fill="x", anchor="w")
|
||
ttk.Label(label_frame, text="Diktat (nur Transkription):").pack(side="left")
|
||
|
||
# Modus auch direkt im Diktat-Fenster: Medizin vs. Allgemein (exklusiv)
|
||
if not hasattr(self, "_transcribe_medical_var"):
|
||
self._transcribe_medical_var = tk.BooleanVar(value=True)
|
||
if not hasattr(self, "_transcribe_general_var"):
|
||
self._transcribe_general_var = tk.BooleanVar(value=False)
|
||
if not hasattr(self, "_transcribe_toggle_guard"):
|
||
self._transcribe_toggle_guard = False
|
||
|
||
def _set_mode(domain_value: str):
|
||
if hasattr(self, "_set_transcribe_domain"):
|
||
self._set_transcribe_domain(domain_value)
|
||
return
|
||
# Fallback ohne Hauptmethode
|
||
if domain_value == "general":
|
||
self._transcribe_medical_var.set(False)
|
||
self._transcribe_general_var.set(True)
|
||
else:
|
||
self._transcribe_medical_var.set(True)
|
||
self._transcribe_general_var.set(False)
|
||
|
||
def _on_med_toggle():
|
||
if self._transcribe_medical_var.get():
|
||
_set_mode("medical")
|
||
elif not self._transcribe_general_var.get():
|
||
_set_mode("medical")
|
||
|
||
def _on_gen_toggle():
|
||
if self._transcribe_general_var.get():
|
||
_set_mode("general")
|
||
elif not self._transcribe_medical_var.get():
|
||
_set_mode("medical")
|
||
|
||
tk.Checkbutton(
|
||
label_frame, text="Medizin", variable=self._transcribe_medical_var,
|
||
command=_on_med_toggle, bg="#B9ECFA", fg="#1a4d6d",
|
||
activebackground="#B9ECFA", selectcolor="#E8F4FA",
|
||
).pack(side="left", padx=(10, 4))
|
||
tk.Checkbutton(
|
||
label_frame, text="Allgemein", variable=self._transcribe_general_var,
|
||
command=_on_gen_toggle, bg="#B9ECFA", fg="#1a4d6d",
|
||
activebackground="#B9ECFA", selectcolor="#E8F4FA",
|
||
).pack(side="left")
|
||
|
||
# Kleinere Schrift für bessere Lesbarkeit (8pt statt 10pt)
|
||
diktat_font = ("Segoe UI", 8)
|
||
txt = ScrolledText(main_f, wrap="word", font=diktat_font, bg="#F5FCFF", height=8)
|
||
txt.pack(fill="both", expand=True, pady=(4, 4))
|
||
|
||
# Schriftgrößen-Spinbox in Fensterhintergrundfarbe
|
||
add_text_font_size_control(label_frame, txt, initial_size=8, bg_color="#B9ECFA", save_key="diktat_window")
|
||
|
||
self._bind_textblock_pending(txt)
|
||
status_var = tk.StringVar(value="Bereit.")
|
||
status_bar = tk.Frame(main_f, bg="#FFE4CC", height=24, padx=8, pady=4)
|
||
status_bar.pack(fill="x", pady=(4, 0))
|
||
status_bar.pack_propagate(False)
|
||
lbl_status = tk.Label(
|
||
status_bar, textvariable=status_var, fg="#BD4500", bg="#FFE4CC",
|
||
font=("Segoe UI", 8), anchor="w",
|
||
)
|
||
lbl_status.pack(side="left", fill="x", expand=True)
|
||
cb_row = tk.Frame(main_f, bg="#B9ECFA")
|
||
cb_row.pack(fill="x", pady=(2, 0))
|
||
_diktat_autocopy_var = tk.BooleanVar(value=is_autocopy_after_diktat_enabled())
|
||
ttk.Checkbutton(
|
||
cb_row, text="Autokopie nach Transkription",
|
||
variable=_diktat_autocopy_var,
|
||
command=lambda: save_autocopy_prefs(autocopy=_diktat_autocopy_var.get()),
|
||
).pack(side="left")
|
||
_diktat_rclick_var = tk.BooleanVar(value=is_global_right_click_paste_enabled())
|
||
ttk.Checkbutton(
|
||
cb_row, text="Rechtsklick = Einfügen",
|
||
variable=_diktat_rclick_var,
|
||
command=lambda: save_autocopy_prefs(global_right_click=_diktat_rclick_var.get()),
|
||
).pack(side="left", padx=(12, 0))
|
||
|
||
btn_row = ttk.Frame(main_f, padding=(0, 4, 0, 0))
|
||
btn_row.pack(fill="x")
|
||
btn_row2 = ttk.Frame(main_f, padding=(0, 2, 0, 0))
|
||
btn_row2.pack(fill="x")
|
||
diktat_recorder = [None]
|
||
is_recording = [False]
|
||
|
||
def toggle_diktat():
|
||
if not diktat_recorder[0]:
|
||
diktat_recorder[0] = AudioRecorder()
|
||
rec = diktat_recorder[0]
|
||
if not is_recording[0]:
|
||
try:
|
||
rec.start()
|
||
is_recording[0] = True
|
||
btn_diktat_record.configure(text="⏹ Aufnahme stoppen")
|
||
status_var.set("Aufnahme läuft…")
|
||
except Exception as e:
|
||
messagebox.showerror("Aufnahme-Fehler", str(e))
|
||
status_var.set("Bereit.")
|
||
else:
|
||
is_recording[0] = False
|
||
btn_diktat_record.configure(text="⏺ Aufnahme starten")
|
||
status_var.set("Transkribiere…")
|
||
|
||
def worker():
|
||
def _safe_after(fn):
|
||
try:
|
||
if self.winfo_exists():
|
||
self.after(0, fn)
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
wav_path = rec.stop_and_save_wav()
|
||
|
||
try:
|
||
with wave.open(wav_path, 'rb') as wf:
|
||
frames = wf.getnframes()
|
||
framerate = wf.getframerate()
|
||
duration = frames / float(framerate)
|
||
|
||
if duration < 0.3:
|
||
try:
|
||
if os.path.exists(wav_path):
|
||
os.remove(wav_path)
|
||
except Exception:
|
||
pass
|
||
diktat_recorder[0] = None
|
||
_safe_after(lambda: status_var.set("Kein Audio erkannt."))
|
||
return
|
||
except Exception:
|
||
pass
|
||
|
||
transcript_result = self.transcribe_wav(wav_path)
|
||
|
||
if hasattr(transcript_result, 'text'):
|
||
transcript_text = transcript_result.text
|
||
elif isinstance(transcript_result, str):
|
||
transcript_text = transcript_result
|
||
else:
|
||
transcript_text = ""
|
||
|
||
try:
|
||
if os.path.exists(wav_path):
|
||
os.remove(wav_path)
|
||
except Exception:
|
||
pass
|
||
|
||
if not transcript_text or not transcript_text.strip():
|
||
diktat_recorder[0] = None
|
||
_safe_after(lambda: status_var.set("Kein Text erkannt."))
|
||
return
|
||
|
||
transcript_text = self._diktat_apply_punctuation(transcript_text)
|
||
|
||
if not transcript_text or not transcript_text.strip():
|
||
diktat_recorder[0] = None
|
||
_safe_after(lambda: status_var.set("Kein Text erkannt."))
|
||
return
|
||
|
||
_safe_after(lambda: _done(transcript_text))
|
||
except Exception as e:
|
||
def _show_err(err=e):
|
||
try:
|
||
if win.winfo_exists():
|
||
messagebox.showerror("Fehler", str(err), parent=win)
|
||
status_var.set("Fehler.")
|
||
except Exception:
|
||
pass
|
||
_safe_after(_show_err)
|
||
|
||
def _done(text):
|
||
diktat_recorder[0] = None
|
||
try:
|
||
if not win.winfo_exists():
|
||
return
|
||
txt.configure(state="normal")
|
||
idx = txt.index(tk.INSERT)
|
||
txt.insert(idx, text)
|
||
full = txt.get("1.0", "end").strip()
|
||
copied = False
|
||
if _diktat_autocopy_var.get() and full:
|
||
if not _win_clipboard_set(full):
|
||
try:
|
||
self.clipboard_clear()
|
||
self.clipboard_append(sanitize_markdown_for_plain_text(full))
|
||
except Exception:
|
||
pass
|
||
copied = True
|
||
if full:
|
||
try:
|
||
save_to_ablage("Diktat", full)
|
||
except Exception:
|
||
pass
|
||
if copied:
|
||
self.set_status("Diktat transkribiert und kopiert.")
|
||
status_var.set("Fertig. Kopiert.")
|
||
else:
|
||
self.set_status("Diktat transkribiert.")
|
||
status_var.set("Fertig.")
|
||
except Exception:
|
||
pass
|
||
|
||
threading.Thread(target=worker, daemon=True).start()
|
||
|
||
def do_neu():
|
||
if is_recording[0]:
|
||
if not messagebox.askyesno(
|
||
"Aufnahme läuft",
|
||
"Es läuft gerade eine Aufnahme.\n"
|
||
"Möchtest du die aktuelle Aufnahme wirklich verwerfen und neu starten?",
|
||
parent=win
|
||
):
|
||
return
|
||
rec = diktat_recorder[0]
|
||
is_recording[0] = False
|
||
btn_diktat_record.configure(text="⏺ Aufnahme starten")
|
||
try:
|
||
wav_path = rec.stop_and_save_wav()
|
||
if os.path.exists(wav_path):
|
||
os.remove(wav_path)
|
||
except Exception:
|
||
pass
|
||
diktat_recorder[0] = None
|
||
txt.configure(state="normal")
|
||
txt.delete("1.0", "end")
|
||
status_var.set("Bereit.")
|
||
toggle_diktat()
|
||
|
||
def do_kopieren():
|
||
t = txt.get("1.0", "end").strip()
|
||
if t:
|
||
if not _win_clipboard_set(t):
|
||
self.clipboard_clear()
|
||
self.clipboard_append(sanitize_markdown_for_plain_text(t))
|
||
self.set_status("Diktat kopiert.")
|
||
else:
|
||
self.set_status("Nichts zum Kopieren.")
|
||
|
||
def do_clear_text():
|
||
txt.configure(state="normal")
|
||
txt.delete("1.0", "end")
|
||
status_var.set("Diktatfeld geleert.")
|
||
self.set_status("Diktatfeld geleert.")
|
||
|
||
btn_diktat_record = RoundedButton(
|
||
btn_row, "⏺ Aufnahme starten", command=toggle_diktat,
|
||
width=160, height=26, canvas_bg="#B9ECFA",
|
||
)
|
||
btn_diktat_record.pack(side="left")
|
||
RoundedButton(
|
||
btn_row, "Neu", command=do_neu,
|
||
width=70, height=26, canvas_bg="#B9ECFA",
|
||
).pack(side="left", padx=(6, 0))
|
||
RoundedButton(
|
||
btn_row2, "Kopieren", command=do_kopieren,
|
||
width=100, height=26, canvas_bg="#B9ECFA",
|
||
).pack(side="left")
|
||
RoundedButton(
|
||
btn_row2, "X", command=do_clear_text,
|
||
width=34, height=26, canvas_bg="#B9ECFA",
|
||
).pack(side="left", padx=(6, 0))
|
||
if self._autotext_data.get("diktat_auto_start", True):
|
||
win.after(350, toggle_diktat)
|