2bc41aeb8602
removeanchors.rs
//! Object › Path › Remove Anchor Points: the menu, the Control bar, the contextual task bar, the
//! Properties panel and the context menu run it on direct-selected anchors. The Control bar's and
//! the Properties panel's other anchor buttons: convert to corner or smooth, connect, cut.
use egui::{Event, PointerButton, Pos2, Rect, Shape, vec2};
use serde_json::json;
use vectorcraft_doc::NodeId;
use vectorcraft_engine::Session;
use vectorcraft_geom::Point;
use crate::canvas::Xf;
use crate::menus::{self, Item};
use crate::{VectorcraftApp, canvas, chrome};
fn app() -> VectorcraftApp {
let mut app = VectorcraftApp::new(Session::new(), Default::default());
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app
}
fn rect(app: &mut VectorcraftApp) -> NodeId {
NodeId(app.run("shape.rectangle", json!({"x": 50, "y": 50, "width": 100, "height": 80})).unwrap()["id"].as_u64().unwrap())
}
fn anchor_count(app: &VectorcraftApp, id: NodeId) -> usize {
app.session.active().and_then(|st| st.doc.node(id)).and_then(|n| n.path_data()).map(|p| p.anchor_count()).unwrap_or(0)
}
fn labels(items: &[Item]) -> Vec<&'static str> {
items
.iter()
.flat_map(|it| match it {
Item::Cmd(l, ..) => vec![*l],
Item::Sub(l, ch) => std::iter::once(*l).chain(labels(ch)).collect(),
_ => vec![],
})
.collect()
}
pub(crate) fn shapes_text(shapes: &[Shape]) -> Vec<(String, Rect)> {
fn walk(s: &Shape, v: &mut Vec<(String, Rect)>) {
match s {
Shape::Text(t) => v.push((t.galley.text().to_string(), Rect::from_min_size(t.pos, t.galley.size()))),
Shape::Vec(s) => s.iter().for_each(|s| walk(s, v)),
_ => {}
}
}
let mut v = vec![];
shapes.iter().for_each(|s| walk(s, &mut v));
v
}
pub(crate) fn control_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>) -> Vec<(String, Rect)> {
let screen = Rect::from_min_size(Pos2::ZERO, vec2(1400.0, 900.0));
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), events, ..Default::default() }, |ui| chrome::control_bar(app, ui));
out.textures_delta.clear();
shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>())
}
pub(crate) fn click_control(app: &mut VectorcraftApp, ctx: &egui::Context, at: Pos2) {
let press = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
control_frame(app, ctx, vec![Event::PointerMoved(at), press(true)]);
control_frame(app, ctx, vec![press(false)]);
control_frame(app, ctx, vec![]);
}
fn canvas_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>) -> Vec<(String, Rect)> {
let screen = Rect::from_min_size(Pos2::ZERO, vec2(800.0, 600.0));
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), events, ..Default::default() }, |ui| canvas::show(app, ui));
out.textures_delta.clear();
shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>())
}
fn click_canvas(app: &mut VectorcraftApp, ctx: &egui::Context, at: Pos2, button: PointerButton) -> Vec<(String, Rect)> {
let press = |pressed| Event::PointerButton { pos: at, button, pressed, modifiers: Default::default() };
canvas_frame(app, ctx, vec![Event::PointerMoved(at)]);
canvas_frame(app, ctx, vec![press(true)]);
canvas_frame(app, ctx, vec![press(false)]);
canvas_frame(app, ctx, vec![])
}
pub(crate) fn properties_frame(app: &mut VectorcraftApp, width: f32) -> Vec<(String, Rect)> {
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let screen = Rect::from_min_size(Pos2::ZERO, vec2(width, 900.0));
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), ..Default::default() }, |ui| {
crate::panels::properties::show(app, ui);
});
out.textures_delta.clear();
shapes_text(&out.shapes.iter().map(|c| c.shape.clone()).collect::<Vec<_>>())
}
pub(crate) fn has(texts: &[(String, Rect)], label: &str) -> bool {
texts.iter().any(|(t, _)| t == label)
}
pub(crate) fn at(texts: &[(String, Rect)], label: &str) -> Pos2 {
texts.iter().find(|(t, _)| t == label).map(|(_, r)| r.center()).unwrap_or_else(|| panic!("no `{label}`"))
}
#[test]
fn the_path_menu_and_bars_run_it_for_direct_selected_anchors() {
const LABEL: &str = "Remove Anchor Points";
let mut app = app();
let id = rect(&mut app);
assert_eq!(anchor_count(&app, id), 4);
let entries: Vec<_> = menus::menu_entries(&app).into_iter().filter(|e| e.label == LABEL).collect();
assert_eq!(entries.len(), 1, "one Remove Anchor Points item");
assert_eq!(entries[0].command.as_deref(), Some("path.removeAnchors"));
assert_eq!(entries[0].path, ["Object", "Path"]);
assert!(!entries[0].enabled, "an object selection is not enough");
assert!(!labels(&menus::context_items(&app)).contains(&LABEL));
assert!(crate::palette::items().iter().any(|(_, cmd, _)| cmd == "path.removeAnchors"));
app.select_tool("directSelection");
app.run("select.anchors", json!({"id": id.0, "anchors": [[0, 1]]})).unwrap();
assert!(menus::enabled(&app, "path.removeAnchors"));
assert!(labels(&menus::context_items(&app)).contains(&LABEL));
// The Control bar's icon follows its "Anchors:" label.
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
click_button(&mut app, &ctx, "Anchors:", 0);
assert_eq!(anchor_count(&app, id), 3, "the Control bar button removes the anchor");
let st = app.session.active().unwrap();
assert_eq!(st.history.undo.last().unwrap().label, LABEL);
let sp = &st.doc.node(id).unwrap().path_data().unwrap().subpaths[0];
assert!(sp.closed, "the path stays closed");
app.run("edit.undo", json!({})).unwrap();
assert_eq!(anchor_count(&app, id), 4);
app.run("select.anchors", json!({"id": id.0, "anchors": [[0, 1]]})).unwrap();
// 230 pt is the dock's minimum width. Each row of anchor buttons has to fit in it.
let props = properties_frame(&mut app, 230.0);
for label in ["Convert:", "Anchors:"] {
let row = props.iter().find(|(t, _)| t == label).map(|(_, r)| *r).expect("properties");
assert!(row.min.x >= -0.5 && button(&props, &ctx, label, 2).x + 12.0 <= 230.5, "properties clips the {label} row: {row:?}");
}
// The task bar's area settles on the second frame.
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
canvas_frame(&mut app, &ctx, vec![]);
let texts = canvas_frame(&mut app, &ctx, vec![]);
assert!(has(&texts, LABEL), "task bar: {texts:?}");
// Right-click keeps the anchor selection (the object is already selected) and runs the item.
let p = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap()).to_screen(Point::new(100.0, 90.0));
let texts = click_canvas(&mut app, &ctx, p, PointerButton::Secondary);
assert!(has(&texts, LABEL), "context menu: {texts:?}");
let texts = click_canvas(&mut app, &ctx, at(&texts, LABEL), PointerButton::Primary);
assert_eq!(anchor_count(&app, id), 3);
assert!(!has(&texts, "Cut Path at Selected Anchor Points"), "the menu closes after the command");
// The next anchor along is selected (#2241), so the task bar offers the command again.
assert_eq!(texts.iter().filter(|(t, _)| t == LABEL).count(), 1, "task bar: {texts:?}");
}
#[test]
fn the_control_bar_and_properties_hide_it_without_anchors() {
let mut app = app();
rect(&mut app);
let props = crate::tests_labels::painted_text(&mut app, crate::panels::properties::show);
assert!(!props.contains("Anchors:"), "{props}");
}
/// The centre of the `i`-th 24 pt icon button after `label`.
fn button(texts: &[(String, Rect)], ctx: &egui::Context, label: &str, i: usize) -> Pos2 {
let r = texts.iter().find(|(t, _)| t == label).map(|(_, r)| *r).unwrap_or_else(|| panic!("no `{label}`"));
let gap = ctx.global_style().spacing.item_spacing.x;
Pos2::new(r.max.x + gap + 12.0 + i as f32 * (24.0 + gap), r.center().y)
}
/// Click the Control bar's `i`-th icon button after `label`.
fn click_button(app: &mut VectorcraftApp, ctx: &egui::Context, label: &str, i: usize) {
let at = button(&control_frame(app, ctx, vec![]), ctx, label, i);
click_control(app, ctx, at);
}
#[test]
fn the_control_bar_converts_connects_and_cuts_selected_anchors() {
let mut app = app();
let id = rect(&mut app);
app.select_tool("directSelection");
app.run("select.anchors", json!({"id": id.0, "anchors": [[0, 1]]})).unwrap();
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
let anchor = |app: &VectorcraftApp, id: NodeId, ai: usize| {
app.session.active().unwrap().doc.node(id).unwrap().path_data().unwrap().subpaths[0].anchors[ai]
};
let last_undo = |app: &VectorcraftApp| app.session.active().unwrap().history.undo.last().unwrap().label.clone();
// Convert: smooth, then corner again.
click_button(&mut app, &ctx, "Convert:", 1);
assert!(anchor(&app, id, 1).has_in() && anchor(&app, id, 1).has_out(), "smooth");
assert_eq!(last_undo(&app), "Convert Anchor Points");
click_button(&mut app, &ctx, "Convert:", 0);
assert!(!anchor(&app, id, 1).has_in() && !anchor(&app, id, 1).has_out(), "corner");
// Cut: the rectangle opens at the anchor, one of its two ends selected.
click_button(&mut app, &ctx, "Anchors:", 2);
assert_eq!(last_undo(&app), "Cut Path");
let st = app.session.active().unwrap();
let sp = &st.doc.node(id).unwrap().path_data().unwrap().subpaths[0];
assert!(!sp.closed && sp.anchors.len() == 5, "{sp:?}");
assert_eq!(st.selection.anchors[&id].iter().collect::<Vec<_>>(), [&(0, 0)]);
// Connect: closes it again.
click_button(&mut app, &ctx, "Anchors:", 1);
assert_eq!(last_undo(&app), "Join");
assert!(app.session.active().unwrap().doc.node(id).unwrap().path_data().unwrap().subpaths[0].closed);
assert_eq!(anchor_count(&app, id), 4, "the coincident ends merge");
}
/// #504: with a tool that edits anchors (Direct Selection, the Pen…), a path selected as a whole
/// shows all its anchors selected, and the Control bar and the Properties panel offer to convert
/// them; removing and cutting wait for anchors direct-selected. The Selection tool shows neither.
#[test]
fn a_whole_path_converts_with_the_tools_that_edit_anchors() {
let mut app = app();
let id = rect(&mut app);
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
app.select_tool("selection");
assert!(!has(&control_frame(&mut app, &ctx, vec![]), "Convert:"));
for tool in ["directSelection", "pen"] {
app.select_tool(tool);
let texts = control_frame(&mut app, &ctx, vec![]);
assert!(has(&texts, "Convert:") && !has(&texts, "Anchors:"), "{tool}: {texts:?}");
let props = crate::tests_labels::painted_text(&mut app, crate::panels::properties::show);
assert!(props.contains("Convert:") && !props.contains("Anchors:"), "{tool}: {props}");
}
click_button(&mut app, &ctx, "Convert:", 1);
let sp = app.session.active().unwrap().doc.node(id).unwrap().path_data().unwrap().subpaths[0].clone();
assert!(sp.anchors.iter().all(|a| a.has_in() && a.has_out()), "every corner made smooth: {sp:?}");
}
/// Use the normal application frame: canvas pointer picking and the keyboard shortcut dispatcher.
fn anchor_delete_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<Event>) {
let screen = Rect::from_min_size(Pos2::ZERO, vec2(1600.0, 900.0));
let time = ctx.input(|i| i.time) + 0.1;
let mut out = ctx.run_ui(egui::RawInput { screen_rect: Some(screen), time: Some(time), events, ..Default::default() }, |ui| {
app.logic(ui.ctx());
app.ui(ui);
});
out.textures_delta.clear();
}
/// Real canvas picking and both deletion keys split an ordinary path, then clear every survivor.
#[test]
fn open_anchor_delete_and_backspace_cut_the_clicked_anchor_then_clear() {
for key in [egui::Key::Delete, egui::Key::Backspace] {
let mut app = app();
let id = NodeId(
app.run(
"path.create",
json!({"anchors": [
{"x": 50, "y": 100}, {"x": 100, "y": 80}, {"x": 150, "y": 100},
{"x": 200, "y": 120}, {"x": 250, "y": 100}
]}),
)
.unwrap()["id"]
.as_u64()
.unwrap(),
);
app.select_tool("directSelection");
let ctx = egui::Context::default();
crate::theme::install_fonts(&ctx);
for _ in 0..3 {
anchor_delete_frame(&mut app, &ctx, vec![]);
}
let at = Xf::new(app.canvas_rect.unwrap(), app.view().unwrap()).to_screen(Point::new(150.0, 100.0));
let click = |pressed| Event::PointerButton { pos: at, button: PointerButton::Primary, pressed, modifiers: Default::default() };
anchor_delete_frame(&mut app, &ctx, vec![Event::PointerMoved(at), click(true)]);
anchor_delete_frame(&mut app, &ctx, vec![click(false)]);
assert_eq!(app.session.tool_id(), "directSelection");
let st = app.session.doc().unwrap();
assert_eq!(st.selection.anchors[&id], [(0, 2)].into(), "the real canvas click selected the interior anchor");
assert!(st.selection.segments.is_empty());
let before = st.doc.clone();
let selection = st.selection.clone();
let undo = st.history.undo.len();
let press = |pressed| Event::Key { key, physical_key: None, pressed, repeat: false, modifiers: Default::default() };
anchor_delete_frame(&mut app, &ctx, vec![press(true)]);
anchor_delete_frame(&mut app, &ctx, vec![press(false)]);
let st = app.session.doc().unwrap();
let pieces = st.selection.objects.clone();
assert_eq!(pieces.len(), 2);
assert_eq!(pieces[0], id);
let points: Vec<Vec<_>> = pieces
.iter()
.map(|piece| {
let path = st.doc.node(*piece).unwrap().path_data().unwrap();
assert_eq!(path.subpaths.len(), 1);
assert!(!path.subpaths[0].closed);
path.subpaths[0].anchors.iter().map(|a| a.p).collect()
})
.collect();
assert_eq!(
points,
vec![vec![Point::new(50.0, 100.0), Point::new(100.0, 80.0)], vec![Point::new(200.0, 120.0), Point::new(250.0, 100.0)]],
"{key:?} must not join the gap"
);
assert!(st.selection.anchors.is_empty() && st.selection.segments.is_empty());
assert_eq!(st.history.undo.len(), undo + 1);
let after = st.doc.clone();
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.doc().unwrap().doc, before);
assert_eq!(app.session.doc().unwrap().selection, selection);
app.run("edit.redo", json!({})).unwrap();
assert_eq!(app.session.doc().unwrap().doc, after);
assert_eq!(app.session.doc().unwrap().selection.objects, pieces);
anchor_delete_frame(&mut app, &ctx, vec![press(true)]);
anchor_delete_frame(&mut app, &ctx, vec![press(false)]);
assert!(pieces.iter().all(|piece| app.session.doc().unwrap().doc.node(*piece).is_none()), "the next {key:?} clears every piece");
}
}
No file is open. Choose one in the tree, or press Ctrl+O (⌘O on a Mac) to find one by name.
Syntax highlighting could not load. The unmodified read-only text remains available above.