Layout: die Formularseite nimmt nur, was sie braucht

Sein Befund
  "die namen und datums bloecke koennen schmaler werden sind zu breit und
  verdrengen die posten block"

  Gemessen stimmte das genau: die sieben Spalten der Leistungstabelle
  brauchten 743 Pixel, sichtbar waren 618 - "E.-Preis" und "Gesamt" standen
  ausserhalb des Bildes.

Wo die Breite wirklich herkam
  An den Feldbreiten zu drehen half NICHTS. Die Arbeitsflaeche verteilte
  ueber eine uniform-Gruppe streng im Verhaeltnis 4:3; die Formularspalte war
  so breit, weil das Gewicht es vorschrieb, nicht weil der Inhalt es
  brauchte - 433 Pixel, ob die Felder nun 38 oder 22 Zeichen breit waren.

  Jetzt bekommt die Formularseite eine feste Mindestbreite und kein Gewicht,
  die Liste allen uebrigen Platz. Wird das Fenster groesser, waechst allein
  die Tabelle - genau dort nuetzt Breite, waehrend ein 600 Pixel breites Feld
  fuer eine Postleitzahl nichts besser macht. 433 -> 329.

Dazu passend
  - Startbreite 1060 -> 1180 und Mindestbreite 900 -> 1080. Unterhalb von
    1080 passen die sieben Spalten selbst dann nicht nebeneinander, wenn die
    Textspalte auf ihrer Mindestbreite steht.
  - Die Eingabefelder links auf das Mass gekuerzt, das sie wirklich brauchen
    (22 statt 38 Zeichen; Datum 12 statt 18). Das senkt die Mindestbreite der
    Formularseite - erst dadurch ist sie so klein moeglich.
  - "Anreise (TT.MM.JJJJ)" -> "Anreise". Die Form steht jetzt einmal als
    graue Zeile unter dem Block. Als Platzhalter IM Feld waere sie
    gefaehrlich: ein nicht geloeschter Platzhalter stuende als Anreisedatum
    auf der Rechnung.
  - Der Textumbruch der Leistungsspalte folgt jetzt ihrer echten Breite. Fest
    eingetragen schnitt er den Text ab, sobald die Spalte schmaler wurde.

pruef_spaltenbreiten.py
  Prueft ueber die ganze erlaubte Spanne, dass alle Spalten hineinpassen, die
  Formularseite lesbar bleibt und NICHT mitwaechst, und der Umbruch zur
  Spalte passt. Kein anderer Pruefstand haette das gefunden: es stuerzt
  nichts ab und rechnet nichts falsch - man sieht die Preise nur nicht.

  Er hat sofort einen zweiten Fehler gefunden: beim Aendern der
  Fenstergroesse lief der Umbruch nicht hinterher, weil ich abgebrochen
  hatte, sobald sich mein eigener Wert nicht mehr aenderte. Die Spalte kann
  aber breiter werden, ohne dass ich etwas aendere. Abbruch jetzt, wenn zwei
  Messungen dieselbe Spaltenbreite ergeben.

Fassung 1.7.1.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01V4t48uxDok5rJXhC9bX1Ax

app.py

@@ -65,10 +65,23 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
         self.cfg = config.load_config()
         self.title(config.PROGRAMM)
         self._fenstersymbol()
-        # Fensterhoehe an den Bildschirm anpassen, damit nichts unter den Rand rutscht
+        # Fenstergroesse an den Bildschirm anpassen, damit nichts unter den
+        # Rand rutscht. Die BREITE ist gemessen, nicht geraten: die
+        # Leistungstabelle braucht 743 Pixel fuer ihre sieben Spalten, dazu
+        # Bildlaufleiste, Rahmen und die Formularseite links - zusammen rund
+        # 1180. Bei den frueheren 1060 waren "E.-Preis" und "Gesamt"
+        # abgeschnitten (sein Befund am 06.09.2026: die Formularbloecke
+        # "verdrengen die posten block"). Passt das nicht auf den Bildschirm,
+        # wird so breit wie moeglich aufgemacht.
         hoehe = max(560, min(840, self.winfo_screenheight() - 90))
