# -*- coding: utf-8 -*- """Farben nach dem Windows-Theme (hell/dunkel) - inklusive Titelleiste. Native tk-Menues und -Popups lassen sich unter Windows nicht einfaerben, darum baut das Programm Menueleiste und Dropdowns selbst; hier stehen nur die Farben. """ import ctypes.wintypes import os import sys import tkinter as tk from tkinter import font as tkfont from tkinter import messagebox from tkinter import ttk # --------------------------------------------------------------------------- # Diese Datei liegt in BEIDEN Programmen gleich und darf deshalb NICHTS aus # einem der beiden importieren. Frueher holte sie sich die Ordner und den # Testlauf-Schalter aus config.py - die gibt es aber nur im Rechnungstool, und # beim Uebernehmen ins Steuerrechnungstool flog sie beim Import auseinander. # Die zwei Dinge, die gebraucht werden, stehen jetzt hier. # --------------------------------------------------------------------------- def _ordner(): """Alle Orte, an denen assets/ liegen kann - Quelle wie gepackte EXE.""" hier = os.path.dirname(os.path.abspath(__file__)) aus_exe = getattr(sys, "_MEIPASS", "") neben_exe = (os.path.dirname(os.path.abspath(sys.executable)) if getattr(sys, "frozen", False) else "") return [p for p in (aus_exe, neben_exe, hier) if p] def titelleiste_faerben(fenster, dunkel): """Die Titelleiste des Fensters mit einfaerben (Windows 10 ab 1809). Tk kann das nicht - die Leiste mit Symbol, Titel und den drei Knoepfen gehoert Windows, nicht dem Programm. Windows nimmt dafuer aber einen Hinweis entgegen: DWMWA_USE_IMMERSIVE_DARK_MODE. Ohne den steht ein weisser Balken ueber einem dunklen Fenster (sein Befund am 07.09.2026: "der icon und titel leiste auch ... die sind noch hell"). Die Nummer des Attributs hat sich einmal geaendert: 19 in den fruehen 1809er-Fassungen, 20 seit 2004. Beide werden gesetzt; die falsche wird ignoriert. """ if not sys.platform.startswith("win"): return False try: fenster.update_idletasks() hwnd = ctypes.windll.user32.GetParent(fenster.winfo_id()) or int(fenster.frame(), 16) wert = ctypes.c_int(1 if dunkel else 0) gesetzt = False for attribut in (20, 19): ergebnis = ctypes.windll.dwmapi.DwmSetWindowAttribute( ctypes.wintypes.HWND(hwnd), ctypes.c_int(attribut), ctypes.byref(wert), ctypes.sizeof(wert)) gesetzt = gesetzt or ergebnis == 0 # Den Rahmen neu zeichnen lassen, ohne Groesse, Platz, Reihenfolge oder # Fokus anzufassen. Ohne das bleibt die Leiste stehen, wie sie war - # die Umstellung wirkt dann erst beim naechsten Start. SWP = 0x0001 | 0x0002 | 0x0004 | 0x0020 # NOSIZE|NOMOVE|NOZORDER|FRAMECHANGED ctypes.windll.user32.SetWindowPos(hwnd, 0, 0, 0, 0, 0, SWP) return gesetzt except Exception: # noqa: BLE001 - ohne dunkle Titelleiste laeuft es weiter return False def pruefplatz(): """Wo ein Pruefstand seine Fenster aufmachen soll: "+x+y" oder "". Seine Ansage am 07.09.2026: *"teste links auf dem 1080p monitor nicht mehr auf dem main ... weil da schau ich nun video"*. Vorher lag der Platz bei `Bildschirmbreite + 20` - also RECHTS neben dem Hauptmonitor. Bei ihm steht der zweite Monitor aber LINKS (x = -1920), und rechts ist gar nichts: die Fenster gingen ins Leere. Sie liefen zwar, waren aber nirgends zu sehen - das hat beim Bildermachen einige Zeit gekostet. Gesucht wird deshalb der nicht-primaere Monitor. Gibt es keinen, bleibt es beim alten Verhalten (neben den Bildschirm), denn im Weg sein soll ein Pruefstand auch dann nicht. """ if not sys.platform.startswith("win"): return "" try: class RECT(ctypes.Structure): _fields_ = [("left", ctypes.c_long), ("top", ctypes.c_long), ("right", ctypes.c_long), ("bottom", ctypes.c_long)] class MONITORINFO(ctypes.Structure): _fields_ = [("cbSize", ctypes.wintypes.DWORD), ("rcMonitor", RECT), ("rcWork", RECT), ("dwFlags", ctypes.wintypes.DWORD)] gefunden = [] def je_monitor(hmon, hdc, lprect, daten): info = MONITORINFO() info.cbSize = ctypes.sizeof(MONITORINFO) if ctypes.windll.user32.GetMonitorInfoW(hmon, ctypes.byref(info)): r = info.rcWork gefunden.append((bool(info.dwFlags & 1), # 1 = MONITORINFOF_PRIMARY r.left, r.top, r.right - r.left)) return 1 RUECKRUF = ctypes.WINFUNCTYPE(ctypes.c_int, ctypes.wintypes.HMONITOR, ctypes.wintypes.HDC, ctypes.POINTER(RECT), ctypes.wintypes.LPARAM) ctypes.windll.user32.EnumDisplayMonitors(0, 0, RUECKRUF(je_monitor), 0) # Der breiteste Nebenmonitor - bei mehreren der linkeste. neben = sorted((m for m in gefunden if not m[0]), key=lambda m: (-m[3], m[1])) if neben: _, x, y, _ = neben[0] return f"+{x + 30}+{y + 40}" except Exception: # noqa: BLE001 - dann eben der alte Weg pass return "" def auf_bildschirm(x, y, breite=0, hoehe=0): """Eine Fensterposition auf den sichtbaren Bereich begrenzen. Frueher stand an diesen Stellen `max(0, x)`. Das sollte verhindern, dass ein Dialog ausserhalb des Bildschirms aufgeht - klemmt aber jede NEGATIVE Koordinate auf null. Steht der zweite Monitor links (bei ihm x = -1920), sprang damit jedes Popup zurueck auf den Hauptbildschirm, obwohl das Programm nebenan lief. Sein Befund am 07.09.2026: *"da gehen noch die popups auf dem video monitor auf"*. Begrenzt wird deshalb auf den GESAMTEN Desktop ueber alle Monitore (SM_*VIRTUALSCREEN), nicht auf den Hauptmonitor. """ if not sys.platform.startswith("win"): return int(x), int(y) try: hole = ctypes.windll.user32.GetSystemMetrics links, oben = hole(76), hole(77) rechts, unten = links + hole(78), oben + hole(79) if breite: x = min(x, rechts - breite) if hoehe: y = min(y, unten - hoehe) return int(max(links, x)), int(max(oben, y)) except Exception: # noqa: BLE001 - dann eben ungebremst return int(x), int(y) def mittig(dialog, ueber): """Einen Dialog mittig ueber sein Elternfenster setzen. Seine Ansage am 07.09.2026: *"einfach so programmieren das die popup auf dem fenster mittig vom main fenster auf gehen"*. Das ist zugleich die Antwort auf die Monitorfrage: steht das Programm auf dem zweiten Bildschirm, geht der Dialog dort auf - ohne dass irgendwo ein Monitor gesucht werden muesste. Vorher standen an den Dialogen feste Versaetze ("+120+140") und ein `max(0, x)`, das jede negative Koordinate auf null klemmte und die Fenster damit auf den Hauptmonitor zurueckriss. Etwas oberhalb der Mitte (ein Drittel statt der Haelfte): so sitzt der Dialog dort, wo der Blick ohnehin ist, und verdeckt nicht die Mitte des Formulars darunter. """ try: dialog.update_idletasks() breite = dialog.winfo_reqwidth() or dialog.winfo_width() hoehe = dialog.winfo_reqheight() or dialog.winfo_height() x = ueber.winfo_rootx() + (ueber.winfo_width() - breite) // 2 y = ueber.winfo_rooty() + (ueber.winfo_height() - hoehe) // 3 x, y = auf_bildschirm(x, y, breite, hoehe) dialog.geometry(f"+{x}+{y}") except tk.TclError: pass # Fenster schon zu - dann ist die Position gleichgueltig def testlauf(): """Faehrt gerade ein Pruefstand das Programm? Muss mit der Definition in app.py uebereinstimmen - beide Programme schalten ueber `--test` oder die Umgebungsvariable. """ return ("--test" in sys.argv) or os.environ.get("CAMPINGHOF_TEST") == "1" # Schrift: Roboto, so wie in den Web-Oberflaechen. Sie wird NICHT auf dem # Rechner installiert, sondern nur fuer diesen einen Prozess geladen (die # Windows-Funktion AddFontResourceEx mit FR_PRIVATE). Damit braucht niemand # Adminrechte, und nach dem Schliessen ist der Rechner wieder wie vorher. # Findet sich die Datei nicht, bleibt es bei Segoe UI - das Programm muss auch # ohne mitgelieferte Schrift laufen. SCHRIFT_NAME = "Segoe UI" SCHRIFT = (SCHRIFT_NAME, 10) KLEIN = (SCHRIFT_NAME, 9) _schrift_geladen = False def schrift_vorbereiten(): """Roboto laden und zur Schrift des Programms machen. Gibt den Namen zurueck.""" global SCHRIFT_NAME, SCHRIFT, KLEIN, _schrift_geladen if _schrift_geladen: return SCHRIFT_NAME _schrift_geladen = True if not sys.platform.startswith("win"): return SCHRIFT_NAME FR_PRIVATE = 0x10 geladen = 0 for basis in _ordner(): ordner = os.path.join(basis, "assets", "fonts") if not os.path.isdir(ordner): continue for datei in sorted(os.listdir(ordner)): if datei.lower().endswith((".ttf", ".otf")): geladen += ctypes.windll.gdi32.AddFontResourceExW( os.path.join(ordner, datei), FR_PRIVATE, 0) if geladen: break if not geladen: print("[schrift] Roboto nicht gefunden - bleibe bei Segoe UI") return SCHRIFT_NAME # Ob Windows sie wirklich angenommen hat, verraet erst die Schriftenliste. if "Roboto" not in tkfont.families(): print("[schrift] Roboto liess sich nicht laden - bleibe bei Segoe UI") return SCHRIFT_NAME SCHRIFT_NAME = "Roboto" SCHRIFT = (SCHRIFT_NAME, 10) KLEIN = (SCHRIFT_NAME, 9) for name in ("TkDefaultFont", "TkTextFont", "TkMenuFont", "TkHeadingFont", "TkIconFont", "TkTooltipFont"): try: tkfont.nametofont(name).configure(family=SCHRIFT_NAME, size=10) except tk.TclError: pass print("[schrift] Roboto geladen") return SCHRIFT_NAME def mischen(vorn, hinten, anteil): """Wie 'rgba(vorn, anteil)' auf 'hinten' - nur ausgerechnet statt gemalt. Tk kann keine halbdurchsichtigen Flaechen (kein backdrop-filter, keine Alpha-Kanaele auf Widgets). Seine Web-Oberflaechen bauen den Glas-Effekt aus genau zwei Zutaten: eine getoente Flaeche und ein feiner Rand in Akzent-Transparenz. Beides laesst sich vorher ausrechnen - das Ergebnis sieht identisch aus, solange der Grund einfarbig ist. Und der ist es hier. """ v = vorn.lstrip("#") h = hinten.lstrip("#") teile = [] for i in (0, 2, 4): a = int(v[i:i + 2], 16) b = int(h[i:i + 2], 16) teile.append(round(a * anteil + b * (1 - anteil))) return "#%02x%02x%02x" % tuple(teile) def windows_dark_mode(): """True, wenn Windows auf das dunkle App-Theme eingestellt ist.""" if not sys.platform.startswith("win"): return False try: import winreg with winreg.OpenKey(winreg.HKEY_CURRENT_USER, r"Software\Microsoft\Windows\CurrentVersion\Themes\Personalize") as k: return winreg.QueryValueEx(k, "AppsUseLightTheme")[0] == 0 except OSError: return False # --------------------------------------------------------------------------- # Welche Darstellung ist gewuenscht? # --------------------------------------------------------------------------- # Drei Moeglichkeiten, gespeichert in der config unter "darstellung": # # "auto" - folgt Windows (Voreinstellung, wie es bisher immer war) # "hell" - immer hell # "dunkel" - immer dunkel # # "auto" ist die Voreinstellung, weil sich das Programm dann verhaelt wie jedes # andere: wer sein Windows abends auf dunkel stellt, bekommt es auch hier. MODI = ("auto", "hell", "dunkel") MODUS_NAMEN = {"auto": "Automatisch (wie Windows)", "hell": "Hell", "dunkel": "Dunkel"} def modus(cfg): """Der eingestellte Modus - immer einer aus MODI.""" wert = str((cfg or {}).get("darstellung", "auto")).strip().lower() return wert if wert in MODI else "auto" def ist_dunkel(cfg): """Soll dunkel gezeichnet werden? Die eine Stelle, die das entscheidet.""" m = modus(cfg) if m == "hell": return False if m == "dunkel": return True return windows_dark_mode() class ThemeMixin: """Farben setzen. Erwartet ein tk.Tk als Basis.""" # ----------------------------------------------------------------- Theme def _apply_theme(self): """Farben passend zur Einstellung setzen (hell, dunkel oder wie Windows).""" schrift_vorbereiten() # Roboto, sonst Segoe UI dark = ist_dunkel(getattr(self, "cfg", None)) self._dark_mode = dark # Die Farben sind die aus seinen anderen Sachen (FiveM-Oberflaechen, # Adminpage, Webseiten): Tuerkis #06C6A4 auf sehr dunklen, gestuften # Flaechen. Das PROGRAMM traegt diese Handschrift - die RECHNUNG traegt # die Farbe der jeweiligen Firma (Einstellungen -> Farbe der Rechnung). # Beides zu vermischen waere falsch: das Blatt gehoert dem Kunden. if dark: self.col_bg = "#0d0e10" # Fenster-Hintergrund (tiefstes Grau) self.col_card = "#15171b" # Kachel / Abschnitt self.col_fg = "#e8e8ea" # Schrift self.col_field = "#2c2e32" # Eingabefelder (heller als die Kachel) self.col_feldrand = "#57585b" # Rahmen der Eingabefelder self.col_sel = "#1f3d38" # aktiv/hover (Akzent, stark abgedunkelt) self.col_accent = "#06C6A4" # Akzent (Pcore-Tuerkis) self.col_accent_hell = "#08dbb5" self.col_auf_accent = "#08221d" # Schrift AUF der Akzentflaeche self.col_gefahr = "#e85a5a" self.col_line = "#25282e" self.col_scroll = "#2f333a" self.col_muted = "#8a8e96" self.col_zebra = "#232830" # jede zweite Zeile der Liste else: self.col_bg = "#eef0f3" self.col_card = "#ffffff" self.col_fg = "#14161a" self.col_field = "#ffffff" self.col_feldrand = "#b9bec6" self.col_sel = "#d7f5ee" self.col_accent = "#04886f" # dunkler, damit es auf Weiss lesbar ist self.col_accent_hell = "#06C6A4" self.col_auf_accent = "#ffffff" self.col_gefahr = "#c0392b" self.col_line = "#d8dce1" self.col_scroll = "#c2c6cc" self.col_muted = "#5c626b" self.col_zebra = "#e4e8ee" self.configure(bg=self.col_bg) # Die Titelleiste gehoert Windows - sie muss eigens umgestellt werden. titelleiste_faerben(self, dark) # Und das Fenstersymbol: in der dunklen Titelleiste geht die dunkle # Haelfte des Zeichens sonst unter. Es haengt hier und nicht im # __init__, damit es beim Umschalten mitgeht - dort wird _apply_theme # erneut gerufen, das __init__ nicht. symbol = getattr(self, "_fenstersymbol", None) if callable(symbol): symbol() style = ttk.Style(self) try: style.theme_use("clam") except tk.TclError: pass bg, fg, field, sel, accent = (self.col_bg, self.col_fg, self.col_field, self.col_sel, self.col_accent) style.configure(".", background=bg, foreground=fg, fieldbackground=field, bordercolor=self.col_line, lightcolor=bg, darkcolor=bg) style.configure("TFrame", background=bg) style.configure("TLabel", background=bg, foreground=fg, font=SCHRIFT) style.configure("TLabelframe", background=bg, bordercolor=self.col_line) style.configure("TLabelframe.Label", background=bg, foreground=accent) # --- Kacheln: ein Abschnitt ist eine Flaeche mit Rand, keine Linie --- style.configure("Karte.TFrame", background=self.col_card, bordercolor=self.col_line, relief="solid", borderwidth=1) # Ein Abschnitt ist eine Kachel: eigene Flaeche, feiner Rand, die # Ueberschrift in Akzentfarbe - genau wie die Kacheln in den # Web-Oberflaechen. # Der Kasten, den man gerade in der Hand hat: blass, gestrichelt. style.configure("Gegriffen.TFrame", background=self.col_bg, bordercolor=self.col_muted, relief="solid", borderwidth=1, lightcolor=self.col_muted, darkcolor=self.col_muted) # Der Kasten, auf den beim Anordnen gerade gezielt wird. style.configure("Ziel.TFrame", background=self.col_card, bordercolor=accent, relief="solid", borderwidth=2, lightcolor=accent, darkcolor=accent) style.configure("Karte.TLabelframe", background=self.col_card, bordercolor=self.col_line, relief="solid", borderwidth=1, lightcolor=self.col_card, darkcolor=self.col_card) style.configure("Karte.TLabelframe.Label", background=self.col_card, foreground=accent, font=(SCHRIFT_NAME, 9, "bold")) style.configure("Karte.TEntry", fieldbackground=field, foreground=fg) style.configure("Karte.TLabel", background=self.col_card, foreground=fg, font=SCHRIFT) style.configure("KarteMuted.TLabel", background=self.col_card, foreground=self.col_muted, font=KLEIN) # Ueberschrift eines Abschnitts: klein, gross geschrieben, in Akzentfarbe - # so wie die Kachelkoepfe in den Web-Oberflaechen. style.configure("Abschnitt.TLabel", background=self.col_card, foreground=accent, font=(SCHRIFT_NAME, 9, "bold")) style.configure("Wert.TLabel", background=self.col_card, foreground=fg, font=(SCHRIFT_NAME, 10)) style.configure("Summe.TLabel", background=bg, foreground=accent, font=(SCHRIFT_NAME, 15, "bold")) style.configure("Zebra.TLabel", background=self.col_zebra, foreground=fg, font=SCHRIFT) # --- Knoepfe im Glas-Stil (wie in seinen Oberflaechen) --- # Getoente Flaeche, feiner Rand in Akzent-Transparenz, Schrift in der # Akzentfarbe. Kein Vollton: der wirkt in dieser Palette wie ein # Fremdkoerper. glas = mischen(accent, bg, 0.10) # ruhige Flaeche glas_hover = mischen(accent, bg, 0.20) rand = mischen(accent, bg, 0.35) rand_hell = mischen(accent, bg, 0.55) style.configure("TButton", background=glas, foreground=fg, bordercolor=rand, padding=(14, 7), font=SCHRIFT, focuscolor=rand, relief="solid", borderwidth=1, lightcolor=rand, darkcolor=rand) style.map("TButton", background=[("pressed", mischen(accent, bg, 0.28)), ("active", glas_hover)], bordercolor=[("active", rand_hell)], lightcolor=[("active", rand_hell)], darkcolor=[("active", rand_hell)], foreground=[("disabled", self.col_muted)]) # Der Knopf, um den es geht: dieselbe Glasflaeche, aber kraeftiger # getoent, mit Akzentrand und Akzentschrift. haupt = mischen(accent, bg, 0.22) style.configure("Haupt.TButton", background=haupt, foreground=self.col_accent_hell, bordercolor=self.col_accent, lightcolor=self.col_accent, darkcolor=self.col_accent, relief="solid", borderwidth=1, padding=(18, 8), font=(SCHRIFT_NAME, 10, "bold")) style.map("Haupt.TButton", background=[("pressed", mischen(accent, bg, 0.45)), ("active", mischen(accent, bg, 0.34)), ("disabled", bg)], foreground=[("disabled", self.col_muted)]) # Storno greift in eine ausgestellte Rechnung ein - gleicher Stil, rot. g_rot = mischen(self.col_gefahr, bg, 0.10) style.configure("Gefahr.TButton", background=g_rot, foreground=self.col_gefahr, bordercolor=mischen(self.col_gefahr, bg, 0.35), lightcolor=mischen(self.col_gefahr, bg, 0.35), darkcolor=mischen(self.col_gefahr, bg, 0.35), relief="solid", borderwidth=1, padding=(14, 7), font=SCHRIFT) style.map("Gefahr.TButton", background=[("pressed", mischen(self.col_gefahr, bg, 0.30)), ("active", mischen(self.col_gefahr, bg, 0.20))], bordercolor=[("active", mischen(self.col_gefahr, bg, 0.55))], lightcolor=[("active", mischen(self.col_gefahr, bg, 0.55))], darkcolor=[("active", mischen(self.col_gefahr, bg, 0.55))]) style.configure("Menu.TMenubutton", background=bg, foreground=fg, relief="flat", arrowcolor=bg, padding=(10, 3)) style.map("Menu.TMenubutton", background=[("active", sel)], foreground=[("active", fg)]) style.configure("TCheckbutton", background=bg, foreground=fg) style.map("TCheckbutton", background=[("active", bg)], foreground=[("active", fg)]) # Eingabefelder heben sich vom Grund ab - sonst sieht man nicht, wo etwas # einzutragen ist. JEDES Feld, in das man tippen kann, traegt diese zwei # Farben: die ttk-Felder ueber die Stile hier, die klassischen Widgets # (Textfelder, Auswahlliste) ueber feld_optionen() weiter unten. feld_hell, feld_rand = self.col_field, self.col_feldrand style.configure("TEntry", fieldbackground=feld_hell, foreground=fg, insertcolor=fg, bordercolor=feld_rand, lightcolor=feld_rand, darkcolor=feld_rand, relief="solid", borderwidth=1, padding=5) style.map("TEntry", bordercolor=[("focus", accent)], lightcolor=[("focus", accent)], darkcolor=[("focus", accent)], fieldbackground=[("focus", mischen(accent, self.col_card, 0.10))]) # Die Felder IN der Leistungsliste stehen auf den Zeilenstreifen und # gingen darin unter - man sah nicht, wo man tippt. Sie bekommen einen # helleren Grund und einen deutlichen Rahmen, beim Tippen den Akzent. style.configure("Liste.TEntry", fieldbackground=feld_hell, foreground=fg, insertcolor=fg, bordercolor=feld_rand, lightcolor=feld_rand, darkcolor=feld_rand, relief="solid", borderwidth=1, padding=4) style.map("Liste.TEntry", bordercolor=[("focus", accent)], lightcolor=[("focus", accent)], darkcolor=[("focus", accent)], fieldbackground=[("focus", mischen(accent, self.col_card, 0.10))]) # Bei state="readonly" zeichnet die Combobox ihren Text als MARKIERUNG, # sobald sie den Fokus hat - ohne diese beiden Farben steht der Wert # unsichtbar im Feld. style.configure("TCombobox", fieldbackground=feld_hell, foreground=fg, background=feld_hell, arrowcolor=fg, bordercolor=feld_rand, lightcolor=feld_rand, darkcolor=feld_rand, selectbackground=feld_hell, selectforeground=fg, padding=3) style.map("TCombobox", fieldbackground=[("readonly", feld_hell)], foreground=[("readonly", fg)], background=[("readonly", feld_hell)], bordercolor=[("focus", accent)], selectbackground=[("readonly", feld_hell)], selectforeground=[("readonly", fg)]) # Die aufgeklappte Liste ist ein klassisches tk-Listbox-Widget self.option_add("*TCombobox*Listbox.background", feld_hell) self.option_add("*TCombobox*Listbox.foreground", fg) self.option_add("*TCombobox*Listbox.selectBackground", sel) self.option_add("*TCombobox*Listbox.selectForeground", fg) for sbs in ("Vertical.TScrollbar", "Horizontal.TScrollbar", "TScrollbar"): style.configure(sbs, troughcolor=bg, background=self.col_scroll, bordercolor=bg, lightcolor=bg, darkcolor=bg, arrowcolor=fg, relief="flat", gripcount=0) style.map(sbs, background=[("active", accent)], troughcolor=[("disabled", bg)]) # Treeview - die Tabelle des Steuerrechnungstools. Ohne diesen Block # bleibt sie weiss im dunklen Fenster: ttk zeichnet Listen nicht ueber # den "."-Grundstil, sondern nur ueber den eigenen. style.configure("Treeview", background=self.col_card, fieldbackground=self.col_card, foreground=fg, bordercolor=self.col_line, rowheight=24, font=SCHRIFT) style.configure("Treeview.Heading", background=bg, foreground=accent, relief="flat", font=(SCHRIFT_NAME, 9, "bold")) style.map("Treeview.Heading", background=[("active", self.col_sel)]) style.map("Treeview", background=[("selected", self.col_sel)], foreground=[("selected", fg)]) # Der Rahmen um die Liste - ttk zeichnet ihn sonst im Systemgrau. style.configure("Treeview.field", bordercolor=self.col_line) style.configure("TSeparator", background=self.col_line) # Reiter (Campingrechnung / Montage): ohne eigene Farben zeichnet clam den # AKTIVEN Reiter dunkler als die ruhenden - man sieht dann nicht, wo man # ist. Der offene Reiter bekommt darum den Hintergrund des Blattes und die # Akzentfarbe, die ruhenden bleiben zurueckgenommen. style.configure("TNotebook", background=bg, bordercolor=self.col_line, tabmargins=(2, 4, 2, 0), borderwidth=0) # Der OFFENE Reiter gehoert zur Kachel darunter und ist deshalb heller # als die ruhenden. Vorher war es andersherum: die ruhenden lagen auf der # helleren Flaeche und sahen aus, als waeren sie ausgewaehlt. # ⚠️ clam zeichnet die Reiterflaeche aus lightcolor/darkcolor, nicht aus # background allein - werden die nicht mitgesetzt, bleibt der ruhende # Reiter hell und sieht aus wie der ausgewaehlte. style.configure("TNotebook.Tab", background=bg, lightcolor=bg, darkcolor=bg, foreground=self.col_muted, bordercolor=self.col_line, # Schmal genug, dass zwoelf Monatsreiter nebeneinander # passen: bei (20, 9) waren "September" und "Dezember" # im Steuerrechnungstool abgeschnitten. padding=(9, 7), font=(SCHRIFT_NAME, 10), borderwidth=1) style.map("TNotebook.Tab", background=[("selected", self.col_card), ("active", mischen(accent, bg, 0.12))], lightcolor=[("selected", self.col_card), ("active", mischen(accent, bg, 0.12))], darkcolor=[("selected", self.col_card), ("active", mischen(accent, bg, 0.12))], bordercolor=[("selected", accent)], foreground=[("selected", accent), ("active", fg)], font=[("selected", (SCHRIFT_NAME, 10, "bold"))]) # Kein expand beim ausgewaehlten Reiter: er wuchs dadurch um ein paar # Pixel, die anderen rueckten nach - beim Umschalten sprang die ganze # Leiste. Erkannt wird der offene Reiter an Farbe und Fettschrift. # Klassische tk-Widgets (Canvas, Toplevel, Text) erben diese Defaults self.option_add("*background", bg) self.option_add("*foreground", fg) def feld_optionen(self, mehrzeilig=False, einfuegemarke=True): """Farben und Rahmen fuer die klassischen Eingabe-Widgets (Text, Listbox). ttk-Felder holen sich das aus dem Stil; tk.Text und tk.Listbox koennen das nicht - sie muessen die Werte einzeln bekommen. Damit trotzdem JEDES Feld gleich aussieht, kommen sie aus dieser einen Stelle. """ opts = { "bg": self.col_field, "fg": self.col_fg, "relief": "solid", "borderwidth": 1, "highlightthickness": 0, } # Eine Auswahlliste hat keine Einfuegemarke - sie kennt die Option nicht # und bricht daran ab. if einfuegemarke: opts["insertbackground"] = self.col_fg if mehrzeilig: opts["padx"] = 4 opts["pady"] = 3 return opts def _style_dialog(self, d): """Toplevel-Dialog an das Theme angleichen. Im Pruefstand wird derselbe Dialog gebaut und bedient, aber nicht gezeigt - und sein grab_set faellt weg. Sonst haelt jeder Dialog Maus und Tastatur fest, waehrend nebenan jemand schreibt. """ d.configure(bg=self.col_bg) # Mittig ueber dem Programmfenster - und damit automatisch auf dem # Bildschirm, auf dem das Programm gerade steht. d.after(1, lambda: mittig(d, self)) if testlauf(): # Ohne grab_set: ein Dialog, der Maus und Tastatur festhaelt, # blockiert den Menschen, der nebenher arbeitet. d.grab_set = lambda *a, **k: None try: d.attributes("-toolwindow", True) # nicht in die Taskleiste except tk.TclError: pass # erst nach dem Anzeigen setzen, sonst greift DWM noch nicht d.after(20, lambda: self._dark_titlebar(d)) def _dark_titlebar(self, win): """Die Titelleiste eines Fensters an die Darstellung anpassen. Frueher machte diese Methode die Leiste nur DUNKEL und tat sonst nichts. Solange das Programm der Windows-Einstellung folgte, fiel das nicht auf - seit man hell und dunkel selbst waehlen kann, sehr wohl: wer von dunkel auf hell stellte, behielt eine schwarze Titelleiste ueber einem hellen Fenster. Sie zeigt jetzt in beide Richtungen und ist nur noch eine Weiterleitung; die Arbeit macht titelleiste_faerben(). """ titelleiste_faerben(win, bool(getattr(self, "_dark_mode", False))) # ------------------------------------------------ Hell / dunkel umstellen # Der Hinweistext gehoert dem einzelnen Programm - er sagt etwas ueber # DIESES Programm. Hier steht nur, was dasteht, wenn ihn niemand setzt. DARSTELLUNG_HINWEIS = "Gilt nur für das Programmfenster." def _cfg_speichern(self): """Die Einstellungen wegschreiben - falls das noetig ist. Im Rechnungstool ist die Konfiguration ein gewoehnliches Woerterbuch und muss ausdruecklich gespeichert werden. Im Steuerrechnungstool ist sie eine Ablage, die jeden Schreibzugriff sofort in die Journaltabelle durchreicht - dort ist hier nichts zu tun. """ return def variablen_sichern(self): """Alle Tk-Variablen des Fensters als {Name: Wert}. WARUM ALLE UND NICHT EINE AUSWAHL --------------------------------- Die _build-Methoden legen ihre Variablen selbst an (`self.k_name = tk.StringVar()`). Nach dem Neubau stehen also neue, leere da. Beim ersten Versuch waren Kundenname und Rechnungsnummer weg, waehrend die Mengen blieben - die hatte ich einzeln gesichert. Durchgegangen wird deshalb, was das Objekt an Tk-Variablen traegt. Wer spaeter ein Feld hinzufuegt, muss nichts eintragen; eine Liste zum Pflegen waere genau die Sorte, die man beim naechsten Feld vergisst. """ gesichert = {} for name in dir(self): if name.startswith("__"): continue try: wert = getattr(self, name) except Exception: # noqa: BLE001 - Eigenschaften koennen werfen continue if isinstance(wert, (tk.StringVar, tk.IntVar, tk.DoubleVar, tk.BooleanVar)): try: gesichert[name] = wert.get() except tk.TclError: pass return gesichert def variablen_zuruecksetzen(self, gesichert): """Die gesicherten Werte in die neu gebauten Variablen zurueckgeben.""" for name, wert in gesichert.items(): neu = getattr(self, name, None) if isinstance(neu, (tk.StringVar, tk.IntVar, tk.DoubleVar, tk.BooleanVar)): try: neu.set(wert) except tk.TclError: pass def kinder_loeschen(self): """Die Oberflaeche abraeumen - aber keine fremden Fenster. Ein tk.Toplevel IST ein Kind des Hauptfensters. Der offene Darstellungsdialog wurde hier bisher mitgeloescht, und die Zeile danach fasste eine Leiche an ("invalid command name .!toplevel"). Gefunden am 07.09.2026 von der Pruefkette, mit dem echten Bedienweg gemessen: Klick auf "Dunkel" -> Farbe wechselt, Fenster ist weg, Traceback im Log. Der Pruefstand hatte es nicht gefunden, weil er cfg["darstellung"] von Hand setzte und _oberflaeche_neu() direkt rief - also alles ausser dem Weg, den ein Mensch geht. Er klickt jetzt. """ for kind in self.winfo_children(): if not isinstance(kind, tk.Toplevel): kind.destroy() def dlg_darstellung(self): """Hell, dunkel oder wie Windows - und sofort sichtbar.""" d = tk.Toplevel(self) d.title("Darstellung") d.transient(self) d.resizable(False, False) self._style_dialog(d) rahmen = ttk.Frame(d, padding=18) rahmen.pack(fill="both", expand=True) ttk.Label(rahmen, text="Darstellung", font=(SCHRIFT_NAME, 11, "bold"), foreground=self.col_accent).pack(anchor="w") ttk.Label(rahmen, justify="left", wraplength=340, foreground=self.col_muted, text=self.DARSTELLUNG_HINWEIS).pack(anchor="w", pady=(6, 12)) gewaehlt = tk.StringVar(value=modus(self.cfg)) def uebernehmen(): neu = gewaehlt.get() if neu == modus(self.cfg): return self.cfg["darstellung"] = neu self._cfg_speichern() self._oberflaeche_neu() # Der Dialog gehoert noch zur alten Darstellung - er wird # mitgefaerbt, sonst steht ein helles Fenster vor einem dunklen. self._style_dialog(d) for wert in MODI: ttk.Radiobutton(rahmen, text=MODUS_NAMEN[wert], value=wert, variable=gewaehlt, command=uebernehmen).pack( anchor="w", pady=3) ttk.Separator(rahmen, orient="horizontal").pack(fill="x", pady=(12, 10)) ttk.Button(rahmen, text="Schließen", width=14, command=d.destroy).pack(anchor="e") mittig(d, self) return d class MeldungMixin: """Eigene Meldungs- und Ja/Nein-Fenster im Theme des Programms. Warum nicht `messagebox`: das sind Fenster von Windows selbst. Sie sind immer hell, egal was das Programm einstellt - mitten in einer dunklen Oberflaeche blendet das und sieht nach Fremdkoerper aus. Dieselbe Erfahrung steckt schon in der eigenen Menueleiste weiter oben. ⚠️ Im PRUEFLAUF geht beides weiter ueber `messagebox`. Die Pruefstaende haengen ihre Antworten dort ein ("auf diese Frage antworte Ja") und lesen dort mit, was das Programm gemeldet hat. Wuerde hier ein eigenes Fenster aufgehen, warteten sie auf einen Klick, den niemand macht. Geprueft wird damit derselbe Weg - nur die Anzeige unterscheidet sich. """ # Die drei Sorten Meldung. `parent=`, `icon=` und `default=` kommen aus den # frueheren messagebox-Aufrufen mit - sie werden geschluckt, damit an den # Aufrufstellen nichts umgeschrieben werden muss. def melden_info(self, titel, text="", **_kw): return self.melden(titel, text, "info") def melden_warnung(self, titel, text="", **_kw): return self.melden(titel, text, "warnung") def melden_fehler(self, titel, text="", **_kw): return self.melden(titel, text, "fehler") def melden(self, titel, text, art="warnung"): """Eine Meldung mit einem OK-Knopf.""" if testlauf(): {"info": messagebox.showinfo, "warnung": messagebox.showwarning, "fehler": messagebox.showerror}.get(art, messagebox.showwarning)(titel, text) return None return self._meldungsfenster(titel, text, art, knoepfe=None) def frage(self, titel, text="", ja="Ja", nein="Nein", vorgabe=True, **_kw): """Ja/Nein. Gibt True oder False zurueck - wie askyesno.""" if testlauf(): return bool(messagebox.askyesno(titel, text)) return bool(self._meldungsfenster(titel, text, "frage", knoepfe=(ja, nein), vorgabe=vorgabe)) def _meldungsfenster(self, titel, text, art, knoepfe=None, vorgabe=True): farbe = {"fehler": self.col_gefahr, "warnung": self.col_gefahr, "frage": self.col_accent}.get(art, self.col_accent) d = tk.Toplevel(self) d.title(titel) d.transient(self) d.resizable(False, False) self._style_dialog(d) antwort = {"wert": False} rahmen = ttk.Frame(d, padding=20) rahmen.pack(fill="both", expand=True) tk.Label(rahmen, text=titel, bg=self.col_bg, fg=farbe, justify="left", font=(SCHRIFT_NAME, 12, "bold")).pack(anchor="w") tk.Label(rahmen, text=text, bg=self.col_bg, fg=self.col_fg, justify="left", wraplength=460, font=(SCHRIFT_NAME, 10)).pack(anchor="w", pady=(10, 0)) leiste = ttk.Frame(rahmen) leiste.pack(fill="x", pady=(20, 0)) def schliessen(wert): antwort["wert"] = wert d.destroy() if knoepfe: ja, nein = knoepfe ttk.Button(leiste, text=ja, style="Haupt.TButton", command=lambda: schliessen(True)).pack(side="right") ttk.Button(leiste, text=nein, command=lambda: schliessen(False)).pack(side="right", padx=(0, 8)) d.bind("", lambda _e: schliessen(vorgabe)) else: ttk.Button(leiste, text="OK", style="Haupt.TButton", command=lambda: schliessen(True)).pack(side="right") d.bind("", lambda _e: schliessen(True)) d.bind("", lambda _e: schliessen(False)) d.protocol("WM_DELETE_WINDOW", lambda: schliessen(False)) mittig(d, self) # Nach vorn holen und den Tastaturfokus nehmen. Ohne das kann der Dialog # beim Start hinter dem Hauptfenster liegen - der Nutzer sieht nur ein # Fenster, das nicht reagiert, und haelt es fuer haengen geblieben. d.lift() d.attributes("-topmost", True) d.after(100, lambda: d.attributes("-topmost", False)) d.focus_force() d.grab_set() d.focus_set() self.wait_window(d) return antwort["wert"]