Kamerafenster: Groesse und Ecke lassen sich stellen

Filipe: "und danach perfektionierst du auch die verschiedenen
groessen von kamera und so, perfektionier das alles bitte."

Sechs Groessen (0,6x bis 2x) und vier Ecken, beide an der SENDUNG
und nicht am Browser: Was Filipe einstellt, sehen alle. Waere es
eine Einstellung je Geraet, redete er ueber ein Bild, das bei den
Zusehenden anders aussieht -- und im Stream stuende ein drittes.

Anordnung, Groesse und Ecke gehen jetzt EINEN Weg (/layout), weil
sie zusammen eine einzige Frage beantworten: Wie sieht das Bild aus?
Drei getrennte Aufrufe waeren drei Rundrufe, und dazwischen saehen
die Zusehenden eine Mischung -- neue Anordnung, alte Ecke. Eine
falsche Angabe laesst auch das Gute stehen, statt halb umzustellen.

Die Ecke gibt es, weil unten rechts bei TikTok die Knopfreihe liegt,
bei YouTube die Fortschrittsleiste, und Untertitel fast immer unten
stehen. Eine feste Ecke ist eine, die bei jeder zweiten Plattform
im Weg ist.

Die OBS-Videoquelle kennt jetzt die Anordnung und blendet sich bei
"Nur Kamera" aus -- sonst laege im Stream ein stehengebliebenes
YouTube-Bild unter den Kameras, und Filipe saehe es nicht, weil er
auf seine Szene schaut und nicht auf die Quelle.

VIER BEFUNDE, ALLE VON DEN PRUEFUNGEN UND KEINER VOM AUGE:

1. Die Knoepfe fuer Groesse und Ecke gab es gar nicht. HTML und
   Stilblatt waren da, das Programm nicht. Gemessen: "0 von 0
   Eckknoepfen gesperrt", und der Hinweistext stand noch wortgleich
   wie im HTML -- zwei leere Kaesten, die aussahen, als sei alles
   in Ordnung.

2. Bei "Nur Kamera" war der Stapel 493 px breit statt 1072. Der
   neue Deckel max-width: 46% -- richtig gegen ein zu grosses
   Fenster bei "Video gross" -- galt still auch dort, wo die
   Kameras die ganze Flaeche fuellen sollen.

3. Am Handy haette die Groesseneinstellung ueberhaupt nichts
   bewirkt: Dort stand weiterhin width: clamp(88px, 26vw, 140px)
   am Fenster selbst. Das ist die dritte Wiederholung derselben
   Sache an einem Tag (die Saalzeilen, die Tafeln, jetzt die
   Kamerabreite): Zwei Regeln fuer dieselbe Frage sind die
   Garantie, dass eine davon irgendwo falsch gewinnt. Breite und
   Rand gehen jetzt ueber --kam-grund/--kam-rand, --kam wird an
   genau EINER Stelle gerechnet, und eine Pruefung zaehlt das nach.

4. Die Pruefung schlug auf ihren EIGENEN Kommentar an, der die
   entfernte Zeile zitiert. Ein Werkzeug, das bei jedem Lauf
   meckert, wird nach dem zweiten Mal weggeklickt -- samt dem
   echten Befund darin. Gezaehlt werden jetzt Regeln, nicht Prosa.

Gemessen beim Zuschauer und nicht in der Datenbank: 1x -> 208 px,
2x -> 416 px, alle Fenster innerhalb der Leinwand, und jede der
vier Ecken am Abstand zu den Kanten nachgewiesen statt an ihrem
eigenen Namen. Ein Knopf, der gerade nichts bewirken kann, ist
grau, und der Satz darunter sagt warum.

pruef-reaktion 320/0 - pruef-buehne 36/0 - pruef-css-klassen ok -
pruef-tippziele 11/0 - mess-reaktion ohne Beanstandung

Co-Authored-By: Claude Opus 5 <[email protected]>

workspace/assets/css/reaktion.css

@@ -385,16 +385,72 @@
    Fenster selbst nehmen Klicks an. Ohne das läge eine unsichtbare
    Scheibe über der ganzen Leinwand.
    --------------------------------------------------------------------- */
