TASK 63: the border-colour picker IS the app's own drop-down

The creator (2026-10-21), on Live -> Layers -> webcam -> Properties:

  "why does the drop down under the web cam properties not show the same style for
   the border color drop down list box?"

  "one of the first things we did was define branding. We established look-and-feel
   standards. And yet you keep ignoring these and I'm wondering why"

WHY IT WAS MISSED - the answer the creator is owed.
The TASK 58 sweep had already walked the whole app for un-themed controls and the
border picker STILL was not themed, because the sweep looked for control TYPES
(ComboBox / CheckBox / TextBox) carrying no theme style - and the border picker was
NONE of those. It was a "..." Button whose Click handler built a ContextMenu of
swatches in code. It was never in the sweep's scope, and PropertiesStyleTests.cs
(a type-based guard) could not see it either. A picker that LOOKS like a drop-down
is invisible to a type-based audit; the guard has to ask "is this the app's widget?".

WHAT CHANGED
- The picker is now the app's YtComboBox - the widget the Display and Font pickers
  wear - bound to the palette (SelectedElement.BorderColorOptions) with its selection
  bound by VALUE (SelectedItem -> BorderColorEntry), because WPF's SelectedValue
  matching is ordinal and the palette mixes #FFFFFF and #e94560.
- The closed box shows the swatch + the colour's NAME; the rows show swatch + hex +
  name (the rows the creator approved in TASK 60). A ComboBox cannot do that with one
  ItemTemplate - WPF copies it into the read-only SelectionBoxItemTemplate - so
  Helpers/ClosedBoxTemplateSelector.cs picks by the ContentPresenter's templated
  parent: the ComboBox for the closed box, the ComboBoxItem for a row. Verified
  against WPF with a throwaway probe, not assumed.
- The swatch is painted by the THEME (Helpers/HexToBrushConverter.cs, registered as
  HexToBrush) - the hand-painted SolidColorBrush(Color.FromRgb(...)) in the old
  click handler was the exact anti-pattern the theme forbids. The swatch also carries
  a 1px #2a3a5e border now, so black and dark swatches are visible on the dark menu
  (the follow-up TASK 60 left open).
- The hex field stays (60px, editable): a colour outside the palette can still be
  typed, and the drop-down then carries that hex as a NAMELESS entry ("no name" is the
  honest answer). The palette's name moved out of TASK 62's TextBlock into the
  drop-down's closed box.
- The hand-built menu, its ContextMenu/MenuItem/SolidColorBrush code and
  WebcamBorderColorPicker_Click are gone.

MODEL: SceneElement.BorderColorName -> BorderColorEntry (the palette entry for the
current hex, with its name; setting it writes the hex back) + BorderColorOptions (the
palette plus the custom entry), both raised when BorderColor changes.
BorderColorPalette gains EntryFor(hex) and OptionsFor(hex); NameOf delegates.

Guards: ytLive.Tests/BorderColorPickerTests.cs (the ONE test for this change - the
model, the panel, and the REAL widget: with the app's theme style and the panel's own
templates the closed box names the colour and the rows show the hex AND the name).
The TASK 60 guard (BorderColorPaletteTests) was updated because the mechanism it
asserted - a code-built menu - no longer exists; it now guards the new wiring (the
drop-down is bound to the palette and neither the panel nor the code-behind carries a
second list of colours).

