Stufe 2: Akte vollstaendig (4.0)

Mehrere Akten mit Liste, Formular und Dokumentansicht, Portraet,
Statusstempel bei gefallen und vermisst, Vorschlagslisten fuer 22
Fraktionen samt Dienstgraden. Datenmodell in akte_modell.py ohne
tkinter, Vorlagen in akte_vorlagen.py. Speichern atomar mit Sicherung,
Loeschen ueber einen Papierkorb-Ordner. Neue Abhaengigkeit Pillow.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
danny 2026-09-10 18:50:18 +02:00
parent f49e9a3ed0
commit 8c0d364a8a
11 changed files with 1308 additions and 29 deletions

View file

@ -1,6 +1,6 @@
# Plan: Modul „Akte" # Plan: Modul „Akte"
Stand: 10. September 2026 · Stufe 0 und 1 umgesetzt, Stufe 2 folgt Stand: 10. September 2026 · Stufe 0 bis 2 umgesetzt, Release 4.0 nach dem Update-Test von 3.4
Eine Personalakte für den eigenen Squad-Charakter: Name, Callsign, Rang, Eine Personalakte für den eigenen Squad-Charakter: Name, Callsign, Rang,
Porträt, Nation, Teilstreitkraft, Einheit, Werdegang. Reines Rollenspiel — Porträt, Nation, Teilstreitkraft, Einheit, Werdegang. Reines Rollenspiel —
@ -81,7 +81,9 @@ riskant.
``` ```
squad_manager.py Hauptfenster, Navigation, Funk-Modul (wie bisher) squad_manager.py Hauptfenster, Navigation, Funk-Modul (wie bisher)
theme.py Farben, Schriften, apply_tactical_theme(), LevelMeter theme.py Farben, Schriften, apply_tactical_theme(), LevelMeter
akte.py Datenmodell, Speicherung, Oberfläche der Akte akte.py Oberfläche der Akte
akte_modell.py Datenmodell und Speicherung, ohne tkinter
akte_vorlagen.py Fraktionen, Dienstgrade, Verwendungen
``` ```
Flach bleibt es, weil Installer, Update-Paket und `start.pyw` heute flache Flach bleibt es, weil Installer, Update-Paket und `start.pyw` heute flache
@ -148,7 +150,7 @@ Eine Akte ist ein Ordner mit JSON-Datei und Porträt:
|---|---|---| |---|---|---|
| **0** | Fehlende Pakete werden beim Start nachinstalliert — **erledigt in 3.3** | klein | | **0** | Fehlende Pakete werden beim Start nachinstalliert — **erledigt in 3.3** | klein |
| **1** | `theme.py` auslagern, Hauptreiter *Funk* / *Akte*, Akte noch leer — **erledigt in 3.4** | mittel | | **1** | `theme.py` auslagern, Hauptreiter *Funk* / *Akte*, Akte noch leer — **erledigt in 3.4** | mittel |
| **2** | Akte vollständig: Liste, Formular, Dokumentansicht, Porträt, Vorbelegungen — Version 4.0 | groß | | **2** | Akte vollständig: Liste, Formular, Dokumentansicht, Porträt, Vorbelegungen — **umgesetzt**, Release 4.0 folgt | groß |
| **3** | Teilen: Akte als PNG-Karte für Discord, Export/Import als `.akte`-Datei | mittel | | **3** | Teilen: Akte als PNG-Karte für Discord, Export/Import als `.akte`-Datei | mittel |
Jede Stufe endet mit einem Release über den Updater. Stufe 1 ist bewusst Jede Stufe endet mit einem Release über den Updater. Stufe 1 ist bewusst

View file