+/* ==== EINE GRUNDBREITE FUER ALLE ANORDNUNGEN ======================
+
+   `--kam` ist die Breite EINES Kamerafensters. Sie steht an einer
+   Stelle und wird von den Anordnungen nur nachjustiert; `--kam-gross`
+   ist der Faktor, den die Regie setzt (0,6 bis 2).
+
+   WARUM EINE VARIABLE UND NICHT FUENF ZAHLEN: Vorher stand die
+   Breite zweimal im Stilblatt -- einmal als Grundregel, einmal für
+   „Kameras gross". Wer die Größe einstellbar macht, müsste beide
+   Stellen mitdenken, und die zweite wird vergessen. Das ist genau
+   die Doppelung, die am selben Tag der Regieleiste null Pixel
+   gegeben hat. */
+.kino {
+  /* `--kam-grund`  wie breit ein Fenster ohne Zutun ist.
+     `--kam-gross`  der Faktor, den die Regie setzt (0,6 bis 2).
+     `--kam`        das Ergebnis -- an EINER Stelle gerechnet.
+     `--kam-rand`   wie weit der Stapel von der Kante der Leinwand
+                    wegsitzt; am Handy enger, weil dort jeder
+                    Pixel Video zählt.
+
+     Wer etwas ändern will, ändert `--kam-grund` oder `--kam-rand`.
+     Wer `--kam` selbst überschreibt, baut die zweite Antwort auf
+     dieselbe Frage -- und die gewinnt dann irgendwo still. */
+  --kam-gross: 1;
+  --kam-grund: clamp(120px, 17vw, 208px);
+  --kam: calc(var(--kam-grund) * var(--kam-gross));
+  --kam-rand: 16px;
+}
 .kameras {
   position: absolute;
-  right: 16px; bottom: 16px;
+  /* Standardecke: unten rechts. `inset` statt `right`/`bottom`
+     einzeln -- die Ecken-Regeln weiter unten setzen dann ALLE vier
+     Werte auf einmal, statt drei zurückzunehmen und einen zu
+     setzen. Ein halb zurückgenommener Rand ist eine Ecke, die
+     manchmal klebt. */
+  inset: auto var(--kam-rand) var(--kam-rand) auto;
+  width: var(--kam);
+  /* NIE MEHR ALS FAST DIE HAELFTE. Bei Faktor 2 auf einem schmalen
+     Bildschirm deckte ein einzelnes Fenster sonst das halbe Video
+     zu -- und auf dem Handy mehr. Der Prozentwert bezieht sich auf
+     die Leinwand, weil der Behälter absolut darin liegt. */
+  max-width: 46%;
   display: flex; flex-direction: column; gap: 12px;
   pointer-events: none;
   z-index: 20;
 }
+
+/* ---- Die vier Ecken ---------------------------------------------------
+   Filipe: „die verschiedenen groessen von kamera und so."
+
+   WOFUER DAS DA IST: Unten rechts liegt bei TikTok die Knopfreihe,
+   bei YouTube die Fortschrittsleiste, und Untertitel stehen fast
+   immer unten. Eine feste Ecke ist eine, die bei jeder zweiten
+   Plattform genau im Weg steht.
+
+   Sie stehen VOR den Anordnungen: „Kameras gross" und „nur Kamera"
+   setzen den Behälter ohnehin in die Mitte, und bei gleicher
+   Stärke gewinnt die spätere Regel. */
+.kino[data-ecke="ol"] .kameras { inset: var(--kam-rand) auto auto var(--kam-rand); }
+.kino[data-ecke="or"] .kameras { inset: var(--kam-rand) var(--kam-rand) auto auto; }
+.kino[data-ecke="ul"] .kameras { inset: auto auto var(--kam-rand) var(--kam-rand); }
+.kino[data-ecke="ur"] .kameras { inset: auto var(--kam-rand) var(--kam-rand) auto; }
+
 .kamera {
   position: relative;
-  width: clamp(120px, 17vw, 208px);
+  width: 100%;
   aspect-ratio: 4 / 3;
   border-radius: 16px;
   overflow: hidden;
@@ -440,19 +496,48 @@
   position: static;
   flex-direction: row;
   justify-content: center;
+  width: 100%; max-width: none;
   padding: 10px;
   background: #07060d;
 }
