Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

22.1 KB
Raw Blame
//! Personal Sheet Metal Rules: rules kept in the user's profile and offered by the Sheet Metal
//! Rules manager of every design (#9346). Picking one only fills the open manager; the manager's
//! OK adds it to the design, or updates the design's rule of that name, as for any rule. The
//! design keeps its own copy, so it builds the same where the profile has no such rule.

use serde::{Deserialize, Serialize, de};
use solidcraft_engine::doc::sheet::{AngleDisplay, ReliefShape, SheetRule};
use solidcraft_engine::doc::{DocError, Document, expr};
use std::collections::BTreeMap;

use crate::dialogs::{Dialog, Kind};
use crate::dialogs_sheet::{ANGLE_DISPLAYS, RELIEF_SHAPES, RULE_FIELDS, Sm, design_rules};
use crate::i18n::tr;
use crate::ui_kit::{self, Text};

const MAX_RULES: usize = 64;
/// The longest rule name `sheet.manage_rules` takes.
const MAX_NAME: usize = 128;
const MAX_EXPRESSION: usize = 512;

const INVALID_NAME: &str = "sheet.personal_rules.invalid_name";
const INVALID_VALUES: &str = "sheet.personal_rules.invalid_values";

/// A personal rule: a rule's name and values. Every length carries its unit, so the rule gives
/// the same sheet in a millimetre or an inch design; `Thickness` and other expressions are kept
/// as written.
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
struct Rule {
    name: String,
    thickness: String,
    k_factor: String,
    bend_radius: String,
    relief_width: String,
    relief_depth: String,
    corner_relief: String,
    corner_relief_shape: String,
    hem_gap: String,
    gap: String,
    angle_display: String,
    /// Values a newer version saved. They survive renaming and are never dropped silently: a rule
    /// that has them can't be recalled or overwritten here.
    #[serde(flatten)]
    unknown: BTreeMap<String, serde_json::Value>,
}

fn valid_text(text: &str, max: usize) -> bool {
    text.len() <= max && !text.chars().any(char::is_control)
}

fn valid_name(name: &str) -> bool {
    !name.trim().is_empty() && name == name.trim() && valid_text(name, MAX_NAME)
}

/// The manager's text for a value, by its parameter name (`dialogs_sheet::RULE_FIELDS`).
fn field<'a>(values: &'a [String], key: &str) -> &'a str {
    RULE_FIELDS.iter().position(|(k, _)| *k == key).and_then(|i| values.get(i)).map_or("", |v| v.trim())
}

/// A length as the rule keeps it: a bare number takes the design's unit, and an expression
/// without a unit is read in it, as the manager's OK would; anything else is kept as written.
fn portable_length(text: &str, unit: &str, lookup: &dyn Fn(&str) -> Result<expr::Value, DocError>) -> Result<String, &'static str> {
    let text = text.trim();
    // A definition (`T = 2`) would name a parameter of this design only.
    if text.is_empty() || !valid_text(text, MAX_EXPRESSION) || expr::definition(text).is_some() {
        return Err(INVALID_VALUES);
    }
    if expr::is_bare_number(text) {
        return Ok(format!("{text} {unit}"));
    }
    let value = expr::eval_with(text, lookup).map_err(|_| INVALID_VALUES)?;
    Ok(if value.unitless() { format!("({text}) * 1 {unit}") } else { text.into() })
}

impl Rule {
    /// A value by its parameter name, as `dialogs_sheet::RULE_FIELDS` names them.
    fn value(&self, key: &str) -> Option<&String> {
        Some(match key {
            "thickness" => &self.thickness,
            "k_factor" => &self.k_factor,
            "bend_radius" => &self.bend_radius,
            "relief_width" => &self.relief_width,
            "relief_depth" => &self.relief_depth,
            "corner_relief" => &self.corner_relief,
            "hem_gap" => &self.hem_gap,
            "gap" => &self.gap,
            _ => return None,
        })
    }

    fn expressions(&self) -> [&String; 8] {
        [&self.thickness, &self.k_factor, &self.bend_radius, &self.relief_width, &self.relief_depth, &self.corner_relief, &self.hem_gap, &self.gap]
    }

    fn sheet_rule(&self) -> SheetRule {
        SheetRule {
            name: self.name.clone(),
            thickness: self.thickness.clone(),
            k_factor: self.k_factor.clone(),
            bend_radius: self.bend_radius.clone(),
            relief_width: self.relief_width.clone(),
            relief_depth: self.relief_depth.clone(),
            corner_relief: self.corner_relief.clone(),
            corner_relief_shape: self.corner_relief_shape.clone(),
            hem_gap: self.hem_gap.clone(),
            gap: self.gap.clone(),
            angle_display: self.angle_display.clone(),
        }
    }

