aleleba/vectorcraft
1
0
Fork 0
mirror of https://github.com/storytold/vectorcraft.git synced 2026-10-30 20:58:00 -06:00
Code Issues Packages Projects Releases Wiki Activity

Fix #429: Type on a path brackets, flip and Type on a Path Options that keep the type in place

Browse Source 
Type on a path could only be repositioned by Type on a Path Options, whose menu item sent
`{start: 0}`, so OK threw the text to the start of its path; nothing showed or dragged its
brackets. Now, as in Illustrator:

- Type on a path flows between a start and an end bracket (`TextKind::OnPath { end }`, None:
  the end of the path or once round a closed one; `TextKind::path_span`). Flipping
  (`TextObject::flip_on_path`) reverses the path keeping a closed path's first anchor and swaps
  the brackets, so the type keeps its stretch of the path.
- Type on a Path Options gains Align to Path (ascender, descender, center, baseline) and
  Spacing (glyphs spaced as if set that far above the path: closed up round the outside of
  curves, opened up round the inside), laid out by the text engine.
- `type.pathOptions {start?, end?, flip?, effect?, alignToPath?, spacing?, ids?}` sets them in
  one undo step; with none of them it queries. The menu item opens the dialog with the selected
  type's Effect, Flip, Align to Path and Spacing (dropdowns for the choices) and leaves the
  brackets alone, so OK as opened changes nothing.
- The Selection and Direct Selection tools show selected type on a path's path and its start,
  centre and end brackets (`tools::pathtype`, with a bracket cursor): dragging the start or end
  bracket sets where the type runs, dragging the centre bracket slides it along the path and,
  across the path, flips it (Cmd/Ctrl held: it only slides). Each drag is one undo step.
- Arc-length measuring moved to `vectorcraft_geom::ArcPath` (layout, the tools and
  `text.createInPath` share it). SVG export outlines path type whose end bracket, alignment or
  spacing `<textPath>` can't express.
