SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Table-driven layout/paint references in both themes. No window or GPU required.
use super::preferences_figures::{ThemeSample, paint_theme_thumbnail};
use super::*;
use crate::ui_kit::{Container, Surface};
use crate::{scenario, theme::Tokens};
use egui::{Ui, vec2};
use solidcraft_engine::kernel::Continuity;
struct Sample {
value: String,
second: String,
selected: usize,
checked: bool,
}
struct Element {
name: &'static str,
rect: &'static str,
handle: Option<&'static str>,
draw: fn(&mut Ui, &mut Sample),
}
macro_rules! element {
($name:literal, $rect:literal, $handle:expr, $draw:expr) => {
Element { name: $name, rect: $rect, handle: $handle, draw: $draw }
};
($name:literal, $draw:expr) => {
element!($name, "gallery:allocation", None, $draw)
};
}
fn navigation_sample(ui: &mut Ui, size: crate::navigation_bar::Size) {
let metrics = NavigationMetrics::for_size(size);
let inset = NAV_PADDING + NAV_BORDER;
let menu_width = metrics.icon + NAV_MENU_LEFT + NAV_MENU_RIGHT + NAV_MENU_GAP + NAV_CHEVRON;
let (rect, _) =
ui.allocate_exact_size(vec2(2.0 * metrics.button + menu_width + 2.0 * NAV_GAP + 2.0 * inset, metrics.height()), egui::Sense::hover());
navigation_surface(ui, rect, size, true);
let mut x = rect.left() + inset;
for (id, icon, kind, selected, width) in [
("pan", "pan", crate::navigation_bar::Kind::Tool, true, metrics.button),
("fit", "fit", crate::navigation_bar::Kind::Action, false, metrics.button),
("visual_style", "style_shaded_edges", crate::navigation_bar::Kind::Menu, false, menu_width),
] {
let bounds = egui::Rect::from_min_size(egui::pos2(x, rect.top() + inset), vec2(width, metrics.button));
navigation_button(
ui,
bounds,
NavigationButton { id, icon, label: id, kind, selected, labels: false, menu: kind == crate::navigation_bar::Kind::Menu },
);
if id == "fit" {
navigation_edit_outline(ui, bounds, true, false);
}
x += width + NAV_GAP;
}
}
// One entry per element/variant: names, rendering and geometry expectations stay together.
const ELEMENTS: &[Element] = &[
element!("theme_mode_segments", |ui, _| {
theme_segments(
ui,
"gallery_mode",
&[ThemeSegment::new("One theme", ThemeGlyph::Monitor, None), ThemeSegment::new("Follow system", ThemeGlyph::Contrast, None)],
Some(1),
false,
);
}),
element!("theme_imported_filter", |ui, _| {
theme_segments(ui, "gallery_imported", &[ThemeSegment::new("Imported", ThemeGlyph::None, Some(2))], Some(0), false);
}),
element!("theme_toolbar", |ui, _| {
theme_toolbar(
ui,
"gallery_toolbar",
68.0,
0.0,
|ui| {
theme_segments(
ui,
"gallery_tone",
&[ThemeSegment::new("Light", ThemeGlyph::Sun, Some(9)), ThemeSegment::new("Dark", ThemeGlyph::Moon, Some(17))],
Some(0),
false,
);
},
|ui| {
theme_segments(
ui,
"gallery_view",
&[ThemeSegment::new("Carousel", ThemeGlyph::Carousel, None), ThemeSegment::new("Grid", ThemeGlyph::Grid, None)],
Some(0),
true,
);
},
);
}),
element!("theme_browser_grid", |ui, _| {
theme_browser(ui, "gallery_grid", 14, true, None, |ui, _, width| {
theme_card(
ui,
&ThemeCard {
name: "Light",
note: "Built in",
options: None,
sample: ThemeSample::from_tokens(&Tokens::light()),
selected: false,
dark: false,
high: false,
day: false,
night: false,
},
width,
);
});
}),
element!("theme_segments", |ui, _| {
theme_segments(
ui,
"gallery",
&[ThemeSegment::new("Light", ThemeGlyph::Sun, Some(10)), ThemeSegment::new("Dark", ThemeGlyph::Moon, Some(17))],
Some(0),
false,
);
}),
element!("theme_import_button", |ui, _| {
theme_import_button(ui, "Import theme file…");
}),
element!("theme_slot", |ui, _| {
theme_slot(
ui,
&ThemeSlot {
title: "Day theme",
name: "Light",
hint: "Pick from below",
aimed: true,
night: false,
width: ui.available_width(),
sample: ThemeSample::from_tokens(&Tokens::light()),
},
);
}),
element!("theme_card", |ui, _| {
theme_card(
ui,
&ThemeCard {
name: "Dark",
note: "Built in · High contrast",
options: Some("Has options"),
sample: ThemeSample::from_tokens(&Tokens::dark()),
selected: true,
dark: true,
high: true,
day: true,
night: true,
},
118.0,
);
}),
element!("theme_empty", |ui, _| {
theme_empty(ui, "No theme matches these filters.", "Clear filters", || {});
}),
element!("theme_browser", |ui, _| {
theme_browser(ui, "gallery_browser", 9, false, None, |ui, i, width| {
theme_card(
ui,
&ThemeCard {
name: if i % 2 == 0 { "Light" } else { "Dark" },
note: "Built in",
options: None,
sample: ThemeSample::from_tokens(&Tokens::get()),
selected: i == 0,
dark: i % 2 != 0,
high: false,
day: false,
night: false,
},
width,
);
});
}),
element!("viewport_status_item", "viewport_status:sample:item", Some("viewport_status:sample:close"), |ui, _| {
let item = StatusItem {
id: "sample".into(),
kind: StatusKind::Mode,
name: "Draft".into(),
setting: "Z · 1°".into(),
has_key: true,
editable: false,
};
viewport_status_item(ui, &item, &mut StatusPresentation::default());
}),
element!("sphere_thumbnail", |ui, _| {
ui.horizontal(|ui| {
for kind in [FinishKind::Matte, FinishKind::Satin, FinishKind::Gloss, FinishKind::Metal, FinishKind::Glass] {
sphere_thumbnail(
ui,
&format!("gallery:sphere:{kind:?}"),
Sphere { color: Tokens::get().render_accent, kind, opacity: None },
Tokens::get().space_24 * 2.0,
);
}
});
}),
element!("look_chain", "gallery:chain", Some("gallery:chain:body"), |ui, _| {
let t = Tokens::get();
look_chain(
ui,
"gallery:chain",
["Face", "Body", "Component", "Material"],
[
None,
Some(Sphere { color: t.render_accent, kind: FinishKind::Satin, opacity: None }),
None,
Some(Sphere { color: t.control_border, kind: FinishKind::Metal, opacity: None }),
],
LookStep::Body,
);
}),
element!("look_chain_empty", |ui, _| {
look_chain(ui, "gallery:empty-chain", ["Face", "Body", "Component", "Material"], [None; 4], LookStep::Face);
}),
element!("navigation_regular", |ui, _| navigation_sample(ui, crate::navigation_bar::Size::Regular)),
element!("navigation_compact", |ui, _| navigation_sample(ui, crate::navigation_bar::Size::Compact)),
element!("navigation_popup", |ui, _| {
navigation_menu(ui, NAV_POPUP_WIDTH, |ui| {
navigation_menu_heading(ui, "Visual style");
let mut row = NavigationMenuRow::new("shaded", "Shaded", "style_shaded");
row.selected = true;
row.show(ui);
navigation_menu_separator(ui);
NavigationMenuRow::new("fit", "Fit", "fit").show(ui);
let mut later = NavigationMenuRow::new("translucent", "Translucent", "style_translucent");
later.enabled = false;
later.detail = Some("Later");
later.show(ui);
});
}),
element!("navigation_settings", |ui, state| {
settings_section(ui, "gallery_navigation", "Navigation bar", |ui| {
text(ui, "Choose the controls on the bar at the bottom of the 3D view.", Text::Hint("gallery_navigation"));
let width = ui.available_width();
navigation_stage(ui, width);
settings_card(ui, |ui| {
text(ui, "Fit", Text::NameCell(true));
text(ui, "Action · Runs once and never stays lit.", Text::Hint("gallery_navigation_action"));
});
navigation_tile(ui, "grid", "Grid", "style", false);
row(ui, "Position", |ui| {
segmented(ui, &mut state.selected, &["Left", "Center", "Right"], Default::default());
});
checkbox(ui, "Show navigation bar", &mut state.checked);
button(ui, "Reset to default", Button::Normal);
});
}),
element!("linear_color_field", |ui, _| {
row(ui, "Zenith", |ui| linear_color_field(ui, &mut [0.5, 0.64, 0.81], 1e6));
}),
element!("section_method", |ui, _| {
section_method(ui, "gallery_method", "Atmosphere", true, "GPU", |ui| {
text(ui, "Participating medium", Text::Inline);
});
}),
element!("segments_availability", |ui, state| {
segmented(
ui,
&mut state.selected,
&["World", "Colour", "Gradient", "Clear"],
Segments { enabled: &[false, true, false, true], compact: true, ..Default::default() },
);
}),
element!("read_only_text", |ui, _| {
read_only_text(ui, "{\n \"samples\": 256\n}");
}),
element!("method_section_sampling", |ui, state| {
method_section(ui, "gallery_method", "Path tracing", "GPU", Some("Needs GPU path tracing"), |ui| {
checkbox(ui, "Reduce noise", &mut state.checked);
});
}),
element!("icon_action", |ui, _| {
icon_action(ui, "Duplicate", "copy", true, false);
icon_action(ui, "Remove", "delete", true, true);
}),
element!("aspect_grid", |ui, _| {
aspect_grid(
ui,
&[
AspectTile { id: "gallery:aspect:wide", label: "16:9", aspect: 16.0 / 9.0, selected: true },
AspectTile { id: "gallery:aspect:square", label: "1:1", aspect: 1.0, selected: false },
AspectTile { id: "gallery:aspect:tall", label: "9:16", aspect: 9.0 / 16.0, selected: false },
],
);
}),
element!("frame_guides", |ui, _| {
let (viewport, _) = ui.allocate_exact_size(vec2(200.0, 150.0), egui::Sense::hover());
frame_guides(ui, viewport, viewport.shrink(20.0), FrameGuides { thirds: true, safe_area: true, centre_mark: true });
}),
element!("comparison_divider", |ui, _| {
let (rect, _) = ui.allocate_exact_size(vec2(220.0, 100.0), egui::Sense::hover());
let mut position = 0.5;
comparison_divider(ui, rect, &mut position, "Comparison divider");
}),
element!("comparison_badge", |ui, _| {
let (rect, _) = ui.allocate_exact_size(vec2(220.0, 100.0), egui::Sense::hover());
comparison_badge(ui, rect, "Live preview", false);
}),
element!("tree_row_rect", |ui, _| {
for (index, row) in [
Row { label: "Objects", ..Default::default() },
Row { label: "Output", subtitle: "1920 × 1080 · PNG", ..Default::default() },
Row { compact: true, label: "Environment", subtitle: "Studio Soft 2K", ..Default::default() },
]
.iter()
.enumerate()
{
let rect = tree_row_rect(ui, row);
assert_eq!(tree_row(ui, ui.scope_id().with(("tree_geometry", index)), row).rect, Some(rect));
}
}),
element!("editor_section", |ui, _| {
editor_section(ui, "edit", "Edit", true, |ui| {
text(ui, "Colour", Text::Inline);
});
}),
element!("method_section", |ui, _| {
method_section(ui, "gpu_section", "Glass and absorption", "GPU", Some("Needs GPU path tracing"), |ui| {
checkbox(ui, "Use physical glass", &mut false);
});
}),
element!("vector3_field", |ui, _| {
row(ui, "Origin", |ui| vector3_field(ui, &mut [0.0; 3], -1e6..=1e6, " mm"));
}),
element!("pending_section", |ui, _| {
pending_section(ui, "upcoming", "Textures", "Soon");
}),
element!("inspector_header", |ui, _| {
inspector_header(ui, "body", "Boss", "Body");
}),
element!("workspace_chip", |ui, _| {
workspace_chip(ui, "Body");
}),
element!("section_heading", |ui, _| {
section_heading(ui, "Edit");
}),
element!("checkbox_at", |ui, sample| {
let side = Tokens::get().space_16;
let (rect, _) = ui.allocate_exact_size(vec2(side, side), egui::Sense::hover());
checkbox_at(ui, rect, "Enabled", &mut sample.checked);
}),
element!("settings_plugin_card", |ui, sample| {
settings_plugin_card(ui, "sample", "Gear generator", "1.2.0", "Adds a parametric gear feature.", &mut sample.checked);
}),
element!("text_button", |ui, _| {
text_button(ui, "Reset", true);
}),
element!("mixed_slider", |ui, _| {
mixed_slider(ui, &mut 0.5, 0.0..=1.0, None);
}),
element!("searchable_icon_dropdown", |ui, _| {
searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]);
}),
element!("number_pair", |ui, _| {
let (mut w, mut h) = (1920, 1080);
number_pair(ui, "Size", [&mut w, &mut h], 1..=16384, 1.0, "");
}),
element!("progress_action", |ui, _| {
progress_action(ui, "gallery:progress", "Rendering", "· 62%", 0.62, "Cancel");
}),
element!("settings_choice_row", |ui, _| {
settings_choice_row(
ui,
&SettingsChoice { icon: None, key: "gallery:radio_row", title: "Preview", summary: "1280 × 720", detail: "Preview size" },
true,
);
}),
element!("icon_label_action", |ui, _| {
icon_label_action(ui, "Render Image", Some("play"), true, true);
}),
element!("completion_text", |ui, _| {
completion_text(ui, "Render 1 · 1920 × 1080", true);
completion_text(ui, "No completed image", false);
}),
element!("tree_row", |ui, _| {
let actions = [TreeAction { icon: "plus", hover_only: false, label: "Add", reason: None, target: "gallery:tree:add" }];
tree_row(ui, ui.scope_id().with("tree_plain"), &Row { label: "Objects", fold: Some(true), actions: &actions, ..Default::default() });
tree_row(
ui,
ui.scope_id().with("tree_subtitle"),
&Row { label: "Output", subtitle: "1920 × 1080 · PNG", selected: true, ..Default::default() },
);
}),
element!("tree_header", |ui, state| {
tree_header(ui, "Scene", &mut state.selected, &["By object", "By look"], "Search objects");
tree_row(
ui,
ui.scope_id().with("compact_environment"),
&Row { compact: true, label: "Environment", icon: "environment_map", subtitle: "Studio Soft 2K", ..Default::default() },
);
tree_row(
ui,
ui.scope_id().with("compact_object"),
&Row {
compact: true,
depth: 1,
label: "Boss",
swatch: Some(Tokens::get().accent),
eye: Some(true),
secondary: "Anodized Blue",
selected: true,
..Default::default()
},
);
}),
element!("tree_row_disabled_actions", |ui, _| {
let actions =
[TreeAction { icon: "lookat", hover_only: true, label: "Solo", reason: Some("Not available yet"), target: "gallery:tree:solo" }];
tree_row(ui, ui.scope_id().with("tree_actions"), &Row { label: "Light", actions: &actions, ..Default::default() });
}),
element!("selection_actions", |ui, _| {
let actions = [
StageAction { icon: Some("chain"), label: "Appearance Chain", enabled: true, primary: false, reason: None },
StageAction { icon: Some("reorder"), label: "Replace All", enabled: true, primary: false, reason: None },
StageAction { icon: Some("star"), label: "Favorite Look", enabled: true, primary: true, reason: None },
StageAction { icon: Some("suppress"), label: "Hide", enabled: true, primary: false, reason: None },
];
selection_actions(ui, "Boss", &actions);
}),
element!("catalog_scope", |ui, state| {
catalog_scope(ui, |ui| {
search_field(ui, ui.scope_id().with("catalog_search"), &mut state.value, "Search appearances");
segmented(
ui,
&mut state.selected,
&["In Design", "Library", "Recent", "★"],
Segments { compact: true, proportional: true, workspace_accent: true, ..Default::default() },
);
ui.horizontal(|ui| {
choice_chip(ui, "catalog_all", "All", true);
choice_chip(ui, "catalog_metal", "Metal", false);
});
catalog_footer(ui, "Click to apply · drag onto the model");
});
}),
element!("catalog_footer", |ui, _| {
catalog_footer(ui, "Click to apply · drag onto the model");
}),
element!("sphere_preview", |ui, _| {
sphere_preview(
ui,
"gallery:preview",
Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None },
"Satin",
["Library", "Used by 2"],
|ui| searchable_icon_dropdown(ui, "spin", "Replace…", &mut String::new(), &[]),
);
}),
element!("sphere_preview_with_source", |ui, _| {
sphere_preview_with_source(
ui,
"gallery:preview-source",
Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None },
"Satin",
"Used by 2",
|ui| {
compact_dropdown_menu(ui, "gallery:source", "In Design", |ui| {
text(ui, "Body look", Text::Inline);
})
},
|ui| text_button(ui, "Replace…", true),
);
}),
element!("mixed_scalar_field", |ui, _| {
let mut value = 0.5;
mixed_scalar_field(ui, &mut value, 0.0..=1.0, Some("Mixed"));
}),
element!("check_line", |ui, _s| {
check_line(ui, "gallery:check_ok", "Ready", false);
}),
element!("check_line_warning", |ui, _s| {
check_line(ui, "gallery:check_warning", "Transparency approximation", true);
}),
element!("check_line_error", |ui, _s| {
check_status_line(ui, "gallery:check_error", "Image size exceeds the renderer limit", CheckStatus::Error);
}),
element!("check_status_line", |ui, _| {
check_status_line(ui, "gallery:status_ok", "Ready", CheckStatus::Ok);
check_status_line(ui, "gallery:status_warning", "Transparency approximation", CheckStatus::Warning);
check_status_line(ui, "gallery:status_error", "Image size exceeds the renderer limit", CheckStatus::Error);
}),
element!("segmented_unavailable", |ui, s| {
segmented(
ui,
&mut s.selected,
&["Draft", "Custom"],
Segments { disabled_reasons: &[Some("waiting for the quality contract"), None], ..Default::default() },
);
}),
element!("review_and_apply", |ui, state| {
ReviewAndApply {
title: "Review native studio",
name: "Soft enveloping studio",
subtitle: "Native studio · whole scene",
replaces: "Lighting, environment, exposure and stage",
kept: "Camera, sampling, dimensions, optical bindings and geometry",
acknowledgement: "Confirm replacing saved state",
apply: "Apply studio",
copy: false,
notice: None,
}
.content(ui, &mut state.checked, |_| {});
}),
element!("catalog_footer_height", |ui, _| {
let expected = catalog_footer_height(ui);
catalog_footer(ui, "Click to apply to the selection.");
assert_eq!(crate::scenario::rect_of("catalog:footer").unwrap().height(), expected);
}),
element!("catalog_footer_with_tip", |ui, _| {
catalog_footer_with_tip(ui, "Click to apply to the selection.", "Paint and drag assignment are not supported yet.");
}),
element!("catalog_layout", |ui, _| {
ui.allocate_ui(egui::vec2(ui.available_width(), 300.0), |ui| {
let layout = CatalogLayout::new(ui, "gallery:catalog", 3);
layout.body(ui, |ui| {
for index in 0..12 {
MenuItem::new("catalog_item", &format!("Surface {index}"), "grid").search_row(ui, "", "Authored map", None);
}
});
layout.footer(ui, |ui| {
catalog_footer(ui, "Select a surface to review.");
});
});
}),
element!("sphere_grid", |ui, _| {
let sphere = Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None };
let tiles = ["gallery:grid:a", "gallery:grid:b", "gallery:grid:c"].map(|id| SphereTile {
id,
name: "Satin",
sphere,
selected: id.ends_with('b'),
users: 1,
tip: "Satin",
badge: None,
});
sphere_grid(ui, &tiles);
}),
element!("sphere_grid_drag", |ui, _| {
let tiles = [SphereTile {
id: "gallery:drag-grid",
name: "Copper",
sphere: Sphere { color: Tokens::get().render_accent, kind: FinishKind::Metal, opacity: None },
selected: true,
users: 1,
tip: "Drag to apply",
badge: None,
}];
sphere_grid_drag(ui, &tiles);
}),
element!("sphere_cursor", |ui, _| {
let sphere = Sphere { color: Tokens::get().render_accent, kind: FinishKind::Satin, opacity: None };
sphere_thumbnail(ui, "gallery:cursor-sample", sphere, Tokens::get().control_height);
sphere_cursor(ui, sphere);
}),
element!("note_height", |ui, _| {
let label = "A wrapped note reserves its measured height in a bounded card.";
let _height = note_height(ui, label);
text(ui, label, Text::Note("gallery:measured-note"));
}),
element!("sphere_tile", "gallery:tile", Some("gallery:tile"), |ui, _| {
SphereTile {
id: "gallery:tile",
name: "Satin metal",
sphere: Sphere { color: Tokens::get().render_accent, kind: FinishKind::Metal, opacity: None },
selected: true,
users: 3,
tip: "Satin metal",
badge: Some("Library"),
}
.show(ui);
}),
element!("strip_toggle", |ui, _| {
ui.horizontal(|ui| {
strip_toggle(ui, true, "Hide Shots strip");
strip_toggle(ui, false, "Shots");
});
}),
element!("strip_heading", |ui, _| {
StripHeading::new(ui.painter(), "History").show(ui);
}),
element!("choice_chip_selected", |ui, _| {
choice_chip(ui, "saved", "Hero", true);
}),
element!("add_choice", |ui, _| {
add_choice(ui, "Save Shot");
}),
element!("compact_dropdown_menu", |ui, _| {
compact_dropdown_menu(ui, "gallery_strip_size", "1920 × 1080", |ui| {
list_picker(ui, "full_hd", "Full HD", true);
});
}),
element!("thumbnail_choice", |ui, _| {
ui.horizontal(|ui| {
thumbnail_choice(ui, "hero", "Hero", ThumbnailChoice { selected: true, modified: true, ..Default::default() });
thumbnail_choice(ui, "front", "Front", ThumbnailChoice { progress: Some(0.6), ..Default::default() });
add_choice(ui, "Save Shot");
});
}),
element!("settings_form", |ui, state| {
settings_form(ui, Tokens::get().form_label_width, |ui| {
row(ui, "Sample", |ui| {
field(ui, &mut state.value);
});
});
}),
element!("below_row_control", |ui, state| {
settings_form(ui, Tokens::get().form_label_width, |ui| {
row(ui, "Autosave every", |ui| {
field(ui, &mut state.value);
});
below_row_control(ui, "Autosave every", 260.0, |ui| settings_autosave_timeline(ui, 5.0));
});
}),
element!("named_control", "dialog:widget:Profile name", Some("dialog:Profile name"), |ui, state| {
named_control(ui, "Profile name", |ui| {
text_field(ui, &mut state.value, "Name this setup");
});
}),
element!("settings_row_card", |ui, _| {
let t = Tokens::get();
for selected in [true, false] {
settings_row_card(ui, selected, t.control_height + t.space_14, |ui| {
text(ui, "Default", if selected { Text::SelectedNameCell } else { Text::NameCell(false) });
if selected {
settings_badge(ui, "Active", false);
} else {
button(ui, "Apply", Button::Normal);
}
});
ui.add_space(t.space_8);
}
}),
element!("settings_composition", |ui, _| {
settings_heading(ui, "Interface", "Appearance and workspace");
settings_section(ui, "gallery_settings", "Layout", |ui| {
settings_pair(
ui,
|ui| {
text(ui, "Controls", Text::Inline);
},
|ui, ()| layout_preview(ui, LayoutPreview { compact: true, labels: false, history: 2, translucent: false, dialog_left: true }),
)
});
}),
element!("settings_picture_choices", |ui, state| {
let choices = [
PictureChoice { key: "bottom", label: "Bottom", figure: super::preferences_figure_data::paint_history_bottom },
PictureChoice { key: "left", label: "Left", figure: super::preferences_figure_data::paint_history_left },
];
if let Some(selected) = settings_picture_choices(ui, "gallery_history", "History", &choices, state.selected % choices.len(), true) {
state.selected = selected;
}
settings_picture_choices(ui, "gallery_history_disabled", "Disabled history", &choices, 0, false);
}),
element!("settings_picture_choices_sized", |ui, state| {
let choices = [
PictureChoice { key: "origin", label: "Origin", figure: super::preferences_figure_data::paint_orbit_origin },
PictureChoice { key: "centre", label: "View center", figure: super::preferences_figure_data::paint_orbit_centre },
];
let t = Tokens::get();
if let Some(selected) = settings_picture_choices_sized(
ui,
"gallery_pivots",
"Orbit around",
&choices,
state.selected % choices.len(),
true,
PictureChoiceSize { width: t.space_24 * 8.0 + t.space_4, aspect: 184.0 / 99.5, caption: false },
) {
state.selected = selected;
}
}),
element!("settings_permission_choices", |ui, state| {
settings_choices(
ui,
&[
SettingsChoice {
icon: None,
key: "gallery:ask",
title: "Ask first",
summary: "Confirm changes before they run.",
detail: "Full permission details",
},
SettingsChoice {
icon: None,
key: "gallery:edits",
title: "Allow edits",
summary: "Ask before running other tools.",
detail: "Full permission details",
},
SettingsChoice {
icon: Some("warning"),
key: "gallery:all",
title: "Allow all",
summary: "Run supported tools without asking.",
detail: "Full permission details",
},
],
&mut state.selected,
);
settings_pointer_preview(ui, true, "Normal", true);
}),
element!("picture_card", |ui, _| {
use super::preferences_figure_data as figures;
let gap = ui.spacing().item_spacing.x;
let width = card_width(ui.available_width(), 4, gap);
ui.horizontal(|ui| {
picture_card(
ui,
&Card {
label: "Coarse",
sub: Some("fastest"),
selected: false,
enabled: true,
options: None,
check: false,
aspect: 120.0 / 64.0,
figure: &figures::paint_tess_coarse,
},
width,
);
picture_card(
ui,
&Card {
label: "Normal",
sub: Some("default"),
selected: true,
enabled: true,
options: None,
check: true,
aspect: 120.0 / 64.0,
figure: &figures::paint_tess_normal,
},
width,
);
picture_card(
ui,
&Card {
label: "Fine",
sub: Some("smoother"),
selected: false,
enabled: true,
options: Some("Has options"),
check: false,
aspect: 120.0 / 64.0,
figure: &figures::paint_tess_fine,
},
width,
);
picture_card(
ui,
&Card {
label: "8×",
sub: Some("not on this GPU"),
selected: false,
enabled: false,
options: None,
check: false,
aspect: 120.0 / 64.0,
figure: &figures::paint_aa_8x,
},
width,
);
});
}),
element!("toggle_tile", |ui, _| {
use super::preferences_figure_data as figures;
let gap = ui.spacing().item_spacing.x;
let width = card_width(ui.available_width(), 3, gap);
ui.horizontal(|ui| {
toggle_tile(
ui,
&Card {
label: "Grid",
sub: None,
selected: true,
enabled: true,
options: None,
check: false,
aspect: 120.0 / 64.0,
figure: &figures::paint_view_grid,
},
width,
);
toggle_tile(
ui,
&Card {
label: "Ground shadow",
sub: None,
selected: false,
enabled: true,
options: None,
check: false,
aspect: 120.0 / 64.0,
figure: &figures::paint_view_shadow,
},
width,
);
toggle_tile(
ui,
&Card {
label: "Perspective",
sub: None,
selected: false,
enabled: false,
options: None,
check: false,
aspect: 120.0 / 64.0,
figure: &figures::paint_view_perspective,
},
width,
);
});
}),
element!("preset_card", |ui, _| {
let icon = |p: &egui::Painter, r: egui::Rect, ink: egui::Color32| crate::icons::paint_ink(p, r, "settings", ink);
let width = ui.available_width();
for (name, word, selected, enabled) in
[("Performance", "Fastest", false, true), ("Quality", "Sharpest", true, true), ("Custom", "Your own mix", false, false)]
{
preset_card(ui, name, word, selected, enabled, &icon, width);
}
}),
element!("help_icon", |ui, _| {
ui.horizontal(|ui| {
text(ui, "Anti-aliasing", Text::Hint("gallery_help"));
help_icon(ui, "Applies when SolidCraft restarts.");
});
}),
element!("preference_theme_thumbnails", |ui, _| {
let (light, dark) = (ThemeSample::from_tokens(&Tokens::light()), ThemeSample::from_tokens(&Tokens::dark()));
ui.horizontal(|ui| {
for kind in 0..2 {
let (rect, _) = ui.allocate_exact_size(vec2(88.0, 88.0 * 76.0 / 124.0), egui::Sense::hover());
match kind {
0 => paint_theme_thumbnail(ui.painter(), rect, &light),
1 => paint_theme_thumbnail(ui.painter(), rect, &dark),
_ => {}
}
}
});
}),
element!("preference_figures", |ui, _| {
ui.horizontal_wrapped(|ui| {
for (name, size, paint) in super::preferences_figure_data::FIGURES {
let width = 96.0;
let (rect, response) = ui.allocate_exact_size(vec2(width, width * size[1] / size[0]), egui::Sense::hover());
paint(ui.painter(), rect);
response.backing_on_hover_text(*name);
}
});
}),
element!("preference_option_cards", |ui, _| {
ui.horizontal_wrapped(|ui| {
for figure in [PreferenceFigure::Pivot(2), PreferenceFigure::UpAxis(true)] {
option_card(ui, "Choice", Some("Example"), true, true, figure);
}
let t = Tokens::get();
let width = t.space_24 * 5.0 + t.space_10;
for (label, figure) in [("Fine", paint_tess_fine as fn(&egui::Painter, egui::Rect)), ("8×", paint_aa_8x)] {
picture_card(
ui,
&Card { label, sub: None, selected: true, enabled: true, options: None, check: true, aspect: 120.0 / 64.0, figure: &figure },
width,
);
}
toggle_tile(
ui,
&Card {
label: "Ambient occlusion",
sub: None,
selected: true,
enabled: true,
options: None,
check: false,
aspect: 120.0 / 64.0,
figure: &paint_ao_on,
},
width,
);
});
}),
element!("settings_font_row", |ui, sample| {
settings_page(ui, |ui| {
settings_font_row(ui, "Font", |ui, part| {
if part == 0 {
named_control(ui, "Interface font", |ui| {
dropdown(ui, "gallery_preferences_font", &mut sample.selected, &["IBM Plex Sans (built in)", "Custom font"]);
});
} else {
button(ui, "Choose font file…", Button::Normal);
button(ui, "Reset", Button::Ghost);
}
});
font_specimen(ui, "The quick brown fox · 0123456789");
});
}),
element!("preference_specimens", |ui, _| {
scale_specimen(ui, 1.1);
status_palette_sample(ui, crate::theme::ColorVision::Deutan);
colour_vision_sample(ui, &Tokens::get());
settings_autosave_timeline(ui, 5.0);
settings_axis_row(ui, "Push X", 0.6, [0.1, 0.2], |_| {}, |_| {}, |_| {});
settings_mouse_mapping(ui, &[(vec!["Shift".into(), "Middle drag".into()], "Orbit".into())], |_| {});
}),
element!("assistant_entry", |ui, _| {
let t = Tokens::get();
crate::ui_kit::Container::show_backing(ui, egui::Frame::NONE.fill(t.app_bar), |ui| {
ui.horizontal(|ui| {
for state in [
AssistantEntryState::Quiet,
AssistantEntryState::Ready,
AssistantEntryState::Busy,
AssistantEntryState::NeedsAuth,
AssistantEntryState::Stopped,
AssistantEntryState::Waiting(3),
] {
let (_, response) = ui.allocate_exact_size(vec2(t.space_24 + t.space_8, t.space_24 + t.space_8), egui::Sense::click());
assistant_entry(ui, &response, state, false, false);
}
});
});
}),
element!("assistant_header", |ui, _| {
assistant_header(ui, |ui| {
ui.horizontal(|ui| {
ui.label("Assistant");
assistant_badge(ui, "Ready", AssistantTone::Success);
});
});
}),
element!("assistant_controls", |ui, _| {
assistant_controls(ui, |ui| {
button(ui, "Connect", Button::Normal);
});
}),
element!("assistant_badge", |ui, _| {
ui.horizontal(|ui| {
for (label, tone) in [
("Ready", AssistantTone::Success),
("Working", AssistantTone::Working),
("Waiting", AssistantTone::Warning),
("Error", AssistantTone::Error),
("Offline", AssistantTone::Neutral),
] {
assistant_badge(ui, label, tone);
}
});
}),
element!("assistant_bubble", |ui, _| {
assistant_bubble(ui, |ui| {
ui.label("Set the plate thickness to 8 mm.");
});
}),
element!("assistant_prose", |ui, _| {
assistant_prose(ui, |ui| {
ui.label("The thickness is now 8 mm. The design rebuilt successfully.");
});
}),
element!("assistant_tool_status", |ui, _| {
ui.horizontal(|ui| {
for state in [AssistantToolState::Pending, AssistantToolState::Running, AssistantToolState::Done, AssistantToolState::Failed] {
assistant_tool_status(ui, state);
}
});
}),
element!("assistant_tool", |ui, _| {
assistant_tool_frame(ui, false, |ui| {
ui.monospace("parameters.set");
assistant_tool_detail(ui, |ui| {
ui.monospace("thickness = 8 mm");
});
});
}),
element!("assistant_tool_failed", |ui, _| {
assistant_tool_frame(ui, false, |ui| {
assistant_tool_row(ui, true, |ui| {
ui.monospace("solid.fillet");
});
});
}),
element!("assistant_approval", |ui, _| {
assistant_approval(ui, "Allow the Assistant to run this?", |ui| {
ui.label("Change the design parameter.");
assistant_actions(ui, |ui| {
primary_button(ui, "Allow once");
button(ui, "Always allow", Button::Normal);
button(ui, "Deny", Button::Normal);
});
});
}),
element!("assistant_composer", |ui, s| {
assistant_composer_footer(ui, |ui| {
assistant_composer(ui, false, |ui| {
assistant_input(ui, ui.scope_id().with("assistant_gallery"), &mut s.value, "Ask for a change…");
});
});
}),
element!("assistant_composer_focused", |ui, _| {
assistant_composer(ui, true, |ui| {
ui.label("Ask for a change…");
});
}),
element!("assistant_send", |ui, _| {
ui.horizontal(|ui| {
assistant_send(ui, true, false, "Send");
assistant_send(ui, true, true, "Stop");
assistant_send(ui, false, false, "Send");
});
}),
element!("assistant_empty", |ui, _| {
assistant_empty(ui, "Set up an assistant", "Choose an installed agent in Preferences.", |ui| {
button(ui, "Open Preferences", Button::Normal);
});
}),
element!("assistant_banner", |ui, _| {
assistant_banner(ui, AssistantTone::Warning, |ui| {
ui.label("Paused after the configured step limit.");
});
}),
element!("settings_tab_chip", |ui, _| {
ui.horizontal_wrapped(|ui| {
settings_tab_chip(ui, "MODEL", "Model", crate::workspace::tab_icon("MODEL"), true);
settings_tab_chip(ui, "SURFACE", "Surface", crate::workspace::tab_icon("SURFACE"), false);
});
}),
element!("history_transport", |ui, _| {
ui.horizontal(|ui| {
let side = Tokens::get().space_24;
for control in HistoryTransport::ALL {
let (rect, _) = ui.allocate_exact_size(vec2(side, side), egui::Sense::hover());
control.show(ui, rect, false);
}
});
}),
element!("history_marker", |ui, _| {
let t = Tokens::get();
let accent = crate::theme::TabAccent::for_tab(&t, "SURFACE");
ui.horizontal(|ui| {
let (rect, _) = ui.allocate_exact_size(vec2(t.space_24 * 7.0, t.space_12), egui::Sense::hover());
ui.painter().rect_filled(rect, 0.0, t.panel);
history_marker(ui.painter(), rect, true, accent);
let (rect, _) = ui.allocate_exact_size(vec2(t.space_12, t.control_height), egui::Sense::hover());
ui.painter().rect_filled(rect, 0.0, t.timeline);
history_marker(ui.painter(), rect, false, accent);
});
}),
element!("history_seam_rest", |ui, _| history_seam_example(ui, HistoryHandleState::Rest)),
element!("history_seam_hover", |ui, _| history_seam_example(ui, HistoryHandleState::Hover)),
element!("history_seam_drag", |ui, _| history_seam_example(ui, HistoryHandleState::Drag)),
element!("history_icons", |ui, _| history_example(ui, false)),
element!("history_names", |ui, _| history_example(ui, true)),
element!("file_navigation", |ui, _| {
FileView::navigation(ui, |ui| {
FileView::back_to(ui, "gallery:file:back", "Back to {name}", "Sample Plate", "Esc");
FileView::nav_row(ui, "gallery:file:start", "Start", "", true, true);
FileView::nav_row(ui, "gallery:file:open", "Open", "Ctrl+O", false, true);
FileView::separator(ui);
FileView::nav_row(ui, "gallery:file:save", "Save", "Ctrl+S", false, false);
});
}),
element!("file_action", |ui, _| {
FileView::action_tile(ui, "gallery:file:new", ui.available_width(), "new", "New design", "Millimeters · opens in Design", true);
}),
element!("file_recovery_banner", |ui, _| {
FileView::recovery_banner(
ui,
"gallery:recovery",
super::file_view::RecoveryMessage {
title: "1 design was recovered",
before_filename: " after SolidCraft closed unexpectedly: ",
filename: "enclosure-lid.sc",
after_filename: ", 2 minutes ago.",
},
"Recover",
Some("Discard"),
);
}),
element!("file_recovery_review", |ui, _| {
FileView::recovery_review(ui, "gallery:recovery-review", "Sample Plate", " · 14 features · 2 minutes ago", "Recover", "Discard");
}),
element!("file_recent_list", |ui, _| {
FileView::recent_list(ui, |ui| {
for id in ["first", "second"] {
FileView::recent_row(
ui,
id,
RecentRow {
title: "Sample Plate",
path: "Designs/sample-plate.sc",
when: "Open now",
workspace: "Design",
thumbnail: None,
thumbnail_failed: false,
},
);
}
});
}),
element!("file_recent", |ui, _| {
FileView::recent_row(
ui,
"gallery:file:recent",
RecentRow {
title: "Sample Plate",
path: "Designs/sample-plate.sc",
when: "Open now",
workspace: "Design",
thumbnail: None,
thumbnail_failed: false,
},
);
}),
element!("file_sample", |ui, _| {
FileView::sample_grid(
ui,
"gallery:file:sample",
&[SampleCard { title: "Sample Plate", description: "Parametric plate with holes and a bored boss", icon: "new", thumbnail: None }],
);
}),
element!("file_recovery", |ui, _| {
FileView::recovery_banner(
ui,
"gallery:recovery-summary",
super::file_view::RecoveryMessage { title: "2 designs have unsaved changes", before_filename: "", filename: "", after_filename: "" },
"Review",
None,
);
}),
element!("command_search", |ui, _| {
let mut query = "fillet".to_owned();
CommandSearch::field(
ui,
&mut query,
false,
true,
true,
SearchFieldGeometry {
height: Tokens::get().control_height + Tokens::get().space_12,
radius: CommandSearch::field_radius(1.0, true),
progress: 1.0,
},
4096,
);
ui.add_space(Tokens::get().space_6);
CommandSearch::sheet(ui, ui.available_width(), 1.0, false, |ui| {
CommandSearch::heading(ui, "search.commands", 1);
let c = solidcraft_engine::find_command("solid.fillet").unwrap();
let mut row = MenuItem::new(c.id, c.label, c.icon);
row.highlighted = true;
row.shortcut = "F";
row.search_row(ui, &query, "MODEL › MODIFY", None);
CommandSearch::detail(ui, "radius 6 mm");
});
}),
element!("menu", |ui, _| {
Menu::show(ui, 268.0, |ui| {
Menu::heading(ui, "Body");
MenuItem::new("gallery:normal", "Properties", "measure").show(ui);
let mut item = MenuItem::new("gallery:hover", "Hide", "eye");
item.highlighted = true;
item.shortcut = "H";
item.show(ui);
item = MenuItem::new("gallery:open", "Appearance", "appearance");
item.submenu = true;
item.highlighted = true;
item.show(ui);
item = MenuItem::new("gallery:disabled", "Paste", "paste");
item.enabled = false;
item.shortcut = "Ctrl+V";
item.show(ui);
item = MenuItem::new("gallery:checked", "Show Origin", "origin");
item.checked = Some(true);
item.show(ui);
item.checked = Some(false);
item.id = "gallery:unchecked";
item.show(ui);
item = MenuItem::new("gallery:swatch", "Aluminum - Satin", "appearance");
item.swatch = Some(Tokens::get().control_border);
item.show(ui);
Menu::separator(ui);
item = MenuItem::new("gallery:danger", "Delete", "delete");
item.danger = true;
item.shortcut = "Del";
item.show(ui);
});
}),
element!("menu_submenu", |ui, _| {
ui.horizontal_top(|ui| {
Menu::show(ui, 244.0, |ui| {
let mut item = MenuItem::new("parent", "Appearance", "appearance");
item.submenu = true;
item.highlighted = true;
item.show(ui);
});
Menu::show(ui, 236.0, |ui| {
Menu::heading(ui, "Appearance");
let mut item = MenuItem::new("look", "Aluminum - Satin", "appearance");
item.swatch = Some(Tokens::get().control_border);
item.show(ui);
});
});
}),
element!("rename_menu", |ui, s| {
rename_menu(ui, &mut s.value, &mut false);
}),
element!("radial_menu", |ui, _| {
let (r, _) = ui.allocate_exact_size(vec2(360.0, 360.0), egui::Sense::hover());
let mut app = crate::test_support::sample_app();
app.ui.tab = "SURFACE".into();
crate::theme::TabAccent::publish(&app, ui.ctx());
radial_menu(ui, r.center(), &crate::context_menu::radial_items(&app), Some(3));
}),
element!("workspace_menu", |ui, _| {
let app = crate::test_support::sample_app();
workspace_menu(ui, &crate::context_menu::items(&app, &crate::context_menu::Target::Workspace), None, 550.0);
}),
element!("window", "dialog:footer", Some("dialog:ok"), |ui, _| {
Window::new(ui.scope_id().with("window"), "settings", "Preferences").content(
ui,
true,
|ui| {
text(ui, "General", Text::Report("window", false));
},
|ui| {
button(ui, "Restore defaults", Button::Normal);
},
);
}),
element!("window_pages", "dialog:pages", Some("gallery:page"), |ui, s| {
panel::page_list(
ui,
&mut s.selected,
&[WindowPage {
group: Some("prefs.input"),
icon: "settings",
label: "ui.general",
handle: "gallery:page",
scroll: true,
draw: |ui, _: &mut ()| {
text(ui, "General", Text::Inline);
},
}],
&mut (),
);
}),
element!("confirm_warning", "dialog:footer", Some("dialog:apply"), |ui, _| {
Confirm::new(ui.scope_id().with("confirm"), "status_warning", "Save changes?")
.tone(Tone::Warning)
.actions("Save", "Cancel", Some("Don't Save"))
.content(ui, true, |ui| {
text(ui, "Your changes will be lost.", Text::Report("message", false));
});
}),
element!("confirm_danger", "dialog:footer", Some("dialog:ok"), |ui, _| {
Confirm::new(ui.scope_id().with("confirm"), "delete", "Delete")
.tone(Tone::Danger)
.detail("Fillet2 · Chamfer1")
.actions("Delete", "Cancel", None)
.content(ui, true, |ui| {
text(ui, "These features will be deleted:", Text::Report("message", false));
});
}),
element!("confirm_info", "dialog:footer", Some("dialog:ok"), |ui, _| {
Confirm::new(ui.scope_id().with("confirm"), "help", "Replace file?").actions("Replace", "Cancel", None).content(ui, true, |ui| {
text(ui, "A file with this name already exists.", Text::Report("message", false));
});
}),
element!("mono_note", |ui, _| {
text(ui, "solid.fillet · replayable", Text::MonoNote("sample"));
}),
element!("color_thumbnail", |ui, _| {
color_thumbnail(ui, ui.scope_id().with("thumb"), Tokens::get().accent, "Sample", ());
}),
element!("list_frame", |ui, _| {
list_frame(ui, "sample", |ui| {
text(ui, "Sample", Text::Cell);
});
}),
element!("segmented_primary", |ui, s| {
segmented(ui, &mut s.selected, &["U8", "F"], Segments { primary: true, ..Default::default() });
}),
element!("color_popover", |ui, _| {
color_popover(ui, &mut [204, 208, 214]);
}),
element!("report_list", |ui, _| {
report_list(ui, "sample", 120.0, |ui| {
report_header(ui, "Internal error", 3, "2026-10-18 21:04:12", "Report", |ui| {
bin_button(ui, "Delete");
});
text(ui, "solid.fillet · replayable", Text::MonoNote("sample"));
});
}),
element!("path_chip", |ui, _| {
path_chip(ui, "/reports", |ui| {
button(ui, "Copy path", Button::Normal);
});
}),
element!("empty_box", |ui, _| {
empty_box(ui, "empty", "No crash reports.");
}),
element!("report_header", |ui, _| {
report_header(ui, "Internal error", 3, "2026-10-18 21:04:12", "Report", |ui| {
bin_button(ui, "Delete");
});
}),
element!("parameter_import", |ui, _| {
icon_label_button(ui, "Import…", "import_tray", true, false);
}),
element!("parameter_export_csv", |ui, _| {
icon_label_button(ui, "Export CSV…", "export_tray", true, false);
}),
element!("parameter_export_json", |ui, _| {
icon_label_button(ui, "Export JSON…", "export_tray", true, false);
}),
element!("icon_label_button", |ui, _| {
icon_label_button(ui, "Copy path", "copy", true, false);
}),
element!("compact_icon_label_button", |ui, _| {
ui.horizontal(|ui| {
compact_icon_label_button(ui, "Paint", "appearance", true);
compact_icon_label_button(ui, "Pick Up", "select", true);
});
}),
element!("section_count", |ui, _| {
section_count(ui, "count", "Parameters", false, Some(5), |_| {});
}),
element!("bin_button", |ui, _| {
bin_button(ui, "Delete");
}),
element!("active_pill", |ui, _| {
active_pill(ui);
}),
element!("library_cell", |ui, s| {
library_cell(ui, ui.scope_id().with("library"), &mut s.value, "Default material", |ui| {
button(ui, "Steel", Button::Normal);
});
}),
element!("add_prompt", "dialog:table:add_prompt:add", Some("dialog:table:add_prompt:add"), |ui, _| {
table_custom(ui, "add_prompt", &[Column::new("Name", 1.0).flex()], "Empty", |ui, table| {
table.headers(ui, |_, _| false);
table.add_prompt(ui, "Add configuration", "Add configuration");
});
}),
element!("removable_header", |ui, _| {
ui.allocate_ui(vec2(140.0, row_height()), |ui| {
removable_header(ui, "Width");
});
}),
element!("sort_header", |ui, _| {
ui.allocate_ui(vec2(140.0, row_height()), |ui| {
ui.set_min_size(vec2(140.0, row_height()));
sort_header(ui, "Name", &mut Sort::Ascending);
});
}),
element!("plus_header", |ui, _| {
ui.allocate_ui(vec2(140.0, row_height()), |ui| {
ui.set_min_size(vec2(140.0, row_height()));
plus_header(ui, |_| {});
});
}),
element!("table_custom", |ui, _| {
table_custom(ui, "custom", &[Column::new("Name", 1.0)], "Empty", |ui, table| {
table.headers(ui, |_, _| false);
table.add_prompt(ui, "Add parameter", "Add parameter");
});
}),
element!("table_row_height", |ui, _| {
ui.allocate_space(vec2(table_row_height(), table_row_height()));
}),
element!("summary_row", |ui, s| {
summary_row(ui, "Rule", "Drives width = 120 mm", &mut s.checked, ContentWidth::button(ui, "Edit"), |ui| {
button(ui, "Edit", Button::Normal);
});
}),
element!("compact_button", |ui, _| {
compact_button(ui, "▲", "Move up", true, false);
}),
element!("error", |ui, _| {
text(ui, "Invalid expression", Text::Error("gallery"));
}),
element!("table_flex", |ui, s| {
table_custom(
ui,
"flex",
&[Column::new("Name", 1.0).flex(), Column::new("Expression", 1.5).flex(), Column::new("Actions", 0.0).icon_only()],
"Empty",
|ui, table| {
table.headers(ui, |_, _| false);
table.row(ui, "row", false, |row| {
row.cell(|ui| {
text(ui, "Width", Text::Cell);
});
row.cell(|ui| {
cell_editor(ui, ui.scope_id().with("expression"), &mut s.value, "Expression", false);
});
row.cell(|ui| {
bin_button(ui, "Delete");
});
});
table.add_prompt(ui, "Add parameter", "Add parameter");
},
);
}),
element!("cell_name", |ui, _| {
text(ui, "Width", Text::NameCell(false));
}),
element!("cell_name_strong", |ui, _| {
text(ui, "Default", Text::NameCell(true));
}),
element!("text_heading", |ui, _| {
text(ui, "Configuration rules", Text::Heading("gallery"));
}),
element!("cell_mono", |ui, _| {
text(ui, "mm", Text::MonoCell);
}),
element!("cell_value", |ui, _| {
text(ui, "80.0000 mm", Text::Value("gallery_value", false));
}),
element!("cell_value_error", |ui, _| {
text(ui, "Unknown parameter", Text::Value("gallery_value_error", true));
}),
element!("scope", |ui, _| {
scope(ui, |ui| {
ui.allocate_space(vec2(row_height(), row_height()));
});
}),
element!("row_height", |ui, _| {
ui.allocate_space(vec2(row_height(), row_height()));
}),
element!("header_height", |ui, _| {
ui.allocate_space(vec2(header_height(), header_height()));
}),
element!("slider_integer_without_editor", |ui, _| {
slider(ui, &mut 12.0, 0.0..=100.0, Slider { show_value: false, integer: true, ..Default::default() });
}),
element!("canvas_value_field", |ui, s| {
canvas_value_field(ui, ui.scope_id().with("canvas_value"), &mut s.value, false);
}),
element!("placement_field", |ui, s| {
placement_field(ui, ui.scope_id().with("placement"), &mut s.value, "Distance");
}),
element!("bounded_cell_editor", |ui, s| {
bounded_cell_editor(ui, ui.scope_id().with("name"), &mut s.value, "Name", false, 128);
}),
element!("password_field", |ui, s| {
password_field(ui, ui.scope_id().with("secret"), &mut s.value, "API key");
}),
element!("number_field", |ui, _| {
number_field(ui, &mut 3_u32, 1..=200, 1.0, "");
}),
element!("number_field_preserving", |ui, _| {
number_field_preserving(ui, &mut 256_u32, 1..=64, 1.0, "");
}),
element!("number_fields", |ui, _| {
row(ui, "Target", |ui| {
number_fields(ui, &mut [-18.0, 125.5, -18.0], -1e9..=1e9, 0.1, "");
});
}),
element!("slider_percent", |ui, _| {
slider(ui, &mut 1.0, 0.5..=2.5, Slider { step: Some(0.05), format: |v| format!("{:.0} %", v * 100.0), ..Default::default() });
}),
element!("dropdown_menu", |ui, _| {
dropdown_menu(ui, "gallery_menu", "Preset", |ui| {
list_picker(ui, "preset", "Preset", true);
});
}),
element!("bounded_dropdown_menu", |ui, state| {
let choices = [
"CPU lens acceptance with a long captured shot name for the retained image",
"GPU lens acceptance with a second long captured shot name for the result",
];
let selected = state.selected.min(choices.len() - 1);
let width = ui.available_width().min(Tokens::get().form_card_width * 0.75);
let response = bounded_dropdown_menu(ui, "gallery_bounded_menu", choices[selected], width, |ui| {
for (index, label) in choices.iter().enumerate() {
let response = list_picker(ui, &format!("bounded:{index}"), label, selected == index);
if response.clicked() {
state.selected = index;
ui.close();
}
response.on_hover_text(*label);
}
});
response.on_hover_text(choices[selected]);
}),
element!("dropdown_menu_with_close_behavior", |ui, s| {
dropdown_menu_with_close_behavior(ui, "gallery_editable_menu", "Preset", egui::PopupCloseBehavior::CloseOnClickOutside, |ui| {
text_field(ui, &mut s.value, "Filter…");
if list_picker(ui, "preset", "Preset", true).clicked() {
ui.close();
}
});
}),
element!("message_field", |ui, s| {
message_field(ui, ui.scope_id().with("message"), &mut s.value, "Message");
}),
element!("text_lines", |ui, _| {
text_lines(ui, "gallery", "Licence\nSecond line");
}),
element!("report_divider", "dialog:divider:gallery_report", None, |ui, _| {
report_list(ui, "gallery_report", row_height() * 3.0, |ui| {
text(ui, "Report message", Text::Report("gallery_report", false));
report_divider(ui, "gallery_report");
});
}),
element!("table", "dialog:table:gallery:row", None, |ui, s| {
table_custom(ui, "gallery", &[Column::new("Name", 1.0), Column::new("Expression", 1.5)], "No rows", |ui, table| {
table.headers(ui, |_, _| false);
table.row(ui, "row", true, |row| {
row.cell(|ui| {
text(ui, "Width", Text::Cell);
});
row.cell(|ui| {
cell_editor(ui, ui.scope_id().with("value"), &mut s.value, "", false);
});
});
});
}),
element!("name_list", "dialog:table:gallery_names:Bracket.solidcraft", None, |ui, _| {
name_list(ui, "gallery_names", &["Name", "Size", "Actions"], "No files", |list| {
list.row("Bracket.solidcraft", |row| {
row.name("Bracket.solidcraft");
row.cell(|ui| text(ui, "12.3 KB", Text::Inline));
row.cell(|ui| button(ui, "Open", Button::Small));
});
});
}),
element!("list_picker", "dialog:list:gallery", Some("dialog:list:gallery"), |ui, _| {
list_picker(ui, "gallery", "Preset", true);
}),
element!("choice_chip", "dialog:list:gallery", Some("dialog:list:gallery"), |ui, _| {
choice_chip(ui, "gallery", "Shot 1", true);
}),
element!("inline_text", "dialog:inline:Active", Some("dialog:inline:Active"), |ui, _| {
text(ui, "Active", Text::Inline);
}),
element!("cell_text", "dialog:cell:Width", Some("dialog:cell:Width"), |ui, _| {
text(ui, "Width", Text::Cell);
}),
element!("label_actions", |ui, _| {
label_actions(ui, "Configuration", |ui| {
button(ui, "Apply", Button::Normal);
});
}),
element!("text", "dialog:report:gallery", Some("dialog:report:gallery"), |ui, _| {
text(ui, "Validation report with retained units: 10 mm", Text::Report("gallery", false));
}),
element!("name_cell_with_hint", "dialog:cell:Width", Some("dialog:cell:Width"), |ui, _| {
name_cell_with_hint(ui, "Width", false, "Double-click to rename");
}),
element!("search_field", |ui, s| {
search_field(ui, ui.scope_id().with("search"), &mut s.value, "Search");
}),
element!("menu_filter", |ui, s| {
menu_filter(ui, ui.scope_id().with("menu_filter"), &mut s.value, "Filter");
}),
element!("cell_editor", |ui, s| {
cell_editor(ui, ui.scope_id().with("cell"), &mut s.value, "Expression", true);
}),
element!("color_field", |ui, _| {
color_field(ui, &mut [120, 150, 180]);
}),
element!("color_field_with_opacity", |ui, _| {
color_field_with_opacity(ui, &mut [120, 150, 180], &mut 0.5);
}),
element!("mixed_color_field", |ui, _| {
mixed_color_field(ui, &mut [120, 150, 180], Some(&mut 0.5), Some("Mixed"));
}),
element!("slider", |ui, _| {
slider(ui, &mut 0.5, 0.0..=1.0, Default::default());
}),
element!("slider_disabled", |ui, _| {
ui.add_enabled_ui(false, |ui| slider(ui, &mut 0.5, 0.0..=1.0, Default::default()));
}),
element!("scalar_field", |ui, _| {
scalar_field(ui, &mut 0.5, 0.0..=1.0);
}),
element!("track_number", |ui, _| {
track_number(ui, &mut 1350.0, 0.5, 1);
}),
element!("length_field", |ui, _| {
length_field(ui, &mut 12.7, "in", 2);
}),
element!("bounded_length_field", |ui, _| {
bounded_length_field(ui, &mut 12.7, "in", 2, 0.0..=25.4, 0.254);
}),
element!("angle_field", |ui, _| {
angle_field(ui, &mut 45.0);
}),
element!("text_area", |ui, s| {
text_area(ui, "Gallery", ui.scope_id().with("area"), &mut s.value, 5, 1024);
}),
element!("color_swatch", |ui, _| {
color_swatch(ui, ui.scope_id().with("swatch"), Tokens::get().accent, true, "Sample", 1);
}),
element!("swatch_grid", |ui, _| {
swatch_grid(ui, &[1, 2, 3], |ui, n| {
color_swatch(ui, ui.scope_id().with(n), Tokens::get().accent, true, "Sample", *n);
});
}),
element!("action_menu", |ui, _| {
action_menu(ui, "Actions", |ui| {
button(ui, "Add", Button::Normal);
});
}),
element!("enabled_button", |ui, _| {
button(ui, "Add", Button::Enabled(true));
}),
element!("header", "dialog:header", Some("dialog:close"), |ui, _| {
header(ui, "fillet", "Fillet", || {});
}),
element!("disclosure", |ui, _| {
let t = Tokens::get();
for open in [true, false] {
let (rect, _) = ui.allocate_exact_size(vec2(t.form_close_size, t.form_close_size), egui::Sense::hover());
disclosure(ui.painter(), rect.center(), open, t.form_dim);
}
}),
element!("disclosure_button_at", |ui, _| {
let t = Tokens::get();
for open in [true, false] {
let (rect, _) = ui.allocate_exact_size(vec2(t.form_close_size, t.form_close_size), egui::Sense::hover());
ui.push_id(open, |ui| disclosure_button_at(ui, rect, open, crate::i18n::tr_label(if open { "Collapse" } else { "Expand" })));
}
}),
element!("panel_disclosure_button_at", |ui, _| {
let t = Tokens::get();
for open in [true, false] {
let (rect, _) = ui.allocate_exact_size(vec2(t.form_close_size, t.form_close_size), egui::Sense::hover());
ui.push_id(open, |ui| panel_disclosure_button_at(ui, rect, open, crate::i18n::tr_label(if open { "Collapse" } else { "Expand" })));
}
}),
element!("dropdown_indicator", |ui, _| {
let t = Tokens::get();
let (rect, _) = ui.allocate_exact_size(vec2(t.form_section_icon_size, t.form_section_icon_size), egui::Sense::hover());
dropdown_indicator(ui.painter(), rect, t.form_dim);
}),
element!("collapsible_header_closed", "dialog:header", Some("dialog:collapse"), |ui, _| {
collapsible_header(ui, "fillet", "Fillet", &mut true, || {});
}),
element!("section_open", "dialog:section:Advanced", Some("dialog:section:Advanced"), |ui, _| {
section(ui, "gallery_open", "Advanced", true, |_| {});
}),
element!("collapsible_header", "dialog:header", Some("dialog:collapse"), |ui, _| {
collapsible_header(ui, "fillet", "Fillet", &mut false, || {});
}),
element!("row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
field(ui, &mut s.value);
});
}),
element!("sized_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
sized_row(ui, "Gallery", row_height() * 2.0, |ui| {
text_field(ui, &mut s.value, "Name");
});
}),
element!("expr_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
expr_row(ui, "Gallery", &mut s.value);
}),
element!("count_row", "dialog:row:Gallery", Some("dialog:Gallery up"), |ui, _| {
let mut count = "6".to_owned();
count_row(ui, "Gallery", &mut count, &Count { min: 1, max: 10, eval: &|text: &str| text.trim().parse().ok() });
}),
element!("count_field", "dialog:row:Gallery", Some("dialog:Gallery down"), |ui, _| {
row(ui, "Gallery", |ui| {
let mut count = "1".to_owned();
count_field(ui, &mut count, &Count { min: 1, max: 10, eval: &|text: &str| text.trim().parse().ok() });
});
}),
element!("hint_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
hint_row(ui, "Gallery", &mut s.value, "Value");
}),
element!("text_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
text_row(ui, "Gallery", &mut s.value, "Name");
}),
element!("choice_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
choice_row(ui, "Gallery", "gallery", &mut s.selected, &["One", "Two"]);
}),
element!("multiline_text_field", "dialog:widget:Gallery", Some("dialog:Gallery"), |ui, s| {
multiline_text_field(ui, "Gallery", ui.scope_id().with("text"), &mut s.value);
}),
element!("searchable_dropdown", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, _| {
row(ui, "Gallery", |ui| {
searchable_dropdown(ui, "gallery", "One", &mut String::new(), &[SearchOption { value: "one", label: "One", handle: None }], None, None);
});
}),
element!("search_picker", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, _| {
row(ui, "Gallery", |ui| {
search_picker(
ui,
SearchPicker {
id: "gallery_search_picker",
handles: "gallery:search_picker",
current: "One",
current_value: "one",
hint: "Search",
choices: &[SearchChoice { value: "one", label: "One", tip: "", group: None }],
custom: true,
note: None,
open_group: None,
enabled: true,
},
);
});
}),
element!("text_emphasis", "dialog:row:Gallery", Some("dialog:Bold"), |ui, s| {
row(ui, "Gallery", |ui| {
text_emphasis(ui, &mut s.checked, &mut false, true);
});
}),
element!("value_pair_named", "dialog:row:Position", Some("dialog:Distance X"), |ui, s| {
value_pair(ui, "Position", [&mut s.value, &mut s.second], ["X", "Y"], Some(["Distance X", "Distance Y"]));
}),
element!("inline_name", |ui, s| {
let (rect, _) = ui.allocate_exact_size(vec2(ui.available_width(), row_height()), egui::Sense::hover());
inline_name(ui, rect, ui.scope_id().with("inline_name"), &mut s.value);
}),
element!("field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
field(ui, &mut s.value);
});
}),
element!("focused_field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
focused_field(ui, &mut s.value);
});
}),
element!("hint_field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
hint_field(ui, &mut s.value, "Length");
});
}),
element!("checked_field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
checked_field(ui, &mut s.value, "Length", s.checked);
});
}),
element!("checked_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
checked_row(ui, "Gallery", &mut s.value, "Length", Some("Too small"));
}),
element!("warning_caption", "dialog:caption:Gallery", None, |ui, _| {
warning_caption(ui, "Gallery", "Too small");
}),
element!("text_field_tip", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
text_field_tip(ui, &mut s.value, "Name", "What it is called");
});
}),
element!("continuity_row", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, _| {
let mut order = Continuity::G1;
continuity_row(ui, "Gallery", "gallery_continuity", &mut order, &[Continuity::G0, Continuity::G1, Continuity::G2]);
}),
element!("continuity_row_explained", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, _| {
let mut order = Continuity::G2;
let allowed = [Continuity::G1, Continuity::G2];
continuity_row_explained(ui, "Gallery", "gallery_continuity", &mut order, &allowed, &continuity_tip(&allowed));
}),
element!("continuity_tip", "dialog:row:Gallery", None, |ui, _| {
let tip = continuity_tip(&[Continuity::G0, Continuity::G1]);
row(ui, "Gallery", |ui| ui.label(tip));
}),
element!("text_field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
text_field(ui, &mut s.value, "Name");
});
}),
element!("text_field_reserving", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
let t = Tokens::get();
let reserve = t.space_24 * 2.0;
let (_, response) = text_field_reserving(ui, &mut s.value, "Name", reserve);
let counter = egui::Rect::from_min_max(egui::pos2(response.rect.right() - reserve, response.rect.top()), response.rect.max);
ui.painter().text(
counter.center(),
egui::Align2::CENTER_CENTER,
format!("{}/64", s.value.chars().count()),
egui::FontId::proportional(t.font_small),
t.form_dim,
);
});
}),
element!("focused_text_field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
focused_text_field(ui, &mut s.value, "Name");
});
}),
element!("fraction_field", "dialog:row:Gallery", Some("dialog:fraction:Gallery"), |ui, _| {
row(ui, "Gallery", |ui| {
fraction_field(ui, &mut 0.5);
});
}),
element!("dropdown", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
dropdown(ui, "gallery", &mut s.selected, &["One", "Two"]);
});
}),
element!("dropdown_icons", "dialog:row:Visual style", Some("dialog:Visual style"), |ui, s| {
row(ui, "Visual style", |ui| {
let options: Vec<_> = crate::navigation_bar::VISUAL_STYLES
.iter()
.enumerate()
.map(|(index, (_, label))| (*label, crate::navigation_bar::visual_style_icon(index as u8)))
.collect();
dropdown_icons(ui, "gallery_visual_style", &mut s.selected, &options);
});
}),
element!("dropdown_previews", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
dropdown_previews(ui, "gallery_previews", &mut s.selected, &["One", "Two"], |ui, index| {
ui.label(if index == 0 { "One" } else { "Two" });
});
});
}),
element!("dropdown_picked", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
dropdown_picked(ui, "gallery_picked", &mut s.selected, &["One", "Two"]);
});
}),
element!("selection_field", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, _| {
row(ui, "Gallery", |ui| {
selection_field(ui, "Point 1", Selection { active: true, filled: true });
});
}),
element!("selection_field_empty", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, _| {
row(ui, "Gallery", |ui| {
selection_field(ui, "Select", Selection { active: false, filled: false });
});
}),
element!("segmented", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
segmented(ui, &mut s.selected, &["One", "Two"], Segments::default());
});
}),
element!("segmented_compact", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
segmented(ui, &mut s.selected, &["Left", "Center", "Right"], Segments { compact: true, ..Default::default() });
});
}),
element!("segmented_states", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
segmented(ui, &mut s.selected, &["One", "Two"], Segments { states: &[true, true], ..Default::default() });
});
}),
element!("segmented_icons", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
segmented_icons(ui, &mut s.selected, &[IconSegment { key: "normal", icon: "normal", tip: "Normal".into() }], &[]);
});
}),
element!("checkbox", "dialog:row:Gallery", Some("dialog:Gallery"), |ui, s| {
row(ui, "Gallery", |ui| {
checkbox(ui, "Option", &mut s.checked);
});
}),
element!("checkbox_off", |ui, _| {
checkbox(ui, "Option", &mut false);
}),
element!("checkbox_wrapped", |ui, s| {
ui.scope(|ui| {
ui.set_width(Tokens::get().space_24 * 8.0);
ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Wrap);
checkbox(ui, "A long translated checkbox label stays readable on several lines", &mut s.checked);
});
}),
element!("checkbox_disabled_on", |ui, _| {
ui.add_enabled_ui(false, |ui| checkbox(ui, "Option", &mut true));
}),
element!("checkbox_disabled_off", |ui, _| {
ui.add_enabled_ui(false, |ui| checkbox(ui, "Option", &mut false));
}),
element!("checkbox_indeterminate", |ui, _| {
checkbox_indeterminate(ui, "Option", &mut false, true);
}),
element!("checkbox_disabled_mixed", |ui, _| {
ui.add_enabled_ui(false, |ui| checkbox_indeterminate(ui, "Option", &mut false, true));
}),
element!("checkbox_focused", |ui, _| {
egui::Frame::new().inner_margin(Tokens::get().space_4).show(ui, |ui| {
checkbox(ui, "Option", &mut true).request_focus();
});
}),
element!("checkbox_focused_off", |ui, _| {
egui::Frame::new().inner_margin(Tokens::get().space_4).show(ui, |ui| {
checkbox(ui, "Option", &mut false).request_focus();
});
}),
element!("checkbox_focused_mixed", |ui, _| {
egui::Frame::new().inner_margin(Tokens::get().space_4).show(ui, |ui| {
checkbox_indeterminate(ui, "Option", &mut false, true).request_focus();
});
}),
element!("checkbox_hovered", |ui, _| {
checkbox(ui, "Option", &mut false);
}),
element!("checkbox_hovered_on", |ui, _| {
checkbox(ui, "Option", &mut true);
}),
element!("checkbox_hovered_mixed", |ui, _| {
checkbox_indeterminate(ui, "Option", &mut false, true);
}),
element!("command_menu_button", |ui, _| {
command_menu_button(ui, "save", "Save", "save", "Ctrl+S", true);
}),
element!("primary_button", "dialog:row:Gallery", Some("dialog:button:Create"), |ui, _| {
row(ui, "Gallery", |ui| {
primary_button(ui, "Create");
});
}),
element!("wide_primary_button", |ui, _| {
wide_primary_button(ui, "Finish Sketch");
}),
element!("persistent_button_shape", "gallery:persistent_button", Some("gallery:persistent_button"), |ui, _| {
let t = Tokens::get();
let (rect, response) = ui.allocate_exact_size(vec2(t.form_button_height * 3.0, t.form_button_height * 2.0), egui::Sense::click());
ui.painter().add(persistent_button_shape(ui, &response, rect));
ui.painter().text(rect.center(), egui::Align2::CENTER_CENTER, "Selected", crate::fonts::semibold(t.font_label), t.selected_ink);
scenario::publish_target("gallery:persistent_button", rect);
}),
element!("native_button_focus", "gallery:native_button_focus", Some("gallery:native_button_focus"), |ui, _| {
let t = Tokens::get();
let (rect, response) = ui.allocate_exact_size(vec2(t.form_button_height * 3.0, t.form_button_height), egui::Sense::click());
response.request_focus();
ui.painter().rect_filled(rect, t.radius_sm, t.control_fill);
ui.painter().add(native_button_focus(ui, &response, rect));
scenario::publish_target("gallery:native_button_focus", rect);
}),
element!("button", "dialog:row:Gallery", Some("dialog:button:Gallery:Add"), |ui, _| {
row(ui, "Gallery", |ui| {
button(ui, "Add", Button::Normal);
});
}),
element!("button_danger_outlined", "dialog:row:Gallery", Some("dialog:button:Gallery:Replace"), |ui, _| {
row(ui, "Gallery", |ui| {
button(ui, "Replace", Button::DangerOutlined);
});
}),
element!("button_at", |ui, _| {
let t = Tokens::get();
let (rect, _) = ui.allocate_exact_size(vec2(t.space_24 * 5.0, t.file_action_height), egui::Sense::hover());
button_at(ui, "gallery:button_at", rect, "Recover", Button::Primary);
}),
element!("small_button", "dialog:row:Gallery", Some("dialog:button:Gallery:×"), |ui, _| {
row(ui, "Gallery", |ui| {
button(ui, "×", Button::Small);
});
}),
element!("checkbox_row", "sketch_palette:toggle:gallery", Some("sketch_palette:toggle:gallery"), |ui, _| {
checkbox_row(ui, "gallery", "Option", true);
}),
element!("checkbox_grid", "dialog:checkbox:First", Some("dialog:First"), |ui, s| {
checkbox_grid(ui, &mut [("First", &mut s.checked), ("Second", &mut false)], 2);
}),
element!("options", "dialog:checkbox:First", Some("dialog:First"), |ui, s| {
options(ui, "gallery", &mut [("First", &mut s.checked), ("Second", &mut false)]);
}),
element!("footer", "dialog:footer", Some("dialog:ok"), |ui, _| {
footer(ui, "OK", "Cancel", true, Footer::default());
}),
element!("footer_apply", "dialog:footer", Some("dialog:apply"), |ui, _| {
footer(ui, "OK", "Cancel", true, Footer { apply: Some("Apply"), ..Default::default() });
}),
element!("footer_status", "dialog:footer", Some("dialog:ok"), |ui, _| {
footer(ui, "OK", "Cancel", true, Footer { status: Some("Computing…"), ..Default::default() });
}),
element!("button_pair", "sketch_palette:look_at", Some("sketch_palette:look_at"), |ui, _| {
button_pair(
ui,
"sketch_palette",
[false, true],
[PairButton { key: "look_at", label: "ui.look_at", icon: Some("lookat") }, PairButton { key: "slice", label: "Slice", icon: None }],
);
}),
element!("icon_button_at", |ui, _| {
let (rect, _) = ui.allocate_exact_size(vec2(row_height(), row_height()), egui::Sense::hover());
icon_button_at(ui, rect, "close", "Close");
}),
element!("mirrored_icon_button_at", |ui, _| {
let (rect, _) = ui.allocate_exact_size(vec2(row_height(), row_height()), egui::Sense::hover());
mirrored_icon_button_at(ui, rect, "chevron_right", "Move left");
}),
element!("quiet_icon_button_at", |ui, _| {
let (rect, _) = ui.allocate_exact_size(vec2(row_height(), row_height()), egui::Sense::hover());
quiet_icon_button_at(ui, rect, "plus", "Add shortcut");
}),
element!("shortcut_binding", |ui, _| {
ui.horizontal(|ui| {
shortcut_binding(ui, "Ctrl+Shift+PageDown", true);
shortcut_binding(ui, "Option+Enter", false);
shortcut_binding(ui, "Ctrl++", true);
});
shortcut_binding(ui, "", true);
}),
element!("keyboard", |ui, _| {
assert_eq!(keyboard(ui.ctx(), true), Action::None);
ui.allocate_space(vec2(row_height(), row_height()));
}),
element!("list_row", "dialog:list:picked", Some("dialog:list:picked:remove"), |ui, _| {
list_row(ui, "picked", "Point 1");
}),
element!("value_pair", "dialog:row:Position", Some("dialog:Y"), |ui, s| {
value_pair(ui, "Position", [&mut s.value, &mut s.second], ["X", "Y"], None);
}),
element!("toggle_icon", "dialog:Alignment:Center", Some("dialog:Alignment:Center"), |ui, s| {
toggle_icon(ui, "Alignment", "Center", &mut s.checked, "pattern_center");
}),
element!("tool_choices", "sketch_palette:feature:line", Some("sketch_palette:feature:line"), |ui, _| {
tool_choices(ui, "Line", "line", &[ToolChoice { key: "line", icon: "normal", label: "Line", enabled: true }]);
}),
element!("status_header", "sketch_palette:meter", None, |ui, _| {
ui.spacing_mut().item_spacing.y = 0.0;
status_header(
ui,
"sketch_palette",
"Sketch 1",
StatusHeader { icon: "sketch", text: "2 degrees of freedom", complete: false, fraction: 0.5 },
);
}),
element!("progress", "dialog:progress:gallery", None, |ui, _| {
progress(ui, "gallery", 0.4);
}),
element!("steps", "dialog:step:gallery:0:done", None, |ui, _| {
steps(ui, "gallery", &["Read", "Mesh", "Show"], 1, Some("40%"));
}),
element!("hint", "dialog:hint:gallery", Some("dialog:hint:gallery"), |ui, _| {
text(ui, "Pick a point", Text::Hint("gallery"));
}),
element!("note", "dialog:note:gallery", None, |ui, _| {
text(ui, "Counts include the original. Center balances copies; Flip chooses the extra side for even totals.", Text::Note("gallery"));
}),
element!("caption", "dialog:caption:Gallery", None, |ui, _| {
caption(ui, "Gallery", "Construction");
}),
element!("status_line", "dialog:status:needs a joint that turns and one that slides", None, |ui, _| {
status_line(ui, "needs a joint that turns and one that slides", StatusTone::Dim);
}),
element!("status_line_warning", |ui, _| {
status_line(ui, "Pick two different components before creating a joint.", StatusTone::Warning);
}),
element!("status_line_error", |ui, _| {
status_line(ui, "The interference check could not finish. Check the selected bodies.", StatusTone::Error);
}),
element!("figure_rows", "dialog:figure:gallery", Some("dialog:Gallery"), |ui, s| {
let Sample { value, second, .. } = s;
figure_rows(ui, "gallery", &mut [("Gallery", value), ("Second", second)], |painter, rect, slots| {
let t = Tokens::get();
painter.rect_stroke(rect.shrink(t.space_4), t.control_radius, egui::Stroke::new(1.0, t.form_dim), egui::StrokeKind::Inside);
for slot in slots {
let ink = if slot.hot { t.form_primary } else { t.form_dim };
let y = slot.rect.center().y;
painter.line_segment([egui::pos2(rect.center().x, y), egui::pos2(slot.rect.left(), y)], egui::Stroke::new(1.0, ink));
}
});
}),
element!("section", "dialog:section:Advanced", Some("dialog:section:Advanced"), |ui, _| {
section(ui, "gallery", "Advanced", false, |_| {});
}),
element!("search_fold", "prefs:search:shortcuts", Some("prefs:search:shortcuts"), |ui, _| {
search_fold(ui, "Shortcuts", 3, |_| {});
}),
element!("divider", "dialog:divider:gallery", None, |ui, _| {
divider(ui, "gallery");
}),
element!("popup_list", |ui, _| {
let anchor = ui.allocate_space(vec2(100.0, row_height())).1;
popup_list(
ui.ctx(),
ui.scope_id().with("popup"),
anchor,
Some(0),
&[PopupOption { kind: "parameter", text: "Width", detail: "10 mm", color: Tokens::get().text }],
"Choose",
);
// The popup is on a separate layer; reserve its painted allocation for the same checks.
ui.allocate_space(vec2(ui.available_width(), row_height() * 5.0));
}),
];
fn example(ui: &mut Ui, element: &Element) -> (&'static str, Option<&'static str>) {
let mut sample = Sample { value: "12 mm".into(), second: "25 mm".into(), selected: 0, checked: true };
let rect = ui.scope(|ui| (element.draw)(ui, &mut sample)).response.rect;
if matches!(
element.name,
"menu" | "menu_submenu" | "rename_menu" | "workspace_menu" | "command_search" | "history_icons" | "history_names" | "navigation_popup"
) {
// A popup's elevation is painted outside its layout rectangle. Reserve those
// actual shadow bounds as part of the gallery sample, keeping the paint guard strict.
ui.expand_to_include_rect(rect + Menu::frame().shadow.margin());
}
scenario::publish_rect("gallery:allocation", rect);
(element.rect, element.handle)
}
#[test]
fn every_element_has_geometry_and_stays_in_its_allocation_in_both_themes() {
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
for element in ELEMENTS {
let name = element.name;
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
for pass in 0..3 {
let events = if element.name.starts_with("checkbox_hovered") && pass > 0 {
vec![egui::Event::PointerMoved(scenario::rect_of("gallery:allocation").expect("hover allocation").center())]
} else {
vec![]
};
scenario::clear_handles();
let mut allocation = egui::Rect::NOTHING;
let mut published = ("", None);
let mut output = ctx.run_ui(
egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(400.0, 600.0))),
events,
..Default::default()
},
|ui| {
ui.set_width(320.0);
allocation = ui
.scope(|ui| {
scope(ui, |ui| {
published = example(ui, element);
})
})
.response
.rect;
},
);
output.textures_delta.clear();
let rect = scenario::rect_of(published.0).unwrap_or_else(|| panic!("{name}: missing {}", published.0));
assert!(rect.is_finite() && rect.is_positive(), "{name}: {rect:?}");
assert!(allocation.expand(1.0).contains_rect(rect), "{name}: {rect:?} outside {allocation:?}");
if let Some(handle) = published.1 {
assert!(
rect.contains(scenario::handle_at(handle).unwrap_or_else(|| panic!("{name}: missing {handle}"))),
"{name}: handle outside {rect:?}"
);
}
if published.0.starts_with("dialog:row:") {
let expected_height = if name == "sized_row" { row_height() * 2.0 } else { Tokens::get().control_height };
assert_eq!(rect.height(), expected_height, "{name}");
}
for shape in output.shapes {
// Native icon-only buttons keep an empty text shape. It has no vertices;
// its sentinel bounds do not describe any painted pixels.
if matches!(&shape.shape, egui::Shape::Text(text) if text.galley.num_vertices == 0) {
continue;
}
let painted = shape.shape.visual_bounding_rect().intersect(shape.clip_rect);
if painted.is_positive() {
assert!(allocation.expand(1.0).contains_rect(painted), "{name}: paint {painted:?} outside {allocation:?}: {:?}", shape.shape);
}
}
}
}
}
crate::theme::set_dark(previous);
}
#[test]
fn visual_style_dropdown_specimen_selects_real_options_and_paints_their_icons() {
let previous = crate::theme::is_dark();
let element = ELEMENTS.iter().find(|element| element.name == "dropdown_icons").unwrap();
for dark in [false, true] {
crate::theme::set_dark(dark);
let ctx = crate::fonts::test_context();
let sample = std::cell::RefCell::new(Sample { value: String::new(), second: String::new(), selected: 0, checked: false });
let mut draw = |ui: &mut Ui| {
(element.draw)(ui, &mut sample.borrow_mut());
};
for _ in 0..3 {
super::test_support::frame(&ctx, vec![], &mut draw);
}
for (index, (_, label)) in crate::navigation_bar::VISUAL_STYLES.into_iter().enumerate() {
let trigger = scenario::handle_at("dialog:Visual style").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(trigger, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(trigger, false), &mut draw);
super::test_support::frame(&ctx, vec![], &mut draw);
for (option, (_, name)) in crate::navigation_bar::VISUAL_STYLES.into_iter().enumerate() {
let rect = scenario::rect_of(&format!("dialog:Visual style:{name}")).unwrap();
let icon = crate::navigation_bar::visual_style_icon(option as u8);
let painted = scenario::rect_of(&format!("dialog:dropdown_icon:{icon}")).unwrap();
let owner = if option == sample.borrow().selected { scenario::rect_of("dialog:widget:Visual style").unwrap() } else { rect };
assert!(owner.contains_rect(painted), "{name}: its real icon is in its option or selected trigger");
}
let option = scenario::handle_at(&format!("dialog:Visual style:{label}")).unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(option, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(option, false), &mut draw);
super::test_support::frame(&ctx, vec![], &mut draw);
assert_eq!(sample.borrow().selected, index, "the specimen edits the real selection index");
let icon = crate::navigation_bar::visual_style_icon(index as u8);
let trigger = scenario::rect_of("dialog:widget:Visual style").unwrap();
assert!(trigger.contains_rect(scenario::rect_of(&format!("dialog:dropdown_icon:{icon}")).unwrap()));
assert!(scenario::handle_at("dialog:Visual style:Wireframe").is_none(), "the native popup closes after selection");
}
}
crate::theme::set_dark(previous);
}
#[test]
fn apply_does_not_submit_and_obeys_validation() {
for enabled in [false, true] {
let ctx = crate::fonts::test_context();
let mut action = Action::None;
let mut draw = |ui: &mut Ui| {
action = footer(ui, "OK", "Cancel", enabled, Footer { apply: Some("Apply"), ..Default::default() });
};
super::test_support::frame(&ctx, vec![], &mut draw);
let at = scenario::handle_at("dialog:apply").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(at, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(at, false), &mut draw);
assert_eq!(action, if enabled { Action::Apply } else { Action::None });
}
}
#[test]
fn picked_item_remove_and_paired_values_have_independent_targets() {
let ctx = crate::fonts::test_context();
let mut removed = false;
let mut draw = |ui: &mut Ui| {
removed = list_row(ui, "point-1", "Point 1").clicked();
};
super::test_support::frame(&ctx, vec![], &mut draw);
let at = scenario::handle_at("dialog:list:point-1:remove").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(at, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(at, false), &mut draw);
assert!(removed);
let mut x = String::new();
let mut y = String::new();
let mut draw = |ui: &mut Ui| {
value_pair(ui, "Position", [&mut x, &mut y], ["X", "Y"], None);
};
super::test_support::frame(&ctx, vec![], &mut draw);
let row = scenario::rect_of("dialog:row:Position").unwrap();
let first = scenario::handle_at("dialog:X").unwrap();
let second = scenario::handle_at("dialog:Y").unwrap();
assert_eq!(row.height(), Tokens::get().control_height);
assert!(row.contains(first) && row.contains(second) && first.x < second.x);
super::test_support::frame(&ctx, super::test_support::pointer(second, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(second, false), &mut draw);
super::test_support::frame(&ctx, vec![egui::Event::Text("25".into())], &mut draw);
assert_eq!(x, "");
assert_eq!(y, "25");
}
#[test]
fn gallery_rows_share_a_label_column_after_measurement_in_both_themes() {
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
let ctx = crate::fonts::test_context();
let mut value = "3".to_owned();
for _ in 0..3 {
super::test_support::frame(&ctx, vec![], |ui| {
row(ui, "Edges", |ui| {
selection_field(ui, "Edge 1", Selection { active: true, filled: true });
});
row(ui, "Counterbore depth", |ui| {
field(ui, &mut value);
});
});
}
let first = scenario::rect_of("dialog:control:Edges").unwrap();
let second = scenario::rect_of("dialog:control:Counterbore depth").unwrap();
assert_eq!(first.left(), second.left());
assert_eq!(first.height(), Tokens::get().control_height);
assert_eq!(second.height(), Tokens::get().control_height);
let width = scenario::rect_of("dialog:label:Edges").unwrap().width();
assert!(width >= Tokens::get().form_label_width && width <= Tokens::get().form_label_width * 1.6);
}
crate::theme::set_dark(previous);
}
#[test]
fn compound_row_actions_preserve_the_original_field_handle() {
let ctx = crate::fonts::test_context();
let mut value = "3 mm".to_owned();
let mut expected = None;
super::test_support::frame(&ctx, vec![], |ui| {
row(ui, "Mid Radius", |ui| {
ui.horizontal(|ui| {
ui.allocate_ui_with_layout(
egui::vec2(Tokens::get().space_24 * 3.0, row_height()),
egui::Layout::left_to_right(egui::Align::Center),
|ui| {
field(ui, &mut value);
},
);
expected = scenario::handle_at("dialog:Mid Radius");
button(ui, "×", Button::Small);
});
});
});
assert_eq!(scenario::handle_at("dialog:Mid Radius"), expected);
assert!(expected.is_some());
assert_ne!(scenario::handle_at("dialog:button:Mid Radius:×"), expected);
}
#[test]
fn emphasis_and_compact_modes_keep_independent_actions_in_both_themes() {
for dark in [false, true] {
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut bold = false;
let mut italic = false;
let mut selected = 0;
let mut draw = |ui: &mut Ui| {
row(ui, "Style", |ui| text_emphasis(ui, &mut bold, &mut italic, true));
row(ui, "Alignment", |ui| {
segmented(
ui,
&mut selected,
&["Long translated left", "Long translated centre", "Long translated right"],
Segments { compact: true, ..Default::default() },
);
});
};
super::test_support::frame(&ctx, vec![], &mut draw);
for handle in ["dialog:Bold", "dialog:Italic", "dialog:Alignment:Long translated centre"] {
let at = scenario::handle_at(handle).unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(at, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(at, false), &mut draw);
}
assert!(bold && italic);
assert_eq!(selected, 1);
}
}
#[test]
fn table_cells_keep_alignment_fixed_rows_editing_and_action_targets() {
for dark in [false, true] {
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut first = "10 mm".to_owned();
let mut second = "20 mm".to_owned();
let mut removed = false;
let mut draw = |ui: &mut Ui| {
scope(ui, |ui| {
table_custom(
ui,
"cells",
&[Column::new("Name", 1.0), Column::new("Expression", 1.5), Column::new("Actions", 0.7)],
"Empty",
|ui, table| {
table.headers(ui, |_, _| false);
for (name, value) in [("Width", &mut first), ("Height", &mut second)] {
table.row(ui, name, name == "Height", |row| {
row.cell(|ui| {
text(ui, name, Text::Cell);
});
row.cell(|ui| {
let response = cell_editor(ui, ui.scope_id().with("expression"), value, "Expression", false);
scenario::publish_handle(&format!("gallery:cell:{name}"), response.rect.center());
scenario::publish_rect(&format!("gallery:cell:{name}"), response.rect);
});
row.cell(|ui| {
if button(ui, "Delete", Button::Small).clicked() {
removed = true;
}
});
});
}
},
);
});
};
for _ in 0..3 {
super::test_support::frame(&ctx, vec![], &mut draw);
}
let first_rect = scenario::rect_of("gallery:cell:Width").unwrap();
let second_rect = scenario::rect_of("gallery:cell:Height").unwrap();
let header = scenario::rect_of("dialog:column:cells:Expression").unwrap();
assert_eq!(first_rect.left(), header.left());
assert_eq!(second_rect.left(), header.left());
assert_eq!(first_rect.height(), Tokens::get().control_height);
assert_eq!(second_rect.height(), Tokens::get().control_height);
let at = scenario::handle_at("gallery:cell:Height").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(at, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(at, false), &mut draw);
super::test_support::frame(&ctx, vec![egui::Event::Text("x".into())], &mut draw);
let delete = scenario::handle_at("dialog:button:Actions:Delete").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(delete, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(delete, false), &mut draw);
assert_eq!(first, "10 mm");
assert!(second.contains('x'));
assert!(removed);
}
}
#[test]
fn popup_suggestions_and_selectable_lists_keep_click_selection() {
for dark in [false, true] {
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut selected = None;
let mut draw = |ui: &mut Ui| {
selected = popup_list(
ui.ctx(),
egui::Id::unique("suggestions"),
egui::Rect::from_min_size(egui::pos2(10.0, 10.0), vec2(220.0, 24.0)),
Some(0),
&[
PopupOption { kind: "parameter", text: "width", detail: "Parameter · 10 mm", color: Tokens::get().text },
PopupOption { kind: "parameter", text: "height", detail: "Parameter · 20 mm", color: Tokens::get().text },
],
"Choose",
);
};
for _ in 0..3 {
super::test_support::frame(&ctx, vec![], &mut draw);
}
let at = scenario::handle_at("dialog:suggestion:1").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(at, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(at, false), &mut draw);
assert_eq!(selected, Some(1));
let mut picked = false;
let mut draw = |ui: &mut Ui| {
scope(ui, |ui| {
if list_picker(ui, "preset", "Preset", picked).clicked() {
picked = !picked;
}
});
};
super::test_support::frame(&ctx, vec![], &mut draw);
let at = scenario::handle_at("dialog:list:preset").unwrap();
super::test_support::frame(&ctx, super::test_support::pointer(at, true), &mut draw);
super::test_support::frame(&ctx, super::test_support::pointer(at, false), &mut draw);
assert!(picked);
}
}
#[test]
fn many_draggable_samples_wrap_inside_the_available_width() {
let ctx = crate::fonts::test_context();
let mut rects = Vec::new();
let mut bounds = egui::Rect::NOTHING;
super::test_support::frame(&ctx, vec![], |ui| {
ui.set_width(Tokens::get().form_label_width * 2.0);
scope(ui, |ui| {
bounds = ui.available_rect_before_wrap();
swatch_grid(ui, &(0..20).collect::<Vec<_>>(), |ui, index| {
let response = color_swatch(ui, ui.scope_id().with(index), Tokens::get().accent, false, "Sample", *index);
rects.push(response.rect);
});
});
});
assert_eq!(rects.len(), 20);
assert!(rects.iter().all(|rect| rect.right() <= bounds.right() && rect.width() == Tokens::get().control_height + Tokens::get().space_6));
assert!(rects.last().unwrap().top() > rects.first().unwrap().top(), "samples must wrap to additional rows");
}
#[test]
fn gallery_covers_every_inline_element() {
let root = std::path::Path::new(env!("CARGO_MANIFEST_DIR")).join("src/ui_kit");
let names: std::collections::BTreeSet<_> = ELEMENTS.iter().map(|e| e.name).collect();
assert_eq!(names.len(), ELEMENTS.len(), "duplicate gallery entries");
for file in [
"actions.rs",
"checks.rs",
"choice.rs",
"color.rs",
"disclosure.rs",
"fields.rs",
"framing.rs",
"layout.rs",
"look_chain.rs",
"menu.rs",
"metrics.rs",
"preferences_cards.rs",
"radial.rs",
"reports.rs",
"sphere.rs",
"status.rs",
"table.rs",
"theme_picker.rs",
"tree.rs",
] {
let source = std::fs::read_to_string(root.join(file)).unwrap();
let ast = syn::parse_file(&source).unwrap();
for item in ast.items {
if let syn::Item::Fn(item) = item
&& matches!(&item.vis, syn::Visibility::Restricted(v) if v.path.is_ident("crate"))
{
let name = item.sig.ident.to_string();
// Inherited labels, state keys and size measurements do not render elements.
if !matches!(name.as_str(), "eye_drag_id" | "icon_label_width" | "label" | "placement_field_content_size") {
assert!(names.contains(name.as_str()), "{file}: {name} needs a gallery entry");
}
}
}
}
}
#[cfg(test)]
fn history_seam_example(ui: &mut Ui, state: HistoryHandleState) {
let t = Tokens::get();
let allocation = ui.allocate_space(vec2(280.0, 250.0)).1;
for (names, offset) in [(false, 0.0), (true, 125.0)] {
let width = if state == HistoryHandleState::Drag { 112.0 } else { history_width(names) };
// Separate samples vertically so the guide/chip fits within the gallery allocation.
let card = egui::Rect::from_min_size(allocation.min + vec2(t.space_8, offset + t.space_8), vec2(width, 104.0));
ui.painter().rect(card, t.radius_lg, t.panel, egui::Stroke::new(1.0, t.border), egui::StrokeKind::Inside);
HistorySeam::new(card).paint(ui.painter(), card, names, state);
}
}
#[cfg(test)]
fn history_example(ui: &mut Ui, names: bool) {
let mut app = crate::test_support::sample_app();
app.preferences.timeline_left = true;
app.preferences.timeline_left_width = crate::ui_kit::history_width(names);
app.run("timeline.roll_to", serde_json::json!({"position":3})).unwrap();
let feature = app.session.doc.features.get(2).unwrap().id;
app.run("select.set", serde_json::json!({"items":[{"type":"feature","id":feature}]})).unwrap();
let width = crate::timeline_left::strip_width(&app);
let rect = ui.allocate_space(vec2(width, 650.0)).1;
ui.scope_builder(egui::UiBuilder::new().max_rect(rect.shrink(5.0)), |ui| {
let frame = Container::new(ui.ctx(), Surface::Panel).frame(ui.ctx(), Tokens::get().panel, crate::frame::Side::Left);
Container::paint_frame(ui.painter(), frame, rect);
crate::timeline_left::left_timeline(&mut app, ui);
});
}
/// CPU captures of the actual vertical strip and browser, in both themes and widths.
#[test]
fn history_board_in_both_themes_and_widths() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let previous = crate::theme::is_dark();
for dark in [false, true] {
for names in [false, true] {
for collapsed in [false, true] {
for state in [HistoryHandleState::Rest, HistoryHandleState::Hover, HistoryHandleState::Drag] {
crate::theme::set_dark(dark);
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
ctx.global_style_mut(|style| style.animation_time = 0.0);
let mut app = crate::test_support::sample_app();
app.preferences.timeline_left = true;
app.preferences.timeline_left_width = crate::ui_kit::history_width(names);
app.preferences.timeline_left_browser_collapsed = collapsed;
app.run("timeline.roll_to", serde_json::json!({"position":3})).unwrap();
let feature = app.session.doc.features.get(2).unwrap().id;
app.run("select.set", serde_json::json!({"items":[{"type":"feature","id":feature}]})).unwrap();
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(560.0, 680.0));
let mut textures = HashMap::new();
let mut image = None;
let mut drag_start = None;
for pass in 0..9 {
let mut events = vec![];
if pass >= 2 {
let card = app.shell.history.unwrap();
if state == HistoryHandleState::Hover {
events.push(egui::Event::PointerMoved(card.right_center()));
} else if state == HistoryHandleState::Drag {
let start = *drag_start.get_or_insert(egui::pos2(card.right() - 4.0, card.top() + 12.0));
if pass == 2 {
events = crate::test_support::pointer(start, true);
} else if pass == 3 {
events.push(egui::Event::PointerMoved(start + vec2(112.0 - history_width(names), 0.0)));
}
}
}
let mut output = ctx.run_ui(
egui::RawInput { screen_rect: Some(bounds), time: Some(pass as f64 * 0.2), focused: true, events, ..Default::default() },
|ui| {
ui.painter().rect_filled(bounds, 0.0, Tokens::get().viewport_top);
crate::timeline_left::left_panel(&mut app, ui);
crate::browser::browser(&mut app, ui);
},
);
textures_update(&mut textures, &output.textures_delta);
output.textures_delta.clear();
image = Some(raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures));
}
if state == HistoryHandleState::Drag {
assert_eq!(app.shell.history_drag_width, Some(112.0));
assert_eq!(app.shell.history.unwrap().width(), 112.0);
}
assert!(app.shell.history.unwrap().right() < app.shell.browser.unwrap().left());
if let Ok(dir) = std::env::var("SOLIDCRAFT_HISTORY_EVIDENCE") {
std::fs::create_dir_all(&dir).unwrap();
image
.unwrap()
.save(std::path::Path::new(&dir).join(format!(
"history-{}-{}-{}-{:?}.png",
if names { "names" } else { "icons" },
if collapsed { "rail" } else { "browser" },
if dark { "dark" } else { "light" },
state
)))
.unwrap();
}
}
}
}
}
crate::theme::set_dark(previous);
}
/// Render actual egui geometry without a desktop window. Opt-in PNGs are reviewer evidence.
#[test]
fn menu_board_in_both_themes() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut textures = HashMap::new();
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(1100.0, 760.0));
let mut app = crate::test_support::sample_app();
app.last_command = Some(("solid.extrude".into(), "Extrude".into()));
let items = crate::context_menu::radial_items(&app);
let mut image = None;
for _ in 0..3 {
let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(bounds), ..Default::default() }, |ui| {
ui.painter().rect_filled(bounds, 0.0, Tokens::get().panel);
for (name, at) in
[("menu", egui::pos2(30.0, 30.0)), ("menu_submenu", egui::pos2(30.0, 430.0)), ("rename_menu", egui::pos2(630.0, 430.0))]
{
ui.scope_builder(egui::UiBuilder::new().max_rect(egui::Rect::from_min_size(at, vec2(550.0, 350.0))), |ui| {
example(ui, ELEMENTS.iter().find(|e| e.name == name).unwrap());
});
}
ui.allocate_rect(egui::Rect::from_min_size(egui::pos2(630.0, 30.0), vec2(360.0, 360.0)), egui::Sense::hover());
radial_menu(ui, egui::pos2(810.0, 210.0), &items, Some(3));
});
textures_update(&mut textures, &output.textures_delta);
output.textures_delta.clear();
image = Some(raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures));
}
let image = image.unwrap();
assert!(image.pixels().any(|p| p.0[3] != 0));
if let Ok(dir) = std::env::var("SOLIDCRAFT_MENU_EVIDENCE") {
std::fs::create_dir_all(&dir).unwrap();
image.save(std::path::Path::new(&dir).join(if dark { "menus-dark.png" } else { "menus-light.png" })).unwrap();
}
}
crate::theme::set_dark(previous);
}
/// CPU raster of the actual popup in all five board states. No display or GPU required.
#[test]
fn command_search_board_in_both_themes() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
let t = Tokens::get();
assert!(crate::theme::contrast_ratio(t.form_success, t.form_success_fill) >= 4.5);
assert!(crate::theme::contrast_ratio(t.selected_ink, t.accent_soft) >= 4.5);
for (state, query) in [
("empty", ""),
("matches", "fillet"),
("command", r#"solid.extrude {"distance":20}"#),
("invalid", r#"solid.extrude {"distance":}"#),
("no-match", "filletttt"),
] {
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut app = crate::test_support::sample_app();
app.run("parameters.add", serde_json::json!({"name":"fillet_radius","expression":"6 mm"})).unwrap();
app.sbox.used("solid.extrude");
app.sbox.used("solid.fillet");
app.sbox.used("sketch.create");
crate::shortcut_box::open(&mut app, Some(egui::pos2(20.0, 20.0)));
app.sbox.text = query.to_owned();
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(570.0, 650.0));
let mut textures = HashMap::new();
let mut image = None;
for _ in 0..3 {
scenario::clear_handles();
let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(bounds), focused: true, ..Default::default() }, |ui| {
ui.painter().rect_filled(bounds, 0.0, Tokens::get().panel);
crate::shortcut_box::show(&mut app, ui.ctx());
});
textures_update(&mut textures, &output.textures_delta);
output.textures_delta.clear();
image = Some(raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures));
}
let popup = scenario::rect_of("ribbon:search_popup").unwrap();
let field = scenario::rect_of("shortcut:search").unwrap();
assert_eq!(field.height(), 40.0);
assert_eq!(field.width(), 520.0);
assert_eq!(popup.width(), 520.0);
assert_eq!(popup.top(), field.bottom() + Tokens::get().space_6);
assert_eq!(popup.x_range(), field.x_range());
let footer = scenario::rect_of("ribbon:search_footer").unwrap();
assert_eq!(footer, egui::Rect::from_min_max(egui::pos2(popup.left(), footer.top()), popup.right_bottom()));
assert!(bounds.contains_rect(popup), "{state}: {popup:?}");
match state {
"matches" => {
assert!(scenario::handle_at("menu:solid.fillet").is_some());
assert_eq!(scenario::rect_of("menu:solid.fillet").unwrap().height(), 38.0);
assert!(scenario::handle_at("menu:search:design:0").is_some());
}
"command" => assert!(scenario::rect_of("dialog:note:command_parameters").is_some()),
"invalid" => assert!(scenario::rect_of("dialog:report:command_parameters").is_some()),
"no-match" => assert!(scenario::rect_of("dialog:report:search_no_match").is_some()),
_ => {}
}
let image = image.unwrap();
assert!(image.pixels().any(|p| p.0[3] != 0));
if let Ok(dir) = std::env::var("SOLIDCRAFT_SEARCH_EVIDENCE") {
std::fs::create_dir_all(&dir).unwrap();
image.save(std::path::Path::new(&dir).join(format!("search-{state}-{}.png", if dark { "dark" } else { "light" }))).unwrap();
}
}
}
crate::theme::set_dark(previous);
}
/// Exercise the actual surface painters, including deliberately shared artwork whose
/// own accent differs from its tone, tab or feature kind.
#[test]
fn confirm_radial_and_history_rows_keep_multitone_artwork() {
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
let mut cases = vec![
("warning", "extrude", "", "MODEL", Some("construction"), 20),
("danger", "extrude", "", "MODEL", Some("constraint"), 20),
("info", "extrude", "", "MODEL", None, 20),
("warning", "status_warning", "", "MODEL", Some("construction"), 20),
("danger", "delete", "", "MODEL", Some("constraint"), 20),
("danger_menu", "delete", "", "MODEL", Some("constraint"), 16),
("info", "surface_extrude", "", "MODEL", None, 20),
];
for (tab, ramp) in [
("SKETCH", Some("sketch")),
("SURFACE", Some("surface")),
("MESH", Some("mesh")),
("FORM", Some("form")),
("MODEL", None),
("SHEET METAL", None),
("RENDER", None),
("unknown", None),
] {
for surface in ["radial", "radial_hover"] {
cases.push((surface, "extrude", "", tab, ramp, 24));
}
}
for (kind, ramp) in [
("Sketch", Some("sketch")),
("SurfaceExtrudeFeature", Some("surface")),
("MeshFeature", Some("mesh")),
("FormFeature", Some("form")),
("ExtrudeFeature", None),
] {
for (surface, side) in [("history_names", 15), ("history_icons", 19)] {
cases.push((surface, "extrude", kind, "MODEL", ramp, side));
}
}
// Surface feature names without the Surface prefix use the same alias rule
// as the browser's timeline::icon_of assignments.
cases.push(("history_names", "surface_extrude", "ExtrudeFeature", "MODEL", Some("surface"), 15));
cases.push(("history_names", "continuity", "MatchFeature", "MODEL", Some("surface"), 15));
let mut dominant_accents: std::collections::HashMap<&str, std::collections::HashSet<egui::Color32>> = std::collections::HashMap::new();
for (surface, icon, kind, tab, ramp, side) in cases {
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut app = crate::SolveApp::new(Default::default(), Default::default());
app.ui.tab = tab.into();
crate::theme::TabAccent::publish(&app, &ctx);
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(600.0, 360.0));
let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(bounds), ..Default::default() }, |ui| {
ui.painter().rect_filled(bounds, 0.0, Tokens::get().panel);
match surface {
"radial" | "radial_hover" => {
radial_menu(
ui,
egui::pos2(180.0, 180.0),
&[crate::context_menu::Item::action("solid.extrude", "Extrude", icon)],
(surface == "radial_hover").then_some(0),
);
}
"danger_menu" => {
let mut item = MenuItem::new("gallery:danger", "Delete", icon);
item.danger = true;
item.show(ui);
}
"history_names" | "history_icons" => {
let style = if surface == "history_names" { HistoryStyle::Names } else { HistoryStyle::Icons };
HistoryChip {
icon,
name: "Extrude1",
kind,
selected: false,
hovered: false,
dim: false,
suppressed: false,
error: false,
warning: false,
reference: false,
accent: crate::theme::TabAccent::for_tab(&Tokens::get(), "MODEL"),
ink: None,
}
.paint(
ui.painter(),
egui::Rect::from_min_size(egui::pos2(20.0, 20.0), vec2(158.0, style.height())),
style,
);
}
_ => {
let tone = match surface {
"warning" => Tone::Warning,
"danger" => Tone::Danger,
_ => Tone::Info,
};
Confirm::new(ui.scope_id().with("confirm"), icon, "Confirm").tone(tone).content(ui, true, |_| {});
}
}
});
let image = output
.textures_delta
.set
.values()
.flatten()
.find_map(|delta| match &delta.image {
egui::ImageData::Color(image) if image.size == [side, side] => Some(image),
_ => None,
})
.expect("the surface must upload its icon texture");
let colours: std::collections::HashSet<_> = image.pixels.iter().filter(|pixel| pixel.a() == 255).copied().collect();
assert!(colours.len() >= 2, "{surface}/{icon}/{kind}/{tab}, dark={dark}: opaque artwork is a silhouette");
let resolved = crate::icon_svg::resolve(icon);
assert!(!resolved.placeholder, "{icon} needs a master");
let look = crate::icon_svg::Look::themed(dark, ramp.and_then(crate::icon_svg::accent_index), crate::theme::vision());
let doc = crate::icon_svg::doc_for(resolved.master, side as u32).unwrap();
let expected = if matches!(surface, "danger" | "danger_menu") {
crate::icon_svg::render_tinted(doc, look, side as u32)
} else {
crate::icon_svg::render(doc, look, side as u32)
}
.unwrap();
if icon == "delete" {
assert!(colours.len() >= 3, "{surface}, dark={dark}: preserve the lid, faces and outline colours");
let dominant = colours.iter().max_by_key(|colour| image.pixels.iter().filter(|pixel| *pixel == *colour).count()).unwrap();
assert!(
dominant.r() > dominant.g() && dominant.r() > dominant.b(),
"{surface}, dark={dark}: dominant bin colour must be red, got {dominant:?}"
);
}
assert_eq!(
image.as_ref(),
&egui::ColorImage::from_rgba_premultiplied([side, side], expected.data()),
"{surface}/{kind}/{tab}: preserve roles with {ramp:?}"
);
if icon == "extrude" {
let dominant = ["active-1", "active-2", "active-3"]
.map(|role| {
let colour = crate::icon_svg::role_colour(role, look);
(image.pixels.iter().filter(|pixel| **pixel == colour).count(), colour)
})
.into_iter()
.max_by_key(|(count, _)| *count)
.unwrap();
assert!(dominant.0 > 0, "{surface}/{kind}/{tab}: missing accent pixels");
let group = if matches!(surface, "warning" | "danger" | "info") { "confirm" } else { surface };
dominant_accents.entry(group).or_default().insert(dominant.1);
}
if let Ok(dir) = std::env::var("SOLIDCRAFT_ICON_SURFACE_EVIDENCE") {
let mut textures = std::collections::HashMap::new();
super::checks::tests::textures_update(&mut textures, &output.textures_delta);
let capture = super::checks::tests::raster(&ctx, output.shapes.clone(), output.pixels_per_point, bounds, &textures);
std::fs::create_dir_all(&dir).unwrap();
capture
.save(std::path::Path::new(&dir).join(format!("{surface}-{icon}-{kind}-{tab}-{}.png", if dark { "dark" } else { "light" })))
.unwrap();
}
output.textures_delta.clear();
}
for (group, count) in [("confirm", 3), ("radial", 5), ("radial_hover", 5), ("history_names", 5), ("history_icons", 5)] {
assert_eq!(dominant_accents[group].len(), count, "{group}, dark={dark}: dominant accent pixels must differ across mappings");
}
}
crate::theme::set_dark(previous);
}
/// Run the application UI, including the ribbon, and optionally save each transition.
#[test]
fn command_search_ribbon_transition_clips_content_in_both_themes() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
let ctx = crate::fonts::test_context();
ctx.set_visuals(if dark { egui::Visuals::dark() } else { egui::Visuals::light() });
let mut app = crate::test_support::sample_app();
app.home.open = false;
app.ui.dark = dark;
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(1600.0, 1000.0));
let mut textures = HashMap::new();
let mut closed = egui::Rect::NOTHING;
for frame in 0..26 {
if frame == 3 {
crate::shortcut_box::open(&mut app, None);
app.sbox.text = "fillet".into();
} else if frame == 14 {
app.ui.palette_open = false;
app.sbox.text.clear();
}
scenario::clear_handles();
let mut output = ctx.run_ui(
egui::RawInput { screen_rect: Some(bounds), time: Some(f64::from(frame) / 60.0), focused: true, ..Default::default() },
|ui| {
app.logic(ui.ctx());
app.ui(ui);
},
);
textures_update(&mut textures, &output.textures_delta);
output.textures_delta.clear();
let field = scenario::rect_of("ribbon:search").unwrap();
if frame == 2 {
closed = field;
}
if (3..14).contains(&frame) {
let sheet = scenario::rect_of("ribbon:search_popup").unwrap();
assert!(sheet.top() > field.bottom() && sheet.top() <= field.bottom() + Tokens::get().space_6);
// Actual result text is painted with the unfolding sheet's clip,
// rather than relying on a smaller background hiding overflow.
let mut result_texts = 0;
for shape in &output.shapes {
if let egui::Shape::Text(text) = &shape.shape
&& text.galley.job.text.contains("Fillet")
&& text.pos.y >= sheet.top()
&& text.pos.x >= sheet.left()
&& text.pos.x < sheet.right()
{
result_texts += 1;
assert!(shape.clip_rect.bottom() <= sheet.bottom() + 0.5, "{frame}: {:?} vs {sheet:?}", shape.clip_rect);
}
}
if frame == 12 {
assert!(result_texts > 0);
}
}
let state = match frame {
2 => Some("closed"),
4 => Some("opening"),
12 => Some("open"),
15 => Some("closing"),
25 => Some("closed-again"),
_ => None,
};
if frame == 12 {
assert_eq!(field.size(), vec2(520.0, 40.0));
assert_eq!(field.right(), closed.right());
} else if frame == 25 {
assert_eq!(field, closed);
}
if let (Some(state), Ok(dir)) = (state, std::env::var("SOLIDCRAFT_SEARCH_EVIDENCE")) {
std::fs::create_dir_all(&dir).unwrap();
let image = raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures);
image.save(std::path::Path::new(&dir).join(format!("ribbon-{state}-{}.png", if dark { "dark" } else { "light" }))).unwrap();
}
}
}
crate::theme::set_dark(previous);
}
/// Opt-in CPU capture of the actual File view, with public temporary fixtures only.
#[test]
#[ignore = "set SOLIDCRAFT_FILE_EVIDENCE to an output directory and run explicitly"]
fn file_view_application_evidence_in_both_themes_and_widths() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let output_dir = std::path::PathBuf::from(std::env::var("SOLIDCRAFT_FILE_EVIDENCE").expect("set SOLIDCRAFT_FILE_EVIDENCE"));
std::fs::create_dir_all(&output_dir).unwrap();
let fixture_dir = std::env::temp_dir().join(format!("solidcraft-file-evidence-{}", std::process::id()));
std::fs::create_dir_all(&fixture_dir).unwrap();
let path = fixture_dir.join("sample-plate.sc");
let fixture = path.to_string_lossy().to_string();
let mut sample = crate::test_support::sample_app();
sample.session.execute("file.save_as", &serde_json::json!({"path":fixture})).unwrap();
let previous = crate::theme::is_dark();
for dark in [false, true] {
for (name, size) in [("desktop", vec2(1440.0, 1000.0)), ("narrow", vec2(420.0, 1000.0))] {
let ctx = crate::fonts::test_context();
let mut app = crate::test_support::sample_app();
app.home.show(0);
app.home.add_recent(&fixture);
app.session.path = Some(fixture.clone());
let preview = image::load_from_memory(include_bytes!("../../../../assets/samples/exports/0.png")).unwrap().to_rgba8();
let preview = egui::ColorImage::from_rgba_unmultiplied([preview.width() as usize, preview.height() as usize], preview.as_raw());
crate::home::install(&mut app.home, &ctx, &fixture, Some(preview));
app.preferences.theme = if dark { "dark" } else { "light" }.into();
app.ui.dark = dark;
app.recoverable.push(solidcraft_engine::recovery::Entry {
id: "public-evidence".into(),
path: Some("enclosure-lid.sc".into()),
name: "Enclosure lid".into(),
saved_at: web_time::SystemTime::now().duration_since(web_time::UNIX_EPOCH).unwrap().as_secs().saturating_sub(120),
features: 14,
});
crate::theme::set_dark(dark);
crate::theme::apply(&ctx);
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, size);
let mut textures = HashMap::new();
for frame in 0..6 {
let mut input =
egui::RawInput { screen_rect: Some(bounds), time: Some(f64::from(frame) / 60.0), focused: true, ..Default::default() };
app.raw_input_hook(&mut input);
let mut output = ctx.run_ui(input, |ui| {
app.logic(ui.ctx());
app.ui(ui);
});
textures_update(&mut textures, &output.textures_delta);
if frame == 5 {
assert!(app.home.open);
let page = scenario::rect_of("home:page").expect("actual File view allocation");
assert!(bounds.contains_rect(page));
raster(&ctx, output.shapes.clone(), output.pixels_per_point, bounds, &textures)
.save(output_dir.join(format!("file-{name}-{}.png", if dark { "dark" } else { "light" })))
.unwrap();
}
output.textures_delta.clear();
}
}
}
crate::theme::set_dark(previous);
std::fs::remove_file(path).unwrap();
std::fs::remove_dir(fixture_dir).unwrap();
}
/// CPU-rendered review board using the actual gallery widgets, without a window.
#[test]
fn material_widgets_board_in_both_themes() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
let ctx = crate::fonts::test_context();
let bounds = egui::Rect::from_min_size(egui::Pos2::ZERO, vec2(360.0, 240.0));
let mut textures = HashMap::new();
let mut image = None;
for _ in 0..3 {
let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(bounds), ..Default::default() }, |ui| {
ui.set_width(320.0);
ui.painter().rect_filled(bounds, 0.0, Tokens::get().panel);
scope(ui, |ui| {
for name in ["sphere_thumbnail", "look_chain", "look_chain_empty"] {
example(ui, ELEMENTS.iter().find(|e| e.name == name).unwrap());
ui.add_space(Tokens::get().space_12);
}
});
});
textures_update(&mut textures, &output.textures_delta);
output.textures_delta.clear();
image = Some(raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures));
}
let image = image.unwrap();
assert!(image.pixels().any(|p| p.0[3] != 0));
if let Some(dir) = std::env::var_os("SOLIDCRAFT_MATERIAL_WIDGET_EVIDENCE") {
std::fs::create_dir_all(&dir).unwrap();
image.save(std::path::Path::new(&dir).join(if dark { "material-widgets-dark.png" } else { "material-widgets-light.png" })).unwrap();
}
}
crate::theme::set_dark(previous);
}
#[test]
fn tree_icon_actions_keep_repeated_light_rows_independent() {
let ctx = crate::fonts::test_context();
let mut ids = std::collections::HashSet::new();
super::test_support::frame(&ctx, vec![], |ui| {
for index in 0..3 {
let target = format!("light:{index}:visibility");
let actions = [TreeAction { icon: "eye", hover_only: false, label: "Hide", reason: Some("Not available yet"), target: &target }];
let row = tree_row(ui, ui.scope_id().with(index), &Row { compact: true, label: "Directional", actions: &actions, ..Default::default() });
for action in row.actions {
assert!(ids.insert(action.id), "each light action must have its own widget identity");
}
}
});
assert_eq!(ids.len(), 3);
}
#[test]
fn card_looks_follow_selected_hover_disabled_and_focus() {
use super::preferences_cards::{CardFill, CardInk, card_look};
let rest = card_look(false, true, false, false);
assert_eq!((rest.border, rest.fill, rest.ink, rest.bold, rest.alpha, rest.focus_ring), (1.0, CardFill::Face, CardInk::Text, false, 1.0, false));
let hover = card_look(false, true, true, false);
assert_eq!(hover.fill, CardFill::Hover);
let selected = card_look(true, true, true, false);
assert_eq!((selected.border, selected.fill, selected.ink, selected.bold), (2.0, CardFill::Selected, CardInk::Accent, true));
let disabled = card_look(false, false, true, true);
assert_eq!((disabled.fill, disabled.alpha, disabled.focus_ring), (CardFill::Face, 0.5, false), "a disabled card neither hovers nor shows focus");
assert!(card_look(false, true, false, true).focus_ring);
assert!(card_look(true, false, false, false).alpha < 1.0, "a selected card can be disabled too");
}
#[test]
fn cards_size_to_their_container_and_survive_hostile_sizes() {
use super::preferences_cards::card_width;
assert_eq!(card_width(320.0, 4, 10.0), 72.5);
assert_eq!(card_width(320.0, 0, 10.0), 320.0);
for bad in [0.0, -5.0, f32::NAN, f32::INFINITY, f32::MAX] {
let w = card_width(bad, 3, 10.0);
assert!(w.is_finite() && w >= 0.0, "{bad}: {w}");
}
// 400 wide: two arrows and their gaps leave 332, which fits three 88-wide items with gaps.
}
fn sample_card<'a>(label: &'a str, selected: bool, enabled: bool) -> super::preferences_cards::Card<'a> {
super::preferences_cards::Card {
label,
sub: Some("sub"),
selected,
enabled,
options: None,
check: selected,
aspect: 120.0 / 64.0,
figure: &super::preferences_figure_data::paint_tess_normal,
}
}
#[test]
fn picture_cards_and_tiles_click_only_when_enabled_and_never_panic() {
use super::preferences_cards::{picture_card, toggle_tile};
let ctx = crate::fonts::test_context();
for tile in [false, true] {
for enabled in [true, false] {
let mut clicked = false;
let mut at = None;
for pass in 0..3 {
let events = match (pass, at) {
(1, Some(p)) => super::test_support::pointer(p, true),
(2, Some(p)) => super::test_support::pointer(p, false),
_ => vec![],
};
super::test_support::frame(&ctx, events, |ui| {
let card = sample_card("Normal", false, enabled);
let response = if tile { toggle_tile(ui, &card, 120.0) } else { picture_card(ui, &card, 120.0) };
at = Some(response.rect.center());
assert!(response.rect.width() == 120.0 && response.rect.height() > 40.0);
clicked |= response.clicked();
});
}
assert_eq!(clicked, enabled, "tile {tile}, enabled {enabled}");
// Zero, negative and non-finite widths must not panic and must stay finite.
super::test_support::frame(&ctx, vec![], |ui| {
for width in [0.0, -3.0, f32::NAN, f32::INFINITY, 1.0e6] {
let response = if tile {
toggle_tile(ui, &sample_card("x", true, enabled), width)
} else {
picture_card(ui, &sample_card("x", true, enabled), width)
};
assert!(response.rect.is_finite());
}
});
}
}
}
#[test]
fn preset_card_and_help_icon_behave() {
use super::preferences_cards::{help_icon, preset_card};
let ctx = crate::fonts::test_context();
let icon = |p: &egui::Painter, r: egui::Rect, ink: egui::Color32| crate::icons::paint_ink(p, r, "settings", ink);
super::test_support::frame(&ctx, vec![], |ui| {
for width in [0.0, 10.0, 204.0, f32::NAN] {
let response = preset_card(ui, "Performance", "Fastest", true, true, &icon, width);
assert!(response.rect.is_finite());
}
let help = help_icon(ui, "Help text");
assert!(help.rect.width() > 8.0 && help.rect.width() < 20.0);
});
}
/// Light and dark boards of the shared Preferences widgets and of every figure, rendered on the CPU.
/// Set `SOLIDCRAFT_PREFERENCE_WIDGET_EVIDENCE` to a directory to keep the PNGs.
#[test]
fn preference_widgets_and_figures_board_in_both_themes() {
use super::checks::tests::{raster, textures_update};
use std::collections::HashMap;
let previous = crate::theme::is_dark();
for dark in [false, true] {
crate::theme::set_dark(dark);
for (board, names) in [
("widgets", &["picture_card", "toggle_tile", "preset_card", "help_icon", "theme_browser", "preference_theme_thumbnails"][..]),
("figures", &["preference_figures"][..]),
] {
for scale in [1.0_f32, 2.0] {
let ctx = crate::fonts::test_context();
ctx.set_pixels_per_point(scale);
let bounds = egui::Rect::from_min_size(
egui::Pos2::ZERO,
vec2(if board == "figures" { 700.0 } else { 360.0 }, if board == "figures" { 920.0 } else { 800.0 }),
);
let mut textures = HashMap::new();
let mut image = None;
for _ in 0..3 {
let mut output = ctx.run_ui(egui::RawInput { screen_rect: Some(bounds), ..Default::default() }, |ui| {
ui.set_width(bounds.width() - 40.0);
ui.painter().rect_filled(bounds, 0.0, Tokens::get().dialog_body);
ui.add_space(12.0);
scope(ui, |ui| {
for name in names {
example(ui, ELEMENTS.iter().find(|e| e.name == *name).unwrap());
ui.add_space(Tokens::get().space_12);
}
});
});
textures_update(&mut textures, &output.textures_delta);
output.textures_delta.clear();
image = Some(raster(&ctx, output.shapes, output.pixels_per_point, bounds, &textures));
}
let image = image.unwrap();
assert!(image.pixels().any(|p| p.0[3] != 0));
if let Some(dir) = std::env::var_os("SOLIDCRAFT_PREFERENCE_WIDGET_EVIDENCE") {
std::fs::create_dir_all(&dir).unwrap();
let suffix = if scale > 1.0 { "@2x" } else { "" };
image
.save(std::path::Path::new(&dir).join(format!("preferences-{board}-{}{suffix}.png", if dark { "dark" } else { "light" })))
.unwrap();
}
}
}
}
crate::theme::set_dark(previous);
}