SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Structured configuration rule editing and non-mutating row preview.
use crate::SolveApp;
use crate::ui_kit;
use crate::ui_kit::BackingTooltipExt as _;
use egui::Ui;
use serde_json::{Value, json};
use solidcraft_engine::doc::config::{Column, ConfigRule, RuleCondition, RuleEffect, RuleOperator};
#[derive(Clone, Debug)]
pub struct Editor {
rule: ConfigRule,
row: String,
preview: Option<Value>,
preview_revision: u64,
pub(super) new_values: std::collections::BTreeMap<String, String>,
pub(super) adding_row: bool,
pub(super) focus_new_row: bool,
pub(super) drafts: std::collections::BTreeMap<(String, String), String>,
/// The configuration table at a design revision: the command's answer and its shown cells.
pub(super) table: Option<std::sync::Arc<(u64, Value, super::Table)>>,
/// The Add Column menu's filter text, and whether the menu was open last frame (the filter
/// takes focus when the menu opens and is cleared when it closes).
pub(super) column_filter: String,
pub(super) column_menu_open: bool,
}
impl Default for Editor {
fn default() -> Self {
Self {
rule: ConfigRule {
id: String::new(),
name: "New rule".into(),
enabled: true,
length_unit: None,
condition: RuleCondition::Always,
effect: RuleEffect::DriveParameter { parameter: String::new(), expression: "10".into() },
},
row: String::new(),
preview: None,
preview_revision: 0,
new_values: Default::default(),
adding_row: false,
focus_new_row: false,
drafts: Default::default(),
table: None,
column_filter: String::new(),
column_menu_open: false,
}
}
}
fn choose(ui: &mut Ui, id: &str, value: &mut String, options: &[String]) {
let mut labels = vec![crate::i18n::tr_label("Choose…")];
labels.extend(options.iter().map(String::as_str));
let mut selected = options.iter().position(|o| o == value).map_or(0, |i| i + 1);
let before = selected;
let label = match id {
"rule_length_units" => "Length units",
"rule_effect_kind" => "Then",
"condition_kind" => "When",
"effect_parameter" | "range_parameter" | "allowed_parameter" | "condition_parameter" => "Parameter",
"effect_feature" | "condition_feature" => "Feature",
"preview_configuration" => "Configuration",
_ => id,
};
ui_kit::row(ui, label, |ui| ui_kit::dropdown(ui, id, &mut selected, &labels));
if before != selected
&& let Some(choice) = selected.checked_sub(1).and_then(|i| options.get(i))
{
*value = choice.clone();
}
}
fn expression(ui: &mut Ui, label: &str, value: &mut String) {
ui_kit::row(ui, label, |ui| {
ui_kit::text_field(ui, value, label);
});
}
pub(super) fn show(ui: &mut Ui, app: &mut SolveApp, error: &mut Option<String>, editor: &mut Editor) {
if editor.preview_revision != app.session.revision {
editor.preview = None;
}
let rules = app.session.doc.configs.rules.clone();
let parameters: Vec<String> =
app.session.doc.configs.columns.iter().filter_map(|c| if let Column::Param(n) = c { Some(n.clone()) } else { None }).collect();
let all_parameters: Vec<String> = app.session.doc.all_param_exprs().into_iter().map(|p| p.0).collect();
let features: Vec<(u64, String)> = app.session.doc.features.iter().map(|f| (f.id, f.name.clone())).collect();
let suppression_features: Vec<(u64, String)> =
features.iter().filter(|(id, _)| app.session.doc.configs.columns.contains(&Column::Suppress(*id))).cloned().collect();
// A rule's target must be a column of the table (the engine refuses any other), so the Then
// lists leave out what has none; a note then says so, where When lists everything (#10532).
let unlisted_features = suppression_features.len() < features.len();
let unlisted_parameters = all_parameters.iter().any(|p| !parameters.contains(p));
ui_kit::divider(ui, "configuration_rules");
ui_kit::text(ui, crate::i18n::tr_label("Configuration rules"), ui_kit::Text::Heading("rules_heading"));
ui_kit::text(
ui,
crate::i18n::tr_label("Rules run from top to bottom. Matched drives change effective values."),
ui_kit::Text::Note("rules_drives"),
);
ui_kit::text(ui, crate::i18n::tr_label("Matched restrictions check the final values."), ui_kit::Text::Note("rules_restrictions"));
for (index, rule) in rules.iter().enumerate() {
ui.push_id(&rule.id, |ui| {
let summary = match &rule.effect {
RuleEffect::DriveParameter { parameter, expression } => format!("Drives {parameter} = {expression}"),
RuleEffect::DriveSuppression { feature, value } => format!(
"Drives suppression {} = {value}",
features.iter().find(|f| f.0 == *feature).map(|f| f.1.as_str()).unwrap_or("missing feature")
),
RuleEffect::ParameterRange { parameter, minimum, maximum } => format!("Restricts {parameter}: {minimum} through {maximum}"),
RuleEffect::AllowParameterValues { parameter, expressions } => format!("Restricts {parameter}: {}", expressions.join(", ")),
};
let actions_width = ["Edit", "↑", "↓", "Delete"].iter().map(|label| ui_kit::ContentWidth::button(ui, label)).sum::<f32>()
+ crate::theme::Tokens::get().space_4 * 3.0;
let mut enabled = rule.enabled;
if ui_kit::summary_row(ui, &rule.name, &summary, &mut enabled, actions_width, |ui| {
if ui_kit::button(ui, crate::i18n::tr_label("Edit"), ui_kit::Button::Normal).clicked() {
editor.rule = rule.clone();
}
let up = ui_kit::button(ui, "↑", ui_kit::Button::Enabled(index > 0)).backing_on_hover_text(crate::i18n::tr_label("Move earlier"));
crate::scenario::publish_handle(&format!("config:rule:{}:up", rule.id), up.rect.center());
if up.clicked() {
*error = app.run("config.rule", json!({"id":rule.id,"index":index-1})).err();
}
if ui_kit::button(ui, "↓", ui_kit::Button::Enabled(index + 1 < rules.len()))
.backing_on_hover_text(crate::i18n::tr_label("Move later"))
.clicked()
{
*error = app.run("config.rule", json!({"id":rule.id,"index":index+1})).err();
}
if ui_kit::button(ui, crate::i18n::tr_label("Delete"), ui_kit::Button::Normal).clicked() {
*error = app.run("config.rule", json!({"id":rule.id,"delete":true})).err();
}
}) {
let mut updated = rule.clone();
updated.enabled = enabled;
*error = app.run("config.rule", json!({"rule":updated})).err();
}
});
}
ui_kit::section(ui, "rule_editor", "Add or edit rule", false, |ui| {
ui.vertical(|ui| {
expression(ui, "Rule name", &mut editor.rule.name);
ui_kit::checkbox(ui, crate::i18n::tr_label("Enabled"), &mut editor.rule.enabled);
if ui_kit::button(ui, crate::i18n::tr_label("New"), ui_kit::Button::Small).clicked() {
editor.rule = Editor::default().rule;
}
});
let mut length_unit = editor.rule.length_unit.clone().unwrap_or_else(|| app.session.doc.units.clone());
let old_unit = length_unit.clone();
ui.vertical(|ui| {
choose(ui, "rule_length_units", &mut length_unit, &["mm".into(), "cm".into(), "m".into(), "in".into(), "ft".into()]);
});
if length_unit != old_unit {
editor.rule.length_unit = Some(length_unit);
}
condition_editor(ui, &mut editor.rule.condition, &all_parameters, &features, 1);
let mut effect_kind = match editor.rule.effect {
RuleEffect::DriveParameter { .. } => "Drive parameter",
RuleEffect::DriveSuppression { .. } => "Drive suppression",
RuleEffect::ParameterRange { .. } => "Range",
RuleEffect::AllowParameterValues { .. } => "Allowed values",
}
.to_string();
let prior = effect_kind.clone();
ui.vertical(|ui| {
choose(
ui,
"rule_effect_kind",
&mut effect_kind,
&["Drive parameter".into(), "Drive suppression".into(), "Range".into(), "Allowed values".into()],
);
});
if prior != effect_kind {
let parameter = parameters.first().cloned().unwrap_or_default();
editor.rule.effect = match effect_kind.as_str() {
"Drive suppression" => RuleEffect::DriveSuppression { feature: suppression_features.first().map(|f| f.0).unwrap_or(0), value: true },
"Range" => RuleEffect::ParameterRange { parameter, minimum: "0".into(), maximum: "100".into() },
"Allowed values" => RuleEffect::AllowParameterValues { parameter, expressions: vec!["10".into(), "20".into()] },
_ => RuleEffect::DriveParameter { parameter, expression: "10".into() },
};
}
match &mut editor.rule.effect {
RuleEffect::DriveParameter { parameter, expression: value } => {
ui.vertical(|ui| {
choose(ui, "effect_parameter", parameter, ¶meters);
columns_note(ui, unlisted_parameters, "config.rule_parameter_columns");
expression(ui, "Value", value);
});
}
RuleEffect::DriveSuppression { feature, value } => {
ui.vertical(|ui| {
feature_choice(ui, "effect_feature", feature, &suppression_features);
columns_note(ui, unlisted_features, "config.rule_suppression_columns");
ui_kit::checkbox(ui, crate::i18n::tr_label("Suppressed"), value);
});
}
RuleEffect::ParameterRange { parameter, minimum, maximum } => {
choose(ui, "range_parameter", parameter, ¶meters);
columns_note(ui, unlisted_parameters, "config.rule_parameter_columns");
ui.vertical(|ui| {
expression(ui, "Minimum", minimum);
});
ui.vertical(|ui| {
expression(ui, "Maximum", maximum);
});
}
RuleEffect::AllowParameterValues { parameter, expressions } => {
choose(ui, "allowed_parameter", parameter, ¶meters);
columns_note(ui, unlisted_parameters, "config.rule_parameter_columns");
let mut text = expressions.join("; ");
if ui_kit::row(ui, "Allowed expressions, separated by semicolons", |ui| ui_kit::text_field(ui, &mut text, "").1) {
*expressions = text.split(';').map(|s| s.trim().to_string()).collect();
}
}
}
let save = ui_kit::button(ui, "Save Rule", ui_kit::Button::Enabled(!app.session.doc.configs.rows.is_empty()));
crate::scenario::publish_handle("config:save_rule", save.rect.center());
if save.clicked() {
let result = (|| -> Result<(), String> {
let mut rule = editor.rule.clone();
if rule.id.is_empty() {
rule.id = (1..).map(|n| format!("Rule{n}")).find(|id| !rules.iter().any(|r| r.id == *id)).unwrap_or_default();
}
app.run("config.rule", json!({"rule":rule.clone()}))?;
editor.rule = app.session.doc.configs.rules.iter().find(|existing| existing.id == rule.id).cloned().unwrap_or(rule);
Ok(())
})();
*error = result.err();
}
});
ui_kit::section(ui, "preview", "Preview", true, |ui| {
let rows: Vec<String> = app.session.doc.configs.rows.iter().map(|r| r.name.clone()).collect();
if !rows.contains(&editor.row) {
editor.row = app.session.doc.configs.active.clone().or_else(|| rows.first().cloned()).unwrap_or_default();
}
let previous_row = editor.row.clone();
ui.vertical(|ui| {
choose(ui, "preview_configuration", &mut editor.row, &rows);
let preview = ui_kit::button(ui, "Preview Row", ui_kit::Button::Enabled(!editor.row.is_empty()));
crate::scenario::publish_handle("config:preview_row", preview.rect.center());
if preview.clicked() {
match app.session.execute("config.preview", &json!({"row":editor.row})) {
Ok(result) => {
editor.preview = Some(result);
editor.preview_revision = app.session.revision;
*error = None;
}
Err(e) => {
editor.preview = None;
*error = Some(e.to_string());
}
}
}
});
if previous_row != editor.row {
editor.preview = None;
}
if let Some(preview) = &editor.preview {
ui_kit::section(ui, "rule_preview", &format!("Preview: {}", preview["active"].as_str().unwrap_or("row")), false, |ui| {
report(ui, crate::i18n::tr_label("Preview leaves the current design unchanged."));
if let Some(styles) = preview["styles"].as_array() {
for style in styles {
report(
ui,
format!(
"{}: {} (shared definition)",
style["target"].as_str().unwrap_or("Appearance"),
if style["dormant"].as_bool() == Some(true) { "dormant" } else { "resolved" }
),
);
}
}
if let Some(trace) = preview["trace"].as_array() {
for entry in trace {
report(
ui,
format!(
"{} — {}",
entry["name"].as_str().unwrap_or("rule"),
if entry["matched"].as_bool() == Some(true) { "matched" } else { "skipped" }
),
);
if entry["matched"].as_bool() == Some(true)
&& let Ok(effect) = serde_json::from_value::<RuleEffect>(entry["effect"].clone())
{
report(
ui,
match effect {
RuleEffect::DriveParameter { parameter, expression } => format!("Driven: {parameter} = {expression}"),
RuleEffect::DriveSuppression { feature, value } => format!(
"Driven: {} is {}",
features.iter().find(|f| f.0 == feature).map(|f| f.1.as_str()).unwrap_or("feature"),
if value { "suppressed" } else { "unsuppressed" }
),
RuleEffect::ParameterRange { parameter, minimum, maximum } => {
format!("Restricted: {parameter}, {minimum} through {maximum}")
}
RuleEffect::AllowParameterValues { parameter, expressions } => {
format!("Restricted: {parameter}, {}", expressions.join("; "))
}
},
);
}
}
}
if let Some(parameters) = preview["parameters"].as_array() {
for parameter in parameters {
if let Some(name) = parameter["name"].as_str()
&& all_parameters.iter().any(|p| p == name)
{
let response = ui_kit::text(
ui,
&format!("{name} = {}", parameter["expression"].as_str().unwrap_or("")),
ui_kit::Text::Report("preview_parameter", false),
);
crate::scenario::publish_handle(&format!("config:preview:param:{name}"), response.rect.center());
}
}
}
});
}
});
}
/// Under a Then list that leaves some out (`unlisted`): only the table's columns are listed, and
/// how to add one.
fn columns_note(ui: &mut Ui, unlisted: bool, message: &'static str) {
if unlisted {
ui_kit::text(ui, crate::i18n::tr(message), ui_kit::Text::Note(message));
}
}
fn report(ui: &mut Ui, text: impl AsRef<str>) {
ui_kit::text(ui, crate::i18n::tr_label(text.as_ref()), ui_kit::Text::Report("rule_report", false));
}
fn feature_choice(ui: &mut Ui, id: &str, feature: &mut u64, features: &[(u64, String)]) {
let options: Vec<_> = features.iter().map(|(_, name)| name.clone()).collect();
let mut selected = features.iter().find(|f| f.0 == *feature).map(|f| f.1.clone()).unwrap_or_default();
choose(ui, id, &mut selected, &options);
if let Some((id, _)) = features.iter().find(|(_, name)| *name == selected) {
*feature = *id;
}
}
fn condition_editor(ui: &mut Ui, condition: &mut RuleCondition, parameters: &[String], features: &[(u64, String)], depth: usize) {
let mut kind = match condition {
RuleCondition::Always => "Always",
RuleCondition::Parameter { .. } => "Parameter",
RuleCondition::Suppression { .. } => "Suppression",
RuleCondition::All { .. } => "All",
RuleCondition::Any { .. } => "Any",
RuleCondition::Not { .. } => "Not",
}
.to_string();
let previous = kind.clone();
let mut choices = vec!["Always".into(), "Parameter".into(), "Suppression".into()];
if depth < 8 {
choices.extend(["All".into(), "Any".into(), "Not".into()]);
}
ui.vertical(|ui| {
choose(ui, "condition_kind", &mut kind, &choices);
});
if previous != kind {
*condition = match kind.as_str() {
"Parameter" => RuleCondition::Parameter {
parameter: parameters.first().cloned().unwrap_or_default(),
operator: RuleOperator::Ge,
expression: "10".into(),
},
"Suppression" => RuleCondition::Suppression { feature: features.first().map(|f| f.0).unwrap_or(0), value: true },
"All" => RuleCondition::All { conditions: vec![RuleCondition::Always] },
"Any" => RuleCondition::Any { conditions: vec![RuleCondition::Always] },
"Not" => RuleCondition::Not { condition: Box::new(RuleCondition::Always) },
_ => RuleCondition::Always,
};
}
match condition {
RuleCondition::Parameter { parameter, operator, expression } => {
ui.vertical(|ui| {
choose(ui, "condition_parameter", parameter, parameters);
let operators = [
("=", RuleOperator::Eq),
("≠", RuleOperator::Ne),
("<", RuleOperator::Lt),
("≤", RuleOperator::Le),
(">", RuleOperator::Gt),
("≥", RuleOperator::Ge),
];
let mut index = operators.iter().position(|(_, op)| op == operator).unwrap_or(0);
let labels: Vec<_> = operators.iter().map(|(label, _)| *label).collect();
ui_kit::row(ui, "Operator", |ui| ui_kit::dropdown(ui, "condition_operator", &mut index, &labels));
if let Some((_, op)) = operators.get(index) {
*operator = *op;
}
ui_kit::row(ui, "Expression", |ui| ui_kit::field(ui, expression));
});
}
RuleCondition::Suppression { feature, value } => {
ui.vertical(|ui| {
feature_choice(ui, "condition_feature", feature, features);
ui_kit::checkbox(ui, crate::i18n::tr_label("Suppressed"), value);
});
}
RuleCondition::All { conditions } | RuleCondition::Any { conditions } => {
let mut remove = None;
for (index, child) in conditions.iter_mut().enumerate() {
ui.push_id(index, |ui| {
ui.indent("condition_group", |ui| {
condition_editor(ui, child, parameters, features, depth + 1);
if ui_kit::button(ui, crate::i18n::tr_label("Remove condition"), ui_kit::Button::Small).clicked() {
remove = Some(index);
}
});
});
}
if let Some(index) = remove {
conditions.remove(index);
}
if ui_kit::button(ui, "Add condition", ui_kit::Button::Enabled(conditions.len() < 32)).clicked() {
conditions.push(RuleCondition::Always);
}
}
RuleCondition::Not { condition } => {
ui.indent("negated_condition", |ui| {
condition_editor(ui, condition, parameters, features, depth + 1);
});
}
RuleCondition::Always => {}
}
}