Maustest startet im normalen Fenster (Programm sonst maximiert)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Programm startet maximiert; Version 1.7.0
2026-11-03 14:36:43 +01:00 · 2026-11-03 14:23:01 +01:00 · 2026-11-03 12:14:02 +01:00 · 2026-11-03 12:04:14 +01:00 · 2026-11-03 11:55:17 +01:00 · 2026-11-03 09:35:16 +01:00
51 changed files with 1079 additions and 212 deletions
@@ -1,6 +1,6 @@
 # Baut die Windows-Version (.exe, mit Windows-Python unter Wine) und die Linux-Version.
 #  - jeder Push / PR: Tests + Programmdateien als Build-Artefakte
-#  - Tag "v*" (z. B. v1.0.0): zusätzlich Gitea-Release mit .exe, .zip und Linux-.tar.gz
+#  - Tag "v*" (z. B. v1.0.0): zusätzlich Gitea-Release mit .exe, .zip, Setup und Linux-.tar.gz
 name: Build

 on:
@@ -37,6 +37,7 @@ jobs:
          path: |
            dist/Provisionsmanager95.exe
            dist/Provisionsmanager95-*.zip
+            dist/Provisionsmanager-Setup-*.exe

      - name: Release erstellen / ergänzen
        if: startsWith(github.ref, 'refs/tags/v')
@@ -44,7 +45,9 @@ jobs:
          TOKEN: ${{ secrets.RELEASE_TOKEN || secrets.GITEA_TOKEN }}
          API: ${{ github.server_url }}/api/v1/repos/${{ github.repository }}
          TAG: ${{ github.ref_name }}
-        run: build/release_hochladen.sh dist/Provisionsmanager95.exe dist/Provisionsmanager95-$(tr -d '\r\n' < dist/VERSION).zip
+        run: |
+          V=$(tr -d '\r\n' < dist/VERSION)
+          build/release_hochladen.sh dist/Provisionsmanager95.exe dist/Provisionsmanager95-$V.zip dist/Provisionsmanager-Setup-$V.exe

  linux:
    runs-on: ubuntu-latest
