adbb035cf1
Seine Ansagen "teste links auf dem 1080p monitor nicht mehr auf dem main ... weil da schau ich nun video" "und das steuertool hat noch kein installer und die rechnungstool hat das icon nicht auf dem desktop etc selbe beim steuertool" Pruefplatz Der Platz fuer Pruefstandsfenster lag 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, waren aber nirgends zu sehen - das hat beim Bildermachen einige Zeit gekostet, ehe es auffiel. theme.pruefplatz() sucht jetzt den nicht-primaeren Monitor und liefert dessen Ecke. Gibt es keinen, bleibt es beim alten Verhalten. Das Steuerrechnungstool hatte ueberhaupt keine Sonderposition - dessen Pruefstandsfenster gingen mitten auf den Hauptbildschirm auf. Verknuepfungen Der Haken "Verknuepfung auf dem Desktop" ist jetzt vorgesetzt statt abgewaehlt, und jede Verknuepfung traegt IconFilename ausdruecklich. Ohne das erbt sie ihr Symbol vom UPDATER - und Windows zeigte an ihrer Stelle das nackte Standardsymbol. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01V4t48uxDok5rJXhC9bX1Ax
656 lines
32 KiB
Python
656 lines
32 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 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)
|
|
if testlauf():
|
|
# Wie das Hauptfenster: auf den zweiten Monitor, und ohne grab_set -
|
|
# ein Dialog, der Maus und Tastatur festhaelt, blockiert den
|
|
# Menschen, der nebenher arbeitet.
|
|
d.geometry(pruefplatz() or f"+{d.winfo_screenwidth() + 20}+40")
|
|
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))
|
|
|
|
d.update_idletasks()
|
|
x = self.winfo_rootx() + max(0, (self.winfo_width() - d.winfo_reqwidth()) // 2)
|
|
y = self.winfo_rooty() + 140
|
|
d.geometry(f"+{max(0, x)}+{max(0, y)}")
|
|
# 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"]
|