From c2cf58941d508ed99d9550201728ac9fd7e65a0b Mon Sep 17 00:00:00 2001 From: aiongg Date: Thu, 12 Nov 2026 01:20:42 +0000 Subject: [PATCH] HarmonyPanel: strip and grid span the panel's width; the centre column is marked Swatch::marked draws a thin text-colour edge inside the outline. SwatchTable::span divides the width among a row's cells with per_row; SwatchTable::marked marks cells by index. --- crates/color/src/ui/harmony.rs | 20 ++++++++++++++++---- crates/color/src/ui/palette.rs | 26 +++++++++++++++++++++----- crates/color/tests/it/panels.rs | 21 +++++++++++++++++++++ crates/ui-widgets/src/choice/swatch.rs | 23 ++++++++++++++++++----- 4 files changed, 76 insertions(+), 14 deletions(-) diff --git a/crates/color/src/ui/harmony.rs b/crates/color/src/ui/harmony.rs index a535ddaea..5e3e5146e 100644 --- a/crates/color/src/ui/harmony.rs +++ b/crates/color/src/ui/harmony.rs @@ -281,7 +281,8 @@ impl GuideCache { /// Color Guide: the base swatch (a click sets the base to the current colour) and the rule `Select`; the harmony strip /// (one cell per colour, tooltip the hex); the variation grid, one row per harmony colour from shades to tints (or -/// cool to warm, muted to vivid); the grid's end labels. A click on any cell chooses its colour; Shift or Cmd selects +/// cool to warm, muted to vivid), the harmony colour itself in the marked centre column; the grid's end labels. The +/// strip's and the grid's cells share the panel's width. A click on any cell chooses its colour; Shift or Cmd selects /// several for Save Colors as Swatches. #[must_use = "show the panel with `show`"] #[derive(Pattern)] @@ -330,16 +331,27 @@ impl<'a> HarmonyPanel<'a> { let strip: Vec<(Label, Srgba)> = guide.colors.iter().map(|c| (Label::from(c.to_hex()), *c)).collect(); let mut strip_selection = Selection::default(); let out = - SwatchTable::new(words.harmony.clone(), &strip).per_row(strip.len().max(1)).selection(Bind::bound(&mut strip_selection)).show_all(ui); + SwatchTable::new(words.harmony.clone(), &strip) + .per_row(strip.len().max(1)) + .span(true) + .selection(Bind::bound(&mut strip_selection)) + .show_all(ui); if let Some(i) = out.selected { chosen = strip.get(i).map(|(_, c)| *c); } - let columns = guide.grid.first().map_or(1, Vec::len); + let columns = guide.grid.first().map_or(1, Vec::len).max(1); + let centre = guide.centre(); let flat: Vec<(Label, Srgba)> = guide.grid.iter().flatten().map(|c| (Label::from(c.to_hex()), *c)).collect(); let mut selection = if before_picked.guide == stamp { before_picked.selection.clone() } else { Selection::default() }; let SwatchTableOutput { selected, chosen: cells, .. } = - SwatchTable::new(words.variations.clone(), &flat).multiple(true).per_row(columns).selection(Bind::bound(&mut selection)).show_all(ui); + SwatchTable::new(words.variations.clone(), &flat) + .multiple(true) + .per_row(columns) + .span(true) + .marked(move |&at| at % columns == centre) + .selection(Bind::bound(&mut selection)) + .show_all(ui); if let Some(i) = selected && cells.len() == 1 { diff --git a/crates/color/src/ui/palette.rs b/crates/color/src/ui/palette.rs index 9756a8d0b..bf65f6d09 100644 --- a/crates/color/src/ui/palette.rs +++ b/crates/color/src/ui/palette.rs @@ -4,6 +4,7 @@ use craft_behavior::{DisplayOrder, EditEvent, ItemSource, Metrics, Mixed, Selection, TileLayout}; use craft_theme::Srgba; use craft_ui::choice::{Swatch, SwatchMetrics}; +use craft_ui::list::RowTest; use craft_ui::contract::{ ActivateOn, Bind, BindMut, Collection, CollectionEvent, CollectionProps, Common, Component, ContainerProps, Cx, Held, NoValue, Outcome, Pattern, Props, Role, SelectMode, ShowCollection as _, ShowContainer as _, Sizing, @@ -145,7 +146,8 @@ impl Outcome for SwatchTableOutput { } /// A table of touching colour cells, one per entry, wrapping to the width or to a fixed count per row. Entries are -/// told apart by index, so duplicates select one cell. +/// told apart by index, so duplicates select one cell. With [`span`](Self::span) and a count per row, the cells share +/// the table's width edge to edge; [`marked`](Self::marked) cells draw the swatch mark. /// /// - A click or Space selects the cell; a double click or Enter reports `open` and the Enter is the table's, so a /// dialog around it does not also answer OK. @@ -168,6 +170,12 @@ pub struct SwatchTable<'a> { /// A fixed number of cells to a row instead of wrapping to the width. #[prop] per_row: Option, + /// With `per_row`, the cells of a row divide the table's width among them, at the cell height. + #[prop] + span: bool, + /// The cells that draw the swatch mark, by index. + #[prop(func = "Fn(&usize) -> bool")] + marked: Option>, /// Whether each cell's name is its tooltip. #[prop] tips: bool, @@ -186,6 +194,8 @@ impl<'a> SwatchTable<'a> { swatches, selection: None, per_row: None, + span: false, + marked: None, tips: false, wells: false, } @@ -200,12 +210,14 @@ impl<'a> SwatchTable<'a> { } /// Shows the table. - pub fn show_all(self, ui: &mut Ui) -> SwatchTableOutput { + pub fn show_all(mut self, ui: &mut Ui) -> SwatchTableOutput { let (swatches, tips, wells) = (self.swatches, self.tips, self.wells); + let marked = self.marked.take(); self.show_items(ui, &SwatchRows::new(swatches), &mut |key, _| { let (name, color) = &swatches[*key]; let cell = Swatch::new(name.clone(), *color).cell(); let cell = if wells { cell.well() } else { cell }; + let cell = if marked.as_ref().is_some_and(|test| test.passes(key)) { cell.marked() } else { cell }; if tips { cell.tooltip(name.clone()) } else { cell } }) } @@ -261,10 +273,14 @@ impl Collection for SwatchTable<'_> { fn item_layout(&self, source: &dyn ItemSource, width: f32, cx: &StyleCx<'_>) -> TileLayout { let metrics = SwatchMetrics::of(cx); let cell = if self.wells { metrics.side } else { metrics.cell }; - let layout = TileLayout::new(source, width, Vec2::splat(cell), 0.0); match self.per_row { - Some(columns) => layout.in_columns(columns), - None => layout, + Some(columns) => { + let columns = columns.max(1); + let spans = self.span && width.is_finite() && width > 0.0; + let tile = if spans { Vec2::new(width / columns as f32, cell) } else { Vec2::splat(cell) }; + TileLayout::new(source, width, tile, 0.0).in_columns(columns) + } + None => TileLayout::new(source, width, Vec2::splat(cell), 0.0), } } } diff --git a/crates/color/tests/it/panels.rs b/crates/color/tests/it/panels.rs index 37d0e582f..3dad2f9d3 100644 --- a/crates/color/tests/it/panels.rs +++ b/crates/color/tests/it/panels.rs @@ -168,6 +168,27 @@ fn a_swatch_table_runs_as_many_components_for_many_cells_as_for_few() { assert_eq!(few, many, "the runs grow with the cells: {few} for 4 cells, {many} for 64"); } +/// A spanning table of 4 cells to a row: the cells of a row cover the table's width edge to edge, each next to the one +/// before without overlap, and the second row starts under the first. +#[trial] +fn a_spanning_swatch_table_divides_its_width_among_a_rows_cells() { + let entries = table_entries(8); + let mut fixture = Fixture::new(move |ui| { + let _ = SwatchTable::new("Color Table", &entries).per_row(4).span(true).show_all(ui); + }); + fixture.room(Vec2::new(400.0, 200.0)).settle(); + let table = fixture.by_role(Role::LIST_BOX).first().expect("the table").rect; + let cell = |i: usize| fixture.by_label(&format!("Index {i}")).unwrap_or_else(|| panic!("cell {i}")).rect; + let row: Vec<_> = (0..4).map(cell).collect(); + assert!((row[0].left() - table.left()).abs() < 0.5, "the first cell starts at the table's edge: {row:?} in {table:?}"); + assert!((row[3].right() - table.right()).abs() < 0.5, "the last cell ends at the table's edge: {row:?} in {table:?}"); + for pair in row.windows(2) { + assert!(pair[1].left() >= pair[0].right() - 0.5 && pair[1].left() <= pair[0].right() + 0.5, "cells touch without overlap: {pair:?}"); + } + assert!(row[0].width() > row[0].height(), "a spanning cell is wider than the square cell: {:?}", row[0]); + assert!(cell(4).top() >= row[0].bottom() - 0.5 && (cell(4).left() - row[0].left()).abs() < 0.5, "the fifth cell starts the second row"); +} + /// A table's cell is a list box option named by its entry with the colour as its value; a click selects it, and the /// pointer's rest shows its name. #[trial] diff --git a/crates/ui-widgets/src/choice/swatch.rs b/crates/ui-widgets/src/choice/swatch.rs index 3973740ea..47299dc8d 100644 --- a/crates/ui-widgets/src/choice/swatch.rs +++ b/crates/ui-widgets/src/choice/swatch.rs @@ -56,6 +56,8 @@ pub struct SwatchStyle { edge: Stateful, /// The ring inside the outline of a selected or checked well; clear while it is off. ring: Stateful, + /// The thin edge just inside the outline of a marked well. + mark: StyleColor, /// The well of a mixed colour. mixed_fill: StyleColor, /// The dash on a mixed well. @@ -124,7 +126,8 @@ impl crate::contract::ItemOutput for SwatchOutput { /// translucent) and whose colour value is the colour; a mixed well has the value "Mixed" and no colour value. /// `member` makes the swatch a member of the enclosing `RadioGroup`: a radio button, checked when the group holds its /// value, whose keys and focus are the group's. `cell` makes it a cell of a table of touching swatches, a list box -/// option. The selected ring is `selected` or a checked radio. +/// option. The selected ring is `selected` or a checked radio. `marked` draws a thin edge in the text colour just inside +/// the outline: a cell that stands out from its row, such as the harmony colour among its variations. #[derive(crate::contract::Component, crate::contract::Props)] #[component(content_painter, probe(Swatch))] pub struct Swatch { @@ -144,6 +147,9 @@ pub struct Swatch { /// Takes the width the layout offers, at the control height. #[prop(flag)] fill: bool, + /// A thin edge in the text colour just inside the outline. + #[prop(flag)] + marked: bool, /// The key of the `ColorRequest` a click files. #[prop(into)] picker: Option, @@ -161,6 +167,7 @@ impl Swatch<()> { cell: false, well: false, fill: false, + marked: false, picker: None, checked: false, activation: None, @@ -179,6 +186,7 @@ impl Swatch { cell: self.cell, well: self.well, fill: self.fill, + marked: self.marked, picker: self.picker, checked: false, activation: None, @@ -208,6 +216,7 @@ impl Component for Swatch { radius: if key.cell && !key.well { CornerRadius::ZERO } else { metrics.radius }, edge: Stateful::new(rest).off(States::new(rest, rest, rest, disabled)), ring: Stateful::new(clear).on(States::new(accent, accent, accent, disabled)), + mark: cx.color(colors.text.normal), mixed_fill: cx.color(colors.surface.sunken), mixed_mark: cx.color(colors.text.muted), checker: [colors.overlay.checker_light, colors.overlay.checker_dark], @@ -264,7 +273,7 @@ impl Component for Swatch { } fn paint(&mut self, ui: &mut PaintUi<'_>, cx: &Cx<'_, Self>) { - paint_face(&ui.draw(), cx.rect, cx.style, cx.state(), self.color); + paint_face(&ui.draw(), cx.rect, cx.style, cx.state(), self.color, self.marked); } fn finish(self, cx: Cx<'_, Self>) -> SwatchOutput { @@ -275,8 +284,8 @@ impl Component for Swatch { } /// The one swatch face painter: the well of `color` in `well` (a checkerboard behind a translucent colour, the dash -/// of a mixed one), then the outline ring and the selection ring, in `state`. -fn paint_face(draw: &Draw<'_>, well: Rect, style: &SwatchStyle, state: &StateSet, color: Mixed) { +/// of a mixed one), then the outline ring, the mark when `marked`, and the selection ring, in `state`. +fn paint_face(draw: &Draw<'_>, well: Rect, style: &SwatchStyle, state: &StateSet, color: Mixed, marked: bool) { let shape = PaintShape::Rect(well, style.radius); match color.same() { None => { @@ -291,6 +300,10 @@ fn paint_face(draw: &Draw<'_>, well: Rect, style: &SwatchStyle, state: &StateSet } } draw.stroke(&shape, StrokeWidth::Thin, state.resolve(&style.edge)); + if marked { + let inside = PaintShape::Rect(well.shrink(draw.width(StrokeWidth::Thin)), style.radius); + draw.stroke(&inside, StrokeWidth::Thin, style.mark); + } draw.stroke(&shape, StrokeWidth::Thick, state.resolve(&style.ring)); } @@ -323,6 +336,6 @@ impl SwatchFace { let style = resolve_style(&scope, key, cx.painter.ctx(), Swatch::<()>::style); let (flags, on) = if self.selected { (Flags::SELECTED, 1.0) } else { (Flags::empty(), 0.0) }; let state = StateSet::new(State::Rest, flags, StateMix::new(0.0, 0.0, on)); - cx.with_draw(|draw| paint_face(draw, rect, &style, &state, self.color)); + cx.with_draw(|draw| paint_face(draw, rect, &style, &state, self.color, false)); } }