SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
Colour popover: step buttons, HSV fields and recent colours (#9234) (#9398)
PaddleStrokeeaf3acc297ca
diff --git a/assets/locales/pending/color-popover-hsv-recent.json b/assets/locales/pending/color-popover-hsv-recent.jsonnew file mode 100644index 0000000000..5184bc13cb--- /dev/null+++ b/assets/locales/pending/color-popover-hsv-recent.json@@ -0,0 +1,90 @@+{+ "en": {+ "color.recent": "Recent colors",+ "color.recent_help": "Colors you pick in any color field appear here",+ "color.saturation": "Saturation (percent)",+ "color.step_down": "Step down",+ "color.step_up": "Step up",+ "color.value": "Value, the brightness (percent)"+ },+ "en-GB": {+ "color.recent": "Recent colours",+ "color.recent_help": "Colours you pick in any colour field appear here",+ "color.saturation": "Saturation (per cent)",+ "color.step_down": "Step down",+ "color.step_up": "Step up",+ "color.value": "Value, the brightness (per cent)"+ },+ "ar": {+ "color.recent": "الألوان الأخيرة",+ "color.recent_help": "تظهر هنا الألوان التي تختارها في أي حقل لون",+ "color.saturation": "التشبع (بالمئة)",+ "color.step_down": "إنقاص خطوة",+ "color.step_up": "زيادة خطوة",+ "color.value": "القيمة، أي السطوع (بالمئة)"+ },+ "de": {+ "color.recent": "Zuletzt verwendete Farben",+ "color.recent_help": "Farben, die Sie in einem beliebigen Farbfeld wählen, erscheinen hier",+ "color.saturation": "Sättigung (Prozent)",+ "color.step_down": "Schritt nach unten",+ "color.step_up": "Schritt nach oben",+ "color.value": "Hellwert (Prozent)"+ },+ "es": {+ "color.recent": "Colores recientes",+ "color.recent_help": "Los colores que elija en cualquier campo de color aparecen aquí",+ "color.saturation": "Saturación (porcentaje)",+ "color.step_down": "Bajar un paso",+ "color.step_up": "Subir un paso",+ "color.value": "Valor, el brillo (porcentaje)"+ },+ "fr": {+ "color.recent": "Couleurs récentes",+ "color.recent_help": "Les couleurs choisies dans n'importe quel champ de couleur apparaissent ici",+ "color.saturation": "Saturation (pour cent)",+ "color.step_down": "Diminuer d'un pas",+ "color.step_up": "Augmenter d'un pas",+ "color.value": "Valeur, la luminosité (pour cent)"+ },+ "he": {+ "color.recent": "צבעים אחרונים",+ "color.recent_help": "צבעים שבוחרים בכל שדה צבע מופיעים כאן",+ "color.saturation": "רוויה (אחוזים)",+ "color.step_down": "צעד למטה",+ "color.step_up": "צעד למעלה",+ "color.value": "ערך, הבהירות (אחוזים)"+ },+ "it": {+ "color.recent": "Colori recenti",+ "color.recent_help": "I colori scelti in qualsiasi campo colore compaiono qui",+ "color.saturation": "Saturazione (percentuale)",+ "color.step_down": "Diminuisci di un passo",+ "color.step_up": "Aumenta di un passo",+ "color.value": "Valore, la luminosità (percentuale)"+ },+ "ja": {+ "color.recent": "最近使った色",+ "color.recent_help": "どの色フィールドで選んだ色もここに表示されます",+ "color.saturation": "彩度(パーセント)",+ "color.step_down": "1 ステップ下げる",+ "color.step_up": "1 ステップ上げる",+ "color.value": "明度(パーセント)"+ },+ "vi": {+ "color.recent": "Màu gần đây",+ "color.recent_help": "Các màu bạn chọn ở bất kỳ ô màu nào sẽ hiện ở đây",+ "color.saturation": "Độ bão hòa (phần trăm)",+ "color.step_down": "Giảm một bước",+ "color.step_up": "Tăng một bước",+ "color.value": "Giá trị, độ sáng (phần trăm)"+ },+ "zh": {+ "color.recent": "最近使用的颜色",+ "color.recent_help": "在任意颜色字段中选择的颜色会显示在这里",+ "color.saturation": "饱和度(百分比)",+ "color.step_down": "减少一步",+ "color.step_up": "增加一步",+ "color.value": "明度(百分比)"+ }+}diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex 955a833a81..55ca5177c9 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -212,6 +212,7 @@ mod print_face_ui;pub(crate) mod quick_measure;#[cfg(test)]mod quick_measure_tests;+pub(crate) mod recent_colors;pub mod recovery_ui;pub mod ref_images;mod render_ui;@@ -370,6 +371,8 @@ pub struct UiState {/// The running tool's icon rides beside the pointer in the viewport (View settings; off by/// default).pub tool_cursor: bool,+ /// The colours picked last in any colour picker, newest first (#9234); kept between runs.+ pub recent_colors: Vec<[u8; 3]>,}impl UiState {@@ -407,6 +410,7 @@ impl Default for UiState {up_axis: Default::default(),agent_cursor: Default::default(),tool_cursor: false,+ recent_colors: Vec::new(),}}}@@ -1008,6 +1012,7 @@ impl SolveApp {"autosave_minutes": self.autosave_minutes,"ground_shadow": self.ui.ground_shadow,"agent_cursor": self.ui.agent_cursor,+ "recent_colors": self.ui.recent_colors,"preferences": self.preferences,"gpu_path_setup_seconds": self.render_workspace.setup_seconds,});@@ -1112,6 +1117,12 @@ impl SolveApp {if let Some(a) = v.get("agent_cursor").and_then(|a| serde_json::from_value(a.clone()).ok()) {self.ui.agent_cursor = a;}+ // Colours that do not read (not three bytes) are left out; the list is capped.+ self.ui.recent_colors = v+ .get("recent_colors")+ .and_then(Value::as_array)+ .map(|a| a.iter().filter_map(|c| serde_json::from_value::<[u8; 3]>(c.clone()).ok()).take(recent_colors::MAX_RECENT_COLORS).collect())+ .unwrap_or_default();}pub fn with_control(mut self, rx: Receiver<ControlRequest>) -> Self {@@ -2766,6 +2777,7 @@ impl SolveApp {pub fn ui(&mut self, ui: &mut egui::Ui) {value_step::set_enabled(ui.ctx(), self.preferences.step_values);canvas::set_boxes_shown(ui.ctx(), self.preferences.value_boxes_in_view);+ recent_colors::share(ui.ctx(), &mut self.ui.recent_colors);let t0 = now_ms();// The first frames draw with the bundled faces while the system's CJK, Hangul and Thai// faces are read on a thread; the fonts are installed again once they are there.diff --git a/crates/ui-egui/src/recent_colors.rs b/crates/ui-egui/src/recent_colors.rsnew file mode 100644index 0000000000..f77376b8c9--- /dev/null+++ b/crates/ui-egui/src/recent_colors.rs@@ -0,0 +1,55 @@+//! The colours picked last in any colour field, newest first (#9234). The app keeps the list in+//! its saved settings (`UiState::recent_colors`) and hands it to the colour pickers every frame+//! through egui memory; the shared `ui_kit` colour popover shows it and adds finished picks.++/// How many colours the recent list keeps.+pub(crate) const MAX_RECENT_COLORS: usize = 12;++/// The colours picked last, newest first, shared by every colour picker of the window.+#[derive(Clone, Default)]+struct RecentColors {+ colors: Vec<[u8; 3]>,+ /// Picked since the app last took the list for its settings.+ changed: bool,+}++fn recent_id() -> egui::Id {+ egui::Id::new("color_recent_colors")+}++/// The recently picked colours, newest first.+pub(crate) fn recent_colors(ctx: &egui::Context) -> Vec<[u8; 3]> {+ ctx.data(|d| d.get_temp::<RecentColors>(recent_id())).map(|r| r.colors).unwrap_or_default()+}++/// Put a finished pick at the front of the recent list (once, capped).+/// `replacing` is the colour the same popover added earlier while it stayed open: it goes if it+/// is still the newest entry.+pub(crate) fn remember_color(ctx: &egui::Context, rgb: [u8; 3], replacing: Option<[u8; 3]>) {+ ctx.data_mut(|d| {+ let recent = d.get_temp_mut_or_default::<RecentColors>(recent_id());+ if replacing.is_some() && recent.colors.first().copied() == replacing {+ recent.colors.remove(0);+ }+ recent.colors.retain(|c| *c != rgb);+ recent.colors.insert(0, rgb);+ recent.colors.truncate(MAX_RECENT_COLORS);+ recent.changed = true;+ });+}++/// Keep the saved list and the pickers' list the same; the app calls this every frame. Picks made+/// since the last call are written to `saved`; otherwise `saved` (loaded, reset) is what the+/// pickers show.+pub(crate) fn share(ctx: &egui::Context, saved: &mut Vec<[u8; 3]>) {+ saved.truncate(MAX_RECENT_COLORS);+ ctx.data_mut(|d| {+ let recent = d.get_temp_mut_or_default::<RecentColors>(recent_id());+ if recent.changed {+ saved.clone_from(&recent.colors);+ recent.changed = false;+ } else if recent.colors != *saved {+ recent.colors.clone_from(saved);+ }+ });+}diff --git a/crates/ui-egui/src/ui_kit/color.rs b/crates/ui-egui/src/ui_kit/color.rsindex aaf5a54532..dfef5e72aa 100644--- a/crates/ui-egui/src/ui_kit/color.rs+++ b/crates/ui-egui/src/ui_kit/color.rs@@ -1,5 +1,6 @@//! Document RGB and optional separate opacity editing. Interface paint uses tokens; gradients are colour data.use super::{layout::label, metrics::dimension};+use crate::recent_colors::{MAX_RECENT_COLORS, recent_colors, remember_color};use crate::ui_kit::{Container, Surface};use crate::{i18n, scenario, theme::Tokens};use egui::{Color32, Response, Sense, Ui, ecolor::HsvaGamma, pos2, vec2};@@ -122,6 +123,7 @@ fn color_popover_with_opacity(ui: &mut Ui, rgb: &mut [u8; 3], mut opacity: Optiolet mut hexadecimal = ui.ctx().data(|d| d.get_temp::<bool>(format_id)).unwrap_or(false);let mut linear = ui.global_style().visuals.numeric_color_space == egui::style::NumericColorSpace::Linear;let mut accepted_mixed = false;+ let mut picked_recent = false;ui.vertical(|ui| {ui.spacing_mut().item_spacing.y = t.space_10;ui.horizontal(|ui| {@@ -197,27 +199,14 @@ fn color_popover_with_opacity(ui: &mut Ui, rgb: &mut [u8; 3], mut opacity: Optio}});} else {+ let spin = if linear {+ Spin { max: 1.0, step: 0.01, speed: 0.003, decimals: 3 }+ } else {+ Spin { max: 255.0, step: 1.0, speed: 0.5, decimals: 0 }+ };ui.columns(3, |columns| {for ((ui, channel), name) in columns.iter_mut().zip(channels.iter_mut()).zip(["R", "G", "B"]) {- ui.vertical(|ui| {- ui.spacing_mut().item_spacing.y = t.space_3;- ui.add(egui::Label::new(egui::RichText::new(name).size(t.font_small).color(t.form_dim)));- let response = ui.add_sized(- vec2(dimension(ui.available_width()), t.control_height),- egui::DragValue::new(channel)- .range(0.0..=if linear { 1.0 } else { 255.0 })- .speed(if linear { 0.003 } else { 0.5 })- .custom_parser(crate::prefs::parse_number)- .custom_formatter(move |v, _| if linear { format!("{v:.03}") } else { format!("{v:.0}") }),- );- response.widget_info(|| {- let mut info = egui::WidgetInfo::drag_value(ui.is_enabled(), *channel);- info.label = Some(name.into());- info- });- publish(&format!("color:channel:{name}"), &response);- edited |= response.changed();- });+ edited |= spin_channel(ui, name, None, channel, spin);}});}@@ -233,6 +222,23 @@ fn color_popover_with_opacity(ui: &mut Ui, rgb: &mut [u8; 3], mut opacity: Optio}// Only graphical edits convert HSV back to RGB. Typed byte values stay exact.let mut graphical_edit = false;+ // Hue in degrees, saturation and value in percent, of the same gamma HSV the square shows.+ const HSV: [(&str, &str, f64); 3] = [("H", "color.hue", 360.0), ("S", "color.saturation", 100.0), ("V", "color.value", 100.0)];+ let mut hsv_fields = [hsv.h, hsv.s, hsv.v].iter().zip(HSV).map(|(v, (_, _, max))| f64::from(*v) * max).collect::<Vec<_>>();+ let mut hsv_edited = false;+ ui.columns(3, |columns| {+ for ((ui, value), (name, tip, max)) in columns.iter_mut().zip(hsv_fields.iter_mut()).zip(HSV) {+ hsv_edited |= spin_channel(ui, name, Some(i18n::tr(tip)), value, Spin { max, step: 1.0, speed: 0.5, decimals: 0 });+ }+ });+ if hsv_edited {+ let unit = |at: usize| {+ let (value, max) = (hsv_fields.get(at).copied().unwrap_or(0.0), HSV.get(at).map_or(1.0, |h| h.2));+ if value.is_finite() { (value / max).clamp(0.0, 1.0) as f32 } else { 0.0 }+ };+ (hsv.h, hsv.s, hsv.v) = (unit(0), unit(1), unit(2));+ graphical_edit = true;+ }let width = dimension(ui.available_width());let (square, response) = ui.allocate_exact_size(vec2(width, t.control_height * 7.0 + t.space_4), Sense::click_and_drag());if (response.clicked() || response.dragged())@@ -274,7 +280,33 @@ fn color_popover_with_opacity(ui: &mut Ui, rgb: &mut [u8; 3], mut opacity: Optio);publish("color:current", &response);response.on_hover_text(i18n::tr("color.selected"));+ if let Some(picked) = recent_row(ui, width) {+ *rgb = picked;+ picked_recent = true;+ accepted_mixed = mixed;+ hsv = crate::theme::srgb(rgb.map(|c| f32::from(c) / 255.0)).into();+ hex.set(*rgb, opacity.as_deref().copied());+ }});+ // A colour joins the recent list once an edit is finished: a drag or a held step button is+ // released, a typed value is entered. Every picker shares the list (`crate::recent_colors`).+ // While the popover stays open, fine-tuning replaces the colour it added rather than filling+ // the list with each step; a colour taken from the list starts a new entry.+ let session_id = id.with("recent_session");+ let pass = ui.ctx().cumulative_pass_nr();+ let mut session = ui.ctx().data(|d| d.get_temp::<RecentSession>(session_id)).unwrap_or_default();+ if session.pass.saturating_add(1) < pass {+ session = RecentSession::default();+ }+ session.pass = pass;+ session.pending |= *rgb != before_rgb;+ if session.pending && !ui.input(|i| i.pointer.any_down()) {+ let replacing = if picked_recent { None } else { session.entry };+ remember_color(ui.ctx(), *rgb, replacing);+ session.entry = if picked_recent { None } else { Some(*rgb) };+ session.pending = false;+ }+ ui.ctx().data_mut(|d| d.insert_temp(session_id, session));hex.sync(*rgb, opacity.as_deref().copied());ui.ctx().data_mut(|d| d.insert_temp(id, (*rgb, hsv)));ui.ctx().data_mut(|d| {@@ -335,6 +367,161 @@ fn parse_hex(text: &str) -> Option<([u8; 3], Option<u8>)> {Some(([byte(0)?, byte(2)?, byte(4)?], if digits.len() == 8 { Some(byte(6)?) } else { None }))}+/// How a channel number edits: its range `0..=max`, the step of its step buttons, the drag+/// speed and the decimals shown.+#[derive(Clone, Copy)]+struct Spin {+ max: f64,+ step: f64,+ speed: f64,+ decimals: usize,+}++/// One channel of the popover: its name above a drag field (drag, or click and type) and a pair+/// of step buttons for fine adjustment. Returns whether the value changed.+/// Tokens: space_2/3/14, control_height, font_small, form_dim.+fn spin_channel(ui: &mut Ui, name: &str, tip: Option<&str>, value: &mut f64, spin: Spin) -> bool {+ let t = Tokens::get();+ let Spin { max, step, speed, decimals } = spin;+ let mut changed = false;+ ui.vertical(|ui| {+ ui.spacing_mut().item_spacing.y = t.space_3;+ let label = ui.add(egui::Label::new(egui::RichText::new(name).size(t.font_small).color(t.form_dim)));+ if let Some(tip) = tip {+ label.on_hover_text(tip);+ }+ ui.horizontal(|ui| {+ ui.spacing_mut().item_spacing.x = t.space_2;+ let width = dimension(ui.available_width() - t.space_14 - t.space_2);+ let response = ui.add_sized(+ vec2(width, t.control_height),+ egui::DragValue::new(value)+ .range(0.0..=max)+ .speed(speed)+ .custom_parser(crate::prefs::parse_number)+ .custom_formatter(move |v, _| format!("{v:.decimals$}")),+ );+ response.widget_info(|| {+ let mut info = egui::WidgetInfo::drag_value(ui.is_enabled(), *value);+ info.label = Some(tip.unwrap_or(name).into());+ info+ });+ publish(&format!("color:channel:{name}"), &response);+ let response = match tip {+ Some(tip) => response.on_hover_text(tip),+ None => response,+ };+ changed |= response.changed();+ let steps = spin_buttons(ui, name, t.control_height);+ if steps != 0 {+ let current = if value.is_finite() { *value } else { 0.0 };+ *value = (current + f64::from(steps) * step).clamp(0.0, max);+ changed = true;+ }+ });+ });+ changed+}++/// Seconds a step button is held before it repeats, then between repeats.+const REPEAT_DELAY: f64 = 0.4;+const REPEAT_EVERY: f64 = 0.05;++/// Step buttons stacked beside a number: a press steps once, holding repeats. Returns this+/// frame's steps (+ up, − down). Tokens: space_14, control_radius, hover, form_ink, form_dim.+fn spin_buttons(ui: &mut Ui, key: &str, height: f32) -> i32 {+ let t = Tokens::get();+ let (rect, _) = ui.allocate_exact_size(vec2(t.space_14, height), Sense::hover());+ let (top, bottom) = rect.split_top_bottom_at_fraction(0.5);+ let mut steps = 0;+ for (direction, half, label, end) in [(1, top, "color.step_up", "up"), (-1, bottom, "color.step_down", "down")] {+ let id = ui.id().with(("color_spin", key, end));+ let response = ui.interact(half, id, Sense::click());+ response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), i18n::tr(label)));+ publish(&format!("color:spin:{key}:{end}"), &response);+ let held = response.is_pointer_button_down_on();+ if response.hovered() || held {+ ui.painter().rect_filled(half, t.control_radius, t.hover);+ }+ let ink = if response.hovered() || held { t.form_ink } else { t.form_dim };+ let side = half.height().min(half.width());+ let icon = egui::Rect::from_center_size(half.center(), vec2(side, side));+ if direction > 0 {+ crate::icons::paint_ink_flipped(ui.painter(), icon, "chevron", ink);+ } else {+ crate::icons::paint_ink(ui.painter(), icon, "chevron", ink);+ }+ let repeat = id.with("repeat");+ if held {+ let now = ui.input(|i| i.time);+ let next = ui.ctx().data(|d| d.get_temp::<f64>(repeat));+ let due = match next {+ None => Some(now + REPEAT_DELAY),+ Some(next) if now >= next => Some(now + REPEAT_EVERY),+ Some(_) => None,+ };+ if let Some(due) = due {+ steps += direction;+ ui.ctx().data_mut(|d| d.insert_temp(repeat, due));+ }+ ui.ctx().request_repaint_after(std::time::Duration::from_secs_f64(REPEAT_EVERY));+ } else {+ ui.ctx().data_mut(|d| d.remove::<f64>(repeat));+ }+ response.on_hover_text(i18n::tr(label));+ }+ steps+}++/// One popover's part in the recent list while it stays open (drawn on consecutive passes).+#[derive(Clone, Copy, Default)]+struct RecentSession {+ /// The pass the popover was last drawn on; a gap means it was closed and opened again.+ pass: u64,+ /// The colour changed and the edit is not finished yet (a button is still down).+ pending: bool,+ /// The colour this opening added, replaced by the next finished edit.+ entry: Option<[u8; 3]>,+}++/// The recent colours as a row of samples (empty slots outlined); returns the one clicked.+/// Tokens: space_3/4/8, font_small, form_dim, control_radius/border, border, form_ink.+fn recent_row(ui: &mut Ui, width: f32) -> Option<[u8; 3]> {+ let t = Tokens::get();+ let colors = recent_colors(ui.ctx());+ let mut picked = None;+ ui.vertical(|ui| {+ ui.spacing_mut().item_spacing.y = t.space_3;+ ui.add(egui::Label::new(egui::RichText::new(i18n::tr("color.recent")).size(t.font_small).color(t.form_dim)));+ let gap = t.space_4;+ let slots = MAX_RECENT_COLORS as f32;+ let side = ((width - gap * (slots - 1.0)) / slots).max(t.space_8);+ let (row, response) = ui.allocate_exact_size(vec2(width, side), Sense::hover());+ publish("color:recent", &response);+ if colors.is_empty() {+ response.on_hover_text(i18n::tr("color.recent_help"));+ }+ for slot in 0..MAX_RECENT_COLORS {+ let rect = egui::Rect::from_min_size(row.min + vec2(slot as f32 * (side + gap), 0.0), vec2(side, side));+ let Some(&[r, g, b]) = colors.get(slot) else {+ ui.painter().rect_stroke(rect, t.control_radius, t.control_border_stroke(t.border), egui::StrokeKind::Inside);+ continue;+ };+ let response = ui.interact(rect, ui.id().with(("color_recent", slot)), Sense::click());+ let stroke = if response.hovered() { t.control_border_stroke(t.form_ink) } else { t.control_border_stroke(t.control_border) };+ ui.painter().rect(rect, t.control_radius, crate::theme::srgb([r, g, b].map(|c| f32::from(c) / 255.0)), stroke, egui::StrokeKind::Inside);+ let hex = format!("#{r:02x}{g:02x}{b:02x}");+ response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, &hex));+ publish(&format!("color:recent:{slot}"), &response);+ let response = response.on_hover_cursor(egui::CursorIcon::PointingHand).on_hover_text(&hex);+ if response.clicked() {+ picked = Some([r, g, b]);+ }+ }+ });+ picked+}+fn marker(ui: &Ui, at: egui::Pos2, radius: f32) {let t = Tokens::get();ui.painter().circle_stroke(at, radius, egui::Stroke::new(t.space_3, t.border));diff --git a/crates/ui-egui/src/ui_kit/color_tests.rs b/crates/ui-egui/src/ui_kit/color_tests.rsindex 07bb7f1e2d..ffc05c0f05 100644--- a/crates/ui-egui/src/ui_kit/color_tests.rs+++ b/crates/ui-egui/src/ui_kit/color_tests.rs@@ -337,3 +337,167 @@ fn rendered_square_hue_and_current_strip_leave_rounded_corner_pixels_clear() {}crate::theme::set_dark(previous);}++/// A taller frame than the shared one: the popover's recent row sits below 400 points.+fn tall_in(ctx: &egui::Context, events: Vec<egui::Event>, id: &str, rgb: &mut [u8; 3]) -> bool {+ let mut changed = false;+ scenario::clear_handles();+ let _ = crate::test_support::frame(+ ctx,+ egui::RawInput {+ screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(320.0, 600.0))),+ events,+ focused: true,+ ..Default::default()+ },+ |ui| {+ ui.set_width(280.0);+ ui.push_id(id, |ui| crate::ui_kit::scope(ui, |ui| changed |= color_popover(ui, rgb)));+ },+ );+ changed+}++fn tall(ctx: &egui::Context, events: Vec<egui::Event>, rgb: &mut [u8; 3]) -> bool {+ tall_in(ctx, events, "picker", rgb)+}++fn tall_click(ctx: &egui::Context, key: &str, rgb: &mut [u8; 3]) -> bool {+ let at = scenario::handle_at(key).unwrap_or_else(|| panic!("missing {key}"));+ tall(ctx, pointer(at, true), rgb) | tall(ctx, pointer(at, false), rgb)+}++fn tall_type(ctx: &egui::Context, field: &str, text: &str, rgb: &mut [u8; 3]) {+ tall_click(ctx, &format!("color:channel:{field}"), rgb);+ let modifiers = egui::Modifiers { command: true, ctrl: true, ..Default::default() };+ tall(+ ctx,+ vec![egui::Event::Key { key: egui::Key::A, physical_key: None, pressed: true, repeat: false, modifiers }, egui::Event::Text(text.into())],+ rgb,+ );+ tall(ctx, crate::ui_kit::test_support::key(egui::Key::Enter), rgb);+}++fn hsv_bytes(h: f32, s: f32, v: f32) -> [u8; 3] {+ let c = Color32::from(HsvaGamma { h, s, v, a: 1.0 });+ [c.r(), c.g(), c.b()]+}++#[test]+fn step_buttons_nudge_rgb_and_hsv_channels_by_one() {+ let ctx = crate::fonts::test_context();+ let mut rgb = [10, 20, 30];+ tall(&ctx, vec![], &mut rgb);+ assert!(tall_click(&ctx, "color:spin:R:up", &mut rgb));+ assert_eq!(rgb, [11, 20, 30]);+ assert!(tall_click(&ctx, "color:spin:B:down", &mut rgb));+ assert_eq!(rgb, [11, 20, 29]);+ // Limits hold: 0 does not step below 0.+ let mut rgb = [0, 0, 0];+ tall(&ctx, vec![], &mut rgb);+ tall_click(&ctx, "color:spin:G:down", &mut rgb);+ assert_eq!(rgb, [0, 0, 0]);+ // H steps one degree, V one percent, on the same gamma HSV as the square.+ let mut rgb = [255, 0, 0];+ tall(&ctx, vec![], &mut rgb);+ tall_click(&ctx, "color:spin:H:up", &mut rgb);+ assert_eq!(rgb, hsv_bytes(1.0 / 360.0, 1.0, 1.0));+ tall_click(&ctx, "color:spin:V:down", &mut rgb);+ assert_eq!(rgb, hsv_bytes(1.0 / 360.0, 1.0, 0.99));+}++#[test]+fn typed_hsv_values_set_the_colour_within_their_ranges() {+ let ctx = crate::fonts::test_context();+ let mut rgb = [255, 0, 0];+ tall(&ctx, vec![], &mut rgb);+ tall_type(&ctx, "H", "120", &mut rgb);+ tall_type(&ctx, "S", "50", &mut rgb);+ assert_eq!(rgb, hsv_bytes(1.0 / 3.0, 0.5, 1.0));+ // A hostile typed value is bounded by the field's range.+ tall_type(&ctx, "V", "1e300", &mut rgb);+ assert_eq!(rgb, hsv_bytes(1.0 / 3.0, 0.5, 1.0));+}++#[test]+fn finished_edits_join_one_recent_list_that_every_picker_offers() {+ let ctx = crate::fonts::test_context();+ let mut rgb = [10, 20, 30];+ tall(&ctx, vec![], &mut rgb);+ assert!(recent_colors(&ctx).is_empty(), "opening a picker records nothing");+ // A drag across the square records only its final colour, once released.+ let square = scenario::rect_of("color:sv").unwrap();+ let end = square.left_top() + vec2(10.0, 10.0);+ tall(&ctx, pointer(square.center(), true), &mut rgb);+ tall(&ctx, vec![egui::Event::PointerMoved(end)], &mut rgb);+ assert!(recent_colors(&ctx).is_empty(), "nothing is recorded mid-drag");+ tall(&ctx, pointer(end, false), &mut rgb);+ assert_eq!(recent_colors(&ctx), vec![rgb]);+ // Fine-tuning in the same opening replaces that entry instead of adding one per step.+ tall_click(&ctx, "color:spin:R:up", &mut rgb);+ tall_click(&ctx, "color:spin:R:up", &mut rgb);+ assert_eq!(recent_colors(&ctx), vec![rgb]);+ let tuned = rgb;+ // Closed (a pass without the popover) and opened again: the next edit is a new entry.+ crate::ui_kit::test_support::frame(&ctx, vec![], |_| {});+ tall(&ctx, vec![], &mut rgb);+ tall_click(&ctx, "color:spin:G:up", &mut rgb);+ assert_eq!(recent_colors(&ctx), vec![rgb, tuned]);+ let second = rgb;+ // Another picker (another colour field of the app) shows the same list and takes from it.+ let mut other = [200, 200, 200];+ tall_in(&ctx, vec![], "another_picker", &mut other);+ assert!(scenario::handle_at("color:recent:2").is_none(), "empty slots are not buttons");+ let slot = scenario::handle_at("color:recent:1").unwrap();+ tall_in(&ctx, pointer(slot, true), "another_picker", &mut other);+ assert!(tall_in(&ctx, pointer(slot, false), "another_picker", &mut other));+ assert_eq!(other, tuned);+ assert_eq!(recent_colors(&ctx), vec![tuned, second], "a picked recent colour moves to the front");+ // Tuning a colour taken from the list adds a new entry and keeps the one it started from.+ let up = scenario::handle_at("color:spin:B:up").unwrap();+ tall_in(&ctx, pointer(up, true), "another_picker", &mut other);+ tall_in(&ctx, pointer(up, false), "another_picker", &mut other);+ assert_eq!(recent_colors(&ctx), vec![other, tuned, second]);+}++#[test]+fn recent_list_is_capped_unique_and_synced_with_the_saved_one() {+ let ctx = crate::fonts::test_context();+ for i in 0..40u8 {+ remember_color(&ctx, [i, 0, 0], None);+ }+ remember_color(&ctx, [35, 0, 0], None);+ let recent = recent_colors(&ctx);+ assert_eq!(recent.len(), MAX_RECENT_COLORS);+ assert_eq!(recent.first(), Some(&[35, 0, 0]));+ assert_eq!(recent.iter().filter(|c| **c == [35, 0, 0]).count(), 1);+ // Picks flow to the saved list once…+ let mut saved = Vec::new();+ crate::recent_colors::share(&ctx, &mut saved);+ assert_eq!(saved, recent);+ // …and a list loaded from preferences (even an oversized one) is what the pickers show.+ let mut loaded: Vec<[u8; 3]> = (0..100u8).map(|i| [0, i, 0]).collect();+ crate::recent_colors::share(&ctx, &mut loaded);+ assert_eq!(loaded.len(), MAX_RECENT_COLORS);+ assert_eq!(recent_colors(&ctx), loaded);+}++#[test]+fn recent_colours_are_saved_with_the_preferences_and_hostile_entries_dropped() {+ use serde_json::json;+ let mut app = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());+ let mut list = vec![json!([1, 2, 3]), json!([300, 0, 0]), json!("red"), json!([1, 2]), json!(null)];+ list.extend((0..50).map(|i| json!([i, i, i])));+ app.load_prefs(&json!({ "recent_colors": list }).to_string());+ assert_eq!(app.ui.recent_colors.len(), MAX_RECENT_COLORS);+ assert_eq!(app.ui.recent_colors.first(), Some(&[1, 2, 3]));+ let ctx = crate::fonts::test_context();+ crate::recent_colors::share(&ctx, &mut app.ui.recent_colors);+ remember_color(&ctx, [9, 8, 7], None);+ crate::recent_colors::share(&ctx, &mut app.ui.recent_colors);+ let mut restored = crate::SolveApp::new(solidcraft_engine::Session::default(), Default::default());+ restored.load_prefs(&app.prefs());+ assert_eq!(restored.ui.recent_colors.first(), Some(&[9, 8, 7]));+ assert_eq!(restored.ui.recent_colors.get(1), Some(&[1, 2, 3]));+ assert_eq!(restored.ui.recent_colors.len(), MAX_RECENT_COLORS);+}