    /// The shape of a stored row. Values are evaluated only in a design (capture and the manager's
    /// OK), never when the preferences load.
    fn validate(&self) -> Result<(), &'static str> {
        if !valid_name(&self.name) {
            return Err(INVALID_NAME);
        }
        if self.expressions().into_iter().any(|text| text.trim().is_empty() || !valid_text(text, MAX_EXPRESSION))
            || ReliefShape::parse(&self.corner_relief_shape).is_none()
            || AngleDisplay::parse(&self.angle_display).is_none()
            || self.unknown.len() > 8
            || self.unknown.iter().any(|(key, value)| {
                key.is_empty()
                    || !valid_text(key, 64)
                    || match value {
                        serde_json::Value::String(text) => !valid_text(text, MAX_EXPRESSION),
                        serde_json::Value::Bool(_) | serde_json::Value::Number(_) | serde_json::Value::Null => false,
                        _ => true,
                    }
            })
        {
            return Err(INVALID_VALUES);
        }
        Ok(())
    }

    /// The rule the manager shows, under `name`. The design must accept it as the manager's OK
    /// would: a positive thickness and a K factor from 0 to 1.
    fn capture(sm: &Sm, name: &str, doc: &Document) -> Result<Self, &'static str> {
        let Sm::Rules { values, relief, angles, .. } = sm else {
            return Err(INVALID_VALUES);
        };
        let (vals, _) = doc.param_values();
        let unit = expr::length_unit_or_mm(&doc.units);
        let lookup = |n: &str| vals.get(n).copied().ok_or_else(|| DocError::Expr(format!("unknown parameter `{n}`")));
        let thickness = portable_length(field(values, "thickness"), unit, &lookup)?;
        let t = expr::eval_with(&thickness, &lookup).and_then(|v| v.to_kind(expr::Kind::Length)).map_err(|_| INVALID_VALUES)?;
        // The other values may use the rule's own thickness, as `rule_values` reads them.
        let with_t = |n: &str| if n == "Thickness" && !vals.contains_key("Thickness") { Ok(expr::Value::length(t)) } else { lookup(n) };
        let length = |key: &str| portable_length(field(values, key), unit, &with_t);
        let k_factor = field(values, "k_factor");
        if k_factor.is_empty() || !valid_text(k_factor, MAX_EXPRESSION) || expr::definition(k_factor).is_some() {
            return Err(INVALID_VALUES);
        }
        let rule = Self {
            name: name.trim().into(),
            thickness,
            k_factor: k_factor.into(),
            bend_radius: length("bend_radius")?,
            relief_width: length("relief_width")?,
            relief_depth: length("relief_depth")?,
            corner_relief: length("corner_relief")?,
            corner_relief_shape: RELIEF_SHAPES.get(*relief).copied().unwrap_or("notch").into(),
            hem_gap: length("hem_gap")?,
            gap: length("gap")?,
            angle_display: ANGLE_DISPLAYS.get(*angles).copied().unwrap_or("bend").into(),
            unknown: BTreeMap::new(),
        };
        rule.validate()?;
        doc.rule_values(&vals, &rule.sheet_rule()).map_err(|_| INVALID_VALUES)?;
        Ok(rule)
    }

    fn same_values(&self, other: &Self) -> bool {
        let values = |rule: &Self| {
            let mut rule = rule.clone();
            rule.name.clear();
            rule.unknown.clear();
            rule
        };
        values(self) == values(other)
    }

    /// Fill the manager with this rule: the design's rule of the same name when it has one, else
    /// a new rule by this name. Nothing changes in the design until the manager's OK.
    fn recall(&self, sm: &mut Sm, doc: &Document) -> Result<(), &'static str> {
        self.validate()?;
        if !self.unknown.is_empty() {
            return Err("sheet.personal_rules.unsupported");
        }
        let Sm::Rules { pick, name, values, relief, angles, active, loaded } = sm else {
            return Err(INVALID_VALUES);
        };
        let rules = design_rules(doc);
        *pick = rules.iter().position(|r| r.name == self.name).unwrap_or(rules.len());
        name.clone_from(&self.name);
        *values = RULE_FIELDS.iter().map(|(key, _)| self.value(key).cloned().unwrap_or_default()).collect();
        *relief = RELIEF_SHAPES.iter().position(|s| s.eq_ignore_ascii_case(self.corner_relief_shape.trim())).unwrap_or(0);
        *angles = ANGLE_DISPLAYS.iter().position(|d| d.eq_ignore_ascii_case(self.angle_display.trim())).unwrap_or(0);
        *active = doc.sheet_rule(None).name == self.name || *pick >= rules.len();
        // The manager loads a rule's values only when its Rule box changes: these are now its own.
        *loaded = Some(*pick);
        Ok(())
    }
}

