Jede Fraktion bietet nur noch ihre Teilstreitkraefte an, jede Teilstreitkraft ihre Dienstgrade. Island hat nur die vier Bereiche der Kuestenwache (See, Luftfahrt, Einsatzfuehrung, Verteidigung), die Bundeswehr Heer, Luftwaffe und Marine mit eigenen Marine-Dienstgraden. Fraktion, Teilstreitkraft, Dienstgrad und Verwendung sind reine Auswahllisten. Alte Akten mit unpassenden Werten werden beim Laden nicht geaendert, sondern mit einem Hinweis markiert. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
849 lines
36 KiB
Python
849 lines
36 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 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)
|
||
# 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"])
|
||
|
||
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._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()
|
||
|
||
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)
|