mirror of
https://github.com/storytold/vectorcraft.git
synced 2026-11-17 22:33:08 +00:00
Selection: loaded text shows a link cursor over an object a click threads it into
With text loaded from a port, the pointer adds a link badge over a closed path, area type or type on a path that a click threads the text into, and keeps the loaded-text cursor over empty canvas and other art. The hover and the click use one target test, the same rules text.thread.add applies to `to`: not the frame the text came from, not a frame already in a thread and not a path inside a compound path. A click on such a frame or path now makes a new frame there instead of a text.thread.add error. Docs: type-parity.md and ui-parity.md no longer say the loaded cursor borrows the I-beam; target-app-parity.md gets a progress line.
This commit is contained in:
@@ -94,6 +94,9 @@ pub enum Cursor {
|
||||
/// The Selection tool loaded with the text of area type or type on a path by a click on its out
|
||||
/// or in port (a click threads it into a path or a new frame, a drag draws the new frame).
|
||||
LoadedText,
|
||||
/// The same loaded Selection tool over a closed path, area type or type on a path that a click
|
||||
/// threads the text into: the loaded text with a link badge.
|
||||
LoadedTextLink,
|
||||
/// The Shape Builder: a crosshair with a plus (merge mode)...
|
||||
ShapeBuilder,
|
||||
/// ...or, with Alt held, a minus (erase mode).
|
||||
|
||||
@@ -170,6 +170,15 @@ shown_when = [
|
||||
hotspot = "Where the new frame's top-left corner goes (the click), or the path clicked."
|
||||
look = "A small block of text lines: the overflow text the pointer carries."
|
||||
|
||||
[[cursor]]
|
||||
id = "LoadedTextLink"
|
||||
group = "Selection"
|
||||
shown_when = [
|
||||
"The Selection tool loaded with text from a port, over a closed path, area type or type on a path that a click threads the text into: not the frame the text came from, not a frame already in a thread and not a path inside a compound path. Over empty canvas or other art the pointer stays the loaded text, and a click there makes a new frame.",
|
||||
]
|
||||
hotspot = "The point of the object's path the click threads the text into."
|
||||
look = "The loaded text's block of lines with two linked chain rings below right."
|
||||
|
||||
# ── Pen family ────────────────────────────────────────────────────────────────────────────────────
|
||||
|
||||
[[cursor]]
|
||||
|
||||
+42
-13
@@ -22,7 +22,8 @@
|
||||
//! bracket drag) cancels it: the art returns to its state at the press.
|
||||
//! Selected area type and type on a path show an in port and an out port. A click on the out port
|
||||
//! loads the pointer with the text ([`Cursor::LoadedText`]): the next click threads it into the
|
||||
//! closed path, area type or type on a path under the pointer, or into a new frame of the same
|
||||
//! closed path, area type or type on a path under the pointer, where the pointer shows the link
|
||||
//! cursor ([`Cursor::LoadedTextLink`]), or into a new frame of the same
|
||||
//! kind, shape and size at the click on empty canvas, and a drag draws a rectangle for the new
|
||||
//! frame (`text.thread.add`), which comes after the clicked one in its thread. A click on the in
|
||||
//! port does the same with the new frame put before it: the story then starts there and flows on
|
||||
@@ -764,21 +765,41 @@ impl SelectionTool {
|
||||
}
|
||||
}
|
||||
|
||||
/// Where the text of `from` goes for a press at `start` released at `end`: a dragged rectangle,
|
||||
/// else the closed path, area type or type on a path pressed on, else a new frame with its
|
||||
/// top-left at `start`.
|
||||
fn thread_params(cx: &ToolContext, from: NodeId, start: Point, end: Point) -> Value {
|
||||
/// The rectangle a press at `start` dragged to `end` draws for a new frame, None when the drag
|
||||
/// is too small to be one (a click).
|
||||
fn new_frame_rect(cx: &ToolContext, start: Point, end: Point) -> Option<Rect> {
|
||||
let r = Rect::from_points(start, end);
|
||||
if r.width() > cx.tol(6.0) && r.height() > cx.tol(6.0) {
|
||||
return json!({ "from": from.0, "rect": [r.x0, r.y0, r.width(), r.height()] });
|
||||
}
|
||||
(r.width() > cx.tol(6.0) && r.height() > cx.tol(6.0)).then_some(r)
|
||||
}
|
||||
|
||||
/// The object a click at `p` threads the text of `from` into: the closed path, area type or type
|
||||
/// on a path drawn there, other than `from`, not inside a compound path and in no thread yet, as
|
||||
/// `text.thread.add` takes for `to`. None elsewhere, where the click makes a new frame, and when
|
||||
/// `from` can no longer thread.
|
||||
fn thread_target(cx: &ToolContext, from: NodeId, p: Point) -> Option<NodeId> {
|
||||
use vectorcraft_doc::NodeKind;
|
||||
let d = cx.doc;
|
||||
let frame = |n: &vectorcraft_doc::Node| {
|
||||
is_threadable(n) || matches!(&n.kind, vectorcraft_doc::NodeKind::Path { path, .. } if path.subpaths.first().is_some_and(|s| s.closed))
|
||||
is_threadable(n) || matches!(&n.kind, NodeKind::Path { path, .. } if path.subpaths.first().is_some_and(|s| s.closed))
|
||||
};
|
||||
// The art the text flows into: what is drawn, not a clipping path's outline.
|
||||
let to =
|
||||
hit_test(cx.doc, start, cx.hit_options()).map(|h| h.top_object(cx.isolation)).filter(|id| *id != from && cx.doc.node(*id).is_some_and(frame));
|
||||
match to {
|
||||
let id = hit_test(d, p, cx.hit_options()).map(|h| h.top_object(cx.isolation))?;
|
||||
let ok = id != from
|
||||
&& d.node(from).is_some_and(is_threadable)
|
||||
&& d.node(id).is_some_and(frame)
|
||||
&& !d.parent_of(id).and_then(|i| d.node(i)).is_some_and(|n| matches!(n.kind, NodeKind::Compound { .. }))
|
||||
&& !d.text_threads.iter().any(|t| t.contains(&id));
|
||||
ok.then_some(id)
|
||||
}
|
||||
|
||||
/// Where the text of `from` goes for a press at `start` released at `end`: a dragged rectangle,
|
||||
/// else the object pressed on that can take it ([`thread_target`]), else a new frame with its
|
||||
/// top-left at `start`.
|
||||
fn thread_params(cx: &ToolContext, from: NodeId, start: Point, end: Point) -> Value {
|
||||
if let Some(r) = new_frame_rect(cx, start, end) {
|
||||
return json!({ "from": from.0, "rect": [r.x0, r.y0, r.width(), r.height()] });
|
||||
}
|
||||
match thread_target(cx, from, start) {
|
||||
Some(to) => json!({ "from": from.0, "to": to.0 }),
|
||||
None => json!({ "from": from.0, "at": [start.x, start.y] }),
|
||||
}
|
||||
@@ -1252,7 +1273,15 @@ impl Tool for SelectionTool {
|
||||
State::Space(_) => return Cursor::ArrowHollow,
|
||||
State::MoveAll(_) | State::Member(_) => return Cursor::Move,
|
||||
State::Bracket(_) => return Cursor::PathBracket,
|
||||
State::Loaded { .. } => return Cursor::LoadedText,
|
||||
// Loaded text: the link cursor where a click threads it into the object there (for a
|
||||
// press held down, the object pressed on until the drag draws a new frame).
|
||||
State::Loaded { from, press, .. } => {
|
||||
let at = match press {
|
||||
Some((start, cur)) => new_frame_rect(cx, start, cur).is_none().then_some(start),
|
||||
None => Some(p),
|
||||
};
|
||||
return if at.and_then(|q| thread_target(cx, from, q)).is_some() { Cursor::LoadedTextLink } else { Cursor::LoadedText };
|
||||
}
|
||||
_ => {}
|
||||
}
|
||||
if self.guide.busy() {
|
||||
|
||||
@@ -2197,6 +2197,110 @@ fn a_click_on_the_out_port_loads_the_text_and_the_next_click_or_drag_threads_it(
|
||||
assert_eq!(t.pointer(&cx, &ev(PointerKind::Down, corner.x, corner.y)), vec![Action::Begin("Resize Type Area".into())]);
|
||||
}
|
||||
|
||||
/// Loaded text shows the link cursor over an object a click threads it into (a closed path,
|
||||
/// area type in no thread), and the loaded text elsewhere: empty canvas, an open path, point type,
|
||||
/// the frame it came from and a frame already in a thread, where a click makes a new frame
|
||||
/// instead. Held down on a target, the press keeps the link cursor until its drag draws a frame;
|
||||
/// placing the text or Escape ends both.
|
||||
#[test]
|
||||
fn loaded_text_shows_the_link_cursor_where_a_click_threads_it_into_the_object() {
|
||||
use vectorcraft_doc::{Node, NodeKind, TextKind, TextObject};
|
||||
use vectorcraft_geom::shapes;
|
||||
let (mut d, id, rect, port) = overflowing_area_type();
|
||||
let l = d.layers[0].id;
|
||||
let add = |d: &mut vectorcraft_doc::Document, n: NodeKind| {
|
||||
let nid = d.alloc_id();
|
||||
d.insert(Some(l), 0, Node::new(nid, n)).unwrap();
|
||||
nid
|
||||
};
|
||||
let area = |x: f64, y: f64| {
|
||||
let mut t = TextObject::point(Point::new(x, y), "", Default::default());
|
||||
t.kind = TextKind::Area { frame: shapes::rectangle(Rect::new(0.0, 0.0, 120.0, 40.0)) };
|
||||
NodeKind::Text(Box::new(t))
|
||||
};
|
||||
let free = add(&mut d, area(300.0, 100.0));
|
||||
let threaded = add(&mut d, area(100.0, 380.0));
|
||||
let next = add(&mut d, area(250.0, 440.0));
|
||||
d.text_threads.push(vec![threaded, next]);
|
||||
let line = vectorcraft_geom::kurbo::Line::new((50.0, 250.0), (250.0, 250.0));
|
||||
let open = Node::path(
|
||||
d.alloc_id(),
|
||||
vectorcraft_geom::PathData::from_bezpath(&vectorcraft_geom::kurbo::Shape::to_path(&line, 0.1)),
|
||||
vectorcraft_doc::Appearance::default_art(),
|
||||
);
|
||||
d.insert(Some(l), 0, open).unwrap();
|
||||
let point = TextObject::point(Point::new(40.0, 480.0), "Point", Default::default());
|
||||
let point_at = point.bounds().expect("point type has bounds").center();
|
||||
add(&mut d, NodeKind::Text(Box::new(point)));
|
||||
let mut s = Selection::default();
|
||||
s.set([id]);
|
||||
let p = paint();
|
||||
let cx = cx(&d, &s, &p);
|
||||
let mut t = SelectionTool::default();
|
||||
let load = |t: &mut SelectionTool| {
|
||||
t.pointer(&cx, &ev(PointerKind::Down, port.x, port.y));
|
||||
t.pointer(&cx, &ev(PointerKind::Up, port.x, port.y));
|
||||
};
|
||||
let at = |t: &SelectionTool, x: f64, y: f64| t.cursor(&cx, Point::new(x, y), Mods::default());
|
||||
let thread = |params: Value| vec![Action::Exec("text.thread.add".into(), params)];
|
||||
load(&mut t);
|
||||
assert_eq!(at(&t, 150.0, 150.0), Cursor::LoadedTextLink, "a closed path");
|
||||
assert_eq!(at(&t, 360.0, 120.0), Cursor::LoadedTextLink, "area type in no thread");
|
||||
assert_eq!(at(&t, 30.0, 420.0), Cursor::LoadedText, "empty canvas");
|
||||
assert_eq!(at(&t, 150.0, 250.0), Cursor::LoadedText, "an open path");
|
||||
assert_eq!(at(&t, point_at.x, point_at.y), Cursor::LoadedText, "point type");
|
||||
assert_eq!(at(&t, 360.0, 320.0), Cursor::LoadedText, "the frame the text came from");
|
||||
assert_eq!(at(&t, 160.0, 400.0), Cursor::LoadedText, "a frame already in a thread");
|
||||
// A click where the pointer shows the loaded text makes a new frame there.
|
||||
t.pointer(&cx, &ev(PointerKind::Down, 160.0, 400.0));
|
||||
assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, 160.0, 400.0)), thread(json!({"from": id.0, "at": [160.0, 400.0]})));
|
||||
load(&mut t);
|
||||
t.pointer(&cx, &ev(PointerKind::Down, 150.0, 150.0));
|
||||
assert_eq!(at(&t, 150.0, 150.0), Cursor::LoadedTextLink, "held down on the path");
|
||||
t.pointer(&cx, &ev(PointerKind::Drag, 151.0, 151.0));
|
||||
assert_eq!(at(&t, 151.0, 151.0), Cursor::LoadedTextLink, "a drag too small to draw a frame");
|
||||
assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, 151.0, 151.0)), thread(json!({"from": id.0, "to": rect.0})));
|
||||
assert!(!matches!(at(&t, 150.0, 150.0), Cursor::LoadedText | Cursor::LoadedTextLink), "the text is placed");
|
||||
load(&mut t);
|
||||
t.pointer(&cx, &ev(PointerKind::Down, 150.0, 150.0));
|
||||
t.pointer(&cx, &ev(PointerKind::Drag, 230.0, 240.0));
|
||||
assert_eq!(at(&t, 230.0, 240.0), Cursor::LoadedText, "the drag draws a new frame");
|
||||
t.pointer(&cx, &ev(PointerKind::Up, 230.0, 240.0));
|
||||
load(&mut t);
|
||||
t.pointer(&cx, &ev(PointerKind::Down, 360.0, 120.0));
|
||||
assert_eq!(t.pointer(&cx, &ev(PointerKind::Up, 360.0, 120.0)), thread(json!({"from": id.0, "to": free.0})));
|
||||
load(&mut t);
|
||||
assert!(t.key(&cx, ToolKey::Escape, Mods::default()).is_empty());
|
||||
assert!(!matches!(at(&t, 150.0, 150.0), Cursor::LoadedText | Cursor::LoadedTextLink), "Escape drops the text");
|
||||
}
|
||||
|
||||
/// In an isolated compound path, loaded text shows no link cursor over a member path, which
|
||||
/// `text.thread.add` does not take for `to`: a click there makes a new frame.
|
||||
#[test]
|
||||
fn loaded_text_shows_no_link_cursor_over_a_compound_paths_member() {
|
||||
use vectorcraft_doc::{Appearance, Node, NodeKind};
|
||||
let (mut d, id, _, port) = overflowing_area_type();
|
||||
let l = d.layers[0].id;
|
||||
let (c, member) = (d.alloc_id(), d.alloc_id());
|
||||
let path = Node::path(member, vectorcraft_geom::shapes::rectangle(Rect::new(300.0, 100.0, 400.0, 200.0)), Appearance::default_art());
|
||||
let mut compound = Node::new(c, NodeKind::Compound { children: vec![std::sync::Arc::new(path)], rule: Default::default() });
|
||||
compound.appearance = Appearance::default_art().into();
|
||||
d.insert(Some(l), 0, compound).unwrap();
|
||||
let mut s = Selection::default();
|
||||
s.set([id]);
|
||||
let p = paint();
|
||||
let cx = ToolContext { isolation: Some(c), ..cx(&d, &s, &p) };
|
||||
let mut t = SelectionTool::default();
|
||||
t.pointer(&cx, &ev(PointerKind::Down, port.x, port.y));
|
||||
t.pointer(&cx, &ev(PointerKind::Up, port.x, port.y));
|
||||
assert_eq!(t.cursor(&cx, Point::new(350.0, 150.0), Mods::default()), Cursor::LoadedText);
|
||||
t.pointer(&cx, &ev(PointerKind::Down, 350.0, 150.0));
|
||||
assert_eq!(
|
||||
t.pointer(&cx, &ev(PointerKind::Up, 350.0, 150.0)),
|
||||
vec![Action::Exec("text.thread.add".into(), json!({"from": id.0, "at": [350.0, 150.0]}))]
|
||||
);
|
||||
}
|
||||
|
||||
/// Loaded text clicked just inside a layer's clipping mask, where art is drawn over the mask's
|
||||
/// edge, threads into that art, not into the unpainted mask: placing text acts on what is drawn,
|
||||
/// so it takes the ordinary hit, not the selection tools' clipping-path outline.
|
||||
|
||||
@@ -84,6 +84,7 @@ pub(super) fn cursor_icon(c: Cursor) -> egui::CursorIcon {
|
||||
| Cursor::PathBracket
|
||||
| Cursor::TypeWidget
|
||||
| Cursor::LoadedText
|
||||
| Cursor::LoadedTextLink
|
||||
| Cursor::LivePaintSelectFace
|
||||
| Cursor::LivePaintSelectEdge
|
||||
| Cursor::LivePaintSelectOutside => C::Default,
|
||||
|
||||
@@ -310,6 +310,19 @@ fn loaded_text(p: &mut Ink, o: Pos2) {
|
||||
}
|
||||
}
|
||||
|
||||
/// Loaded text over an object a click threads it into: the loaded text's block with a link
|
||||
/// badge (two chain rings) below right.
|
||||
fn loaded_text_link(p: &mut Ink, o: Pos2) {
|
||||
loaded_text(p, o);
|
||||
let rings = [o + vec2(13.0, 17.0), o + vec2(18.0, 17.0)];
|
||||
for c in rings {
|
||||
p.circle_stroke(c, 3.2, Stroke::new(3.2, HALO));
|
||||
}
|
||||
for c in rings {
|
||||
p.circle_stroke(c, 3.2, Stroke::new(1.3, INK));
|
||||
}
|
||||
}
|
||||
|
||||
/// The gradient annotator's stop cursors: the arrow with a plus (add a stop) or minus (delete it)
|
||||
/// badge.
|
||||
fn stop_badge(p: &mut Ink, o: Pos2, add: bool) {
|
||||
@@ -537,7 +550,7 @@ fn magnifier(p: &mut Ink, o: Pos2, out: bool) {
|
||||
|
||||
/// Every cursor with a glyph: its own, drawn here, or the one it borrows.
|
||||
#[cfg(test)]
|
||||
const GLYPHS: [Cursor; 98] = [
|
||||
const GLYPHS: [Cursor; 99] = [
|
||||
Cursor::Hand,
|
||||
Cursor::HandGrab,
|
||||
Cursor::ZoomIn,
|
||||
@@ -586,6 +599,7 @@ const GLYPHS: [Cursor; 98] = [
|
||||
Cursor::PathBracket,
|
||||
Cursor::TypeWidget,
|
||||
Cursor::LoadedText,
|
||||
Cursor::LoadedTextLink,
|
||||
Cursor::ShapeBuilder,
|
||||
Cursor::ShapeBuilderErase,
|
||||
Cursor::Lasso,
|
||||
@@ -727,6 +741,7 @@ fn glyph(c: Cursor, p: Pos2) -> Option<Vec<Shape>> {
|
||||
Cursor::PathBracket => path_bracket(ink, p),
|
||||
Cursor::TypeWidget => type_widget(ink, p),
|
||||
Cursor::LoadedText => loaded_text(ink, p),
|
||||
Cursor::LoadedTextLink => loaded_text_link(ink, p),
|
||||
Cursor::ShapeBuilder => shape_builder(ink, p, false),
|
||||
Cursor::ShapeBuilderErase => shape_builder(ink, p, true),
|
||||
Cursor::LivePaintBucket => paint_bucket(ink, p, false),
|
||||
|
||||
@@ -79,6 +79,22 @@ fn loaded_text_cursor_is_not_the_text_i_beam() {
|
||||
assert!(pixel(&loaded, hx, hy)[3] > 200, "hotspot lies on the drawn frame");
|
||||
}
|
||||
|
||||
/// Loaded text over an object a click threads it into is drawn as its own glyph: the loaded
|
||||
/// text's block with a link badge below right, so it has more ink than the plain loaded text.
|
||||
#[test]
|
||||
fn loaded_text_link_cursor_is_the_loaded_text_with_a_link_badge() {
|
||||
assert!(Cursor::LoadedTextLink.stand_in().is_none());
|
||||
for ppp in [1.0f32, 2.0] {
|
||||
let link = rasterize(Cursor::LoadedTextLink, ppp).expect("link bitmap");
|
||||
let loaded = rasterize(Cursor::LoadedText, ppp).expect("loaded text bitmap");
|
||||
assert_ne!(link, loaded, "a glyph of its own at {ppp}x");
|
||||
let ink = |img: &CustomCursorImage| img.rgba.as_chunks::<4>().0.iter().filter(|p| p[0] < 64 && p[3] > 200).count();
|
||||
assert!(ink(&link) > ink(&loaded), "the badge adds ink at {ppp}x");
|
||||
let [hx, hy] = link.hotspot.map(usize::from);
|
||||
assert!(pixel(&link, hx, hy)[3] > 200, "hotspot lies on the drawn frame at {ppp}x");
|
||||
}
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn every_glyph_becomes_a_bitmap_with_its_hotspot_inside() {
|
||||
for ppp in [1.0, 1.25, 1.5, 2.0, 3.0] {
|
||||
|
||||
@@ -670,6 +670,7 @@ since 2026-10-01.
|
||||
- **Roughen at Size 0 keeps the outline:** with Size 0 (relative or absolute), Effect › Distort & Transform › Roughen… moves no point: each segment is split at the Detail spacing (fewer points past the anchor limit) into pieces of equal length on the segment itself, so the path keeps its outline, with Smooth or Corner points alike. A straight segment gets corner points without handles, and a curve gets smooth points whose handles follow it. Before, the points were joined by straight lines (Corner) or a smoothed curve through them (Smooth), which changed curved outlines. Existing documents with a Roughen of Size 0 on a curved path, or with Smooth points, draw differently. This is VectorCraft's own rule; what Roughen does is described in [Distort and transform effects](https://helpx.adobe.com/illustrator/desktop/manage-objects/reshape-transform-objects/distort-and-transform-effects-in-illustrator.html) (effects `tests::roughen_at_size_0_keeps_the_outline_and_spaces_its_points_evenly`). Scores and hours unchanged.
|
||||
|
||||
- **Clipping paths on their outline (G1):** the selection tools (Selection, Direct Selection, Group Selection), Object Highlighting and a right-click take a clipping path on its outline before the art it clips; Select Behind lists the same; the eyedropper, the tools that act on what is drawn and the selection tools' double-clicks, loaded text and guide release take the art. Doc and tool regression tests; score unchanged.
|
||||
- **Link cursor for loaded text:** with text loaded from a port, the Selection tool's pointer adds a link badge over a closed path, area type or type on a path that a click threads the text into, and keeps the loaded text elsewhere; a click on a frame already in a thread or a path inside a compound path makes a new frame instead of a `text.thread.add` error (`select::tests::loaded_text_shows_the_link_cursor_where_a_click_threads_it_into_the_object`, `cursors::tests::loaded_text_link_cursor_is_the_loaded_text_with_a_link_badge`); score unchanged.
|
||||
- **Copy and Cut of anchors picked with a lent Direct Selection (#6123):** with the Pen or the Curvature tool, Cmd/Ctrl held lends Direct Selection for the gesture; the anchors and segments it picks are what Edit › Copy and Cut take once the key is let go, as with Direct Selection chosen, while the last anchor the Pen leaves selected as it draws still makes Copy take the whole path (#2122). A Cmd gesture that leaves the selection as it was (a Shift marquee over nothing) picks nothing. Regression test: `tests::draw2::pen_cmd_selected_anchors_are_what_copy_and_cut_take`.
|
||||
- **Cut of picked anchors (#6361):** Edit › Cut removes direct-selected anchors from their path and from a compound path's member, with the segments attached to them, as Clear does. Picked segments still lose only those segments. When a path also has a picked segment, Cut removes and copies only its picked segments and ignores its picked anchors, on every contour, as Clear does; an anchor left without a surviving segment is removed with them. Regression tests: `cut_*_anchors_*` and `cut_of_an_anchor_with_a_segment_on_another_contour_leaves_the_source_as_clear_does` in `crates/engine/tests/it/copy_direct_selection.rs`.
|
||||
- **Escape in Selection tool drags:** Escape during a Selection tool move or Alt-drag copy, a bounding-box scale or rotation, a marquee, or a corner widget, pie widget or bracket drag cancels it: the art returns to its state at the press, no copy is left, no undo step is added, the release does nothing, and the tool stays chosen. This is VectorCraft's own behavior. Regression tests: `escape_cancels_*` in `select/tests.rs` and `pie.rs`, and `escape_cancels_a_selection_tool_move_copy_scale_or_rotation` in `tests/selectescape.rs`.
|
||||
|
||||
+1
-1
@@ -26,7 +26,7 @@ against Illustrator's public documentation; **estimated** unless noted.
|
||||
| Point, area and type-on-a-path type; vertical variants | done / partial | vertical point, area and path type have initial support; fullwidth `!` / `?` keep the nominal glyph upright when no vertical alternate exists (Unicode Tu); in a non-rectangular area a word too wide for the top lines moves down to the first line that holds it (#1615); Escape while typing ends the edit, keeps the type selected and switches back to the tool whose double-click on type chose the Type tool (kept until another tool is chosen or another document or window becomes active, so later edits with the Type tool return there too), or to the Selection tool when there is no such tool, as when the Type tool was chosen from the toolbar or after such a switch (#1802), and Cmd+Enter (Ctrl+Enter on Windows and Linux) does the same unless a command is bound to it; `text.create` and `text.createInPath` take `justify` (#1752); MCP `add_text` forwards `vertical` to both commands; Type › Type Orientation sets every frame of a thread, and a thread's frames share one writing direction; the Type and Vertical Type tools make area type when a closed path's outline is clicked and type on a path when an open one is, with pointers that say which, as the public help describes ([Create text](https://web.archive.org/web/20220127090642/https://helpx.adobe.com/illustrator/using/creating-text.html), [Create type on a path](https://web.archive.org/web/20220127090635/https://helpx.adobe.com/illustrator/using/creating-type-path.html)) |
|
||||
| Area Type Options (rows, columns, inset, first baseline, Text Flow by rows or by columns, Auto Size, Shrink Text to Fit) | done | Text Flow fills the cells down each column first (By Columns, the default, as files from before it open) or across each row first (By Rows), in the dialog and `text.areaOptions {flow}` (#4978); the commands that make or restyle type say when it does not fit its frame; MCP `add_text` takes Auto Size and Shrink Text to Fit (#1471) |
|
||||
| Threaded text, Fit Headline, Text Wrap | done | Fit Headline sees wrapping in a frame one line tall (#1444); a thread holds area type and type on a path in any mix, as Illustrator links type in an area or along a path ([help](https://helpx.adobe.com/illustrator/using/manage-text-area.html)); a frame's empty last paragraph keeps a format given to it when the story flows again |
|
||||
| Threading from the ports: selected area type and type on a path show an in port and an out port, empty, with an arrow on a side where the frame is threaded, or with a red "+" in the out port when the text doesn't fit; a click on either port loads the text; a click on a closed path, area type or type on a path threads into it, a click on empty canvas makes a frame of the same kind, shape and size there, a drag draws a rectangular frame; the frame placed comes after the clicked one from its out port and before it from its in port (the story then starts there); Escape or another tool cancels; a double-click on a threaded port breaks the thread there | partial | #2572: the Selection tool, `text.thread.add {from, to?, rect?, at?, before?}`, as the reference app's help describes ports and threading ([archived help, Threading text between objects](https://web.archive.org/web/20210119051048/https://helpx.adobe.com/illustrator/using/creating-text.html), [create text threads](https://helpx.adobe.com/illustrator/desktop/design-with-text/add-manage-text/create-text-threads-between-objects.html)); area type's in port sits on the left side below the top-left corner, type on a path's just before its start bracket; Show Text Threads draws its lines between the same ports; with more than 1,000 such objects selected no ports are drawn. a double-click on a port where the frame is threaded breaks the thread there, the story flowing into the frames before the break and the frames after it left empty, still threaded with each other when two or more (`text.thread.break`, [archived help](https://web.archive.org/web/20220127090642/https://helpx.adobe.com/illustrator/using/creating-text.html)). Remaining: the ports only take clicks with the Selection tool, and the loaded cursor borrows the I-beam until it's drawn |
|
||||
| Threading from the ports: selected area type and type on a path show an in port and an out port, empty, with an arrow on a side where the frame is threaded, or with a red "+" in the out port when the text doesn't fit; a click on either port loads the text; a click on a closed path, area type or type on a path threads into it, a click on empty canvas makes a frame of the same kind, shape and size there, a drag draws a rectangular frame; the frame placed comes after the clicked one from its out port and before it from its in port (the story then starts there); Escape or another tool cancels; a double-click on a threaded port breaks the thread there | partial | #2572: the Selection tool, `text.thread.add {from, to?, rect?, at?, before?}`, as the reference app's help describes ports and threading ([archived help, Threading text between objects](https://web.archive.org/web/20210119051048/https://helpx.adobe.com/illustrator/using/creating-text.html), [create text threads](https://helpx.adobe.com/illustrator/desktop/design-with-text/add-manage-text/create-text-threads-between-objects.html)); area type's in port sits on the left side below the top-left corner, type on a path's just before its start bracket; Show Text Threads draws its lines between the same ports; with more than 1,000 such objects selected no ports are drawn. a double-click on a port where the frame is threaded breaks the thread there, the story flowing into the frames before the break and the frames after it left empty, still threaded with each other when two or more (`text.thread.break`, [archived help](https://web.archive.org/web/20220127090642/https://helpx.adobe.com/illustrator/using/creating-text.html)). The loaded text has a cursor of its own; over a closed path, area type or type on a path that a click threads it into the pointer adds a link badge, as the [archived help on threading text between objects](https://web.archive.org/web/20210601162814/https://helpx.adobe.com/pdf/illustrator_reference.pdf#page=476) describes the pointer changing over the object's path. The frame the text came from, a frame already in a thread, a path inside a compound path and other art show no badge, and a click there makes a new frame (`select::tests::loaded_text_shows_the_link_cursor_where_a_click_threads_it_into_the_object`). Remaining: the ports only take clicks with the Selection tool |
|
||||
| Type on a Path effects and options; brackets | done | #429; Type on a Path Options has a Preview checkbox (#5360, as public tutorials of the dialog show); Direct Selection shows the anchors and direction handles of selected type on a path's path and drags both, the brackets keeping their fractions of the path and the text reflowing along it (#3980, #3565; `text.reshapePath`, `text.setPathHandle`), as the [Direct Selection page](https://helpx.adobe.com/illustrator/using/tool-techniques/direct-selection-tool.html) describes for a path; Type › Dynamic Text (`type.dynamicText`, also on the Contextual Task Bar) sizes type on a path to fill the span between its brackets and fits it again after each edit, as the [Dynamic Text overview](https://helpx.adobe.com/photoshop/desktop/text-typography/work-with-dynamic-text/dynamic-text-overview.html) describes; the 0.1 pt steps, the 0.1 to 1,296 pt range and keeping the drawn sizes when it is turned off or threaded are VectorCraft's own rules (`crates/text/src/tests/fit.rs`, `crates/engine/src/tests/dynamic_text.rs`) |
|
||||
| Character and Paragraph panels, styles with overrides | done | Character-style Auto-leading resets, partial definitions, local leading overrides, override markers, Undo/Redo and native serialization have regression coverage; differing paragraph alignments leave the shared alignment buttons unselected (headless regressions, full integration CI and visual review pass); mixed-value display for other paragraph fields remains missing. Double-clicking a user character style's row opens its Character Style Options, and the dialog keeps a fixed width while its sections scroll when the window is shorter, so its buttons stay on screen; a paragraph style's row opens the same Paragraph Style Options dialog as the panel menu, with General, Basic Paragraph Formats, Tabs, Composition, Hyphenation, Justification and East Asian Composition Settings. Evidence: `panels::text_styles::tests::double_clicking_a_character_style_row_opens_its_options`, `dialogs::char_style_options::tests::the_sections_scroll_in_a_window_shorter_than_the_general_list`, `dialogs::para_style_options::tests::every_section_draws_its_fields`, `dialogs::para_style_options::tests::tabs_section_edits_the_style_stops` |
|
||||
| Copy or Cut selected characters, then paste as separate text art | done | A Type-range copy keeps the selected characters' font family, size and color when pasted on the canvas after leaving text editing, in the same document or another. On desktop the clipboard offers plain text to text consumers and rich art for canvas Paste; Paste Without Formatting while editing uses the destination text's style. `tests::clipboard::type_range_copy_stays_styled_when_pasted_as_art` (#5636) |
|
||||
|
||||
+1
-1
@@ -331,7 +331,7 @@ tools, never checked side by side) isn't captured row by row.
|
||||
| Document Setup → Edit Artboards applies valid settings, closes the dialog and activates the Artboard tool | done | Pointer-click tests cover successful handoff, invalid settings, OK, Cancel and Undo in `dialogs/document_setup.rs`. |
|
||||
| Escape leaves Artboard editing for Selection; during a drag it first cancels the gesture | done | Headless egui key events cover idle Escape, active-drag cancellation and a subsequent Escape in `tests/distortkeys.rs`. |
|
||||
| Escape while typing ends the edit, keeps the type selected and switches back to the tool whose double-click on type chose the Type tool (kept until another tool is chosen or another document or window becomes active, so later edits with the Type tool return there too), or to the Selection tool when there is no such tool, as when the Type tool was chosen from the toolbar or after such a switch | done | #1802 (#1686, #1656) |
|
||||
| Selection tool: selected area type and type on a path show an in port and an out port (empty, an arrow where threaded, the red "+" of overflow); a click on either loads the text cursor; a click on a closed path, on empty canvas or a drag threads the text there, after the clicked frame from its out port, before it from its in port; Escape or another tool drops it; a double-click on a threaded port breaks the thread there | partial | #2572 (`text.thread.add`, `before` for the in port); the out port sits on the frame's right side above the bottom-right corner handle and the in port on its left side below the top-left one, so the handles can still be grabbed; a double-click on a threaded port breaks the thread (`text.thread.break`, [archived help](https://web.archive.org/web/20220127090642/https://helpx.adobe.com/illustrator/using/creating-text.html)); the loaded cursor borrows the I-beam |
|
||||
| Selection tool: selected area type and type on a path show an in port and an out port (empty, an arrow where threaded, the red "+" of overflow); a click on either loads the text cursor; a click on a closed path, on empty canvas or a drag threads the text there, after the clicked frame from its out port, before it from its in port; Escape or another tool drops it; a double-click on a threaded port breaks the thread there | partial | #2572 (`text.thread.add`, `before` for the in port); the out port sits on the frame's right side above the bottom-right corner handle and the in port on its left side below the top-left one, so the handles can still be grabbed; a double-click on a threaded port breaks the thread (`text.thread.break`, [archived help](https://web.archive.org/web/20220127090642/https://helpx.adobe.com/illustrator/using/creating-text.html)); the loaded text has a cursor of its own, with a link badge over a closed path, area type or type on a path that a click threads it into |
|
||||
| Shift-click selects several artboards (Artboard tool, Artboards panel); they move, Alt-copy and delete together | done | `artboard.move`/`artboard.delete` `indices` (#1139); in the panel, Shift- and Ctrl/Cmd-click work with any tool by switching to the Artboard tool (#5698); panel menu, trash and Properties share selected-set deletion; all-selected retains artboard 1 and a single board cannot be deleted, with pointer-event and Undo/Redo coverage |
|
||||
| Artboards panel: drag a row above or below another to reorder the artboards (as Move Up / Move Down do) | done | #4687; a line shows where the row lands, `artboard.reorder` in one undo step, the moved artboard becomes active; public forum answers describe the drag |
|
||||
| Artboards panel › Delete Empty Artboards | done | `artboard.deleteEmpty`; one undo step, guides go too, locked artboards stay, and artboard 1 when every artboard is empty and none is locked; an artboard is empty when no object (hidden, locked and template art included; guides not) has visual bounds that meet or touch it, a group counting by its members and a clip group or clipping layer by its members inside the clip (our reading of "no artwork"; the pages give no finer rule); [spec](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/add-edit-artboards/delete-artboards.html) |
|
||||
|
||||
Reference in New Issue
Block a user