2007 lines
68 KiB
Python
2007 lines
68 KiB
Python
# -*- coding: utf-8 -*-
|
||
"""
|
||
AzA Office Hülle V1.2
|
||
======================
|
||
|
||
Aufbauend auf V1.1:
|
||
|
||
* Keine feste linke Arbeitsoptionen-Leiste mehr — mehr Platz für den Inhalt.
|
||
* **Zahnrad** oben rechts öffnet/schließt ein kompaktes Einstellungs-Popup
|
||
(gleiche Akzentfarbe wie Start/Korrigieren/Diktat).
|
||
* Popup: Rechtsklick-Einfügen, Kommentare anzeigen, **Chat-Empfang**
|
||
(Auto-Option + einmaliges Öffnen/Anheben des Empfang-Fensters über
|
||
``_send_to_empfang``).
|
||
* **Erscheinungsbild**: dieselbe **Transparenz-Logik** wie in der klassischen
|
||
Hauptfenster-Kopfzeile (``_opacity_var_main``, ``MIN_OPACITY``, ``save_opacity``)
|
||
sowie Zugriff auf **alle Einstellungen** (``_open_settings``). Die Farbpalette
|
||
der Office-Hülle folgt der beim Start geladenen Hell/Dunkel-Präferenz;
|
||
Umschalten nur noch über das klassische Einstellungsfenster, falls dort angeboten.
|
||
* Footer-Branding und Logo ca. **30 % größer** als in V1.1.
|
||
|
||
Technische Strategie
|
||
--------------------
|
||
|
||
Nach ``_build_ui`` blendet die Hülle die alten Hauptfenster-Kinder aus und
|
||
baut die Office-Oberfläche neu auf. Bestehende App-Methoden und Variablen
|
||
aus ``KGDesktopApp`` werden verdrahtet.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import json
|
||
import os
|
||
import sys
|
||
import tkinter as tk
|
||
from tkinter import messagebox
|
||
from tkinter import ttk
|
||
from tkinter.scrolledtext import ScrolledText
|
||
from typing import Callable, Dict, List, Optional
|
||
|
||
try:
|
||
from PIL import Image, ImageTk
|
||
_HAS_PIL = True
|
||
except Exception:
|
||
_HAS_PIL = False
|
||
|
||
try:
|
||
from aza_config import MIN_OPACITY
|
||
except Exception:
|
||
MIN_OPACITY = 0.4
|
||
|
||
try:
|
||
from aza_persistence import load_opacity, save_opacity
|
||
except Exception:
|
||
def load_opacity() -> float:
|
||
return 1.0
|
||
|
||
def save_opacity(_v: float) -> None:
|
||
pass
|
||
|
||
|
||
PREFS_FILENAME = "aza_office_shell_v11_prefs.json"
|
||
|
||
# Sektions-Toggles (Sidebar + Hauptbereich); Schema-Hochzählung nur bei echten Strukturänderungen.
|
||
SECTION_PREFS_SCHEMA = 2
|
||
|
||
FF = "Segoe UI"
|
||
FONT_DEFAULT = (FF, 9)
|
||
FONT_BOLD = (FF, 9, "bold")
|
||
FONT_SECTION = (FF, 10, "bold")
|
||
FONT_BRAND = (FF, 18, "bold") # V1.1: 14 → +~29 %
|
||
FONT_BRAND_SUB = (FF, 12) # V1.1: 9 → +33 %
|
||
|
||
BTN_W_HEADER = 110
|
||
BTN_W_ACTION = 130
|
||
BTN_W_DOC = 150
|
||
BTN_W_SOAP = 158
|
||
BTN_H = 32
|
||
|
||
LOGO_PX = 57 # V1.1: 44 → ×1.295 ≈ +30 %
|
||
|
||
# Popover = gleiche Farbe wie Primärbuttons (ACCENT aus Palette)
|
||
POPOVER_TRACK = "#3D6F8D"
|
||
POPOVER_KNOB = "#FFFFFF"
|
||
POPOVER_KNOB_RING = "#E2EEF6"
|
||
|
||
PALETTE_LIGHT: Dict[str, str] = {
|
||
"BG": "#EAF2F7",
|
||
"SURFACE": "#FFFFFF",
|
||
"SURFACE_ALT": "#F4F8FB",
|
||
"BORDER": "#D6E2EB",
|
||
"TEXT": "#1A4D6D",
|
||
"TEXT_STRONG": "#0F3850",
|
||
"SUBTLE": "#5C7A8E",
|
||
"ACCENT": "#5B8DB3",
|
||
"ACCENT_HOVER": "#4A7A9E",
|
||
"ACCENT_PRESSED": "#3A6884",
|
||
"ACCENT_SOFT": "#E2EEF6",
|
||
"WARN": "#C2840F",
|
||
"RECORD": "#C0392B",
|
||
"RECORD_HOVER": "#A6291C",
|
||
"TEXT_AREA_BG": "#FFFFFF",
|
||
"TEXT_AREA_FG": "#1A4D6D",
|
||
}
|
||
|
||
PALETTE_DARK: Dict[str, str] = {
|
||
"BG": "#1B2E36",
|
||
"SURFACE": "#243B45",
|
||
"SURFACE_ALT": "#2D4652",
|
||
"BORDER": "#3D5866",
|
||
"TEXT": "#E8F2F7",
|
||
"TEXT_STRONG": "#FFFFFF",
|
||
"SUBTLE": "#9BB8C9",
|
||
"ACCENT": "#6BA3C4",
|
||
"ACCENT_HOVER": "#5A92B5",
|
||
"ACCENT_PRESSED": "#4A82A6",
|
||
"ACCENT_SOFT": "#2F4F5E",
|
||
"WARN": "#E0B456",
|
||
"RECORD": "#E74C3C",
|
||
"RECORD_HOVER": "#C0392B",
|
||
"TEXT_AREA_BG": "#1E323B",
|
||
"TEXT_AREA_FG": "#EAF4F8",
|
||
}
|
||
|
||
|
||
def _prefs_path() -> str:
|
||
try:
|
||
from aza_config import get_writable_data_dir
|
||
base = get_writable_data_dir()
|
||
except Exception:
|
||
base = os.path.dirname(os.path.abspath(__file__))
|
||
return os.path.join(base, PREFS_FILENAME)
|
||
|
||
|
||
def _load_office_prefs() -> dict:
|
||
try:
|
||
with open(_prefs_path(), encoding="utf-8") as fh:
|
||
d = json.load(fh)
|
||
return d if isinstance(d, dict) else {}
|
||
except Exception:
|
||
return {}
|
||
|
||
|
||
def _save_office_prefs(data: dict) -> None:
|
||
try:
|
||
path = _prefs_path()
|
||
root = os.path.dirname(path)
|
||
if root:
|
||
os.makedirs(root, exist_ok=True)
|
||
with open(path, "w", encoding="utf-8") as fh:
|
||
json.dump(data, fh, indent=2, ensure_ascii=False)
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Konnte Office-Prefs nicht speichern: {exc}")
|
||
|
||
|
||
def _has_autotext_config_file_on_disk() -> bool:
|
||
try:
|
||
from aza_persistence import _autotext_config_path
|
||
|
||
return os.path.isfile(_autotext_config_path())
|
||
except Exception:
|
||
return False
|
||
|
||
|
||
def _shell_sections_strict_new_defaults() -> dict:
|
||
"""Neuinstallation / kein vorhandenes autotext.json: alles zu außer KG."""
|
||
return {
|
||
"schema": SECTION_PREFS_SCHEMA,
|
||
"arb_open": False,
|
||
"ersch_open": False,
|
||
"tb_open": False,
|
||
"transcript_open": False,
|
||
"kg_open": True,
|
||
"soap_open": False,
|
||
"documents_open": False,
|
||
}
|
||
|
||
|
||
def _shell_sections_upgrade_defaults(app) -> dict:
|
||
"""Bestehende Installation ohne Schema: früheres Layout (SOAP/Dokumente sichtbar)."""
|
||
ad = getattr(app, "_autotext_data", None)
|
||
tb_open = True
|
||
if isinstance(ad, dict):
|
||
tb_open = bool(ad.get("office_sidebar_textbloecke_open", True))
|
||
return {
|
||
"schema": SECTION_PREFS_SCHEMA,
|
||
"arb_open": True,
|
||
"ersch_open": True,
|
||
"tb_open": tb_open,
|
||
"transcript_open": False,
|
||
"kg_open": True,
|
||
"soap_open": True,
|
||
"documents_open": True,
|
||
}
|
||
|
||
|
||
def _load_dark_pref() -> bool:
|
||
return bool(_load_office_prefs().get("dark_mode", False))
|
||
|
||
|
||
def _save_dark_pref(dark: bool) -> None:
|
||
data = _load_office_prefs()
|
||
data["dark_mode"] = dark
|
||
_save_office_prefs(data)
|
||
|
||
|
||
class PillButton(tk.Canvas):
|
||
"""Pill-Button; Farben aus Palette-Dict."""
|
||
|
||
def __init__(
|
||
self,
|
||
parent,
|
||
text: str,
|
||
command: Optional[Callable] = None,
|
||
*,
|
||
kind: str = "default",
|
||
width: int = BTN_W_ACTION,
|
||
height: int = BTN_H,
|
||
weight: str = "normal",
|
||
tooltip: Optional[str] = None,
|
||
palette: Dict[str, str],
|
||
):
|
||
bg = parent.cget("bg") if hasattr(parent, "cget") else PALETTE_LIGHT["BG"]
|
||
super().__init__(parent, width=width, height=height, bg=bg,
|
||
highlightthickness=0, bd=0, cursor="hand2")
|
||
self._text = text
|
||
self._command = command
|
||
self._kind = kind
|
||
self._btn_w = width
|
||
self._btn_h = height
|
||
self._weight = weight
|
||
self._palette = palette
|
||
self._hover = False
|
||
self._press = False
|
||
self.bind("<Configure>", lambda e: self._draw())
|
||
self.bind("<Enter>", self._on_enter)
|
||
self.bind("<Leave>", self._on_leave)
|
||
self.bind("<ButtonPress-1>", self._on_press)
|
||
self.bind("<ButtonRelease-1>", self._on_release)
|
||
if tooltip:
|
||
try:
|
||
from aza_ui_helpers import add_tooltip
|
||
add_tooltip(self, tooltip)
|
||
except Exception:
|
||
pass
|
||
self._draw()
|
||
|
||
def _p(self) -> Dict[str, str]:
|
||
return self._palette
|
||
|
||
def _colors(self):
|
||
p = self._p()
|
||
if self._kind == "primary":
|
||
fill = (p["ACCENT_PRESSED"] if self._press
|
||
else p["ACCENT_HOVER"] if self._hover else p["ACCENT"])
|
||
return fill, "white", fill
|
||
if self._kind == "danger":
|
||
fill = p["RECORD_HOVER"] if (self._hover or self._press) else p["RECORD"]
|
||
return fill, "white", fill
|
||
if self._kind == "ghost":
|
||
fill = p["ACCENT_SOFT"] if (self._hover or self._press) else p["SURFACE"]
|
||
border = p["ACCENT"] if (self._hover or self._press) else p["BORDER"]
|
||
return fill, p["TEXT"], border
|
||
fill = p["ACCENT_SOFT"] if (self._hover or self._press) else p["SURFACE_ALT"]
|
||
border = p["ACCENT"] if (self._hover or self._press) else p["BORDER"]
|
||
return fill, p["TEXT"], border
|
||
|
||
def _draw(self):
|
||
try:
|
||
self.delete("all")
|
||
w = max(self._btn_w, int(self.winfo_width() or 0))
|
||
h = max(self._btn_h, int(self.winfo_height() or 0))
|
||
fill, fg, border = self._colors()
|
||
r = max(2, min(8, h // 2))
|
||
self._round_rect(0, 0, w, h, r, fill=fill, outline=border)
|
||
self.create_text(w // 2, h // 2, text=self._text, fill=fg,
|
||
font=(FF, 9, self._weight))
|
||
except Exception:
|
||
pass
|
||
|
||
def _round_rect(self, x1, y1, x2, y2, r, **kw):
|
||
pts = [
|
||
x1 + r, y1, x2 - r, y1, x2, y1, x2, y1 + r,
|
||
x2, y2 - r, x2, y2, x2 - r, y2, x1 + r, y2,
|
||
x1, y2, x1, y2 - r, x1, y1 + r, x1, y1,
|
||
]
|
||
return self.create_polygon(pts, smooth=True, **kw)
|
||
|
||
def _on_enter(self, _e=None):
|
||
self._hover = True
|
||
self._draw()
|
||
|
||
def _on_leave(self, _e=None):
|
||
self._hover = False
|
||
self._press = False
|
||
self._draw()
|
||
|
||
def _on_press(self, _e=None):
|
||
self._press = True
|
||
self._draw()
|
||
|
||
def _on_release(self, _e=None):
|
||
was = self._press
|
||
self._press = False
|
||
self._draw()
|
||
if was and self._command:
|
||
try:
|
||
self._command()
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Aktion '{self._text}' fehlgeschlagen: {exc}")
|
||
|
||
def configure(self, **kw):
|
||
if "command" in kw:
|
||
self._command = kw.pop("command")
|
||
if "text" in kw:
|
||
self._text = str(kw.pop("text"))
|
||
self._draw()
|
||
if kw:
|
||
try:
|
||
super().configure(**kw)
|
||
except Exception:
|
||
pass
|
||
|
||
config = configure
|
||
|
||
def set_text(self, t: str):
|
||
self.configure(text=t)
|
||
|
||
def set_palette_ref(self, palette: Dict[str, str]):
|
||
self._palette = palette
|
||
self._draw()
|
||
|
||
def set_font_size_scale(self, _s: float):
|
||
return None
|
||
|
||
def set_button_size_scale(self, _s: float):
|
||
return None
|
||
|
||
def set_font_scale(self, _s: float):
|
||
return None
|
||
|
||
|
||
class PopoverThemeSwitch(tk.Canvas):
|
||
"""Hell/Dunkel-Schalter für Office-Hülle (auf Akzent-Hintergrund)."""
|
||
|
||
def __init__(
|
||
self,
|
||
parent,
|
||
*,
|
||
width: int = 52,
|
||
height: int = 26,
|
||
is_dark: bool,
|
||
command: Callable[[], None],
|
||
bg_accent: str,
|
||
):
|
||
super().__init__(
|
||
parent, width=width, height=height, bg=bg_accent,
|
||
highlightthickness=0, bd=0, cursor="hand2",
|
||
)
|
||
self._is_dark = is_dark
|
||
self._command = command
|
||
self._bg_accent = bg_accent
|
||
self._track_w = width
|
||
self._track_h = height
|
||
self.bind("<Button-1>", self._on_click)
|
||
self.bind("<Configure>", lambda e: self._draw())
|
||
self._draw()
|
||
|
||
def _on_click(self, _e=None):
|
||
try:
|
||
self._command()
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Theme-Toggle: {exc}")
|
||
|
||
def set_dark(self, dark: bool):
|
||
self._is_dark = dark
|
||
self._draw()
|
||
|
||
def _draw(self):
|
||
try:
|
||
self.delete("all")
|
||
w = max(self._track_w, int(self.winfo_width() or 0))
|
||
h = max(self._track_h, int(self.winfo_height() or 0))
|
||
pad = 3
|
||
x1, y1, x2, y2 = pad, h // 2 - 8, w - pad, h // 2 + 8
|
||
r = 10
|
||
pts = [
|
||
x1 + r, y1, x2 - r, y1, x2, y1, x2, y1 + r,
|
||
x2, y2 - r, x2, y2, x2 - r, y2, x1 + r, y2,
|
||
x1, y2, x1, y2 - r, x1, y1 + r, x1, y1,
|
||
]
|
||
self.create_polygon(pts, smooth=True, fill=POPOVER_TRACK, outline="")
|
||
knob_r = 9
|
||
cx = (w - pad - knob_r - 4) if self._is_dark else (pad + knob_r + 4)
|
||
cy = h // 2
|
||
self.create_oval(
|
||
cx - knob_r, cy - knob_r,
|
||
cx + knob_r, cy + knob_r,
|
||
fill=POPOVER_KNOB, outline=POPOVER_KNOB_RING, width=1,
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def _load_logo(size: int):
|
||
if not _HAS_PIL:
|
||
return None
|
||
cands: list[str] = [os.path.dirname(os.path.abspath(__file__))]
|
||
if getattr(sys, "frozen", False):
|
||
try:
|
||
cands.append(os.path.dirname(os.path.abspath(sys.executable)))
|
||
except Exception:
|
||
pass
|
||
m = getattr(sys, "_MEIPASS", "")
|
||
if m:
|
||
cands.append(m)
|
||
for d in cands:
|
||
p = os.path.join(d, "logo.png")
|
||
if not os.path.isfile(p):
|
||
continue
|
||
try:
|
||
img = Image.open(p)
|
||
if img.mode not in ("RGB", "RGBA"):
|
||
img = img.convert("RGBA")
|
||
resample = (Image.Resampling.LANCZOS
|
||
if hasattr(Image, "Resampling") else Image.LANCZOS)
|
||
img = img.resize((size, size), resample)
|
||
return ImageTk.PhotoImage(img)
|
||
except Exception:
|
||
continue
|
||
return None
|
||
|
||
|
||
def _safe_call(obj, attr: str):
|
||
fn = getattr(obj, attr, None)
|
||
if not callable(fn):
|
||
print(f"[OfficeV1.2] Methode '{attr}' nicht verfügbar.")
|
||
return
|
||
try:
|
||
fn()
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Aufruf '{attr}' fehlgeschlagen: {exc}")
|
||
|
||
|
||
class _OfficeShellV12:
|
||
def __init__(self, app):
|
||
self.app = app
|
||
self._logo_img = None
|
||
self._record_btn: Optional[PillButton] = None
|
||
self._korrigieren_btn: Optional[PillButton] = None
|
||
self._diktat_btn: Optional[PillButton] = None
|
||
self._license_lbl: Optional[tk.Label] = None
|
||
self._theme_switch_pop: Optional[PopoverThemeSwitch] = None
|
||
self._sidebar: Optional[tk.Frame] = None
|
||
self._sec_arb_open: bool = False
|
||
self._sec_ersch_open: bool = False
|
||
self._sec_arb_arrow: Optional[tk.Label] = None
|
||
self._sec_ersch_arrow: Optional[tk.Label] = None
|
||
self._sec_arb_body: Optional[tk.Frame] = None
|
||
self._sec_ersch_body: Optional[tk.Frame] = None
|
||
self._transcript_open: bool = False
|
||
self._kg_open: bool = True
|
||
self._soap_open: bool = False
|
||
self._documents_open: bool = False
|
||
self._soap_arrow: Optional[tk.Label] = None
|
||
self._soap_fold_body: Optional[tk.Frame] = None
|
||
self._documents_arrow: Optional[tk.Label] = None
|
||
self._documents_fold_body: Optional[tk.Frame] = None
|
||
self._main_fill: Optional[tk.Frame] = None
|
||
self._content: Optional[tk.Frame] = None
|
||
self._header_inner: Optional[tk.Frame] = None
|
||
self._header_bar: Optional[tk.Frame] = None
|
||
self._footer_bar: Optional[tk.Frame] = None
|
||
self._sep_top: Optional[tk.Frame] = None
|
||
self._sep_bottom: Optional[tk.Frame] = None
|
||
self._status_row_fr: Optional[tk.Frame] = None
|
||
self._palette: Dict[str, str] = {}
|
||
self._dark_mode: bool = False
|
||
self._pills: List[PillButton] = []
|
||
self._footer_tb: Optional[tk.Frame] = None
|
||
self._footer_logo_lbl: Optional[tk.Label] = None
|
||
self._footer_brand_title: Optional[tk.Label] = None
|
||
self._footer_brand_sub: Optional[tk.Label] = None
|
||
self._shell_labels: List[tk.Label] = []
|
||
self._settings_win = None # Legacy-Popup
|
||
self._gear_btn: Optional[tk.Misc] = None
|
||
self._head_tb: Optional[tk.Frame] = None
|
||
self._sidebar_head_arb: Optional[tk.Frame] = None
|
||
self._sec_tb_open: bool = False
|
||
self._sec_tb_arrow: Optional[tk.Label] = None
|
||
self._sec_tb_body: Optional[tk.Frame] = None
|
||
self._sidebar_head_ersch: Optional[tk.Frame] = None
|
||
|
||
# ── Öffentlich ────────────────────────────────────────────────────
|
||
|
||
def install(self):
|
||
app = self.app
|
||
self._hydrate_shell_section_prefs()
|
||
self._dark_mode = _load_dark_pref()
|
||
self._palette = (
|
||
PALETTE_DARK.copy() if self._dark_mode else PALETTE_LIGHT.copy()
|
||
)
|
||
|
||
try:
|
||
from aza_version import APP_VERSION
|
||
app.title(f"AzA Office (v{APP_VERSION})")
|
||
except Exception:
|
||
app.title("AzA Office")
|
||
try:
|
||
app.configure(bg=self._palette["BG"])
|
||
except Exception:
|
||
pass
|
||
|
||
self._hide_legacy_children()
|
||
self._apply_ttk_theme()
|
||
|
||
self._build_footer()
|
||
self._build_header()
|
||
self._build_status_row()
|
||
self._build_main_fill()
|
||
|
||
try:
|
||
btp = getattr(app, "_bind_textblock_pending", None)
|
||
if callable(btp):
|
||
for attr in ("txt_transcript", "txt_output"):
|
||
wid = getattr(app, attr, None)
|
||
if wid is not None:
|
||
btp(wid)
|
||
except Exception:
|
||
pass
|
||
|
||
if self._record_btn is not None:
|
||
app.btn_record = self._record_btn
|
||
if self._korrigieren_btn is not None:
|
||
app.btn_record_append = self._korrigieren_btn
|
||
if self._diktat_btn is not None:
|
||
app._btn_diktat_top = self._diktat_btn
|
||
|
||
try:
|
||
app.after(250, self._enforce_default_fonts)
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
ud = getattr(app, "_update_kg_detail_display", None)
|
||
if callable(ud):
|
||
ud()
|
||
except Exception:
|
||
pass
|
||
|
||
self._update_license_label()
|
||
try:
|
||
app.after(2500, self._periodic_license_refresh)
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
from aza_workspace_license import ensure_workspace_license_dialog_then_start_hybrid_sync
|
||
|
||
ensure_workspace_license_dialog_then_start_hybrid_sync(app)
|
||
except Exception as shell_exc:
|
||
print(f"[OfficeV1.2] Workspace-Hybrid-Sync konnte nicht gestartet werden: {shell_exc}")
|
||
|
||
try:
|
||
existing = getattr(app, "_dev_status_window", None)
|
||
if existing is not None and existing.winfo_exists():
|
||
existing.destroy()
|
||
except Exception:
|
||
pass
|
||
app._dev_status_window = None
|
||
|
||
def _hydrate_shell_section_prefs(self) -> None:
|
||
app = self.app
|
||
prefs = _load_office_prefs()
|
||
ss = prefs.get("shell_sections") if isinstance(prefs.get("shell_sections"), dict) else {}
|
||
valid = ss.get("schema") == SECTION_PREFS_SCHEMA
|
||
|
||
if not valid:
|
||
if _has_autotext_config_file_on_disk():
|
||
new_ss = _shell_sections_upgrade_defaults(app)
|
||
else:
|
||
new_ss = _shell_sections_strict_new_defaults()
|
||
prefs["shell_sections"] = new_ss
|
||
_save_office_prefs(prefs)
|
||
self._apply_shell_section_prefs_from_dict(new_ss)
|
||
|
||
sync_tb = getattr(app, "_autotext_data", None)
|
||
if isinstance(sync_tb, dict):
|
||
sync_tb["office_sidebar_textbloecke_open"] = bool(new_ss["tb_open"])
|
||
try:
|
||
from aza_persistence import save_autotext
|
||
|
||
save_autotext(sync_tb)
|
||
except Exception:
|
||
pass
|
||
return
|
||
|
||
self._apply_shell_section_prefs_from_dict(ss)
|
||
|
||
def _apply_shell_section_prefs_from_dict(self, ss: dict) -> None:
|
||
app = self.app
|
||
self._sec_arb_open = bool(ss.get("arb_open", False))
|
||
self._sec_ersch_open = bool(ss.get("ersch_open", False))
|
||
self._sec_tb_open = bool(ss.get("tb_open", False))
|
||
self._transcript_open = bool(ss.get("transcript_open", False))
|
||
self._kg_open = bool(ss.get("kg_open", True))
|
||
self._soap_open = bool(ss.get("soap_open", False))
|
||
self._documents_open = bool(ss.get("documents_open", False))
|
||
setattr(app, "_transcript_collapsed", not self._transcript_open)
|
||
setattr(app, "_kg_collapsed", not self._kg_open)
|
||
|
||
def _persist_shell_sections(self) -> None:
|
||
d = _load_office_prefs()
|
||
d["shell_sections"] = {
|
||
"schema": SECTION_PREFS_SCHEMA,
|
||
"arb_open": self._sec_arb_open,
|
||
"ersch_open": self._sec_ersch_open,
|
||
"tb_open": self._sec_tb_open,
|
||
"transcript_open": self._transcript_open,
|
||
"kg_open": self._kg_open,
|
||
"soap_open": self._soap_open,
|
||
"documents_open": self._documents_open,
|
||
}
|
||
_save_office_prefs(d)
|
||
|
||
# ── Hilfen ────────────────────────────────────────────────────────
|
||
|
||
def _register_pill(self, b: PillButton) -> PillButton:
|
||
self._pills.append(b)
|
||
return b
|
||
|
||
def _hide_legacy_children(self):
|
||
for child in list(self.app.winfo_children()):
|
||
for forget in ("pack_forget", "place_forget", "grid_forget"):
|
||
try:
|
||
getattr(child, forget)()
|
||
except Exception:
|
||
pass
|
||
|
||
def _apply_opacity_percent_str(self, val: str) -> None:
|
||
"""Wie ``on_opacity_main`` in ``basis14._build_ui`` (Transparenz)."""
|
||
app = self.app
|
||
try:
|
||
alpha = float(val) / 100.0
|
||
alpha = max(float(MIN_OPACITY), min(1.0, alpha))
|
||
app.attributes("-alpha", alpha)
|
||
save_opacity(alpha)
|
||
ov = getattr(app, "_opacity_var_main", None)
|
||
if ov is not None:
|
||
ov.set(round(alpha * 100))
|
||
sc = getattr(app, "_opacity_scale_main", None)
|
||
if sc is not None:
|
||
try:
|
||
sc.set(round(alpha * 100))
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
def _apply_ttk_theme(self):
|
||
p = self._palette
|
||
try:
|
||
style = ttk.Style(self.app)
|
||
try:
|
||
style.theme_use("clam")
|
||
except tk.TclError:
|
||
pass
|
||
style.configure("TFrame", background=p["BG"])
|
||
style.configure("TLabel", background=p["BG"], foreground=p["TEXT"],
|
||
font=FONT_DEFAULT)
|
||
style.configure(
|
||
"TButton", background=p["ACCENT"], foreground="white",
|
||
padding=(10, 6), borderwidth=0, font=FONT_DEFAULT,
|
||
)
|
||
style.map("TButton", background=[
|
||
("active", p["ACCENT_HOVER"]),
|
||
("pressed", p["ACCENT_PRESSED"]),
|
||
])
|
||
style.configure(
|
||
"OfficePop.Horizontal.TScale",
|
||
troughcolor="#E2EEF6",
|
||
background=p["ACCENT"],
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
def _apply_main_theme(self):
|
||
p = self._palette
|
||
app = self.app
|
||
try:
|
||
app.configure(bg=p["BG"])
|
||
except Exception:
|
||
pass
|
||
|
||
for fr in (self._header_inner, self._header_bar):
|
||
if fr is not None:
|
||
try:
|
||
fr.configure(bg=p["SURFACE"])
|
||
except Exception:
|
||
pass
|
||
if self._header_inner is not None:
|
||
try:
|
||
for ch in self._header_inner.winfo_children():
|
||
try:
|
||
if ch is self._gear_btn:
|
||
continue
|
||
ch.configure(bg=p["SURFACE"])
|
||
except Exception:
|
||
pass
|
||
except Exception:
|
||
pass
|
||
|
||
for fr in (self._main_fill, self._content, self._status_row_fr,
|
||
self._footer_bar):
|
||
if fr is not None:
|
||
try:
|
||
fr.configure(bg=p["BG"])
|
||
except Exception:
|
||
pass
|
||
|
||
if self._sep_top is not None:
|
||
try:
|
||
self._sep_top.configure(bg=p["BORDER"])
|
||
except Exception:
|
||
pass
|
||
if self._sep_bottom is not None:
|
||
try:
|
||
self._sep_bottom.configure(bg=p["BORDER"])
|
||
except Exception:
|
||
pass
|
||
|
||
try:
|
||
app.lbl_status.configure(bg=p["BG"], fg=p["SUBTLE"])
|
||
except Exception:
|
||
pass
|
||
|
||
if self._license_lbl is not None:
|
||
try:
|
||
mode = getattr(app, "license_mode", "demo")
|
||
self._license_lbl.configure(
|
||
bg=p["SURFACE"],
|
||
fg=p["ACCENT"] if mode == "active" else p["WARN"],
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
self._apply_section_backgrounds(p["BG"])
|
||
self._apply_shell_labels(p)
|
||
self._apply_text_widgets(p)
|
||
|
||
if self._footer_tb is not None:
|
||
try:
|
||
self._footer_tb.configure(bg=p["BG"])
|
||
except Exception:
|
||
pass
|
||
if self._footer_logo_lbl is not None:
|
||
try:
|
||
self._footer_logo_lbl.configure(bg=p["BG"])
|
||
except Exception:
|
||
pass
|
||
if self._footer_brand_title is not None:
|
||
try:
|
||
self._footer_brand_title.configure(bg=p["BG"], fg=p["TEXT_STRONG"])
|
||
except Exception:
|
||
pass
|
||
if self._footer_brand_sub is not None:
|
||
try:
|
||
self._footer_brand_sub.configure(bg=p["BG"], fg=p["SUBTLE"])
|
||
except Exception:
|
||
pass
|
||
|
||
for pill in self._pills:
|
||
try:
|
||
pill.configure(bg=p["SURFACE"])
|
||
except Exception:
|
||
pass
|
||
pill.set_palette_ref(p)
|
||
|
||
app._soap_bg = p["BG"]
|
||
try:
|
||
app._rebuild_soap_section_controls()
|
||
except Exception:
|
||
pass
|
||
|
||
self._apply_ttk_theme()
|
||
if self._sidebar is not None:
|
||
try:
|
||
self._sidebar.configure(bg=p["ACCENT"])
|
||
except Exception:
|
||
pass
|
||
try:
|
||
self._build_sidebar_content()
|
||
except Exception:
|
||
pass
|
||
|
||
def _toggle_theme_main(self):
|
||
self._dark_mode = not self._dark_mode
|
||
_save_dark_pref(self._dark_mode)
|
||
self._palette = (
|
||
PALETTE_DARK.copy() if self._dark_mode else PALETTE_LIGHT.copy()
|
||
)
|
||
self._apply_main_theme()
|
||
|
||
def _apply_shell_labels(self, p: Dict[str, str]):
|
||
for w in self._shell_labels:
|
||
try:
|
||
w.configure(bg=p["BG"], fg=p["TEXT"])
|
||
except Exception:
|
||
pass
|
||
|
||
def _apply_section_backgrounds(self, bg: str):
|
||
sh = getattr(self, "_shell_section_frames", None)
|
||
if not sh:
|
||
return
|
||
for fr in sh:
|
||
try:
|
||
fr.configure(bg=bg)
|
||
except Exception:
|
||
pass
|
||
|
||
def _apply_text_widgets(self, p: Dict[str, str]):
|
||
for attr in ("txt_output", "txt_transcript"):
|
||
w = getattr(self.app, attr, None)
|
||
if w is None:
|
||
continue
|
||
try:
|
||
w.configure(
|
||
bg=p["TEXT_AREA_BG"], fg=p["TEXT_AREA_FG"],
|
||
highlightbackground=p["BORDER"], insertbackground=p["TEXT_AREA_FG"],
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
def _on_chat_empfang_toggle(self):
|
||
_safe_call(self.app, "_toggle_empfang_auto")
|
||
try:
|
||
self.app.after(80, lambda: _safe_call(self.app, "_send_to_empfang"))
|
||
except Exception:
|
||
pass
|
||
|
||
# ── (Legacy Popover-Code, in V1.2.1 nicht mehr verwendet) ─────────
|
||
|
||
def _destroy_settings_pop(self):
|
||
if self._settings_win is not None:
|
||
try:
|
||
self._settings_win.destroy()
|
||
except Exception:
|
||
pass
|
||
self._settings_win = None
|
||
self._theme_switch_pop = None
|
||
|
||
def _toggle_settings_pop(self):
|
||
if self._settings_win is not None:
|
||
try:
|
||
if self._settings_win.winfo_exists():
|
||
self._destroy_settings_pop()
|
||
return
|
||
except tk.TclError:
|
||
pass
|
||
self._show_settings_pop()
|
||
|
||
def _show_settings_pop(self):
|
||
self._destroy_settings_pop()
|
||
app = self.app
|
||
acc = self._palette["ACCENT"]
|
||
pop = tk.Toplevel(app)
|
||
pop.withdraw()
|
||
pop.configure(bg=acc)
|
||
try:
|
||
pop.transient(app)
|
||
except Exception:
|
||
pass
|
||
self._settings_win = pop
|
||
|
||
pad = dict(
|
||
bg=acc, fg="white", font=FONT_DEFAULT,
|
||
activebackground=acc, activeforeground="white",
|
||
selectcolor="#1a4d6d", highlightthickness=0,
|
||
bd=0, anchor="w",
|
||
)
|
||
|
||
outer = tk.Frame(pop, bg=acc, padx=14, pady=12)
|
||
outer.pack(fill="both", expand=True)
|
||
|
||
tk.Label(
|
||
outer, text="Arbeitsoptionen",
|
||
bg=acc, fg="white", font=(FF, 10, "bold"),
|
||
).pack(anchor="w", pady=(0, 8))
|
||
|
||
if getattr(app, "_rclick_paste_var", None) is None:
|
||
app._rclick_paste_var = tk.BooleanVar(master=app, value=True)
|
||
if getattr(app, "_kommentare_auto_var", None) is None:
|
||
app._kommentare_auto_var = tk.BooleanVar(master=app, value=False)
|
||
if getattr(app, "_empfang_auto_var", None) is None:
|
||
app._empfang_auto_var = tk.BooleanVar(master=app, value=False)
|
||
|
||
tk.Checkbutton(
|
||
outer, text="Rechtsklick = Einfügen",
|
||
variable=app._rclick_paste_var,
|
||
command=lambda: _safe_call(app, "_toggle_rclick_paste"),
|
||
**pad,
|
||
).pack(fill="x", pady=3)
|
||
|
||
tk.Checkbutton(
|
||
outer, text="Kommentare anzeigen",
|
||
variable=app._kommentare_auto_var,
|
||
command=lambda: _safe_call(app, "_toggle_kommentare_auto"),
|
||
**pad,
|
||
).pack(fill="x", pady=3)
|
||
|
||
tk.Checkbutton(
|
||
outer, text="Chat-Empfang",
|
||
variable=app._empfang_auto_var,
|
||
command=self._on_chat_empfang_toggle,
|
||
**pad,
|
||
).pack(fill="x", pady=3)
|
||
|
||
tk.Frame(outer, bg=acc, height=8).pack()
|
||
|
||
tk.Label(
|
||
outer, text="Erscheinungsbild",
|
||
bg=acc, fg="white", font=(FF, 10, "bold"),
|
||
).pack(anchor="w", pady=(4, 6))
|
||
|
||
tk.Label(
|
||
outer,
|
||
text="Fenster-Transparenz (wie Hauptfenster)",
|
||
bg=acc, fg="#E2EEF6", font=FONT_DEFAULT,
|
||
).pack(anchor="w")
|
||
|
||
ov = getattr(app, "_opacity_var_main", None)
|
||
if ov is None:
|
||
ov = tk.DoubleVar(master=app, value=round(load_opacity() * 100))
|
||
app._opacity_var_main = ov
|
||
|
||
row_op = tk.Frame(outer, bg=acc)
|
||
row_op.pack(fill="x", pady=(4, 2))
|
||
|
||
lbl_half = tk.Label(
|
||
row_op, text="◐", font=("Segoe UI Symbol", 14),
|
||
bg=acc, fg="white", cursor="hand2",
|
||
)
|
||
lbl_half.pack(side="left", padx=(0, 4))
|
||
lbl_half.bind(
|
||
"<Button-1>",
|
||
lambda e: self._apply_opacity_percent_str(str(int(MIN_OPACITY * 100))),
|
||
)
|
||
|
||
sc = ttk.Scale(
|
||
row_op,
|
||
from_=40,
|
||
to=100,
|
||
variable=ov,
|
||
orient="horizontal",
|
||
length=140,
|
||
command=self._apply_opacity_percent_str,
|
||
style="OfficePop.Horizontal.TScale",
|
||
)
|
||
sc.pack(side="left", fill="x", expand=True, padx=(0, 4))
|
||
|
||
lbl_full = tk.Label(
|
||
row_op, text="☀", font=("Segoe UI Symbol", 14),
|
||
bg=acc, fg="white", cursor="hand2",
|
||
)
|
||
lbl_full.pack(side="left")
|
||
lbl_full.bind("<Button-1>", lambda e: self._apply_opacity_percent_str("100"))
|
||
|
||
tk.Label(
|
||
outer,
|
||
text="Office-Hülle hell / dunkel",
|
||
bg=acc, fg="#E2EEF6", font=FONT_DEFAULT,
|
||
).pack(anchor="w", pady=(8, 4))
|
||
|
||
row_th = tk.Frame(outer, bg=acc)
|
||
row_th.pack(fill="x")
|
||
|
||
tk.Label(row_th, text="Hell", bg=acc, fg="white",
|
||
font=FONT_DEFAULT).pack(side="left", padx=(0, 6))
|
||
|
||
def _flip():
|
||
self._toggle_theme_main()
|
||
if self._theme_switch_pop:
|
||
self._theme_switch_pop.set_dark(self._dark_mode)
|
||
|
||
self._theme_switch_pop = PopoverThemeSwitch(
|
||
row_th,
|
||
is_dark=self._dark_mode,
|
||
command=_flip,
|
||
bg_accent=acc,
|
||
)
|
||
self._theme_switch_pop.pack(side="left")
|
||
|
||
tk.Label(row_th, text="Dunkel", bg=acc, fg="white",
|
||
font=FONT_DEFAULT).pack(side="left", padx=(6, 0))
|
||
|
||
tk.Frame(outer, bg=acc, height=6).pack()
|
||
|
||
link = tk.Label(
|
||
outer,
|
||
text="Weitere Einstellungen …",
|
||
bg=acc, fg="white", font=(FF, 9, "underline"),
|
||
cursor="hand2",
|
||
)
|
||
link.pack(anchor="w", pady=(4, 0))
|
||
link.bind("<Button-1>", lambda e: (_safe_call(app, "_open_settings"), self._destroy_settings_pop()))
|
||
|
||
pop.update_idletasks()
|
||
w_req = max(outer.winfo_reqwidth() + 28, 280)
|
||
h_req = outer.winfo_reqheight() + 24
|
||
|
||
if self._gear_btn is not None:
|
||
self._gear_btn.update_idletasks()
|
||
gx = self._gear_btn.winfo_rootx()
|
||
gy = self._gear_btn.winfo_rooty()
|
||
gh = self._gear_btn.winfo_height()
|
||
gw = self._gear_btn.winfo_width()
|
||
sw = pop.winfo_screenwidth()
|
||
sh = pop.winfo_screenheight()
|
||
px = min(max(8, gx + gw - w_req), sw - w_req - 8)
|
||
py = gy + gh + 6
|
||
if py + h_req > sh - 8:
|
||
py = max(8, gy - h_req - 6)
|
||
else:
|
||
px = app.winfo_rootx() + app.winfo_width() - w_req - 24
|
||
py = app.winfo_rooty() + 72
|
||
|
||
pop.geometry(f"{w_req}x{h_req}+{px}+{py}")
|
||
try:
|
||
pop.overrideredirect(True)
|
||
except Exception:
|
||
pass
|
||
try:
|
||
pop.deiconify()
|
||
pop.lift()
|
||
pop.attributes("-topmost", True)
|
||
pop.after(120, lambda: pop.attributes("-topmost", False))
|
||
except Exception:
|
||
pass
|
||
|
||
# ── Header / Body ─────────────────────────────────────────────────
|
||
|
||
def _build_header(self):
|
||
app = self.app
|
||
p = self._palette
|
||
|
||
self._header_bar = tk.Frame(app, bg=p["SURFACE"], bd=0,
|
||
highlightthickness=0)
|
||
self._header_bar.pack(side="top", fill="x")
|
||
|
||
self._sep_top = tk.Frame(app, bg=p["BORDER"], height=1)
|
||
self._sep_top.pack(side="top", fill="x")
|
||
|
||
self._header_inner = tk.Frame(self._header_bar, bg=p["SURFACE"])
|
||
self._header_inner.pack(fill="x", padx=18, pady=10)
|
||
|
||
left = tk.Frame(self._header_inner, bg=p["SURFACE"])
|
||
left.pack(side="left")
|
||
|
||
self._record_btn = self._register_pill(PillButton(
|
||
left, "⏺ Start",
|
||
command=lambda: _safe_call(app, "toggle_record"),
|
||
kind="primary", width=BTN_W_ACTION, weight="bold",
|
||
tooltip="Aufnahme starten / stoppen (Transkription)",
|
||
palette=p,
|
||
))
|
||
self._record_btn.pack(side="left", padx=(0, 8))
|
||
|
||
self._korrigieren_btn = self._register_pill(PillButton(
|
||
left, "⏺ Korrigieren",
|
||
command=lambda: _safe_call(app, "_toggle_record_append"),
|
||
kind="primary", width=BTN_W_ACTION, weight="bold",
|
||
tooltip="Korrektur-/Append-Aufnahme",
|
||
palette=p,
|
||
))
|
||
self._korrigieren_btn.pack(side="left", padx=(0, 8))
|
||
|
||
self._diktat_btn = self._register_pill(PillButton(
|
||
left, "Diktat",
|
||
command=lambda: _safe_call(app, "open_diktat_window"),
|
||
kind="primary", width=BTN_W_ACTION, weight="bold",
|
||
tooltip="Diktatfenster öffnen",
|
||
palette=p,
|
||
))
|
||
self._diktat_btn.pack(side="left")
|
||
|
||
right = tk.Frame(self._header_inner, bg=p["SURFACE"])
|
||
right.pack(side="right")
|
||
|
||
self._license_lbl = tk.Label(
|
||
right, text="Lizenz prüfen …", font=FONT_DEFAULT,
|
||
bg=p["SURFACE"], fg=p["SUBTLE"], cursor="hand2", padx=8, pady=4,
|
||
)
|
||
self._license_lbl.pack(side="left", padx=(0, 12))
|
||
self._license_lbl.bind(
|
||
"<Button-1>",
|
||
lambda e: _safe_call(app, "_show_activation_dialog"),
|
||
)
|
||
|
||
self._register_pill(PillButton(
|
||
right, "Profil",
|
||
command=lambda: _safe_call(app, "_show_profile_editor"),
|
||
kind="ghost", width=BTN_W_HEADER, palette=p,
|
||
tooltip="Profil bearbeiten",
|
||
)).pack(side="left", padx=(0, 6))
|
||
|
||
self._register_pill(PillButton(
|
||
right, "Aktivierung",
|
||
command=lambda: _safe_call(app, "_show_activation_dialog"),
|
||
kind="ghost", width=BTN_W_HEADER, palette=p,
|
||
tooltip="Aktivierungsdialog öffnen",
|
||
)).pack(side="left")
|
||
|
||
def _build_status_row(self):
|
||
app = self.app
|
||
p = self._palette
|
||
self._status_row_fr = tk.Frame(app, bg=p["BG"])
|
||
self._status_row_fr.pack(side="top", fill="x", padx=18, pady=(8, 4))
|
||
|
||
var = getattr(app, "status_var", None)
|
||
if var is None:
|
||
var = tk.StringVar(master=app, value="Bereit.")
|
||
app.status_var = var
|
||
|
||
lbl = tk.Label(self._status_row_fr, textvariable=var, bg=p["BG"],
|
||
fg=p["SUBTLE"], font=FONT_DEFAULT, anchor="w")
|
||
lbl.pack(side="left")
|
||
app.lbl_status = lbl
|
||
|
||
def _build_main_fill(self):
|
||
app = self.app
|
||
p = self._palette
|
||
self._main_fill = tk.Frame(app, bg=p["BG"])
|
||
self._main_fill.pack(side="top", fill="both", expand=True)
|
||
|
||
self._sidebar = tk.Frame(self._main_fill, bg=p["ACCENT"], width=220)
|
||
self._sidebar.pack(side="left", fill="y")
|
||
self._sidebar.pack_propagate(False)
|
||
|
||
self._build_sidebar_content()
|
||
|
||
self._content = tk.Frame(self._main_fill, bg=p["BG"])
|
||
self._content.pack(side="left", fill="both", expand=True)
|
||
|
||
self._shell_section_frames = []
|
||
|
||
self._build_transcript_section()
|
||
self._build_kg_section()
|
||
self._build_soap_section()
|
||
self._build_documents_section()
|
||
|
||
def _build_sidebar_content(self):
|
||
app = self.app
|
||
acc = self._palette["ACCENT"]
|
||
bar = self._sidebar
|
||
self._theme_switch_pop = None
|
||
for w in list(bar.winfo_children()):
|
||
try:
|
||
w.destroy()
|
||
except Exception:
|
||
pass
|
||
|
||
cb_pad = dict(
|
||
bg=acc, fg="white", font=FONT_DEFAULT,
|
||
activebackground=acc, activeforeground="white",
|
||
selectcolor="#1a4d6d", highlightthickness=0,
|
||
bd=0, anchor="w",
|
||
)
|
||
|
||
if getattr(app, "_rclick_paste_var", None) is None:
|
||
app._rclick_paste_var = tk.BooleanVar(master=app, value=True)
|
||
if getattr(app, "_kommentare_auto_var", None) is None:
|
||
app._kommentare_auto_var = tk.BooleanVar(master=app, value=False)
|
||
if getattr(app, "_empfang_auto_var", None) is None:
|
||
app._empfang_auto_var = tk.BooleanVar(master=app, value=False)
|
||
|
||
stack = tk.Frame(bar, bg=acc)
|
||
stack.pack(fill="both", expand=True)
|
||
|
||
# ── Sektion: Arbeitsoptionen ─────────────────────────────
|
||
head_arb = tk.Frame(stack, bg=acc, cursor="hand2")
|
||
head_arb.pack(fill="x", padx=10, pady=(14, 4))
|
||
self._sidebar_head_arb = head_arb
|
||
|
||
self._sec_arb_arrow = tk.Label(
|
||
head_arb,
|
||
text=("▼" if self._sec_arb_open else "▶"),
|
||
bg=acc, fg="white", font=(FF, 9, "bold"),
|
||
cursor="hand2",
|
||
)
|
||
self._sec_arb_arrow.pack(side="left", padx=(0, 6))
|
||
|
||
ttl_arb = tk.Label(
|
||
head_arb, text="Arbeitsoptionen",
|
||
bg=acc, fg="white", font=(FF, 9, "bold"),
|
||
cursor="hand2",
|
||
)
|
||
ttl_arb.pack(side="left")
|
||
|
||
for _w in (head_arb, self._sec_arb_arrow, ttl_arb):
|
||
_w.bind("<Button-1>", lambda e: self._toggle_section_arb())
|
||
|
||
self._sec_arb_body = tk.Frame(stack, bg=acc)
|
||
|
||
tk.Checkbutton(
|
||
self._sec_arb_body, text="Rechtsklick = Einfügen",
|
||
variable=app._rclick_paste_var,
|
||
command=lambda: _safe_call(app, "_toggle_rclick_paste"),
|
||
**cb_pad,
|
||
).pack(fill="x", padx=12, pady=3)
|
||
|
||
tk.Checkbutton(
|
||
self._sec_arb_body, text="Kommentare anzeigen",
|
||
variable=app._kommentare_auto_var,
|
||
command=lambda: _safe_call(app, "_toggle_kommentare_auto"),
|
||
**cb_pad,
|
||
).pack(fill="x", padx=12, pady=3)
|
||
|
||
tk.Checkbutton(
|
||
self._sec_arb_body, text="Chat-Empfang",
|
||
variable=app._empfang_auto_var,
|
||
command=self._on_chat_empfang_toggle,
|
||
**cb_pad,
|
||
).pack(fill="x", padx=12, pady=3)
|
||
|
||
tk.Label(
|
||
self._sec_arb_body,
|
||
text="Chatverlauf",
|
||
bg=acc,
|
||
fg="white",
|
||
font=FONT_DEFAULT,
|
||
cursor="hand2",
|
||
anchor="w",
|
||
).pack(fill="x", padx=(28, 12), pady=(2, 8))
|
||
self._sec_arb_body.winfo_children()[-1].bind(
|
||
"<Button-1>",
|
||
lambda e: _safe_call(app, "_open_empfang_chat_history"),
|
||
)
|
||
|
||
tk.Label(
|
||
self._sec_arb_body,
|
||
text="Autotext verwalten …",
|
||
bg=acc,
|
||
fg="#E2EEF6",
|
||
font=FONT_DEFAULT,
|
||
cursor="hand2",
|
||
anchor="w",
|
||
).pack(fill="x", padx=(28, 12), pady=(2, 10))
|
||
self._sec_arb_body.winfo_children()[-1].bind(
|
||
"<Button-1>",
|
||
lambda e: self._open_workspace_autotext(),
|
||
)
|
||
|
||
if self._sec_arb_open:
|
||
self._sec_arb_body.pack(fill="x", after=self._sidebar_head_arb)
|
||
|
||
self._build_textbloecke_sidebar_section(stack, acc)
|
||
|
||
# ── Sektion: Erscheinungsbild (nach Textblöcken) ─
|
||
head_ersch = tk.Frame(stack, bg=acc, cursor="hand2")
|
||
head_ersch.pack(fill="x", padx=10, pady=(10, 4))
|
||
self._sidebar_head_ersch = head_ersch
|
||
|
||
self._sec_ersch_arrow = tk.Label(
|
||
head_ersch,
|
||
text=("▼" if self._sec_ersch_open else "▶"),
|
||
bg=acc, fg="white", font=(FF, 9, "bold"),
|
||
cursor="hand2",
|
||
)
|
||
self._sec_ersch_arrow.pack(side="left", padx=(0, 6))
|
||
|
||
ttl_ersch = tk.Label(
|
||
head_ersch, text="Erscheinungsbild",
|
||
bg=acc, fg="white", font=(FF, 9, "bold"),
|
||
cursor="hand2",
|
||
)
|
||
ttl_ersch.pack(side="left")
|
||
|
||
for _w in (head_ersch, self._sec_ersch_arrow, ttl_ersch):
|
||
_w.bind("<Button-1>", lambda e: self._toggle_section_ersch())
|
||
|
||
self._sec_ersch_body = tk.Frame(stack, bg=acc)
|
||
|
||
tk.Label(
|
||
self._sec_ersch_body, text="Fenster-Transparenz",
|
||
bg=acc, fg="#E2EEF6", font=FONT_DEFAULT,
|
||
).pack(anchor="w", padx=14)
|
||
|
||
ov = getattr(app, "_opacity_var_main", None)
|
||
if ov is None:
|
||
ov = tk.DoubleVar(master=app, value=round(load_opacity() * 100))
|
||
app._opacity_var_main = ov
|
||
|
||
row_op = tk.Frame(self._sec_ersch_body, bg=acc)
|
||
row_op.pack(fill="x", padx=12, pady=(2, 4))
|
||
|
||
lbl_half = tk.Label(
|
||
row_op, text="◐", font=("Segoe UI Symbol", 14),
|
||
bg=acc, fg="white", cursor="hand2",
|
||
)
|
||
lbl_half.pack(side="left", padx=(0, 4))
|
||
lbl_half.bind(
|
||
"<Button-1>",
|
||
lambda e: self._apply_opacity_percent_str(str(int(MIN_OPACITY * 100))),
|
||
)
|
||
|
||
sc = ttk.Scale(
|
||
row_op, from_=40, to=100, variable=ov,
|
||
orient="horizontal", length=120,
|
||
command=self._apply_opacity_percent_str,
|
||
style="OfficePop.Horizontal.TScale",
|
||
)
|
||
sc.pack(side="left", fill="x", expand=True, padx=(0, 4))
|
||
|
||
lbl_full = tk.Label(
|
||
row_op, text="☀", font=("Segoe UI Symbol", 14),
|
||
bg=acc, fg="white", cursor="hand2",
|
||
)
|
||
lbl_full.pack(side="left")
|
||
lbl_full.bind("<Button-1>", lambda e: self._apply_opacity_percent_str("100"))
|
||
|
||
tk.Frame(self._sec_ersch_body, bg=acc, height=8).pack()
|
||
|
||
link = tk.Label(
|
||
self._sec_ersch_body, text="Weitere Einstellungen …",
|
||
bg=acc, fg="white", font=(FF, 9, "underline"),
|
||
cursor="hand2",
|
||
)
|
||
link.pack(anchor="w", padx=14, pady=(2, 6))
|
||
link.bind("<Button-1>", lambda e: _safe_call(app, "_open_settings"))
|
||
|
||
if self._sec_ersch_open:
|
||
self._sec_ersch_body.pack(fill="x", after=self._sidebar_head_ersch)
|
||
|
||
def _persist_tb_sidebar_open_flag(self) -> None:
|
||
app = self.app
|
||
data = getattr(app, "_autotext_data", None)
|
||
if not isinstance(data, dict):
|
||
return
|
||
data["office_sidebar_textbloecke_open"] = self._sec_tb_open
|
||
try:
|
||
from aza_persistence import save_autotext
|
||
|
||
save_autotext(data)
|
||
except Exception:
|
||
pass
|
||
|
||
def _toggle_section_tb(self) -> None:
|
||
self._sec_tb_open = not self._sec_tb_open
|
||
self._persist_tb_sidebar_open_flag()
|
||
if self._sec_tb_arrow is not None:
|
||
try:
|
||
self._sec_tb_arrow.configure(
|
||
text=("▼" if self._sec_tb_open else "▶"),
|
||
)
|
||
except tk.TclError:
|
||
pass
|
||
if self._sec_tb_body is not None:
|
||
try:
|
||
if self._sec_tb_open:
|
||
self._sec_tb_body.pack(fill="x", after=self._head_tb)
|
||
else:
|
||
self._sec_tb_body.pack_forget()
|
||
except tk.TclError:
|
||
pass
|
||
self._persist_shell_sections()
|
||
|
||
def _open_workspace_autotext(self) -> None:
|
||
try:
|
||
from aza_office_workspace_ui import open_workspace_autotext_manager
|
||
|
||
open_workspace_autotext_manager(self.app)
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Autotext-Fenster: {exc}")
|
||
|
||
def _build_textbloecke_sidebar_section(
|
||
self,
|
||
parent: tk.Frame,
|
||
acc: str,
|
||
) -> None:
|
||
self._head_tb = tk.Frame(parent, bg=acc, cursor="hand2")
|
||
self._head_tb.pack(fill="x", padx=10, pady=(10, 2))
|
||
|
||
self._sec_tb_arrow = tk.Label(
|
||
self._head_tb,
|
||
text=("▼" if self._sec_tb_open else "▶"),
|
||
bg=acc, fg="white", font=(FF, 9, "bold"),
|
||
cursor="hand2",
|
||
)
|
||
self._sec_tb_arrow.pack(side="left", padx=(0, 6))
|
||
|
||
ttl = tk.Label(
|
||
self._head_tb, text="Textblöcke",
|
||
bg=acc, fg="white", font=(FF, 9, "bold"),
|
||
cursor="hand2",
|
||
)
|
||
ttl.pack(side="left")
|
||
|
||
minus = tk.Button(
|
||
self._head_tb, text="−", command=self._office_tb_remove,
|
||
bg=acc, fg="white", activebackground=acc, activeforeground="white",
|
||
font=(FF, 11, "bold"), relief="flat", bd=0, highlightthickness=0,
|
||
cursor="hand2", width=2, padx=0, pady=0,
|
||
)
|
||
minus.pack(side="right")
|
||
|
||
plus = tk.Button(
|
||
self._head_tb, text="+", command=self._office_tb_add,
|
||
bg=acc, fg="white", activebackground=acc, activeforeground="white",
|
||
font=(FF, 11, "bold"), relief="flat", bd=0, highlightthickness=0,
|
||
cursor="hand2", width=2, padx=0, pady=0,
|
||
)
|
||
plus.pack(side="right", padx=(0, 4))
|
||
|
||
for _w in (self._sec_tb_arrow, ttl):
|
||
_w.bind("<Button-1>", lambda e: self._toggle_section_tb())
|
||
|
||
self._sec_tb_body = tk.Frame(parent, bg=acc)
|
||
|
||
from aza_persistence import load_textbloecke
|
||
|
||
tb = load_textbloecke()
|
||
for sk in sorted(tb.keys(), key=int):
|
||
row = tk.Frame(self._sec_tb_body, bg=acc)
|
||
row.pack(fill="x", padx=(18, 10), pady=2)
|
||
label = (tb.get(sk) or {}).get("name") or f"Textblock {sk}"
|
||
lb = tk.Label(
|
||
row, text=f" · {label}",
|
||
bg=acc, fg="white", font=FONT_DEFAULT,
|
||
cursor="hand2", anchor="w",
|
||
)
|
||
lb.pack(fill="x")
|
||
lb.bind(
|
||
"<Button-1>",
|
||
lambda e, k=sk: self._on_sidebar_textblock_click(e, str(k)),
|
||
)
|
||
|
||
if self._sec_tb_open:
|
||
self._sec_tb_body.pack(fill="x", after=self._head_tb)
|
||
|
||
def _on_sidebar_textblock_click(self, event: tk.Event, slot_key: str) -> None:
|
||
"""Einzelklick = Einfügen; Shift+Klick öffnet den Editor."""
|
||
st = int(getattr(event, "state", 0) or 0)
|
||
if st & 0x0001:
|
||
self._open_workspace_textblock(str(slot_key))
|
||
return
|
||
ins = getattr(self.app, "_office_sidebar_insert_textblock", None)
|
||
if callable(ins):
|
||
try:
|
||
ins(str(slot_key))
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Textblock-Einfügen: {exc}")
|
||
|
||
def _open_workspace_textblock(self, slot_key: str) -> None:
|
||
try:
|
||
from aza_office_workspace_ui import (
|
||
open_workspace_textblock_editor,
|
||
)
|
||
|
||
open_workspace_textblock_editor(self.app, slot_key)
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Textblock-Editor: {exc}")
|
||
|
||
def _office_tb_add(self) -> None:
|
||
try:
|
||
from aza_persistence import load_textbloecke, save_textbloecke
|
||
from aza_workspace_sync import schedule_workspace_cloud_push, utc_now_iso
|
||
|
||
tb = load_textbloecke()
|
||
keys = sorted(tb.keys(), key=int)
|
||
new_key = str(int(keys[-1]) + 1)
|
||
tb[new_key] = {
|
||
"name": f"Textblock {new_key}",
|
||
"content": "",
|
||
"updated_at": utc_now_iso(),
|
||
}
|
||
save_textbloecke(tb)
|
||
schedule_workspace_cloud_push()
|
||
self.refresh_sidebar_textbloecke_section()
|
||
except Exception as exc:
|
||
try:
|
||
messagebox.showerror("Textblöcke", str(exc), parent=self.app)
|
||
except Exception:
|
||
print(f"[OfficeV1.2] Textblock +: {exc}")
|
||
|
||
def _office_tb_remove(self) -> None:
|
||
try:
|
||
from aza_persistence import load_textbloecke, save_textbloecke
|
||
from aza_workspace_sync import schedule_workspace_cloud_push
|
||
|
||
tb = load_textbloecke()
|
||
keys = sorted(tb.keys(), key=int)
|
||
if len(keys) <= 2:
|
||
messagebox.showinfo(
|
||
"Textblöcke",
|
||
"Es bleiben mindestens zwei Textblöcke erhalten.",
|
||
parent=self.app,
|
||
)
|
||
return
|
||
last_k = str(keys[-1])
|
||
name = (tb.get(last_k) or {}).get("name") or f"Textblock {last_k}"
|
||
if not messagebox.askyesno(
|
||
"Textblöcke",
|
||
f"„{name}“ wirklich löschen?",
|
||
parent=self.app,
|
||
):
|
||
return
|
||
del tb[last_k]
|
||
save_textbloecke(tb)
|
||
schedule_workspace_cloud_push()
|
||
self.refresh_sidebar_textbloecke_section()
|
||
except Exception as exc:
|
||
try:
|
||
messagebox.showerror("Textblöcke", str(exc), parent=self.app)
|
||
except Exception:
|
||
print(f"[OfficeV1.2] Textblock −: {exc}")
|
||
|
||
def refresh_sidebar_textbloecke_section(self) -> None:
|
||
try:
|
||
self._build_sidebar_content()
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Sidebar-Refresh: {exc}")
|
||
|
||
def _toggle_section_arb(self):
|
||
self._sec_arb_open = not self._sec_arb_open
|
||
if self._sec_arb_arrow is not None:
|
||
try:
|
||
self._sec_arb_arrow.configure(
|
||
text=("▼" if self._sec_arb_open else "▶"),
|
||
)
|
||
except Exception:
|
||
pass
|
||
if self._sec_arb_body is not None:
|
||
try:
|
||
if self._sec_arb_open:
|
||
self._sec_arb_body.pack(
|
||
fill="x",
|
||
after=self._sidebar_head_arb,
|
||
)
|
||
else:
|
||
self._sec_arb_body.pack_forget()
|
||
except Exception:
|
||
pass
|
||
self._persist_shell_sections()
|
||
|
||
def _toggle_section_ersch(self):
|
||
self._sec_ersch_open = not self._sec_ersch_open
|
||
if self._sec_ersch_arrow is not None:
|
||
try:
|
||
self._sec_ersch_arrow.configure(
|
||
text=("▼" if self._sec_ersch_open else "▶"),
|
||
)
|
||
except Exception:
|
||
pass
|
||
if self._sec_ersch_body is not None:
|
||
try:
|
||
if self._sec_ersch_open:
|
||
hd = getattr(self, "_sidebar_head_ersch", None)
|
||
if hd is not None:
|
||
self._sec_ersch_body.pack(fill="x", after=hd)
|
||
else:
|
||
self._sec_ersch_body.pack(fill="x")
|
||
else:
|
||
self._sec_ersch_body.pack_forget()
|
||
except Exception:
|
||
pass
|
||
self._persist_shell_sections()
|
||
|
||
def _build_transcript_section(self):
|
||
app = self.app
|
||
p = self._palette
|
||
parent = self._content
|
||
wrap = tk.Frame(parent, bg=p["BG"])
|
||
wrap.pack(side="top", fill="x", padx=18, pady=(4, 4))
|
||
self._shell_section_frames.append(wrap)
|
||
|
||
head = tk.Frame(wrap, bg=p["BG"], cursor="hand2")
|
||
head.pack(fill="x")
|
||
self._shell_section_frames.extend([head])
|
||
|
||
arrow = tk.Label(
|
||
head,
|
||
text=("▼" if self._transcript_open else "▶"),
|
||
bg=p["BG"], fg=p["TEXT"], font=FONT_SECTION,
|
||
padx=2, cursor="hand2",
|
||
)
|
||
arrow.pack(side="left")
|
||
title = tk.Label(head, text=" Transkript", bg=p["BG"], fg=p["TEXT"],
|
||
font=FONT_SECTION, cursor="hand2")
|
||
title.pack(side="left")
|
||
self._shell_labels.extend([arrow, title])
|
||
|
||
body = tk.Frame(wrap, bg=p["BG"])
|
||
self._shell_section_frames.append(body)
|
||
txt = ScrolledText(
|
||
body, wrap="word", font=FONT_DEFAULT,
|
||
bg=p["TEXT_AREA_BG"], fg=p["TEXT_AREA_FG"], relief="flat", bd=0,
|
||
height=8, highlightthickness=1, highlightbackground=p["BORDER"],
|
||
padx=8, pady=6, insertbackground=p["TEXT_AREA_FG"],
|
||
)
|
||
txt.pack(fill="x", pady=(6, 0))
|
||
|
||
app.txt_transcript = txt
|
||
app._transcript_frame = body
|
||
app._transcript_collapsed = not bool(self._transcript_open)
|
||
if self._transcript_open:
|
||
body.pack(fill="x")
|
||
|
||
def _toggle(_e=None):
|
||
self._transcript_open = not self._transcript_open
|
||
if self._transcript_open:
|
||
body.pack(fill="x")
|
||
arrow.configure(text="▼")
|
||
app._transcript_collapsed = False
|
||
else:
|
||
body.pack_forget()
|
||
arrow.configure(text="▶")
|
||
app._transcript_collapsed = True
|
||
self._persist_shell_sections()
|
||
|
||
for w in (head, arrow, title):
|
||
w.bind("<Button-1>", _toggle)
|
||
|
||
def _build_kg_section(self):
|
||
app = self.app
|
||
p = self._palette
|
||
parent = self._content
|
||
wrap = tk.Frame(parent, bg=p["BG"])
|
||
wrap.pack(side="top", fill="both", expand=True, padx=18, pady=(8, 4))
|
||
self._shell_section_frames.append(wrap)
|
||
|
||
head = tk.Frame(wrap, bg=p["BG"])
|
||
head.pack(fill="x")
|
||
self._shell_section_frames.append(head)
|
||
|
||
toggle_box = tk.Frame(head, bg=p["BG"], cursor="hand2")
|
||
toggle_box.pack(side="left")
|
||
self._shell_section_frames.append(toggle_box)
|
||
kg_arrow = tk.Label(
|
||
toggle_box,
|
||
text=("▼" if self._kg_open else "▶"),
|
||
bg=p["BG"], fg=p["TEXT"],
|
||
font=FONT_SECTION, padx=2, cursor="hand2",
|
||
)
|
||
kg_arrow.pack(side="left")
|
||
title = tk.Label(
|
||
toggle_box, text=" Krankengeschichte", bg=p["BG"], fg=p["TEXT"],
|
||
font=FONT_SECTION, cursor="hand2",
|
||
)
|
||
title.pack(side="left")
|
||
self._shell_labels.extend([kg_arrow, title])
|
||
|
||
actions = tk.Frame(head, bg=p["BG"])
|
||
actions.pack(side="right")
|
||
self._shell_section_frames.append(actions)
|
||
|
||
btn_make = self._register_pill(PillButton(
|
||
actions, "KG erstellen",
|
||
command=lambda: _safe_call(app, "make_kg_from_text"),
|
||
kind="primary", width=BTN_W_ACTION, weight="bold",
|
||
tooltip="Krankengeschichte aus Transkript erstellen",
|
||
palette=p,
|
||
))
|
||
btn_make.pack(side="left", padx=(0, 6))
|
||
app.btn_make_kg = btn_make
|
||
|
||
btn_copy = self._register_pill(PillButton(
|
||
actions, "KG kopieren",
|
||
command=lambda: _safe_call(app, "copy_output"),
|
||
kind="ghost", width=BTN_W_ACTION, palette=p,
|
||
tooltip="Krankengeschichte in Zwischenablage kopieren",
|
||
))
|
||
btn_copy.pack(side="left", padx=(0, 6))
|
||
app.btn_copy = btn_copy
|
||
|
||
btn_kom = self._register_pill(PillButton(
|
||
actions, "Kommentare",
|
||
command=lambda: _safe_call(app, "_open_kommentare_fenster"),
|
||
kind="ghost", width=BTN_W_ACTION, palette=p,
|
||
tooltip="Medizinische Kurzkommentare zum KG-Inhalt",
|
||
))
|
||
btn_kom.pack(side="left")
|
||
app._btn_kommentare = btn_kom
|
||
|
||
body = tk.Frame(wrap, bg=p["BG"])
|
||
self._shell_section_frames.append(body)
|
||
|
||
txt = ScrolledText(
|
||
body, wrap="word", font=FONT_DEFAULT,
|
||
bg=p["TEXT_AREA_BG"], fg=p["TEXT_AREA_FG"], relief="flat", bd=0,
|
||
height=15, highlightthickness=1, highlightbackground=p["BORDER"],
|
||
padx=8, pady=6, insertbackground=p["TEXT_AREA_FG"],
|
||
)
|
||
txt.pack(fill="both", expand=True)
|
||
|
||
app.txt_output = txt
|
||
app._kg_frame = body
|
||
app._kg_collapsed = not bool(self._kg_open)
|
||
if self._kg_open:
|
||
body.pack(fill="both", expand=True, pady=(6, 0))
|
||
|
||
def _toggle(_e=None):
|
||
self._kg_open = not self._kg_open
|
||
if self._kg_open:
|
||
body.pack(fill="both", expand=True, pady=(6, 0))
|
||
kg_arrow.configure(text="▼")
|
||
app._kg_collapsed = False
|
||
else:
|
||
body.pack_forget()
|
||
kg_arrow.configure(text="▶")
|
||
app._kg_collapsed = True
|
||
self._persist_shell_sections()
|
||
|
||
for w in (toggle_box, kg_arrow, title):
|
||
w.bind("<Button-1>", _toggle)
|
||
|
||
def _build_soap_section(self):
|
||
app = self.app
|
||
p = self._palette
|
||
parent = self._content
|
||
wrap = tk.Frame(parent, bg=p["BG"])
|
||
wrap.pack(side="top", fill="x", padx=18, pady=(8, 4))
|
||
self._shell_section_frames.append(wrap)
|
||
|
||
head_soap = tk.Frame(wrap, bg=p["BG"], cursor="hand2")
|
||
head_soap.pack(fill="x")
|
||
self._shell_section_frames.append(head_soap)
|
||
|
||
self._soap_arrow = tk.Label(
|
||
head_soap,
|
||
text=("▼" if self._soap_open else "▶"),
|
||
bg=p["BG"], fg=p["TEXT"], font=FONT_SECTION,
|
||
padx=2, cursor="hand2",
|
||
)
|
||
self._soap_arrow.pack(side="left")
|
||
|
||
soap_title = tk.Label(
|
||
head_soap, text=" SOAP", bg=p["BG"], fg=p["TEXT"],
|
||
font=FONT_SECTION, cursor="hand2",
|
||
)
|
||
soap_title.pack(side="left")
|
||
self._shell_labels.extend([self._soap_arrow, soap_title])
|
||
|
||
reset_frm = tk.Frame(head_soap, bg=p["BG"], cursor="hand2")
|
||
reset_frm.pack(side="right")
|
||
reset_lbl = tk.Label(
|
||
reset_frm,
|
||
text="\u21BB",
|
||
font=("Segoe UI", 13),
|
||
bg=p["BG"],
|
||
fg=p["SUBTLE"],
|
||
cursor="hand2",
|
||
padx=4,
|
||
)
|
||
reset_lbl.pack(side="right")
|
||
reset_lbl.bind("<Button-1>",
|
||
lambda e: _safe_call(app, "_reset_all_soap_sections"))
|
||
reset_lbl.bind("<Enter>", lambda e: reset_lbl.configure(fg=p["ACCENT"]))
|
||
reset_lbl.bind("<Leave>", lambda e: reset_lbl.configure(fg=p["SUBTLE"]))
|
||
self._shell_labels.append(reset_lbl)
|
||
|
||
self._soap_fold_body = tk.Frame(wrap, bg=p["BG"])
|
||
self._shell_section_frames.append(self._soap_fold_body)
|
||
|
||
sec_row = tk.Frame(self._soap_fold_body, bg=p["BG"])
|
||
sec_row.pack(fill="x", pady=(6, 0))
|
||
self._shell_section_frames.append(sec_row)
|
||
|
||
soap_inner = tk.Frame(sec_row, bg=p["BG"])
|
||
soap_inner.pack(side="left")
|
||
self._shell_section_frames.append(soap_inner)
|
||
|
||
app._soap_inner = soap_inner
|
||
app._soap_bg = p["BG"]
|
||
if not hasattr(app, "_soap_section_labels"):
|
||
app._soap_section_labels = {}
|
||
try:
|
||
app._rebuild_soap_section_controls()
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] SOAP-Sektionen: {exc}")
|
||
|
||
act = tk.Frame(self._soap_fold_body, bg=p["BG"])
|
||
act.pack(fill="x", pady=(8, 0))
|
||
self._shell_section_frames.append(act)
|
||
|
||
btn_kuerz = self._register_pill(PillButton(
|
||
act, "Kürzer",
|
||
command=lambda: _safe_call(app, "_kg_kuerzer"),
|
||
kind="default", width=BTN_W_SOAP,
|
||
tooltip="Krankengeschichte kürzer fassen",
|
||
palette=p,
|
||
))
|
||
btn_kuerz.pack(side="left", padx=(0, 8))
|
||
app.btn_kg_kuerzer = btn_kuerz
|
||
|
||
btn_ausf = self._register_pill(PillButton(
|
||
act, "Ausführlicher",
|
||
command=lambda: _safe_call(app, "_kg_ausfuehrlicher"),
|
||
kind="default", width=BTN_W_SOAP,
|
||
tooltip="Krankengeschichte ausführlicher gestalten",
|
||
palette=p,
|
||
))
|
||
btn_ausf.pack(side="left", padx=(0, 8))
|
||
app.btn_kg_ausfuehrlicher = btn_ausf
|
||
|
||
btn_vor = self._register_pill(PillButton(
|
||
act, "Vorlage",
|
||
command=lambda: _safe_call(app, "_open_kg_vorlage"),
|
||
kind="default", width=BTN_W_SOAP,
|
||
tooltip="Vorlage für KG-Erstellung bearbeiten",
|
||
palette=p,
|
||
))
|
||
btn_vor.pack(side="left")
|
||
app.btn_kg_vorlage = btn_vor
|
||
|
||
def _soap_toggle(_e=None):
|
||
self._soap_open = not self._soap_open
|
||
arr = getattr(self, "_soap_arrow", None)
|
||
fold = getattr(self, "_soap_fold_body", None)
|
||
if isinstance(arr, tk.Label):
|
||
try:
|
||
arr.configure(text=("▼" if self._soap_open else "▶"))
|
||
except tk.TclError:
|
||
pass
|
||
try:
|
||
if self._soap_open:
|
||
fold.pack(fill="x", after=head_soap)
|
||
elif fold is not None:
|
||
fold.pack_forget()
|
||
except tk.TclError:
|
||
pass
|
||
self._persist_shell_sections()
|
||
|
||
head_soap.bind("<Button-1>", _soap_toggle)
|
||
self._soap_arrow.bind("<Button-1>", _soap_toggle)
|
||
soap_title.bind("<Button-1>", _soap_toggle)
|
||
|
||
if self._soap_open:
|
||
self._soap_fold_body.pack(fill="x", after=head_soap)
|
||
|
||
def _build_documents_section(self):
|
||
app = self.app
|
||
p = self._palette
|
||
parent = self._content
|
||
wrap = tk.Frame(parent, bg=p["BG"])
|
||
wrap.pack(side="top", fill="x", padx=18, pady=(12, 4))
|
||
self._shell_section_frames.append(wrap)
|
||
|
||
head_doc = tk.Frame(wrap, bg=p["BG"], cursor="hand2")
|
||
head_doc.pack(fill="x")
|
||
self._shell_section_frames.append(head_doc)
|
||
|
||
self._documents_arrow = tk.Label(
|
||
head_doc,
|
||
text=("▼" if self._documents_open else "▶"),
|
||
bg=p["BG"], fg=p["TEXT"], font=FONT_SECTION,
|
||
padx=2, cursor="hand2",
|
||
)
|
||
self._documents_arrow.pack(side="left")
|
||
ttl = tk.Label(
|
||
head_doc, text=" Dokumente", bg=p["BG"], fg=p["TEXT"],
|
||
font=FONT_SECTION, cursor="hand2",
|
||
)
|
||
ttl.pack(side="left")
|
||
self._shell_labels.extend([self._documents_arrow, ttl])
|
||
|
||
self._documents_fold_body = tk.Frame(wrap, bg=p["BG"])
|
||
self._shell_section_frames.append(self._documents_fold_body)
|
||
|
||
grid = tk.Frame(self._documents_fold_body, bg=p["BG"])
|
||
grid.pack(fill="x", pady=(6, 0))
|
||
self._shell_section_frames.append(grid)
|
||
|
||
items = [
|
||
("Brief", "open_brief_window"),
|
||
("Rezept", "open_rezept_window"),
|
||
("OP-Bericht", "open_op_bericht_window"),
|
||
("KOGU", "open_kogu_window"),
|
||
("Diskussion mit KI", "open_diskussion_window"),
|
||
("Arztzeugnis", "_open_arztzeugnis"),
|
||
("KI-Kontrolle", "open_ki_pruefen"),
|
||
("Korrektur", "open_pruefen_window"),
|
||
]
|
||
cols = 4
|
||
for i, (label, method) in enumerate(items):
|
||
r, c = divmod(i, cols)
|
||
b = self._register_pill(PillButton(
|
||
grid, label,
|
||
command=(lambda m=method: _safe_call(app, m)),
|
||
kind="default", width=BTN_W_DOC, palette=p,
|
||
tooltip=f"{label} öffnen",
|
||
))
|
||
b.grid(row=r, column=c,
|
||
padx=(0 if c == 0 else 8), pady=4, sticky="w")
|
||
|
||
def _doc_toggle(_e=None):
|
||
self._documents_open = not self._documents_open
|
||
arr = getattr(self, "_documents_arrow", None)
|
||
fold = getattr(self, "_documents_fold_body", None)
|
||
if isinstance(arr, tk.Label):
|
||
try:
|
||
arr.configure(text=("▼" if self._documents_open else "▶"))
|
||
except tk.TclError:
|
||
pass
|
||
try:
|
||
if self._documents_open:
|
||
fold.pack(fill="x", after=head_doc)
|
||
elif fold is not None:
|
||
fold.pack_forget()
|
||
except tk.TclError:
|
||
pass
|
||
self._persist_shell_sections()
|
||
|
||
head_doc.bind("<Button-1>", _doc_toggle)
|
||
self._documents_arrow.bind("<Button-1>", _doc_toggle)
|
||
ttl.bind("<Button-1>", _doc_toggle)
|
||
|
||
if self._documents_open:
|
||
self._documents_fold_body.pack(fill="x", after=head_doc)
|
||
|
||
def _build_footer(self):
|
||
app = self.app
|
||
p = self._palette
|
||
|
||
self._sep_bottom = tk.Frame(app, bg=p["BORDER"], height=1)
|
||
self._sep_bottom.pack(side="bottom", fill="x")
|
||
|
||
self._footer_bar = tk.Frame(app, bg=p["BG"])
|
||
self._footer_bar.pack(side="bottom", fill="x", padx=18, pady=12)
|
||
|
||
self._logo_img = _load_logo(LOGO_PX)
|
||
self._footer_logo_lbl = None
|
||
if self._logo_img is not None:
|
||
self._footer_logo_lbl = tk.Label(
|
||
self._footer_bar, image=self._logo_img, bg=p["BG"],
|
||
bd=0, highlightthickness=0,
|
||
)
|
||
self._footer_logo_lbl.image = self._logo_img
|
||
self._footer_logo_lbl.pack(side="left", padx=(0, 12))
|
||
|
||
tb = tk.Frame(self._footer_bar, bg=p["BG"])
|
||
tb.pack(side="left", anchor="w")
|
||
self._footer_tb = tb
|
||
self._footer_brand_title = tk.Label(
|
||
tb, text="AzA von Arzt zu Arzt", bg=p["BG"],
|
||
fg=p["TEXT_STRONG"], font=FONT_BRAND,
|
||
)
|
||
self._footer_brand_title.pack(anchor="w")
|
||
self._footer_brand_sub = tk.Label(
|
||
tb, text="Informatik zu fairen Preisen", bg=p["BG"],
|
||
fg=p["SUBTLE"], font=FONT_BRAND_SUB,
|
||
)
|
||
self._footer_brand_sub.pack(anchor="w")
|
||
|
||
def _periodic_license_refresh(self):
|
||
try:
|
||
self._update_license_label()
|
||
finally:
|
||
try:
|
||
self.app.after(15000, self._periodic_license_refresh)
|
||
except Exception:
|
||
pass
|
||
|
||
def _update_license_label(self):
|
||
if not self._license_lbl:
|
||
return
|
||
p = self._palette
|
||
try:
|
||
mode = getattr(self.app, "license_mode", "demo")
|
||
self._license_lbl.configure(
|
||
text=("Lizenz: aktiv" if mode == "active" else "Demo / Testversion"),
|
||
fg=p["ACCENT"] if mode == "active" else p["WARN"],
|
||
bg=p["SURFACE"],
|
||
)
|
||
except Exception:
|
||
pass
|
||
|
||
def _enforce_default_fonts(self):
|
||
for attr in ("txt_output", "txt_transcript"):
|
||
w = getattr(self.app, attr, None)
|
||
if w is None:
|
||
continue
|
||
try:
|
||
w.configure(font=FONT_DEFAULT)
|
||
except Exception:
|
||
pass
|
||
|
||
|
||
def apply_office_shell_v1(app) -> None:
|
||
"""Wendet die AzA Office Hülle V1.2 auf eine bestehende ``KGDesktopApp`` an.
|
||
|
||
Der Funktionsname bleibt aus Kompatibilität zu ``basis14.py`` erhalten.
|
||
"""
|
||
if getattr(app, "_aza_office_v1_installed", False):
|
||
return
|
||
app._suppress_inline_soap_reset_icon = True
|
||
try:
|
||
shell = _OfficeShellV12(app)
|
||
shell.install()
|
||
app._aza_office_v1 = shell
|
||
app._aza_office_v1_installed = True
|
||
except Exception as exc:
|
||
print(f"[OfficeV1.2] Installation fehlgeschlagen: {exc}")
|
||
import traceback
|
||
traceback.print_exc()
|
||
|
||
|
||
__all__ = ["apply_office_shell_v1"]
|