- Neuer Hauptreiter SQUAD: Anmeldung und Registrierung; angemeldet alle Charaktere mit Zustand (KIA/MIA/WIA), Suche und Fraktionsfilter, fremde Akten als Dokument, Squads gruenden und verwalten, Einladungen annehmen, ablehnen, zurueckziehen; Konto abmelden oder loeschen - Akten werden nach dem Anmelden, kurz nach jeder Aenderung und alle 5 Minuten mit dem Server abgeglichen; Zustand unter der Aktenliste - Dokumentansicht als dokument_zeichnen() fuer eigene und fremde Akten; ohne Portraet scheint "KEIN PORTRAET" nicht mehr durch den Stempel - Release-Bau: Bezeichner wie "konto_loeschen" bekommen keine Umlaute mehr - sonst waeren vier Serveraktionen im Paket kaputt gewesen - Tests koennen mit SM_PROGRAMM gegen das gebaute Paket laufen - Datenschutz-Baustein fuer tyrveil.com, Anleitung und Doku auf 1.6.0 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
914 lines
39 KiB
Python
914 lines
39 KiB
Python
"""
|
||
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 abgleich
|
||
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"
|
||
# Setzt der Squad-Reiter: Nach jeder Aenderung wird der Abgleich angestossen
|
||
self.bei_gespeichert = None
|
||
|
||
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))
|
||
self.abgleich_var = tk.StringVar(value="")
|
||
self.abgleich_zeile = ttk.Label(links, textvariable=self.abgleich_var, style="Dim.TLabel",
|
||
wraplength=236, justify="left")
|
||
self.abgleich_zeile.grid(row=3, column=0, columnspan=2, sticky="w", 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)
|
||
# Nur Auswahllisten: Teilstreitkraft und Dienstgrad haengen von der
|
||
# Fraktion ab, siehe _auswahl_anpassen
|
||
self.fraktion_box = feld(d, 0, 0, ("dienst", "fraktion"), "Fraktion", "fest",
|
||
vorlagen.fraktionsnamen())
|
||
self.tsk_box = feld(d, 0, 2, ("dienst", "teilstreitkraft"), "Teilstreitkraft", "fest")
|
||
self.rang_box = feld(d, 1, 0, ("dienst", "rang"), "Dienstgrad", "fest")
|
||
feld(d, 1, 2, ("dienst", "verwendung"), "Verwendung", "fest", vorlagen.VERWENDUNGEN)
|
||
feld(d, 2, 0, ("dienst", "dienstbeginn"), "Dienstbeginn")
|
||
feld(d, 2, 2, ("dienst", "status"), "Status", "fest", modell.STATUS)
|
||
self.pruef_var = tk.StringVar()
|
||
self.pruef_hinweis = ttk.Label(d, textvariable=self.pruef_var, foreground=AMBER,
|
||
wraplength=520, justify="left")
|
||
self.pruef_hinweis.grid(row=3, column=0, columnspan=4, sticky="w", pady=(6, 0))
|
||
self.pruef_hinweis.grid_remove()
|
||
ttk.Label(d, text="Einheit", style="Dim.TLabel").grid(
|
||
row=4, column=0, columnspan=4, sticky="w", pady=(10, 2))
|
||
for i, (pfad, beschriftung) in enumerate(EINHEIT):
|
||
feld(d, 5 + 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"])
|
||
self._gespeichert()
|
||
|
||
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()
|
||
# Vor dem Verschieben: server.json liegt im Aktenordner
|
||
abgleich.loeschen_vormerken(self.aktuell["id"])
|
||
modell.in_papierkorb(self.aktuell["id"])
|
||
self.aktuell = None
|
||
self.akten_laden()
|
||
self._gespeichert()
|
||
|
||
# -- 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._auswahl_anpassen(beim_laden=True)
|
||
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 in (("dienst", "fraktion"), ("dienst", "teilstreitkraft")):
|
||
self._auswahl_anpassen()
|
||
if pfad[0] == "dienst":
|
||
self._pruefhinweis_zeigen()
|
||
if pfad in NAMENSFELDER:
|
||
self.liste.item(self.aktuell["id"],
|
||
values=(modell.listenname(self.aktuell),
|
||
self.aktuell["aktennummer"]))
|
||
self._speichern_planen()
|
||
|
||
def _auswahl_anpassen(self, beim_laden=False):
|
||
"""
|
||
Stellt die Listen fuer Teilstreitkraft und Dienstgrad auf die Fraktion ein.
|
||
|
||
Nach einem Wechsel wird ersetzt, was nicht mehr passt: die
|
||
Teilstreitkraft durch die erste der Fraktion, der Dienstgrad durch
|
||
nichts. Beim Laden bleibt die Akte unveraendert, unpassende Werte
|
||
meldet dann der Pruefhinweis.
|
||
"""
|
||
fraktion = self.vars[("dienst", "fraktion")].get()
|
||
tsk_var = self.vars[("dienst", "teilstreitkraft")]
|
||
rang_var = self.vars[("dienst", "rang")]
|
||
teilstreitkraefte = vorlagen.teilstreitkraefte_fuer(fraktion)
|
||
self.tsk_box["values"] = teilstreitkraefte
|
||
if not beim_laden and teilstreitkraefte and tsk_var.get() not in teilstreitkraefte:
|
||
tsk_var.set(teilstreitkraefte[0]) # loest diese Methode erneut aus
|
||
raenge = vorlagen.raenge_fuer(fraktion, tsk_var.get())
|
||
self.rang_box["values"] = raenge
|
||
if not beim_laden and rang_var.get() and rang_var.get() not in raenge:
|
||
rang_var.set("")
|
||
if beim_laden:
|
||
self._pruefhinweis_zeigen()
|
||
|
||
def _pruefhinweis_zeigen(self):
|
||
hinweise = vorlagen.pruefen(self.aktuell.get("dienst", {})) if self.aktuell else []
|
||
self.pruef_var.set("\n".join("⚠ " + h + " Bitte neu wählen." for h in hinweise))
|
||
if hinweise:
|
||
self.pruef_hinweis.grid()
|
||
else:
|
||
self.pruef_hinweis.grid_remove()
|
||
|
||
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()
|
||
self._gespeichert()
|
||
|
||
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()
|
||
self._gespeichert()
|
||
|
||
# -- 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}")
|
||
return
|
||
self._gespeichert()
|
||
|
||
def _gespeichert(self):
|
||
if self.bei_gespeichert is not None:
|
||
self.bei_gespeichert()
|
||
|
||
# -- Abgleich mit dem Server ---------------------------------------------
|
||
def abgleich_zustand(self, text, art):
|
||
farben = {"ok": FG_DIM, "laeuft": FG_DIM, "aus": FG_DIM, "offline": AMBER, "fehler": RED}
|
||
self.abgleich_var.set(text)
|
||
self.abgleich_zeile.configure(foreground=farben.get(art, FG_DIM))
|
||
|
||
def nach_abgleich(self, geaendert):
|
||
"""
|
||
Der Abgleich hat lokale Akten neu geschrieben - Liste und offene Akte
|
||
neu einlesen. Ungespeicherte Eingaben gehen vor: Sie werden zuerst
|
||
gesichert und beim naechsten Abgleich hochgeladen.
|
||
"""
|
||
if not geaendert:
|
||
return
|
||
self.speichern_sofort()
|
||
auswahl = self.aktuell["id"] if self.aktuell else None
|
||
self._fotos = {k: v for k, v in self._fotos.items() if k[0] not in geaendert}
|
||
if auswahl is None or auswahl in geaendert:
|
||
self.aktuell = None
|
||
self.akten_laden(auswahl)
|
||
return
|
||
# Die offene Akte ist unveraendert: nur die Liste auffrischen, damit
|
||
# Scrollstand und Eingabefokus bleiben
|
||
offen = self.aktuell
|
||
self.akten = [offen if a["id"] == auswahl else a for a in 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 self.liste.exists(auswahl):
|
||
self.liste.selection_set(auswahl)
|
||
|
||
# -- 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
|
||
if self.aktuell is None:
|
||
self.dok.delete("all")
|
||
return
|
||
akte_id = self.aktuell["id"]
|
||
dokument_zeichnen(self.dok, self.aktuell, lambda groesse: self._foto(akte_id, groesse))
|
||
|
||
|
||
def dokument_zeichnen(c, a, foto_fuer):
|
||
"""
|
||
Zeichnet eine Akte als Dokument auf die Zeichenflaeche c.
|
||
|
||
foto_fuer((breite, hoehe)) liefert das Portraet als PhotoImage oder
|
||
None. Genutzt von der eigenen Akte und im Squad-Reiter fuer fremde
|
||
Akten, deren Portraet vom Server kommt.
|
||
"""
|
||
c.delete("all")
|
||
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 = foto_fuer((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="")
|
||
# Unter einem Stempel wuerde der Text nur durchscheinen
|
||
if dienst.get("status", "aktiv") not in ("gefallen", "vermisst"):
|
||
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"):
|
||
_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))
|
||
|
||
|
||
|
||
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)
|