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>
291 lines
12 KiB
Python
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()
|