+/* Hier bestimmt das Fenster seine Breite selbst -- der Behälter ist
+   die ganze Zeile. `min-width: 0` erlaubt dem Flexraster, sie bei
+   zwei Gästen zu kürzen, statt die Zeile breiter zu machen. */
+.kino[data-layout="gleich"] .kamera {
+  width: var(--kam);
+  flex: 0 1 auto;
+  min-width: 0;
+}
 .kino[data-layout="gleich"] .leinwand {
   grid-template-rows: 1fr auto;
   align-content: stretch;
 }
-/* Anordnung „kamera": die Kameras groß, das Video klein in der Ecke. */
-.kino[data-layout="kamera"] .kamera { width: clamp(160px, 30vw, 380px); }
+/* Anordnung „kamera": die Kameras groß, das Video klein in der Ecke.
+
+   DER BEHAELTER LIEGT AUF DER GANZEN LEINWAND (`inset: 0`) und nicht
+   mehr an einem Punkt mit `transform`. Grund: Ein absolut gesetzter
+   Behälter mit nur EINER Kante bemisst sich nach seinem Inhalt und
+   kann ihn überlaufen -- am 28.09. waren das bei „nur Kamera"
+   2175 px in einer 1072 px breiten Leinwand, und ein Gast stand
+   komplett außerhalb. Mit `inset: 0` gibt es eine feste Breite, auf
+   die sich `max-width` beziehen kann. */
+/* Nur die GRUNDBREITE ist hier eine andere -- der Faktor der Regie
+   gilt weiter, und gerechnet wird trotzdem nur an der einen Stelle
+   oben. */
+.kino[data-layout="kamera"] { --kam-grund: clamp(160px, 30vw, 380px); }
+.kino[data-layout="kamera"] .kamera {
+  width: var(--kam);
+  flex: 0 1 auto;
+  min-width: 0;
+  max-width: calc(50% - 8px);
+}
 .kino[data-layout="kamera"] .kameras {
-  right: auto; left: 50%; top: 50%; bottom: auto;
-  transform: translate(-50%, -50%);
+  inset: 0;
+  width: auto; max-width: none;
+  transform: none;
   flex-direction: row;
+  justify-content: center; align-items: center;
+  gap: 14px; padding: 16px;
 }
 .kino[data-layout="kamera"] .leinwand__video {
   position: absolute; right: 14px; bottom: 14px;
@@ -514,8 +599,16 @@
    kann sich nicht verrechnen. */
 .kino[data-layout="nur_kamera"] .kameras {
   position: absolute; inset: 0;
-  right: auto; bottom: auto;
-  width: 100%; height: 100%;
+  /* DER DECKEL MUSS HIER WEG. `.kameras` trägt seit dem 28.09. ein
+     `max-width: 46%` — richtig für „Video groß", wo ein Fenster
+     sonst bei doppelter Größe das halbe Video zudeckt. Hier füllen
+     die Kameras die ganze Leinwand, und der Deckel machte daraus
+     493 px in einer 1072 px breiten Leinwand. Gefunden hat das nicht
+     das Auge, sondern die Messung, die die Breite mit „Video groß"
+     vergleicht: 208 px gegen 225 px, wo ein Vielfaches stehen müsste.
+     Die Breite kommt aus `inset: 0`, nicht aus `width` — sonst
+     stünden wieder zwei Angaben für dieselbe Kante da. */
+  width: auto; height: auto; max-width: none;
   flex-direction: row;
   justify-content: center; align-items: stretch;
   gap: 12px;
@@ -1669,6 +1762,87 @@
 #stufen-stand[data-offen="ja"] { color: var(--gleich); font-weight: 700; }
 #stufen-stand[data-offen="nein"] { color: var(--schrift-leise); }
 
+/* ==== GRÖSSE UND ECKE DER KAMERAFENSTER ============================
+   Zwei Gruppen nebeneinander, beide klein — sie stehen unter der
+   Anordnung und sind deren Feinjustierung, nicht ihresgleichen. */
+.kamerawahl { display: flex; flex-wrap: wrap; gap: 14px 22px; align-items: flex-start; }
+.kamerawahl__teil { display: grid; gap: 5px; }
+.kamerawahl__wort {
+  font-size: .72rem; font-weight: 700;
+  letter-spacing: .06em; text-transform: uppercase;
+  color: var(--schrift-leise);
+}
+
+.kamgroesse { display: flex; gap: 4px; flex-wrap: wrap; }
+.kamgroesse__knopf {
+  appearance: none; cursor: pointer;
+  min-height: 38px; min-width: 44px; padding: 0 9px;
+  border-radius: 9px;
+  border: 1px solid var(--rand);
+  background: rgba(255, 255, 255, .04);
+  color: var(--schrift-leise);
+  font-size: .76rem; font-weight: 700;
+  font-variant-numeric: tabular-nums;
+}
+.kamgroesse__knopf[aria-pressed="true"] {
+  background: rgba(154, 183, 255, .14);
+  border-color: rgba(154, 183, 255, .38);
+  color: #cfe0ff;
+}
+
+/* ---- Die vier Ecken --------------------------------------------------
+   Jeder Knopf ist ein kleines Abbild der Leinwand mit einem Feld in
+   der Ecke, die er meint. Ein Wort wäre länger zu lesen, als das
+   Bild zu erfassen ist — und vier Wörter nebeneinander passen am
+   Handy nicht in eine Zeile.
+   Der Name steht trotzdem da: als `aria-label` für Hilfsmittel und
+   als Hinweis unter dem Zeiger. */
+.kamecke { display: flex; gap: 6px; }
+.kamecke__knopf {
+  appearance: none; cursor: pointer;
+  position: relative;
+  width: 44px; height: 38px;
+  padding: 5px;
+  border-radius: 8px;
+  border: 1px solid var(--rand);
+  background: rgba(255, 255, 255, .04);
+}
+.kamecke__feld {
+  position: absolute;
+  width: 12px; height: 9px;
+  border-radius: 2px;
+  background: var(--schrift-leise);
+  opacity: .5;
+}
+.kamecke__knopf[data-ecke="ol"] .kamecke__feld { top: 5px; left: 5px; }
+.kamecke__knopf[data-ecke="or"] .kamecke__feld { top: 5px; right: 5px; }
+.kamecke__knopf[data-ecke="ul"] .kamecke__feld { bottom: 5px; left: 5px; }
+.kamecke__knopf[data-ecke="ur"] .kamecke__feld { bottom: 5px; right: 5px; }
+.kamecke__knopf[aria-pressed="true"] {
+  border-color: rgba(154, 183, 255, .38);
+  background: rgba(154, 183, 255, .14);
+}
+.kamecke__knopf[aria-pressed="true"] .kamecke__feld {
+  background: #cfe0ff; opacity: 1;
+}
+/* Ein Knopf, der gerade nichts tun kann, sieht auch so aus — und
+   der Satz darunter sagt, warum. Gilt für beide Gruppen: die Ecke
+   wirkt nur bei „Video groß", die Größe überall außer bei „Nur
+   Video", wo es gar keine Kamerafenster gibt. */
+.kamecke__knopf:disabled,
+.kamgroesse__knopf:disabled { opacity: .38; cursor: default; }
+
+/* Am Finger werden beide Gruppen auf Hausgröße gehoben.
+   `min-height`/`min-width` und nicht `height`/`width` — das ist
+   nicht Geschmack: `pruef-tippziele` leitet daraus ab, dass ein
+   Element gedeckt ist, und hat den Eckwähler zu Recht gemeldet,
+   solange dort nur eine feste Höhe stand. Eine feste Höhe sagt
+   „genau so groß"; die Regel will wissen „mindestens so groß". */
+@media (pointer: coarse) {
+  .kamgroesse__knopf { min-height: 44px; }
+  .kamecke__knopf { min-height: 44px; min-width: 52px; height: 44px; width: 52px; }
+}
+
 .layout-reihe { display: flex; gap: 9px; flex-wrap: wrap; }
 .layout-knopf {
   appearance: none; cursor: pointer;
@@ -1757,11 +1931,25 @@
     border-top: 1px solid var(--rand);
     min-height: 0;
   }
-  .kameras {
-    right: 10px; bottom: 10px;
-    flex-direction: row;
+  /* ==== AM HANDY NUR ZWEI ZAHLEN ANDERS ==========================
+
+     Hier stand bis zum 28.09. `.kamera { width: clamp(88px, 26vw,
+     140px) }` -- eine feste Breite am Fenster selbst. Seit die Regie
+     die Größe einstellen kann, war das die zweite Antwort auf
+     dieselbe Frage, und sie gewann: Filipes Einstellung hätte am
+     Telefon gar nichts bewirkt, und am Rechner wäre alles richtig
+     gewesen. Gefunden hat das die Prüfung, nicht das Auge.
+
+     Und `.kameras { right: 10px; bottom: 10px }` war seit den vier
+     Ecken wirkungslos: `.kino[data-ecke="…"] .kameras` ist stärker
+     und setzt `inset` vollständig, ganz gleich, in welcher Reihe die
+     Regel steht. Eine Regel, die aussieht, als täte sie etwas, ist
+     schlimmer als keine. */
+  .kino {
+    --kam-grund: clamp(88px, 26vw, 140px);
+    --kam-rand: 10px;
   }
-  .kamera { width: clamp(88px, 26vw, 140px); }
+  .kameras { flex-direction: row; }
 
   /* ==== KEINE LADE, SONDERN EIN STAPEL =========================
      (28.09.2026, nach der ersten Messung auf dem Handy.)

workspace/assets/js/buehne.js

@@ -101,6 +101,28 @@
     } catch { /* ein Spieler, der noch lädt, kann das noch nicht */ }
   }
 
+  /* ==== DIE ANORDNUNG ====
+     Nur „nur Kamera" schaltet das Bild ab. „Kameras groß" lässt das
+     Video klein stehen — wie klein und wo, bestimmt Filipe in OBS
+     selbst, das ist nicht Sache dieser Quelle. */
+  function bildStellen(s) {
+    document.body.dataset.bild = (s && s.layout === 'nur_kamera') ? 'aus' : 'an';
+  }
+
+  /** Ein neuer Stand — an EINER Stelle.
+   *
+   *  Vorher stand dasselbe Dreierlei zweimal da: merken, Spieler
+   *  bauen oder nachziehen. Als die Anordnung dazukam, wäre sie an
+   *  einer der beiden Stellen vergessen worden. Das ist keine
+   *  Vermutung: Am selben Tag haben im selben Haus zwei Regeln für
+   *  dieselbe Frage der Regieleiste null Pixel gegeben. */
+  function standSetzen(neu) {
+    stand = neu;
+    letztes = Date.now();
+    bildStellen(stand);
+    if (!spieler) api(); else folgen(stand);
+  }
+
   function folgen(s) {
     if (!bereit || !s) return;
     if (s.video && s.video !== letztesVideo) {
@@ -136,9 +158,7 @@
       return false;
     }
     if (!a.ok) return false;
-    stand = await a.json();
-    letztes = Date.now();
-    if (!spieler) api(); else folgen(stand);
+    standSetzen(await a.json());
     return true;
   }
 
@@ -158,8 +178,7 @@
     strom.addEventListener('video', (e) => {
       letztes = Date.now();
       try {
-        stand = { ...(stand || {}), ...JSON.parse(e.data) };
-        if (!spieler) api(); else folgen(stand);
+        standSetzen({ ...(stand || {}), ...JSON.parse(e.data) });
       } catch { /* eine kaputte Meldung darf die Quelle nicht reissen */ }
     });
 

workspace/assets/js/meldung.js

@@ -212,6 +212,10 @@
       'Es sind schon zwei Gäste dabei. Nimm erst jemanden heraus.',
     layout_unbekannt:
       'Diese Anordnung gibt es nicht.',
+    kameragroesse_unklar:
+      'Diese Größe gibt es nicht. Möglich sind 0,6-fach bis 2-fach.',
+    ecke_unklar:
+      'Diese Ecke gibt es nicht. Möglich sind oben/unten und links/rechts.',
     tempo_unklar:
       'Diese Geschwindigkeit gibt es nicht. Möglich sind 0,5 bis 2-fach.',
     schon_im_bild:

workspace/assets/js/reaktion.js

@@ -201,6 +201,11 @@
     /* ---- Live ---- */
     const kino = $('teil-live');
     kino.dataset.layout = lage.layout || 'kino';
+    /* Größe und Ecke der Kamerafenster. Sie stehen am Kino und nicht
+       an jedem Fenster einzeln -- ein Wert, eine Stelle, und die
+       Fenster erben ihn. */
+    kino.dataset.ecke = lage.kamera_ecke || 'ur';
+    kino.style.setProperty('--kam-gross', String(lage.kamera_gross || 1));
     /* Das Tempo steht am Kino und nicht nur im Pult: Der Zuschauer
        soll sehen, warum es schneller läuft -- sonst sucht er den
        Fehler bei seiner Leitung. */
@@ -1598,6 +1603,51 @@
       lreihe.append(k);
     }
 
