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

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

291 lines
12 KiB
Python

"""
Akte als Bild zum Teilen, etwa in Discord.
Gezeichnet mit Pillow statt vom Bildschirm abfotografiert: Die Karte sieht
so auf jedem Rechner gleich aus, unabhaengig von Fenstergroesse und
Bildschirmskalierung, und laesst sich ohne Fenster erzeugen und pruefen.
Das Format 1200 x 675 zeigt Discord gross und scharf an.
"""
import io
import re
from pathlib import Path
from PIL import Image, ImageDraw, ImageFont, ImageOps
import akte_modell as modell
from theme import BG, PANEL, LINE, FG, FG_DIM, OLIVE_HI, AMBER, RED
BREITE, HOEHE = 1200, 675
FUSSZEILE = "ERSTELLT MIT SQUAD MANAGER · SVA.TYRVEIL.COM"
MONO, MONO_FETT = "consola.ttf", "consolab.ttf"
UI, UI_HALBFETT = "segoeui.ttf", "seguisb.ttf"
def _schrift(datei, groesse):
try:
return ImageFont.truetype(datei, groesse)
except OSError:
return ImageFont.load_default(groesse)
def _kuerzen(zeichnen, text, schrift, breite):
"""Schneidet mit Auslassungszeichen ab, bis der Text in die Breite passt."""
if zeichnen.textlength(text, font=schrift) <= breite:
return text
while text and zeichnen.textlength(text + " …", font=schrift) > breite:
text = text[:-1]
return text.rstrip() + " …"
def _umbrechen(zeichnen, text, schrift, breite, zeilen_max):
zeilen, aktuell = [], ""
for wort in text.split():
probe = f"{aktuell} {wort}".strip()
if zeichnen.textlength(probe, font=schrift) <= breite or not aktuell:
aktuell = probe
else:
zeilen.append(aktuell)
aktuell = wort
if aktuell:
zeilen.append(aktuell)
if len(zeilen) > zeilen_max:
zeilen = zeilen[:zeilen_max]
zeilen[-1] += " …"
return [_kuerzen(zeichnen, z, schrift, breite) for z in zeilen]
def _groesste_schrift(zeichnen, text, datei, breite, groessen):
for groesse in groessen:
schrift = _schrift(datei, groesse)
if zeichnen.textlength(text, font=schrift) <= breite:
return schrift
return _schrift(datei, groessen[-1])
def _portraet(akte, groesse, gedaempft):
pfad = modell.portraet_pfad(akte.get("id", ""))
if not pfad or not Path(pfad).is_file():
return None
try:
with Image.open(pfad) as quelle:
bild = ImageOps.fit(ImageOps.exif_transpose(quelle).convert("RGB"), groesse,
Image.LANCZOS)
except OSError:
return None
if gedaempft:
grau = ImageOps.grayscale(bild).convert("RGB")
bild = Image.blend(grau, Image.new("RGB", groesse, BG), 0.35)
return bild
def _stempel(bild, mitte, text, farbe, winkel=18):
"""Schraeger Stempel wie in der Dokumentansicht, hier als gedrehte Ebene."""
schrift = _schrift(MONO_FETT, 42)
probe = ImageDraw.Draw(bild)
links, oben, rechts, unten = probe.textbbox((0, 0), text, font=schrift)
breite, hoehe = rechts - links + 60, unten - oben + 40
ebene = Image.new("RGBA", (breite, hoehe), (0, 0, 0, 0))
zeichnen = ImageDraw.Draw(ebene)
zeichnen.rectangle((3, 3, breite - 4, hoehe - 4), outline=farbe, width=6)
zeichnen.text((breite / 2, hoehe / 2), text, font=schrift, fill=farbe, anchor="mm")
ebene = ebene.rotate(winkel, expand=True, resample=Image.BICUBIC)
ebene.putalpha(ebene.getchannel("A").point(lambda wert: int(wert * 0.92)))
x, y = int(mitte[0] - ebene.width / 2), int(mitte[1] - ebene.height / 2)
bild.paste(ebene, (x, y), ebene)
def _datum(iso):
teile = str(iso)[:10].split("-")
return ".".join(reversed(teile)) if len(teile) == 3 else ""
def karte(akte):
"""Gibt die Karte als Pillow-Bild zurueck."""
pers, dienst = akte.get("personalien", {}), akte.get("dienst", {})
status = dienst.get("status", "aktiv") or "aktiv"
gefallen = status == "gefallen"
schrift_farbe = FG_DIM if gefallen else FG
akzent = FG_DIM if gefallen else OLIVE_HI
bild = Image.new("RGB", (BREITE, HOEHE), BG)
z = ImageDraw.Draw(bild)
z.rectangle((24, 24, BREITE - 25, HOEHE - 25), fill=PANEL, outline=LINE, width=2)
klein = _schrift(MONO, 17)
z.text((60, 46), f"AKTE NR. {akte.get('aktennummer', '')}", font=klein, fill=FG_DIM)
z.text((BREITE - 60, 46), "SQUAD MANAGER · PERSONALWESEN", font=klein, fill=FG_DIM,
anchor="ra")
z.line((60, 80, BREITE - 60, 80), fill=LINE, width=2)
# Portraet links
px0, py0, pb, ph = 60, 108, 312, 390
z.rectangle((px0 - 7, py0 - 7, px0 + pb + 6, py0 + ph + 6), outline=LINE, width=2)
foto = _portraet(akte, (pb, ph), gefallen)
if foto:
bild.paste(foto, (px0, py0))
else:
z.rectangle((px0, py0, px0 + pb - 1, py0 + ph - 1), fill=BG)
# Unter einem Stempel wuerde der Text nur durchscheinen
if status not in ("gefallen", "vermisst"):
z.multiline_text((px0 + pb / 2, py0 + ph / 2), "KEIN\nPORTRÄT",
font=_schrift(MONO, 22), fill=FG_DIM, anchor="mm",
align="center", spacing=8)
# Kopfdaten rechts
x, rechts = 420, BREITE - 60
breite = rechts - x
stempel_schrift = _schrift(MONO_FETT, 24)
links, oben, r, unten = z.textbbox((x + 16, 112), "PERSONALAKTE", font=stempel_schrift)
z.rectangle((links - 16, oben - 10, r + 16, unten + 10), outline=AMBER, width=3)
z.text((x + 16, 112), "PERSONALAKTE", font=stempel_schrift, fill=AMBER)
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 "NEUE AKTE")
titel_schrift = _groesste_schrift(z, titel, UI_HALBFETT, breite, range(72, 38, -4))
y = 160
z.text((x, y), _kuerzen(z, titel, titel_schrift, breite), font=titel_schrift, fill=akzent)
y += titel_schrift.size + 10
zweite = " ".join(t for t in (dienst.get("rang", ""), name if callsign else "") if t)
if zweite:
name_schrift = _schrift(UI, 30)
z.text((x, y), _kuerzen(z, zweite, name_schrift, breite), font=name_schrift,
fill=schrift_farbe)
y += 44
y += 8
einheit = " · ".join(v for v in (dienst.get("einheit", {}).get(k, "") for k in
("verband", "bataillon", "kompanie", "zug", "gruppe")) if v)
einsaetze = akte.get("einsaetze", [])
letzter = next((e.get("ort", "") for e in reversed(einsaetze) if e.get("ort")), "")
zeilen = [
("FRAKTION", " · ".join(v for v in (dienst.get("fraktion", ""),
dienst.get("teilstreitkraft", "")) if v)),
("VERWENDUNG", dienst.get("verwendung", "")),
("EINHEIT", einheit),
("STATUS", status.upper()),
("DIENSTBEGINN", dienst.get("dienstbeginn", "")),
("EINSÄTZE", f"{len(einsaetze)}" + (f" · zuletzt {letzter}" if letzter else "")
if einsaetze else ""),
]
beschriftung, inhalt = _schrift(MONO, 17), _schrift(MONO, 21)
wert_x = x + 190
for titel_zeile, wert in zeilen:
if not wert:
continue
umbruch = _umbrechen(z, wert, inhalt, rechts - wert_x, 2)
if y + 31 * len(umbruch) > 512:
break
z.text((x, y + 3), titel_zeile, font=beschriftung, fill=FG_DIM)
farbe = (RED if gefallen else AMBER) if titel_zeile == "STATUS" and \
status in ("gefallen", "vermisst") else schrift_farbe
for teil in umbruch:
z.text((wert_x, y), teil, font=inhalt, fill=farbe)
y += 31
if status in ("gefallen", "vermisst"):
_stempel(bild, (px0 + pb / 2, py0 + ph / 2), status.upper(), RED if gefallen else AMBER)
# Leiste unten: Auszeichnungen, sonst ein Stueck Beschreibung
z.line((60, 526, BREITE - 60, 526), fill=LINE, width=2)
auszeichnungen = [e.get("bezeichnung", "") for e in akte.get("auszeichnungen", [])
if e.get("bezeichnung")]
unten_schrift = _schrift(UI, 21)
unten_breite = BREITE - 120
abstand = " "
if auszeichnungen:
z.text((60, 542), "AUSZEICHNUNGEN", font=_schrift(MONO_FETT, 17), fill=akzent)
# Nur ganze Eintraege, der Rest als Zahl - ein halber Orden liest sich schlecht
gezeigt, rest = [], len(auszeichnungen)
for name_a in auszeichnungen:
probe = gezeigt + ["■ " + name_a]
anhang = f"{abstand}+ {rest - 1} weitere" if rest > 1 else ""
if gezeigt and z.textlength(abstand.join(probe) + anhang,
font=unten_schrift) > unten_breite:
break
gezeigt, rest = probe, rest - 1
text = abstand.join(gezeigt) + (f"{abstand}+ {rest} weitere" if rest else "")
z.text((60, 568), _kuerzen(z, text, unten_schrift, unten_breite), font=unten_schrift,
fill=schrift_farbe)
elif akte.get("beschreibung", "").strip():
z.text((60, 542), "BESCHREIBUNG", font=_schrift(MONO_FETT, 17), fill=akzent)
zeile = _umbrechen(z, akte["beschreibung"].replace("\n", " "), unten_schrift,
unten_breite, 1)[0]
z.text((60, 568), zeile, font=unten_schrift, fill=schrift_farbe)
fuss = _schrift(MONO, 14)
z.text((60, HOEHE - 52), FUSSZEILE, font=fuss, fill=FG_DIM)
stand = _datum(akte.get("geaendert", ""))
if stand:
z.text((BREITE - 60, HOEHE - 52), f"STAND {stand}", font=fuss, fill=FG_DIM, anchor="ra")
return bild
def dateiname(akte):
pers = akte.get("personalien", {})
name = pers.get("callsign") or pers.get("nachname") or "Akte"
name = re.sub(r"[^\w\-]+", "_", f"{name}_{akte.get('aktennummer', '')}").strip("_")
return f"{name}.png"
def in_zwischenablage(bild):
"""
Legt die Karte in die Windows-Zwischenablage.
Zweimal: als DIB, das jedes Programm versteht, und als PNG, das Discord
und Browser bevorzugen und das verlustfrei ankommt.
"""
import ctypes
import ctypes.wintypes as wintypes
import time
user32 = ctypes.WinDLL("user32", use_last_error=True)
kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
user32.OpenClipboard.argtypes = (wintypes.HWND,)
user32.OpenClipboard.restype = wintypes.BOOL
user32.EmptyClipboard.restype = wintypes.BOOL
user32.CloseClipboard.restype = wintypes.BOOL
user32.SetClipboardData.argtypes = (wintypes.UINT, wintypes.HANDLE)
user32.SetClipboardData.restype = wintypes.HANDLE
user32.RegisterClipboardFormatW.argtypes = (wintypes.LPCWSTR,)
user32.RegisterClipboardFormatW.restype = wintypes.UINT
kernel32.GlobalAlloc.argtypes = (wintypes.UINT, ctypes.c_size_t)
kernel32.GlobalAlloc.restype = wintypes.HGLOBAL
kernel32.GlobalLock.argtypes = (wintypes.HGLOBAL,)
kernel32.GlobalLock.restype = wintypes.LPVOID
kernel32.GlobalUnlock.argtypes = (wintypes.HGLOBAL,)
kernel32.GlobalFree.argtypes = (wintypes.HGLOBAL,)
bmp = io.BytesIO()
bild.convert("RGB").save(bmp, "BMP")
dib = bmp.getvalue()[14:] # ohne BITMAPFILEHEADER
png = io.BytesIO()
bild.save(png, "PNG")
def speicherblock(daten):
block = kernel32.GlobalAlloc(0x0002, len(daten)) # GMEM_MOVEABLE
if not block:
raise MemoryError("Kein Speicher für die Zwischenablage")
ctypes.memmove(kernel32.GlobalLock(block), daten, len(daten))
kernel32.GlobalUnlock(block)
return block
# Ein anderes Programm kann die Zwischenablage kurz belegt halten
for _ in range(20):
if user32.OpenClipboard(None):
break
time.sleep(0.05)
else:
raise OSError("Die Zwischenablage ist gerade von einem anderen Programm belegt.")
try:
user32.EmptyClipboard()
for format_nr, daten in ((8, dib), # CF_DIB
(user32.RegisterClipboardFormatW("PNG"), png.getvalue())):
block = speicherblock(daten)
if not user32.SetClipboardData(format_nr, block):
kernel32.GlobalFree(block)
raise OSError("Die Karte konnte nicht in die Zwischenablage gelegt werden.")
finally:
user32.CloseClipboard()