/// Stored as one preference array. A malformed row cannot discard unrelated preferences or valid
/// rows. The rows and every user-controlled string are bounded.
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[serde(transparent)]
pub struct Library(Vec<Rule>);

impl<'de> Deserialize<'de> for Library {
    fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
        struct LibraryVisitor;
        impl<'de> de::Visitor<'de> for LibraryVisitor {
            type Value = Library;
            fn expecting(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
                f.write_str("an array of personal sheet metal rules")
            }
            fn visit_seq<A: de::SeqAccess<'de>>(self, mut seq: A) -> Result<Library, A::Error> {
                let mut library = Library::default();
                for _ in 0..MAX_RULES {
                    let Some(row) = seq.next_element::<serde_json::Value>()? else { return Ok(library) };
                    if let Ok(rule) = serde_json::from_value::<Rule>(row)
                        && rule.validate().is_ok()
                        && library.find(&rule.name).is_none()
                    {
                        library.0.push(rule);
                    }
                }
                while seq.next_element::<de::IgnoredAny>()?.is_some() {}
                Ok(library)
            }
        }
        deserializer.deserialize_seq(LibraryVisitor)
    }
}

impl Library {
    /// Names are unique ignoring case.
    fn find(&self, name: &str) -> Option<usize> {
        let name = name.to_lowercase();
        self.0.iter().position(|rule| rule.name.to_lowercase() == name)
    }

    fn save(&mut self, sm: &Sm, name: &str, doc: &Document) -> Result<(), &'static str> {
        if self.find(name.trim()).is_some() {
            return Err("sheet.personal_rules.name_exists");
        }
        if self.0.len() >= MAX_RULES {
            return Err("sheet.personal_rules.full");
        }
        self.0.push(Rule::capture(sm, name, doc)?);
        Ok(())
    }

    fn modified(&self, selected: &str, sm: &Sm, doc: &Document) -> bool {
        self.find(selected).and_then(|index| self.0.get(index)).is_some_and(|saved| match Rule::capture(sm, &saved.name, doc) {
            Ok(current) => !current.same_values(saved),
            Err(_) => true,
        })
    }

    fn overwrite(&mut self, selected: &str, sm: &Sm, doc: &Document) -> Result<(), &'static str> {
        let index = self.find(selected).ok_or("sheet.personal_rules.missing")?;
        let saved = self.0.get(index).ok_or("sheet.personal_rules.missing")?;
        if !saved.unknown.is_empty() {
            return Err("sheet.personal_rules.unsupported");
        }
        let candidate = Rule::capture(sm, &saved.name, doc)?;
        // Capture and its checks finish before the saved rule is replaced.
        *self.0.get_mut(index).ok_or("sheet.personal_rules.missing")? = candidate;
        Ok(())
    }

    fn rename(&mut self, old: &str, new: &str) -> Result<(), &'static str> {
        let new = new.trim();
        if !valid_name(new) {
            return Err(INVALID_NAME);
        }
        let index = self.find(old).ok_or("sheet.personal_rules.missing")?;
        if self.find(new).is_some_and(|other| other != index) {
            return Err("sheet.personal_rules.name_exists");
        }
        let rule = self.0.get_mut(index).ok_or("sheet.personal_rules.missing")?;
        rule.name = new.into();
        Ok(())
    }
}

/// The name of the rule the manager shows: the design's rule picked, or the new rule's name.
fn shown_name(sm: &Sm, doc: &Document) -> String {
    let Sm::Rules { pick, name, .. } = sm else { return String::new() };
    design_rules(doc).get(*pick).map_or_else(|| name.trim().to_string(), |rule| rule.name.clone())
}

#[derive(Clone)]
struct NamePrompt {
    name: String,
    renaming: bool,
}

#[derive(Clone, Default)]
struct PanelState {
    selected: String,
    prompt: Option<NamePrompt>,
    confirming_delete: bool,
    error: Option<&'static str>,
}