-        self.geometry(f"1060x{hoehe}")
+        breite = max(1000, min(1180, self.winfo_screenwidth() - 60))
-        self.minsize(900, 540)
+        self.geometry(f"{breite}x{hoehe}")
+        # Die Mindestbreite ist keine Geschmacksfrage: unterhalb von 1060
+        # Pixeln passen die sieben Spalten der Leistungstabelle selbst dann
+        # nicht mehr nebeneinander, wenn die Textspalte auf ihrer
+        # Mindestbreite steht - "E.-Preis" und "Gesamt" waeren dann nicht mehr
+        # zu sehen und auch nicht zu erreichen. Frueher stand hier 900.
+        self.minsize(1080, 540)
         if config.testlauf():
             # Ein Pruefstand bedient das Programm, waehrend nebenan jemand
             # arbeitet. Das Fenster geht deshalb NEBEN dem Bildschirm auf (auf
@@ -295,13 +308,18 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
                 row=i, column=0, sticky="w", pady=4)
             if var is self.k_anrede:
                 # Auswahlliste, aber nicht gesperrt - Sonderfaelle kann man tippen.
-                w = ttk.Combobox(kunde, textvariable=var, width=36, values=ANREDEN)
+                w = ttk.Combobox(kunde, textvariable=var, width=22, values=ANREDEN)
             else:
-                w = ttk.Entry(kunde, textvariable=var, width=38)
+                # 22 Zeichen: das laengste, was hier realistisch steht, ist eine
+                # Strasse mit Hausnummer ("Bornaer Chaussee 36" = 19). Breiter
+                # gemacht hat das Feld nur die linke Spalte aufgeblaeht und der
+                # Leistungstabelle den Platz genommen. Getippt werden kann
+                # weiterhin beliebig viel - das Feld scrollt mit.
+                w = ttk.Entry(kunde, textvariable=var, width=22)
             w.grid(row=i, column=1, sticky="ew", padx=(8, 0), pady=2)
         ttk.Label(kunde, text="* Pflicht – Name und Anschrift des Kunden gehören "
                               "auf die Rechnung (§ 14 Abs. 4 Nr. 1 UStG).",
-                  style="KarteMuted.TLabel", wraplength=330, justify="left").grid(
+                  style="KarteMuted.TLabel", wraplength=250, justify="left").grid(
             row=len(felder), column=0, columnspan=2, sticky="w", pady=(6, 0))
         kunde.columnconfigure(1, weight=1)
 
@@ -314,8 +332,8 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
         rows = [
             ("Rechnungsnummer", self.r_nummer),
             ("Rechnungsdatum", self.r_datum),
-            ("Anreise (TT.MM.JJJJ)", self.r_anreise),
+            ("Anreise", self.r_anreise),
-            ("Abreise (TT.MM.JJJJ)", self.r_abreise),
+            ("Abreise", self.r_abreise),
         ]
         date_vars = (self.r_datum, self.r_anreise, self.r_abreise)
         self.datum_labels = {}
@@ -326,7 +344,14 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
                 self.datum_labels["von"] = beschriftung
             elif var is self.r_abreise:
                 self.datum_labels["bis"] = beschriftung
-            ent = ttk.Entry(info, textvariable=var, width=18)
+            # 12 Zeichen reichen fuer "TT.MM.JJJJ" und jede Rechnungsnummer.
+            # Die Form stand frueher in der Beschriftung ("Anreise
+            # (TT.MM.JJJJ)") und hat den ganzen Block breit gemacht - Breite,
+            # die der Leistungstabelle rechts fehlte. Sie steht jetzt einmal
+            # als graue Zeile unter dem Block. Als Platzhalter IM Feld waere
+            # sie gefaehrlich: ein nicht geloeschter Platzhalter stuende als
+            # Anreisedatum auf der Rechnung.
+            ent = ttk.Entry(info, textvariable=var, width=12)
             ent.grid(row=i, column=1, sticky="ew", padx=(8, 0), pady=2)
             if var is self.r_nummer:
                 # Waehrend eines Stornos wird das Feld gesperrt - die Nummern
@@ -339,12 +364,17 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
         ttk.Label(info, textvariable=self.r_naechte, style="Karte.TLabel",
                   font=(theme.SCHRIFT_NAME, 11, "bold")).grid(
             row=4, column=1, sticky="w", padx=(8, 0))