+    /* ---- Größe der Kamerafenster ----
+       Zwischen „Video groß" (208 px) und „Kameras groß" (380 px) gab
+       es nichts. Für eine Sendung, in der zwei Leute reden, ist das
+       eine zu klein und das andere verdeckt das Video.
+
+       Die Werte kommen vom Server (`lage.kamera_groessen`). Eine
+       zweite Liste hier wäre eine, die irgendwann von der ersten
+       abweicht -- und dann steht ein Knopf da, den der Server
+       ablehnt. */
+    const greihe = $('kamgroesse');
+    greihe.textContent = '';
+    for (const wert of (lage.kamera_groessen || [1])) {
+      const k = el('button', 'kamgroesse__knopf',
+        wert === 1 ? '1×' : `${String(wert).replace('.', ',')}×`);
+      k.type = 'button';
+      k.dataset.gross = String(wert);
+      k.title = wert === 1 ? 'Normale Größe'
+        : `${String(wert).replace('.', ',')}-fache Größe`;
+      k.addEventListener('click', () => bildSetzen({ kamera_gross: wert }));
+      greihe.append(k);
+    }
+
+    /* ---- Ecke ----
+       Vier Knöpfe mit einem kleinen Feld darin, das die Ecke zeigt.
+       Ein Wort wie „oben links" wäre länger zu lesen, als das Bild
+       zu erfassen ist -- und vier Wörter nebeneinander passen am
+       Handy nicht in eine Zeile. Der Name steht trotzdem da, als
+       `aria-label` und als Hinweis unter dem Zeiger. */
+    const ECKENWORT = {
+      ol: 'Oben links', or: 'Oben rechts',
+      ul: 'Unten links', ur: 'Unten rechts',
+    };
+    const ereihe = $('kamecke');
+    ereihe.textContent = '';
+    for (const ecke of (lage.kamera_ecken || ['ur'])) {
+      const k = el('button', 'kamecke__knopf');
+      k.type = 'button';
+      k.dataset.ecke = ecke;
+      k.title = ECKENWORT[ecke] || ecke;
+      k.setAttribute('aria-label', ECKENWORT[ecke] || ecke);
+      k.append(el('i', 'kamecke__feld'));
+      k.addEventListener('click', () => bildSetzen({ kamera_ecke: ecke }));
+      ereihe.append(k);
+    }
+
     /* ---- Geschwindigkeit ----
        Die möglichen Werte kommen vom Server (`lage.tempi`) und
        stehen nicht hier. Eine zweite Liste an einer zweiten Stelle
@@ -1814,13 +1864,36 @@
     tonNachziehen();
   }
 
-  async function layoutSetzen(schluessel) {
+  /** Anordnung, Größe und Ecke gehen denselben Weg.
+   *
+   *  EIN WEG FÜR DAS GANZE BILD: Drei getrennte Aufrufe wären drei
+   *  Rundrufe, und zwischen ihnen sähen die Zusehenden eine
+   *  Mischung -- neue Anordnung, alte Ecke.
+   *
+   *  UND DER EIGENE STAND WIRD GLEICH NACHGEZOGEN. Vorher verließ
+   *  sich `layoutSetzen` allein auf den Rundruf, der auf dem Weg
+   *  über den Server zurückkommt. Das ging gut, solange nur ein
+   *  Wert im Spiel war; bei dreien sieht man in der Zwischenzeit
+   *  die eigene Änderung noch nicht und drückt ein zweites Mal. */
+  async function bildSetzen(was) {
     const a = await hole('/workspace/api/reaktion/layout', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ layout: schluessel }),
