squad-manager/akte.py
danny f89396e1b9 Stufe 3: Akte als PNG-Karte teilen
Neuer Knopf "Teilen ..." in der Akte. akte_karte.py zeichnet mit Pillow
eine Karte 1200 x 675 fuer Discord: Portraet, Callsign, Dienstgrad,
Fraktion, Einheit, Status mit Stempel, Auszeichnungen. Kopieren legt sie
als DIB und als PNG in die Zwischenablage (Strg+V in Discord), alternativ
Speichern als PNG-Datei.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
2026-09-11 06:27:37 +02:00

818 lines
35 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

"""
Modul Akte: Personalakten fuer Rollenspiel-Charaktere.
Links die Liste der eigenen Akten, rechts die gewaehlte Akte - wahlweise
als Dokument (Ansicht) oder als Formular (Bearbeiten). Die Datenhaltung
liegt in akte_modell.py, die Vorschlagslisten in akte_vorlagen.py.
"""
import math
import tkinter as tk
from tkinter import ttk, filedialog, messagebox
from PIL import Image, ImageOps, ImageTk
import akte_karte
import akte_modell as modell
import akte_vorlagen as vorlagen
from theme import (BG, PANEL, LINE, FG, FG_DIM, OLIVE, OLIVE_HI, AMBER, RED,
FONT_UI, FONT_BOLD, FONT_MONO, dunkle_titelleiste)
SPEICHERN_NACH_MS = 800
FONT_DOK = ("Consolas", 10)
FONT_DOK_FETT = ("Consolas", 10, "bold")
FONT_DOK_KLEIN = ("Consolas", 9)
FONT_STEMPEL = ("Consolas", 15, "bold")
FONT_CALLSIGN = ("Segoe UI Semibold", 22)
FONT_NAME = ("Segoe UI", 12)
TEXT_STIL = dict(bg=PANEL, fg=FG, insertbackground=FG, relief="flat",
highlightthickness=1, highlightbackground=LINE,
highlightcolor=OLIVE, font=FONT_UI, padx=6, pady=4,
wrap="word", selectbackground=OLIVE,
selectforeground="#12150f", undo=True)
PERSONALIEN = [
(("personalien", "vorname"), "Vorname"),
(("personalien", "nachname"), "Nachname"),
(("personalien", "callsign"), "Callsign"),
(("personalien", "geburtsdatum"), "Geburtsdatum"),
(("personalien", "herkunft"), "Herkunft"),
]
DIENST = [
(("dienst", "fraktion"), "Fraktion"),
(("dienst", "teilstreitkraft"), "Teilstreitkraft"),
(("dienst", "rang"), "Dienstgrad"),
(("dienst", "verwendung"), "Verwendung"),
(("dienst", "dienstbeginn"), "Dienstbeginn"),
(("dienst", "status"), "Status"),
]
EINHEIT = [
(("dienst", "einheit", "verband"), "Verband"),
(("dienst", "einheit", "bataillon"), "Bataillon"),
(("dienst", "einheit", "kompanie"), "Kompanie"),
(("dienst", "einheit", "zug"), "Zug"),
(("dienst", "einheit", "gruppe"), "Gruppe"),
]
LISTEN = {
"auszeichnungen": ("Auszeichnung",
[("bezeichnung", "Bezeichnung", False),
("datum", "Datum", False),
("anlass", "Anlass", True)]),
"einsaetze": ("Einsatz",
[("datum", "Datum", False),
("ort", "Ort", False),
("bericht", "Bericht", True)]),
}
NAMENSFELDER = {("personalien", "vorname"), ("personalien", "nachname"),
("personalien", "callsign"), ("dienst", "rang")}
def wert(akte, pfad):
ziel = akte
for teil in pfad:
ziel = ziel.get(teil, "") if isinstance(ziel, dict) else ""
return ziel if isinstance(ziel, str) else ""
def setzen(akte, pfad, inhalt):
ziel = akte
for teil in pfad[:-1]:
ziel = ziel.setdefault(teil, {})
ziel[pfad[-1]] = inhalt
def eintrag_dialog(eltern, titel, felder, werte=None):
"""Kleines Eingabefenster fuer einen Listeneintrag. None bei Abbruch."""
werte = werte or {}
fenster = tk.Toplevel(eltern)
fenster.title(titel)
fenster.configure(bg=BG)
fenster.resizable(False, False)
fenster.transient(eltern.winfo_toplevel())
rahmen = ttk.Frame(fenster)
rahmen.pack(padx=18, pady=16, fill="both")
eingaben = {}
erstes = None
for zeile, (schluessel, beschriftung, lang) in enumerate(felder):
ttk.Label(rahmen, text=beschriftung).grid(
row=zeile, column=0, sticky="nw", padx=(0, 12), pady=5)
if lang:
feld = tk.Text(rahmen, width=46, height=6, **TEXT_STIL)
feld.insert("1.0", werte.get(schluessel, ""))
else:
feld = ttk.Entry(rahmen, width=48)
feld.insert(0, werte.get(schluessel, ""))
feld.grid(row=zeile, column=1, sticky="ew", pady=5)
eingaben[schluessel] = feld
erstes = erstes or feld
ergebnis = {}
def uebernehmen(*_):
for schluessel, feld in eingaben.items():
inhalt = feld.get("1.0", "end-1c") if isinstance(feld, tk.Text) else feld.get()
ergebnis[schluessel] = inhalt.strip()
fenster.destroy()
knoepfe = ttk.Frame(rahmen)
knoepfe.grid(row=len(felder), column=0, columnspan=2, sticky="e", pady=(12, 0))
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
ttk.Button(knoepfe, text="Übernehmen", style="Accent.TButton",
command=uebernehmen).pack(side="right", padx=(0, 8))
fenster.bind("<Escape>", lambda e: fenster.destroy())
dunkle_titelleiste(fenster)
fenster.update_idletasks()
oben = eltern.winfo_toplevel()
x = oben.winfo_rootx() + (oben.winfo_width() - fenster.winfo_width()) // 2
y = oben.winfo_rooty() + (oben.winfo_height() - fenster.winfo_height()) // 3
fenster.geometry(f"+{max(x, 0)}+{max(y, 0)}")
fenster.grab_set()
if erstes is not None:
erstes.focus_set()
eltern.wait_window(fenster)
return ergebnis or None
class ScrollFlaeche(ttk.Frame):
"""Senkrecht scrollbarer Bereich; der Inhalt gehoert in self.innen."""
def __init__(self, master):
super().__init__(master)
self.canvas = tk.Canvas(self, bg=BG, highlightthickness=0, bd=0)
leiste = ttk.Scrollbar(self, orient="vertical", command=self.canvas.yview)
self.canvas.configure(yscrollcommand=leiste.set)
leiste.pack(side="right", fill="y")
self.canvas.pack(side="left", fill="both", expand=True)
self.innen = ttk.Frame(self.canvas)
self._fenster = self.canvas.create_window(0, 0, window=self.innen, anchor="nw")
self.innen.bind("<Configure>", lambda e: self.canvas.configure(
scrollregion=self.canvas.bbox("all")))
self.canvas.bind("<Configure>", lambda e: self.canvas.itemconfigure(
self._fenster, width=e.width))
self._rollziel = self.canvas
class AkteSeite(ttk.Frame):
"""Inhalt des Hauptreiters AKTE."""
def __init__(self, master):
super().__init__(master)
self.akten = []
self.aktuell = None
self._geaendert_flag = False
self._speicher_job = None
self._zeichen_job = None
self._laedt = False
self._fotos = {}
self.modus = "ansicht"
self._aufbau()
self.bind_all("<MouseWheel>", self._mausrad, add="+")
self.akten_laden()
# -- Aufbau ------------------------------------------------------------
def _aufbau(self):
self.columnconfigure(1, weight=1)
self.rowconfigure(0, weight=1)
links = ttk.Frame(self, width=240)
links.grid(row=0, column=0, sticky="nsw", padx=(0, 12), pady=(8, 0))
links.rowconfigure(1, weight=1)
ttk.Label(links, text="AKTEN", style="Dim.TLabel").grid(
row=0, column=0, columnspan=2, sticky="w", pady=(0, 4))
self.liste = ttk.Treeview(links, columns=("name", "nr"), show="headings",
selectmode="browse", height=12)
self.liste.heading("name", text="Name", anchor="w")
self.liste.heading("nr", text="Nr.", anchor="w")
self.liste.column("name", width=150, anchor="w")
self.liste.column("nr", width=86, anchor="w", stretch=False)
self.liste.grid(row=1, column=0, columnspan=2, sticky="nsew")
self.liste.bind("<<TreeviewSelect>>", self._auswahl)
ttk.Button(links, text="Neue Akte", style="Accent.TButton",
command=self.neue_akte).grid(row=2, column=0, sticky="ew",
pady=(8, 0), padx=(0, 4))
ttk.Button(links, text="Papierkorb", command=self.in_papierkorb).grid(
row=2, column=1, sticky="ew", pady=(8, 0))
rechts = ttk.Frame(self)
rechts.grid(row=0, column=1, sticky="nsew", pady=(8, 0))
rechts.columnconfigure(0, weight=1)
rechts.rowconfigure(1, weight=1)
self.rechts = rechts
leiste = ttk.Frame(rechts)
leiste.grid(row=0, column=0, sticky="ew", pady=(0, 6))
self.nummer_var = tk.StringVar()
ttk.Label(leiste, textvariable=self.nummer_var, style="Mono.TLabel").pack(side="left")
self.knopf_bearbeiten = ttk.Button(leiste, text="Bearbeiten",
command=lambda: self.modus_setzen("bearbeiten"))
self.knopf_bearbeiten.pack(side="right")
self.knopf_ansicht = ttk.Button(leiste, text="Ansicht",
command=lambda: self.modus_setzen("ansicht"))
self.knopf_ansicht.pack(side="right", padx=(0, 6))
self.knopf_teilen = ttk.Button(leiste, text="Teilen …", command=self.teilen_menue)
self.knopf_teilen.pack(side="right", padx=(0, 18))
self.rueckmeldung_var = tk.StringVar()
ttk.Label(leiste, textvariable=self.rueckmeldung_var, style="Dim.TLabel").pack(
side="left", padx=(16, 0))
self._rueckmeldung_job = None
self.leiste = leiste
# Dokumentansicht
self.ansicht = ttk.Frame(rechts)
self.dok = tk.Canvas(self.ansicht, bg=BG, highlightthickness=0, bd=0)
dok_leiste = ttk.Scrollbar(self.ansicht, orient="vertical", command=self.dok.yview)
self.dok.configure(yscrollcommand=dok_leiste.set)
dok_leiste.pack(side="right", fill="y")
self.dok.pack(side="left", fill="both", expand=True)
self.dok._rollziel = self.dok
self.dok.bind("<Configure>", lambda e: self._neu_zeichnen_planen())
# Formular
self.formular = ScrollFlaeche(rechts)
self._formular_aufbauen(self.formular.innen)
# Leerzustand
self.leer = ttk.Frame(rechts)
mitte = ttk.Frame(self.leer)
mitte.place(relx=0.5, rely=0.4, anchor="center")
stempel = tk.Canvas(mitte, width=300, height=86, bg=BG, highlightthickness=0)
stempel.pack(pady=(0, 18))
stempel.create_rectangle(8, 8, 292, 78, outline=AMBER, width=3)
stempel.create_rectangle(15, 15, 285, 71, outline=AMBER, width=1)
stempel.create_text(150, 43, text="PERSONALAKTE", fill=AMBER,
font=("Consolas", 20, "bold"))
ttk.Label(mitte, text="Noch keine Akte angelegt",
font=("Segoe UI Semibold", 12)).pack()
ttk.Label(mitte, style="Dim.TLabel", justify="center",
text="Lege eine Akte für deinen Charakter an: Porträt,\n"
"Dienstgrad, Einheit, Auszeichnungen und Werdegang.").pack(pady=(6, 14))
ttk.Button(mitte, text="Erste Akte anlegen", style="Accent.TButton",
command=self.neue_akte).pack()
def _abschnitt(self, eltern, titel):
rahmen = ttk.LabelFrame(eltern, text=titel)
rahmen.pack(fill="x", padx=(2, 14), pady=(0, 12))
innen = ttk.Frame(rahmen)
innen.pack(fill="x", padx=12, pady=10)
return innen
def _formular_aufbauen(self, f):
self.vars = {}
def feld(eltern, zeile, spalte, pfad, beschriftung, art="eingabe", werte=()):
ttk.Label(eltern, text=beschriftung).grid(
row=zeile, column=spalte, sticky="w", padx=(0, 10), pady=4)
var = tk.StringVar()
if art == "eingabe":
widget = ttk.Entry(eltern, textvariable=var)
else:
widget = ttk.Combobox(eltern, textvariable=var, values=list(werte),
state="readonly" if art == "fest" else "normal")
# Mausrad soll die Seite rollen, nicht den Eintrag wechseln
widget.bind("<MouseWheel>", lambda e: (self._mausrad(e), "break")[1])
widget.grid(row=zeile, column=spalte + 1, sticky="ew", pady=4, padx=(0, 16))
var.trace_add("write", lambda *_, p=pfad, v=var: self._feld_geaendert(p, v.get()))
self.vars[pfad] = var
return widget
# I. Personalien, mit Portraet rechts
p = self._abschnitt(f, "I. Personalien")
p.columnconfigure(1, weight=1)
for zeile, (pfad, beschriftung) in enumerate(PERSONALIEN):
feld(p, zeile, 0, pfad, beschriftung)
bildrahmen = ttk.Frame(p)
bildrahmen.grid(row=0, column=2, rowspan=len(PERSONALIEN), sticky="ne", padx=(8, 0))
self.bild_vorschau = tk.Label(bildrahmen, bg=PANEL, fg=FG_DIM, width=12, height=7,
text="kein\nPorträt", font=FONT_UI,
highlightthickness=1, highlightbackground=LINE)
self.bild_vorschau.pack()
ttk.Button(bildrahmen, text="Bild wählen …",
command=self.portraet_waehlen).pack(fill="x", pady=(6, 2))
ttk.Button(bildrahmen, text="Entfernen",
command=self.portraet_entfernen).pack(fill="x")
# II. Dienst
d = self._abschnitt(f, "II. Dienst")
d.columnconfigure(1, weight=1)
d.columnconfigure(3, weight=1)
self.fraktion_box = feld(d, 0, 0, ("dienst", "fraktion"), "Fraktion", "liste",
vorlagen.fraktionsnamen())
self.tsk_box = feld(d, 0, 2, ("dienst", "teilstreitkraft"), "Teilstreitkraft",
"liste", vorlagen.TEILSTREITKRAEFTE)
self.rang_box = feld(d, 1, 0, ("dienst", "rang"), "Dienstgrad", "liste")
feld(d, 1, 2, ("dienst", "verwendung"), "Verwendung", "liste", vorlagen.VERWENDUNGEN)
feld(d, 2, 0, ("dienst", "dienstbeginn"), "Dienstbeginn")
feld(d, 2, 2, ("dienst", "status"), "Status", "fest", modell.STATUS)
ttk.Label(d, text="Einheit", style="Dim.TLabel").grid(
row=3, column=0, columnspan=4, sticky="w", pady=(10, 2))
for i, (pfad, beschriftung) in enumerate(EINHEIT):
feld(d, 4 + i // 2, (i % 2) * 2, pfad, beschriftung)
# III. Beschreibung
b = self._abschnitt(f, "III. Beschreibung")
self.text_beschreibung = self._textfeld(b, "beschreibung", 7)
# IV. und V. Listen
self.listen = {}
for schluessel, titel in (("auszeichnungen", "IV. Auszeichnungen"),
("einsaetze", "V. Einsätze")):
self.listen[schluessel] = self._listenfeld(self._abschnitt(f, titel), schluessel)
# VI. Vermerke
v = self._abschnitt(f, "VI. Vermerke")
self.text_vermerke = self._textfeld(v, "vermerke", 4)
def _textfeld(self, eltern, schluessel, hoehe):
text = tk.Text(eltern, height=hoehe, **TEXT_STIL)
text.pack(fill="x")
def geaendert(_):
if text.edit_modified():
text.edit_modified(False)
if not self._laedt and self.aktuell is not None:
self.aktuell[schluessel] = text.get("1.0", "end-1c")
self._speichern_planen()
text.bind("<<Modified>>", geaendert)
return text
def _listenfeld(self, eltern, schluessel):
einzahl, felder = LISTEN[schluessel]
spalten = [f[0] for f in felder]
tabelle = ttk.Treeview(eltern, columns=spalten, show="headings", height=4,
selectmode="browse")
for s, beschriftung, lang in felder:
tabelle.heading(s, text=beschriftung, anchor="w")
breite = 260 if lang else 80 if s == "datum" else 180
tabelle.column(s, width=breite, anchor="w", stretch=lang)
tabelle.pack(fill="x")
tabelle.bind("<Double-1>", lambda e: self._eintrag_bearbeiten(schluessel))
knoepfe = ttk.Frame(eltern)
knoepfe.pack(fill="x", pady=(6, 0))
ttk.Button(knoepfe, text=f"{einzahl} hinzufügen",
command=lambda: self._eintrag_neu(schluessel)).pack(side="left")
ttk.Button(knoepfe, text="Bearbeiten",
command=lambda: self._eintrag_bearbeiten(schluessel)).pack(side="left", padx=6)
ttk.Button(knoepfe, text="Entfernen",
command=lambda: self._eintrag_entfernen(schluessel)).pack(side="left")
return tabelle
# -- Liste der Akten -----------------------------------------------------
def akten_laden(self, auswahl=None):
self.akten = modell.alle_akten()
self.liste.delete(*self.liste.get_children())
for akte in self.akten:
self.liste.insert("", "end", iid=akte["id"],
values=(modell.listenname(akte), akte["aktennummer"]))
if not self.akten:
self.aktuell = None
self._zeigen(self.leer)
self.nummer_var.set("")
return
ziel = auswahl if auswahl in {a["id"] for a in self.akten} else self.akten[0]["id"]
self.liste.selection_set(ziel)
self.liste.see(ziel)
self._oeffnen(ziel)
def _auswahl(self, _=None):
auswahl = self.liste.selection()
if auswahl and (self.aktuell is None or auswahl[0] != self.aktuell["id"]):
self._oeffnen(auswahl[0])
def _oeffnen(self, akte_id):
self.speichern_sofort()
vorher = self.aktuell["id"] if self.aktuell else None
self.aktuell = next((a for a in self.akten if a["id"] == akte_id), None)
if self.aktuell is None:
return
self.nummer_var.set(f"AKTE {self.aktuell['aktennummer']}")
self._formular_fuellen()
if akte_id != vorher:
# Eine andere Akte beginnt oben, nicht an der Stelle der vorigen
self.dok.yview_moveto(0)
self.formular.canvas.yview_moveto(0)
self.modus_setzen(self.modus)
def neue_akte(self):
self.speichern_sofort()
try:
akte = modell.neu_anlegen()
except OSError as fehler:
messagebox.showerror("Akte", f"Die Akte konnte nicht angelegt werden:\n{fehler}")
return
self.modus = "bearbeiten"
self.akten_laden(akte["id"])
def in_papierkorb(self):
if self.aktuell is None:
return
name = modell.anzeigename(self.aktuell)
if not messagebox.askyesno(
"Akte in den Papierkorb",
f"„{name}“ in den Papierkorb verschieben?\n\n"
"Die Akte wird nicht gelöscht, sondern in den Ordner "
"_papierkorb verschoben und lässt sich von dort zurückholen."):
return
self.speichern_sofort()
modell.in_papierkorb(self.aktuell["id"])
self.aktuell = None
self.akten_laden()
# -- Teilen --------------------------------------------------------------
def teilen_menue(self):
if self.aktuell is None:
return
menue = tk.Menu(self, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE,
activeforeground="#12150f", font=FONT_UI)
menue.add_command(label="Karte kopieren – in Discord mit Strg+V einfügen",
command=self.karte_kopieren)
menue.add_command(label="Karte als PNG speichern …", command=self.karte_speichern)
knopf = self.knopf_teilen
menue.tk_popup(knopf.winfo_rootx(), knopf.winfo_rooty() + knopf.winfo_height())
def _karte(self):
self.speichern_sofort()
return akte_karte.karte(self.aktuell)
def karte_kopieren(self):
try:
akte_karte.in_zwischenablage(self._karte())
except Exception as fehler:
messagebox.showerror("Akte teilen",
f"Die Karte konnte nicht kopiert werden:\n{fehler}")
return
# Kurz: Neben Nummer und drei Knoepfen bleiben in der Leiste nur
# rund 150 Pixel. Den Tipp mit Strg+V nennt schon der Menueeintrag.
self._rueckmeldung("✓ Kopiert")
def karte_speichern(self):
ziel = filedialog.asksaveasfilename(
parent=self, title="Karte speichern", defaultextension=".png",
filetypes=[("PNG-Bild", "*.png")],
initialfile=akte_karte.dateiname(self.aktuell))
if not ziel:
return
try:
self._karte().save(ziel, "PNG", optimize=True)
except Exception as fehler:
messagebox.showerror("Akte teilen",
f"Die Karte konnte nicht gespeichert werden:\n{fehler}")
return
self._rueckmeldung("✓ Gespeichert")
def _rueckmeldung(self, text):
self.rueckmeldung_var.set(text)
if self._rueckmeldung_job is not None:
self.after_cancel(self._rueckmeldung_job)
self._rueckmeldung_job = self.after(
5000, lambda: self.rueckmeldung_var.set(""))
# -- Umschalten ----------------------------------------------------------
def _zeigen(self, rahmen):
for r in (self.ansicht, self.formular, self.leer):
if r is not rahmen:
r.grid_remove()
rahmen.grid(row=1, column=0, sticky="nsew")
if rahmen is self.leer:
self.leiste.grid_remove()
else:
self.leiste.grid()
def modus_setzen(self, modus):
self.modus = modus
if self.aktuell is None:
self._zeigen(self.leer)
return
if modus == "ansicht":
self.speichern_sofort()
self._zeigen(self.ansicht)
self.ansicht_zeichnen()
else:
self._zeigen(self.formular)
self.knopf_ansicht.configure(style="Accent.TButton" if modus == "ansicht" else "TButton")
self.knopf_bearbeiten.configure(style="Accent.TButton" if modus != "ansicht" else "TButton")
# -- Formular ------------------------------------------------------------
def _formular_fuellen(self):
a = self.aktuell
self._laedt = True
try:
for pfad, var in self.vars.items():
var.set(wert(a, pfad))
self._raenge_anpassen()
for text, schluessel in ((self.text_beschreibung, "beschreibung"),
(self.text_vermerke, "vermerke")):
text.delete("1.0", "end")
text.insert("1.0", a.get(schluessel, ""))
text.edit_reset()
text.edit_modified(False)
for schluessel in self.listen:
self._liste_fuellen(schluessel)
self._vorschau_aktualisieren()
finally:
self._laedt = False
def _feld_geaendert(self, pfad, inhalt):
if self._laedt or self.aktuell is None:
return
setzen(self.aktuell, pfad, inhalt)
if pfad == ("dienst", "fraktion"):
self._raenge_anpassen()
if not self.vars[("dienst", "teilstreitkraft")].get():
standard = vorlagen.standard_teilstreitkraft(inhalt)
if standard:
self.vars[("dienst", "teilstreitkraft")].set(standard)
if pfad in NAMENSFELDER:
self.liste.item(self.aktuell["id"],
values=(modell.listenname(self.aktuell),
self.aktuell["aktennummer"]))
self._speichern_planen()
def _raenge_anpassen(self):
fraktion = self.vars[("dienst", "fraktion")].get()
self.rang_box["values"] = vorlagen.raenge_fuer(fraktion)
def _liste_fuellen(self, schluessel):
tabelle = self.listen[schluessel]
tabelle.delete(*tabelle.get_children())
_, felder = LISTEN[schluessel]
for i, eintrag in enumerate(self.aktuell.get(schluessel, [])):
tabelle.insert("", "end", iid=str(i),
values=[eintrag.get(f[0], "").replace("\n", " ") for f in felder])
def _eintrag_neu(self, schluessel):
if self.aktuell is None:
return
einzahl, felder = LISTEN[schluessel]
eintrag = eintrag_dialog(self, f"{einzahl} hinzufügen", felder)
if eintrag and any(eintrag.values()):
self.aktuell.setdefault(schluessel, []).append(eintrag)
self._liste_fuellen(schluessel)
self._speichern_planen()
def _eintrag_bearbeiten(self, schluessel):
auswahl = self.listen[schluessel].selection()
if self.aktuell is None or not auswahl:
return
i = int(auswahl[0])
einzahl, felder = LISTEN[schluessel]
eintrag = eintrag_dialog(self, f"{einzahl} bearbeiten", felder,
self.aktuell[schluessel][i])
if eintrag is not None:
self.aktuell[schluessel][i] = eintrag
self._liste_fuellen(schluessel)
self._speichern_planen()
def _eintrag_entfernen(self, schluessel):
auswahl = self.listen[schluessel].selection()
if self.aktuell is None or not auswahl:
return
del self.aktuell[schluessel][int(auswahl[0])]
self._liste_fuellen(schluessel)
self._speichern_planen()
# -- Portraet ------------------------------------------------------------
def _foto(self, akte_id, groesse):
pfad = modell.portraet_pfad(akte_id)
if pfad is None:
return None
schluessel = (akte_id, groesse)
stand = pfad.stat().st_mtime
vorhanden = self._fotos.get(schluessel)
if vorhanden and vorhanden[0] == stand:
return vorhanden[1]
with Image.open(pfad) as bild:
foto = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), groesse))
self._fotos[schluessel] = (stand, foto)
return foto
def _vorschau_aktualisieren(self):
foto = self._foto(self.aktuell["id"], (96, 120)) if self.aktuell else None
if foto:
self.bild_vorschau.configure(image=foto, text="", width=96, height=120)
else:
self.bild_vorschau.configure(image="", text="kein\nPorträt", width=12, height=7)
def portraet_waehlen(self):
if self.aktuell is None:
return
quelle = filedialog.askopenfilename(
title="Porträt wählen",
filetypes=[("Bilder", "*.png *.jpg *.jpeg *.webp *.bmp *.gif"),
("Alle Dateien", "*.*")])
if not quelle:
return
try:
modell.portraet_setzen(self.aktuell["id"], quelle)
except modell.AktenFehler as fehler:
messagebox.showerror("Porträt", str(fehler))
return
self._vorschau_aktualisieren()
def portraet_entfernen(self):
if self.aktuell is None or modell.portraet_pfad(self.aktuell["id"]) is None:
return
modell.portraet_entfernen(self.aktuell["id"])
self._fotos = {k: v for k, v in self._fotos.items() if k[0] != self.aktuell["id"]}
self._vorschau_aktualisieren()
# -- Speichern -----------------------------------------------------------
def _speichern_planen(self):
self._geaendert_flag = True
if self._speicher_job is not None:
self.after_cancel(self._speicher_job)
self._speicher_job = self.after(SPEICHERN_NACH_MS, self.speichern_sofort)
def speichern_sofort(self):
if self._speicher_job is not None:
self.after_cancel(self._speicher_job)
self._speicher_job = None
if not self._geaendert_flag or self.aktuell is None:
return
try:
modell.speichern(self.aktuell)
self._geaendert_flag = False
except OSError as fehler:
messagebox.showerror("Akte", f"Die Akte konnte nicht gespeichert werden:\n{fehler}")
# -- Mausrad -------------------------------------------------------------
def _mausrad(self, ereignis):
try:
widget = self.winfo_containing(ereignis.x_root, ereignis.y_root)
except (KeyError, tk.TclError):
return
while widget is not None:
if isinstance(widget, (tk.Text, ttk.Treeview)):
return
ziel = getattr(widget, "_rollziel", None)
if ziel is not None:
ziel.yview_scroll(int(-ereignis.delta / 120), "units")
return
if widget is self:
return
widget = widget.master
# -- Dokumentansicht -----------------------------------------------------
def _neu_zeichnen_planen(self):
if self.modus != "ansicht" or self.aktuell is None:
return
if self._zeichen_job is not None:
self.after_cancel(self._zeichen_job)
self._zeichen_job = self.after(60, self.ansicht_zeichnen)
def ansicht_zeichnen(self):
self._zeichen_job = None
c = self.dok
c.delete("all")
a = self.aktuell
if a is None:
return
breite = max(c.winfo_width(), 540)
rand = 14
links, rechts = rand + 22, breite - rand - 22
dienst, pers = a.get("dienst", {}), a.get("personalien", {})
status = dienst.get("status", "aktiv")
gefallen = status == "gefallen"
schrift = FG_DIM if gefallen else FG
akzent = FG_DIM if gefallen else OLIVE_HI
y = rand + 18
c.create_text(links, y, anchor="nw", fill=FG_DIM, font=FONT_DOK_KLEIN,
text=f"AKTE NR. {a.get('aktennummer', '')}")
c.create_text(rechts, y, anchor="ne", fill=FG_DIM, font=FONT_DOK_KLEIN,
text="SQUAD MANAGER · PERSONALWESEN")
y += 26
c.create_text(links + 10, y + 6, anchor="nw", text="PERSONALAKTE",
fill=AMBER, font=FONT_STEMPEL, tags="stempel")
x0, y0, x1, y1 = c.bbox("stempel")
c.create_rectangle(x0 - 10, y0 - 6, x1 + 10, y1 + 6, outline=AMBER, width=2)
y = y1 + 26
# Portraet rechts oben
pb, ph = 150, 190
px1, px0 = rechts, rechts - pb
py0, py1 = y, y + ph
c.create_rectangle(px0 - 5, py0 - 5, px1 + 5, py1 + 5, outline=LINE)
foto = self._foto(a["id"], (pb, ph))
if foto:
c.create_image((px0 + px1) // 2, (py0 + py1) // 2, image=foto)
else:
c.create_rectangle(px0, py0, px1, py1, fill=BG, outline="")
c.create_text((px0 + px1) // 2, (py0 + py1) // 2, text="KEIN\nPORTRÄT",
fill=FG_DIM, font=FONT_DOK_KLEIN, justify="center")
# Kopfdaten links neben dem Portraet
textbreite = px0 - links - 30
name = " ".join(t for t in (pers.get("vorname", ""), pers.get("nachname", "")) if t)
callsign = pers.get("callsign", "")
titel = callsign.upper() if callsign else (name or "OHNE NAMEN")
oben = y
t = c.create_text(links, oben, anchor="nw", text=titel, fill=akzent,
font=FONT_CALLSIGN, width=textbreite)
oben = c.bbox(t)[3] + 4
zweite = " ".join(x for x in (dienst.get("rang", ""), name if callsign else "") if x)
if zweite:
t = c.create_text(links, oben, anchor="nw", text=zweite, fill=schrift,
font=FONT_NAME, width=textbreite)
oben = c.bbox(t)[3] + 14
else:
oben += 10
for zeile in (" · ".join(x for x in (dienst.get("fraktion", ""),
dienst.get("teilstreitkraft", "")) if x),
dienst.get("verwendung", ""),
f"STATUS: {status.upper()}"):
if zeile:
t = c.create_text(links, oben, anchor="nw", text=zeile, fill=schrift,
font=FONT_DOK, width=textbreite)
oben = c.bbox(t)[3] + 4
if status in ("gefallen", "vermisst"):
self._stempel(c, (px0 + px1) / 2, (py0 + py1) / 2, status.upper(),
RED if gefallen else AMBER)
y = max(oben, py1) + 30
def abschnitt(titel, y):
c.create_text(links, y, anchor="nw", text=titel, fill=akzent, font=FONT_DOK_FETT)
c.create_line(links, y + 20, rechts, y + 20, fill=LINE)
return y + 30
def zeilen(paare, y):
for beschriftung, inhalt in paare:
c.create_text(links, y, anchor="nw", text=beschriftung.upper(),
fill=FG_DIM, font=FONT_DOK_KLEIN)
t = c.create_text(links + 150, y, anchor="nw", text=inhalt or "—",
fill=schrift if inhalt else FG_DIM, font=FONT_DOK,
width=rechts - links - 150)
y = c.bbox(t)[3] + 6
return y + 10
def fliesstext(inhalt, y):
t = c.create_text(links, y, anchor="nw", text=inhalt or "—",
fill=schrift if inhalt else FG_DIM, font=FONT_DOK,
width=rechts - links)
return c.bbox(t)[3] + 18
y = abschnitt("I. PERSONALIEN", y)
y = zeilen([(b, wert(a, p)) for p, b in PERSONALIEN], y)
y = abschnitt("II. DIENST", y)
einheit = " · ".join(wert(a, p) for p, _ in EINHEIT if wert(a, p))
y = zeilen([(b, wert(a, p)) for p, b in DIENST] + [("Einheit", einheit)], y)
y = abschnitt("III. BESCHREIBUNG", y)
y = fliesstext(a.get("beschreibung", ""), y)
y = abschnitt("IV. AUSZEICHNUNGEN", y)
auszeichnungen = a.get("auszeichnungen", [])
if not auszeichnungen:
y = fliesstext("", y)
for e in auszeichnungen:
kopf = e.get("bezeichnung", "") + (f" ({e['datum']})" if e.get("datum") else "")
t = c.create_text(links, y, anchor="nw", text="■ " + kopf, fill=schrift,
font=FONT_DOK_FETT, width=rechts - links)
y = c.bbox(t)[3] + 2
if e.get("anlass"):
t = c.create_text(links + 18, y, anchor="nw", text=e["anlass"], fill=schrift,
font=FONT_DOK, width=rechts - links - 18)
y = c.bbox(t)[3]
y += 10
y = abschnitt("V. EINSÄTZE", y + 4)
einsaetze = a.get("einsaetze", [])
if not einsaetze:
y = fliesstext("", y)
for e in einsaetze:
kopf = " · ".join(x for x in (e.get("datum", ""), e.get("ort", "")) if x) or "Einsatz"
t = c.create_text(links, y, anchor="nw", text=kopf, fill=akzent,
font=FONT_DOK_FETT, width=rechts - links)
y = c.bbox(t)[3] + 2
if e.get("bericht"):
t = c.create_text(links, y, anchor="nw", text=e["bericht"], fill=schrift,
font=FONT_DOK, width=rechts - links)
y = c.bbox(t)[3]
y += 14
y = abschnitt("VI. VERMERKE", y + 4)
y = fliesstext(a.get("vermerke", ""), y)
karte = c.create_rectangle(rand, rand, breite - rand, y + 6, fill=PANEL, outline=LINE)
c.tag_lower(karte)
c.configure(scrollregion=(0, 0, breite, y + rand + 10))
@staticmethod
def _stempel(c, mx, my, text, farbe, winkel=18):
"""Schraeger Stempel ueber dem Portraet, mit gedrehtem Rahmen."""
t = c.create_text(mx, my, text=text, fill=farbe, angle=winkel,
font=("Consolas", 18, "bold"))
breite = len(text) * 14 + 26
hoehe = 38
rad = math.radians(winkel)
ecken = []
for dx, dy in ((-breite / 2, -hoehe / 2), (breite / 2, -hoehe / 2),
(breite / 2, hoehe / 2), (-breite / 2, hoehe / 2)):
ecken += [mx + dx * math.cos(rad) + dy * math.sin(rad),
my - dx * math.sin(rad) + dy * math.cos(rad)]
c.create_polygon(*ecken, outline=farbe, fill="", width=3)
c.tag_raise(t)