* Test: a text's words follow its text parameters, and so does its cut A sketch text whose words are an expression of text parameters (`Label + '-L'`): a parameter edit and a configuration row that sets the parameter relabel the text, the text's cut follows, and the expression is saved with the design. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PsiqyXWBFGTCX9J51bhysc * Text parameters: a sketch text's words built from them follow every change A design's parameters are numbers; a text's words (a part label, a size code) could only be typed. Text parameters hold words: `parameters.add` or `parameters.change` with `unit: "text"` (the expression is the text, quotes optional), and `sketch.text` and `sketch.edit_text` take `text_expression` (quoted texts and text parameters joined by `+`, `Label + '-L'`) instead of `text`. The text is laid out anew from its expression on every evaluation, so a parameter edit, a configuration row or a script relabels it and the features built on it (a cut, an emboss) follow in the same rebuild. The design file keeps the text parameters and each text's expression (one pending format change); a configuration table's parameter column can be a text parameter; the Parameters dialog lists them under the unit `text`. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> Claude-Session: https://claude.ai/code/session_01PsiqyXWBFGTCX9J51bhysc * Text parameters: the joints' same-but-features check compares the text parameters The joints are solved once per change unless the design differs only in its features (same_but_features, #6372), which names every Document field. The text parameters are a field of their own and change what a text's words evaluate to, so two designs that differ in them are not the same but for their features. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com> --------- Co-authored-by: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -130,6 +130,7 @@ impl Document {
|
||||
/// A column's current value in the design.
|
||||
pub fn config_current(&self, c: &Column) -> Option<String> {
|
||||
match c {
|
||||
Column::Param(n) if self.text_param(n).is_some() => self.text_param(n).map(|p| p.text.clone()),
|
||||
Column::Param(n) => self.all_param_exprs().into_iter().find(|(m, _, _)| m == n).map(|(_, e, kind)| {
|
||||
// Feature literals are stored in base units, unlike newly typed bare
|
||||
// row cells. Capture their unit explicitly before editing in an inch design.
|
||||
@@ -262,6 +263,7 @@ impl Document {
|
||||
}
|
||||
self.configs.columns.iter().zip(&r.cells).all(|(c, v)| match c {
|
||||
Column::Suppress(id) => suppression_cell(v).is_ok_and(|on| self.feature(*id).is_some_and(|f| f.suppressed == on)),
|
||||
Column::Param(name) if self.text_param(name).is_some() => self.text_param(name).is_some_and(|p| p.text == crate::text_params::unquote(v)),
|
||||
Column::Param(name) => {
|
||||
let kind = self
|
||||
.features
|
||||
|
||||
@@ -2518,6 +2518,9 @@ pub struct Document {
|
||||
#[serde(default, skip_serializing_if = "crate::Metadata::is_empty")]
|
||||
pub metadata: crate::Metadata,
|
||||
pub params: Vec<Param>,
|
||||
/// Named texts the words of sketch texts can be built from ([`crate::text_params`]).
|
||||
#[serde(default, skip_serializing_if = "Vec::is_empty")]
|
||||
pub text_params: Vec<crate::text_params::TextParam>,
|
||||
pub features: Vec<Feature>,
|
||||
/// Timeline marker: features at or after this index are rolled back (not evaluated).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
@@ -2791,6 +2794,7 @@ impl Document {
|
||||
units: default_units(),
|
||||
metadata: Default::default(),
|
||||
params: Vec::new(),
|
||||
text_params: Vec::new(),
|
||||
features: Vec::new(),
|
||||
marker: None,
|
||||
next_id: 1,
|
||||
@@ -3474,6 +3478,12 @@ impl Document {
|
||||
/// Add or change a parameter. Fails if the result would not evaluate. A new parameter
|
||||
/// without a unit takes the unit of its value (mm, deg or none).
|
||||
pub fn set_param(&mut self, name: &str, expr_s: &str, unit: Option<&str>, comment: Option<&str>) -> Result<()> {
|
||||
// A text parameter: one with the text unit, or an existing one when no unit is given.
|
||||
match (unit.map(crate::text_params::is_text_unit), self.text_param(name).is_some()) {
|
||||
(Some(true), _) | (None, true) => return self.set_text_param(name, expr_s, comment),
|
||||
(Some(false), true) => return Err(DocError::Invalid(format!("`{name}` is a text parameter"))),
|
||||
_ => {}
|
||||
}
|
||||
if let Some(p) = Self::param_name_problem(name) {
|
||||
return Err(DocError::Invalid(p));
|
||||
}
|
||||
@@ -3694,14 +3704,14 @@ impl Document {
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Give the texts of a sketch the numbers their expressions come to (in place): a text's
|
||||
/// height, place and angle that were typed as expressions. A text's outlines are rebuilt from
|
||||
/// its numbers when the sketch's links are refreshed, so this comes before that. A number
|
||||
/// typed as a number is left as it is.
|
||||
/// Give the texts of a sketch the numbers and words their expressions come to (in place): a
|
||||
/// text's height, place and angle that were typed as expressions, and its words built from
|
||||
/// text parameters. A text's outlines are rebuilt from them when the sketch's links are
|
||||
/// refreshed, so this comes before that. What was typed as such is left as it is.
|
||||
pub fn apply_text_values(&self, vals: &std::collections::BTreeMap<String, expr::Value>, sk: &mut Sketch) -> Result<()> {
|
||||
use crate::eval::val;
|
||||
for link in &mut sk.links {
|
||||
let solidcraft_sketch::LinkSource::Text { at, height, angle, exprs, .. } = &mut link.source else { continue };
|
||||
let solidcraft_sketch::LinkSource::Text { text, at, height, angle, exprs, .. } = &mut link.source else { continue };
|
||||
let number = |e: &Option<String>, kind: Kind, what: &str| -> Result<Option<f64>> {
|
||||
match e {
|
||||
None => Ok(None),
|
||||
@@ -3723,6 +3733,13 @@ impl Document {
|
||||
if exprs.height.is_some() && !(*height > 1e-6 && *height < 1e5) {
|
||||
return Err(DocError::Invalid("a text's height must be positive".into()));
|
||||
}
|
||||
if let Some(e) = &exprs.text {
|
||||
let words = self.eval_words(e).map_err(|error| DocError::Expr(format!("text: {error}")))?;
|
||||
if words.trim().is_empty() || words.chars().count() > solidcraft_sketch::MAX_TEXT_CHARS {
|
||||
return Err(DocError::Invalid(format!("text: `{e}` gives no words, or too many")));
|
||||
}
|
||||
*text = words;
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
+11
-8
@@ -1178,19 +1178,20 @@ pub struct Model {
|
||||
}
|
||||
|
||||
/// Parameters a feature uses directly (inputs, sketch dimensions and the expressions of a
|
||||
/// sketch's texts), sorted.
|
||||
/// sketch's texts, the text parameters of their words included), sorted.
|
||||
fn param_names(f: &Feature) -> Vec<String> {
|
||||
let mut names: Vec<String> = f.kind.expressions().iter().flat_map(|e| expr::references(e)).collect();
|
||||
if let FeatureKind::Sketch { sketch, .. } = &f.kind {
|
||||
names.extend(sketch.constraints.iter().filter_map(|c| c.param.clone()));
|
||||
names.extend(sketch.text_exprs().into_iter().flat_map(|(_, e)| expr::references(e)));
|
||||
names.extend(sketch.text_word_exprs().into_iter().flat_map(|e| crate::text_params::references(e)));
|
||||
}
|
||||
names.sort();
|
||||
names.dedup();
|
||||
names
|
||||
}
|
||||
|
||||
fn fingerprint(prev: u64, f: &Feature, vals: &BTreeMap<String, Value>, rolled_back: bool, steps: &StepDigests) -> u64 {
|
||||
fn fingerprint(doc: &Document, prev: u64, f: &Feature, vals: &BTreeMap<String, Value>, rolled_back: bool, steps: &StepDigests) -> u64 {
|
||||
let mut h = std::collections::hash_map::DefaultHasher::new();
|
||||
prev.hash(&mut h);
|
||||
rolled_back.hash(&mut h);
|
||||
@@ -1198,13 +1199,14 @@ fn fingerprint(prev: u64, f: &Feature, vals: &BTreeMap<String, Value>, rolled_ba
|
||||
hash_feature_json(f, steps, &mut h);
|
||||
for n in param_names(f) {
|
||||
n.hash(&mut h);
|
||||
match vals.get(&n) {
|
||||
Some(v) => {
|
||||
match (vals.get(&n), doc.text_param(&n)) {
|
||||
(Some(v), _) => {
|
||||
v.v.to_bits().hash(&mut h);
|
||||
v.len.hash(&mut h);
|
||||
v.ang.hash(&mut h);
|
||||
}
|
||||
None => 0u8.hash(&mut h),
|
||||
(None, Some(p)) => p.text.hash(&mut h),
|
||||
(None, None) => 0u8.hash(&mut h),
|
||||
}
|
||||
}
|
||||
h.finish()
|
||||
@@ -1381,7 +1383,7 @@ fn chain_fingerprint(
|
||||
steps: &StepDigests,
|
||||
st: Option<&ModelState>,
|
||||
) -> u64 {
|
||||
let mut fp = fingerprint(prev, f, vals, rolled_back, steps) ^ placement_digest(doc, f, st);
|
||||
let mut fp = fingerprint(doc, prev, f, vals, rolled_back, steps) ^ placement_digest(doc, f, st);
|
||||
// Sheet metal features also depend on the rules (and the parameters they use).
|
||||
if f.kind.is_sheet() {
|
||||
let mut h = std::collections::hash_map::DefaultHasher::new();
|
||||
@@ -1420,7 +1422,7 @@ fn context_digest(doc: &Document, vals: &BTreeMap<String, Value>) -> u64 {
|
||||
for f in doc.features.iter().filter(|f| {
|
||||
matches!(f.kind, FeatureKind::ConstructionPlane { .. } | FeatureKind::ConstructionAxis { .. } | FeatureKind::ConstructionPoint { .. })
|
||||
}) {
|
||||
fingerprint(0, f, vals, false, &StepDigests::default()).hash(&mut h);
|
||||
fingerprint(doc, 0, f, vals, false, &StepDigests::default()).hash(&mut h);
|
||||
}
|
||||
doc.units.hash(&mut h);
|
||||
serde_json::to_string(&doc.sheet).unwrap_or_default().hash(&mut h);
|
||||
@@ -1989,7 +1991,8 @@ impl Model {
|
||||
Arc::make_mut(&mut state).reserved_body_names.clone_from(&reserved);
|
||||
}
|
||||
// The same feature on the same inputs: its earlier result.
|
||||
let key = cache_key(f, fp, fingerprint(0, f, &vals, false, &self.step_digests) ^ placement_digest(doc, f, Some(&state)), ctx, &state);
|
||||
let key =
|
||||
cache_key(f, fp, fingerprint(doc, 0, f, &vals, false, &self.step_digests) ^ placement_digest(doc, f, Some(&state)), ctx, &state);
|
||||
let kept = self.kept.0.as_ref().filter(|_| !self.no_cache);
|
||||
if !self.no_cache
|
||||
&& let Some(c) = self.cache.lock().ok().and_then(|mut m| m.get(key)).or_else(|| kept.and_then(|k| k.get(key)))
|
||||
|
||||
@@ -0,0 +1,5 @@
|
||||
//! Text parameters (`text_params`: name, text, comment) and the expression behind a sketch
|
||||
//! text's words (`exprs.text` of a text link, e.g. `Label + '-L'`), whose words are what it gave
|
||||
//! last. Older designs need no transformation: they have neither. The last release refuses the
|
||||
//! newer format number instead of opening a design whose texts would lose their link to the
|
||||
//! parameters.
|
||||
@@ -65,6 +65,7 @@ pub mod render_settings;
|
||||
pub mod render_surface;
|
||||
pub use project3d::iso_grid;
|
||||
pub mod sheet;
|
||||
pub mod text_params;
|
||||
|
||||
pub use assembly::{
|
||||
IDENTITY, MAX_PLACEMENT_DEPTH, MAX_PLACEMENTS, Mat, Occurrence, apply_point, apply_vector, is_identity, map_point_expr, mat_inverse, mat_mul,
|
||||
|
||||
@@ -636,7 +636,7 @@ impl Model {
|
||||
let mut before = Arc::new(ModelState::default());
|
||||
if let Ok(mut cache) = model.cache.lock() {
|
||||
for (f, r) in doc.features.iter().zip(&model.results).filter(|(_, r)| !r.skipped && r.error.is_none()) {
|
||||
let local = fingerprint(0, f, &vals, false, &model.step_digests) ^ placement_digest(doc, f, Some(&before));
|
||||
let local = fingerprint(doc, 0, f, &vals, false, &model.step_digests) ^ placement_digest(doc, f, Some(&before));
|
||||
cache.put(
|
||||
cache_key(f, r.fingerprint, local, ctx, &before),
|
||||
CachedEval {
|
||||
|
||||
@@ -103,6 +103,9 @@ pub struct ParamRow {
|
||||
/// Names this one's expression uses, and names whose expressions use this one.
|
||||
pub uses: Vec<String>,
|
||||
pub used_by: Vec<String>,
|
||||
/// A text parameter's text (its unit is `text`, its value none).
|
||||
#[serde(skip_serializing_if = "Option::is_none")]
|
||||
pub text: Option<String>,
|
||||
}
|
||||
|
||||
fn unit_of(k: Kind) -> &'static str {
|
||||
@@ -129,7 +132,7 @@ impl Document {
|
||||
}
|
||||
|
||||
pub(crate) fn name_taken(&self, n: &str) -> bool {
|
||||
self.param(n).is_some() || self.features.iter().any(|f| f.param_names.iter().any(|x| x == n))
|
||||
self.param(n).is_some() || self.text_param(n).is_some() || self.features.iter().any(|f| f.param_names.iter().any(|x| x == n))
|
||||
}
|
||||
|
||||
/// The next free `dN` name.
|
||||
@@ -289,6 +292,14 @@ impl Document {
|
||||
if expression.len() > 4096 || expression.trim().is_empty() {
|
||||
return Err(DocError::Expr("expression is empty or too long".into()));
|
||||
}
|
||||
if let Some(p) = next.text_params.iter_mut().find(|p| p.name == *name) {
|
||||
let text = crate::text_params::unquote(expression);
|
||||
if p.text != text {
|
||||
changed.insert(name.clone());
|
||||
}
|
||||
p.text = text;
|
||||
continue;
|
||||
}
|
||||
if let Some(p) = next.params.iter_mut().find(|p| p.name == *name) {
|
||||
if p.expr != expression.trim() {
|
||||
changed.insert(name.clone());
|
||||
@@ -349,6 +360,7 @@ impl Document {
|
||||
favorite: self.favorites.contains(&p.name),
|
||||
uses: refs.get(&p.name).cloned().unwrap_or_default(),
|
||||
used_by: used_by(&p.name),
|
||||
text: None,
|
||||
});
|
||||
}
|
||||
for f in &self.features {
|
||||
@@ -369,9 +381,28 @@ impl Document {
|
||||
favorite: self.favorites.contains(name),
|
||||
uses: refs.get(name).cloned().unwrap_or_default(),
|
||||
used_by: used_by(name),
|
||||
text: None,
|
||||
});
|
||||
}
|
||||
}
|
||||
for p in &self.text_params {
|
||||
let readers = self.features_reading_texts(&BTreeSet::from([p.name.clone()]));
|
||||
rows.push(ParamRow {
|
||||
name: p.name.clone(),
|
||||
expression: p.text.clone(),
|
||||
unit: crate::text_params::TEXT_UNIT.into(),
|
||||
value: None,
|
||||
error: None,
|
||||
comment: p.comment.clone(),
|
||||
source: "user",
|
||||
feature: None,
|
||||
input: None,
|
||||
favorite: self.favorites.contains(&p.name),
|
||||
uses: Vec::new(),
|
||||
used_by: readers.iter().filter_map(|id| self.feature(*id)).map(|f| format!("Feature:{}", f.name)).collect(),
|
||||
text: Some(p.text.clone()),
|
||||
});
|
||||
}
|
||||
rows
|
||||
}
|
||||
|
||||
@@ -498,6 +529,9 @@ impl Document {
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
if unit.map_or(self.text_param(name).is_some(), crate::text_params::is_text_unit) {
|
||||
return self.set_text_param(name, expr_s, comment);
|
||||
}
|
||||
if let Some(p) = Self::param_name_problem(name) {
|
||||
return Err(DocError::Invalid(p));
|
||||
}
|
||||
@@ -709,6 +743,9 @@ impl Document {
|
||||
out.push(ParamUser::Feature { feature: f.id, name: f.name.clone(), input: what.to_string() });
|
||||
}
|
||||
}
|
||||
if sketch.text_word_exprs().iter().any(|e| crate::text_params::references(e).iter().any(|r| r == name)) {
|
||||
out.push(ParamUser::Feature { feature: f.id, name: f.name.clone(), input: "Text".into() });
|
||||
}
|
||||
}
|
||||
}
|
||||
for (joint, input, e) in self.assembly.exprs() {
|
||||
@@ -740,6 +777,9 @@ impl Document {
|
||||
|
||||
/// Remove a stored parameter; refused while something uses it (the error lists the users).
|
||||
pub fn remove_param(&mut self, name: &str) -> Result<()> {
|
||||
if self.text_param(name).is_some() {
|
||||
return self.remove_text_param(name);
|
||||
}
|
||||
if self.param(name).is_none() {
|
||||
if self.features.iter().any(|f| f.param_names.iter().any(|n| n == name)) {
|
||||
return Err(DocError::Invalid(format!("`{name}` is a feature's input: delete or edit the feature instead")));
|
||||
@@ -774,6 +814,12 @@ impl Document {
|
||||
return Err(DocError::Invalid(format!("there is already a parameter `{new}`")));
|
||||
}
|
||||
let mut n = 0;
|
||||
let text = self.text_param(old).is_some();
|
||||
for p in &mut self.text_params {
|
||||
if p.name == old {
|
||||
p.name = new.to_string();
|
||||
}
|
||||
}
|
||||
for p in &mut self.params {
|
||||
if p.name == old {
|
||||
p.name = new.to_string();
|
||||
@@ -825,6 +871,13 @@ impl Document {
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
for e in sketch.text_word_exprs_mut() {
|
||||
let r = crate::text_params::rename_reference(e, old, new);
|
||||
if r != *e {
|
||||
*e = r;
|
||||
n += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
if self.favorites.remove(old) {
|
||||
@@ -839,9 +892,11 @@ impl Document {
|
||||
for rule in &mut self.configs.rules {
|
||||
rule.rename_parameter(old, new);
|
||||
}
|
||||
// A text parameter's cells are texts, not expressions.
|
||||
let texts: BTreeSet<String> = self.text_params.iter().map(|p| p.name.clone()).collect();
|
||||
for r in &mut self.configs.rows {
|
||||
for (column, cell) in self.configs.columns.iter().zip(&mut r.cells) {
|
||||
if matches!(column, crate::config::Column::Param(_)) {
|
||||
if !text && matches!(column, crate::config::Column::Param(c) if !texts.contains(c)) {
|
||||
*cell = expr::rename_reference(cell, old, new);
|
||||
}
|
||||
}
|
||||
@@ -886,6 +941,10 @@ impl Document {
|
||||
p.comment = comment.to_string();
|
||||
return Ok(());
|
||||
}
|
||||
if let Some(p) = self.text_params.iter_mut().find(|p| p.name == name) {
|
||||
p.comment = comment.to_string();
|
||||
return Ok(());
|
||||
}
|
||||
if !self.name_taken(name) {
|
||||
return Err(DocError::Unknown(format!("parameter `{name}`")));
|
||||
}
|
||||
@@ -907,6 +966,7 @@ impl Document {
|
||||
names.extend(sketch.constraints.iter().filter_map(|c| c.param.clone()));
|
||||
names.extend(sketch.text_exprs().into_iter().flat_map(|(_, e)| expr::references(e)));
|
||||
names.extend(sketch.patterns.iter().filter_map(|p| p.count_expression.as_deref()).flat_map(expr::references));
|
||||
names.extend(sketch.text_word_exprs().into_iter().flat_map(|e| crate::text_params::references(e)));
|
||||
}
|
||||
// Sheet metal and plastic features rebuild when their rules' parameters change (#4420).
|
||||
if f.kind.is_sheet() {
|
||||
@@ -948,6 +1008,7 @@ impl Document {
|
||||
if let FeatureKind::Sketch { sketch, .. } = &f.kind {
|
||||
hit |= sketch.constraints.iter().any(|c| c.param.as_ref().is_some_and(|p| affected.contains(p)));
|
||||
hit |= sketch.text_exprs().iter().any(|(_, e)| expr::references(e).iter().any(|r| affected.contains(r)));
|
||||
hit |= sketch.text_word_exprs().iter().any(|e| crate::text_params::references(e).iter().any(|r| affected.contains(r)));
|
||||
}
|
||||
if hit {
|
||||
out.push(f.id);
|
||||
|
||||
@@ -688,7 +688,11 @@ fn refresh_links_in(
|
||||
}
|
||||
sk.set_link_source(&l.id, r.source);
|
||||
let _ = sk.set_link_wires(&l.id, &r.wires);
|
||||
// Words built from text parameters change shape when the parameters do: that
|
||||
// rebuild is the text following them, not a reference that changed under it.
|
||||
let words_follow = matches!(&l.source, LinkSource::Text { exprs, .. } if exprs.text.is_some());
|
||||
match sk.update_link(&l.id, &r.geom) {
|
||||
Ok(true) if words_follow => {}
|
||||
Ok(true) => warn.push(format!("projected {} changed shape and was rebuilt", l.source.describe())),
|
||||
Ok(false) if r.moved => warn.push(format!("projected {} was re-found on the nearest geometry", l.source.describe())),
|
||||
Ok(false) => {}
|
||||
|
||||
@@ -0,0 +1,252 @@
|
||||
//! Text parameters: named texts (`Label` = `TAG-1`) that the words of a sketch text can be built
|
||||
//! from, by an expression that joins them and quoted texts with `+` (`Label + '-L'`). They are
|
||||
//! kept apart from the number parameters: a text has no unit and no number expression reads it.
|
||||
//! A parameter edit or a configuration row that sets one relabels every text built from it, and
|
||||
//! the features that use those texts follow in the same rebuild.
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
use crate::{DocError, Document, FeatureKind, MAX_PARAMS, Result};
|
||||
|
||||
/// The unit that marks a text parameter where parameters are listed, added or imported.
|
||||
pub const TEXT_UNIT: &str = "text";
|
||||
|
||||
/// Longest text a text parameter holds, and longest words expression.
|
||||
const MAX_LEN: usize = 4096;
|
||||
|
||||
/// A named text.
|
||||
#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
|
||||
pub struct TextParam {
|
||||
pub name: String,
|
||||
pub text: String,
|
||||
#[serde(default, skip_serializing_if = "String::is_empty")]
|
||||
pub comment: String,
|
||||
}
|
||||
|
||||
/// Is `unit` the text unit?
|
||||
pub fn is_text_unit(unit: &str) -> bool {
|
||||
unit.trim() == TEXT_UNIT
|
||||
}
|
||||
|
||||
/// A text as typed for a text parameter: inside matching quotes, what they hold (a quote doubled
|
||||
/// inside stands for one); else the text itself, without surrounding spaces.
|
||||
pub fn unquote(s: &str) -> String {
|
||||
let t = s.trim();
|
||||
for q in ['\'', '"'] {
|
||||
if t.len() >= 2 && t.starts_with(q) && t.ends_with(q) {
|
||||
let inner = t.get(1..t.len() - 1).unwrap_or_default();
|
||||
let doubled = format!("{q}{q}");
|
||||
// Only a text whose inner quotes all come in pairs is one quoted text.
|
||||
if inner.replace(&doubled, "").contains(q) {
|
||||
break;
|
||||
}
|
||||
return inner.replace(&doubled, &q.to_string());
|
||||
}
|
||||
}
|
||||
t.to_string()
|
||||
}
|
||||
|
||||
enum Term {
|
||||
Text(String),
|
||||
Name(String),
|
||||
}
|
||||
|
||||
/// The terms of a words expression with their byte ranges: quoted texts (single or double
|
||||
/// quotes, a quote doubled inside stands for one) and parameter names, joined by `+`.
|
||||
fn terms(s: &str) -> Result<Vec<(Term, usize, usize)>> {
|
||||
if s.len() > MAX_LEN {
|
||||
return Err(DocError::Expr("text expression too long".into()));
|
||||
}
|
||||
let cs: Vec<(usize, char)> = s.char_indices().collect();
|
||||
let at = |i: usize| cs.get(i).map_or(s.len(), |x| x.0);
|
||||
let mut out = Vec::new();
|
||||
let mut i = 0;
|
||||
let mut want_term = true;
|
||||
while let Some(&(_, c)) = cs.get(i) {
|
||||
if c.is_whitespace() {
|
||||
i += 1;
|
||||
} else if !want_term {
|
||||
if c != '+' {
|
||||
return Err(DocError::Expr(format!("unexpected `{c}`: a text expression joins quoted texts and text parameters with +")));
|
||||
}
|
||||
want_term = true;
|
||||
i += 1;
|
||||
} else if c == '\'' || c == '"' {
|
||||
let start = i;
|
||||
let mut text = String::new();
|
||||
i += 1;
|
||||
loop {
|
||||
match cs.get(i).map(|x| x.1) {
|
||||
None => return Err(DocError::Expr(format!("a text in quotes ({c}) is not closed"))),
|
||||
Some(d) if d == c && cs.get(i + 1).is_some_and(|x| x.1 == c) => {
|
||||
text.push(c);
|
||||
i += 2;
|
||||
}
|
||||
Some(d) if d == c => {
|
||||
i += 1;
|
||||
break;
|
||||
}
|
||||
Some(d) => {
|
||||
text.push(d);
|
||||
i += 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
out.push((Term::Text(text), at(start), at(i)));
|
||||
want_term = false;
|
||||
} else if c.is_alphabetic() || c == '_' {
|
||||
let start = i;
|
||||
while cs.get(i).is_some_and(|x| x.1.is_alphanumeric() || x.1 == '_') {
|
||||
i += 1;
|
||||
}
|
||||
out.push((Term::Name(s.get(at(start)..at(i)).unwrap_or_default().to_string()), at(start), at(i)));
|
||||
want_term = false;
|
||||
} else {
|
||||
return Err(DocError::Expr(format!("unexpected `{c}`: a text expression joins quoted texts and text parameters with +")));
|
||||
}
|
||||
}
|
||||
if want_term {
|
||||
let what = if out.is_empty() { "the text expression is empty" } else { "the text expression ends with +" };
|
||||
return Err(DocError::Expr(what.into()));
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
/// The parameters a words expression names (none when it does not parse).
|
||||
pub fn references(s: &str) -> Vec<String> {
|
||||
let mut out: Vec<String> = Vec::new();
|
||||
for (t, _, _) in terms(s).unwrap_or_default() {
|
||||
if let Term::Name(n) = t
|
||||
&& !out.contains(&n)
|
||||
{
|
||||
out.push(n);
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
|
||||
/// The words expression with every reference to `old` renamed to `new` (quoted texts kept).
|
||||
pub fn rename_reference(s: &str, old: &str, new: &str) -> String {
|
||||
let Ok(terms) = terms(s) else { return s.to_string() };
|
||||
let mut out = String::with_capacity(s.len());
|
||||
let mut last = 0;
|
||||
for (t, a, b) in terms {
|
||||
if matches!(&t, Term::Name(n) if n == old) {
|
||||
out.push_str(s.get(last..a).unwrap_or_default());
|
||||
out.push_str(new);
|
||||
last = b;
|
||||
}
|
||||
}
|
||||
out.push_str(s.get(last..).unwrap_or_default());
|
||||
out
|
||||
}
|
||||
|
||||
/// The words an expression comes to, each parameter's text from `lookup`.
|
||||
pub fn eval(s: &str, lookup: &dyn Fn(&str) -> Result<String>) -> Result<String> {
|
||||
let mut out = String::new();
|
||||
for (t, _, _) in terms(s)? {
|
||||
match t {
|
||||
Term::Text(text) => out.push_str(&text),
|
||||
Term::Name(n) => out.push_str(&lookup(&n)?),
|
||||
}
|
||||
if out.len() > MAX_LEN {
|
||||
return Err(DocError::Expr("the text is too long".into()));
|
||||
}
|
||||
}
|
||||
Ok(out)
|
||||
}
|
||||
|
||||
impl Document {
|
||||
pub fn text_param(&self, name: &str) -> Option<&TextParam> {
|
||||
self.text_params.iter().find(|p| p.name == name)
|
||||
}
|
||||
|
||||
/// The words a words expression comes to in this design.
|
||||
pub fn eval_words(&self, e: &str) -> Result<String> {
|
||||
eval(e, &|n| match self.text_param(n) {
|
||||
Some(p) => Ok(p.text.clone()),
|
||||
None if self.name_taken(n) => Err(DocError::Expr(format!("`{n}` is a number parameter: a text's words take text parameters"))),
|
||||
None => Err(DocError::Expr(format!("unknown text parameter `{n}`"))),
|
||||
})
|
||||
}
|
||||
|
||||
/// Set text parameter `name` to `text` (as typed: [`unquote`]), adding it when new.
|
||||
pub fn set_text_param(&mut self, name: &str, text: &str, comment: Option<&str>) -> Result<()> {
|
||||
if let Some(p) = Self::param_name_problem(name) {
|
||||
return Err(DocError::Invalid(p));
|
||||
}
|
||||
if text.len() > MAX_LEN {
|
||||
return Err(DocError::Expr("text too long".into()));
|
||||
}
|
||||
if comment.is_some_and(|c| c.len() > 4096) {
|
||||
return Err(DocError::Invalid("comment too long".into()));
|
||||
}
|
||||
let text = unquote(text);
|
||||
if let Some(p) = self.text_params.iter_mut().find(|p| p.name == name) {
|
||||
p.text = text;
|
||||
if let Some(c) = comment {
|
||||
p.comment = c.to_string();
|
||||
}
|
||||
return Ok(());
|
||||
}
|
||||
if self.name_taken(name) {
|
||||
return Err(DocError::Invalid(format!("`{name}` is a number parameter")));
|
||||
}
|
||||
if self.params.len() + self.text_params.len() >= MAX_PARAMS {
|
||||
return Err(DocError::Invalid("too many parameters".into()));
|
||||
}
|
||||
self.text_params.push(TextParam { name: name.to_string(), text, comment: comment.unwrap_or_default().to_string() });
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// Remove text parameter `name`; refused while a text uses it.
|
||||
pub(crate) fn remove_text_param(&mut self, name: &str) -> Result<()> {
|
||||
let users = self.param_users(name);
|
||||
if !users.is_empty() {
|
||||
let list: Vec<String> = users.iter().map(crate::ParamUser::describe).collect();
|
||||
return Err(DocError::Invalid(format!("`{name}` is used by {}", list.join(", "))));
|
||||
}
|
||||
self.text_params.retain(|p| p.name != name);
|
||||
self.favorites.remove(name);
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/// The sketches whose texts' words read one of `names`.
|
||||
pub(crate) fn features_reading_texts(&self, names: &std::collections::BTreeSet<String>) -> Vec<u64> {
|
||||
self.features
|
||||
.iter()
|
||||
.filter(|f| match &f.kind {
|
||||
FeatureKind::Sketch { sketch, .. } => sketch.text_word_exprs().iter().any(|e| references(e).iter().any(|r| names.contains(r))),
|
||||
_ => false,
|
||||
})
|
||||
.map(|f| f.id)
|
||||
.collect()
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn words_expressions_join_quoted_texts_and_parameters() {
|
||||
let look = |n: &str| match n {
|
||||
"Label" => Ok("TAG-1".to_string()),
|
||||
_ => Err(DocError::Expr(format!("unknown text parameter `{n}`"))),
|
||||
};
|
||||
assert_eq!(eval("Label + '-L'", &look).unwrap(), "TAG-1-L");
|
||||
assert_eq!(eval("\"it's \" + Label", &look).unwrap(), "it's TAG-1");
|
||||
assert_eq!(eval("'it''s'", &look).unwrap(), "it's");
|
||||
assert_eq!(eval("'a+b' + 'c'", &look).unwrap(), "a+bc");
|
||||
for bad in ["", "Label +", "+ 'a'", "Label 'a'", "'open", "Label - 'a'", "Other"] {
|
||||
assert!(eval(bad, &look).is_err(), "{bad}");
|
||||
}
|
||||
assert_eq!(references("Label + 'Label' + Other + Label"), ["Label", "Other"]);
|
||||
assert_eq!(rename_reference("Label+'Label-' + Label", "Label", "Tag"), "Tag+'Label-' + Tag");
|
||||
assert_eq!(unquote(" 'A B' "), "A B");
|
||||
assert_eq!(unquote("\"it''s\""), "it''s");
|
||||
assert_eq!(unquote("'it''s'"), "it's");
|
||||
assert_eq!(unquote("'a' + 'b'"), "'a' + 'b'");
|
||||
assert_eq!(unquote("TAG-1"), "TAG-1");
|
||||
}
|
||||
}
|
||||
@@ -98,7 +98,7 @@ fn column_of(s: &Session, p: &Value, cmd: &str) -> Result<Column> {
|
||||
}
|
||||
}
|
||||
if let Some(n) = str_(p, "param") {
|
||||
if !s.doc.all_param_exprs().iter().any(|(m, _, _)| m == n) {
|
||||
if !s.doc.all_param_exprs().iter().any(|(m, _, _)| m == n) && s.doc.text_param(n).is_none() {
|
||||
return Err(bad(cmd, format!("no parameter `{n}`")));
|
||||
}
|
||||
return Ok(Column::Param(n.to_string()));
|
||||
|
||||
@@ -11,7 +11,8 @@ use crate::{EngineError, Result, Session};
|
||||
|
||||
pub static COMMANDS: &[CommandSpec] = &[
|
||||
CommandSpec::new("parameters.change", "Change Parameters", change_param).at("SOLID", "MODIFY").icon("params").params(
|
||||
"name, expression (number or text), unit?: mm|cm|m|in|ft|deg|rad|\"\" (new parameters default to their value's unit), comment?, \
|
||||
"name, expression (number or text), unit?: mm|cm|m|in|ft|deg|rad|\"\"|text (new parameters default to their value's unit; \
|
||||
a text parameter's expression is its text, quotes round it optional: sketch texts' words are built from it), comment?, \
|
||||
favorite?: bool, new_name?: rename (references follow); or delete: name; or changes: {name: expression, …} (existing \
|
||||
parameters, checked together and rebuilt once, all or nothing) → changed?: {name: value} (with changes), recomputed: features rebuilt, \
|
||||
restored: features whose earlier result for the same inputs was reused (e.g. a value set back), switched?: [{feature, name, suppressed}] \
|
||||
@@ -22,7 +23,9 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
"favorites?: bool (only favourites), filter?: all|user|sketch|feature|favorites → parameters (name, expression, unit, value in its unit, \
|
||||
source, feature/input, comment, favorite, uses, used_by, error) and cycles",
|
||||
),
|
||||
CommandSpec::new("parameters.add", "Add User Parameter", add).icon("new").params("name, expression, unit?, comment?, favorite?: bool"),
|
||||
CommandSpec::new("parameters.add", "Add User Parameter", add)
|
||||
.icon("new")
|
||||
.params("name, expression, unit?: as parameters.change (text: a text parameter, its expression the text), comment?, favorite?: bool"),
|
||||
CommandSpec::new("parameters.rename", "Rename Parameter", rename)
|
||||
.icon("rename")
|
||||
.params("name, new_name (expressions, feature inputs and dimensions that use it follow)"),
|
||||
@@ -53,7 +56,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.icon("params")
|
||||
.noundo()
|
||||
.doc_only()
|
||||
.params("expression, kind?: length|angle|unitless (or unit?: mm|in|deg…) → ok, value (mm/rad), display_value, references, error"),
|
||||
.params("expression, kind?: length|angle|unitless (or unit?: mm|in|deg…; text: the text a text parameter would hold, as `text`) → ok, value (mm/rad), display_value, references, error"),
|
||||
CommandSpec::new("parameters.complete", "Complete Expression", complete)
|
||||
.icon("params")
|
||||
.noundo()
|
||||
@@ -79,7 +82,7 @@ fn failing(s: &Session) -> Vec<Value> {
|
||||
}
|
||||
|
||||
pub(super) fn known(s: &Session, name: &str) -> bool {
|
||||
s.doc.param(name).is_some() || s.doc.features.iter().any(|f| f.param_names.iter().any(|n| n == name))
|
||||
s.doc.param(name).is_some() || s.doc.text_param(name).is_some() || s.doc.features.iter().any(|f| f.param_names.iter().any(|n| n == name))
|
||||
}
|
||||
|
||||
fn change_param(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
@@ -132,6 +135,9 @@ fn change_param(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
}
|
||||
out["name"] = json!(name);
|
||||
out["expression"] = json!(e);
|
||||
if let Some(t) = s.doc.text_param(&name) {
|
||||
out["text"] = json!(t.text);
|
||||
}
|
||||
out["value"] = json!(vals.get(&name).map(|v| v.v));
|
||||
out["display_value"] = json!(s.doc.param_display_value(&vals, &name));
|
||||
out["recomputed"] = json!(s.model.last_recomputed);
|
||||
@@ -217,6 +223,9 @@ fn add(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
s.doc_mut().set_favorite(&name, f)?;
|
||||
}
|
||||
let (vals, _) = s.doc.param_values();
|
||||
if let Some(t) = s.doc.text_param(&name) {
|
||||
return Ok(json!({"name": name, "unit": solidcraft_doc::text_params::TEXT_UNIT, "text": t.text, "value": null}));
|
||||
}
|
||||
Ok(
|
||||
json!({"name": name, "unit": s.doc.param(&name).map(|x| x.unit.clone()), "value": vals.get(&name).map(|v| v.v), "display_value": s.doc.param_display_value(&vals, &name)}),
|
||||
)
|
||||
@@ -335,6 +344,10 @@ fn evaluate(s: &mut Session, p: &Value) -> Result<Value> {
|
||||
let cmd = "expr.evaluate";
|
||||
let e = expr_arg(p, "expression").ok_or_else(|| bad(cmd, "`expression` must be text or a number"))?;
|
||||
let unit = str_(p, "unit");
|
||||
// A text parameter's expression is its text.
|
||||
if unit.is_some_and(solidcraft_doc::text_params::is_text_unit) {
|
||||
return Ok(json!({"ok": true, "kind": "text", "text": solidcraft_doc::text_params::unquote(&e), "references": []}));
|
||||
}
|
||||
if let Some(u) = unit
|
||||
&& expr::unit_info(u).is_none()
|
||||
{
|
||||
|
||||
@@ -101,7 +101,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.enabled(in_sketch)
|
||||
.params("curves: [line ids], value?: bool (default toggles): infinite line type (#1359): construction geometry drawn across the whole view through the line's two points; off, a normal line"),
|
||||
CommandSpec::new("sketch.text", "Text", text).at("SKETCH", "CREATE").icon("sketch_text").enabled(in_sketch).params(concat!(
|
||||
"text: string (\\n breaks lines), at: baseline start [x,y], height?: capital height mm (default 5), angle?: deg; at's x and y, height and angle each take a number or an expression over the design's parameters as a string (\"plate_width / 2\", \"label_size\"): the text keeps the expression, follows the parameters, and returns it in `exprs`; an expression naming no parameter is the number it comes to, a bare number in one is in the design's units, \
|
||||
"text: string (\\n breaks lines), or text_expression: the words built from text parameters (parameters.add with unit text) and quoted texts joined by + (\"Label + '-L'\"): the text keeps it, its words follow the parameters (a parameter edit or a configuration row relabels it) and `exprs` returns it as `text`; at: baseline start [x,y], height?: capital height mm (default 5), angle?: deg; at's x and y, height and angle each take a number or an expression over the design's parameters as a string (\"plate_width / 2\", \"label_size\"): the text keeps the expression, follows the parameters, and returns it in `exprs`; an expression naming no parameter is the number it comes to, a bare number in one is in the design's units, \
|
||||
font?: an installed font's family or full name, or a .ttf/.otf file path (~ and %VAR% expand; default: the built-in Liberation Sans), ",
|
||||
text_style_doc!(),
|
||||
created_doc!()
|
||||
@@ -110,7 +110,7 @@ pub static COMMANDS: &[CommandSpec] = &[
|
||||
.enabled(in_sketch)
|
||||
.live(edit_text_live)
|
||||
.params(concat!(
|
||||
"link: the text's link id (or entity: one of its curves), text?, at?, height?, angle?: deg (numbers or expressions as in sketch.text; a number replaces an expression, and so does moving the text), font?: family or file path (empty: the built-in font), ",
|
||||
"link: the text's link id (or entity: one of its curves), text? or text_expression? (as in sketch.text; typed words replace the expression), at?, height?, angle?: deg (numbers or expressions as in sketch.text; a number replaces an expression, and so does moving the text), font?: family or file path (empty: the built-in font), ",
|
||||
text_style_doc!(),
|
||||
" (each kept when left out); or edits: [{link or entity, text?, at?, …}]: several texts changed together, the design rebuilt once \
|
||||
(all or nothing; returns edits: each one's result); live?: bool: one frame of an interactive change (the sketch is solved, the features after it stay as they were until `sketch.drag_end`)",
|
||||
@@ -199,10 +199,20 @@ type TextValues = (String, Vec2, f64, f64, Option<String>, TextStyle, TextExprs)
|
||||
fn text_source(doc: &solidcraft_doc::Document, p: &Value, cmd: &str, old: Option<TextValues>) -> Result<LinkSource> {
|
||||
let (t0, mut at, mut height, mut angle, f0, s0, mut exprs) =
|
||||
old.unwrap_or((String::new(), Vec2::ZERO, 5.0, 0.0, None, TextStyle::default(), TextExprs::default()));
|
||||
let text = match p.get("text") {
|
||||
None | Some(Value::Null) => t0,
|
||||
Some(Value::String(t)) => t.clone(),
|
||||
Some(_) => return Err(bad(cmd, "`text` must be a string")),
|
||||
let text = match (p.get("text").filter(|v| !v.is_null()), p.get("text_expression").filter(|v| !v.is_null())) {
|
||||
(Some(_), Some(_)) => return Err(bad(cmd, "give `text` or `text_expression`, not both")),
|
||||
(None, None) => t0,
|
||||
(Some(Value::String(t)), None) => {
|
||||
exprs.text = None;
|
||||
t.clone()
|
||||
}
|
||||
(None, Some(Value::String(e))) => {
|
||||
let words = doc.eval_words(e.trim()).map_err(|error| bad(cmd, format!("`text_expression`: {error}")))?;
|
||||
exprs.text = Some(e.trim().to_string());
|
||||
words
|
||||
}
|
||||
(Some(_), None) => return Err(bad(cmd, "`text` must be a string")),
|
||||
(None, Some(_)) => return Err(bad(cmd, "`text_expression` must be a string")),
|
||||
};
|
||||
if text.trim().is_empty() {
|
||||
return Err(bad(cmd, "`text` must not be empty"));
|
||||
@@ -248,7 +258,7 @@ fn text_source(doc: &solidcraft_doc::Document, p: &Value, cmd: &str, old: Option
|
||||
fn text_exprs_json(src: &LinkSource) -> Option<Value> {
|
||||
let LinkSource::Text { exprs, .. } = src else { return None };
|
||||
let mut out = serde_json::Map::new();
|
||||
for (key, e) in [("x", &exprs.x), ("y", &exprs.y), ("height", &exprs.height), ("angle", &exprs.angle)] {
|
||||
for (key, e) in [("x", &exprs.x), ("y", &exprs.y), ("height", &exprs.height), ("angle", &exprs.angle), ("text", &exprs.text)] {
|
||||
if let Some(e) = e {
|
||||
out.insert(key.into(), json!(e));
|
||||
}
|
||||
|
||||
@@ -289,3 +289,111 @@ fn bare_numbers_in_a_text_expression_are_in_the_designs_units() {
|
||||
let r = run(&mut s, "sketch.text", json!({"text": "A", "at": [0, 0], "height": 2}));
|
||||
assert!((stored(&s, r["link"].as_str().unwrap()).1 - 2.0).abs() < 1e-12);
|
||||
}
|
||||
|
||||
/// A 100 x 30 x 10 mm block with a text cut 1 mm into its face, its words given by `words`
|
||||
/// (`{"text": …}` or `{"text_expression": …}`). The text's sketch is `S`; the reply is
|
||||
/// `sketch.text`'s.
|
||||
fn block_with_text(s: &mut Session, words: Value) -> Value {
|
||||
run(s, "sketch.create", json!({"plane": "XY"}));
|
||||
run(s, "sketch.rectangle.two_point", json!({"p0": [0, 0], "p1": [100, 30]}));
|
||||
run(s, "sketch.finish", json!({}));
|
||||
run(s, "solid.extrude", json!({"distance": -10}));
|
||||
run(s, "sketch.create", json!({"plane": "XY", "name": "S"}));
|
||||
let mut p = json!({"at": [5, 10], "height": 8});
|
||||
for (k, v) in words.as_object().unwrap() {
|
||||
p[k] = v.clone();
|
||||
}
|
||||
let r = run(s, "sketch.text", p);
|
||||
run(s, "sketch.finish", json!({}));
|
||||
run(s, "solid.extrude", json!({"distance": -1, "operation": "cut"}));
|
||||
r
|
||||
}
|
||||
|
||||
fn volume(s: &mut Session) -> f64 {
|
||||
run(s, "inspect.measure", json!({}))["total"]["volume_mm3"].as_f64().unwrap()
|
||||
}
|
||||
|
||||
/// The words of the text `link` of sketch `S`, as evaluated.
|
||||
fn words(s: &Session, link: &str) -> String {
|
||||
let id = s.doc.find_feature("S").unwrap().id;
|
||||
let st = s.model.state();
|
||||
let LinkSource::Text { text, .. } = &st.sketch(id).unwrap().sketch.link(link).unwrap().source else { panic!("not a text") };
|
||||
text.clone()
|
||||
}
|
||||
|
||||
/// The expression of the words of the text `link` of sketch `S` (null: typed words).
|
||||
fn word_expr(s: &Session, link: &str) -> Value {
|
||||
serde_json::to_value(stored(s, link).3).unwrap()["text"].clone()
|
||||
}
|
||||
|
||||
/// A text's words can be an expression of text parameters (`Label + '-L'`): a parameter edit,
|
||||
/// or a configuration row that sets the parameter, relabels the text, and a cut of the text
|
||||
/// follows in the same rebuild, as if its words had been typed.
|
||||
#[test]
|
||||
fn a_texts_words_follow_its_text_parameters_and_so_does_its_cut() {
|
||||
let typed = |words: &str| {
|
||||
let mut s = Session::default();
|
||||
block_with_text(&mut s, json!({"text": words}));
|
||||
no_trouble(&s);
|
||||
volume(&mut s)
|
||||
};
|
||||
let same = |a: f64, b: f64, what: &str| assert!((a - b).abs() < 1e-6, "{what}: {a} against {b} typed");
|
||||
let mut s = Session::default();
|
||||
let r = run(&mut s, "parameters.add", json!({"name": "Label", "expression": "IT", "unit": "text"}));
|
||||
assert_eq!((r["unit"].as_str(), r["text"].as_str()), (Some("text"), Some("IT")), "{r}");
|
||||
let r = block_with_text(&mut s, json!({"text_expression": "Label + '-L'"}));
|
||||
let link = r["link"].as_str().unwrap().to_string();
|
||||
assert_eq!(r["exprs"], json!({"text": "Label + '-L'"}), "{r}");
|
||||
no_trouble(&s);
|
||||
assert_eq!(words(&s, &link), "IT-L");
|
||||
same(volume(&mut s), typed("IT-L"), "IT-L");
|
||||
|
||||
// A parameter edit relabels; the cut follows in the same rebuild, and after a save.
|
||||
run(&mut s, "parameters.change", json!({"name": "Label", "expression": "WWM"}));
|
||||
no_trouble(&s);
|
||||
assert_eq!(words(&s, &link), "WWM-L");
|
||||
let wide = typed("WWM-L");
|
||||
same(volume(&mut s), wide, "WWM-L");
|
||||
let mut again = reopened(&s);
|
||||
no_trouble(&again);
|
||||
same(volume(&mut again), wide, "WWM-L reopened");
|
||||
|
||||
// A configuration row sets it like any parameter.
|
||||
run(&mut s, "config.configure", json!({"params": ["Label"]}));
|
||||
run(&mut s, "config.row", json!({"name": "Short", "values": {"Label": "I"}}));
|
||||
run(&mut s, "config.row", json!({"name": "Wide", "values": {"Label": "WWM"}}));
|
||||
run(&mut s, "config.activate", json!({"row": "Short"}));
|
||||
no_trouble(&s);
|
||||
assert_eq!(words(&s, &link), "I-L");
|
||||
same(volume(&mut s), typed("I-L"), "row Short");
|
||||
run(&mut s, "config.activate", json!({"row": "Wide"}));
|
||||
same(volume(&mut s), wide, "row Wide");
|
||||
|
||||
// Listed with its text; a rename follows into the expression; deleting it is refused while
|
||||
// the text uses it.
|
||||
let list = run(&mut s, "parameters.list", json!({}));
|
||||
let row = list["parameters"].as_array().unwrap().iter().find(|r| r["name"] == "Label").cloned().unwrap();
|
||||
assert_eq!((row["unit"].as_str(), row["text"].as_str()), (Some("text"), Some("WWM")), "{row}");
|
||||
run(&mut s, "parameters.rename", json!({"name": "Label", "new_name": "Tag"}));
|
||||
assert_eq!(word_expr(&s, &link), json!("Tag + '-L'"));
|
||||
let users = run(&mut s, "parameters.users", json!({"name": "Tag"}));
|
||||
assert!(users["drives"].to_string().contains("\"S\""), "{users}");
|
||||
let e = s.execute("parameters.delete", &json!({"name": "Tag"})).unwrap_err().to_string();
|
||||
assert!(e.contains("Text"), "{e}");
|
||||
no_trouble(&s);
|
||||
same(volume(&mut s), wide, "after the rename");
|
||||
|
||||
// Words typed as a text replace the expression.
|
||||
run(&mut s, "sketch.edit", json!({"sketch": "S"}));
|
||||
run(&mut s, "sketch.edit_text", json!({"link": link, "text": "OK"}));
|
||||
run(&mut s, "sketch.finish", json!({}));
|
||||
assert_eq!((words(&s, &link).as_str(), word_expr(&s, &link)), ("OK", Value::Null));
|
||||
|
||||
// An expression naming no text parameter, or a number parameter, is refused.
|
||||
run(&mut s, "parameters.add", json!({"name": "W", "expression": "10 mm"}));
|
||||
run(&mut s, "sketch.edit", json!({"sketch": "S"}));
|
||||
for (bad, says) in [("Nope + 'x'", "Nope"), ("W", "W"), ("Tag +", "")] {
|
||||
let e = s.execute("sketch.edit_text", &json!({"link": link, "text_expression": bad})).unwrap_err().to_string();
|
||||
assert!(e.contains(says), "{bad}: {e}");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1432,6 +1432,7 @@ fn same_but_features(a: &Document, b: &Document) -> bool {
|
||||
units,
|
||||
metadata,
|
||||
params,
|
||||
text_params,
|
||||
features: _,
|
||||
marker,
|
||||
next_id,
|
||||
@@ -1465,6 +1466,7 @@ fn same_but_features(a: &Document, b: &Document) -> bool {
|
||||
&& *units == b.units
|
||||
&& *metadata == b.metadata
|
||||
&& *params == b.params
|
||||
&& *text_params == b.text_params
|
||||
&& *marker == b.marker
|
||||
&& *next_id == b.next_id
|
||||
&& *reserved_body_names == b.reserved_body_names
|
||||
|
||||
@@ -91,7 +91,8 @@ pub enum LinkSource {
|
||||
}
|
||||
|
||||
/// The expressions behind a text's numbers that were typed as expressions: its place (`x`, `y`),
|
||||
/// its height and its angle. A number without an expression is the number typed. The numbers
|
||||
/// its height and its angle; and behind its words (`text`), an expression of the design's text
|
||||
/// parameters. A number or text without an expression is the one typed. The numbers and words
|
||||
/// of `LinkSource::Text` are what the expressions gave last: the document evaluates them against
|
||||
/// its parameters before the text's outlines are rebuilt (`Document::apply_text_values`), and
|
||||
/// the sketch crate, which knows no parameters, only keeps them.
|
||||
@@ -105,6 +106,9 @@ pub struct TextExprs {
|
||||
pub height: Option<String>,
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub angle: Option<String>,
|
||||
/// The words: text parameters and quoted texts joined by `+` (`Label + '-L'`).
|
||||
#[serde(default, skip_serializing_if = "Option::is_none")]
|
||||
pub text: Option<String>,
|
||||
}
|
||||
|
||||
impl TextExprs {
|
||||
@@ -112,7 +116,8 @@ impl TextExprs {
|
||||
*self == TextExprs::default()
|
||||
}
|
||||
|
||||
/// The expressions set, each with what it sets.
|
||||
/// The expressions of numbers set, each with what it sets (the words' expression is of
|
||||
/// texts, not numbers: [`TextExprs::text`]).
|
||||
pub fn list(&self) -> Vec<(&'static str, &String)> {
|
||||
[("Text X", &self.x), ("Text Y", &self.y), ("Text height", &self.height), ("Text angle", &self.angle)]
|
||||
.into_iter()
|
||||
@@ -560,6 +565,28 @@ impl Sketch {
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// The expressions of the words of the sketch's texts (of text parameters).
|
||||
pub fn text_word_exprs(&self) -> Vec<&String> {
|
||||
self.links
|
||||
.iter()
|
||||
.filter_map(|l| match &l.source {
|
||||
LinkSource::Text { exprs, .. } => exprs.text.as_ref(),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Mutable view of [`Sketch::text_word_exprs`], for renaming the parameters they refer to.
|
||||
pub fn text_word_exprs_mut(&mut self) -> Vec<&mut String> {
|
||||
self.links
|
||||
.iter_mut()
|
||||
.filter_map(|l| match &mut l.source {
|
||||
LinkSource::Text { exprs, .. } => exprs.text.as_mut(),
|
||||
_ => None,
|
||||
})
|
||||
.collect()
|
||||
}
|
||||
|
||||
/// Mutable view of [`Sketch::text_exprs`], for renaming the parameters they refer to.
|
||||
pub fn text_exprs_mut(&mut self) -> Vec<&mut String> {
|
||||
self.links
|
||||
|
||||
@@ -21,7 +21,7 @@ use crate::ui_kit::{self, Column};
|
||||
/// can't be picked (#3216).
|
||||
pub(crate) const IMPORT_TYPES: &[&str] = &["csv", "json"];
|
||||
|
||||
const UNITS: [&str; 9] = ["mm", "cm", "m", "in", "ft", "deg", "rad", "", "um"];
|
||||
const UNITS: [&str; 10] = ["mm", "cm", "m", "in", "ft", "deg", "rad", "", "um", "text"];
|
||||
|
||||
/// Dialog state (what is being typed; the parameters themselves live in the document).
|
||||
#[derive(Default)]
|
||||
@@ -99,6 +99,8 @@ struct Row {
|
||||
source: String,
|
||||
group: String,
|
||||
favorite: bool,
|
||||
/// A text parameter's text.
|
||||
text: Option<String>,
|
||||
}
|
||||
|
||||
fn rows(app: &mut SolveApp) -> Vec<Row> {
|
||||
@@ -134,6 +136,7 @@ fn rows(app: &mut SolveApp) -> Vec<Row> {
|
||||
error: r.get("error").and_then(Value::as_str).map(str::to_string),
|
||||
comment: s(r, "comment"),
|
||||
favorite: r.get("favorite").and_then(Value::as_bool).unwrap_or(false),
|
||||
text: r.get("text").and_then(Value::as_str).map(str::to_string),
|
||||
source,
|
||||
group,
|
||||
name,
|
||||
@@ -146,7 +149,7 @@ fn show_value(r: &Row) -> String {
|
||||
match r.value {
|
||||
Some(v) if r.unit.is_empty() => format!("{v:.4}"),
|
||||
Some(v) => format!("{v:.4} {}", r.unit),
|
||||
None => "—".into(),
|
||||
None => r.text.clone().unwrap_or_else(|| "—".into()),
|
||||
}
|
||||
}
|
||||
|
||||
@@ -365,6 +368,9 @@ fn model_group(app: &mut SolveApp, ui: &mut egui::Ui, d: &mut ParamsDialog, grou
|
||||
/// Live check of an expression typed for a parameter of this unit: Ok(shown value) or the message.
|
||||
fn check(app: &mut SolveApp, e: &str, unit: &str) -> Result<String, String> {
|
||||
let r = app.session.execute("expr.evaluate", &json!({"expression": e, "unit": unit})).map_err(|e| e.to_string())?;
|
||||
if let Some(text) = r["text"].as_str() {
|
||||
return Ok(text.to_string());
|
||||
}
|
||||
if r["ok"].as_bool().unwrap_or(false) {
|
||||
let v = r["display_value"].as_f64().unwrap_or(0.0);
|
||||
Ok(if unit.is_empty() { format!("{v:.4}") } else { format!("{v:.4} {unit}") })
|
||||
|
||||
Reference in New Issue
Block a user