+        ttk.Label(info, text="Datum als TT.MM.JJJJ – die Punkte setzt das "
+                             "Programm beim Tippen.",
+                  style="KarteMuted.TLabel", wraplength=250,
+                  justify="left").grid(row=5, column=0, columnspan=2,
+                                       sticky="w", pady=(8, 0))
         # Storno-Hinweis: steht nur da, solange ein Storno im Zwischenspeicher liegt.
         self.storno_hinweis = tk.StringVar(value="")
         ttk.Label(info, textvariable=self.storno_hinweis, style="Karte.TLabel",
                   foreground=self.col_gefahr,
-                  font=(theme.SCHRIFT_NAME, 9, "bold"), wraplength=200, justify="left").grid(
+                  font=(theme.SCHRIFT_NAME, 9, "bold"), wraplength=250, justify="left").grid(
-            row=5, column=0, columnspan=2, sticky="w", pady=(6, 0))
+            row=6, column=0, columnspan=2, sticky="w", pady=(6, 0))
         info.columnconfigure(1, weight=1)
         self.r_anreise.trace_add("write", lambda *a: self._update_naechte())
         self.r_abreise.trace_add("write", lambda *a: self._update_naechte())
@@ -414,7 +444,12 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
     # (Titel, Ausrichtung, Mindestbreite px). col 1 (Leistung) bekommt das Gewicht.
     COLS = [
         ("Pos.", "center", 38),
-        ("Leistung", "w", 330),
+        # Die Textspalte hat als einzige Gewicht - sie bekommt allen freien
+        # Platz. Ihre Mindestbreite ist deshalb bewusst klein: bei einem engen
+        # Fenster soll sie schrumpfen und umbrechen, statt die Preisspalten
+        # rechts aus dem Bild zu schieben. Bei den frueheren 330 tat sie genau
+        # das - "E.-Preis" und "Gesamt" waren nicht mehr zu sehen.
+        ("Leistung", "w", 200),
         ("USt %", "center", 50),
         ("Anzahl\nTage/Menge", "center", 80),
         ("Pers.", "center", 56),
@@ -451,7 +486,13 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
         self._pos_win = canvas.create_window((0, 0), window=self.pos_frame, anchor="nw")
         self.pos_frame.bind("<Configure>", lambda e: canvas.configure(scrollregion=canvas.bbox("all")))
         # pos_frame auf Canvas-Breite ziehen (minus Luft rechts zum Scrollbalken)
-        canvas.bind("<Configure>", lambda e: canvas.itemconfig(self._pos_win, width=e.width - 18))
+        def breite_gesetzt(e):
+            canvas.itemconfig(self._pos_win, width=e.width - 18)
+            # after_idle, weil die Spaltenbreite erst NACH dem Neuverteilen
+            # feststeht - direkt im Ereignis gemessen kaeme der alte Wert.
+            self.after_idle(self._umbruch_nachziehen)
+
+        canvas.bind("<Configure>", breite_gesetzt)
         canvas.configure(yscrollcommand=sb.set)
         canvas.pack(side="left", fill="both", expand=True, pady=(4, 0))
         sb.pack(side="right", fill="y")
@@ -463,9 +504,55 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
 
         self._render_positionszeilen()
 
+    def _umbruch_nachziehen(self, runde=0, vorige_breite=None):
+        """Den Textumbruch der Leistungsspalte auf ihre echte Breite setzen.
+
+        Die Spalte ist die einzige mit Gewicht - sie bekommt allen freien
+        Platz und schrumpft bei engem Fenster bis auf ihre Mindestbreite. Ein
+        fest eingetragener Umbruch passt dann nicht mehr: er bricht zu spaet,
+        der Text laeuft ueber die Spalte hinaus und wird abgeschnitten. Genau
+        das war nach dem Umbau am 06.09.2026 bei Position 1 zu sehen
+        ("... inkl. Pkw, Stro").
+
+        Es braucht mehrere Runden, und zwar aus einem Grund, der beim ersten
+        Versuch Zeit gekostet hat: beim ersten Messen steht die Spalte noch auf
+        ihrer MINDESTbreite, weil die Labels noch mit dem alten Umbruch
+        vermessen sind. Setzt man danach nur einmal, bleibt der Text auf der
+        Mindestbreite umgebrochen, obwohl die Spalte laengst breiter ist - der
+        Text stand dann dreizeilig in einer Spalte, in die er zweizeilig
+        gepasst haette. Also wird gemessen, gesetzt und noch einmal gemessen,
+        bis sich nichts mehr aendert.
+
+        Abgebrochen wird, wenn zwei Messungen dieselbe SPALTENBREITE ergeben -
+        nicht, wenn sich der Umbruch nicht geaendert hat. Der Unterschied ist
+        entscheidend und hat beim ersten Versuch eine Runde gekostet: die
+        Spalte kann breiter werden, ohne dass ich etwas geaendert habe (sie
+        bekommt den freien Platz des Fensters). Wer dann abbricht, weil sein
+        eigener Wert gleich blieb, laesst den Umbruch auf dem alten Stand
+        stehen - beim Vergroessern bricht der Text unnoetig um, beim
+        Verkleinern laeuft er aus der Spalte heraus. Die Rundengrenze ist der
+        zweite Riegel gegen ein Aufschaukeln.
+        """
+        if not getattr(self, "_text_zellen", None):
+            return
+        kasten = self.pos_frame.grid_bbox(column=1, row=0)
+        if not kasten or kasten[2] < 40:
+            return
+        breite = kasten[2] - 14          # padx=6 auf beiden Seiten, etwas Luft
+        for lbl in self._text_zellen:
+            try:
+                if int(lbl.cget("wraplength")) != breite:
+                    lbl.configure(wraplength=breite)
+            except tk.TclError:          # Zeile wurde zwischendurch neu gebaut
+                pass
+        if runde < 5 and breite != vorige_breite:
+            self.after_idle(
+                lambda: self._umbruch_nachziehen(runde + 1, breite))
+
     def _render_positionszeilen(self):
         for w in self.pos_frame.winfo_children():
             w.destroy()
+        self._text_zellen = []
         self.anzahl_vars.clear()
         self.personen_vars.clear()
         self.gesamt_lbls.clear()
@@ -512,7 +599,12 @@ class RechnungsApp(ThemeMixin, MeldungMixin, KorrekturMixin, EinstellungenMixin,
                 return lbl
 
             zelle(str(nr), 0)
-            zelle(pos["leistung"], 1, anker="w", umbruch=330)
+            # Der Umbruch wird nicht fest gesetzt: die Leistungsspalte ist die
+            # einzige, die mitwaechst, und ein fester Wert schnitt den Text ab,
+            # sobald die Spalte schmaler wurde als er. _umbruch_nachziehen()
+            # holt ihn nach jeder Groessenaenderung.
+            self._text_zellen.append(
+                zelle(pos["leistung"], 1, anker="w", umbruch=200))
             zelle(str(pos["satz"]), 2)
             ttk.Entry(self.pos_frame, textvariable=av, width=8, justify="center",
                       style="Liste.TEntry").grid(

flaeche.py

@@ -42,6 +42,12 @@ STANDARD = {
 
 
 class Arbeitsflaeche(ttk.Frame):
+    # Wie breit die beiden Spalten mindestens sein muessen. Die Formularseite
+    # ist gemessen, nicht geschaetzt: das breiteste, was dort steht, ist die
+    # Beschriftung "Nachname / Firma *" neben einem 22 Zeichen breiten Feld.
+    MIN_FORMULAR = 330
+    MIN_LISTE = 520
+
     def __init__(self, master, farben=None, beim_umbauen=None):
         super().__init__(master)
         self.f = farben if farben is not None else master
@@ -85,23 +91,43 @@ class Arbeitsflaeche(ttk.Frame):
     def _platz_verteilen(self):
         """Der freie Platz gehoert dem Kasten mit der langen Liste.
 
-        Feste Gewichte gehen nicht: die Liste wandert beim Verschieben, und wer
+        Feste Gewichte an festen Zellen gehen nicht: die Liste wandert beim
-        das Gewicht an einer festen Zelle laesst, schneidet danach den
+        Verschieben, und wer das Gewicht an einer festen Zelle laesst,
-        Kundenkasten unten ab - genau das ist beim ersten Versuch passiert.
+        schneidet danach den Kundenkasten unten ab - genau das ist beim ersten
+        Versuch passiert.
+
+        WARUM NICHT MEHR `uniform` (06.09.2026)
+        ---------------------------------------
+        Vorher standen beide Spalten in einer uniform-Gruppe mit den Gewichten
+        4 und 3. Das teilt die Breite STRENG in diesem Verhaeltnis auf - bei
+        1040 Pixeln also 594 zu 446, ganz gleich, was in den Kaesten steht.
+        Sein Befund: *"die namen und datums bloecke koennen schmaler werden
+        sind zu breit und verdrengen die posten block"*. Er hatte recht, aber
+        an den Feldbreiten zu drehen half nichts: die Spalte war so breit, weil
+        das Gewicht es vorschrieb, nicht weil der Inhalt es brauchte.
+
+        Jetzt bekommen die Formularkaesten nur, was sie brauchen (feste
+        Mindestbreite, kein Gewicht), und der ganze uebrige Platz geht an die
+        Liste. Wird das Fenster groesser, waechst allein die Tabelle - genau
+        dort nuetzt die Breite, waehrend ein Adressfeld von 600 Pixeln nichts
+        besser macht.
         """
         for z in range(2):
             self.rowconfigure(z, weight=0, minsize=0)
         for sp in range(2):
-            self.columnconfigure(sp, weight=1, uniform="spalten")
+            self.columnconfigure(sp, weight=0, uniform="", minsize=0)
         lang = self.layout.get("leistungen")
         if not lang:
+            for sp in range(2):
+                self.columnconfigure(sp, weight=1)
             return
         spalte, zeile, hoch = lang
         for z in range(zeile, zeile + hoch):
             self.rowconfigure(z, weight=1)
-        # Die Spalte mit der Liste bekommt mehr Breite als die andere.
+        # Die Liste nimmt allen freien Platz ...
-        self.columnconfigure(spalte, weight=4, uniform="spalten")
+        self.columnconfigure(spalte, weight=1, minsize=self.MIN_LISTE)
-        self.columnconfigure(1 - spalte, weight=3, uniform="spalten")
+        # ... die Formularseite genau so viel, wie ihr breitestes Feld braucht.
+        self.columnconfigure(1 - spalte, weight=0, minsize=self.MIN_FORMULAR)
         # Steht die Liste nur in EINER Zeile, braucht die andere trotzdem Luft
         # fuer ihren Inhalt - sonst wird sie zusammengequetscht.
         if hoch == 1:

pruef_spaltenbreiten.py

@@ -0,0 +1,137 @@
+# -*- coding: utf-8 -*-
+"""Pruefstand: passt die Leistungstabelle in jedes erlaubte Fenster?
+
+DER FALL, DER DAZU GEFUEHRT HAT (06.09.2026)
+--------------------------------------------
+Sein Befund: *"die namen und datums bloecke koennen schmaler werden sind zu
+breit und verdrengen die posten block"*. Gemessen stimmte das genau: die
+sieben Spalten der Leistungstabelle brauchten 743 Pixel, sichtbar waren 618 -
+"E.-Preis" und "Gesamt" standen ausserhalb des Bildes.
+
+WARUM DAS KEIN ANDERER PRUEFSTAND FINDET
+----------------------------------------
+Es stuerzt nichts ab, es rechnet nichts falsch, kein Wert fehlt. Die Rechnung
+wird korrekt erstellt - man sieht die Preise nur nicht. Ein Fehler, den man
+ansehen muss, um ihn zu bemerken. Genau deshalb steht er hier als Messung.
+
+Und die Ursache lag nicht dort, wo man sie vermutet: an den Feldbreiten links
+zu drehen half NICHTS. Die Arbeitsflaeche verteilte die Breite ueber eine
+uniform-Gruppe streng im Verhaeltnis 4:3 - die Spalte war so breit, weil das
+Gewicht es vorschrieb, nicht weil der Inhalt es brauchte.
+
+WAS HIER GEPRUEFT WIRD
+----------------------
+Ueber die ganze erlaubte Spanne von der Mindestbreite bis zu einem grossen
+Fenster:
+
+  1. Alle Spalten der Tabelle passen nebeneinander in die sichtbare Flaeche.
+  2. Die Formularseite bleibt lesbar - sie darf nicht unter ihre gemessene
+     Mindestbreite fallen.
+  3. Die Formularseite waechst NICHT mit. Zusaetzliche Breite gehoert der
+     Tabelle; ein 600 Pixel breites Feld fuer eine Postleitzahl macht nichts
+     besser.
+  4. Der Textumbruch der Leistungsspalte folgt ihrer echten Breite. Ist er
+     groesser, wird der Text abgeschnitten; ist er viel kleiner, bricht er
+     unnoetig um.
+"""
+import os
+import sys
+import time
+
+QUELLE = os.path.dirname(os.path.abspath(__file__))
+sys.path.insert(0, QUELLE)
+
+fehler = []
+
+
+def pruefe(bedingung, text):
+    zeile = ("  OK   | " if bedingung else "FEHLER | ") + text
+    kod = sys.stdout.encoding or "utf-8"
+    print(zeile.encode(kod, "replace").decode(kod))
+    if not bedingung:
+        fehler.append(text)
+
+
+os.chdir(QUELLE)
+os.environ["CAMPINGHOF_TEST"] = "1"
+
+from tkinter import messagebox  # noqa: E402
+
+antworten = {"Erprobungsfassung": True, "Fertig": False, "Hausnummer": True}
+
+
+def askyesno(titel, text, **kw):
+    for schlue, wert in antworten.items():
+        if schlue in titel:
+            return wert
+    raise AssertionError(f"unangemeldeter Dialog: {titel!r}")
+
+
+messagebox.askyesno = askyesno
+for _n in ("showinfo", "showwarning", "showerror"):
+    setattr(messagebox, _n, lambda *a, **k: None)
+
+import app as A  # noqa: E402
+
+f = A.RechnungsApp()
+
+
+def einpendeln(sekunden=1.2):
+    """Ereignisschleife drehen - Tk verteilt die Breite erst danach."""
+    ende = time.time() + sekunden
+    while time.time() < ende:
+        f.update()
+        time.sleep(0.02)
+    f.update_idletasks()
+
+
+einpendeln(2.0)
+
+# Die Mindestbreite ist die untere Grenze dessen, was der Benutzer einstellen
+# kann - genau dort muss es noch passen.
+MINDEST = f.minsize()[0]
+print(f"        (Mindestbreite laut minsize: {MINDEST})")
+
+formular_breiten = []
+for breite in (MINDEST, MINDEST + 40, 1180, 1400, 1600):
+    f.geometry(f"{breite}x680")
+    einpendeln()
+    pf = f.pos_frame
+    sichtbar = pf.master.winfo_width()          # der Canvas darunter
+    spalten = [(pf.grid_bbox(column=i, row=0) or (0, 0, 0, 0))[2]
+               for i in range(len(A.RechnungsApp.COLS))]
+    gesamt = sum(spalten)
+    formular = f.flaeche.kaesten["kunde"]["aussen"].winfo_width()
+    formular_breiten.append(formular)
+
+    pruefe(gesamt <= sichtbar,
+           f"bei {breite:4d} px passen alle {len(spalten)} Spalten "
+           f"({gesamt} von {sichtbar} px)")
+    pruefe(formular >= 300,
+           f"bei {breite:4d} px bleibt die Formularseite lesbar ({formular} px)")
+
+    # Der Umbruch der Textspalte muss zur Spalte passen.
+    zellen = getattr(f, "_text_zellen", [])
+    if zellen:
+        umbruch = int(zellen[0].cget("wraplength"))
+        text_spalte = spalten[1]
+        pruefe(umbruch <= text_spalte,
+               f"bei {breite:4d} px bricht der Leistungstext INNERHALB der "
+               f"Spalte um ({umbruch} <= {text_spalte})")
+        pruefe(umbruch >= text_spalte - 30,
+               f"bei {breite:4d} px nutzt er die Spalte auch aus "
+               f"({umbruch} >= {text_spalte - 30})")
+
+# Mehr Platz gehoert der Tabelle, nicht den Adressfeldern.
+pruefe(len(set(formular_breiten)) == 1,
+       f"die Formularseite waechst nicht mit dem Fenster {formular_breiten}")
+
+try:
+    f.destroy()
+except Exception:  # noqa: BLE001
+    pass
+
+if fehler:
+    print(f"ROT | {len(fehler)} Punkt(e) nicht erfuellt")
+    sys.exit(1)
+print("GRUEN | Die Leistungstabelle passt in jedes erlaubte Fenster")

version.py

@@ -10,11 +10,11 @@ und NUR hier; alles andere (Info-Dialog, Updater, Release) liest sie von hier.
 Regel
 -----
 Die Nummer wird beim Ausliefern erhoeht und entspricht dem Release-Tag ohne das
-"v": Tag `v1.7.0` -> VERSION "1.7.0". Wer das eine ohne das andere aendert,
+"v": Tag `v1.7.1` -> VERSION "1.7.1". Wer das eine ohne das andere aendert,
 baut dem Updater eine Falle.
 """
 
-VERSION = "1.7.0"
+VERSION = "1.7.1"
 
 # Zu welchem Repository dieses Programm gehoert - der Updater sucht dort.
 REPOSITORY = "TheMockTv/rechnungstool"