688dfb53c4
Seine Ansage "da gehen noch die popups auf dem video monitor auf" "einfach so programmieren das die popup auf dem fenster mittig vom main fenster auf gehen" Was falsch war An sechs Stellen stand `max(0, x)`. Das sollte verhindern, dass ein Dialog ausserhalb des Bildschirms aufgeht - klemmt aber jede NEGATIVE Koordinate auf null. Bei ihm steht der zweite Monitor links (x = -1920): jedes Popup sprang damit zurueck auf den Hauptbildschirm, obwohl das Programm nebenan lief. Dazu kamen feste Versaetze wie "+120+140", die mit der Fenstergroesse nichts zu tun hatten. theme.mittig(dialog, ueber) Eine Stelle fuer alle Dialoge: mittig ueber dem Elternfenster, etwas oberhalb der Mitte (ein Drittel statt der Haelfte), damit der Blick dort ist und die Mitte des Formulars frei bleibt. 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 muss. Die Sonderbehandlung im Testlauf konnte deshalb entfallen; geblieben ist dort nur der Verzicht auf grab_set. theme.auf_bildschirm(x, y, breite, hoehe) Begrenzt eine Position auf den GESAMTEN Desktop ueber alle Monitore (SM_*VIRTUALSCREEN) statt auf den Hauptmonitor. Das war die eigentliche Absicht hinter dem alten max(0, ...). Gemessen statt geglaubt: Dialogmitte und Fenstermitte liegen 8 Pixel auseinander (Fensterrahmen), der Dialog liegt innerhalb des Fensters. Steht als Pruefung in pruef_darstellung.py. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V4t48uxDok5rJXhC9bX1Ax
711 lines
34 KiB
Python
711 lines
34 KiB
Python
# -*- 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:
|
|
import ctypes
|
|
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:
|
|
import ctypes
|
|
from ctypes import wintypes
|
|
|
|
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", wintypes.DWORD), ("rcMonitor", RECT),
|
|
("rcWork", RECT), ("dwFlags", 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, wintypes.HMONITOR,
|
|
wintypes.HDC, ctypes.POINTER(RECT),
|
|
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:
|
|
import ctypes
|
|
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
|
|
import ctypes
|
|
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)))
|
|
|
|
|
|
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("<Return>", lambda _e: schliessen(vorgabe))
|
|
else:
|
|
ttk.Button(leiste, text="OK", style="Haupt.TButton",
|
|
command=lambda: schliessen(True)).pack(side="right")
|
|
d.bind("<Return>", lambda _e: schliessen(True))
|
|
d.bind("<Escape>", 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"]
|