fn panel_id() -> egui::Id {
    egui::Id::unique("personal_sheet_rules_panel")
}

fn rule_manager(d: &mut Dialog) -> Option<&mut Sm> {
    match &mut d.kind {
        Kind::Sheet(sm @ Sm::Rules { .. }) => Some(sm),
        _ => None,
    }
}

/// One section above the Sheet Metal Rules manager's fields. Only the library is kept in the
/// preferences; the selection, errors and the naming prompt belong to this dialog.
pub(crate) fn rows(ui: &mut egui::Ui, d: &mut Dialog, library: &mut Library, doc: &Document, reset: bool) {
    let Some(sm) = rule_manager(d) else { return };
    let id = panel_id();
    let mut state = if reset { PanelState::default() } else { ui.ctx().data_mut(|data| data.get_temp::<PanelState>(id)).unwrap_or_default() };
    ui_kit::section(ui, "personal_sheet_rules", "sheet.personal_rules.title", false, |ui| {
        ui.label(tr("sheet.personal_rules.scope"));
        crate::dialogs::form_row(ui, "sheet.personal_rules.rule", |ui| {
            let before = library.find(&state.selected).map_or(0, |index| index + 1);
            let mut selected = before;
            let dirty = library.modified(&state.selected, sm, doc);
            let display = library.find(&state.selected).and_then(|index| library.0.get(index)).map_or_else(
                || tr("sheet.personal_rules.select").to_string(),
                |rule| {
                    if dirty { format!("* {}", rule.name) } else { rule.name.clone() }
                },
            );
            let height = ui_kit::row_height();
            let width = (ui.available_width() - height - ui.spacing().item_spacing.x).max(1.0);
            ui.allocate_ui_with_layout(egui::vec2(width, height), egui::Layout::left_to_right(egui::Align::Center), |ui| {
                let response = ui_kit::dropdown_menu(ui, "personal_sheet_rule_choice", &display, |ui| {
                    let placeholder = ui_kit::list_picker(ui, "personal_sheet_rules_select", tr("sheet.personal_rules.select"), selected == 0);
                    if placeholder.clicked() {
                        selected = 0;
                    }
                    crate::scenario::publish_handle(
                        &format!("dialog:sheet.personal_rules.rule:{}", tr("sheet.personal_rules.select")),
                        placeholder.rect.center(),
                    );
                    for (index, rule) in library.0.iter().enumerate() {
                        let option = ui_kit::list_picker(ui, &format!("personal_sheet_rule_{index}"), &rule.name, selected == index + 1);
                        if option.clicked() {
                            selected = index + 1;
                        }
                        crate::scenario::publish_handle(&format!("dialog:sheet.personal_rules.rule:{}", rule.name), option.rect.center());
                    }
                });
                response.widget_info(|| {
                    let mut info = egui::WidgetInfo::labeled(egui::Role::ComboBox, ui.is_enabled(), tr("sheet.personal_rules.rule"));
                    info.current_text_value = Some(display.clone());
                    info
                });
            });
            if selected != before {
                let rule = selected.checked_sub(1).and_then(|index| library.0.get(index));
                state.selected = rule.map_or_else(String::new, |rule| rule.name.clone());
                state.error = rule.and_then(|rule| rule.recall(sm, doc).err());
                state.prompt = None;
                state.confirming_delete = false;
            }
            let modified = library.modified(&state.selected, sm, doc);
            ui.add_enabled_ui(modified, |ui| {
                let (rect, _) = ui.allocate_exact_size(egui::vec2(height, height), egui::Sense::hover());
                let save = ui_kit::icon_button_at(ui, rect, "save", tr("sheet.personal_rules.overwrite"));
                crate::scenario::publish_target("dialog:sheet.personal_rules:overwrite", save.rect);
                if save.clicked() {
                    state.error = library.overwrite(&state.selected, sm, doc).err();
                    state.confirming_delete = false;
                }
            });
        });
        let chosen = library.find(&state.selected);
        // Each button is also a handle (`dialog:sheet.personal_rules:<action>`) for scenarios and the
        // control channel.
        let button = |ui: &mut egui::Ui, action: &str, label: &str, enabled: bool| {
            let response = ui_kit::button(ui, label, ui_kit::Button::Enabled(enabled));
            crate::scenario::publish_handle(&format!("dialog:sheet.personal_rules:{action}"), response.rect.center());
            response.clicked()
        };
        ui.horizontal_wrapped(|ui| {
            if button(ui, "save", tr("sheet.personal_rules.save"), true) {
                state.prompt = Some(NamePrompt { name: shown_name(sm, doc), renaming: false });
                state.error = None;
                state.confirming_delete = false;
            }
            if button(ui, "rename", tr("sheet.personal_rules.rename"), chosen.is_some()) {
                state.prompt = Some(NamePrompt { name: state.selected.clone(), renaming: true });
                state.error = None;
                state.confirming_delete = false;
            }
            if button(ui, "delete", tr("sheet.personal_rules.delete"), chosen.is_some()) {
                state.confirming_delete = true;
                state.error = None;
            }
        });
        if state.confirming_delete {
            ui.label(tr("sheet.personal_rules.delete_prompt"));
            ui.horizontal_wrapped(|ui| {
                if button(ui, "confirm_delete", tr("sheet.personal_rules.confirm_delete"), true) {
                    if let Some(index) = library.find(&state.selected) {
                        library.0.remove(index);
                    }
                    state = PanelState::default();
                }
                if ui_kit::button(ui, tr("ui.cancel"), ui_kit::Button::Normal).clicked() {
                    state.confirming_delete = false;
                }
            });
        }
        if state.prompt.is_none()
            && let Some(error) = state.error
        {
            ui_kit::text(ui, tr(error), Text::Report("personal_sheet_rules_error", true));
        }
    });
    ui.ctx().data_mut(|data| data.insert_temp(id, state));
}