@@ -16,3 +16,4 @@ build/version_info.txt
 selbsttest.txt
 /*.jpg
 /*.png
+.claude/
@@ -5,6 +5,16 @@ von **freenet** (CSV/Excel) und **Vodafone/Euronics** (Excel) ein, ordnet die Po
 Unterhändlern zu, erlaubt freie Anpassung der Auszahlung und exportiert je Händler eine
 fertige Excel-Abrechnung. Optik: Windows 95.

+## Installation (Windows)
+
+`Provisionsmanager-Setup-<version>.exe` aus dem Release herunterladen und starten – keine
+Admin-Rechte nötig. Das Programm landet in `%LOCALAPPDATA%\Programs\Provisionsmanager` mit
+Eintrag im Startmenü (Desktop-Verknüpfung optional) und startet schneller als die einzelne `.exe`.
+Ein Update installiert man einfach drüber (ein laufendes Programm wird dafür geschlossen).
+Deinstallieren über *Einstellungen ▸ Apps*; Datenbank und Einstellungen in
+`%APPDATA%\Provisionsmanager95` bleiben dabei erhalten. Ohne Installation geht weiterhin
+`Provisionsmanager95.exe` (bzw. das `.zip`) – einfach starten.
+
 ## Erster Start

 Beim ersten Start führt ein **Einrichtungs-Assistent** durch Speicherort, Unterhändler
@@ -66,18 +76,20 @@ Welche Provisionsart Airtime bzw. Jahresbonus ist, erkennt das Programm an den T
 „AirTime Provision“, „Umsatzbeteiligung“, „Jahresbonus“); umstellbar je Provisionsart unter
 *Händler ▸ Provisionsarten…*.

-Das Hauptfenster ist unter Windows ein echtes Programmfenster mit Win95-Optik: an den Bildschirmrand
+Das Programm startet maximiert. Das Hauptfenster ist unter Windows ein echtes Programmfenster: an den Bildschirmrand
 ziehen (Andocken), `Win`+Pfeiltasten, Doppelklick auf die Titelleiste und Ziehen am Rand funktionieren
 wie gewohnt.

-**Zeitraum abrechnen:** Im Export-Dialog „Nur von … bis …“ eintragen (oder „Vormonat“), wahlweise nach
+**Zeitraum abrechnen:** Im Export-Dialog „Nur von … bis …“ eintragen (oder „Vormonat“; „Noch nicht abgerechnet“ = alles Offene), wahlweise nach
 Aktivierungsdatum oder Abrechnungszeitraum des Anbieters. Exportierte Positionen werden als *abgerechnet*
 gekennzeichnet (grau) und nie wieder exportiert – auch nicht, wenn dieselbe Position später in einer
 anderen Datei oder Abrechnung auftaucht. Versehentlich? Rechtsklick ▸ *Kennzeichnung „abgerechnet“ aufheben*.
 *Datei ▸ Abrechnung erledigt / wieder öffnen* sperrt eine fertige Abrechnung gegen Änderungen.

-**Design:** Standard ist ein modernes, helles Design (wie Windows 11); das Windows-95-Design gibt es weiter
-unter *Datei ▸ Einstellungen ▸ Darstellung* (wirkt nach Neustart).
+**Design:** Standard ist das Design der Handy-Insel-Webtools (Lila, Schrift IBM Plex – liegt dem Programm bei):
+Kopfzeile mit Menüs und Suche, links Abrechnungen und Händler, oben Kennzahlen, über der Tabelle Filter
+(nicht zugeordnet, von Hand geändert, doppelt, bereits abgerechnet). Oben rechts „Dunkel“/„Hell“ schaltet
+das dunkle Design um. Das Windows-95-Design gibt es weiter unter *Datei ▸ Einstellungen ▸ Darstellung*.

 **Linux:** `Provisionsmanager95-linux-x86_64-<Version>.tar.gz` entpacken und `Provisionsmanager95` starten
 (ab Debian 12 / Ubuntu 24.04). Daten liegen unter `~/.config/Provisionsmanager95`.
@@ -119,7 +131,8 @@ Aufbau:
 | `provtool/db.py` | SQLite: Händler, Kennungen, Regeln, Abrechnungen, Positionen |
 | `provtool/export.py` | Excel-Export im Zielformat |
 | `provtool/money.py` | Beträge (intern immer in Cent) |
-| `provtool/gui/` | Oberfläche (Tkinter im Win95-Stil) |
+| `provtool/gui/` | Oberfläche (Tkinter; Designs hell, dunkel, Win95) |
+| `provtool/gui/schriften/` | IBM Plex (SIL Open Font License, siehe `OFL.txt`) |
 | `provtool/gui/rahmen.py` | selbst gezeichnete Titelleiste, Menüleiste, Größenänderung |
 | `provtool/gui/assistent.py` | Einrichtungs-Assistent, Rundgang, Tipp des Tages |

@@ -134,7 +147,9 @@ Gitea Actions (`.gitea/workflows/windows-build.yml`) baut die `.exe` im Containe
 - jeder Push: alle Tests unter Windows-Python (Wine) **inklusive Oberflächen-Tests** auf einem
  virtuellen Bildschirm, danach `Provisionsmanager95.exe` bauen und mit
  `Provisionsmanager95.exe --selbsttest` die **fertige .exe** prüfen; erst dann gibt es das Artefakt
- Tag `vX.Y.Z` (passend zu `provtool/__init__.py`): zusätzlich ein Gitea-Release mit `.exe` und `.zip`
+- danach das Setup (`build/installer.iss`, Inno Setup unter Wine) bauen, still installieren,
+  den Selbsttest in der installierten `.exe` laufen lassen und still deinstallieren
+- Tag `vX.Y.Z` (passend zu `provtool/__init__.py`): zusätzlich ein Gitea-Release mit `.exe`, `.zip` und Setup

 Die Oberflächen-Tests (`tests/test_gui.py`) bedienen die echte Oberfläche: Dialoge öffnen,
 Programm schließen, während Assistent/Rückfragen/Rundgang offen sind, Alt+F4, Beträge ändern usw.
@@ -1,6 +1,7 @@
 #!/usr/bin/env bash
 # Baut die Windows-.exe mit Windows-Python unter Wine (z. B. im Container tobix/pywine:3.12).
-# Ergebnis: dist/Provisionsmanager95.exe und dist/Provisionsmanager95-<version>.zip
+# Ergebnis: dist/Provisionsmanager95.exe, dist/Provisionsmanager95-<version>.zip und
+#           dist/Provisionsmanager-Setup-<version>.exe (Inno Setup, Installation pro Benutzer)
 set -euo pipefail
 cd "$(dirname "$0")/.."

@@ -40,19 +41,24 @@ echo "== PyInstaller =="
 $PY -m PyInstaller --noconfirm --clean --distpath dist --workpath build/tmp build/provisionsmanager.spec

 test -f dist/Provisionsmanager95.exe
+test -f dist/Provisionsmanager/Provisionsmanager.exe   # Ordner-Variante für das Setup

-echo "== Selbsttest der fertigen .exe =="
+selbsttest() {   # $1 = zu prüfende .exe
  rm -f selbsttest.txt
  set +e
-timeout 300 wine dist/Provisionsmanager95.exe --selbsttest selbsttest.txt
+  timeout 300 wine "$1" --selbsttest selbsttest.txt
  CODE=$?
  set -e
  cat selbsttest.txt 2>/dev/null || echo "(keine Ergebnisdatei – die .exe ist vermutlich gar nicht gestartet)"
  if [ "$CODE" -ne 0 ] || ! head -1 selbsttest.txt 2>/dev/null | tr -d '\r' | grep -qx OK; then
-  echo "Selbsttest der .exe FEHLGESCHLAGEN (Exit-Code $CODE)"
+    echo "Selbsttest von $1 FEHLGESCHLAGEN (Exit-Code $CODE)"
    exit 1
  fi
  echo "Selbsttest bestanden"
+}
+
+echo "== Selbsttest der fertigen .exe =="
+selbsttest dist/Provisionsmanager95.exe
 cp README.md dist/LIESMICH.md 2>/dev/null || true
 ( cd dist && rm -f Provisionsmanager95-*.zip && \
  python3 -c "import zipfile,sys; z=zipfile.ZipFile(sys.argv[1],'w',zipfile.ZIP_DEFLATED); [z.write(f) for f in sys.argv[2:]]; z.close()" \
@@ -60,4 +66,34 @@ cp README.md dist/LIESMICH.md 2>/dev/null || true
  || $PY -c "import zipfile,sys; z=zipfile.ZipFile(sys.argv[1],'w',zipfile.ZIP_DEFLATED); [z.write(f) for f in sys.argv[2:]]; z.close()" \
    "Provisionsmanager95-${VERSION}.zip" Provisionsmanager95.exe LIESMICH.md )
 echo "$VERSION" > dist/VERSION
+
+echo "== Setup (Inno Setup) =="
+INNO_VERSION=6.7.3
+INNO_SHA256=9c73c3bae7ed48d44112a0f48e66742c00090bdb5bef71d9d3c056c66e97b732
+INNO_EXE=build/tmp/innosetup-$INNO_VERSION.exe
+mkdir -p build/tmp
+curl -fsSL -o "$INNO_EXE" "https://github.com/jrsoftware/issrc/releases/download/is-${INNO_VERSION//./_}/innosetup-$INNO_VERSION.exe"
+echo "$INNO_SHA256  $INNO_EXE" | sha256sum -c -
+timeout 300 wine "$INNO_EXE" /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /SP- /CURRENTUSER '/DIR=C:\InnoSetup'
+rm -f dist/Provisionsmanager-Setup-*.exe
+timeout 300 wine 'C:\InnoSetup\ISCC.exe' /Q "/DAppVersion=$VERSION" 'build\installer.iss'
+SETUP="dist/Provisionsmanager-Setup-$VERSION.exe"
+test -f "$SETUP"
+
+echo "== Installer-Test (still installieren, Selbsttest, still deinstallieren) =="
+winordner() { winepath -u "$(wine cmd /c echo "%$1%" | tr -d '\r')"; }   # z. B. APPDATA -> /opt/wineprefix/...
+DATEN="$(winordner APPDATA)/Provisionsmanager95"
+ZIEL="$(winordner LOCALAPPDATA)/Programs/Provisionsmanager"
+mkdir -p "$DATEN"
+echo "Benutzerdaten" > "$DATEN/installer-test.txt"
+timeout 300 wine "$SETUP" /VERYSILENT /SUPPRESSMSGBOXES /CURRENTUSER /NORESTART
+test -f "$(winordner APPDATA)/Microsoft/Windows/Start Menu/Programs/Provisions-Manager.lnk"
+selbsttest "$ZIEL/Provisionsmanager.exe"
+timeout 300 wine "$ZIEL/unins000.exe" /VERYSILENT /SUPPRESSMSGBOXES /NORESTART
+# Der Deinstaller arbeitet als Kopie im Temp-Ordner weiter – auf das Ende warten
+for _ in $(seq 60); do [ -e "$ZIEL" ] || break; sleep 1; done
+if [ -e "$ZIEL" ]; then echo "Deinstallation FEHLGESCHLAGEN – Programmordner noch da:"; ls -la "$ZIEL"; exit 1; fi
+if [ ! -f "$DATEN/installer-test.txt" ]; then echo "Deinstallation hat Benutzerdaten gelöscht!"; exit 1; fi
+rm "$DATEN/installer-test.txt"
+echo "Installer-Test bestanden"
 ls -la dist
@@ -0,0 +1,45 @@
+; Inno-Setup-Skript: Installation pro Benutzer (ohne Admin-Rechte) aus dist/Provisionsmanager/
+; Aufruf (siehe build/build_windows.sh):  ISCC.exe /DAppVersion=1.2.3 build\installer.iss
+; Ergebnis: dist/Provisionsmanager-Setup-<version>.exe
+#ifndef AppVersion
+  #error AppVersion fehlt – ISCC mit /DAppVersion=<version> aufrufen
+#endif
+
+[Setup]
+; AppId nie ändern: daran erkennt Windows bei Updates die bestehende Installation
+AppId={{79CF85D1-16DC-4FD5-924B-B6C9AFB90309}
+AppName=Provisions-Manager
+AppVersion={#AppVersion}
+AppPublisher=Handy-Insel Miesbach
+PrivilegesRequired=lowest
+DefaultDirName={localappdata}\Programs\Provisionsmanager
+DefaultGroupName=Provisions-Manager
+DisableProgramGroupPage=yes
+UninstallDisplayIcon={app}\Provisionsmanager.exe
+SetupIconFile=..\assets\app.ico
+OutputDir=..\dist
+OutputBaseFilename=Provisionsmanager-Setup-{#AppVersion}
+CloseApplications=yes
+WizardStyle=modern
+; Benutzerdaten liegen in %APPDATA%\Provisionsmanager95 – das Setup fasst sie nicht an,
+; der Deinstaller entfernt nur, was er selbst installiert hat.
+
+[Languages]
+Name: "de"; MessagesFile: "compiler:Languages\German.isl"
+
+[Tasks]
+Name: "desktopicon"; Description: "{cm:CreateDesktopIcon}"; GroupDescription: "{cm:AdditionalIcons}"; Flags: unchecked
+
+[InstallDelete]
+; Update: Bibliotheken der alten Version entfernen, damit keine veralteten Dateien liegen bleiben
+Type: filesandordirs; Name: "{app}\_internal"
+
+[Files]
+Source: "..\dist\Provisionsmanager\*"; DestDir: "{app}"; Flags: ignoreversion recursesubdirs createallsubdirs
+
+[Icons]
+Name: "{autoprograms}\Provisions-Manager"; Filename: "{app}\Provisionsmanager.exe"
+Name: "{autodesktop}\Provisions-Manager"; Filename: "{app}\Provisionsmanager.exe"; Tasks: desktopicon
+
+[Run]
+Filename: "{app}\Provisionsmanager.exe"; Description: "{cm:LaunchProgram,Provisions-Manager}"; Flags: nowait postinstall skipifsilent
@@ -1,20 +0,0 @@
-"""Erzeugt assets/app.ico aus der Pixel-Grafik in provtool/gui/win95.py (benötigt Pillow, nur zum Entwickeln)."""
-import sys
-from pathlib import Path
-
-from PIL import Image
-
-ROOT = Path(__file__).resolve().parents[1]
-sys.path.insert(0, str(ROOT))
-from provtool.gui.win95 import PALETTE, _icon_rows  # noqa: E402
-
-img = Image.new("RGBA", (16, 16), (0, 0, 0, 0))
-for y, row in enumerate(_icon_rows("app")):
-    for x, ch in enumerate(row):
-        if ch != ".":
-            img.putpixel((x, y), tuple(int(PALETTE[ch][i:i + 2], 16) for i in (1, 3, 5)) + (255,))
-groessen = [16, 32, 48, 64, 128, 256]
-big = img.resize((256, 256), Image.NEAREST)
-big.save(ROOT / "assets" / "app.ico", sizes=[(s, s) for s in groessen])
-big.save(ROOT / "assets" / "app.png")
-print("assets/app.ico geschrieben")
@@ -0,0 +1,117 @@
+"""Zeichnet die modernen Symbole (flach, wie Windows 11) und das Programm-Icon.
+
+Ausgabe: provtool/gui/bilder/modern/<name>.png (20 px) und <name>_gross.png (40 px),
+assets/app.ico und assets/app.png. Benötigt Pillow – nur zum Entwickeln, nicht zur Laufzeit.
+"""
+from pathlib import Path
+
+from PIL import Image, ImageDraw, ImageFont
+
+ROOT = Path(__file__).resolve().parents[1]
+ZIEL = ROOT / "provtool" / "gui" / "bilder" / "modern"
+N = 160  # Zeichenfläche (8-fach), danach weich verkleinert
+LINIE, AKZENT, HELL = (66, 66, 66, 255), (0, 95, 184, 255), (255, 255, 255, 255)
+GELB, ROT, ORANGE = (240, 190, 70, 255), (196, 43, 28, 255), (247, 168, 0, 255)
+S = 9  # Strichstärke auf der Zeichenfläche
+SCHRIFT = "/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf"
+
+
+def leinwand():
+    img = Image.new("RGBA", (N, N), (0, 0, 0, 0))
+    return img, ImageDraw.Draw(img)
+
+
+def zeichen(d, text, farbe, groesse=104):
+    f = ImageFont.truetype(SCHRIFT, groesse)
+    d.text((N / 2, N / 2 + 4), text, font=f, fill=farbe, anchor="mm")
+
+
+def prozent(d, farbe, s=S):
+    d.ellipse((28, 28, 68, 68), outline=farbe, width=s)
+    d.ellipse((92, 92, 132, 132), outline=farbe, width=s)
+    d.line((120, 30, 40, 130), fill=farbe, width=s + 2)
+
+
+def neu(d):
+    d.polygon([(34, 14), (96, 14), (126, 44), (126, 146), (34, 146)], outline=LINIE, width=S, fill=HELL)
+    d.line([(96, 14), (96, 44), (126, 44)], fill=LINIE, width=S)
+    d.ellipse((86, 86, 150, 150), fill=AKZENT)
+    d.line((118, 100, 118, 136), fill=HELL, width=S)
+    d.line((100, 118, 136, 118), fill=HELL, width=S)
+
+
+def oeffnen(d):
+    d.polygon([(14, 34), (62, 34), (76, 50), (146, 50), (146, 132), (14, 132)], fill=GELB, outline=(193, 140, 30, 255),
+              width=S - 2)
+    d.rectangle((14, 66, 146, 132), fill=(250, 210, 100, 255), outline=(193, 140, 30, 255), width=S - 2)
+
+
+def ablage(d, hoch: bool):
+    d.line([(18, 96), (18, 140), (142, 140), (142, 96)], fill=LINIE, width=S, joint="curve")
+    oben, unten = (14, 104) if hoch else (14, 104)
+    d.line((80, oben, 80, unten), fill=AKZENT, width=S + 2)
+    if hoch:
+        d.polygon([(80, 8), (52, 42), (108, 42)], fill=AKZENT)
+    else:
+        d.polygon([(80, 118), (52, 82), (108, 82)], fill=AKZENT)
+
+
+def haendler(d):
+    d.ellipse((24, 26, 74, 76), outline=LINIE, width=S)
+    d.arc((8, 82, 90, 170), 180, 360, fill=LINIE, width=S)
+    d.ellipse((88, 34, 132, 78), fill=AKZENT)
+    d.pieslice((74, 86, 152, 166), 180, 360, fill=AKZENT)
+
+
+def rechner(d):  # Stift: Betrag ändern
+    d.polygon([(110, 18), (142, 50), (58, 134), (26, 102)], fill=HELL, outline=LINIE, width=S)
+    d.polygon([(26, 102), (58, 134), (16, 144)], fill=AKZENT)
+    d.line((98, 30, 130, 62), fill=LINIE, width=S)
+
+
+def birne(d):
+    d.ellipse((34, 10, 126, 102), fill=GELB, outline=(193, 140, 30, 255), width=S - 2)
+    d.rectangle((56, 96, 104, 122), fill=GELB)
+    d.rectangle((56, 122, 104, 150), fill=(120, 120, 120, 255))
+    d.line((60, 134, 100, 134), fill=HELL, width=4)
+
+
+def kreis(d, farbe, text):
+    d.ellipse((6, 6, 154, 154), fill=farbe)
+    zeichen(d, text, HELL)
+
+
+def warnung(d):
+    d.polygon([(80, 8), (156, 148), (4, 148)], fill=ORANGE)
+    zeichen(d, "!", (30, 30, 30, 255), 92)
+
+
+def app(d):
+    d.rounded_rectangle((4, 4, 156, 156), radius=34, fill=AKZENT)
+    prozent(d, HELL, 13)
+
+
+ICONS = {
+    "neu": neu, "oeffnen": oeffnen, "import": lambda d: ablage(d, False), "export": lambda d: ablage(d, True),
+    "haendler": haendler, "prozent": lambda d: prozent(d, AKZENT), "rechner": rechner, "birne": birne,
+    "info": lambda d: kreis(d, AKZENT, "i"), "frage": lambda d: kreis(d, AKZENT, "?"),
+    "fehler": lambda d: kreis(d, ROT, "×"), "warnung": warnung, "app": app,
+}
+
+
+def main():
+    ZIEL.mkdir(parents=True, exist_ok=True)
+    for name, zeichne in ICONS.items():
+        img, d = leinwand()
+        zeichne(d)
+        img.resize((20, 20), Image.LANCZOS).save(ZIEL / f"{name}.png")
+        img.resize((40, 40), Image.LANCZOS).save(ZIEL / f"{name}_gross.png")
+        if name == "app":
+            gross = img.resize((256, 256), Image.LANCZOS)
+            gross.save(ROOT / "assets" / "app.png")
+            gross.save(ROOT / "assets" / "app.ico", sizes=[(s, s) for s in (16, 24, 32, 48, 64, 128, 256)])
+    print(f"{len(ICONS)} Symbole nach {ZIEL} geschrieben, assets/app.ico + app.png erneuert")
+
+
+if __name__ == "__main__":
+    main()
@@ -16,7 +16,7 @@ home = tempfile.mkdtemp()
 os.environ["PROVTOOL_HOME"] = home
 with open(os.path.join(home, "einstellungen.json"), "w") as f:
    json.dump({"assistent_erledigt": True, "tipps_beim_start": False, "fenster": "900x560+100+100",
-               "design": "win95"}, f)  # nur Win95 hat den eigenen Fensterrahmen
+               "design": "win95", "vollbild": False}, f)  # nur Win95 hat den eigenen Fensterrahmen
 sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
 from provtool.gui import app as A  # noqa: E402

@@ -1,4 +1,5 @@
-# PyInstaller-Spezifikation – erzeugt eine einzelne Programmdatei (Windows: .exe, Linux: ELF)
+# PyInstaller-Spezifikation – erzeugt eine einzelne Programmdatei (Windows: .exe, Linux: ELF),
+# unter Windows zusätzlich den Ordner dist/Provisionsmanager/ (schneller Start, Inhalt des Setups)
 # Aufruf:  pyinstaller --noconfirm build/provisionsmanager.spec
 import os
 import sys
@@ -11,7 +12,8 @@ a = Analysis(
    [os.path.join(ROOT, "build", "start.py")],
    pathex=[ROOT],
    hiddenimports=["openpyxl", "xlrd"],
-    datas=[(os.path.join(ROOT, "provtool", "gui", "bilder"), os.path.join("provtool", "gui", "bilder"))],
+    datas=[(os.path.join(ROOT, "provtool", "gui", "bilder"), os.path.join("provtool", "gui", "bilder")),
+           (os.path.join(ROOT, "provtool", "gui", "schriften"), os.path.join("provtool", "gui", "schriften"))],
    excludes=["numpy", "pandas", "PIL", "pytest", "matplotlib", "unittest", "pydoc_data"],
    noarchive=False,
 )
@@ -31,3 +33,19 @@ exe = EXE(
    strip=False,
    runtime_tmpdir=None,
 )
+
+if WIN:
+    exe_ordner = EXE(
+        pyz,
+        a.scripts,
+        [],
+        exclude_binaries=True,
+        name="Provisionsmanager",
+        icon=os.path.join(ROOT, "assets", "app.ico"),
+        version=os.path.join(ROOT, "build", "version_info.txt"),
+        console=False,
+        upx=False,
+        debug=False,
+        strip=False,
+    )
+    COLLECT(exe_ordner, a.binaries, a.datas, name="Provisionsmanager", upx=False, strip=False)
@@ -11,7 +11,7 @@ release_id() { curl -sf "$API/releases/tags/$TAG" -H "Authorization: token $TOKE
 id=$(release_id || true)
 if [ -z "$id" ]; then
  curl -sf -X POST "$API/releases" -H "Authorization: token $TOKEN" -H "Content-Type: application/json" \
-    -d "{\"tag_name\":\"$TAG\",\"name\":\"Provisions-Manager 95 $TAG\",\"body\":\"Windows: .exe herunterladen und starten. Linux: tar.gz entpacken, Provisionsmanager95 starten (ab Debian 12 / Ubuntu 24.04).\"}" \
+    -d "{\"tag_name\":\"$TAG\",\"name\":\"Provisions-Manager 95 $TAG\",\"body\":\"Windows: Setup installieren (oder die .exe direkt starten). Linux: tar.gz entpacken, Provisionsmanager95 starten (ab Debian 12 / Ubuntu 24.04).\"}" \
    >/dev/null || sleep 5   # Gleichzeitig angelegt? Dann gibt es das Release jetzt.
  id=$(release_id)
 fi
@@ -1,5 +1,5 @@
 """Provisions-Manager 95 – Provisionsabrechnung für Unterhändler der Handy-Insel Miesbach."""

-__version__ = "1.4.0"
+__version__ = "1.7.0"
 APP_NAME = "Provisions-Manager 95"
 APP_ORG = "Handy-Insel Miesbach"
@@ -12,7 +12,7 @@ from datetime import date
 from pathlib import Path
 from tkinter import filedialog

-from provtool import APP_NAME, config
+from provtool import config
 from provtool import export as exp
 from provtool import regeln
 from provtool.db import EIGEN, UNZUGEORDNET, AbrechnungErledigt, Datenbank
@@ -79,12 +79,16 @@ class App:
        root.report_callback_exception = self._fehler_handler
        klassisch = w.DESIGN == "win95"  # Win95: eigene Titelleiste; modern: normaler Windows-Rahmen
        w.KLASSISCH = klassisch
-        self.rahmen = rh.Hauptrahmen(root, APP_NAME, self.icons("app"), self.beenden, klassisch=klassisch)
-        self.rahmen.set_titel(APP_NAME)
+        self.rahmen = rh.Hauptrahmen(root, w.APP_NAME, self.icons("app"), self.beenden, klassisch=klassisch)
+        self.rahmen.set_titel(w.APP_NAME)
        self.inhalt = self.rahmen.inhalt
+        if w.DUNKEL:
+            from provtool.gui import win32
+            win32.dunkle_titelleiste(root)

-        self._menue()
-        self._toolbar()
+        self.neustart = False   # Design umgeschaltet: main() baut das Fenster neu auf
+        self.filter = "alle"
+        self._kopf()
        self._body()
        self.status = w.Statusleiste(self.inhalt, [("info", 0), ("pos", 16), ("orig", 22), ("ausz", 22)])
        griff = self.rahmen.griff(self.status)
@@ -92,7 +96,8 @@ class App:
            griff.pack(side="right", anchor="se")
        self.status.pack(side="bottom", fill="x")
        self._tasten()
-        self.rahmen.geometrie_setzen(self.settings.get("fenster"), self.settings.get("maximiert", False))
+        # startet maximiert („vollbild“, abschaltbar nur für Tests); „fenster“ = Größe nach dem Wiederherstellen
+        self.rahmen.geometrie_setzen(self.settings.get("fenster"), self.settings.get("vollbild", True))
        if self.settings.get("trenner"):
            root.after(200, lambda: self.pw.sash_place(0, int(self.settings["trenner"]), 0))

@@ -107,9 +112,52 @@ class App:
            root.after(500, self.tipp_des_tages)

    # ================================================================= Aufbau
-    def _menue(self):
-        self.menueleiste = mn.Menueleiste(self.inhalt, self.root)
-        self.menueleiste.pack(side="top", fill="x")
+    def _kopf(self):
+        """Kopfzeile wie in den Webtools: Logo, Menüs, rechts Suche (modern auch Hell/Dunkel)."""
+        kopf = tk.Frame(self.inhalt, bg=w.FACE)
+        kopf.pack(side="top", fill="x")
+        if w.MODERN:
+            w.trenner(self.inhalt, vertikal=False).pack(side="top", fill="x")
+        innen = tk.Frame(kopf, bg=w.FACE)
+        innen.pack(fill="x", padx=(18, 14) if w.MODERN else 0, pady=10 if w.MODERN else 0)
+        if w.MODERN:
+            w.logo(innen).pack(side="left")
+            namen = tk.Frame(innen, bg=w.FACE)
+            namen.pack(side="left", padx=(10, 22))
+            tk.Label(namen, text=w.APP_NAME, font=(w.FONT_FAMILY, w.FONT_SIZE + 1, "bold")).pack(anchor="w")
+            tk.Label(namen, text="Handy-Insel", fg=w.SHADOW, font=(w.MONO_FAMILY, w.FONT_SIZE - 2)).pack(anchor="w")
+        self._menue(innen)
+
+        if w.MODERN:
+            self.b_design = w.knopf(innen, "Hell" if w.DUNKEL else "Dunkel", self.design_umschalten)
+            self.b_design.pack(side="right", padx=(8, 0))
+            w.Tooltip(self.b_design, "Zwischen hellem und dunklem Design wechseln")
+        self.v_suche = tk.StringVar()
+        if w.MODERN:  # Suchfeld mit Rahmen, Hinweis und Tastenkürzel
+            sf = tk.Frame(innen, bg=w.WHITE, highlightthickness=1, highlightbackground=w.RAND2,
+                          highlightcolor=w.NAVY)
+            sf.pack(side="right")
+            tk.Label(sf, text="Suchen", bg=w.WHITE, fg=w.SHADOW).pack(side="left", padx=(10, 2))
+            e = tk.Entry(sf, textvariable=self.v_suche, width=28, highlightthickness=0, bd=4)
+            e.pack(side="left")
+            tk.Label(sf, text="Strg F", bg=w.WHITE, fg=w.SHADOW, font=(w.MONO_FAMILY, w.FONT_SIZE - 2)).pack(
+                side="left", padx=(2, 10))
+            e.bind("<FocusIn>", lambda _e: sf.configure(highlightbackground=w.NAVY), add="+")
+            e.bind("<FocusOut>", lambda _e: sf.configure(highlightbackground=w.RAND2), add="+")
+        else:
+            sf = tk.Frame(innen, bg=w.FACE)
+            sf.pack(side="right", padx=8)
+            tk.Label(sf, text="Suchen:").pack(side="left")
+            e = tk.Entry(sf, textvariable=self.v_suche, width=22)
+            e.pack(side="left", padx=4)
+        self._suche_geplant = None
+        self.v_suche.trace_add("write", lambda *_: self._suche_planen())
+        self._suchfeld = e
+        self._suchrahmen = sf
+
+    def _menue(self, master):
+        self.menueleiste = mn.Menueleiste(master, self.root)
+        self.menueleiste.pack(side="left")
        d = self.menueleiste.menue("Datei")
        d.add_command(label="Neue Abrechnung...", accelerator="Strg+N", command=self.neu)
        d.add_command(label="Abrechnung öffnen...", accelerator="Strg+O", command=self.abrechnung_waehlen)
@@ -144,110 +192,193 @@ class App:
        h.add_command(label="Provisionsarten (Airtime / Jahresbonus)...", command=self.provisionsarten)
        h.add_command(label="Standard-Staffel Jahresbonus...", command=self.standard_staffel)

-        hi = self.menueleiste.menue("?", underline=None)
+        self.hilfe_menue = "Hilfe" if w.MODERN else "?"
+        hi = self.menueleiste.menue(self.hilfe_menue, underline=None)
        hi.add_command(label="Kurzanleitung", accelerator="F1", command=self.hilfe)
        hi.add_command(label="Rundgang durch das Programm", command=self.rundgang)
        hi.add_command(label="Tipp des Tages...", command=self.tipp_des_tages)
        hi.add_separator()
        hi.add_command(label="Einrichtungs-Assistent...", command=self.assistent)
        hi.add_separator()
-        hi.add_command(label=f"Info über {APP_NAME}...", command=lambda: dlg.InfoDialog(self.root).zeigen())
+        hi.add_command(label=f"Info über {w.APP_NAME}...", command=lambda: dlg.InfoDialog(self.root).zeigen())

-    def _toolbar(self):
-        tb = tk.Frame(self.inhalt, bg=w.FACE, bd=0 if w.MODERN else 1, relief="raised")
-        self.tb: dict[str, w.ToolbarButton] = {}
-        tb.pack(side="top", fill="x")
-        for text, icon, cmd, tip in (
-            ("Neu", "neu", self.neu, "Neue Abrechnung anlegen (Strg+N)"),
-            ("Öffnen", "oeffnen", self.abrechnung_waehlen, "Gespeicherte Abrechnung öffnen (Strg+O)"),
-            (None, None, None, None),
-            ("Import", "import", self.importieren, "CSV-/Excel-Dateien einlesen (Strg+I)"),
-            ("Export", "export", self.exportieren, "Händler-Abrechnungen als Excel speichern (Strg+E)"),
-            (None, None, None, None),
-            ("Händler", "haendler", self.haendler, "Händler und Kennungen verwalten (Strg+H)"),
-            ("Prozent", "prozent", self.prozent, "Auszahlung für Auswahl in Prozent festlegen (F4)"),
-            ("Betrag", "rechner", self.betrag_bearbeiten, "Betrag der Position ändern (F2)"),
-        ):
-            if text is None:
-                w.trenner(tb).pack(side="left", fill="y", padx=4, pady=3)
-                continue
-            self.tb[text] = w.ToolbarButton(tb, text, self.icons(icon), cmd, tip)
-            self.tb[text].pack(side="left", padx=1, pady=1)
-        self.v_suche = tk.StringVar()
-        sf = tk.Frame(tb, bg=w.FACE)
-        sf.pack(side="right", padx=8)
-        tk.Label(sf, text="Suchen:").pack(side="left")
-        e = tk.Entry(sf, textvariable=self.v_suche, width=22)
-        e.pack(side="left", padx=4)
-        self._suche_geplant = None
-        self.v_suche.trace_add("write", lambda *_: self._suche_planen())
-        self._suchfeld = e
-        self._suchrahmen = sf
+    FILTER = (("alle", "Alle"), ("unzugeordnet", "Nicht zugeordnet"), ("manuell", "Von Hand geändert"),
+              ("doppelt", "Doppelt"), ("abgerechnet", "Bereits abgerechnet"))

    def _body(self):
-        desk = tk.Frame(self.inhalt, bg=w.TEAL)
+        m = w.MODERN
+        desk = tk.Frame(self.inhalt, bg=w.BG)
        desk.pack(side="top", fill="both", expand=True)
-        # Trennlinie zwischen den Spalten: grau und erhaben wie ein Win95-Splitter, mit der Maus ziehbar.
-        # Wie im Win95-Explorer wandert beim Ziehen nur eine Linie mit; neu aufgebaut wird erst beim
-        # Loslassen (flüssig, auch mit vielen Positionen).
-        pw = self.pw = tk.PanedWindow(desk, orient="horizontal", bg=w.FACE, sashwidth=7,
-                                      sashrelief="flat" if w.MODERN else "raised",
+        # Trennlinie zwischen den Spalten, mit der Maus ziehbar. Beim Ziehen wandert nur eine Linie mit;
+        # neu aufgebaut wird erst beim Loslassen (flüssig, auch mit vielen Positionen).
+        pw = self.pw = tk.PanedWindow(desk, orient="horizontal", bg=w.BG, sashwidth=6 if m else 7,
+                                      sashrelief="flat" if m else "raised",
                                      bd=0, opaqueresize=False, sashcursor="sb_h_double_arrow")
-        pw.pack(fill="both", expand=True, padx=6, pady=6)
+        pw.pack(fill="both", expand=True, padx=0 if m else 6, pady=0 if m else 6)

-        # --- Händler-Fenster
-        self.f_h = w.Fenster(pw, "Händler", self.icons("haendler"))
-        r, self.htree = w.scroll_tree(self.f_h.inhalt, columns=("anzahl", "summe"), show="tree headings",
-                                      selectmode="browse")
-        self.htree.heading("#0", text="Händler", anchor="w")
-        self.htree.heading("anzahl", text="Pos.")
-        self.htree.heading("summe", text="Auszahlung")
-        self.htree.column("#0", width=150, minwidth=80, stretch=False)
-        self.htree.column("anzahl", width=38, anchor="e", stretch=False)
-        self.htree.column("summe", width=84, anchor="e", stretch=False)
+        # ---------------- Seitenleiste: Abrechnungen und Händler
+        # Win95: zwei eigene Flächen mit blauer Titelleiste auf dem Desktop
+        links = tk.Frame(pw, bg=w.FACE if m else w.BG)
+        innen = tk.Frame(links, bg=w.FACE if m else w.BG)
+        innen.pack(fill="both", expand=True, padx=12 if m else 0, pady=(16, 10) if m else 0)
+        seite = dict(style="Seite.Treeview") if m else {}
+        rand = {} if m else dict(padx=2, pady=(0, 2))   # Abstand der Liste zum Win95-Rahmen
+
+        self.f_a = tk.Frame(innen, bg=w.FACE) if m else w.Karte(innen)
+        self.f_a.pack(fill="x", pady=(0, 16 if m else 6))
+        zeile = self._abschnitt_zeile(self.f_a, "Abrechnungen")
+        self.b_neu = w.knopf(zeile, "+ Neu", self.neu, padx=8, pady=0, **self._link())
+        self.b_neu.pack(side="right", padx=0 if m else 1)
+        w.Tooltip(self.b_neu, "Neue Abrechnung anlegen (Strg+N)")
+        r, self.atree = w.scroll_tree(self.f_a, columns=("status",), show="tree", height=5, selectmode="browse",
+                                      auto=True, **seite)
+        self.atree.column("#0", width=150, minwidth=80, stretch=False)
+        self.atree.column("status", width=110, anchor="e", stretch=False)
+        w.auto_breite(self.atree, {"#0": 1})
+        self.atree.tag_configure("leise", foreground=w.SHADOW)
+        self._punkte = {f: w.punkt(self.root, getattr(w, f)) for f in ("BLAU", "GOLD", "GRUEN", "ROT", "SHADOW")}
+        r.pack(fill="both", expand=True, **rand)
+        self.atree.bind("<<TreeviewSelect>>", self._abrechnung_gewaehlt)
+
+        self.f_h = tk.Frame(innen, bg=w.FACE) if m else w.Karte(innen)
+        self.f_h.pack(fill="both", expand=True)
+        zeile = self._abschnitt_zeile(self.f_h, "Händler")
+        self.b_haendler = w.knopf(zeile, "Verwalten", self.haendler, padx=8, pady=0, **self._link())
+        self.b_haendler.pack(side="right", padx=0 if m else 1)
+        w.Tooltip(self.b_haendler, "Händler und Kennungen verwalten (Strg+H)")
+        r, self.htree = w.scroll_tree(self.f_h, columns=("anzahl", "summe"), show="tree", selectmode="browse",
+                                      auto=True, **seite)
+        self.htree.column("#0", width=140, minwidth=80, stretch=False)
+        self.htree.column("anzahl", width=40, anchor="e", stretch=False)
+        self.htree.column("summe", width=96, anchor="e", stretch=False)
        w.auto_breite(self.htree, {"#0": 1})
        self.htree.tag_configure("grau", foreground=w.SHADOW)
        self.htree.tag_configure("fett", font=w.FONT_BOLD)
-        r.pack(fill="both", expand=True)
+        r.pack(fill="both", expand=True, **rand)
        self.htree.bind("<<TreeviewSelect>>", self._haendler_gewaehlt)
        self.htree.bind("<Double-1>", lambda e: self._haendler_doppelklick())
-        pw.add(self.f_h, minsize=240, width=310)
+        pw.add(links, minsize=240, width=320)
+
+        # ---------------- Inhalt: Kopf der Abrechnung, Kennzahlen, Positionen
+        rechts = tk.Frame(pw, bg=w.BG)
+        innen = tk.Frame(rechts, bg=w.BG)
+        innen.pack(fill="both", expand=True, padx=(16, 20) if m else 0, pady=(16, 0) if m else 0)
+
+        kopf = tk.Frame(innen, bg=w.BG)
+        kopf.pack(fill="x", pady=(0, 14 if m else 6))
+        texte = tk.Frame(kopf, bg=w.BG)
+        texte.pack(side="left", fill="x", expand=True)
+        self.l_status = w.abschnitt(texte, "", bg=w.BG)
+        self.l_status.pack(anchor="w")
+        self.l_titel = tk.Label(texte, text="", bg=w.BG, font=w.FONT_TITEL, anchor="w")
+        self.l_titel.pack(anchor="w")
+        self.l_info = tk.Label(texte, text="", bg=w.BG, fg=w.TEXT2, anchor="w")
+        self.l_info.pack(anchor="w")
+        if not m:  # Win95: weiße Schrift auf dem Desktop, wie die Symbolbeschriftungen
+            for lbl in (self.l_status, self.l_titel, self.l_info):
+                lbl.configure(fg=w.WHITE)
+        self.b_export = w.knopf(kopf, "Exportieren", self.exportieren, primaer=True)
+        self.b_export.pack(side="right", anchor="s")
+        w.Tooltip(self.b_export, "Händler-Abrechnungen als Excel speichern (Strg+E)")
+        self.b_import = w.knopf(kopf, "Importieren", self.importieren)
+        self.b_import.pack(side="right", anchor="s", padx=8)
+        w.Tooltip(self.b_import, "CSV-/Excel-Dateien einlesen (Strg+I)")
+        self.b_erledigt = w.knopf(kopf, "Als erledigt markieren", self.erledigt_umschalten)
+        self.b_erledigt.pack(side="right", anchor="s")
+        self.tb = {"Neu": self.b_neu, "Import": self.b_import, "Export": self.b_export, "Händler": self.b_haendler}
+
+        kacheln = tk.Frame(innen, bg=w.BG)
+        kacheln.pack(fill="x", pady=(0, 14 if m else 6))
+        self.kpi: dict[str, tuple[tk.Label, tk.Label]] = {}
+        for i, (key, titel) in enumerate((("pos", "Positionen"), ("orig", "Provision"), ("ausz", "Auszahlung"),
+                                          ("air", "Airtime"))):
+            k = w.Karte(kacheln)
+            k.grid(row=0, column=i, sticky="nsew", padx=(0 if i == 0 else 7, 0 if i == 3 else 7))
+            kacheln.columnconfigure(i, weight=1, uniform="kpi")
+            ki = tk.Frame(k, bg=w.FACE)
+            ki.pack(fill="both", expand=True, padx=16 if m else 8, pady=12 if m else 6)
+            w.abschnitt(ki, titel).pack(anchor="w")
+            farbe = {"ausz": w.NAVY, "air": w.GRUEN}.get(key, w.DARK)
+            wert = tk.Label(ki, text="", font=w.FONT_ZAHL, fg=farbe, anchor="w")
+            wert.pack(anchor="w", pady=(4, 0))
+            info = tk.Label(ki, text="", fg=w.TEXT2, anchor="w")
+            info.pack(anchor="w")
+            self.kpi[key] = (wert, info)
+
+        self.f_p = w.Karte(innen)
+        self.f_p.pack(fill="both", expand=True, pady=(0, 12 if m else 0))
+        if not m:  # Win95: Titel in der blauen Leiste, Filter darunter wie eine Werkzeugleiste
+            _, self.l_ptitel = w.titelleiste(self.f_p, "Positionen")
+        kopfzeile = tk.Frame(self.f_p, bg=w.FACE)
+        kopfzeile.pack(fill="x", padx=14 if m else 4, pady=10 if m else 4)
+        if m:
+            self.l_ptitel = tk.Label(kopfzeile, text="Positionen", font=(w.FONT_FAMILY, w.FONT_SIZE + 1, "bold"))
+            self.l_ptitel.pack(side="left", padx=(0, 12))
+        self.pills: dict[str, w.Pill] = {}
+        for key, text in self.FILTER:
+            self.pills[key] = w.Pill(kopfzeile, text, lambda k=key: self._filter_setzen(k), aktiv=key == self.filter)
+            self.pills[key].pack(side="left", padx=(0, 6))
+        self.l_auswahl = tk.Label(kopfzeile, text="", fg=w.TEXT2)
+        self.l_auswahl.pack(side="right")
+        if m:
+            w.trenner(self.f_p, vertikal=False).pack(fill="x")

-        # --- Positionen-Fenster
-        self.f_p = w.Fenster(pw, "Positionen", self.icons("neu"))
        cols = ("datum", "rufnummer", "tarif", "zeitraum", "kennung", "orig", "proz", "ausz")
-        r2, self.ptree = w.scroll_tree(self.f_p.inhalt, columns=cols, show="tree headings", selectmode="extended")
-        self.ptree.heading("#0", text="Provisionsart / Kunde", anchor="w")
+        r2, self.ptree = w.scroll_tree(self.f_p, columns=cols, show="tree headings", selectmode="extended")
+        if m:
+            r2.configure(highlightthickness=0)
+        kopf_text = (lambda t: t.upper()) if m else (lambda t: t)
+        self.ptree.heading("#0", text=kopf_text("Provisionsart / Kunde"), anchor="w")
        self.ptree.column("#0", width=200, minwidth=140, stretch=False)
-        for c, t, b, a in (("datum", "Datum", 76, "w"), ("rufnummer", "Rufnummer", 100, "w"),
-                           ("tarif", "Tarif", 120, "w"), ("zeitraum", "Zeitraum", 84, "w"),
-                           ("kennung", "Kennung", 70, "w"),
-                           ("orig", "Provision", 78, "e"), ("proz", "%", 52, "e"), ("ausz", "Auszahlung", 84, "e")):
-            self.ptree.heading(c, text=t, anchor=a)
+        for c, t, b, a in (("datum", "Datum", 86, "w"), ("rufnummer", "Rufnummer", 112, "w"),
+                           ("tarif", "Tarif", 120, "w"), ("zeitraum", "Zeitraum", 94, "w"),
+                           ("kennung", "Kennung", 80, "w"),
+                           ("orig", "Provision", 100, "e"), ("proz", "%", 64, "e"), ("ausz", "Auszahlung", 112, "e")):
+            self.ptree.heading(c, text=kopf_text(t), anchor=a)
            self.ptree.column(c, width=b, minwidth=80 if c == "tarif" else 30, anchor=a, stretch=False)
        w.auto_breite(self.ptree, {"#0": 0.6, "tarif": 0.4})
        self.ptree.tag_configure("gruppe", background=w.LIGHT, font=w.FONT_BOLD)
-        self.ptree.tag_configure("manuell", foreground="#0000c0")
-        self.ptree.tag_configure("abw", foreground="#a00000")
-        self.ptree.tag_configure("negativ", foreground="#a00000")
+        self.ptree.tag_configure("zebra", background=w.ZEBRA)
+        self.ptree.tag_configure("manuell", foreground=w.MANUELL)
+        self.ptree.tag_configure("abw", foreground=w.ROT)
+        self.ptree.tag_configure("negativ", foreground=w.ROT)
        self.ptree.tag_configure("abgerechnet", foreground=w.SHADOW)
        r2.pack(fill="both", expand=True)
        self.ptree.bind("<Double-1>", self._doppelklick)
        self.ptree.bind("<Button-3>", self._kontextmenue)
        self.ptree.bind("<<TreeviewSelect>>", lambda e: self._status_auswahl())

-        leiste = tk.Frame(self.f_p.inhalt, bg=w.FACE)
-        leiste.pack(fill="x", pady=(4, 0))
-        self.b_prozent = w.knopf(leiste, "Prozent...", self.prozent, self.icons("prozent"))
+        leiste = tk.Frame(self.f_p, bg=w.FACE)
+        leiste.pack(fill="x", padx=14 if m else 2, pady=10 if m else (4, 2))
+        self.b_prozent = w.knopf(leiste, "Prozent...", self.prozent, None if m else self.icons("prozent"))
        self.b_prozent.pack(side="left")
-        w.knopf(leiste, "Betrag ändern...", self.betrag_bearbeiten, self.icons("rechner")).pack(side="left", padx=4)
+        w.knopf(leiste, "Betrag ändern...", self.betrag_bearbeiten,
+                None if m else self.icons("rechner")).pack(side="left", padx=6)
        w.knopf(leiste, "Zurücksetzen", self.zuruecksetzen).pack(side="left")
-        self.v_alle_auf = tk.BooleanVar(value=True)
        w.knopf(leiste, "Alle zuklappen", lambda: self._klappen(False)).pack(side="right")
-        w.knopf(leiste, "Alle aufklappen", lambda: self._klappen(True)).pack(side="right", padx=4)
-        tk.Label(leiste, text="Blau = von Hand · Rot = abweichend · Grau = abgerechnet", fg=w.SHADOW).pack(
-            side="left", padx=8)
-        pw.add(self.f_p, minsize=500)
+        w.knopf(leiste, "Alle aufklappen", lambda: self._klappen(True)).pack(side="right", padx=6)
+        pw.add(rechts, minsize=560)
+
+    @staticmethod
+    def _abschnitt_zeile(master, titel: str) -> tk.Frame:
+        """Überschrift eines Abschnitts der Seitenleiste; Win95 als blaue Titelleiste. Knöpfe kommen rechts hinein."""
+        if not w.MODERN:
+            return w.titelleiste(master, titel)[0]
+        zeile = tk.Frame(master, bg=w.FACE)
+        zeile.pack(fill="x", pady=(0, 4))
+        w.abschnitt(zeile, titel).pack(side="left", padx=(8, 0))
+        return zeile
+
+    @staticmethod
+    def _link() -> dict:
+        """Kleine Textknöpfe in der Seitenleiste (modern ohne Rahmen, in Akzentfarbe)."""
+        return dict(fg=w.NAVY, highlightthickness=0, font=w.FONT_BOLD) if w.MODERN else {}
+
+    def _filter_setzen(self, key: str):
+        self.filter = key
+        for k, pill in self.pills.items():
+            pill.setzen(k == key)
+        self._tabelle()

    def _tasten(self):
        r = self.root
@@ -277,16 +408,53 @@ class App:
        if self.aid and self.db.abrechnung(self.aid):
            self.positionen = self.db.positionen(self.aid)
            titel = self.db.abrechnung(self.aid)["titel"] + (" – erledigt" if self.db.erledigt(self.aid) else "")
-            self.rahmen.set_titel(f"{APP_NAME} - [{titel}]")
+            self.rahmen.set_titel(f"{w.APP_NAME} - [{titel}]")
            self.status.set("info", f" Abrechnung: {titel}")
        else:
            self.aid = None
            self.positionen = []
-            self.rahmen.set_titel(APP_NAME)
+            self.rahmen.set_titel(w.APP_NAME)
            self.status.set("info", " Keine Abrechnung geöffnet – Datei > Neue Abrechnung oder Import")
+        self._abrechnungsliste()
+        self._seitenkopf()
        self._haendlerliste(behalte_auswahl)
        self._tabelle()

+    def _seitenkopf(self):
+        """Titel, Status und Knöpfe über den Kennzahlen."""
+        a = self.db.abrechnung(self.aid) if self.aid else None
+        if not a:
+            self.l_status.configure(text="Keine Abrechnung geöffnet".upper() if w.MODERN else "Keine Abrechnung")
+            self.l_titel.configure(text="Willkommen")
+            self.l_info.configure(text="Links „+ Neu“ anlegen oder gleich Dateien importieren.")
+            self.b_erledigt.configure(text="Als erledigt markieren", state="disabled")
+            return
+        erledigt = self.db.erledigt(self.aid)
+        dateien = self.db.dateien(self.aid)
+        status = "erledigt" if erledigt else "offen"
+        self.l_status.configure(text=f"Abrechnung · {status}".upper() if w.MODERN else f"Abrechnung ({status})")
+        self.l_titel.configure(text=a["titel"])
+        self.l_info.configure(text=f"{len(dateien)} {'Datei' if len(dateien) == 1 else 'Dateien'} importiert · "
+                                   f"{sum(d['anzahl'] for d in dateien)} Zeilen" if dateien else "Noch nichts importiert")
+        self.b_erledigt.configure(text="Wieder öffnen" if erledigt else "Als erledigt markieren", state="normal")
+
+    def _abrechnungsliste(self):
+        t = self.atree
+        t.delete(*t.get_children())
+        for a in self.db.abrechnungen():
+            status, farbe = (("erledigt", "GRUEN") if a["erledigt"] else
+                             (f"{a['abgerechnet']} abgerechnet", "GOLD") if a["abgerechnet"] else ("offen", "BLAU"))
+            t.insert("", "end", iid=str(a["id"]), text=" " + a["titel"], values=(status,), image=self._punkte[farbe])
+        if self.aid and t.exists(str(self.aid)):
+            t.selection_set(str(self.aid))
+            t.see(str(self.aid))
+
+    def _abrechnung_gewaehlt(self, _e=None):
+        sel = self.atree.selection()
+        if sel and int(sel[0]) != self.aid:
+            self.ansicht = ALLE
+            self.oeffnen(int(sel[0]))
+
    def _suche_planen(self):
        """Suche erst kurz nach dem letzten Tastendruck ausführen (flüssiges Tippen)."""
        if self._suche_geplant is not None:
@@ -366,6 +534,10 @@ class App:
            pos = [p for p in pos if such in " ".join(str(p.get(k) or "") for k in (
                "rufnummer", "vorname", "name", "tarif", "provisionsart", "kennung", "zeitraum", "aktionscode",
                "imei")).lower()]
+        pruef = {"unzugeordnet": lambda p: p["haendler_id"] == UNZUGEORDNET, "manuell": lambda p: p["manuell"],
+                 "doppelt": lambda p: p["doppelt"], "abgerechnet": lambda p: p["abgerechnet"]}.get(self.filter)
+        if pruef:
+            pos = [p for p in pos if pruef(p)]
        gruppen: dict[str, list[dict]] = defaultdict(list)
        for p in exp.sortiert(pos):
            gruppen[self._gruppe_von(p)].append(p)
@@ -382,8 +554,8 @@ class App:
                pz = fmt_percent(next(iter(proz))) if len(proz) == 1 and None not in proz else ("gemischt" if so else "")
            t.insert("", "end", iid=giid, text=f"{gname}  ({len(plist)})", open=(war_leer or giid in offen or bool(such)),
                     values=("", "", "", "", "", fmt(so), pz, fmt(sa)), tags=("gruppe",))
-            for p in plist:
-                tags = []
+            for i, p in enumerate(plist):
+                tags = ["zebra"] if i % 2 else []
                if p["abgerechnet"] or p["doppelt"]:
                    tags.append("abgerechnet")
                elif p["manuell"]:
@@ -402,17 +574,30 @@ class App:
        name = {ALLE: "Alle Positionen", UNZUGEORDNET: "Nicht zugeordnet",
                EIGEN: "Eigene Kennungen (ausgeblendet, werden nicht exportiert)"}.get(
            self.ansicht, self.haendler_namen.get(self.ansicht, ""))
-        self.f_p.set_titel(f"Positionen – {name}")
+        self.l_ptitel.configure(text=f"Positionen – {name}")
        so = sum(p["betrag_orig"] for p in pos)
        sa = sum(p["betrag"] for p in pos)
+        air = [p for p in pos if p.get("typ") == regeln.AIRTIME]
        self.status.set("pos", f" {len(pos)} Positionen")
        self.status.set("orig", f" Provision: {fmt(so)}")
        self.status.set("ausz", f" Auszahlung: {fmt(sa)}")
+        self._kennzahl("pos", str(len(pos)), name)
+        self._kennzahl("orig", fmt(so), "laut Anbieter")
+        self._kennzahl("ausz", fmt(sa), f"{round(sa * 100 / so)} % im Schnitt" if so > 0 else "")
+        self._kennzahl("air", fmt(sum(p["betrag"] for p in air)),
+                       (f"{len(air)} Posten · eigene Excel-Datei" if any(p["betrag"] for p in air) else f"{len(air)} Posten")
+                       if air else "keine Airtime")
+        self.l_auswahl.configure(text="")
+
+    def _kennzahl(self, key: str, wert: str, info: str):
+        self.kpi[key][0].configure(text=wert)
+        self.kpi[key][1].configure(text=info)

    def _status_auswahl(self):
        pids = self._ausgewaehlte_pids()
        if len(pids) > 1 or (pids and any(i.startswith("g") for i in self.ptree.selection())):
            ps = [p for p in self.positionen if p["id"] in set(pids)]
+            self.l_auswahl.configure(text=f"{len(ps)} ausgewählt · {fmt(sum(p['betrag'] for p in ps))}")
            self.status.set("pos", f" {len(ps)} ausgewählt")
            self.status.set("orig", f" Provision: {fmt(sum(p['betrag_orig'] for p in ps))}")
            self.status.set("ausz", f" Auszahlung: {fmt(sum(p['betrag'] for p in ps))}")
@@ -466,7 +651,7 @@ class App:
        else:
            self._aktualisieren()

-    def importieren(self, dateien: list[str] | None = None):
+    def importieren(self, dateien: list[str] | None = None, ziel: int | None = None):
        if not dateien:
            dateien = list(filedialog.askopenfilenames(
                parent=self.root, title="Provisionsabrechnungen importieren",
@@ -477,7 +662,22 @@ class App:
        if not dateien:
            return
        self.settings["import_ordner"] = str(Path(dateien[0]).parent)
-        if not self._brauche_abrechnung() or self._gesperrt():
+        if ziel is None:  # jedes Mal fragen, in welche Abrechnung
+            if not self.db.abrechnungen():
+                if not self.neu():
+                    return
+            else:
+                res = dlg.AbrechnungenDialog(self.root, self.db, self.aid, fuer_import=True).zeigen()
+                if not res:
+                    return
+                if res[0] == "neu":
+                    if not self.neu():
+                        return
+                else:
+                    self.aid, self.ansicht = res[1], ALLE
+        else:
+            self.aid = ziel
+        if self._gesperrt():
            return
        bericht = []
        self.root.configure(cursor="watch")
@@ -968,15 +1168,22 @@ class App:
        res = dlg.EinstellungenDialog(self.root, self.settings, str(self.db.path)).zeigen()
        if not res:
            return
-        if res["design"] != w.DESIGN:
-            self.settings["design"] = res["design"]
-            config.save(self.settings)
-            w.info(self.root, "Einstellungen", "Das neue Design wird beim nächsten Programmstart wirksam.")
        if res["pfad"] and Path(res["pfad"]) != self.db.path:
            try:
                self.db_wechseln(res["pfad"])
            except Exception as exc:
                w.fehler(self.root, "Einstellungen", f"Datenbank konnte nicht geöffnet werden:\n{exc}")
+        if res["design"] != w.DESIGN:
+            self.design_wechseln(res["design"])
+
+    def design_umschalten(self):
+        self.design_wechseln("modern" if w.DUNKEL else "dunkel")
+
+    def design_wechseln(self, design: str):
+        """Fenster mit dem neuen Design neu aufbauen (main() startet es nach dem Schließen wieder)."""
+        self.settings["design"] = design
+        self.neustart = True
+        self.root.after_idle(self.beenden)

    def hilfe(self):
        w.info(self.root, "Kurzanleitung",
@@ -1018,7 +1225,7 @@ class App:
            self.ansicht = ALLE
            self._aktualisieren()
            if res["dateien"]:
-                self.importieren(res["dateien"])
+                self.importieren(res["dateien"], ziel=self.aid)
        if res["rundgang"]:
            self.root.after(200, self.rundgang)

@@ -1035,7 +1242,7 @@ class App:
             "(freenet-Unterhändlernummer, Vodafone-VO-Nr. oder Kundenname in GROSSBUCHSTABEN)."),
            (tb["Neu"], "Neue Abrechnung",
             "Für jeden Abrechnungszeitraum – meist ein Monat – legen Sie eine neue Abrechnung an. "
-             "Mit „Öffnen“ holen Sie frühere Abrechnungen wieder hervor."),
+             "Frühere Abrechnungen öffnen Sie mit einem Klick in der Liste darunter."),
            (tb["Import"], "Dateien importieren",
             "Wählen Sie die CSV- und Excel-Dateien von freenet und Vodafone – gerne mehrere auf einmal. "
             "Das Programm erkennt das Format selbst und warnt bei doppelt importierten Dateien."),
@@ -1043,25 +1250,29 @@ class App:
             "Links sehen Sie jeden Händler mit Anzahl der Positionen und Auszahlungssumme.\n\n"
             "„(Nicht zugeordnet)“ ist alles, was keinem Unterhändler gehört – meist Ihre eigene Filiale. "
             "Das wird nicht exportiert."),
+            (self.pills["alle"], "Filter",
+             "Mit diesen Knöpfen zeigen Sie nur bestimmte Positionen: nicht zugeordnete, von Hand geänderte, "
+             "doppelte oder bereits abgerechnete."),
            (self.f_p, "Positionen prüfen",
             "Rechts stehen die Positionen des gewählten Händlers, gruppiert nach Provisionsart.\n\n"
             "- Doppelklick auf eine Position: Betrag frei ändern\n"
             "- Rechtsklick: Auszahlung 0 €, Händler zuweisen, ...\n"
             "- Blau = von Hand geändert, Rot = durch Prozent-Regel geändert"),
            (self.b_prozent, "Auszahlung in Prozent",
-             "Graue Gruppenzeile (Provisionsart) markieren und hier klicken – z. B. 80 % für den Sonderbonus. "
+             "Gruppenzeile (Provisionsart) markieren und hier klicken – z. B. 80 % für den Sonderbonus. "
             "Mit „Als Standard merken“ gilt das auch in den nächsten Monaten automatisch."),
            (tb["Export"], "Exportieren",
-             "Zum Schluss erstellt „Export“ für jeden Händler eine Excel-Datei im gewohnten Abrechnungsformat "
+             "Zum Schluss erstellt „Exportieren“ für jeden Händler eine Excel-Datei im gewohnten Abrechnungsformat "
             "(Airtime darin als eine Summenzeile) und – falls vorhanden – die Airtime-Liste."),
            (self.status, "Summen",
             "Unten sehen Sie immer die Summe der angezeigten bzw. markierten Positionen: "
             "Provision laut Anbieter und Ihre Auszahlung."),
            (self._suchrahmen, "Suchen",
             "Rufnummer, Name oder Tarif eingeben – die Liste filtert sofort. Tastenkürzel: Strg+F."),
-            (self.menueleiste.knoepfe["?"], "Das war's!",
-             "Diesen Rundgang, den Einrichtungs-Assistenten und die Tipps finden Sie jederzeit hier im Menü „?“.\n\n"
-             "Viel Erfolg mit dem Provisions-Manager 95!"),
+            (self.menueleiste.knoepfe[self.hilfe_menue], "Das war's!",
+             "Diesen Rundgang, den Einrichtungs-Assistenten und die Tipps finden Sie jederzeit hier im Menü "
+             f"„{self.hilfe_menue}“.\n\n"
+             f"Viel Erfolg mit dem {w.APP_NAME}!"),
        ]
        self._rundgang = ass.Rundgang(self, schritte)

@@ -1073,7 +1284,7 @@ class App:
        text = "".join(traceback.format_exception(exc, val, tb))
        try:
            with (config.app_dir() / "fehler.log").open("a", encoding="utf-8") as f:
-                f.write(f"--- {date.today().isoformat()} {APP_NAME}\n{text}\n")
+                f.write(f"--- {date.today().isoformat()} {w.APP_NAME}\n{text}\n")
        except OSError:
            pass
        # Beim/nach dem Beenden keine Meldung mehr zeigen – das Fenster gibt es dann nicht mehr
@@ -1164,11 +1375,16 @@ def main():
            ctypes.windll.shcore.SetProcessDpiAwareness(1)
        except Exception:
            pass
+    dateien = [a for a in sys.argv[1:] if Path(a).exists()]
+    while True:
        root = tk.Tk(className="Provisionsmanager95")
        app = App(root)
-    if len(sys.argv) > 1:
-        root.after(200, lambda: app.importieren([a for a in sys.argv[1:] if Path(a).exists()]))
+        if dateien:
+            root.after(200, lambda: app.importieren(dateien))
+            dateien = []
        root.mainloop()
+        if not app.neustart:  # sonst: Design wurde umgeschaltet – Fenster neu aufbauen
+            break


 if __name__ == "__main__":
@@ -7,7 +7,6 @@ from collections import Counter, defaultdict
 from pathlib import Path
 from tkinter import filedialog, ttk

-from provtool import APP_NAME
 from provtool.db import CAPS_ANBIETER, CAPS_WERT, Haendler, ist_grossgeschrieben
 from provtool.gui import win32
 from provtool.gui import win95 as w
@@ -33,7 +32,7 @@ class Einrichtungsassistent(w.Dialog):
    BREITE, HOEHE = 470, 340

    def __init__(self, app):
-        super().__init__(app.root, "Provisions-Manager 95 – Einrichtung")
+        super().__init__(app.root, f"{w.APP_NAME} – Einrichtung")
        self.app = app
        self.dateien: list[str] = []
        self.vorschlaege: dict[str, list[str]] = {"freenet": [], "vodafone": []}
@@ -75,9 +74,9 @@ class Einrichtungsassistent(w.Dialog):
        self._img = w.make_icon(self, "app", 7)
        c.create_rectangle(0, self.HOEHE - 70, 160, self.HOEHE + 10, fill="#006060", outline="")
        for i, (x, y) in enumerate(((20, 30), (120, 55), (35, 120), (128, 150), (60, 20))):
-            c.create_rectangle(x, y, x + 2 + i % 2, y + 2 + i % 2, fill=w.WHITE, outline="")
+            c.create_rectangle(x, y, x + 2 + i % 2, y + 2 + i % 2, fill="#ffffff", outline="")
        c.create_image(77, self.HOEHE // 2 - 10, image=self._img)
-        c.create_text(77, self.HOEHE - 38, text="Provisions-\nManager 95", fill=w.WHITE, font=w.FONT_BOLD,
+        c.create_text(77, self.HOEHE - 38, text=w.APP_NAME.replace("-", "-\n", 1), fill="#ffffff", font=w.FONT_BOLD,
                      justify="center")

    def _leeren(self):
@@ -100,7 +99,7 @@ class Einrichtungsassistent(w.Dialog):
        self.b_zurueck.configure(state="normal" if nr > 0 else "disabled")
        self.b_weiter.configure(text="Fertig stellen" if nr == len(self.seiten) - 1 else "Weiter >")
        if self.titelleiste:
-            self.titelleiste.set_titel(f"Provisions-Manager 95 – Einrichtung (Schritt {nr + 1} von {len(self.seiten)})")
+            self.titelleiste.set_titel(f"{w.APP_NAME} – Einrichtung (Schritt {nr + 1} von {len(self.seiten)})")

    def _weiter(self):
        pruefer = getattr(self, f"_pruefe_{self.nr}", None)
@@ -128,7 +127,7 @@ class Einrichtungsassistent(w.Dialog):

    # ---------------------------------------------------------------- Seite 1
    def _s_willkommen(self):
-        self._ueberschrift(f"Willkommen beim {APP_NAME}!")
+        self._ueberschrift(f"Willkommen beim {w.APP_NAME}!")
        self._text("Dieser Assistent richtet das Programm in wenigen Schritten ein:")
        for punkt in ("Speicherort der Daten festlegen",
                      "Unterhändler mit ihren Kennungen anlegen",
@@ -384,7 +383,7 @@ class Einrichtungsassistent(w.Dialog):
    def _s_fertig(self):
        self._ueberschrift("Fertig!")
        n = len(self.app.db.haendler_liste())
-        self._text(f"Der {APP_NAME} ist eingerichtet.")
+        self._text(f"Der {w.APP_NAME} ist eingerichtet.")
        self._text(f"     -  {n} Händler angelegt")
        if self.v_abrechnung.get():
            self._text(f"     -  Abrechnung „{self.v_titel.get().strip()}“"
@@ -582,13 +581,14 @@ class TippDesTages(w.Dialog):
        haupt.pack(padx=12, pady=12)
        box = tk.Frame(haupt, bg=w.WHITE, bd=2, relief="sunken")
        box.pack(side="left", fill="both")
-        self._bild = tipp_bild(self)
-        self.bild_ok = self._bild is not None
-        if self._bild is None:  # Ersatz, falls das Bild fehlt
+        # Büroklammer nur im Win95-Design; modern eine schlichte Glühbirne
+        self._bild = None if w.MODERN else tipp_bild(self)
+        self.bild_ok = self._bild is not None or w.MODERN
+        if self._bild is None:
            self._bild = w.make_icon(self, "birne", 3)
        tk.Label(box, image=self._bild, bg=w.WHITE).pack(side="left", anchor="n", padx=(12, 4), pady=10)
        # fester Textbereich: der Tipp bricht darin um und kann nicht mehr abgeschnitten werden
-        rechts = tk.Frame(box, bg=w.WHITE, padx=12, pady=10, width=380, height=self._bild.height() + 20)
+        rechts = tk.Frame(box, bg=w.WHITE, padx=12, pady=10, width=380, height=max(self._bild.height(), 170) + 20)
        rechts.pack(side="left", fill="both")
        rechts.pack_propagate(False)
        tk.Label(rechts, text="Wussten Sie schon...", bg=w.WHITE, font=(w.FONT_FAMILY, w.FONT_SIZE + 6, "bold"),
@@ -4,7 +4,7 @@ from __future__ import annotations
 import tkinter as tk
 from tkinter import filedialog, ttk

-from provtool import APP_NAME, APP_ORG, __version__
+from provtool import APP_ORG, __version__
 from provtool import regeln
 from provtool import zeitraum as zr
 from provtool.db import CAPS_ANBIETER, CAPS_WERT, AbrechnungErledigt, Datenbank, Haendler
@@ -558,10 +558,13 @@ class ProvisionsartenDialog(w.Dialog):
 # =========================================================================== Abrechnungen

 class AbrechnungenDialog(w.Dialog):
-    def __init__(self, master, db: Datenbank, aktuelle_id: int | None):
-        super().__init__(master, "Abrechnung öffnen", resizable=True)
+    def __init__(self, master, db: Datenbank, aktuelle_id: int | None, fuer_import: bool = False):
+        """fuer_import: Ziel eines Imports wählen (Ergebnis ("oeffnen", id) oder ("neu",))."""
+        super().__init__(master, "Import – in welche Abrechnung?" if fuer_import else "Abrechnung öffnen",
+                         resizable=True)
        self.db = db
-        tk.Label(self, text="Gespeicherte Abrechnungen:", anchor="w").pack(fill="x", padx=10, pady=(10, 2))
+        tk.Label(self, text="In welche Abrechnung sollen die Dateien importiert werden?" if fuer_import
+                 else "Gespeicherte Abrechnungen:", anchor="w").pack(fill="x", padx=10, pady=(10, 2))
        r, self.tree = w.scroll_tree(self, columns=("titel", "status", "geaendert", "anzahl", "dateien"),
                                     show="headings", height=12, selectmode="browse")
        for c, t, b in (("titel", "Bezeichnung", 180), ("status", "Status", 110), ("geaendert", "Zuletzt geändert", 120),
@@ -572,6 +575,10 @@ class AbrechnungenDialog(w.Dialog):
        self.tree.bind("<Double-1>", lambda e: self._oeffnen())
        k = tk.Frame(self, bg=w.FACE)
        k.pack(fill="x", padx=10, pady=10)
+        if fuer_import:
+            w.knopf(k, "Hierhin importieren", self._oeffnen, default="active").pack(side="left")
+            w.knopf(k, "Neue Abrechnung...", self._neu).pack(side="left", padx=6)
+        else:
            w.knopf(k, "Öffnen", self._oeffnen, breite=10, default="active").pack(side="left")
            w.knopf(k, "Umbenennen...", self._umbenennen, breite=12).pack(side="left", padx=6)
            w.knopf(k, "Löschen", self._loeschen, breite=10).pack(side="left")
@@ -600,6 +607,10 @@ class AbrechnungenDialog(w.Dialog):
            self.result = ("oeffnen", self._sel())
            self.destroy()

+    def _neu(self):
+        self.result = ("neu",)
+        self.destroy()
+
    def _umbenennen(self):
        aid = self._sel()
        if not aid:
@@ -857,10 +868,15 @@ class ExportDialog(w.Dialog):
        """haendler: (id, name, anzahl, summe_cent)"""
        super().__init__(master, "Abrechnungen exportieren")
        self.settings = settings
-        f = tk.Frame(self, bg=w.FACE)
-        f.pack(fill="both", expand=True, padx=10, pady=10)
+        rumpf = tk.Frame(self, bg=w.FACE)
+        rumpf.pack(fill="both", expand=True, padx=10, pady=10)
+        # zwei Spalten (links Händler, rechts Zeitraum und Optionen) – passt auch auf kleine Bildschirme
+        f = tk.Frame(rumpf, bg=w.FACE)
+        f.pack(side="left", fill="both", expand=True)
+        rechts = tk.Frame(rumpf, bg=w.FACE)
+        rechts.pack(side="left", fill="y", padx=(14, 0))
        tk.Label(f, text="Für welche Händler soll eine Excel-Datei erstellt werden?", anchor="w").pack(fill="x")
-        r, self.tree = w.scroll_tree(f, columns=("name", "anzahl", "summe"), show="tree headings", height=8,
+        r, self.tree = w.scroll_tree(f, columns=("name", "anzahl", "summe"), show="tree headings", height=12,
                                     selectmode="extended")
        self.tree.heading("#0", text="")
        self.tree.column("#0", width=40, stretch=False)
@@ -880,7 +896,7 @@ class ExportDialog(w.Dialog):
        w.knopf(kk, "Alle", lambda: self._alle(True)).pack(side="left")
        w.knopf(kk, "Keine", lambda: self._alle(False)).pack(side="left", padx=4)

-        g = w.gruppe(f, "Optionen")
+        g = w.gruppe(rechts, "Optionen")
        g.pack(fill="x", pady=(8, 0))
        tk.Label(g, text="Bezeichnung im Dateinamen:").grid(row=0, column=0, sticky="w")
        self.v_titel = tk.StringVar(value=titel)
@@ -902,13 +918,14 @@ class ExportDialog(w.Dialog):
                ("Summenzeile unter der Tabelle", self.v_sum),
                ("Ordner nach dem Export öffnen", self.v_auf)), start=2):
            tk.Checkbutton(g, text=text, variable=var).grid(row=zeile, column=0, columnspan=3, sticky="w")
-        tk.Label(g, text="Airtime steht in der Abrechnung als eine Summenzeile, die Einzelposten kommen in eine\n"
-                         "eigene Datei „... - Airtime - ...xlsx“.", fg=w.SHADOW, justify="left", anchor="w").grid(
+        tk.Label(g, text="Airtime steht in der Abrechnung als eine Summenzeile, die Einzelposten kommen in eine "
+                         "eigene Datei „... - Airtime - ...xlsx“.", fg=w.SHADOW, justify="left", anchor="w",
+                 wraplength=420).grid(
            row=7, column=0, columnspan=3, sticky="w", pady=(4, 0))
        g.columnconfigure(1, weight=1)

-        z = w.gruppe(f, "Zeitraum und Abrechnung")
-        z.pack(fill="x", pady=(8, 0))
+        z = w.gruppe(rechts, "Zeitraum und Abrechnung")
+        z.pack(fill="x", before=g)
        zf = tk.Frame(z, bg=w.FACE)
        zf.pack(fill="x")
        tk.Label(zf, text="Nur von:").pack(side="left")
@@ -917,14 +934,18 @@ class ExportDialog(w.Dialog):
        tk.Label(zf, text="bis:").pack(side="left")
        tk.Entry(zf, textvariable=self.v_bis, width=11).pack(side="left", padx=4)
        w.knopf(zf, "Vormonat", self._vormonat).pack(side="left", padx=(4, 0))
+        # ohne Zeitraum = alles, was noch nicht abgerechnet ist (abgerechnete Positionen exportiert er nie)
+        w.knopf(zf, "Noch nicht abgerechnet", lambda: (self.v_von.set(""), self.v_bis.set(""))).pack(
+            side="left", padx=(4, 0))
        self.v_basis = tk.StringVar(value=zr.BASEN[settings.get("export_basis", zr.AKTIVIERUNG)])
        ttk.Combobox(z, textvariable=self.v_basis, values=list(zr.BASEN.values()), state="readonly",
                     width=40).pack(anchor="w", pady=(4, 0))
-        tk.Label(z, text="(leer = alle offenen Positionen; Datum als TT.MM.JJJJ)", fg=w.SHADOW, anchor="w").pack(
-            fill="x")
+        tk.Label(z, text="(leer bzw. „Noch nicht abgerechnet“ = alle offenen Positionen; Datum als TT.MM.JJJJ)",
+                 fg=w.SHADOW, anchor="w", justify="left", wraplength=420).pack(fill="x")
        self.v_kennz = tk.BooleanVar(value=True)
        tk.Checkbutton(z, text="Exportierte Positionen als abgerechnet kennzeichnen (werden dann nicht noch "
-                               "einmal abgerechnet)", variable=self.v_kennz, anchor="w").pack(fill="x", pady=(4, 0))
+                               "einmal abgerechnet)", variable=self.v_kennz, anchor="w", justify="left",
+                       wraplength=400).pack(fill="x", pady=(4, 0))
        self.knopfleiste([("Exportieren", self._ok), ("Abbrechen", self.abbrechen)]).pack(pady=(0, 10))

    def _vormonat(self):
@@ -1000,10 +1021,11 @@ class EinstellungenDialog(w.Dialog):
        g2 = w.gruppe(self, "Darstellung")
        g2.pack(fill="x", padx=10, pady=(0, 10))
        self.v_design = tk.StringVar(value=settings.get("design", "modern"))
-        tk.Radiobutton(g2, text="Modern (wie Windows 11)", variable=self.v_design, value="modern").pack(anchor="w")
+        tk.Radiobutton(g2, text="Modern hell", variable=self.v_design, value="modern").pack(anchor="w")
+        tk.Radiobutton(g2, text="Modern dunkel", variable=self.v_design, value="dunkel").pack(anchor="w")
        tk.Radiobutton(g2, text="Klassisch (Windows 95, Legacy)", variable=self.v_design, value="win95").pack(
            anchor="w")
-        tk.Label(g2, text="Wirkt beim nächsten Programmstart.", fg=w.SHADOW).pack(anchor="w")
+        tk.Label(g2, text="Das Fenster wird nach OK mit dem neuen Design neu aufgebaut.", fg=w.SHADOW).pack(anchor="w")
        self.knopfleiste([("OK", self._ok), ("Abbrechen", self.abbrechen)]).pack(pady=(0, 10))

    def _waehlen(self):
@@ -1022,7 +1044,7 @@ class EinstellungenDialog(w.Dialog):

 class InfoDialog(w.Dialog):
    def __init__(self, master):
-        super().__init__(master, f"Info über {APP_NAME}")
+        super().__init__(master, f"Info über {w.APP_NAME}")
        top = tk.Frame(self, bg=w.FACE)
        top.pack(padx=14, pady=14)
        c = tk.Canvas(top, width=110, height=110, bg=w.TEAL, bd=2, relief="sunken", highlightthickness=0)
@@ -1031,7 +1053,7 @@ class InfoDialog(w.Dialog):
        c.create_image(57, 57, image=self._img)
        rechts = tk.Frame(top, bg=w.FACE)
        rechts.pack(side="left", padx=(14, 0), anchor="n")
-        tk.Label(rechts, text=APP_NAME, font=w.FONT_BIG).pack(anchor="w")
+        tk.Label(rechts, text=w.APP_NAME, font=w.FONT_BIG).pack(anchor="w")
        tk.Label(rechts, text=f"Version {__version__}", anchor="w").pack(anchor="w")
        w.trenner(rechts, vertikal=False).pack(fill="x", pady=8)
        tk.Label(rechts, text=f"Lizenziert für:\n{APP_ORG}\n\nProvisionsabrechnung für Unterhändler\n"
@@ -226,7 +226,8 @@ class Menueleiste(tk.Frame):
        self.offener_knopf: tk.Label | None = None

    def menue(self, label: str, underline: int | None = 0) -> Popup:
-        knopf = tk.Label(self, text=label, bg=w.FACE, padx=7, pady=2, bd=1, relief="flat",
+        knopf = tk.Label(self, text=label, bg=w.FACE, padx=10 if w.MODERN else 7, pady=6 if w.MODERN else 2,
+                         bd=1, relief="flat",
                         underline=-1 if underline is None else underline)
        knopf.pack(side="left")
        popup = Popup(self)
@@ -414,6 +414,11 @@ class Hauptrahmen:
        self._nativ_einrichten()
        if maximiert and self.klassisch:
            self.root.after(100, self.maximieren)
+        elif maximiert:  # normaler Windows-Rahmen: Windows maximiert selbst
+            try:
+                self.root.state("zoomed")
+            except tk.TclError:
+                self.root.attributes("-zoomed", True)  # Linux/X11

    def normale_geometrie(self) -> str:
        return self._normal_geo if self.maximiert and self._normal_geo else self.root.geometry()
@@ -0,0 +1,93 @@
+Copyright © 2017 IBM Corp. with Reserved Font Name "Plex"
+
+This Font Software is licensed under the SIL Open Font License, Version 1.1.
+
+This license is copied below, and is also available with a FAQ at: http://scripts.sil.org/OFL
+
+
+-----------------------------------------------------------
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded, 
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
@@ -80,6 +80,19 @@ def hwnd(fenster: tk.Misc) -> int | None:
        return None


+def dunkle_titelleiste(fenster: tk.Misc) -> None:
+    """Windows-Titelleiste dunkel (Design „dunkel“, ab Windows 10 20H1)."""
+    h = hwnd(fenster)
+    if not h:
+        return
+    try:
+        import ctypes
+        an = ctypes.c_int(1)
+        ctypes.windll.dwmapi.DwmSetWindowAttribute(h, 20, ctypes.byref(an), ctypes.sizeof(an))  # IMMERSIVE_DARK_MODE
+    except (OSError, AttributeError):
+        pass
+
+
 def stapel(*fenster: tk.Misc) -> list[int]:
    """Reihenfolge der übergebenen Fenster im Windows-Fensterstapel, oberstes zuerst (Indizes)."""
    ziele = [hwnd(f) for f in fenster]
@@ -7,6 +7,7 @@ from __future__ import annotations

 import sys
 import tkinter as tk
+from pathlib import Path
 from tkinter import ttk

 FACE = "#c0c0c0"
@@ -21,16 +22,35 @@ INFO_BG = "#ffffe1"
 SEL_BG, SEL_FG = NAVY, WHITE   # Auswahl/Markierung
 RAND = SHADOW                  # dünne Rahmenlinien (nur modern)
 DESIGN = "win95"
-MODERN = False
+MODERN = False                 # „modern“ oder „dunkel“
+DUNKEL = False
+APP_NAME = "Provisions-Manager 95"   # modern: ohne „95“

+# Farbnamen: FACE = Fläche (Fenster, Karten, Dialoge), BG = Grund hinter den Karten, WHITE = Eingabefelder/Listen,
+# DARK = Text, TEXT2 = Nebentext, SHADOW = leiser Text/Win95-Schatten, NAVY = Akzent, RAND/RAND2 = Linien,
+# PRIMAER/AUF_PRIMAER = Hauptknopf, MANUELL = von Hand geänderte Beträge, *_SOFT = Grund der Status-Pills.
 _PALETTEN = {
    "win95": dict(FACE="#c0c0c0", HILITE="#ffffff", LIGHT="#dfdfdf", SHADOW="#808080", DARK="#000000",
                  NAVY="#000080", TEAL="#008080", WHITE="#ffffff", INFO_BG="#ffffe1", SEL_BG="#000080",
-                  SEL_FG="#ffffff", RAND="#808080"),
-    "modern": dict(FACE="#f3f3f3", HILITE="#ffffff", LIGHT="#ebebeb", SHADOW="#8a8a8a", DARK="#1b1b1b",
-                   NAVY="#005fb8", TEAL="#e6eef6", WHITE="#ffffff", INFO_BG="#ffffff", SEL_BG="#cce4f7",
-                   SEL_FG="#1b1b1b", RAND="#d1d1d1"),
+                  SEL_FG="#ffffff", RAND="#808080", BG="#008080", RAND2="#808080", TEXT2="#000000",
+                  PRIMAER="#c0c0c0", AUF_PRIMAER="#000000", ZEBRA="#ffffff", MANUELL="#0000c0", ROT="#a00000",
+                  ROT_SOFT="#c0c0c0", GRUEN="#008000", GRUEN_SOFT="#c0c0c0", BLAU="#0000ff", BLAU_SOFT="#c0c0c0",
+                  GOLD="#808000", GOLD_SOFT="#c0c0c0"),
+    # Hausfarben der Handy-Insel-Webtools (VVL-Tool): Lila, IBM Plex
+    "modern": dict(FACE="#ffffff", HILITE="#ffffff", LIGHT="#f1edf8", SHADOW="#6b6386", DARK="#211a38",
+                   NAVY="#5e35b1", TEAL="#f1eef8", WHITE="#ffffff", INFO_BG="#ffffff", SEL_BG="#ede7fa",
+                   SEL_FG="#2d1b69", RAND="#e5e0f0", BG="#f1eef8", RAND2="#d6cee8", TEXT2="#5b5372",
+                   PRIMAER="#2d1b69", AUF_PRIMAER="#ffffff", ZEBRA="#faf8fd", MANUELL="#5e35b1", ROT="#b8223f",
+                   ROT_SOFT="#fbe4e9", GRUEN="#11734d", GRUEN_SOFT="#def3ea", BLAU="#2a59c4", BLAU_SOFT="#e4ebfb",
+                   GOLD="#8a6212", GOLD_SOFT="#f7eed8"),
+    "dunkel": dict(FACE="#1c1436", HILITE="#1c1436", LIGHT="#2a2049", SHADOW="#948daa", DARK="#ece8f6",
+                   NAVY="#a88beb", TEAL="#120c22", WHITE="#221940", INFO_BG="#2a2049", SEL_BG="#3a2d66",
+                   SEL_FG="#ece8f6", RAND="#312551", BG="#120c22", RAND2="#3f3167", TEXT2="#ada5c6",
+                   PRIMAER="#c3adee", AUF_PRIMAER="#1c1436", ZEBRA="#201838", MANUELL="#c3adee", ROT="#f26982",
+                   ROT_SOFT="#3a1e28", GRUEN="#4fc796", GRUEN_SOFT="#163025", BLAU="#7da0f0", BLAU_SOFT="#1e2743",
+                   GOLD="#d8b058", GOLD_SOFT="#332a17"),
 }
+globals().update(_PALETTEN["win95"])

 IS_WIN = sys.platform.startswith("win")
 FONT_FAMILY = "MS Sans Serif" if IS_WIN else "DejaVu Sans"
@@ -38,25 +58,57 @@ FONT_SIZE = 8 if IS_WIN else 9
 FONT = (FONT_FAMILY, FONT_SIZE)
 FONT_BOLD = (FONT_FAMILY, FONT_SIZE, "bold")
 FONT_BIG = (FONT_FAMILY, FONT_SIZE + 4, "bold")
-FONT_MONO = ("Courier New" if IS_WIN else "DejaVu Sans Mono", FONT_SIZE + 1)
+MONO_FAMILY = "Courier New" if IS_WIN else "DejaVu Sans Mono"
+FONT_MONO = (MONO_FAMILY, FONT_SIZE + 1)
+FONT_KLEIN_FETT = FONT_TITEL = FONT_ZAHL = FONT_BOLD


 def design_setzen(name: str) -> None:
-    """„modern“ oder „win95“ – setzt Farben und Schriften (Feinschliff der Schrift in apply())."""
-    global DESIGN, MODERN, FONT_FAMILY, FONT_SIZE
+    """„modern“ (hell), „dunkel“ oder „win95“ – setzt Farben und Schriften (Feinschliff der Schrift in apply())."""
+    global DESIGN, MODERN, DUNKEL, FONT_FAMILY, FONT_SIZE, APP_NAME, MONO_FAMILY
    DESIGN = name if name in _PALETTEN else "modern"
-    MODERN = DESIGN == "modern"
+    MODERN = DESIGN in ("modern", "dunkel")
+    DUNKEL = DESIGN == "dunkel"
+    APP_NAME = "Provisions-Manager" if MODERN else "Provisions-Manager 95"
    globals().update(_PALETTEN[DESIGN])
    FONT_FAMILY = ("Segoe UI" if MODERN else "MS Sans Serif") if IS_WIN else "DejaVu Sans"
-    FONT_SIZE = 9 if (MODERN or not IS_WIN) else 8
+    MONO_FAMILY = ("Consolas" if MODERN else "Courier New") if IS_WIN else "DejaVu Sans Mono"
+    FONT_SIZE = 10 if MODERN else (8 if IS_WIN else 9)
    _schriften()


 def _schriften():
-    global FONT, FONT_BOLD, FONT_BIG
+    global FONT, FONT_BOLD, FONT_BIG, FONT_MONO, FONT_KLEIN_FETT, FONT_TITEL, FONT_ZAHL
    FONT = (FONT_FAMILY, FONT_SIZE)
    FONT_BOLD = (FONT_FAMILY, FONT_SIZE, "bold")
    FONT_BIG = (FONT_FAMILY, FONT_SIZE + 4, "bold")
+    FONT_MONO = (MONO_FAMILY, FONT_SIZE + (0 if MODERN else 1))
+    FONT_KLEIN_FETT = (FONT_FAMILY, FONT_SIZE - 2, "bold")   # Abschnitts-Überschriften (ABRECHNUNGEN …)
+    FONT_TITEL = (FONT_FAMILY, FONT_SIZE + 8, "bold")        # Name der geöffneten Abrechnung
+    FONT_ZAHL = (MONO_FAMILY, FONT_SIZE + 6) if MODERN else (FONT_FAMILY, FONT_SIZE + 4, "bold")  # Kennzahlen
+
+
+SCHRIFTEN = Path(__file__).resolve().parent / "schriften"
+
+
+def _schriften_laden() -> None:
+    """IBM Plex (Hausschrift der Handy-Insel-Webtools) nur für dieses Programm laden – ohne Installation."""
+    import ctypes
+    import ctypes.util
+    dateien = sorted(SCHRIFTEN.glob("*.ttf"))
+    try:
+        if IS_WIN:
+            for f in dateien:
+                ctypes.windll.gdi32.AddFontResourceExW(str(f), 0x10, 0)  # FR_PRIVATE
+            return
+        lib = ctypes.util.find_library("fontconfig")
+        if lib:
+            fc = ctypes.CDLL(lib)
+            fc.FcConfigAppFontAddFile.argtypes = [ctypes.c_void_p, ctypes.c_char_p]
+            for f in dateien:
+                fc.FcConfigAppFontAddFile(None, str(f).encode())
+    except Exception:
+        pass  # dann eben Segoe UI / Systemschrift

 # --------------------------------------------------------------------------- Pixel-Icons (16x16)
 PALETTE = {
@@ -295,7 +347,13 @@ def _icon_rows(name: str) -> list[str]:
    return [r.ljust(16, ".")[:16] for r in rows[:16]] + ["." * 16] * (16 - len(rows))


+MODERNE_ICONS = Path(__file__).resolve().parent / "bilder" / "modern"
+
+
 def make_icon(master, name: str, scale: int = 1) -> tk.PhotoImage:
+    datei = MODERNE_ICONS / f"{name}{'_gross' if scale > 1 else ''}.png"
+    if MODERN and datei.exists():  # glatte Symbole aus build/make_moderne_icons.py
+        return tk.PhotoImage(master=master, file=str(datei))
    img = tk.PhotoImage(master=master, width=16 * scale, height=16 * scale)
    for y, row in enumerate(_icon_rows(name)):
        for x, ch in enumerate(row):
@@ -323,12 +381,15 @@ class Icons:
 # --------------------------------------------------------------------------- Theme

 def apply(root: tk.Tk) -> None:
-    global FONT_FAMILY
-    if MODERN and not IS_WIN:  # Linux: die erste vorhandene moderne Schrift
+    global FONT_FAMILY, MONO_FAMILY
+    if MODERN:  # die erste vorhandene moderne Schrift, am liebsten IBM Plex
        from tkinter import font as tkfont
+        _schriften_laden()
        vorhanden = set(tkfont.families(root))
-        FONT_FAMILY = next((f for f in ("Segoe UI", "Noto Sans", "Cantarell", "Ubuntu", "DejaVu Sans")
-                            if f in vorhanden), FONT_FAMILY)
+        FONT_FAMILY = next((f for f in ("IBM Plex Sans", "Segoe UI", "Noto Sans", "Cantarell", "Ubuntu",
+                                        "DejaVu Sans") if f in vorhanden), FONT_FAMILY)
+        MONO_FAMILY = next((f for f in ("IBM Plex Mono", "Consolas", "DejaVu Sans Mono") if f in vorhanden),
+                           MONO_FAMILY)
        _schriften()
    root.configure(bg=FACE)
    o = root.option_add
@@ -390,40 +451,61 @@ def apply(root: tk.Tk) -> None:


 def _modern(root: tk.Tk, st: ttk.Style, zeile: int) -> None:
-    """Flach und hell: dünne graue Rahmen statt 3D-Kanten, Akzentfarbe beim Fokus."""
+    """Flach wie die Handy-Insel-Webtools: weiße Flächen, dünne Linien, Lila als Akzent."""
    o = root.option_add
    for klasse in ("Entry", "Text", "Listbox", "Spinbox"):
        o(f"*{klasse}.relief", "flat")
-        o(f"*{klasse}.borderWidth", 3)
+        o(f"*{klasse}.borderWidth", 4)
        o(f"*{klasse}.highlightThickness", 1)
-        o(f"*{klasse}.highlightBackground", RAND)
+        o(f"*{klasse}.highlightBackground", RAND2)
        o(f"*{klasse}.highlightColor", NAVY)
+        o(f"*{klasse}.background", WHITE)
+        o(f"*{klasse}.foreground", DARK)
+        o(f"*{klasse}.insertBackground", DARK)
+    o("*Entry.disabledBackground", LIGHT)
    o("*Button.relief", "flat")
    o("*Button.borderWidth", 0)
    o("*Button.highlightThickness", 1)
-    o("*Button.highlightBackground", RAND)
-    o("*Button.background", WHITE)
-    o("*Button.activeBackground", SEL_BG)
-    o("*Button.padY", 3)
-    o("*Checkbutton.activeBackground", FACE)
-    o("*Radiobutton.activeBackground", FACE)
+    o("*Button.highlightBackground", RAND2)
+    o("*Button.background", FACE)
+    o("*Button.activeBackground", LIGHT)
+    o("*Button.padX", 12)
+    o("*Button.padY", 4)
+    o("*Button.cursor", "hand2")
+    for klasse in ("Checkbutton", "Radiobutton"):
+        o(f"*{klasse}.activeBackground", FACE)
+        o(f"*{klasse}.selectColor", WHITE)
+    o("*selectBackground", SEL_BG)
+    o("*selectForeground", SEL_FG)
    o("*Menu.relief", "flat")
+    o("*TCombobox*Listbox.background", WHITE)
+    o("*TCombobox*Listbox.foreground", DARK)
+    o("*TCombobox*Listbox.selectBackground", SEL_BG)
+    o("*TCombobox*Listbox.selectForeground", SEL_FG)
    st.theme_use("clam")
    st.configure(".", background=FACE, foreground=DARK, font=FONT, troughcolor=FACE, selectbackground=SEL_BG,
-                 selectforeground=SEL_FG, fieldbackground=WHITE, bordercolor=RAND, lightcolor=WHITE,
-                 darkcolor=RAND, focuscolor=NAVY)
-    st.configure("Treeview", background=WHITE, fieldbackground=WHITE, rowheight=zeile + 4, borderwidth=0, font=FONT)
+                 selectforeground=SEL_FG, fieldbackground=WHITE, bordercolor=RAND, lightcolor=FACE,
+                 darkcolor=RAND, focuscolor=NAVY, insertcolor=DARK)
+    st.configure("Treeview", background=WHITE, fieldbackground=WHITE, foreground=DARK, rowheight=zeile + 10,
+                 borderwidth=0, font=FONT)
    st.map("Treeview", background=[("selected", SEL_BG)], foreground=[("selected", SEL_FG)])
-    st.configure("Treeview.Heading", background=WHITE, relief="flat", borderwidth=1, font=FONT, padding=(6, 3),
-                 bordercolor=RAND, lightcolor=WHITE, darkcolor=RAND)
+    st.configure("Treeview.Heading", background=FACE, foreground=SHADOW, relief="flat", borderwidth=1,
+                 font=FONT_KLEIN_FETT, padding=(10, 7), bordercolor=RAND, lightcolor=FACE, darkcolor=RAND)
    st.map("Treeview.Heading", background=[("active", LIGHT)], relief=[("pressed", "flat")])
-    st.configure("TScrollbar", background=LIGHT, troughcolor=FACE, arrowcolor=SHADOW, bordercolor=FACE,
-                 lightcolor=LIGHT, darkcolor=LIGHT, relief="flat", arrowsize=12, width=12)
-    st.map("TScrollbar", background=[("active", RAND)])
-    st.configure("TCombobox", fieldbackground=WHITE, background=WHITE, arrowcolor=DARK, padding=3,
-                 bordercolor=RAND, lightcolor=WHITE, darkcolor=WHITE)
+    # Seitenleiste: ohne Kopf, hohe Zeilen, Auswahl lila wie im VVL-Tool
+    st.configure("Seite.Treeview", background=FACE, fieldbackground=FACE, rowheight=zeile + 16, font=FONT,
+                 borderwidth=0)
+    st.layout("Seite.Treeview", [("Treeview.treearea", {"sticky": "nswe"})])  # ohne Rahmen
+    st.map("Seite.Treeview", background=[("selected", SEL_BG)], foreground=[("selected", NAVY)])
+    st.configure("TScrollbar", background=RAND2, troughcolor=FACE, arrowcolor=SHADOW, bordercolor=FACE,
+                 lightcolor=RAND2, darkcolor=RAND2, relief="flat", arrowsize=10, width=10, gripcount=0)
+    st.map("TScrollbar", background=[("active", SHADOW)])
+    st.configure("TCombobox", fieldbackground=WHITE, background=FACE, foreground=DARK, arrowcolor=DARK, padding=4,
+                 bordercolor=RAND2, lightcolor=WHITE, darkcolor=WHITE)
    st.map("TCombobox", fieldbackground=[("readonly", WHITE)], selectbackground=[("readonly", WHITE)],
           selectforeground=[("readonly", DARK)], bordercolor=[("focus", NAVY)])
+    st.configure("TPanedwindow", background=BG)
+    st.configure("Sash", sashthickness=6, background=BG)


 # --------------------------------------------------------------------------- Wort löschen
@@ -557,12 +639,19 @@ class Statusleiste(tk.Frame):
        self.vars[key].set(text)


-def knopf(master, text: str, command=None, icon: tk.PhotoImage | None = None, breite: int | None = None, **kw):
+def knopf(master, text: str, command=None, icon: tk.PhotoImage | None = None, breite: int | None = None,
+          primaer: bool = False, **kw):
+    """primaer: der eine Hauptknopf einer Fläche (modern dunkel-lila gefüllt, Win95 mit dickem Rahmen)."""
    if MODERN:
+        if primaer:
+            kw = dict(bg=PRIMAER, fg=AUF_PRIMAER, activebackground=NAVY, activeforeground=AUF_PRIMAER,
+                      highlightbackground=PRIMAER, font=FONT_BOLD) | kw
        b = tk.Button(master, text=text, command=command, **kw)  # Aussehen aus apply()/_modern()
    else:
        b = tk.Button(master, text=text, command=command, bd=2, relief="raised", bg=FACE,
                      activebackground=FACE, **kw)
+        if primaer:
+            b.configure(default="active")
    if icon is not None:
        b.configure(image=icon, compound="left", padx=6)
    if breite:
@@ -570,6 +659,115 @@ def knopf(master, text: str, command=None, icon: tk.PhotoImage | None = None, br
    return b


+class Karte(tk.Frame):
+    """Fläche, die Inhalte zusammenfasst (Kennzahl, Tabelle): modern weiß mit dünner Linie."""
+
+    def __init__(self, master, **kw):
+        if MODERN:
+            kw = dict(bg=FACE, bd=0, highlightthickness=1, highlightbackground=RAND, highlightcolor=RAND) | kw
+        else:
+            kw = dict(bg=FACE, bd=2, relief="raised") | kw
+        super().__init__(master, **kw)
+
+
+def titelleiste(master, text: str = "") -> tuple[tk.Frame, tk.Label]:
+    """Win95: blaue Titelleiste oben in einer Karte (wie bei Fenster); rechts passen kleine Knöpfe hinein."""
+    f = tk.Frame(master, bg=NAVY)
+    f.pack(fill="x", padx=1, pady=1)
+    lbl = tk.Label(f, text=text, bg=NAVY, fg=WHITE, font=FONT_BOLD, anchor="w", padx=3)
+    lbl.pack(side="left", pady=1)
+    return f, lbl
+
+
+def abschnitt(master, text: str, **kw) -> tk.Label:
+    """Kleine Überschrift (modern in Großbuchstaben und grau, wie die Tabellenköpfe der Webtools)."""
+    if MODERN:
+        return tk.Label(master, text=text.upper(), fg=SHADOW, font=FONT_KLEIN_FETT, anchor="w", **kw)
+    return tk.Label(master, text=text, font=FONT_BOLD, anchor="w", **kw)
+
+
+def _rund(c: tk.Canvas, x0, y0, x1, y1, r, **kw):
+    """Abgerundetes Rechteck auf einem Canvas."""
+    r = min(r, (x1 - x0) / 2, (y1 - y0) / 2)
+    pkt = [x0 + r, y0, x1 - r, y0, x1, y0, x1, y0 + r, x1, y1 - r, x1, y1, x1 - r, y1, x0 + r, y1, x0, y1,
+           x0, y1 - r, x0, y0 + r, x0, y0]
+    return c.create_polygon(pkt, smooth=True, **kw)
+
+
+class Pill(tk.Canvas):
+    """Umschalter für Filter („Alle“, „Von Hand geändert“ …): modern abgerundet, Win95 als Knopf,
+    der eingedrückt bleibt. command bekommt nichts übergeben; aktiv wird von außen gesetzt."""
+
+    def __init__(self, master, text: str, command=None, aktiv: bool = False, **kw):
+        from tkinter import font as tkfont
+        f = tkfont.Font(root=master, font=FONT)
+        breite, hoehe = f.measure(text) + (24 if MODERN else 16), f.metrics("linespace") + (10 if MODERN else 8)
+        bg = kw.pop("bg", master.cget("bg"))
+        super().__init__(master, width=breite, height=hoehe, bg=bg, highlightthickness=0, bd=0, takefocus=1,
+                         cursor="hand2" if MODERN else "", **kw)
+        self.text, self.command, self.aktiv = text, command, aktiv
+        self._zeichnen()
+        self.bind("<Button-1>", lambda e: self._ausloesen())
+        self.bind("<space>", lambda e: self._ausloesen())
+        self.bind("<Return>", lambda e: self._ausloesen())
+
+    def _ausloesen(self):
+        self.focus_set()
+        if self.command:
+            self.command()
+
+    def setzen(self, aktiv: bool):
+        if aktiv != self.aktiv:
+            self.aktiv = aktiv
+            self._zeichnen()
+
+    def _zeichnen(self):
+        self.delete("all")
+        b, h = int(self["width"]), int(self["height"])
+        if MODERN:
+            fuell, linie, fg = (PRIMAER, PRIMAER, AUF_PRIMAER) if self.aktiv else (FACE, RAND2, TEXT2)
+            _rund(self, 1, 1, b - 2, h - 2, h, fill=fuell, outline=linie)
+        else:
+            oben, unten = (SHADOW, HILITE) if self.aktiv else (HILITE, SHADOW)
+            self.create_rectangle(0, 0, b - 1, h - 1, fill=LIGHT if self.aktiv else FACE, outline=DARK)
+            self.create_line(1, h - 2, 1, 1, b - 2, 1, fill=oben)
+            self.create_line(1, h - 2, b - 2, h - 2, b - 2, 1, fill=unten)
+            fg = DARK
+        self.create_text(b // 2 + (1 if self.aktiv and not MODERN else 0), h // 2, text=self.text, fill=fg, font=FONT)
+
+
+def punkt(master, farbe: str, d: int = 9) -> tk.PhotoImage:
+    """Farbiger Punkt (Status in Listen); Ecken bleiben durchsichtig."""
+    img = tk.PhotoImage(master=master, width=d + 4, height=d)
+    r = d / 2
+    # Win95: grauer Ring, damit der Punkt auf weißem Grund und auf der blauen Auswahl sichtbar ist
+    for f, rr in ((farbe, r),) if MODERN else ((SHADOW, r), (farbe, r - 1)):
+        for y in range(d):
+            xs = [x for x in range(d) if (x + .5 - r) ** 2 + (y + .5 - r) ** 2 <= rr * rr]
+            if xs:
+                img.put(f, to=(xs[0], y, xs[-1] + 1, y + 1))
+    return img
+
+
+def logo(master, groesse: int = 34) -> tk.Canvas:
+    """Logo-Kachel wie in den Webtools: Lila-Verlauf, abgerundet, weißes %."""
+    c = tk.Canvas(master, width=groesse, height=groesse, bg=master.cget("bg"), highlightthickness=0, bd=0)
+    img = tk.PhotoImage(master=master, width=groesse, height=groesse)
+    a, e = (0x2d, 0x1b, 0x69), (0x5e, 0x35, 0xb1)
+    r = groesse * 0.28
+    for y in range(groesse):
+        for x in range(groesse):
+            dx = max(r - x - .5, x + .5 - (groesse - r), 0)
+            dy = max(r - y - .5, y + .5 - (groesse - r), 0)
+            if dx * dx + dy * dy <= r * r:
+                t = (x + y) / (2 * groesse - 2)
+                img.put("#%02x%02x%02x" % tuple(round(a[i] + (e[i] - a[i]) * t) for i in range(3)), (x, y))
+    c.create_image(0, 0, image=img, anchor="nw")
+    c.bild = img  # type: ignore[attr-defined]  # Referenz halten
+    c.create_text(groesse / 2, groesse / 2, text="%", fill="#ffffff", font=(FONT_FAMILY, int(groesse * .4), "bold"))
+    return c
+
+
 class ToolbarButton(tk.Label):
    """Flacher Werkzeugleisten-Knopf (Office-95-Stil): hebt sich beim Überfahren, senkt sich beim Klick."""

@@ -651,15 +849,28 @@ def gruppe(master, titel: str, **kw) -> tk.LabelFrame:
    return tk.LabelFrame(master, text=titel, bd=2, relief="groove", bg=FACE, padx=6, pady=4, **kw)


-def scroll_tree(master, **kw) -> tuple[tk.Frame, ttk.Treeview]:
-    rahmen = Sunken(master, bg=WHITE)
+def _bei_bedarf(leiste: ttk.Scrollbar):
+    """Bildlaufleiste nur zeigen, wenn nicht alles hineinpasst."""
+    def setzen(lo, hi):
+        leiste.grid() if float(lo) > 0 or float(hi) < 1 else leiste.grid_remove()
+        leiste.set(lo, hi)
+    return setzen
+
+
+def scroll_tree(master, auto: bool = False, **kw) -> tuple[tk.Frame, ttk.Treeview]:
+    """Treeview mit Bildlaufleisten (modern nur bei Bedarf). auto: keine waagrechte Leiste (Seitenleiste)."""
+    rahmen = Sunken(master, bg=WHITE if MODERN else FACE)  # Win95: graue Ecke zwischen den Leisten
    tree = ttk.Treeview(rahmen, **kw)
    vs = ttk.Scrollbar(rahmen, orient="vertical", command=tree.yview)
-    hs = ttk.Scrollbar(rahmen, orient="horizontal", command=tree.xview)
-    tree.configure(yscrollcommand=vs.set, xscrollcommand=hs.set)
    tree.grid(row=0, column=0, sticky="nsew")
    vs.grid(row=0, column=1, sticky="ns")
+    if auto and MODERN:
+        rahmen.configure(highlightthickness=0, bg=FACE)
+    if not auto:
+        hs = ttk.Scrollbar(rahmen, orient="horizontal", command=tree.xview)
        hs.grid(row=1, column=0, sticky="ew")
+        tree.configure(xscrollcommand=_bei_bedarf(hs) if MODERN else hs.set)
+    tree.configure(yscrollcommand=_bei_bedarf(vs) if auto or MODERN else vs.set)
    rahmen.rowconfigure(0, weight=1)
    rahmen.columnconfigure(0, weight=1)
    return rahmen, tree
@@ -738,6 +949,8 @@ class Dialog(tk.Toplevel):
        self.geometry(f"{w}x{h}+{max(0, x)}+{max(0, y)}")  # Größe + Position zusammen (siehe Tooltip)
        self.deiconify()
        self.update_idletasks()
+        if DUNKEL:
+            win32.dunkle_titelleiste(self)
        if KLASSISCH and win32.IS_WIN:
            # eigener Taskleisten-Eintrag; wird erst nach kurzem Aus-/Einblenden wirksam
            if win32.taskleisteneintrag(self):
@@ -787,7 +1000,7 @@ class Dialog(tk.Toplevel):
    def knopfleiste(self, knoepfe: list[tuple[str, object]], default: int = 0) -> tk.Frame:
        f = tk.Frame(self, bg=FACE)
        for i, (text, cmd) in enumerate(knoepfe):
-            b = knopf(f, text, cmd, breite=10)
+            b = knopf(f, text, cmd, breite=10, primaer=MODERN and i == default)
            if i == default:
                b.configure(default="active")
            b.pack(side="left", padx=4)
@@ -29,7 +29,8 @@ class Lauf:

    def __init__(self, home, einstellungen: dict | None = None):
        self.home = home
-        if einstellungen is not None:
+        # Tests starten im normalen Fenster (die App sonst maximiert)
+        einstellungen = {"vollbild": False} | (einstellungen or {})
        (home / "einstellungen.json").write_text(json.dumps(einstellungen), encoding="utf-8")
        self.root = None
        for versuch in range(3):
@@ -1098,11 +1099,18 @@ def test_export_zeitraum_kennzeichnen_und_erledigt(lauf_modern, tmp_path, monkey
        d.v_auf.set(False)
        d._ok()

+    def ok_offen():
+        d = lauf.dialog(ExportDialog)
+        d.v_von.set("01.10.2026")
+        d.v_bis.set("02.10.2026")
+        next(k for k in _alle(d) if isinstance(k, tk.Button) and k.cget("text") == "Noch nicht abgerechnet").invoke()
+        ok(d.v_von.get(), d.v_bis.get())
+
    lauf.ablauf([
        (IMMER, app.exportieren, "Export Oktober 6."),
        (lambda: lauf.dialog(ExportDialog) is not None, lambda: ok("01.10.2026", "05.10.2026"), "nur bis 5.10."),
        (lambda: lauf.dialog(ExportDialog) is None, app.exportieren, "Export Rest"),
-        (lambda: lauf.dialog(ExportDialog) is not None, ok, "alles Offene"),
+        (lambda: lauf.dialog(ExportDialog) is not None, ok_offen, "Noch nicht abgerechnet"),
        (lambda: lauf.dialog(ExportDialog) is None, app.exportieren, "nochmal"),
    ])
    assert not lauf.uebrig, lauf.diagnose()
@@ -1116,3 +1124,84 @@ def test_export_zeitraum_kennzeichnen_und_erledigt(lauf_modern, tmp_path, monkey
    app.prozent()
    assert "erledigt" in meldungen[-1]
    lauf.pruefen()
+
+
+def _alle(widget):
+    for kind in widget.winfo_children():
+        yield kind
+        yield from _alle(kind)
+
+
+def test_abrechnungen_links_und_import_fragt_nach_ziel(lauf_modern, home, monkeypatch):
+    from provtool.gui import win95 as w
+    from provtool.gui.dialogs import AbrechnungenDialog, ImportBericht
+    monkeypatch.setattr(w, "frage", lambda *a, **k: True)  # „bereits importiert – trotzdem?“ (Testdatei ist schon drin)
+    lauf = lauf_modern
+    app = lauf.app
+    alt = app.aid
+    neu = app.db.abrechnung_neu("November 2026")
+    app._aktualisieren()
+    assert set(app.atree.get_children()) == {str(alt), str(neu)}, "Abrechnungen fehlen links"
+    app.atree.selection_set(str(neu))
+    lauf.root.update()
+    assert app.aid == neu and not app.positionen, "Klick links öffnet die Abrechnung nicht"
+    app.atree.selection_set(str(alt))
+    lauf.root.update()
+
+    def ziel_waehlen():
+        d = lauf.dialog(AbrechnungenDialog)
+        d.tree.selection_set(str(neu))
+        d._oeffnen()
+
+    lauf.ablauf([
+        (IMMER, lambda: app.importieren([str(home / "freenet.csv")]), "Import"),
+        (lambda: lauf.dialog(AbrechnungenDialog) is not None, ziel_waehlen, "Ziel: November"),
+        (lambda: lauf.dialog(ImportBericht) is not None, lambda: lauf.dialog(ImportBericht).abbrechen(), "Bericht zu"),
+    ])
+    assert not lauf.uebrig, lauf.diagnose()
+    assert app.aid == neu and len(app.positionen) == 3, "Import nicht in der gewählten Abrechnung"
+    assert app.atree.selection() == (str(neu),)
+    lauf.pruefen()
+
+
+def test_filter_kennzahlen_und_hell_dunkel(lauf_modern):
+    """Filter-Knöpfe über der Tabelle, Kennzahl-Kacheln und der Hell/Dunkel-Schalter in der Kopfzeile."""
+    from provtool import config
+    from provtool.db import EIGEN
+    lauf = lauf_modern
+    app = lauf.app
+    alle = [p for p in app.positionen if p["haendler_id"] != EIGEN]
+    assert app.kpi["pos"][0].cget("text") == str(len(alle))
+    p = alle[0]
+    app.db.betrag_setzen(p["id"], 123)
+    app._aktualisieren()
+    app.pills["manuell"]._ausloesen()  # wie ein Klick (event_generate kommt unter Wine nicht an)
+    lauf.root.update()
+    manuell = [x for x in app.positionen if x["manuell"] and x["haendler_id"] != EIGEN]
+    assert len(manuell) == 1
+    zeilen = [i for g in app.ptree.get_children() for i in app.ptree.get_children(g)]
+    assert len(zeilen) == len(manuell), "Filter „Von Hand geändert“ wirkt nicht"
+    assert app.kpi["pos"][0].cget("text") == str(len(manuell))
+    assert app.pills["manuell"].aktiv and not app.pills["alle"].aktiv
+    app._filter_setzen("alle")
+    assert len([i for g in app.ptree.get_children() for i in app.ptree.get_children(g)]) == len(alle)
+
+    app.design_umschalten()  # schließt das Fenster; main() baut es danach dunkel neu auf
+    for _ in range(50):
+        if app._beendet:
+            break
+        lauf.root.update()
+    assert app.neustart and app._beendet
+    assert config.load()["design"] == "dunkel"
+
+
+def test_startet_maximiert(home):
+    _profil_mit_daten(home)
+    lauf = Lauf(home, {"assistent_erledigt": True, "tipps_beim_start": False, "vollbild": True, "design": "win95"})
+    try:
+        for _ in range(30):
+            lauf.root.update()
+            time.sleep(0.02)
+        assert lauf.app.rahmen.maximiert, "Programm startet nicht maximiert"
+    finally:
+        lauf.ende()
Author	SHA1	Message	Date
Kerim AtilganandClaude Opus 5.5	03b48f063c	Maustest startet im normalen Fenster (Programm sonst maximiert) Build / linux (push) Successful in 1m53s Details Build / windows-exe (push) Failing after 7m23s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 14:36:43 +01:00
Kerim AtilganandClaude Opus 5.5	c332c5a487	Programm startet maximiert; Version 1.7.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 14:23:01 +01:00
Kerim AtilganandClaude Opus 5.5	c96cf1bd94	Test: Filter-Knopf direkt auslösen (Wine) Build / linux (push) Successful in 1m51s Details Build / windows-exe (push) Successful in 7m49s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 12:14:02 +01:00
Kerim AtilganandClaude Opus 5.5	c35356aeb9	Win95-Design an das neue Hauptfenster angepasst, Version 1.6.0 Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 12:04:14 +01:00
Kerim AtilganandClaude Opus 5.5	f296483fdc	Neues Design im Stil der Handy-Insel-Webtools: Kopfzeile, Seitenleiste, Kennzahlen, Filter, hell/dunkel, IBM Plex Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 11:55:17 +01:00
Kerim AtilganandClaude Opus 5.5	2600eea574	Abrechnungen links im Hauptfenster (Klick öffnet), Import fragt nach der Ziel-Abrechnung Build / linux (push) Successful in 1m50s Details Build / windows-exe (push) Successful in 7m49s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 09:35:16 +01:00
Kerim AtilganandClaude Opus 5.5	057cca6378	Export: Knopf „Noch nicht abgerechnet“; Version 1.5.0 (mit Windows-Setup) Build / linux (push) Successful in 1m52s Details Build / windows-exe (push) Successful in 7m39s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 08:44:46 +01:00
Kerim AtilganandClaude Opus 5.5	ec99042569	Windows-Setup (Inno Setup): Installation pro Benutzer, Installer-Test im Build - PyInstaller baut unter Windows zusätzlich die Ordner-Variante dist/Provisionsmanager/ (schnellerer Start); onefile-.exe und .zip bleiben, Linux unverändert - build/installer.iss: ohne Admin nach %LOCALAPPDATA%\Programs\Provisionsmanager, Startmenü, optional Desktop, deutsch, feste AppId, CloseApplications, Benutzerdaten in %APPDATA%\Provisionsmanager95 bleiben bei Deinstallation erhalten - build_windows.sh: Inno Setup 6.7.3 (SHA256 geprüft) unter Wine installieren, Setup bauen, still installieren, Selbsttest der installierten .exe, still deinstallieren und prüfen - Pipeline: Setup als Artefakt und am Release; README-Abschnitt Installation Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-03 08:31:16 +01:00
Kerim AtilganandClaude Opus 5.5	7b9a2acec0	Testdaten: erfundene statt echter Kundennummer Build / linux (push) Successful in 1m58s Details Build / windows-exe (push) Successful in 7m19s Details Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-02 21:15:08 +01:00
Kerim AtilganandClaude Opus 5.5	8c86571034	Modernes Design: neue Symbole und Programm-Icon, ohne „95“ im Namen, Tipp des Tages ohne Büroklammer Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>	2026-11-02 21:12:05 +01:00