From 8c0d364a8a40fc2c2b6e3bcca632ebb13cc788b1 Mon Sep 17 00:00:00 2001 From: danny Date: Thu, 10 Sep 2026 18:50:18 +0200 Subject: [PATCH] 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 --- PLAN-AKTE.md | 8 +- PROJEKT-UEBERGABE.md | 42 ++- README.md | 6 +- akte.py | 755 +++++++++++++++++++++++++++++++++++++- akte_modell.py | 234 ++++++++++++ akte_vorlagen.py | 229 ++++++++++++ requirements.txt | 1 + squad_manager.py | 14 +- start.pyw | 2 +- theme.py | 42 +++ werkzeuge/baue_release.py | 4 +- 11 files changed, 1308 insertions(+), 29 deletions(-) create mode 100644 akte_modell.py create mode 100644 akte_vorlagen.py diff --git a/PLAN-AKTE.md b/PLAN-AKTE.md index 01eb01e..a35002c 100644 --- a/PLAN-AKTE.md +++ b/PLAN-AKTE.md @@ -1,6 +1,6 @@ # 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, Porträt, Nation, Teilstreitkraft, Einheit, Werdegang. Reines Rollenspiel — @@ -81,7 +81,9 @@ riskant. ``` squad_manager.py Hauptfenster, Navigation, Funk-Modul (wie bisher) 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 @@ -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 | | **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 | Jede Stufe endet mit einem Release über den Updater. Stufe 1 ist bewusst diff --git a/PROJEKT-UEBERGABE.md b/PROJEKT-UEBERGABE.md index 9e0851f..e651afe 100644 --- a/PROJEKT-UEBERGABE.md +++ b/PROJEKT-UEBERGABE.md @@ -1,6 +1,6 @@ # 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 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) 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 make_icon.py erzeugt icon.ico aus icon.png icon.png / icon.ico Programmsymbol (vom Nutzer geliefert) @@ -103,9 +105,11 @@ frisch. ## 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 -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 ein zirkulärer Import, weil `squad_manager.py` die Akte einbindet. 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 steht als `modul` in der `config.json`. +**Akte:** Ablage je Akte unter `%APPDATA%\SquadManager\akten\\` 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--`, 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 @@ -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 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 @@ -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 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 hatte den Eintrag der Nutzerinstallation unter *Apps und Features* übernommen. Bereinigt; seitdem gilt Erkenntnis 16. diff --git a/README.md b/README.md index 9986530..7ee67f4 100644 --- a/README.md +++ b/README.md @@ -13,11 +13,13 @@ Technische Dokumentation und alle bekannten Fallstricke: |---|---| | `squad_manager.py` | Hauptfenster, Funk-Modul, Updater | | `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 | | `make_icon.py` | erzeugt `icon.ico` aus `icon.png` | | `icon.png`, `icon.ico` | Programmsymbol | -| `requirements.txt` | numpy, sounddevice | +| `requirements.txt` | numpy, sounddevice, Pillow | | `installer/` | Inno-Setup-Skript, Einrichtung nach der Installation, Server-Anleitung | | `werkzeuge/` | Release-Bau und Testhilfen | | `Design-Briefing.md` | Auftrag für die Gestaltung | diff --git a/akte.py b/akte.py index 6af1094..7ffa6fa 100644 --- a/akte.py +++ b/akte.py @@ -1,14 +1,158 @@ """ Modul Akte: Personalakten fuer Rollenspiel-Charaktere. -Stufe 1 (Version 3.4) schafft nur den Platz in der Oberflaeche. Datenmodell, -Speicherung und Dokumentansicht folgen in Stufe 2, siehe PLAN-AKTE.md. +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 +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("", 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("", lambda e: self.canvas.configure( + scrollregion=self.canvas.bbox("all"))) + self.canvas.bind("", lambda e: self.canvas.itemconfigure( + self._fenster, width=e.width)) + self._rollziel = self.canvas class AkteSeite(ttk.Frame): @@ -16,20 +160,603 @@ class AkteSeite(ttk.Frame): def __init__(self, master): super().__init__(master) - mitte = ttk.Frame(self) - mitte.place(relx=0.5, rely=0.42, anchor="center") + 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" - stempel = tk.Canvas(mitte, width=300, height=86, bg=BG, - highlightthickness=0) - stempel.pack(pady=(0, 20)) + self._aufbau() + self.bind_all("", 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("<>", 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("", 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="In Vorbereitung", + ttk.Label(mitte, text="Noch keine Akte angelegt", font=("Segoe UI Semibold", 12)).pack() ttk.Label(mitte, style="Dim.TLabel", justify="center", - text="Hier entsteht die Personalakte für deine Charaktere:\n" - "Porträt, Dienstgrad, Einheit, Auszeichnungen und " - "Werdegang.").pack(pady=(6, 0)) + 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("", 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("<>", 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("", 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) diff --git a/akte_modell.py b/akte_modell.py new file mode 100644 index 0000000..3fac5f2 --- /dev/null +++ b/akte_modell.py @@ -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\\\\akte.json + %APPDATA%\\SquadManager\\akten\\\\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--; 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" diff --git a/akte_vorlagen.py b/akte_vorlagen.py new file mode 100644 index 0000000..6b37f38 --- /dev/null +++ b/akte_vorlagen.py @@ -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", "") diff --git a/requirements.txt b/requirements.txt index e6ad8bb..e624a52 100644 --- a/requirements.txt +++ b/requirements.txt @@ -1,2 +1,3 @@ numpy>=1.26 sounddevice>=0.4.6 +Pillow>=10.4 diff --git a/squad_manager.py b/squad_manager.py index 563c333..1d1178d 100644 --- a/squad_manager.py +++ b/squad_manager.py @@ -59,7 +59,7 @@ from theme import ( # noqa: E402 import akte # noqa: E402 APP_NAME = "Squad Manager" -VERSION = "3.4" +VERSION = "4.0" CONFIG_PATH = Path(os.getenv("APPDATA", ".")) / "SquadManager" / "config.json" LOG_PATH = CONFIG_PATH.parent / "error.log" # Bis Version 3.2 hiess das Programm "Squad Voice Activation" @@ -688,8 +688,8 @@ class VoiceActivationApp: def __init__(self, root): self.root = root self.root.title(f"{APP_NAME} {VERSION}") - self.root.geometry("700x830") - self.root.minsize(660, 480) + self.root.geometry("900x830") + self.root.minsize(780, 520) set_window_icon(self.root) set_dark_titlebar(self.root) @@ -1054,6 +1054,10 @@ class VoiceActivationApp: log_exception(type(fehler), fehler, fehler.__traceback__) self.update_fehler(fehler) return + try: + self.akte.speichern_sofort() + except Exception as e: + log_exception(type(e), e, e.__traceback__) self.stop() self.root.after(400, self.root.destroy) @@ -1492,6 +1496,10 @@ class VoiceActivationApp: self.root.after(80, self.ui_tick) def on_close(self): + try: + self.akte.speichern_sofort() + except Exception as e: + log_exception(type(e), e, e.__traceback__) try: self.save_config() except Exception: diff --git a/start.pyw b/start.pyw index 3cddb63..879c50a 100644 --- a/start.pyw +++ b/start.pyw @@ -26,7 +26,7 @@ from pathlib import Path ORDNER = Path(__file__).resolve().parent VENV_PYTHON = ORDNER / ".venv" / "Scripts" / "python.exe" 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): if pfad.is_dir(): diff --git a/theme.py b/theme.py index 1da2a3c..858d33f 100644 --- a/theme.py +++ b/theme.py @@ -6,10 +6,36 @@ Eigene Datei, damit mehrere Module (Funk, Akte) denselben Stil nutzen, ohne sich gegenseitig zu importieren. """ +import ctypes +import ctypes.wintypes as wintypes import tkinter as tk 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 PANEL = "#1e231b" # Flaechen, Eingabefelder PANEL_HI = "#2a3125" # Hover, ausgewaehlter Reiter @@ -115,6 +141,22 @@ def apply_tactical_theme(root): background=[("active", BG)], lightcolor=[("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 # als uebergeordnete Ebene von den umrahmten Unterreitern ab. style.configure("Haupt.TNotebook", background=BG, bordercolor=BG, diff --git a/werkzeuge/baue_release.py b/werkzeuge/baue_release.py index 7680604..06a80b1 100644 --- a/werkzeuge/baue_release.py +++ b/werkzeuge/baue_release.py @@ -26,8 +26,8 @@ WURZEL = Path(__file__).resolve().parent.parent DIST = WURZEL / "dist" BASIS_URL = "https://sva.tyrveil.com" -PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "start.pyw", - "make_icon.py") +PYTHON_DATEIEN = ("squad_manager.py", "theme.py", "akte.py", "akte_modell.py", + "akte_vorlagen.py", "start.pyw", "make_icon.py") MITKOPIEREN = ("requirements.txt", "icon.png", "icon.ico") ISCC_KANDIDATEN = (