+      body: JSON.stringify(was),
     });
-    if (!a.ok) melde(await a.json().catch(() => null), 'Die Anordnung ging nicht.');
+    if (!a.ok) { melde(await a.json().catch(() => null), 'Das ging nicht.'); return; }
+    const d = await a.json();
+    lage = {
+      ...lage,
+      layout: d.layout,
+      kamera_gross: d.kamera_gross,
+      kamera_ecke: d.kamera_ecke,
+    };
+    zeichnen();
+  }
+
+  function layoutSetzen(schluessel) {
+    return bildSetzen({ layout: schluessel });
   }
 
   /* ---- Die Videospur bedienen -------------------------------------- */
@@ -2092,6 +2165,40 @@
     for (const k of $('tempo').children) {
       k.setAttribute('aria-pressed', String(Number(k.dataset.tempo) === (lage.tempo || 1)));
     }
+    for (const k of $('kamgroesse').children) {
+      k.setAttribute('aria-pressed',
+        String(Number(k.dataset.gross) === (lage.kamera_gross || 1)));
+    }
+    /* ==== EIN KNOPF, DER NICHTS TUN KANN, SIEHT AUCH SO AUS ====
+
+       Die GRÖSSE wirkt überall, wo es Kamerafenster gibt — nur bei
+       „Nur Video" gibt es gar keine. Wer dort auf 2× drückt, sieht
+       nichts passieren und sucht den Fehler bei sich.
+
+       Die ECKE wirkt nur bei „Video groß"; in den anderen
+       Anordnungen stehen die Fenster mittig oder füllen die Fläche.
+
+       Beide werden nicht versteckt, sondern grau. Ein Knopf, der
+       verschwindet, lässt einen suchen; einer, der grau ist,
+       erklärt sich — derselbe Grundsatz wie bei den drei großen
+       Knöpfen im Pult. */
+    const anordnung = lage.layout || 'kino';
+    const kamerasDa = anordnung !== 'nur_video';
+    const eckeGilt = anordnung === 'kino';
+    for (const k of $('kamgroesse').children) k.disabled = !kamerasDa;
+    for (const k of $('kamecke').children) {
+      k.setAttribute('aria-pressed', String(k.dataset.ecke === (lage.kamera_ecke || 'ur')));
+      k.disabled = !eckeGilt;
+    }
+    /* EIN SATZ, NICHT DREI. Es gibt immer nur einen Grund
+       gleichzeitig, und drei Zeilen untereinander liest mitten in
+       einer Sendung niemand. */
+    $('kamecke-hinweis').textContent = !kamerasDa
+      ? 'Bei „Nur Video" sind die Kamerafenster ganz weg — Größe und Ecke '
+        + 'gelten wieder, sobald sie zurückkommen.'
+      : eckeGilt
+        ? 'Unten rechts liegt bei TikTok die Knopfreihe — such dir eine freie Ecke.'
+        : 'Die Ecke gilt bei „Video groß" — gerade stehen die Fenster in der Mitte.';
 
     /* ---- Der Umschalter ----
        Er steht nur da, wenn es etwas zum Umschalten GIBT. Ein Knopf,
@@ -2499,7 +2606,24 @@
           }
           return;
         }
-        if (d.was === 'layout') { $('teil-live').dataset.layout = d.layout; return; }
+        if (d.was === 'layout') {
+          /* DER RUNDRUF BRINGT DAS GANZE BILD, nicht nur die
+             Anordnung. Vorher stand hier eine Zeile für `layout`;
+             als Größe und Ecke dazukamen, hätten die Zusehenden die
+             neue Anordnung mit der alten Ecke gesehen -- bis zum
+             nächsten Mal, wenn zufällig etwas anderes den ganzen
+             Stand nachzieht. */
+          if (lage) {
+            lage = {
+              ...lage,
+              layout: d.layout,
+              kamera_gross: d.kamera_gross ?? lage.kamera_gross,
+              kamera_ecke: d.kamera_ecke ?? lage.kamera_ecke,
+            };
+            zeichnen();
+          }
+          return;
+        }
 
         /* ==== MODERATION ==========================================