@ -1,6 +1,6 @@
# Projektübergabe: Squad Manager # Projektübergabe: Squad Manager
Stand: 10. September 2026 · Version 3.4 · Git-Repository im Quellordner Stand: 10. September 2026 · Version 4.0 (Akte) · Git-Repository im Quellordner
Seit 3.2 wird über einen Inno-Setup-Installer und einen eingebauten Seit 3.2 wird über einen Inno-Setup-Installer und einen eingebauten
Auto-Updater verteilt (Server: https://sva.tyrveil.com), siehe Abschnitt 4. Auto-Updater verteilt (Server: https://sva.tyrveil.com), siehe Abschnitt 4.
@ -46,7 +46,9 @@ Arbeitsverzeichnis. Hier wird entwickelt. Der Code enthält hier
``` ```
squad_manager.py Hauptfenster, Funk-Modul, Updater (~1500 Zeilen) squad_manager.py Hauptfenster, Funk-Modul, Updater (~1500 Zeilen)
theme.py Farben, Schriften, ttk-Stil, Pegelanzeige theme.py Farben, Schriften, ttk-Stil, Pegelanzeige
akte.py Modul Akte (seit 3.4, noch Platzhalter) akte.py Akte: Oberfläche (Liste, Formular, Dokumentansicht)
akte_modell.py Akte: Datenmodell und Speicherung, ohne tkinter
akte_vorlagen.py Akte: Fraktionen, Dienstgrade, Verwendungen
start.pyw Startskript ohne Konsolenfenster start.pyw Startskript ohne Konsolenfenster
make_icon.py erzeugt icon.ico aus icon.png make_icon.py erzeugt icon.ico aus icon.png
icon.png / icon.ico Programmsymbol (vom Nutzer geliefert) icon.png / icon.ico Programmsymbol (vom Nutzer geliefert)
@ -103,9 +105,11 @@ frisch.
## 3. Aufbau des Programms ## 3. Aufbau des Programms
Drei Dateien, `tkinter`/`ttk`: `squad_manager.py` mit Hauptfenster, `tkinter`/`ttk`, fünf flache Dateien: `squad_manager.py` mit Hauptfenster,
Funk-Modul und Updater (Hauptklasse `VoiceActivationApp`), `theme.py` mit Funk-Modul und Updater (Hauptklasse `VoiceActivationApp`), `theme.py` mit
dem Stil und `akte.py` mit dem Modul Akte. `theme.py` gibt es, damit dem Stil, und das Modul Akte in drei Teilen — `akte.py` (Oberfläche),
`akte_modell.py` (Datenmodell und Speicherung, bewusst ohne tkinter und
damit ohne Fenster testbar) und `akte_vorlagen.py` (Vorschlagslisten). `theme.py` gibt es, damit
`akte.py` die Farben nicht aus `squad_manager.py` holen muss — das wäre `akte.py` die Farben nicht aus `squad_manager.py` holen muss — das wäre
ein zirkulärer Import, weil `squad_manager.py` die Akte einbindet. ein zirkulärer Import, weil `squad_manager.py` die Akte einbindet.
Weitere Module gehören ebenfalls flach daneben: Installer, Update-Paket Weitere Module gehören ebenfalls flach daneben: Installer, Update-Paket
@ -145,6 +149,17 @@ HORCHT / SENDET / GESPERRT) — die Sprachaktivierung läuft weiter, während
man in einem anderen Modul arbeitet. Der zuletzt gewählte Hauptreiter man in einem anderen Modul arbeitet. Der zuletzt gewählte Hauptreiter
steht als `modul` in der `config.json`. steht als `modul` in der `config.json`.
**Akte:** Ablage je Akte unter `%APPDATA%\SquadManager\akten\<id>\` als
`akte.json`, dazu `portraet.png` (auf höchstens 512 px verkleinerte
Kopie). Geschrieben wird atomar über eine `.tmp`-Datei, die vorige Fassung
bleibt als `.bak`; ist `akte.json` beim Lesen defekt, wird die Sicherung
genommen. Löschen heißt Verschieben nach `akten\_papierkorb\`.
Aktennummern `SM-<Jahr>-<n>`, der Papierkorb zählt mit, damit keine Nummer
doppelt vergeben wird. Das Feld `schema` erlaubt spätere Formatänderungen;
`migrieren()` ergänzt fehlende Felder und lässt unbekannte stehen. Offene
Änderungen werden 800 ms nach der letzten Eingabe gespeichert, außerdem beim
Schließen und vor einem Update.
--- ---
## 4. Release bauen, Installer und Updater ## 4. Release bauen, Installer und Updater
@ -309,6 +324,19 @@ Für Tests eine Kopie von `setup.iss` mit eigener `AppId` übersetzen
Auch stille Deinstallationen können Dialoge öffnen, wenn `[Code]` ein Auch stille Deinstallationen können Dialoge öffnen, wenn `[Code]` ein
normales `MsgBox` verwendet — dort immer `SuppressibleMsgBox`. normales `MsgBox` verwendet — dort immer `SuppressibleMsgBox`.
**17 — Neue Module an zwei Stellen eintragen.**
In `werkzeuge/baue_release.py` unter `PYTHON_DATEIEN`, sonst fehlen sie im
Paket, und in `start.pyw` unter `EIGENE_MODULE`. Fehlt der zweite Eintrag,
hält `start.pyw` einen Importfehler in einem eigenen Modul für ein
fehlendes Paket und versucht es per pip nachzuinstallieren.
**18 — ttk-Stile erben die Zustandsregeln des Themas.**
Ein eigener Stil wie `Haupt.TNotebook.Tab` übernimmt die `map`-Regeln von
`TNotebook.Tab`, bei *clam* auch einen eigenen Innenabstand für den
gewählten Reiter. Die Schrift sprang dadurch beim Umschalten um 4 Pixel.
Jede Zustandsregel, die man nicht will, im eigenen Stil ausdrücklich
überschreiben — und die Wirkung nachmessen, nicht nur ansehen.
--- ---
## 6. Umgebung ## 6. Umgebung
@ -340,6 +368,12 @@ Nach dem Upload von 3.3 die alten Dateien vom Server nehmen, damit niemand
mehr mit 3.2 anfängt. Den ersten echten Updater-Durchlauf liefert dann mehr mit 3.2 anfängt. Den ersten echten Updater-Durchlauf liefert dann
3.3 → 3.4. 3.3 → 3.4.
**4.0 wartet auf diesen Test.** Die Akte ist gebaut, `dist/server/` enthält
schon 4.0. Die Serverdateien von 3.4 für den Test liegen getrennt in
`dist/server-3.4/` — nicht mischen: `version.json` und Zip gehören über die
Prüfsumme zusammen. Erst wenn 3.3 → 3.4 sauber läuft, 4.0 hochladen; das
prüft zugleich die Nachinstallation von Pillow über `start.pyw`.
**Vorfall 10. September:** Ein Installer-Test mit der *echten* App-ID **Vorfall 10. September:** Ein Installer-Test mit der *echten* App-ID
hatte den Eintrag der Nutzerinstallation unter *Apps und Features* hatte den Eintrag der Nutzerinstallation unter *Apps und Features*
übernommen. Bereinigt; seitdem gilt Erkenntnis 16. übernommen. Bereinigt; seitdem gilt Erkenntnis 16.

View file

@ -13,11 +13,13 @@ Technische Dokumentation und alle bekannten Fallstricke:
|---|---| |---|---|
| `squad_manager.py` | Hauptfenster, Funk-Modul, Updater | | `squad_manager.py` | Hauptfenster, Funk-Modul, Updater |
| `theme.py` | Farben, Schriften, Stil, Pegelanzeige | | `theme.py` | Farben, Schriften, Stil, Pegelanzeige |
| `akte.py` | Modul Akte (in Arbeit, siehe `PLAN-AKTE.md`) | | `akte.py` | Modul Akte: Oberfläche |
| `akte_modell.py` | Modul Akte: Datenmodell und Speicherung |
| `akte_vorlagen.py` | Modul Akte: Fraktionen, Dienstgrade, Verwendungen |
| `start.pyw` | Startskript ohne Konsolenfenster | | `start.pyw` | Startskript ohne Konsolenfenster |
| `make_icon.py` | erzeugt `icon.ico` aus `icon.png` | | `make_icon.py` | erzeugt `icon.ico` aus `icon.png` |
| `icon.png`, `icon.ico` | Programmsymbol | | `icon.png`, `icon.ico` | Programmsymbol |
| `requirements.txt` | numpy, sounddevice | | `requirements.txt` | numpy, sounddevice, Pillow |
| `installer/` | Inno-Setup-Skript, Einrichtung nach der Installation, Server-Anleitung | | `installer/` | Inno-Setup-Skript, Einrichtung nach der Installation, Server-Anleitung |
| `werkzeuge/` | Release-Bau und Testhilfen | | `werkzeuge/` | Release-Bau und Testhilfen |
| `Design-Briefing.md` | Auftrag für die Gestaltung | | `Design-Briefing.md` | Auftrag für die Gestaltung |

755
akte.py
View file

@ -1,14 +1,158 @@
""" """
Modul Akte: Personalakten fuer Rollenspiel-Charaktere. Modul Akte: Personalakten fuer Rollenspiel-Charaktere.
Stufe 1 (Version 3.4) schafft nur den Platz in der Oberflaeche. Datenmodell, Links die Liste der eigenen Akten, rechts die gewaehlte Akte - wahlweise
Speicherung und Dokumentansicht folgen in Stufe 2, siehe PLAN-AKTE.md. 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 import tkinter as tk
from tkinter import ttk from tkinter import ttk, filedialog, messagebox
from theme import BG, AMBER from PIL import Image, ImageOps, ImageTk
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): class AkteSeite(ttk.Frame):
@ -16,20 +160,603 @@ class AkteSeite(ttk.Frame):
def __init__(self, master): def __init__(self, master):
super().__init__(master) super().__init__(master)
mitte = ttk.Frame(self) self.akten = []
mitte.place(relx=0.5, rely=0.42, anchor="center") self.aktuell = None
self._geaendert_flag = False
self._speicher_job = None
self._zeichen_job = None
self._laedt = False
self._fotos = {}
self.modus = "ansicht"
stempel = tk.Canvas(mitte, width=300, height=86, bg=BG, self._aufbau()
highlightthickness=0) self.bind_all("<MouseWheel>", self._mausrad, add="+")
stempel.pack(pady=(0, 20)) 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.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(8, 8, 292, 78, outline=AMBER, width=3)
stempel.create_rectangle(15, 15, 285, 71, outline=AMBER, width=1) stempel.create_rectangle(15, 15, 285, 71, outline=AMBER, width=1)
stempel.create_text(150, 43, text="PERSONALAKTE", fill=AMBER, stempel.create_text(150, 43, text="PERSONALAKTE", fill=AMBER,
font=("Consolas", 20, "bold")) font=("Consolas", 20, "bold"))
ttk.Label(mitte, text="Noch keine Akte angelegt",
ttk.Label(mitte, text="In Vorbereitung",
font=("Segoe UI Semibold", 12)).pack() font=("Segoe UI Semibold", 12)).pack()
ttk.Label(mitte, style="Dim.TLabel", justify="center", ttk.Label(mitte, style="Dim.TLabel", justify="center",
text="Hier entsteht die Personalakte für deine Charaktere:\n" text="Lege eine Akte für deinen Charakter an: Porträt,\n"
"Porträt, Dienstgrad, Einheit, Auszeichnungen und " "Dienstgrad, Einheit, Auszeichnungen und Werdegang.").pack(pady=(6, 14))
"Werdegang.").pack(pady=(6, 0)) 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()
# -- 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)

234
akte_modell.py Normal file
View file

@ -0,0 +1,234 @@
"""
Datenmodell und Speicherung der Personalakten.
Bewusst ohne tkinter: Laden, Speichern und spaetere Umbauten des Formats
lassen sich so ohne Oberflaeche pruefen.
Ablage je Akte:
%APPDATA%\\SquadManager\\akten\\<id>\\akte.json
%APPDATA%\\SquadManager\\akten\\<id>\\portraet.png
Geschrieben wird atomar - erst in eine Zwischendatei, dann umbenennen -
und die vorherige Fassung bleibt als akte.json.bak liegen. Ein Absturz
mitten im Speichern kann eine Akte damit nicht zerstoeren.
"""
import copy
import datetime
import json
import os
import re
import shutil
import uuid
from pathlib import Path
SCHEMA = 1
AKTEN_ORDNER = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "akten"
PAPIERKORB = AKTEN_ORDNER / "_papierkorb"
DATEI = "akte.json"
PORTRAET = "portraet.png"
PORTRAET_MAX = 512
STATUS = ("aktiv", "verwundet", "vermisst", "gefallen", "außer Dienst")
_VORLAGE = {
"schema": SCHEMA,
"id": "",
"aktennummer": "",
"erstellt": "",
"geaendert": "",
"personalien": {
"vorname": "", "nachname": "", "callsign": "",
"geburtsdatum": "", "herkunft": "",
},
"dienst": {
"fraktion": "", "teilstreitkraft": "",
"einheit": {"verband": "", "bataillon": "", "kompanie": "",
"zug": "", "gruppe": ""},
"rang": "", "verwendung": "", "dienstbeginn": "", "status": "aktiv",
},
"beschreibung": "",
"auszeichnungen": [],
"einsaetze": [],
"vermerke": "",
}
class AktenFehler(Exception):
"""Fehler, die sich dem Nutzer verstaendlich melden lassen."""
def zeitstempel():
return datetime.datetime.now().isoformat(timespec="seconds")
def leere_akte():
akte = copy.deepcopy(_VORLAGE)
akte["id"] = uuid.uuid4().hex
akte["erstellt"] = akte["geaendert"] = zeitstempel()
return akte
def _ergaenzen(daten, vorlage):
"""Fehlende Felder aus der Vorlage nachtragen, vorhandene nie ueberschreiben."""
for schluessel, standard in vorlage.items():
if schluessel not in daten:
daten[schluessel] = copy.deepcopy(standard)
elif isinstance(standard, dict) and isinstance(daten[schluessel], dict):
_ergaenzen(daten[schluessel], standard)
return daten
def migrieren(daten):
"""
Bringt eine gelesene Akte auf den aktuellen Stand.
Bei neuen Schema-Versionen kommen die Umbauschritte hierher. Unbekannte
Felder bleiben erhalten, damit eine aeltere Programmfassung Daten einer
neueren nicht stillschweigend verliert.
"""
if not isinstance(daten, dict):
raise AktenFehler("Die Datei enthaelt keine Akte.")
return _ergaenzen(daten, _VORLAGE)
def ordner_von(akte_id):
if not re.fullmatch(r"[0-9a-f]{32}", str(akte_id)):
raise AktenFehler(f"Ungueltige Akten-ID: {akte_id!r}")
return AKTEN_ORDNER / akte_id
def _alle_nummern():
nummern = []
for datei in list(AKTEN_ORDNER.glob(f"*/{DATEI}")) + list(PAPIERKORB.glob(f"*/{DATEI}")):
try:
nummern.append(json.loads(datei.read_text(encoding="utf-8")).get("aktennummer", ""))
except Exception:
continue
return nummern
def naechste_aktennummer(jahr=None):
"""SM-<Jahr>-<laufende Nummer>; auch Akten im Papierkorb zaehlen mit."""
jahr = jahr or datetime.date.today().year
hoechste = 0
for nummer in _alle_nummern():
treffer = re.fullmatch(rf"SM-{jahr}-(\d+)", str(nummer))
if treffer:
hoechste = max(hoechste, int(treffer.group(1)))
return f"SM-{jahr}-{hoechste + 1:04d}"
def speichern(akte):
"""Schreibt die Akte atomar und haelt die vorige Fassung als .bak."""
akte["geaendert"] = zeitstempel()
ordner = ordner_von(akte["id"])
ordner.mkdir(parents=True, exist_ok=True)
ziel = ordner / DATEI
zwischen = ordner / (DATEI + ".tmp")
zwischen.write_text(json.dumps(akte, indent=2, ensure_ascii=False),
encoding="utf-8")
if ziel.exists():
shutil.copy2(ziel, ordner / (DATEI + ".bak"))
os.replace(zwischen, ziel)
return akte
def neu_anlegen():
akte = leere_akte()
akte["aktennummer"] = naechste_aktennummer()
return speichern(akte)
def laden(akte_id):
"""Liest eine Akte; ist die Datei beschaedigt, wird die Sicherung versucht."""
ordner = ordner_von(akte_id)
for datei in (ordner / DATEI, ordner / (DATEI + ".bak")):
if not datei.exists():
continue
try:
return migrieren(json.loads(datei.read_text(encoding="utf-8")))
except (ValueError, AktenFehler):
continue
raise AktenFehler(f"Akte {akte_id} ist nicht lesbar.")
def alle_akten():
"""Alle lesbaren Akten, nach Aktennummer sortiert. Defekte werden uebersprungen."""
if not AKTEN_ORDNER.is_dir():
return []
akten = []
for ordner in AKTEN_ORDNER.iterdir():
if not ordner.is_dir() or ordner.name.startswith("_"):
continue
try:
akten.append(laden(ordner.name))
except AktenFehler:
continue
return sorted(akten, key=lambda a: a.get("aktennummer", ""))
def in_papierkorb(akte_id):
"""Verschiebt statt zu loeschen - Wiederherstellen bleibt moeglich."""
quelle = ordner_von(akte_id)
if not quelle.is_dir():
return None
PAPIERKORB.mkdir(parents=True, exist_ok=True)
ziel = PAPIERKORB / f"{akte_id}_{datetime.datetime.now():%Y%m%d-%H%M%S}"
shutil.move(str(quelle), str(ziel))
return ziel
def portraet_pfad(akte_id):
pfad = ordner_von(akte_id) / PORTRAET
return pfad if pfad.is_file() else None
def portraet_setzen(akte_id, quelle):
"""
Uebernimmt ein Bild als Portraet: Kopie, hoechstens 512 Bildpunkte je
Seite, als PNG. Die Akte haengt danach nicht mehr am Original.
"""
from PIL import Image, ImageOps, UnidentifiedImageError
try:
with Image.open(quelle) as bild:
bild = ImageOps.exif_transpose(bild)
bild = bild.convert("RGBA" if bild.mode in ("RGBA", "LA", "P") else "RGB")
bild.thumbnail((PORTRAET_MAX, PORTRAET_MAX))
ordner = ordner_von(akte_id)
ordner.mkdir(parents=True, exist_ok=True)
zwischen = ordner / (PORTRAET + ".tmp")
bild.save(zwischen, "PNG")
os.replace(zwischen, ordner / PORTRAET)
except (UnidentifiedImageError, OSError) as fehler:
raise AktenFehler(f"Das Bild konnte nicht gelesen werden:\n{fehler}") from fehler
return ordner_von(akte_id) / PORTRAET
def portraet_entfernen(akte_id):
pfad = portraet_pfad(akte_id)
if pfad:
pfad.unlink()
def anzeigename(akte):
"""Kurzname fuer Listen: Rang, Name und Callsign, soweit vorhanden."""
p, d = akte.get("personalien", {}), akte.get("dienst", {})
name = " ".join(t for t in (p.get("vorname", ""), p.get("nachname", "")) if t)
teile = [t for t in (d.get("rang", ""), name) if t]
text = " ".join(teile)
if p.get("callsign"):
text = f'{text} „{p["callsign"]}“' if text else f'„{p["callsign"]}“'
return text or "Neue Akte"
def listenname(akte):
"""Knapper Name fuer die schmale Aktenliste: Callsign vor Nachname."""
p = akte.get("personalien", {})
vorname, nachname = p.get("vorname", ""), p.get("nachname", "")
name = f"{nachname}, {vorname}" if nachname and vorname else nachname or vorname
if p.get("callsign"):
return f'{p["callsign"]} · {nachname or vorname}' if name else p["callsign"]
return name or "Neue Akte"

229
akte_vorlagen.py Normal file
View file

@ -0,0 +1,229 @@
"""
Vorschlagslisten fuer die Akte: Fraktionen, Dienstgrade, Verwendungen.
Nur Vorschlaege - jedes Feld nimmt auch Freitext an. Dienstgrade jeweils vom
niedrigsten zum hoechsten. Fremdsprachige Ranggruppen in gaengiger
Umschrift, bei nicht-lateinischen Sprachen mit englischer Entsprechung in
Klammern.
Quellen (Stand September 2026): Wikipedia-Artikel der jeweiligen
Streitkraefte, fuer Italien "Gradi e qualifiche dell'Esercito Italiano".
Bei den Squad-Fraktionen widersprechen sich die Quellen; aufgenommen ist die
Vereinigungsmenge, auch Fraktionen, deren aktueller Status unklar ist
(Middle Eastern Alliance, Canadian Resistance Forces).
"""
TEILSTREITKRAEFTE = [
"Heer", "Marine", "Luftwaffe", "Marineinfanterie", "Luftlandetruppe",
"Spezialkräfte", "Küstenwache", "Miliz", "Private Sicherheitsfirma",
]
VERWENDUNGEN = [
"Squad Leader", "Fireteam Leader", "Rifleman", "Medic",
"Automatic Rifleman", "Machine Gunner", "Grenadier", "Marksman", "Sniper",
"Light Anti-Tank (LAT)", "Heavy Anti-Tank (HAT)", "Combat Engineer",
"Sapper", "Crewman", "Pilot", "Scout", "Raider", "Ambusher", "Funker",
]
_INFORMELL = [
"Kämpfer", "Veteran", "Truppführer", "Gruppenführer", "Zellenführer",
"Stellvertretender Kommandeur", "Kommandeur",
]
_RUSSLAND = [
"Ryadovoy (Private)", "Yefreytor (Lance Corporal)",
"Mladshiy serzhant (Junior Sergeant)", "Serzhant (Sergeant)",
"Starshiy serzhant (Senior Sergeant)", "Starshina (Sergeant Major)",
"Praporshchik (Warrant Officer)", "Starshiy praporshchik (Senior Warrant Officer)",
"Mladshiy leytenant (Junior Lieutenant)", "Leytenant (Lieutenant)",
"Starshiy leytenant (Senior Lieutenant)", "Kapitan (Captain)", "Mayor (Major)",
"Podpolkovnik (Lieutenant Colonel)", "Polkovnik (Colonel)",
"General-mayor (Major General)", "General-leytenant (Lieutenant General)",
"General-polkovnik (Colonel General)", "General armii (General of the Army)",
]
_CHINA = [
"Liebing (Private)", "Shangdengbing (Private First Class)",
"Xiashi (Corporal)", "Zhongshi (Sergeant)", "Shangshi (Staff Sergeant)",
"Siji junshizhang (Master Sergeant 4th Class)",
"Sanji junshizhang (Master Sergeant 3rd Class)",
"Erji junshizhang (Master Sergeant 2nd Class)",
"Yiji junshizhang (Master Sergeant 1st Class)",
"Shaowei (Second Lieutenant)", "Zhongwei (First Lieutenant)",
"Shangwei (Captain)", "Shaoxiao (Major)", "Zhongxiao (Lieutenant Colonel)",
"Shangxiao (Colonel)", "Daxiao (Senior Colonel)",
"Shaojiang (Major General)", "Zhongjiang (Lieutenant General)",
"Shangjiang (General)",
]
FRAKTIONEN = {
# --- Squad: BLUFOR ---------------------------------------------------
"US Army": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Private (PV1)", "Private (PV2)", "Private First Class (PFC)",
"Specialist (SPC)", "Corporal (CPL)", "Sergeant (SGT)",
"Staff Sergeant (SSG)", "Sergeant First Class (SFC)",
"Master Sergeant (MSG)", "First Sergeant (1SG)", "Sergeant Major (SGM)",
"Command Sergeant Major (CSM)", "Warrant Officer 1 (WO1)",
"Chief Warrant Officer 2 (CW2)", "Chief Warrant Officer 3 (CW3)",
"Chief Warrant Officer 4 (CW4)", "Chief Warrant Officer 5 (CW5)",
"Second Lieutenant (2LT)", "First Lieutenant (1LT)", "Captain (CPT)",
"Major (MAJ)", "Lieutenant Colonel (LTC)", "Colonel (COL)",
"Brigadier General (BG)", "Major General (MG)",
"Lieutenant General (LTG)", "General (GEN)"]},
"US Marine Corps": {"gruppe": "Squad", "teilstreitkraft": "Marineinfanterie", "raenge": [
"Private (Pvt)", "Private First Class (PFC)", "Lance Corporal (LCpl)",
"Corporal (Cpl)", "Sergeant (Sgt)", "Staff Sergeant (SSgt)",
"Gunnery Sergeant (GySgt)", "Master Sergeant (MSgt)",
"First Sergeant (1stSgt)", "Master Gunnery Sergeant (MGySgt)",
"Sergeant Major (SgtMaj)", "Warrant Officer (WO)",
"Chief Warrant Officer 2 (CWO2)", "Chief Warrant Officer 3 (CWO3)",
"Chief Warrant Officer 4 (CWO4)", "Chief Warrant Officer 5 (CWO5)",
"Second Lieutenant (2ndLt)", "First Lieutenant (1stLt)",
"Captain (Capt)", "Major (Maj)", "Lieutenant Colonel (LtCol)",
"Colonel (Col)", "Brigadier General (BGen)", "Major General (MajGen)",
"Lieutenant General (LtGen)", "General (Gen)"]},
"British Army": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Private (Pte)", "Lance Corporal (LCpl)", "Corporal (Cpl)",
"Sergeant (Sgt)", "Staff Sergeant (SSgt)", "Colour Sergeant (CSgt)",
"Warrant Officer Class 2 (WO2)", "Warrant Officer Class 1 (WO1)",
"Officer Cadet (OCdt)", "Second Lieutenant (2Lt)", "Lieutenant (Lt)",
"Captain (Capt)", "Major (Maj)", "Lieutenant Colonel (Lt Col)",
"Colonel (Col)", "Brigadier (Brig)", "Major General (Maj Gen)",
"Lieutenant General (Lt Gen)", "General (Gen)"]},
"Canadian Army": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Private (Pte)", "Corporal (Cpl)", "Master Corporal (MCpl)",
"Sergeant (Sgt)", "Warrant Officer (WO)",
"Master Warrant Officer (MWO)", "Chief Warrant Officer (CWO)",
"Officer Cadet (OCdt)", "Second Lieutenant (2Lt)", "Lieutenant (Lt)",
"Captain (Capt)", "Major (Maj)", "Lieutenant-Colonel (LCol)",
"Colonel (Col)", "Brigadier-General (BGen)", "Major-General (MGen)",
"Lieutenant-General (LGen)", "General (Gen)"]},
"Australian Army": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Private (PTE)", "Lance Corporal (LCPL)", "Corporal (CPL)",
"Sergeant (SGT)", "Staff Sergeant (SSGT)",
"Warrant Officer Class 2 (WO2)", "Warrant Officer Class 1 (WO1)",
"Officer Cadet (OCDT)", "Second Lieutenant (2LT)", "Lieutenant (LT)",
"Captain (CAPT)", "Major (MAJ)", "Lieutenant Colonel (LTCOL)",
"Colonel (COL)", "Brigadier (BRIG)", "Major General (MAJGEN)",
"Lieutenant General (LTGEN)", "General (GEN)"]},
"Armed Forces of Ukraine": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Soldat (Private)", "Starshyi soldat (Senior Soldier)",
"Molodshyi serzhant (Junior Sergeant)", "Serzhant (Sergeant)",
"Starshyi serzhant (Senior Sergeant)", "Holovnyi serzhant (Chief Sergeant)",
"Shtab-serzhant (Staff Sergeant)", "Maister-serzhant (Master Sergeant)",
"Starshyi maister-serzhant (Senior Master Sergeant)",
"Holovnyi maister-serzhant (Chief Master Sergeant)",
"Molodshyi leitenant (Junior Lieutenant)", "Leitenant (Lieutenant)",
"Starshyi leitenant (Senior Lieutenant)", "Kapitan (Captain)",
"Maior (Major)", "Pidpolkovnyk (Lieutenant Colonel)",
"Polkovnyk (Colonel)", "Bryhadnyi heneral (Brigadier General)",
"Heneral-maior (Major General)", "Heneral-leitenant (Lieutenant General)",
"Heneral (General)"]},
# --- Squad: REDFOR ---------------------------------------------------
"Russian Ground Forces": {"gruppe": "Squad", "teilstreitkraft": "Heer",
"raenge": _RUSSLAND},
"Russian Airborne Forces (VDV)": {"gruppe": "Squad", "teilstreitkraft": "Luftlandetruppe",
"raenge": _RUSSLAND},
"People's Liberation Army": {"gruppe": "Squad", "teilstreitkraft": "Heer",
"raenge": _CHINA},
"PLA Navy Marine Corps": {"gruppe": "Squad", "teilstreitkraft": "Marineinfanterie",
"raenge": _CHINA},
# --- Squad: INDFOR ---------------------------------------------------
"Insurgents": {"gruppe": "Squad", "teilstreitkraft": "Miliz", "raenge": _INFORMELL},
"Irregular Militia": {"gruppe": "Squad", "teilstreitkraft": "Miliz", "raenge": _INFORMELL},
"Ground Forces of Iran": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Sarbaz dovvom (Private 2nd Class)", "Sarbaz yekom (Private 1st Class)",
"Sarjukheh (Corporal)", "Gorouhban sevvom (Sergeant 3rd Class)",
"Gorouhban dovvom (Sergeant 2nd Class)", "Gorouhban yekom (Sergeant 1st Class)",
"Ostovar dovvom (Warrant Officer 2nd Class)",
"Ostovar yekom (Warrant Officer 1st Class)",
"Setvan sevvom (Third Lieutenant)", "Setvan dovvom (Second Lieutenant)",
"Setvan yekom (First Lieutenant)", "Sarvan (Captain)", "Sargord (Major)",
"Sarhang dovvom (Lieutenant Colonel)", "Sarhang (Colonel)",
"Sartip dovvom (Second Brigadier General)", "Sartip (Brigadier General)",
"Sarlashkar (Major General)", "Sepahbod (Lieutenant General)",
"Arteshbod (General)"]},
"Turkish Land Forces": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Er", "Onbaşı", "Çavuş", "Uzman Çavuş", "Astsubay Çavuş",
"Astsubay Kıdemli Çavuş", "Astsubay Üstçavuş",
"Astsubay Kıdemli Üstçavuş", "Astsubay Başçavuş",
"Astsubay Kıdemli Başçavuş", "Asteğmen", "Teğmen", "Üsteğmen",
"Yüzbaşı", "Binbaşı", "Yarbay", "Albay", "Tuğgeneral", "Tümgeneral",
"Korgeneral", "Orgeneral"]},
"Private Military Contractor": {"gruppe": "Squad",
"teilstreitkraft": "Private Sicherheitsfirma", "raenge": [
"Contractor", "Senior Contractor", "Deputy Team Leader", "Team Leader",
"Shift Leader", "Operations Manager", "Country Manager"]},
"Middle Eastern Alliance": {"gruppe": "Squad", "teilstreitkraft": "Heer", "raenge": [
"Jundi (Private)", "Jundi awwal (Private First Class)", "Areef (Corporal)",
"Raqib (Sergeant)", "Raqib awwal (Staff Sergeant)",
"Musa'id (Warrant Officer)", "Musa'id awwal (Chief Warrant Officer)",
"Mulazim (Second Lieutenant)", "Mulazim awwal (First Lieutenant)",
"Naqib (Captain)", "Ra'id (Major)", "Muqaddam (Lieutenant Colonel)",
"Aqid (Colonel)", "Amid (Brigadier General)", "Liwa (Major General)",
"Fariq (Lieutenant General)", "Fariq awwal (General)"]},
"Canadian Resistance Forces": {"gruppe": "Squad", "teilstreitkraft": "Miliz",
"raenge": _INFORMELL},
# --- Weitere Armeen ---------------------------------------------------
"Bundeswehr": {"gruppe": "Weitere", "teilstreitkraft": "Heer", "raenge": [
"Soldat / Schütze", "Gefreiter", "Obergefreiter", "Hauptgefreiter",
"Stabsgefreiter", "Oberstabsgefreiter", "Korporal", "Stabskorporal",
"Unteroffizier", "Fahnenjunker", "Stabsunteroffizier", "Feldwebel",
"Fähnrich", "Oberfeldwebel", "Hauptfeldwebel", "Oberfähnrich",
"Stabsfeldwebel", "Oberstabsfeldwebel", "Leutnant", "Oberleutnant",
"Hauptmann", "Stabshauptmann", "Major", "Oberstleutnant", "Oberst",
"Brigadegeneral", "Generalmajor", "Generalleutnant", "General"]},
"Frankreich – Armée de Terre": {"gruppe": "Weitere", "teilstreitkraft": "Heer", "raenge": [
"Soldat de 2e classe", "Soldat de 1re classe", "Caporal", "Caporal-chef",
"Caporal-chef de 1re classe", "Sergent", "Sergent-chef", "Adjudant",
"Adjudant-chef", "Major", "Aspirant", "Sous-lieutenant", "Lieutenant",
"Capitaine", "Commandant", "Lieutenant-colonel", "Colonel",
"Général de brigade", "Général de division", "Général de corps d'armée",
"Général d'armée"]},
"Spanien – Ejército de Tierra": {"gruppe": "Weitere", "teilstreitkraft": "Heer", "raenge": [
"Soldado", "Cabo", "Cabo primero", "Cabo mayor", "Sargento",
"Sargento primero", "Brigada", "Subteniente", "Suboficial mayor",
"Alférez", "Teniente", "Capitán", "Comandante", "Teniente coronel",
"Coronel", "General de brigada", "General de división",
"Teniente general", "General de ejército"]},
"Italien – Esercito Italiano": {"gruppe": "Weitere", "teilstreitkraft": "Heer", "raenge": [
"Soldato", "Caporale", "Caporal maggiore", "Graduato", "Graduato scelto",
"Graduato capo", "Primo graduato", "Graduato aiutante", "Sergente",
"Sergente maggiore", "Sergente maggiore capo", "Sergente maggiore aiutante",
"Maresciallo", "Maresciallo ordinario", "Maresciallo capo",
"Primo maresciallo", "Luogotenente", "Primo luogotenente",
"Sottotenente", "Tenente", "Capitano", "Maggiore", "Tenente colonnello",
"Colonnello", "Generale di brigata", "Generale di divisione",
"Generale di corpo d'armata", "Generale"]},
# Island hat keine Armee. Die Kuestenwache (Landhelgisgaeslan) fuehrt
# keine klassischen Dienstgrade, sondern Funktions- und Besoldungs-
# bezeichnungen (Wikipedia, "Icelandic Coast Guard"). Deutsch in Klammern
# ist die woertliche Uebersetzung.
"Island – Küstenwache": {"gruppe": "Weitere", "teilstreitkraft": "Küstenwache", "raenge": [
"Undirmaður AS-1 (Mannschaft, Einstieg)", "Undirmaður AS-2 (Mannschaft)",
"Undirmaður AS-3 (Mannschaft)", "Undirmaður AS-4 (Mannschaft)",
"Millistjórnandi MS-1 (Führungskraft / Spezialist)",
"Millistjórnandi MS-2 (Führungskraft / Spezialist)",
"Millistjórnandi MS-3 (Führungskraft / Spezialist)",
"Byrjandi í yfirmannastöðu (Offizier, Einstieg)", "Yfirmaður (Offizier)",
"Stýrimaður (Steuermann)", "Vélstjóri (Maschinist)", "Flugmaður (Pilot)",
"Yfirstýrimaður (Erster Steuermann)", "Yfirvélstjóri (Leitender Maschinist)",
"Næstráðandi (Stellvertreter)", "Skipherra (Kommandant)",
"Flugstjóri (Flugkapitän)", "Deildarstjóri (Abteilungsleiter)",
"Flaggskipherra (Flaggkommandant)", "Yfirflugstjóri (Chefpilot)",
"Tæknistjóri (Technischer Leiter)", "Flugrekstrarstjóri (Leiter Flugbetrieb)",
"Framkvæmdastjóri (Bereichsleiter)",
"Forstjóri Landhelgisgæslunnar (Direktor)"]},
}
def fraktionsnamen():
return list(FRAKTIONEN)
def raenge_fuer(fraktion):
return list(FRAKTIONEN.get(fraktion, {}).get("raenge", []))
def standard_teilstreitkraft(fraktion):
return FRAKTIONEN.get(fraktion, {}).get("teilstreitkraft", "")

View file

@ -1,2 +1,3 @@
numpy>=1.26 numpy>=1.26
sounddevice>=0.4.6 sounddevice>=0.4.6
Pillow>=10.4

View file

@ -59,7 +59,7 @@ from theme import ( # noqa: E402
import akte # noqa: E402 import akte # noqa: E402
APP_NAME = "Squad Manager" APP_NAME = "Squad Manager"
VERSION = "3.4" VERSION = "4.0"
CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json" CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json"
LOG_PATH = CONFIG_PATH.parent / "error.log" LOG_PATH = CONFIG_PATH.parent / "error.log"
# Bis Version 3.2 hiess das Programm "Squad Voice Activation" # Bis Version 3.2 hiess das Programm "Squad Voice Activation"
@ -688,8 +688,8 @@ class VoiceActivationApp:
def __init__(self, root): def __init__(self, root):
self.root = root self.root = root
self.root.title(f"{APP_NAME} {VERSION}") self.root.title(f"{APP_NAME} {VERSION}")
self.root.geometry("700x830") self.root.geometry("900x830")
self.root.minsize(660, 480) self.root.minsize(780, 520)
set_window_icon(self.root) set_window_icon(self.root)
set_dark_titlebar(self.root) set_dark_titlebar(self.root)
@ -1054,6 +1054,10 @@ class VoiceActivationApp:
log_exception(type(fehler), fehler, fehler.__traceback__) log_exception(type(fehler), fehler, fehler.__traceback__)
self.update_fehler(fehler) self.update_fehler(fehler)
return return
try:
self.akte.speichern_sofort()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
self.stop() self.stop()
self.root.after(400, self.root.destroy) self.root.after(400, self.root.destroy)
@ -1492,6 +1496,10 @@ class VoiceActivationApp:
self.root.after(80, self.ui_tick) self.root.after(80, self.ui_tick)
def on_close(self): def on_close(self):
try:
self.akte.speichern_sofort()
except Exception as e:
log_exception(type(e), e, e.__traceback__)
try: try:
self.save_config() self.save_config()
except Exception: except Exception:

View file

@ -26,7 +26,7 @@ from pathlib import Path
ORDNER = Path(__file__).resolve().parent ORDNER = Path(__file__).resolve().parent
VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe" VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe"
ANFORDERUNGEN = ORDNER / "requirements.txt" ANFORDERUNGEN = ORDNER / "requirements.txt"
EIGENE_MODULE = {"squad_manager", "theme", "akte"} EIGENE_MODULE = {"squad_manager", "theme", "akte", "akte_modell", "akte_vorlagen"}
for pfad in (ORDNER / ".venv" / "Lib" / "site-packages", ORDNER): for pfad in (ORDNER / ".venv" / "Lib" / "site-packages", ORDNER):
if pfad.is_dir(): if pfad.is_dir():

View file

@ -6,10 +6,36 @@ Eigene Datei, damit mehrere Module (Funk, Akte) denselben Stil nutzen,
ohne sich gegenseitig zu importieren. ohne sich gegenseitig zu importieren.
""" """
import ctypes
import ctypes.wintypes as wintypes
import tkinter as tk import tkinter as tk
from tkinter import ttk from tkinter import ttk
def dunkle_titelleiste(fenster):
"""
Dunkle Titelleiste fuer ein beliebiges Fenster, auch fuer Dialoge.
Windows zeichnet sie sonst hell. Attribut 20 gilt fuer aktuelle
Windows-Versionen, 19 fuer aeltere. Danach muss das Fenster einmal neu
gezeichnet werden, sonst bleibt die alte Farbe stehen.
"""
try:
fenster.update_idletasks()
hwnd = ctypes.windll.user32.GetParent(fenster.winfo_id()) or fenster.winfo_id()
an = ctypes.c_int(1)
for attribut in (20, 19):
if ctypes.windll.dwmapi.DwmSetWindowAttribute(
wintypes.HWND(hwnd), ctypes.c_uint(attribut),
ctypes.byref(an), ctypes.sizeof(an)) == 0:
fenster.withdraw()
fenster.deiconify()
return True
except Exception:
pass
return False
BG = "#151814" # Fensterhintergrund, fast schwarz mit Gruenstich BG = "#151814" # Fensterhintergrund, fast schwarz mit Gruenstich
PANEL = "#1e231b" # Flaechen, Eingabefelder PANEL = "#1e231b" # Flaechen, Eingabefelder
PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter
@ -115,6 +141,22 @@ def apply_tactical_theme(root):
background=[("active", BG)], background=[("active", BG)],
lightcolor=[("active", OLIVE_HI)], lightcolor=[("active", OLIVE_HI)],
darkcolor=[("active", OLIVE_HI)]) darkcolor=[("active", OLIVE_HI)])
# Tabellen und Scrollbalken (Modul Akte)
style.configure("Treeview", background=PANEL, fieldbackground=PANEL,
foreground=FG, bordercolor=LINE, lightcolor=PANEL,
darkcolor=PANEL, rowheight=24, font=FONT_UI)
style.map("Treeview",
background=[("selected", OLIVE)],
foreground=[("selected", "#12150f")])
style.configure("Treeview.Heading", background=BG, foreground=FG_DIM,
bordercolor=LINE, lightcolor=BG, darkcolor=BG,
font=FONT_BOLD, relief="flat")
style.map("Treeview.Heading", background=[("active", PANEL_HI)])
style.configure("Vertical.TScrollbar", background=PANEL, troughcolor=BG,
bordercolor=LINE, arrowcolor=FG_DIM, lightcolor=PANEL,
darkcolor=PANEL)
style.map("Vertical.TScrollbar", background=[("active", PANEL_HI)])
# Hauptreiter (FUNK, AKTE): ohne Kasten, nur Schrift - so heben sie sich # Hauptreiter (FUNK, AKTE): ohne Kasten, nur Schrift - so heben sie sich
# als uebergeordnete Ebene von den umrahmten Unterreitern ab. # als uebergeordnete Ebene von den umrahmten Unterreitern ab.
style.configure("Haupt.TNotebook", background=BG, bordercolor=BG, style.configure("Haupt.TNotebook", background=BG, bordercolor=BG,

View file

@ -26,8 +26,8 @@ WURZEL = Path(__file__).resolve().parent.parent
DIST = WURZEL / "dist" DIST = WURZEL / "dist"
BASIS_URL = "https://sva.tyrveil.com" BASIS_URL = "https://sva.tyrveil.com"
PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "start.pyw", PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py",
"make_icon.py") "akte_vorlagen.py", "start.pyw", "make_icon.py")
MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico") MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico")
ISCC_KANDIDATEN = ( ISCC_KANDIDATEN = (