- docs/mcp.md documents the command and the drags; ROADMAP updated; dialog strings translated.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
bflatastic
2026-10-08 12:50:25 +07:00
co-authored by Claude Opus 5.5
parent 696d9f619b
commit 1706e84829
37 changed files with 1191 additions and 146 deletions
Download Patch File Download Diff File Expand all files Collapse all files
crates/engine/src/cmd/textedit.rs
+6 -2
View File
@@ -453,10 +453,10 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
}
let text = str_param(p, "text").unwrap_or("").to_string();
let start = match point_param(p, "at") {
Some(at) if on_path => vectorcraft_text::path_fraction_at(&path.to_bezpath(), at).0,
Some(at) if on_path => vectorcraft_geom::ArcPath::new(path).fraction_at(at).unwrap_or(0.0),
_ => 0.0,
};
let kind = if on_path { TextKind::OnPath { path: path.clone(), start } } else { TextKind::Area { frame: path.clone() } };
let kind = if on_path { TextKind::OnPath { path: path.clone(), start, end: None } } else { TextKind::Area { frame: path.clone() } };
let mut t = TextObject {
vertical: p.get("vertical").and_then(Value::as_bool).unwrap_or(false),
kind,
@@ -465,6 +465,8 @@ fn create_in_path(s: &mut Session, p: &Value) -> Result<Value> {
para: super::create::new_type_para(),
area: Default::default(),
path_effect: Default::default(),
path_align: Default::default(),
path_spacing: 0.0,
wrap: Vec::new(),
cached_bounds: None,
};
@@ -595,6 +597,8 @@ fn headline_tracking(t: &TextObject, target: f64) -> Option<f64> {
para: Default::default(),
area: Default::default(),
path_effect: Default::default(),
path_align: Default::default(),
path_spacing: 0.0,
wrap: Vec::new(),
cached_bounds: None,
};
crates/engine/src/cmd/typemenu.rs
+71 -14
View File
@@ -52,7 +52,7 @@ pub fn specs() -> Vec<CommandSpec> {
"Type on a Path Options…",
["Type", "Type on a Path"],
None,
"{start?: 0..1 (fraction of the path length), flip?: bool (reverse the path), effect?: rainbow|skew|3dRibbon|stairStep|gravity, ids?}",
"{ids?, start?: 0..1, end?: 0..1|null, flip?: bool, effect?: rainbow|skew|3dRibbon|stairStep|gravity, alignToPath?: ascender|descender|center|baseline, spacing?: pt} set the selected type on a path's options: start and end place its start and end brackets as fractions of the path's length (end null: the end of the path, or once round a closed path), and flip then turns the type to the other side of its path (the path runs the other way, the brackets swap ends); none given: query → the first object's {start, end, flip: false, effect, alignToPath, spacing}",
has_selection,
path_options
),
@@ -343,38 +343,95 @@ fn to_point(s: &mut Session, p: &Value) -> Result<Value> {
Ok(ids_json(&ids))
}
/// The options `type.pathOptions` sets; with none of them given it queries.
const PATH_OPTIONS: [&str; 6] = ["start", "end", "flip", "effect", "alignToPath", "spacing"];
/// Type on a path's text, if `n` is type on a path.
fn path_text(n: Option<&vectorcraft_doc::Node>) -> Option<&TextObject> {
match n.map(|n| &n.kind) {
Some(NodeKind::Text(t)) if matches!(t.kind, TextKind::OnPath { .. }) => Some(t),
_ => None,
}
}
/// Type on a Path Options of `t`, as `type.pathOptions` takes them (`flip` is an action: false).
fn path_options_of(t: &TextObject) -> Value {
let (start, end) = match &t.kind {
TextKind::OnPath { start, end, .. } => (*start, *end),
_ => (0.0, None),
};
json!({
"start": start,
"end": end,
"flip": false,
"effect": t.path_effect.id(),
"alignToPath": t.path_align.id(),
"spacing": t.path_spacing,
})
}
fn path_options(s: &mut Session, p: &Value) -> Result<Value> {
const C: &str = "type.pathOptions";
let ids = texts(s, p, C)?;
let start = p.get("start").and_then(Value::as_f64);
let ids: Vec<NodeId> = {
let d = &s.doc()?.doc;
texts(s, p, C)?.into_iter().filter(|i| path_text(d.node(*i)).is_some()).collect()
};
let first = *ids.first().ok_or_else(|| bad(C, "select type on a path"))?;
let options = |s: &Session| -> Result<Value> {
let t = path_text(s.doc()?.doc.node(first)).ok_or_else(|| bad(C, "select type on a path"))?;
Ok(path_options_of(t))
};
if !PATH_OPTIONS.iter().any(|k| p.get(k).is_some()) {
return options(s);
}
// A bracket: a fraction of the path's length.
let fraction = |k: &str| -> Result<Option<f64>> {
match p.get(k) {
None | Some(Value::Null) => Ok(None),
Some(v) => v.as_f64().filter(|x| x.is_finite()).map(|x| Some(x.clamp(0.0, 1.0))).ok_or_else(|| bad(C, format!("`{k}` is a number 0..1"))),
}
};
let start = fraction("start")?;
// `end: null` puts the end bracket back at the end of the path.
let end = p.get("end").map(|_| fraction("end")).transpose()?;
let flip = bool_or(p, "flip", false);
let effect = match str_param(p, "effect") {
Some(e) => Some(vectorcraft_doc::PathEffect::parse(e).ok_or_else(|| bad(C, format!("unknown effect `{e}`")))?),
None => None,
};
let n = s.edit("Type on a Path Options", |d, _| {
let mut n = 0;
let align = match str_param(p, "alignToPath") {
Some(a) => Some(vectorcraft_doc::PathAlign::parse(a).ok_or_else(|| bad(C, format!("unknown alignToPath `{a}`")))?),
None => None,
};
let spacing = p.get("spacing").and_then(Value::as_f64).filter(|x| x.is_finite()).map(|x| x.clamp(-1000.0, 1000.0));
s.edit("Type on a Path Options", |d, _| {
for id in &ids {
let Some(NodeKind::Text(t)) = d.node_mut(*id).map(|n| &mut n.kind) else { continue };
let TextKind::OnPath { path, start: st } = &mut t.kind else { continue };
let TextKind::OnPath { start: st, end: en, .. } = &mut t.kind else { continue };
if let Some(v) = start {
*st = v.clamp(0.0, 1.0);
*st = v;
}
if let Some(v) = end {
*en = v;
}
// After the brackets: they are given on the path as it runs before the flip.
if flip {
path.reverse();
t.flip_on_path();
}
if let Some(e) = effect {
t.path_effect = e;
}
n += 1;
if let Some(a) = align {
t.path_align = a;
}
if let Some(v) = spacing {
t.path_spacing = v;
}
refresh_bounds(t);
}
if n == 0 {
return Err(bad(C, "select type on a path"));
}
Ok(n)
Ok(())
})?;
Ok(json!({ "changed": n }))
options(s)
}
// ---------- placeholder / insert ----------