/// Global shortcuts run before dialogs. A pending name prompt owns their keyboard even when
/// Escape has already left its text field. Stale state cannot block other tools.
pub(crate) fn name_prompt_open(ctx: &egui::Context, dialog: Option<&Dialog>) -> bool {
    dialog.is_some_and(|d| matches!(&d.kind, Kind::Sheet(Sm::Rules { .. })))
        && ctx.data_mut(|data| data.get_temp::<PanelState>(panel_id())).is_some_and(|state| state.prompt.is_some())
}

/// Drawn after the manager's card, so the prompt owns input and its footer handles. `true` also
/// covers the prompt's frame: its Enter and Cancel never reach the manager.
pub(crate) fn name_prompt(ctx: &egui::Context, d: &mut Dialog, library: &mut Library, doc: &Document) -> bool {
    let Some(sm) = rule_manager(d) else { return false };
    let id = panel_id();
    let mut state = ctx.data_mut(|data| data.get_temp::<PanelState>(id)).unwrap_or_default();
    let Some(mut prompt) = state.prompt.take() else { return false };
    let title = tr(if prompt.renaming { "sheet.personal_rules.rename" } else { "sheet.personal_rules.save" });
    let (closed, action) = ui_kit::Confirm::new(egui::Id::unique("personal_sheet_rule_name"), "save", title)
        .actions(if prompt.renaming { tr("sheet.personal_rules.rename") } else { crate::i18n::tr_label("Save") }, "Cancel", None)
        .show(ctx, true, |ui| {
            ui_kit::row(ui, "sheet.personal_rules.name", |ui| ui_kit::focused_text_field(ui, &mut prompt.name, tr("sheet.personal_rules.name_hint")));
            // Keep an over-long name for a clear error, but bound what the prompt holds.
            if prompt.name.len() > MAX_EXPRESSION {
                let end = prompt.name.char_indices().map(|(index, _)| index).take_while(|index| *index <= MAX_EXPRESSION).last().unwrap_or(0);
                prompt.name.truncate(end);
            }
            if let Some(error) = state.error {
                ui_kit::text(ui, tr(error), Text::Report("personal_sheet_rules_name_error", true));
            }
        });
    ctx.input_mut(|input| {
        input.consume_key(egui::Modifiers::NONE, egui::Key::Enter);
        input.consume_key(egui::Modifiers::NONE, egui::Key::Escape);
    });
    if closed || action == ui_kit::Action::Cancel {
        state.error = None;
    } else if action == ui_kit::Action::Ok {
        state.error = if prompt.renaming { library.rename(&state.selected, &prompt.name).err() } else { library.save(sm, &prompt.name, doc).err() };
        if state.error.is_none() {
            state.selected = prompt.name.trim().into();
        } else {
            state.prompt = Some(prompt);
        }
    } else {
        state.prompt = Some(prompt);
    }
    ctx.data_mut(|data| data.insert_temp(id, state));
    true
}

#[cfg(test)]
#[path = "personal_sheet_rules_tests.rs"]
mod tests;