- Neuer Hauptreiter SQUAD: Anmeldung und Registrierung; angemeldet alle Charaktere mit Zustand (KIA/MIA/WIA), Suche und Fraktionsfilter, fremde Akten als Dokument, Squads gruenden und verwalten, Einladungen annehmen, ablehnen, zurueckziehen; Konto abmelden oder loeschen - Akten werden nach dem Anmelden, kurz nach jeder Aenderung und alle 5 Minuten mit dem Server abgeglichen; Zustand unter der Aktenliste - Dokumentansicht als dokument_zeichnen() fuer eigene und fremde Akten; ohne Portraet scheint "KEIN PORTRAET" nicht mehr durch den Stempel - Release-Bau: Bezeichner wie "konto_loeschen" bekommen keine Umlaute mehr - sonst waeren vier Serveraktionen im Paket kaputt gewesen - Tests koennen mit SM_PROGRAMM gegen das gebaute Paket laufen - Datenschutz-Baustein fuer tyrveil.com, Anleitung und Doku auf 1.6.0 Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
945 lines
43 KiB
Python
945 lines
43 KiB
Python
"""
|
||
Hauptreiter SQUAD: Konto, alle Charaktere, Squads und Einladungen.
|
||
|
||
Ohne Anmeldung zeigt der Reiter die Anmeldung und Registrierung; alles
|
||
andere im Programm funktioniert auch ohne Konto. Angemeldet gibt es drei
|
||
Unterreiter:
|
||
|
||
Charaktere alle Charaktere aller Spieler mit Zustand (KIA, MIA ...)
|
||
Squads alle Squads, eigene verwalten, neues gruenden
|
||
Einladungen erhaltene annehmen oder ablehnen, verschickte zurueckziehen
|
||
|
||
Dazu steuert AbgleichSteuerung, wann die eigenen Akten mit dem Server
|
||
abgeglichen werden. Alle Serveraufrufe laufen ueber hintergrund.py, damit
|
||
das Fenster nie einfriert.
|
||
"""
|
||
|
||
import io
|
||
import time
|
||
import tkinter as tk
|
||
import webbrowser
|
||
from tkinter import messagebox, ttk
|
||
|
||
from PIL import Image, ImageOps, ImageTk
|
||
|
||
import abgleich
|
||
import akte
|
||
import akte_modell as modell
|
||
import akte_vorlagen as vorlagen
|
||
import konto
|
||
from hintergrund import Hintergrund
|
||
from theme import (AMBER, BG, FG, FG_DIM, FONT_BOLD, FONT_UI, OLIVE_HI, PANEL, RED,
|
||
dunkle_titelleiste)
|
||
|
||
ALLE_FRAKTIONEN = "Alle Fraktionen"
|
||
ZUSTAND = {
|
||
"aktiv": ("", "aktiv"),
|
||
"verwundet": ("WIA", "verwundet"),
|
||
"vermisst": ("MIA", "vermisst"),
|
||
"gefallen": ("KIA", "gefallen"),
|
||
"außer Dienst": ("a. D.", "außer Dienst"),
|
||
}
|
||
|
||
|
||
def zustand_text(status):
|
||
kurz, lang = ZUSTAND.get(status, ("", status or "aktiv"))
|
||
return f"{kurz} · {lang}" if kurz else lang
|
||
|
||
|
||
def charakter_name(c):
|
||
name = " ".join(t for t in (c.get("vorname", ""), c.get("nachname", "")) if t)
|
||
if c.get("callsign"):
|
||
return f'{c["callsign"]} · {c.get("nachname") or name}' if name else c["callsign"]
|
||
return name or c.get("aktennummer") or "Ohne Namen"
|
||
|
||
|
||
def fehlertext(fehler):
|
||
if isinstance(fehler, konto.ServerFehler):
|
||
return fehler.meldung
|
||
return f"Unerwarteter Fehler: {fehler}"
|
||
|
||
|
||
def dialog_zentrieren(fenster, eltern):
|
||
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)}")
|
||
|
||
|
||
# -- Abgleich ----------------------------------------------------------------------
|
||
|
||
class AbgleichSteuerung:
|
||
"""Stoesst den Abgleich an: nach dem Anmelden, kurz nach Aenderungen und regelmaessig."""
|
||
|
||
NACH_AENDERUNG_MS = 4000
|
||
TAKT_MS = 5 * 60 * 1000
|
||
|
||
def __init__(self, widget, hintergrund, akte_seite, protokollieren, bei_abmeldung):
|
||
self.widget = widget
|
||
self.hintergrund = hintergrund
|
||
self.akte_seite = akte_seite
|
||
self.protokollieren = protokollieren
|
||
self.bei_abmeldung = bei_abmeldung
|
||
self.beobachter = [akte_seite.abgleich_zustand]
|
||
self._job = None
|
||
self._laeuft = False
|
||
self._erneut = False
|
||
akte_seite.bei_gespeichert = lambda: self.anstossen(self.NACH_AENDERUNG_MS)
|
||
self.melden()
|
||
widget.after(1500, self._takt)
|
||
|
||
def melden(self, text=None, art="aus"):
|
||
if text is None:
|
||
text, art = ("Angemeldet – Abgleich folgt", "aus") if konto.angemeldet() \
|
||
else ("Nicht angemeldet – Akten liegen nur auf diesem PC", "aus")
|
||
for beobachter in self.beobachter:
|
||
beobachter(text, art)
|
||
|
||
def anstossen(self, verzoegerung_ms=0):
|
||
if not konto.angemeldet():
|
||
self.melden()
|
||
return
|
||
if self._job is not None:
|
||
self.widget.after_cancel(self._job)
|
||
self._job = self.widget.after(verzoegerung_ms, self._starten)
|
||
|
||
def _starten(self):
|
||
self._job = None
|
||
if self._laeuft:
|
||
self._erneut = True
|
||
return
|
||
self._laeuft = True
|
||
self.akte_seite.speichern_sofort()
|
||
self.melden("Abgleich läuft …", "laeuft")
|
||
self.hintergrund.starten(abgleich.abgleichen, self._fertig, self._fehler)
|
||
|
||
def _nachlauf(self):
|
||
self._laeuft = False
|
||
if self._erneut:
|
||
self._erneut = False
|
||
self.anstossen(500)
|
||
|
||
def _fertig(self, ergebnis):
|
||
if ergebnis is not None:
|
||
self.akte_seite.nach_abgleich(ergebnis["geaendert"])
|
||
text = f"Mit dem Server abgeglichen · {time.strftime('%H:%M')}"
|
||
if ergebnis["konflikte"]:
|
||
text += (f" · {ergebnis['konflikte']} Konflikt(e): die Serverfassung liegt als "
|
||
"konflikt-Datei im Aktenordner")
|
||
self.melden(text, "offline" if ergebnis["konflikte"] else "ok")
|
||
self._nachlauf()
|
||
|
||
def _fehler(self, fehler):
|
||
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
|
||
self.melden("Die Anmeldung ist abgelaufen – bitte neu anmelden", "fehler")
|
||
self.bei_abmeldung()
|
||
elif isinstance(fehler, konto.ServerFehler) and fehler.code == "offline":
|
||
self.melden("Offline – Änderungen werden später hochgeladen", "offline")
|
||
else:
|
||
self.protokollieren(type(fehler), fehler, fehler.__traceback__)
|
||
self.melden(f"Abgleich gescheitert: {fehlertext(fehler)}", "fehler")
|
||
self._nachlauf()
|
||
|
||
def _takt(self):
|
||
if konto.angemeldet():
|
||
self.anstossen()
|
||
try:
|
||
self.widget.after(self.TAKT_MS, self._takt)
|
||
except tk.TclError:
|
||
pass
|
||
|
||
|
||
# -- Anmeldung und Registrierung ------------------------------------------------------
|
||
|
||
class AnmeldeFlaeche(ttk.Frame):
|
||
def __init__(self, master, hintergrund, bei_anmeldung):
|
||
super().__init__(master)
|
||
self.hintergrund = hintergrund
|
||
self.bei_anmeldung = bei_anmeldung
|
||
self._knoepfe = []
|
||
|
||
mitte = ttk.Frame(self)
|
||
mitte.place(relx=0.5, rely=0.42, anchor="center")
|
||
ttk.Label(mitte, text="SQUAD", font=("Segoe UI Semibold", 16)).pack(anchor="w")
|
||
ttk.Label(mitte, style="Dim.TLabel", justify="left", wraplength=420, text=(
|
||
"Mit einem Konto liegen deine Akten sicher auf dem Server, du siehst die "
|
||
"Charaktere der anderen Spieler und kannst Squads bilden. Ohne Konto "
|
||
"funktioniert alles andere wie bisher.")).pack(anchor="w", pady=(4, 14))
|
||
|
||
reiter = ttk.Notebook(mitte)
|
||
reiter.pack(fill="x")
|
||
self.reiter = reiter
|
||
self._anmelden_aufbauen(reiter)
|
||
self._registrieren_aufbauen(reiter)
|
||
|
||
self.meldung_var = tk.StringVar()
|
||
self.meldung = ttk.Label(mitte, textvariable=self.meldung_var, wraplength=420, justify="left")
|
||
self.meldung.pack(anchor="w", pady=(12, 0))
|
||
self.erneut_knopf = ttk.Button(mitte, text="Bestätigungsmail erneut senden",
|
||
command=self.bestaetigung_erneut)
|
||
|
||
verweise = ttk.Frame(mitte)
|
||
verweise.pack(anchor="w", pady=(14, 0))
|
||
for text, pfad in (("Passwort vergessen?", None),
|
||
("Impressum und Datenschutz", "https://tyrveil.com/rechtliches#impressum")):
|
||
verweis = ttk.Label(verweise, text=text, style="Dim.TLabel", cursor="hand2")
|
||
verweis.pack(side="left", padx=(0, 18))
|
||
ziel = pfad or konto.webseite("/konto/vergessen.php")
|
||
verweis.bind("<Button-1>", lambda e, z=ziel: webbrowser.open(z))
|
||
|
||
@staticmethod
|
||
def _feld(eltern, zeile, beschriftung, verdeckt=False):
|
||
ttk.Label(eltern, text=beschriftung).grid(row=zeile, column=0, sticky="w", pady=5, padx=(0, 12))
|
||
var = tk.StringVar()
|
||
eingabe = ttk.Entry(eltern, textvariable=var, width=34, show="•" if verdeckt else "")
|
||
eingabe.grid(row=zeile, column=1, sticky="ew", pady=5)
|
||
return var, eingabe
|
||
|
||
def _anmelden_aufbauen(self, reiter):
|
||
f = ttk.Frame(reiter, padding=16)
|
||
reiter.add(f, text="Anmelden")
|
||
self.login_var, erstes = self._feld(f, 0, "Benutzername oder E-Mail")
|
||
self.passwort_var, pw = self._feld(f, 1, "Passwort", verdeckt=True)
|
||
knopf = ttk.Button(f, text="Anmelden", style="Accent.TButton", command=self.anmelden)
|
||
knopf.grid(row=2, column=1, sticky="e", pady=(10, 0))
|
||
self._knoepfe.append(knopf)
|
||
for eingabe in (erstes, pw):
|
||
eingabe.bind("<Return>", lambda e: self.anmelden())
|
||
self.erstes_feld = erstes
|
||
|
||
def _registrieren_aufbauen(self, reiter):
|
||
f = ttk.Frame(reiter, padding=16)
|
||
reiter.add(f, text="Registrieren")
|
||
self.neu_name_var, _ = self._feld(f, 0, "Benutzername")
|
||
self.neu_email_var, _ = self._feld(f, 1, "E-Mail")
|
||
self.neu_pw_var, _ = self._feld(f, 2, "Passwort (mind. 10 Zeichen)", verdeckt=True)
|
||
self.neu_pw2_var, letztes = self._feld(f, 3, "Passwort wiederholen", verdeckt=True)
|
||
letztes.bind("<Return>", lambda e: self.registrieren())
|
||
knopf = ttk.Button(f, text="Konto anlegen", style="Accent.TButton", command=self.registrieren)
|
||
knopf.grid(row=4, column=1, sticky="e", pady=(10, 0))
|
||
self._knoepfe.append(knopf)
|
||
|
||
def _zeigen(self, text, art="info"):
|
||
farben = {"info": FG, "ok": OLIVE_HI, "fehler": RED, "warnung": AMBER}
|
||
self.meldung_var.set(text)
|
||
self.meldung.configure(foreground=farben.get(art, FG))
|
||
|
||
def _beschaeftigt(self, ja):
|
||
for knopf in self._knoepfe:
|
||
knopf.configure(state="disabled" if ja else "normal")
|
||
|
||
def anmelden(self):
|
||
login, passwort = self.login_var.get().strip(), self.passwort_var.get()
|
||
if not login or not passwort:
|
||
self._zeigen("Bitte Benutzername oder E-Mail und Passwort eingeben.", "warnung")
|
||
return
|
||
self.erneut_knopf.pack_forget()
|
||
self._beschaeftigt(True)
|
||
self._zeigen("Melde an …")
|
||
|
||
def fertig(nutzer):
|
||
self._beschaeftigt(False)
|
||
self.passwort_var.set("")
|
||
self._zeigen("")
|
||
self.bei_anmeldung(nutzer)
|
||
|
||
def fehler(f):
|
||
self._beschaeftigt(False)
|
||
self._zeigen(fehlertext(f), "fehler")
|
||
if isinstance(f, konto.ServerFehler) and f.code == "nicht_bestaetigt":
|
||
self.erneut_knopf.pack(anchor="w", pady=(8, 0))
|
||
|
||
self.hintergrund.starten(lambda: konto.anmelden(login, passwort), fertig, fehler)
|
||
|
||
def bestaetigung_erneut(self):
|
||
email = self.login_var.get().strip()
|
||
if "@" not in email:
|
||
self._zeigen("Trage oben deine E-Mail-Adresse ein, dann schicken wir die Mail erneut.", "warnung")
|
||
return
|
||
self.hintergrund.starten(lambda: konto.bestaetigung_erneut(email),
|
||
lambda antwort: self._zeigen(antwort.get("meldung", "Mail ist unterwegs."), "ok"),
|
||
lambda f: self._zeigen(fehlertext(f), "fehler"))
|
||
|
||
def registrieren(self):
|
||
name, email = self.neu_name_var.get().strip(), self.neu_email_var.get().strip()
|
||
pw, pw2 = self.neu_pw_var.get(), self.neu_pw2_var.get()
|
||
if not name or not email or not pw:
|
||
self._zeigen("Bitte alle Felder ausfüllen.", "warnung")
|
||
return
|
||
if pw != pw2:
|
||
self._zeigen("Die beiden Passwörter stimmen nicht überein.", "warnung")
|
||
return
|
||
self._beschaeftigt(True)
|
||
self._zeigen("Lege Konto an …")
|
||
|
||
def fertig(antwort):
|
||
self._beschaeftigt(False)
|
||
self.neu_pw_var.set("")
|
||
self.neu_pw2_var.set("")
|
||
self.login_var.set(email)
|
||
self.reiter.select(0)
|
||
self._zeigen("Konto angelegt. Bitte bestätige den Link in der Mail an "
|
||
f"{email} – danach kannst du dich hier anmelden.", "ok")
|
||
|
||
def fehler(f):
|
||
self._beschaeftigt(False)
|
||
self._zeigen(fehlertext(f), "fehler")
|
||
|
||
self.hintergrund.starten(lambda: konto.registrieren(name, email, pw), fertig, fehler)
|
||
|
||
|
||
# -- Fremde Akte ansehen ----------------------------------------------------------------
|
||
|
||
def akte_fenster(eltern, charakter, bild_bytes):
|
||
"""Zeigt eine Akte vom Server als Dokument in einem eigenen Fenster."""
|
||
fenster = tk.Toplevel(eltern)
|
||
fenster.title(f"Akte {charakter.get('aktennummer') or ''} – {charakter_name(charakter)}")
|
||
fenster.configure(bg=BG)
|
||
fenster.geometry("720x820")
|
||
fenster.transient(eltern.winfo_toplevel())
|
||
leinwand = tk.Canvas(fenster, bg=BG, highlightthickness=0, bd=0)
|
||
leiste = ttk.Scrollbar(fenster, orient="vertical", command=leinwand.yview)
|
||
leinwand.configure(yscrollcommand=leiste.set)
|
||
leiste.pack(side="right", fill="y")
|
||
leinwand.pack(side="left", fill="both", expand=True)
|
||
|
||
daten = modell.migrieren(dict(charakter.get("daten") or {}))
|
||
daten["aktennummer"] = charakter.get("aktennummer") or daten.get("aktennummer", "")
|
||
fotos = {}
|
||
|
||
def foto_fuer(groesse):
|
||
if not bild_bytes:
|
||
return None
|
||
if groesse not in fotos:
|
||
with Image.open(io.BytesIO(bild_bytes)) as bild:
|
||
fotos[groesse] = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), groesse))
|
||
return fotos[groesse]
|
||
|
||
zeichnen = lambda e=None: akte.dokument_zeichnen(leinwand, daten, foto_fuer) # noqa: E731
|
||
leinwand.bind("<Configure>", zeichnen)
|
||
leinwand.bind("<MouseWheel>", lambda e: leinwand.yview_scroll(int(-e.delta / 120), "units"))
|
||
fenster.bind("<Escape>", lambda e: fenster.destroy())
|
||
dialog_zentrieren(fenster, eltern)
|
||
return fenster
|
||
|
||
|
||
# -- Hauptreiter ------------------------------------------------------------------------
|
||
|
||
def _tabelle(eltern, spalten, hoehe=12):
|
||
rahmen = ttk.Frame(eltern)
|
||
baum = ttk.Treeview(rahmen, columns=[s for s, _, _ in spalten], show="headings",
|
||
selectmode="browse", height=hoehe)
|
||
for schluessel, titel, breite in spalten:
|
||
baum.heading(schluessel, text=titel, anchor="w")
|
||
baum.column(schluessel, width=breite, anchor="w", stretch=True)
|
||
leiste = ttk.Scrollbar(rahmen, orient="vertical", command=baum.yview)
|
||
baum.configure(yscrollcommand=leiste.set)
|
||
baum.pack(side="left", fill="both", expand=True)
|
||
leiste.pack(side="right", fill="y")
|
||
baum.tag_configure("kia", foreground=RED)
|
||
baum.tag_configure("mia", foreground=AMBER)
|
||
baum.tag_configure("wia", foreground=AMBER)
|
||
baum.tag_configure("ad", foreground=FG_DIM)
|
||
baum.tag_configure("eigener", foreground=OLIVE_HI)
|
||
return rahmen, baum
|
||
|
||
|
||
def _zustand_tag(status):
|
||
return {"gefallen": "kia", "vermisst": "mia", "verwundet": "wia", "außer Dienst": "ad"}.get(status, "")
|
||
|
||
|
||
class SquadSeite(ttk.Frame):
|
||
def __init__(self, master, akte_seite, protokollieren):
|
||
super().__init__(master)
|
||
self.hintergrund = Hintergrund(self)
|
||
self.akte_seite = akte_seite
|
||
self.protokollieren = protokollieren
|
||
self.charaktere = []
|
||
self.squads = []
|
||
self.einladungen = {"eingang": [], "ausgang": []}
|
||
self._bilder = {}
|
||
self._zuletzt_geladen = 0.0
|
||
self._laedt = False
|
||
|
||
self.abgleich = AbgleichSteuerung(self, self.hintergrund, akte_seite, protokollieren,
|
||
bei_abmeldung=self._abgemeldet)
|
||
self.anmeldung = AnmeldeFlaeche(self, self.hintergrund, self._angemeldet)
|
||
self.inhalt = ttk.Frame(self)
|
||
self._inhalt_aufbauen()
|
||
self.abgleich.beobachter.append(self._abgleich_zustand)
|
||
self._ansicht()
|
||
if konto.angemeldet():
|
||
# Pruefen, ob die gespeicherte Anmeldung noch gilt
|
||
self.hintergrund.starten(konto.pruefen, lambda nutzer: self._ansicht(),
|
||
self._pruefung_gescheitert)
|
||
|
||
# -- Umschalten -----------------------------------------------------------------
|
||
|
||
def _ansicht(self):
|
||
if konto.angemeldet():
|
||
self.anmeldung.pack_forget()
|
||
self.inhalt.pack(fill="both", expand=True)
|
||
nutzer = konto.nutzer() or {}
|
||
self.nutzer_var.set(f"Angemeldet als {nutzer.get('benutzername', '?')}")
|
||
else:
|
||
self.inhalt.pack_forget()
|
||
self.anmeldung.pack(fill="both", expand=True)
|
||
|
||
def _pruefung_gescheitert(self, fehler):
|
||
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
|
||
self._abgemeldet()
|
||
|
||
def _angemeldet(self, nutzer):
|
||
self._ansicht()
|
||
self.abgleich.anstossen(0)
|
||
self.aktualisieren()
|
||
|
||
def _abgemeldet(self):
|
||
self.charaktere, self.squads = [], []
|
||
self.einladungen = {"eingang": [], "ausgang": []}
|
||
self._ansicht()
|
||
self.abgleich.melden()
|
||
|
||
def abmelden(self):
|
||
if not messagebox.askyesno("Abmelden",
|
||
"Abmelden? Deine Akten bleiben auf diesem PC und werden "
|
||
"nach der nächsten Anmeldung wieder abgeglichen.", parent=self):
|
||
return
|
||
self.hintergrund.starten(konto.abmelden, lambda _: self._abgemeldet(),
|
||
lambda f: self._abgemeldet())
|
||
|
||
def konto_loeschen(self):
|
||
"""Loescht das Konto samt Akten auf dem Server. Die lokalen Akten bleiben."""
|
||
fenster = tk.Toplevel(self)
|
||
fenster.title("Konto löschen")
|
||
fenster.configure(bg=BG)
|
||
fenster.resizable(False, False)
|
||
fenster.transient(self.winfo_toplevel())
|
||
f = ttk.Frame(fenster, padding=18)
|
||
f.pack(fill="both")
|
||
ttk.Label(f, wraplength=380, justify="left", text=(
|
||
"Das Konto wird mit allen Charakteren auf dem Server gelöscht. Führt einer "
|
||
"deiner Charaktere ein Squad, übernimmt das dienstälteste Mitglied.\n\n"
|
||
"Deine Akten auf diesem PC bleiben erhalten. Das lässt sich nicht rückgängig machen.")
|
||
).grid(row=0, column=0, columnspan=2, sticky="w")
|
||
ttk.Label(f, text="Passwort zur Bestätigung").grid(row=1, column=0, sticky="w", pady=(14, 0), padx=(0, 12))
|
||
passwort = tk.StringVar()
|
||
eingabe = ttk.Entry(f, textvariable=passwort, show="•", width=28)
|
||
eingabe.grid(row=1, column=1, sticky="ew", pady=(14, 0))
|
||
|
||
def loeschen():
|
||
wert = passwort.get()
|
||
if wert:
|
||
fenster.destroy()
|
||
self.konto_loeschen_ausfuehren(wert)
|
||
|
||
knoepfe = ttk.Frame(f)
|
||
knoepfe.grid(row=2, column=0, columnspan=2, sticky="e", pady=(16, 0))
|
||
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
|
||
ttk.Button(knoepfe, text="Endgültig löschen", command=loeschen).pack(side="right", padx=(0, 8))
|
||
fenster.bind("<Escape>", lambda e: fenster.destroy())
|
||
dialog_zentrieren(fenster, self)
|
||
fenster.grab_set()
|
||
eingabe.focus_set()
|
||
|
||
def konto_loeschen_ausfuehren(self, passwort, bestaetigen=True):
|
||
def arbeit():
|
||
konto.aufrufen("konto_loeschen", passwort=passwort)
|
||
# Lokale Akten gelten danach als nie abgeglichen - bei einem neuen
|
||
# Konto werden sie wieder hochgeladen statt in den Papierkorb geraeumt
|
||
for eintrag in modell.alle_akten():
|
||
(modell.ordner_von(eintrag["id"]) / abgleich.META).unlink(missing_ok=True)
|
||
konto.abmelden()
|
||
|
||
def fertig(_):
|
||
self._abgemeldet()
|
||
if bestaetigen:
|
||
messagebox.showinfo("Konto gelöscht", "Dein Konto ist gelöscht.", parent=self)
|
||
|
||
self.hintergrund.starten(arbeit, fertig,
|
||
lambda fehler: messagebox.showerror("Konto löschen", fehlertext(fehler), parent=self))
|
||
|
||
def sichtbar(self):
|
||
"""Vom Hauptfenster aufgerufen, wenn der Reiter gewaehlt wird."""
|
||
if konto.angemeldet() and time.time() - self._zuletzt_geladen > 20:
|
||
self.aktualisieren()
|
||
|
||
# -- Aufbau -----------------------------------------------------------------------
|
||
|
||
def _inhalt_aufbauen(self):
|
||
kopf = ttk.Frame(self.inhalt)
|
||
kopf.pack(fill="x", pady=(8, 6))
|
||
self.nutzer_var = tk.StringVar()
|
||
ttk.Label(kopf, textvariable=self.nutzer_var, font=FONT_BOLD).pack(side="left")
|
||
konto_menue = ttk.Menubutton(kopf, text="Konto")
|
||
menue = tk.Menu(konto_menue, tearoff=False, bg=PANEL, fg=FG, activebackground=OLIVE_HI,
|
||
activeforeground="#12150f", font=FONT_UI)
|
||
menue.add_command(label="Abmelden", command=self.abmelden)
|
||
menue.add_separator()
|
||
menue.add_command(label="Konto löschen …", command=self.konto_loeschen)
|
||
konto_menue["menu"] = menue
|
||
konto_menue.pack(side="right")
|
||
ttk.Button(kopf, text="Aktualisieren", command=self.aktualisieren).pack(side="right", padx=(0, 6))
|
||
self.status_var = tk.StringVar()
|
||
self.status = ttk.Label(kopf, textvariable=self.status_var, style="Dim.TLabel")
|
||
self.status.pack(side="left", padx=(16, 0))
|
||
|
||
nb = ttk.Notebook(self.inhalt)
|
||
nb.pack(fill="both", expand=True)
|
||
self.nb = nb
|
||
self._charaktere_aufbauen(nb)
|
||
self._squads_aufbauen(nb)
|
||
self._einladungen_aufbauen(nb)
|
||
|
||
def _charaktere_aufbauen(self, nb):
|
||
seite = ttk.Frame(nb, padding=10)
|
||
nb.add(seite, text="Charaktere")
|
||
seite.columnconfigure(0, weight=1)
|
||
seite.rowconfigure(1, weight=1)
|
||
|
||
filter_ = ttk.Frame(seite)
|
||
filter_.grid(row=0, column=0, columnspan=2, sticky="ew", pady=(0, 8))
|
||
self.suche_var = tk.StringVar()
|
||
suche = ttk.Entry(filter_, textvariable=self.suche_var, width=24)
|
||
suche.pack(side="left")
|
||
suche.bind("<Return>", lambda e: self.aktualisieren())
|
||
self.fraktion_var = tk.StringVar(value=ALLE_FRAKTIONEN)
|
||
fraktion = ttk.Combobox(filter_, textvariable=self.fraktion_var, state="readonly", width=28,
|
||
values=[ALLE_FRAKTIONEN] + vorlagen.fraktionsnamen())
|
||
fraktion.pack(side="left", padx=8)
|
||
fraktion.bind("<<ComboboxSelected>>", lambda e: self.aktualisieren())
|
||
fraktion.bind("<MouseWheel>", lambda e: "break")
|
||
ttk.Button(filter_, text="Suchen", command=self.aktualisieren).pack(side="left")
|
||
|
||
rahmen, self.liste = _tabelle(seite, [("name", "Charakter", 170), ("rang", "Dienstgrad", 150),
|
||
("zustand", "Zustand", 90), ("squad", "Squad", 110),
|
||
("spieler", "Spieler", 90)])
|
||
rahmen.grid(row=1, column=0, sticky="nsew")
|
||
self.liste.bind("<<TreeviewSelect>>", lambda e: self._charakter_gewaehlt())
|
||
self.liste.bind("<Double-1>", lambda e: self.akte_ansehen())
|
||
|
||
detail = ttk.Frame(seite, width=240)
|
||
detail.grid(row=1, column=1, sticky="nsew", padx=(12, 0))
|
||
detail.grid_propagate(False)
|
||
self.bild = tk.Label(detail, bg=PANEL, fg=FG_DIM, text="kein\nPorträt", font=FONT_UI,
|
||
width=20, height=10)
|
||
self.bild.pack(anchor="w")
|
||
self.detail_titel = ttk.Label(detail, text="", font=("Segoe UI Semibold", 13), wraplength=230)
|
||
self.detail_titel.pack(anchor="w", pady=(8, 2))
|
||
self.detail_text = ttk.Label(detail, text="Wähle links einen Charakter.", style="Dim.TLabel",
|
||
wraplength=230, justify="left")
|
||
self.detail_text.pack(anchor="w")
|
||
self.knopf_ansehen = ttk.Button(detail, text="Akte ansehen", command=self.akte_ansehen)
|
||
self.knopf_ansehen.pack(anchor="w", fill="x", pady=(10, 4))
|
||
self.knopf_einladen = ttk.Button(detail, text="In mein Squad einladen", style="Accent.TButton",
|
||
command=self.einladen)
|
||
self.knopf_einladen.pack(anchor="w", fill="x")
|
||
self.einladen_hinweis = ttk.Label(detail, text="", style="Dim.TLabel", wraplength=230)
|
||
self.einladen_hinweis.pack(anchor="w", pady=(4, 0))
|
||
self._detail_leeren()
|
||
|
||
def _squads_aufbauen(self, nb):
|
||
seite = ttk.Frame(nb, padding=10)
|
||
nb.add(seite, text="Squads")
|
||
seite.columnconfigure(0, weight=2)
|
||
seite.columnconfigure(1, weight=3)
|
||
seite.rowconfigure(1, weight=1)
|
||
ttk.Button(seite, text="Squad gründen …", style="Accent.TButton",
|
||
command=self.squad_gruenden).grid(row=0, column=0, sticky="w", pady=(0, 8))
|
||
|
||
rahmen, self.squad_liste = _tabelle(seite, [("name", "Squad", 150), ("fuehrer", "Führer", 120),
|
||
("staerke", "Stärke", 55)])
|
||
rahmen.grid(row=1, column=0, sticky="nsew")
|
||
self.squad_liste.bind("<<TreeviewSelect>>", lambda e: self._squad_gewaehlt())
|
||
|
||
rechts = ttk.Frame(seite)
|
||
rechts.grid(row=1, column=1, sticky="nsew", padx=(12, 0))
|
||
rechts.rowconfigure(2, weight=1)
|
||
rechts.columnconfigure(0, weight=1)
|
||
self.squad_titel = ttk.Label(rechts, text="Wähle ein Squad.", font=("Segoe UI Semibold", 13))
|
||
self.squad_titel.grid(row=0, column=0, sticky="w")
|
||
self.squad_beschreibung = ttk.Label(rechts, text="", style="Dim.TLabel", wraplength=420, justify="left")
|
||
self.squad_beschreibung.grid(row=1, column=0, sticky="w", pady=(2, 8))
|
||
rahmen, self.mitglieder = _tabelle(rechts, [("name", "Mitglied", 150), ("rang", "Dienstgrad", 140),
|
||
("zustand", "Zustand", 80), ("spieler", "Spieler", 80)], 8)
|
||
rahmen.grid(row=2, column=0, sticky="nsew")
|
||
self.mitglieder.bind("<<TreeviewSelect>>", lambda e: self._squad_knoepfe())
|
||
knoepfe = ttk.Frame(rechts)
|
||
knoepfe.grid(row=3, column=0, sticky="w", pady=(8, 0))
|
||
self.knopf_entfernen = ttk.Button(knoepfe, text="Entfernen", command=self.mitglied_entfernen)
|
||
self.knopf_uebergeben = ttk.Button(knoepfe, text="Führung übergeben", command=self.fuehrung_uebergeben)
|
||
self.knopf_verlassen = ttk.Button(knoepfe, text="Squad verlassen", command=self.squad_verlassen)
|
||
self.knopf_aufloesen = ttk.Button(knoepfe, text="Squad auflösen", command=self.squad_aufloesen)
|
||
for knopf in (self.knopf_entfernen, self.knopf_uebergeben, self.knopf_verlassen, self.knopf_aufloesen):
|
||
knopf.pack(side="left", padx=(0, 6))
|
||
self._squad_knoepfe()
|
||
|
||
def _einladungen_aufbauen(self, nb):
|
||
seite = ttk.Frame(nb, padding=10)
|
||
nb.add(seite, text="Einladungen")
|
||
self.einladungen_seite = seite
|
||
seite.columnconfigure(0, weight=1)
|
||
seite.rowconfigure(1, weight=1)
|
||
seite.rowconfigure(4, weight=1)
|
||
|
||
ttk.Label(seite, text="ERHALTEN", style="Dim.TLabel").grid(row=0, column=0, sticky="w")
|
||
rahmen, self.eingang = _tabelle(seite, [("squad", "Squad", 170), ("fuer", "Für deinen Charakter", 190),
|
||
("von", "Eingeladen von", 190)], 6)
|
||
rahmen.grid(row=1, column=0, sticky="nsew")
|
||
knoepfe = ttk.Frame(seite)
|
||
knoepfe.grid(row=2, column=0, sticky="w", pady=(6, 14))
|
||
ttk.Button(knoepfe, text="Annehmen", style="Accent.TButton",
|
||
command=lambda: self.einladung_beantworten(True)).pack(side="left", padx=(0, 6))
|
||
ttk.Button(knoepfe, text="Ablehnen", command=lambda: self.einladung_beantworten(False)).pack(side="left")
|
||
|
||
ttk.Label(seite, text="VERSCHICKT", style="Dim.TLabel").grid(row=3, column=0, sticky="w")
|
||
rahmen, self.ausgang = _tabelle(seite, [("squad", "Squad", 170), ("charakter", "Eingeladen", 190),
|
||
("spieler", "Spieler", 190)], 5)
|
||
rahmen.grid(row=4, column=0, sticky="nsew")
|
||
ttk.Button(seite, text="Zurückziehen", command=self.einladung_zurueckziehen).grid(
|
||
row=5, column=0, sticky="w", pady=(6, 0))
|
||
|
||
# -- Laden ------------------------------------------------------------------------
|
||
|
||
def _abgleich_zustand(self, text, art):
|
||
if not self._laedt:
|
||
self.status_var.set(text)
|
||
|
||
def aktualisieren(self):
|
||
if not konto.angemeldet() or self._laedt:
|
||
return
|
||
self._laedt = True
|
||
self.status_var.set("Lädt …")
|
||
suche = self.suche_var.get().strip()
|
||
fraktion = "" if self.fraktion_var.get() == ALLE_FRAKTIONEN else self.fraktion_var.get()
|
||
|
||
def arbeit():
|
||
return (konto.aufrufen("charaktere_alle", suche=suche, fraktion=fraktion)["charaktere"],
|
||
konto.aufrufen("squads")["squads"],
|
||
konto.aufrufen("einladungen"))
|
||
|
||
self.hintergrund.starten(arbeit, self._geladen, self._laden_gescheitert)
|
||
|
||
def _laden_gescheitert(self, fehler):
|
||
self._laedt = False
|
||
if isinstance(fehler, konto.ServerFehler) and fehler.code == "nicht_angemeldet":
|
||
self._abgemeldet()
|
||
return
|
||
self.status_var.set(fehlertext(fehler))
|
||
|
||
def _geladen(self, ergebnis):
|
||
self._laedt = False
|
||
self._zuletzt_geladen = time.time()
|
||
self.charaktere, self.squads, einladungen = ergebnis
|
||
self.einladungen = {"eingang": einladungen.get("eingang", []), "ausgang": einladungen.get("ausgang", [])}
|
||
self.status_var.set(f"{len(self.charaktere)} Charaktere · {len(self.squads)} Squads · "
|
||
f"Stand {time.strftime('%H:%M')}")
|
||
self._liste_fuellen()
|
||
self._squads_fuellen()
|
||
self._einladungen_fuellen()
|
||
|
||
def _ersetzen(self, baum, zeilen):
|
||
auswahl = baum.selection()
|
||
baum.delete(*baum.get_children())
|
||
for iid, werte, tags in zeilen:
|
||
baum.insert("", "end", iid=iid, values=werte, tags=tags)
|
||
if auswahl and baum.exists(auswahl[0]):
|
||
baum.selection_set(auswahl[0])
|
||
|
||
def _liste_fuellen(self):
|
||
zeilen = []
|
||
for c in self.charaktere:
|
||
tags = tuple(t for t in (_zustand_tag(c["status"]), "eigener" if c["eigener"] else "") if t)
|
||
zeilen.append((str(c["id"]), (charakter_name(c), c["rang"], zustand_text(c["status"]),
|
||
(c.get("squad") or {}).get("name", "—"), c["spieler"]), tags))
|
||
self._ersetzen(self.liste, zeilen)
|
||
self._charakter_gewaehlt()
|
||
|
||
def _squads_fuellen(self):
|
||
zeilen = []
|
||
for s in self.squads:
|
||
fuehrer = next((m for m in s["mitglieder"] if m["id"] == s["fuehrer_id"]), None)
|
||
zeilen.append((str(s["id"]), (s["name"], charakter_name(fuehrer) if fuehrer else "—",
|
||
len(s["mitglieder"])), ()))
|
||
self._ersetzen(self.squad_liste, zeilen)
|
||
self._squad_gewaehlt()
|
||
|
||
def _einladungen_fuellen(self):
|
||
self._ersetzen(self.eingang, [
|
||
(str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}),
|
||
charakter_name(e.get("von") or {}) + f" ({(e.get('von') or {}).get('spieler', '?')})"), ())
|
||
for e in self.einladungen["eingang"]])
|
||
self._ersetzen(self.ausgang, [
|
||
(str(e["id"]), ((e.get("squad") or {}).get("name", "?"), charakter_name(e.get("charakter") or {}),
|
||
(e.get("charakter") or {}).get("spieler", "?")), ())
|
||
for e in self.einladungen["ausgang"]])
|
||
anzahl = len(self.einladungen["eingang"])
|
||
self.nb.tab(self.einladungen_seite, text=f"Einladungen ({anzahl})" if anzahl else "Einladungen")
|
||
|
||
# -- Charaktere -------------------------------------------------------------------
|
||
|
||
def _gewaehlter(self):
|
||
auswahl = self.liste.selection()
|
||
return next((c for c in self.charaktere if str(c["id"]) == auswahl[0]), None) if auswahl else None
|
||
|
||
def _eigene_ids(self):
|
||
return {c["id"] for c in self.charaktere if c["eigener"]}
|
||
|
||
def _meine_gefuehrten_squads(self):
|
||
eigene = self._eigene_ids()
|
||
return [s for s in self.squads if s["fuehrer_id"] in eigene]
|
||
|
||
def _detail_leeren(self):
|
||
self.bild.configure(image="", text="kein\nPorträt", width=20, height=10)
|
||
self.detail_titel.configure(text="")
|
||
self.detail_text.configure(text="Wähle links einen Charakter.")
|
||
self.knopf_ansehen.configure(state="disabled")
|
||
self.knopf_einladen.configure(state="disabled")
|
||
self.einladen_hinweis.configure(text="")
|
||
|
||
def _charakter_gewaehlt(self):
|
||
c = self._gewaehlter()
|
||
if c is None:
|
||
self._detail_leeren()
|
||
return
|
||
self.detail_titel.configure(text=c["callsign"] or charakter_name(c))
|
||
zeilen = [
|
||
" ".join(t for t in (c["rang"], c["vorname"], c["nachname"]) if t),
|
||
" · ".join(t for t in (c["fraktion"], c["teilstreitkraft"]) if t),
|
||
c["verwendung"],
|
||
f"Zustand: {zustand_text(c['status'])}",
|
||
f"Squad: {(c.get('squad') or {}).get('name', '—')}",
|
||
f"Spieler: {c['spieler']}" + (" (du)" if c["eigener"] else ""),
|
||
c.get("aktennummer") or "",
|
||
]
|
||
self.detail_text.configure(text="\n".join(z for z in zeilen if z))
|
||
self.knopf_ansehen.configure(state="normal")
|
||
|
||
gefuehrt = self._meine_gefuehrten_squads()
|
||
hinweis = ""
|
||
if c.get("squad"):
|
||
hinweis = "Ist schon in einem Squad."
|
||
elif not gefuehrt:
|
||
hinweis = "Zum Einladen brauchst du ein Squad, das einer deiner Charaktere führt."
|
||
self.knopf_einladen.configure(state="disabled" if hinweis else "normal")
|
||
self.einladen_hinweis.configure(text=hinweis)
|
||
self._bild_zeigen(c)
|
||
|
||
def _bild_zeigen(self, c):
|
||
if not c["portraet"]:
|
||
self.bild.configure(image="", text="kein\nPorträt", width=20, height=10)
|
||
return
|
||
schluessel = (c["id"], c.get("portraet_kennung"))
|
||
if schluessel in self._bilder:
|
||
foto = self._bilder[schluessel][1]
|
||
self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height())
|
||
return
|
||
self.bild.configure(image="", text="lädt …", width=20, height=10)
|
||
|
||
def fertig(daten):
|
||
if not daten:
|
||
return
|
||
with Image.open(io.BytesIO(daten)) as bild:
|
||
foto = ImageTk.PhotoImage(ImageOps.contain(bild.convert("RGBA"), (150, 190)))
|
||
self._bilder[schluessel] = (daten, foto)
|
||
aktuell = self._gewaehlter()
|
||
if aktuell is not None and aktuell["id"] == c["id"]:
|
||
self.bild.configure(image=foto, text="", width=foto.width(), height=foto.height())
|
||
|
||
self.hintergrund.starten(lambda: konto.bild(c["id"]), fertig, lambda f: None)
|
||
|
||
def akte_ansehen(self):
|
||
c = self._gewaehlter()
|
||
if c is None:
|
||
return
|
||
|
||
def arbeit():
|
||
voll = konto.aufrufen("charakter_ansehen", id=c["id"])["charakter"]
|
||
bild = konto.bild(c["id"]) if voll.get("portraet") else None
|
||
return voll, bild
|
||
|
||
self.hintergrund.starten(arbeit, lambda erg: akte_fenster(self, erg[0], erg[1]),
|
||
lambda f: messagebox.showerror("Akte", fehlertext(f), parent=self))
|
||
|
||
def einladen(self):
|
||
c = self._gewaehlter()
|
||
gefuehrt = self._meine_gefuehrten_squads()
|
||
if c is None or not gefuehrt:
|
||
return
|
||
if len(gefuehrt) == 1:
|
||
self._einladen_in(gefuehrt[0], c)
|
||
return
|
||
menue = tk.Menu(self, tearoff=False)
|
||
for squad in gefuehrt:
|
||
menue.add_command(label=squad["name"], command=lambda s=squad: self._einladen_in(s, c))
|
||
knopf = self.knopf_einladen
|
||
menue.tk_popup(knopf.winfo_rootx(), knopf.winfo_rooty() + knopf.winfo_height())
|
||
|
||
def _einladen_in(self, squad, c):
|
||
self._aktion(lambda: konto.aufrufen("squad_einladen", squad_id=squad["id"], charakter_id=c["id"]),
|
||
f"{charakter_name(c)} ist zu {squad['name']} eingeladen. Der Spieler muss annehmen.")
|
||
|
||
# -- Squads -----------------------------------------------------------------------
|
||
|
||
def _gewaehltes_squad(self):
|
||
auswahl = self.squad_liste.selection()
|
||
return next((s for s in self.squads if str(s["id"]) == auswahl[0]), None) if auswahl else None
|
||
|
||
def _squad_gewaehlt(self):
|
||
s = self._gewaehltes_squad()
|
||
if s is None:
|
||
self.squad_titel.configure(text="Wähle ein Squad." if self.squads else "Noch keine Squads.")
|
||
self.squad_beschreibung.configure(text="")
|
||
self._ersetzen(self.mitglieder, [])
|
||
else:
|
||
self.squad_titel.configure(text=s["name"])
|
||
self.squad_beschreibung.configure(text=s.get("beschreibung") or "")
|
||
# Der Fuehrer steht immer oben, die anderen in Reihenfolge des Beitritts
|
||
mitglieder = sorted(s["mitglieder"], key=lambda m: m["id"] != s["fuehrer_id"])
|
||
self._ersetzen(self.mitglieder, [
|
||
(str(m["id"]), (("★ " if m["id"] == s["fuehrer_id"] else "") + charakter_name(m), m["rang"],
|
||
zustand_text(m["status"]), m["spieler"]),
|
||
tuple(t for t in (_zustand_tag(m["status"]), "eigener" if m["eigener"] else "") if t))
|
||
for m in mitglieder])
|
||
self._squad_knoepfe()
|
||
|
||
def _gewaehltes_mitglied(self, squad):
|
||
auswahl = self.mitglieder.selection()
|
||
if squad is None or not auswahl:
|
||
return None
|
||
return next((m for m in squad["mitglieder"] if str(m["id"]) == auswahl[0]), None)
|
||
|
||
def _squad_knoepfe(self):
|
||
s = self._gewaehltes_squad()
|
||
eigene = self._eigene_ids()
|
||
fuehre = s is not None and s["fuehrer_id"] in eigene
|
||
mitglied = self._gewaehltes_mitglied(s)
|
||
fremdes_mitglied = mitglied is not None and mitglied["id"] != s["fuehrer_id"]
|
||
mein_mitglied = s is not None and any(m["id"] in eigene and m["id"] != s["fuehrer_id"]
|
||
for m in s["mitglieder"])
|
||
self.knopf_entfernen.configure(state="normal" if fuehre and fremdes_mitglied else "disabled")
|
||
self.knopf_uebergeben.configure(state="normal" if fuehre and fremdes_mitglied else "disabled")
|
||
self.knopf_aufloesen.configure(state="normal" if fuehre else "disabled")
|
||
self.knopf_verlassen.configure(state="normal" if mein_mitglied or (fuehre and len(s["mitglieder"]) == 1)
|
||
else "disabled")
|
||
|
||
def squad_gruenden(self):
|
||
frei = [c for c in self.charaktere if c["eigener"] and not c.get("squad")]
|
||
if not frei:
|
||
messagebox.showinfo("Squad gründen",
|
||
"Du brauchst einen eigenen Charakter ohne Squad. Neue Akten erscheinen "
|
||
"hier, sobald sie mit dem Server abgeglichen sind.", parent=self)
|
||
return
|
||
fenster = tk.Toplevel(self)
|
||
fenster.title("Squad gründen")
|
||
fenster.configure(bg=BG)
|
||
fenster.resizable(False, False)
|
||
fenster.transient(self.winfo_toplevel())
|
||
f = ttk.Frame(fenster, padding=18)
|
||
f.pack(fill="both")
|
||
ttk.Label(f, text="Name des Squads").grid(row=0, column=0, sticky="w", pady=5, padx=(0, 12))
|
||
name_var = tk.StringVar()
|
||
name = ttk.Entry(f, textvariable=name_var, width=36)
|
||
name.grid(row=0, column=1, sticky="ew", pady=5)
|
||
ttk.Label(f, text="Geführt von").grid(row=1, column=0, sticky="w", pady=5, padx=(0, 12))
|
||
namen = [charakter_name(c) for c in frei]
|
||
fuehrer_var = tk.StringVar(value=namen[0])
|
||
ttk.Combobox(f, textvariable=fuehrer_var, values=namen, state="readonly", width=34).grid(
|
||
row=1, column=1, sticky="ew", pady=5)
|
||
ttk.Label(f, text="Beschreibung").grid(row=2, column=0, sticky="nw", pady=5, padx=(0, 12))
|
||
beschreibung = tk.Text(f, width=36, height=4, **akte.TEXT_STIL)
|
||
beschreibung.grid(row=2, column=1, sticky="ew", pady=5)
|
||
|
||
def gruenden():
|
||
c = frei[namen.index(fuehrer_var.get())]
|
||
text = beschreibung.get("1.0", "end-1c").strip()
|
||
wert = name_var.get().strip()
|
||
fenster.destroy()
|
||
self._aktion(lambda: konto.aufrufen("squad_gruenden", charakter_id=c["id"], name=wert,
|
||
beschreibung=text),
|
||
f"Squad {wert} gegründet.")
|
||
|
||
knoepfe = ttk.Frame(f)
|
||
knoepfe.grid(row=3, column=0, columnspan=2, sticky="e", pady=(12, 0))
|
||
ttk.Button(knoepfe, text="Abbrechen", command=fenster.destroy).pack(side="right")
|
||
ttk.Button(knoepfe, text="Gründen", style="Accent.TButton", command=gruenden).pack(side="right", padx=(0, 8))
|
||
fenster.bind("<Escape>", lambda e: fenster.destroy())
|
||
dialog_zentrieren(fenster, self)
|
||
fenster.grab_set()
|
||
name.focus_set()
|
||
|
||
def mitglied_entfernen(self):
|
||
s = self._gewaehltes_squad()
|
||
m = self._gewaehltes_mitglied(s)
|
||
if m and messagebox.askyesno("Entfernen", f"{charakter_name(m)} aus {s['name']} entfernen?", parent=self):
|
||
self._aktion(lambda: konto.aufrufen("squad_entfernen", squad_id=s["id"], charakter_id=m["id"]),
|
||
f"{charakter_name(m)} wurde entfernt.")
|
||
|
||
def fuehrung_uebergeben(self):
|
||
s = self._gewaehltes_squad()
|
||
m = self._gewaehltes_mitglied(s)
|
||
if m and messagebox.askyesno("Führung übergeben",
|
||
f"Die Führung von {s['name']} an {charakter_name(m)} übergeben?", parent=self):
|
||
self._aktion(lambda: konto.aufrufen("squad_fuehrung_uebergeben", squad_id=s["id"], charakter_id=m["id"]),
|
||
f"{charakter_name(m)} führt jetzt {s['name']}.")
|
||
|
||
def squad_verlassen(self):
|
||
s = self._gewaehltes_squad()
|
||
if s is None:
|
||
return
|
||
eigene = [m for m in s["mitglieder"] if m["eigener"]]
|
||
# Wer allein fuehrt, verlaesst das Squad damit auch - es wird aufgeloest
|
||
kandidaten = [m for m in eigene if m["id"] != s["fuehrer_id"]] or eigene
|
||
if not kandidaten:
|
||
return
|
||
m = kandidaten[0]
|
||
if messagebox.askyesno("Squad verlassen", f"{charakter_name(m)} verlässt {s['name']}?", parent=self):
|
||
self._aktion(lambda: konto.aufrufen("squad_verlassen", charakter_id=m["id"]),
|
||
f"{charakter_name(m)} hat {s['name']} verlassen.")
|
||
|
||
def squad_aufloesen(self):
|
||
s = self._gewaehltes_squad()
|
||
if s and messagebox.askyesno("Squad auflösen",
|
||
f"{s['name']} auflösen? Alle Mitglieder sind danach ohne Squad.", parent=self):
|
||
self._aktion(lambda: konto.aufrufen("squad_aufloesen", squad_id=s["id"]), f"{s['name']} wurde aufgelöst.")
|
||
|
||
# -- Einladungen ------------------------------------------------------------------
|
||
|
||
def einladung_beantworten(self, annehmen):
|
||
auswahl = self.eingang.selection()
|
||
if not auswahl:
|
||
return
|
||
e = next((x for x in self.einladungen["eingang"] if str(x["id"]) == auswahl[0]), None)
|
||
if e is None:
|
||
return
|
||
squad = (e.get("squad") or {}).get("name", "das Squad")
|
||
self._aktion(lambda: konto.aufrufen("einladung_beantworten", einladung_id=e["id"], annehmen=annehmen),
|
||
f"Willkommen in {squad}." if annehmen else "Einladung abgelehnt.")
|
||
|
||
def einladung_zurueckziehen(self):
|
||
auswahl = self.ausgang.selection()
|
||
if auswahl:
|
||
self._aktion(lambda: konto.aufrufen("einladung_zurueckziehen", einladung_id=int(auswahl[0])),
|
||
"Einladung zurückgezogen.")
|
||
|
||
# -- Gemeinsam --------------------------------------------------------------------
|
||
|
||
def _aktion(self, arbeit, erfolg):
|
||
self.status_var.set("Einen Moment …")
|
||
|
||
def fertig(_):
|
||
self.status_var.set(erfolg)
|
||
self._laedt = False
|
||
self.aktualisieren()
|
||
|
||
def fehler(f):
|
||
if isinstance(f, konto.ServerFehler) and f.code == "nicht_angemeldet":
|
||
self._abgemeldet()
|
||
return
|
||
self.status_var.set("")
|
||
messagebox.showerror("Squad", fehlertext(f), parent=self)
|
||
self.aktualisieren()
|
||
|
||
self.hintergrund.starten(arbeit, fertig, fehler)
|