Full suite: 435/435 passed, 0 warnings.
This commit is contained in:
2026-10-21 23:09:11 -07:00
parent ef52508b1e
commit 987fddac24
19 changed files with 536 additions and 143 deletions
+61
View File
@@ -2213,3 +2213,64 @@ widths should be fixed to accomodate the max number of possible digits."* The ro
5. **A label beside a field needs the field to be FIXED too.** The same trap in a different
costume: a field that fills its row pushes whatever sits after it to the far edge, so the
label drifts away from the value it labels (TASK 62 — the colour name beside the hex field).
## 2026-10-21 — A STYLE SWEEP THAT LOOKS AT CONTROL TYPES CANNOT SEE A HAND-ROLLED PICKER (RECIPE — TASK 63)
The creator: *"one of the first things we did was define branding. We established look-and-feel
standards. And yet you keep ignoring these and I'm wondering why"* — about the webcam's
border-colour drop-down.
**The trap:** the TASK 58 sweep had already walked the whole app for un-themed controls, and the
border picker STILL was not themed. The reason is a one-line blind spot in the sweep itself:
it asked *"does this `ComboBox`/`CheckBox`/`TextBox` carry a theme style?"* — and the border
picker was **none of those types**. It was a `Button` whose `Click` handler built a
`ContextMenu` of swatches in code. The sweep's guard (`PropertiesStyleTests.cs`) asserts control
**types**, so it could not see it either. A picker that LOOKS like a drop-down is invisible to a
type-based audit.
**The recipe:**
1. When auditing for the design system, search for **what a control DOES**, not what it IS:
grep for `Click=` handlers that open a `ContextMenu`/`Menu`/`Popup`, and for `new
ContextMenu`/`new MenuItem` in code-behind. A menu built in code is a control that never
wears the theme.
2. The guard must assert the **design system**, not the control type: for every control that
presents a CHOICE to the creator, assert it is the app's widget (`Style="{StaticResource
YtComboBox}"` etc.). "It is a ComboBox" is not the requirement; "it is the app's ComboBox" is.
3. **A hand-painted brush in code is the same smell as a hand-painted `Background`** — the theme
owns the colour. A colour is DATA: bind it and let a converter paint it
(`Helpers/HexToBrushConverter.cs`).
## 2026-10-21 — A COMBOBOX'S CLOSED BOX AND ITS ROWS CAN ONLY DIFFER THROUGH A TEMPLATE SELECTOR (RECIPE — TASK 63)
WPF copies `ComboBox.ItemTemplate` into `SelectionBoxItemTemplate`, and that property is
**read-only in C#** ("Property or indexer 'ComboBox.SelectionBoxItemTemplate' cannot be assigned
to -- it is read only"). So one `ItemTemplate` renders the SAME content in the closed box and in
every row — you cannot show "Crimson" when shut and "#e94560 Crimson" when open.
**The one mechanism that works — an `ItemTemplateSelector`.** WPF calls it with the
`ContentPresenter`'s **templated parent**:
| What is rendering | The container's `TemplatedParent` |
|---|---|
| the CLOSED selection box | the **`ComboBox`** |
| a drop-down ROW | the **`ComboBoxItem`** |
```csharp
public override DataTemplate? SelectTemplate(object item, DependencyObject container)
=> container is FrameworkElement { TemplatedParent: ComboBox } ? ClosedTemplate : RowTemplate;
```
**What does NOT work:** setting `ComboBoxItem.ContentTemplate` through an `ItemContainerStyle`.
WPF overwrites the container's `ContentTemplate` with the ComboBox's `ItemTemplate` (null) when
it prepares the container, so the style's value is wiped.
**How I found it (the probe recipe):** a throwaway xunit test in the test project (STA via the
`RealApp` collection host), a `ComboBox` in a shown `Window`, an `ItemTemplateSelector` that
logs `container.GetType().Name` + the parent's type, and a `DispatcherPriority.Loaded` pump so
the popup materialises its rows. The log `item=a,parent=ComboBox | item=a,parent=ComboBoxItem`
settled the design in one run. **Probe, then code** — this is not in any WPF book.
**Bonus measurement (the theme's popup):** the `YtComboBox` popup carries no width binding, so it
sizes to its **content**, not to the ComboBox — measured 142.7px of popup for a 100px ComboBox
whose rows read "swatch + hex + name". A long row is never clipped, and the popup may be wider
than the closed box. Measure with `ActualWidth` in a throwaway test; do not guess widths.