diff --git a/crates/mcp/src/tests.rs b/crates/mcp/src/tests.rs index 56b2f95944..bcee18074e 100644 --- a/crates/mcp/src/tests.rs +++ b/crates/mcp/src/tests.rs @@ -323,6 +323,7 @@ fn headless_command_list_includes_ui_commands() { "app.quit", "window.arrange.tile", "align.horizontalLeft", + "align.toKeyObject", "ui.action.play", ]; for (n, id) in want.iter().enumerate() { diff --git a/crates/mcp/src/ui_catalog.rs b/crates/mcp/src/ui_catalog.rs index b9b53059b4..8c3bcef98e 100644 --- a/crates/mcp/src/ui_catalog.rs +++ b/crates/mcp/src/ui_catalog.rs @@ -374,6 +374,24 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[ "", "{} the Align panel's Horizontal Distribute Space button: object.distributeSpacing {axis: \"horizontal\"} with to: \"key\" while there is a key, else the Align To choice, and spacing: the Distribute Spacing value while there is a key; with the Artboard tool chosen, the artboard command of the same name (artboard.distribute, artboard.distributeSpacing) with the same direction on the artboards the tool has selected, to: \"artboard\" (the active artboard) and spacing: the Distribute Spacing value while Align to Artboard is chosen, else \"selection\"", ), + ( + "align.toSelection", + "Align to Selection", + "", + "{} the Align panel's Align to Selection button: Align To becomes Selection (saved with the preferences, ui.inspect › ui.align_to) and the key object, key guide or key anchor is let go → {alignTo: the choice the Align panel then shows: \"selection\", or \"artboard\" while one object is selected, since one object aligns to the artboard}", + ), + ( + "align.toKeyObject", + "Align to Key Object", + "", + "{} the Align panel's Align to Key Object button: with no key, the topmost of two or more selected objects becomes the key object, or a ruler guide selected with one object the key guide; the stored Selection or Artboard choice stays → {alignTo: \"key\"}; an error (\"no key object\") when there is no key and nothing to make one of, when the topmost selected object can't be the key (it is inside another selected object), or with the Artboard tool chosen", + ), + ( + "align.toArtboard", + "Align to Artboard", + "", + "{} the Align panel's Align to Artboard button: Align To becomes Artboard (saved with the preferences, ui.inspect › ui.align_to) and the key object, key guide or key anchor is let go → {alignTo: \"artboard\"}; with the Artboard tool chosen the selected objects keep their key", + ), ( "type.bold", "Bold", diff --git a/crates/ui-egui/src/menus/run.rs b/crates/ui-egui/src/menus/run.rs index ad85ed5bfa..aa4263112c 100644 --- a/crates/ui-egui/src/menus/run.rs +++ b/crates/ui-egui/src/menus/run.rs @@ -356,6 +356,7 @@ fn run_ui_part4(app: &mut VectorcraftApp, id: &str, _p: &Value) -> Option crate::panels::paragraph::convert_list_to_text(app), id if let Some(b) = crate::panels::align::button(id) => crate::panels::align::run_button(app, b), + id if let Some(v) = crate::panels::align::align_to_command(id) => crate::panels::align::run_align_to(app, v), "view.gradientAnnotator" => flag(&mut app.ui.view.gradient_annotator), "view.livePaintGaps" => flag(&mut app.ui.view.live_paint_gaps), "effect.last" => match app.last_effect.clone() { diff --git a/crates/ui-egui/src/menus/state.rs b/crates/ui-egui/src/menus/state.rs index 36dcdfc1d4..db1803c711 100644 --- a/crates/ui-egui/src/menus/state.rs +++ b/crates/ui-egui/src/menus/state.rs @@ -61,6 +61,8 @@ pub fn checked(app: &VectorcraftApp, id: &str, p: &Value) -> Option { // A View › Rotate View item is checked when the active view is turned to its angle; without // a document no item is checked. "view.rotate" => app.view().zip(p.get("angle").and_then(Value::as_f64)).is_some_and(|(view, a)| (view.rotation - a).abs() < 1e-9), + // Object › Align's Align To items: the choice the Align panel shows. + id if let Some(v) = crate::panels::align::align_to_command(id) => crate::panels::align::shown_align_to(app) == v, "window.control" => app.ui.control_bar, "window.helpBar" => app.ui.help_bar, "view.statusBarShow" => p.get("show").and_then(Value::as_str) == Some(app.ui.status_bar_show.param()), @@ -227,6 +229,7 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool { id if crate::panels::paragraph::ALIGN_COMMANDS.iter().any(|c| c.0 == id) => crate::panels::character::text_style(app).is_some(), "type.applyBullets" | "type.applyNumbers" | "type.convertListToText" => crate::panels::character::text_style(app).is_some(), id if let Some(b) = crate::panels::align::button(id) => enabled(app, b.command_now(app)), + id if let Some(v) = crate::panels::align::align_to_command(id) => crate::panels::align::can_choose(app, v), "file.reveal" => app.services.reveal.is_some() && app.session.active().is_some_and(|d| d.path.is_some()), "file.cancelExport" | "file.exportInBackground" => app.background.jobs.iter().any(|j| j.progress.is_some() && !j.cancelled()), "file.cancelOpen" => !app.opening.pending.is_empty(), diff --git a/crates/ui-egui/src/menus/tree.rs b/crates/ui-egui/src/menus/tree.rs index 137c3b5758..1f08bfa4a5 100644 --- a/crates/ui-egui/src/menus/tree.rs +++ b/crates/ui-egui/src/menus/tree.rs @@ -164,6 +164,11 @@ pub fn menu_tree_named(english_names: bool) -> Vec<(&'static str, Vec)> { cp("Vertical Align Top", "object.align", json!({"vertical": "top"})), cp("Vertical Align Center", "object.align", json!({"vertical": "center"})), cp("Vertical Align Bottom", "object.align", json!({"vertical": "bottom"})), + Sep, + // The Align panel's Align To choices, checked as the panel shows them. + c("Align to Selection", "align.toSelection"), + c("Align to Key Object", "align.toKeyObject"), + c("Align to Artboard", "align.toArtboard"), ], ), // The Align panel's Distribute Objects and Distribute Spacing buttons: each item runs diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rs index e2c40562f1..5c24ca9db9 100644 --- a/crates/ui-egui/src/menus/ui_commands.rs +++ b/crates/ui-egui/src/menus/ui_commands.rs @@ -375,6 +375,24 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[ "", "{} the Align panel's Horizontal Distribute Space button: object.distributeSpacing {axis: \"horizontal\"} with to: \"key\" while there is a key, else the Align To choice, and spacing: the Distribute Spacing value while there is a key; with the Artboard tool chosen, the artboard command of the same name (artboard.distribute, artboard.distributeSpacing) with the same direction on the artboards the tool has selected, to: \"artboard\" (the active artboard) and spacing: the Distribute Spacing value while Align to Artboard is chosen, else \"selection\"", ), + ( + "align.toSelection", + "Align to Selection", + "", + "{} the Align panel's Align to Selection button: Align To becomes Selection (saved with the preferences, ui.inspect › ui.align_to) and the key object, key guide or key anchor is let go → {alignTo: the choice the Align panel then shows: \"selection\", or \"artboard\" while one object is selected, since one object aligns to the artboard}", + ), + ( + "align.toKeyObject", + "Align to Key Object", + "", + "{} the Align panel's Align to Key Object button: with no key, the topmost of two or more selected objects becomes the key object, or a ruler guide selected with one object the key guide; the stored Selection or Artboard choice stays → {alignTo: \"key\"}; an error (\"no key object\") when there is no key and nothing to make one of, when the topmost selected object can't be the key (it is inside another selected object), or with the Artboard tool chosen", + ), + ( + "align.toArtboard", + "Align to Artboard", + "", + "{} the Align panel's Align to Artboard button: Align To becomes Artboard (saved with the preferences, ui.inspect › ui.align_to) and the key object, key guide or key anchor is let go → {alignTo: \"artboard\"}; with the Artboard tool chosen the selected objects keep their key", + ), ( "type.bold", "Bold", diff --git a/crates/ui-egui/src/panels/align.rs b/crates/ui-egui/src/panels/align.rs index e5cb5d07dc..b7de2bb612 100644 --- a/crates/ui-egui/src/panels/align.rs +++ b/crates/ui-egui/src/panels/align.rs @@ -329,7 +329,7 @@ fn key_is_anchor(app: &VectorcraftApp) -> bool { /// The Align To choice that the Align panel and the Control bar show chosen: Artboard while one /// object is selected (the buttons then align it to the artboard), else [`align_to`]. With the /// Artboard tool chosen, it is the stored choice, Selection or Artboard. -fn shown_align_to(app: &VectorcraftApp) -> AlignTo { +pub(crate) fn shown_align_to(app: &VectorcraftApp) -> AlignTo { if on_artboards(app) { return app.ui.align_to; } @@ -340,7 +340,7 @@ fn shown_align_to(app: &VectorcraftApp) -> AlignTo { /// guide, or something to make one of: two or more selected objects, or a guide selected with /// objects. With the Artboard tool chosen it is off: Align to Artboard keeps the active artboard /// in place. -fn can_choose(app: &VectorcraftApp, v: AlignTo) -> bool { +pub(crate) fn can_choose(app: &VectorcraftApp, v: AlignTo) -> bool { if on_artboards(app) { return v != AlignTo::Key; } @@ -377,6 +377,33 @@ pub(crate) fn choose_align_to(app: &mut VectorcraftApp, v: AlignTo) { } } +/// The Align To choices as UI commands ([`crate::menus::UI_COMMANDS`]): (command id, choice). Object +/// › Align lists them after its align items, checked as the Align panel shows its choice, and Edit › +/// Keyboard Shortcuts lists each under Align with no default shortcut. +pub const ALIGN_TO_COMMANDS: [(&str, AlignTo); 3] = + [("align.toSelection", AlignTo::Selection), ("align.toKeyObject", AlignTo::Key), ("align.toArtboard", AlignTo::Artboard)]; + +/// The Align To choice of UI command `id` ([`ALIGN_TO_COMMANDS`]). `None`: `id` is not one of them. +pub(crate) fn align_to_command(id: &str) -> Option { + ALIGN_TO_COMMANDS.iter().find(|c| c.0 == id).map(|c| c.1) +} + +/// Runs the UI command of Align To choice `v`: chooses it as the Align panel's Align To buttons do +/// ([`choose_align_to`]) → `{alignTo}`, the choice the Align panel then shows. An error when it +/// can't be chosen: Align to Key Object with no key object and nothing to make one of, with the +/// Artboard tool chosen, or when the topmost selected object can't be the key (it is inside +/// another selected object). +pub(crate) fn run_align_to(app: &mut VectorcraftApp, v: AlignTo) -> Result { + if !can_choose(app, v) { + return Err("no key object".into()); + } + choose_align_to(app, v); + if v == AlignTo::Key && !has_key(app) { + return Err("no key object".into()); + } + Ok(json!({"alignTo": shown_align_to(app).param()})) +} + /// The width of the Control bar's Align To menu ([`align_to_menu`]) for buttons `size` points /// square: the icon of the choice and the arrow after it. pub(crate) fn align_to_menu_width(size: f32) -> f32 { diff --git a/crates/ui-egui/src/panels/align/tests.rs b/crates/ui-egui/src/panels/align/tests.rs index 727498c61c..f2efcf6e35 100644 --- a/crates/ui-egui/src/panels/align/tests.rs +++ b/crates/ui-egui/src/panels/align/tests.rs @@ -627,6 +627,90 @@ fn object_align_follows_align_to() { assert_eq!((bounds(&app, &a).x1, bounds(&app, &b).x1), (boards[1].x1, boards[1].x1), "the active artboard's right edge"); } +/// The Align To choices of Object → Align ([`ALIGN_TO_COMMANDS`]), in their order: (command id, +/// label). +const ALIGN_TO_ENTRIES: [(&str, &str); 3] = + [("align.toSelection", "Align to Selection"), ("align.toKeyObject", "Align to Key Object"), ("align.toArtboard", "Align to Artboard")]; + +/// Which of Object → Align's Align To items are checked, in their order. +fn align_to_checks(app: &VectorcraftApp) -> Vec> { + ALIGN_TO_ENTRIES.iter().map(|(id, _)| crate::menus::checked(app, id, &json!({}))).collect() +} + +/// Object → Align lists the Align To choices after its align items, the one the Align panel shows +/// checked, and a click on one chooses it as the panel's button does. Edit › Keyboard Shortcuts +/// lists each under Align with no default shortcut, and a shortcut chooses it too. +#[test] +fn object_align_lists_the_align_to_choices() { + let (mut app, back, front) = back_and_front(); + let items: Vec<(String, Option)> = + crate::menus::menu_entries(&app).into_iter().filter(|e| e.path == ["Object", "Align"]).map(|e| (e.label, e.command)).skip(7).collect(); + let expected: Vec<(String, Option)> = ALIGN_TO_ENTRIES.iter().map(|(id, l)| (l.to_string(), Some(id.to_string()))).collect(); + assert_eq!(items, expected, "after the seven align items"); + assert_eq!(align_to_checks(&app), [Some(true), Some(false), Some(false)]); + object_align(&mut app, "Align to Artboard"); + assert_eq!(app.ui.align_to, AlignTo::Artboard); + assert_eq!(align_to_checks(&app), [Some(false), Some(false), Some(true)]); + let list = app.run("shortcuts.list", json!({})).unwrap(); + for (id, label) in ALIGN_TO_ENTRIES { + let e = list.as_array().unwrap().iter().find(|e| e["id"] == id).unwrap_or_else(|| panic!("{id} is not listed")); + assert_eq!((e["label"].as_str(), e["group"].as_str(), &e["default"]), (Some(label), Some("Align"), &Value::Null), "{id}"); + } + // Align to Key Object by a shortcut: the topmost selected object becomes the key, and the + // stored choice stays. + app.run("shortcuts.set", json!({"id": "align.toKeyObject", "shortcut": CHORD})).unwrap(); + press_chord(&mut app); + assert_eq!(app.session.active().unwrap().selection.key.map(|k| k.0), front.as_u64(), "{}", app.ui.status); + assert_eq!(align_to_checks(&app), [Some(false), Some(true), Some(false)]); + assert_eq!(app.ui.align_to, AlignTo::Artboard); + // Align to Selection lets the key go and stores Selection. + assert_eq!(app.run("align.toSelection", json!({})).unwrap(), json!({"alignTo": "selection"})); + assert!(!has_key(&app)); + assert_eq!(app.ui.align_to, AlignTo::Selection); + // One object: Align to Key Object is off and fails, and Align To shows Artboard checked. + app.run("select.set", json!({"ids": [back]})).unwrap(); + let key_item = crate::menus::menu_entries(&app).into_iter().find(|e| e.command.as_deref() == Some("align.toKeyObject")).unwrap(); + assert!(!key_item.enabled, "one object"); + assert_eq!(app.run("align.toKeyObject", json!({})).unwrap_err(), "no key object"); + assert!(!has_key(&app)); + assert_eq!(align_to_checks(&app), [Some(false), Some(false), Some(true)]); + // Align to Selection with one object stores Selection and returns what the panel shows. + assert_eq!(app.run("align.toSelection", json!({})).unwrap(), json!({"alignTo": "artboard"})); + assert_eq!(app.ui.align_to, AlignTo::Selection); +} + +/// With the Artboard tool chosen, Align to Key Object is off and fails, and Align to Artboard and +/// Align to Selection store the choice while the selected objects keep their key. +#[test] +fn align_to_commands_with_the_artboard_tool() { + let (mut app, _, front) = back_and_front(); + app.run("align.toKeyObject", json!({})).unwrap(); + app.select_tool("artboard"); + assert!(has_key(&app), "choosing the Artboard tool keeps the key"); + let key_item = crate::menus::menu_entries(&app).into_iter().find(|e| e.command.as_deref() == Some("align.toKeyObject")).unwrap(); + assert!(!key_item.enabled, "the Artboard tool"); + assert_eq!(app.run("align.toKeyObject", json!({})).unwrap_err(), "no key object"); + assert_eq!(app.run("align.toArtboard", json!({})).unwrap(), json!({"alignTo": "artboard"})); + assert_eq!(app.ui.align_to, AlignTo::Artboard); + assert_eq!(align_to_checks(&app), [Some(false), Some(false), Some(true)]); + assert_eq!(app.run("align.toSelection", json!({})).unwrap(), json!({"alignTo": "selection"})); + assert_eq!(app.ui.align_to, AlignTo::Selection); + assert_eq!(align_to_checks(&app), [Some(true), Some(false), Some(false)]); + assert_eq!(app.session.active().unwrap().selection.key.map(|k| k.0), front.as_u64(), "the key stays"); +} + +/// Align to Key Object fails when the topmost selected object can't be the key: a group selected +/// with an object inside it. +#[test] +fn align_to_key_object_fails_when_the_topmost_object_cannot_be_the_key() { + let (mut app, _, front) = back_and_front(); + let group = app.run("object.group", json!({})).unwrap()["id"].clone(); + app.run("select.set", json!({"ids": [group, front]})).unwrap(); + assert_eq!(app.session.active().unwrap().selection.objects.len(), 2, "the group and its member"); + assert_eq!(app.run("align.toKeyObject", json!({})).unwrap_err(), "no key object"); + assert!(!has_key(&app)); +} + /// With anchor points selected, Object → Align sends its params unchanged: two anchor points of /// one path align to their own bounds with Align to Selection and with Align to Artboard chosen. #[test] diff --git a/docs/mcp.md b/docs/mcp.md index 2a71579399..70e64f9771 100644 --- a/docs/mcp.md +++ b/docs/mcp.md @@ -6988,6 +6988,17 @@ the Align To choice, and while there is a key object or a key guide they send th `shortcuts.set {id, shortcut}` gives one a shortcut. The Object › Distribute menu lists the eight Distribute commands, and each item runs its command. +The Align panel's Align To choices are UI commands too, with no params: `align.toSelection`, `align.toKeyObject` and +`align.toArtboard`. Each chooses what a click on its Align To button chooses and returns `{alignTo}`, the choice the +panel then shows (`align.toSelection` returns `"artboard"` while one object is selected, which aligns to the artboard). +`align.toSelection` and `align.toArtboard` store the choice (`ui.inspect` › `ui.align_to`) and let the key go; with the +Artboard tool chosen they store it and the selected objects keep their key. With no key, `align.toKeyObject` makes the +topmost of two or more selected objects the key object, or a ruler guide selected with one object the key guide, and +keeps the stored choice. It fails with "no key object" when there is nothing to make the key, when the topmost selected +object is inside another selected object and can't be the key, and with the Artboard tool chosen. Object › Align lists +the three after its align items, with the choice the panel shows checked, and Edit › Keyboard Shortcuts lists them +under Align with no default shortcut. + With the Artboard tool chosen, the same buttons and UI commands, and the Control bar's Align and Distribute buttons, run `artboard.align`, `artboard.distribute` and `artboard.distributeSpacing` on the artboards the tool has selected. Align To then offers Align to Selection and Align to Artboard. Align to Artboard sends `to: "artboard"`, which keeps the diff --git a/docs/target-app-parity.md b/docs/target-app-parity.md index c767c1e6cc..3aa58f2427 100644 --- a/docs/target-app-parity.md +++ b/docs/target-app-parity.md @@ -1268,6 +1268,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur The Control bar has an Align To menu after its Align buttons. The public documentation offers Align to Selection, Align to Key Object and Align to Artboard in the Control panel (VectorCraft's Control bar) as well as in the Align panel ([Move, align, and distribute objects](https://web.archive.org/web/20250115013546/https://helpx.adobe.com/illustrator/using/moving-aligning-distributing-objects.html)). The menu shows the icon of the choice the Align panel's Align To shows, and a pick sets the same choice as the Align panel's buttons do. Align to Key Object is off while no key object can be made. When the bar runs short of room, it drops the Distribute buttons first, then the Align To menu, then the Align buttons. Object › Align aligns objects as the align buttons do: it aligns one object to the active artboard whatever Align To is set to, and otherwise it aligns to the key object while there is one, else to the Align To choice, which is saved with the preferences (`ui.inspect` → `ui.align_to`). With direct-selected anchor points, Object › Align aligns the points to their own bounds. While one object is selected, Align To shows Artboard. Edit › Keyboard Shortcuts lists each of the Align panel's Align Objects, Distribute Objects and Distribute Spacing buttons under Align, with no default shortcut, as the reference app's [release notes](https://web.archive.org/web/20261006170350/https://helpx.adobe.com/illustrator/desktop/new-features/release-notes.html) describe for its Align and Distribute commands. A shortcut set there runs what a click on the button runs, with the Align To choice, the key object and the Distribute Spacing value (`align.horizontalLeft` and the other `align.*` UI commands). + Object › Align lists Align to Selection, Align to Key Object and Align to Artboard after its align items, with the choice the Align panel shows checked, and each sets that choice as the panel's Align To buttons do; Edit › Keyboard Shortcuts lists them under Align with no default shortcut. The public page has shortcuts for the Align commands set under Object › Align ([Align and distribute objects](https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/align-and-distribute-objects.html)); placing the Align To choices there is VectorCraft's own (`align.toSelection`, `align.toKeyObject`, `align.toArtboard`; `panels::align::tests::object_align_lists_the_align_to_choices`). The command palette lists `select.key` as Cancel Key Object, and a pick cancels the key object (#541). Agent selection commands validate every object id before changing the selection and report the resulting count and ids (#784). Commands that act on `id` or else the selection, the highlighted layer row or a new object (`css.export`, `object.isolate`, `layer.locate`, `layer.releaseToLayers`, the graphic, character and paragraph style commands, `image.info`, the `links.*` and `shaper.*` commands that take an `id`, opacity mask editing and viewing, `symbol.edit`, the blend spine commands and `path.curvature`) refuse an `id` that is not an object id (`"abc"`, `"5"`, `true`) and change nothing; `effect.apply` with the effect given as `id` still applies it to the selection. diff --git a/docs/ui-parity.md b/docs/ui-parity.md index e44a28165c..9bbe2d0d35 100644 --- a/docs/ui-parity.md +++ b/docs/ui-parity.md @@ -227,6 +227,7 @@ tools, never checked side by side) isn't captured row by row. | Align panel menu › Align to Glyph Bounds › Point Text and Area Text (checked while on): Align and Distribute measure point type or area type by the ink of its glyphs instead of its em box or frame | done | #4231; `alignGlyphBoundsPoint`, `alignGlyphBoundsArea` ([Align text](https://helpx.adobe.com/illustrator/desktop/design-with-text/edit-format-text/align-text.html)); `tests::glyphbounds`, `panels::align::tests::align_to_glyph_bounds_toggles_point_and_area_text`; the Character and Properties panels' Align to Glyph Bounds controls are not done | | Align and distribute artboards: with the Artboard tool chosen, the Align panel's Align Objects, Distribute Objects and Distribute Spacing buttons, and the Control bar's, move the selected artboards with the art inside them (Move Artwork with Artboard) | done | `artboard.align`, `artboard.distribute`, `artboard.distributeSpacing` ([Align and distribute artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/align-and-distribute-artboards.html)); VectorCraft's own rules: Align to Artboard keeps the active artboard in place and sends the Distribute Spacing value, Align to Key Object is off, a locked artboard stays where it is; `cmd::artboardalign::tests`, `panels::align::tests::the_align_buttons_align_the_selected_artboards` | | Object › Distribute, below Object › Align: Horizontal Distribute Left, Center and Right, Vertical Distribute Top, Center and Bottom, Horizontal Distribute Space and Vertical Distribute Space, each running what a click on its Align panel button runs (Align To, the key object, the Distribute Spacing value and, with the Artboard tool chosen, the selected artboards) | done | The `align.distribute*` commands; the public page names Object › Distribute beside Object › Align for the Align and Distribute commands ([Align and distribute objects](https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/align-and-distribute-objects.html)); the items and their order are VectorCraft's own, taken from the Align panel; `menus::tests::object_distribute_runs_the_distribute_buttons` | +| Object › Align's Align to Selection, Align to Key Object and Align to Artboard, after the align items: each sets the Align panel's Align To choice as its button does, the choice the panel shows is checked, and Edit › Keyboard Shortcuts lists them under Align with no default key | done | `align.toSelection`, `align.toKeyObject`, `align.toArtboard`; the public page has shortcuts for the Align commands set under Object › Align ([Align and distribute objects](https://helpx.adobe.com/illustrator/desktop/manage-objects/arrange-objects/align-and-distribute-objects.html)); placing the Align To choices there is VectorCraft's own; `panels::align::tests::object_align_lists_the_align_to_choices` | | A marquee selects the objects whose paths it touches (anchors or segments): drawn inside a filled shape, over a background, it leaves that shape (Preview and Outline) | done | #1103 | | Click a segment independently of its endpoint anchors; only its direction handles show | done | #1278: hollow endpoint squares, selected edge emphasized; headless egui checked | | Drag a curved segment to bend it, a straight one to move its anchors | done | |