Swatches: a drop lands where the button came up, with the keys held then

A drop on the Swatches panel is decided by the position and modifiers of
the primary button's release, so moving on to another swatch or letting
go of Alt later in the same frame no longer changes which swatch takes
the drop or whether it replaces one. Hover feedback still follows the
pointer and the keys held now.

Replace Pattern Art also refuses type whose inline graphic shows a
symbol painted with the pattern, which would make a tile that refers to
itself.
This commit is contained in:
dotCooCoo committed 2026-11-18 17:07:36 -08:00
1 parent e496cfd103
commit 5e62518a09
4 files changed
+134 -34

No files matched your search

+8 -5
View File
@@ -473,9 +473,9 @@ enum Uses<'a> {
Brush(&'a str),
}
/// Does `art` paint pattern `name`, itself or through the symbols, patterns, graph designs and
/// brushes it uses? A graph's stored series and label paints count, since its marks and labels
/// take them each time it is drawn again.
/// Does `art` paint pattern `name`, itself or through the symbols (of its instances and of the
/// inline graphics in its type), patterns, graph designs and brushes it uses? A graph's stored
/// series and label paints count, since its marks and labels take them each time it is drawn again.
fn paints_pattern(d: &Document, art: &[Arc<Node>], name: &str) -> bool {
let brushes = vectorcraft_brush::library(d);
// What was already looked into, and the art left to look at.
@@ -484,8 +484,11 @@ fn paints_pattern(d: &Document, art: &[Arc<Node>], name: &str) -> bool {
while let Some(n) = left.pop() {
let mut used = vec![];
walk_with_masks(n, &mut |c| {
if let NodeKind::SymbolInstance { symbol, .. } = &c.kind {
used.push(Uses::Symbol(symbol.as_str()));
match &c.kind {
NodeKind::SymbolInstance { symbol, .. } => used.push(Uses::Symbol(symbol.as_str())),
// The symbol of every inline graphic in type counts, overset or not.
NodeKind::Text(t) => used.extend(t.runs.iter().filter_map(|r| r.inline.as_ref()).map(|a| Uses::Symbol(a.symbol.as_str()))),
_ => {}
}
for it in &c.appearance.items {
if let vectorcraft_doc::AppearanceItem::Stroke(sk) = it
+6 -1
View File
@@ -285,7 +285,8 @@ fn replace_art_that_matches_the_tile_art_records_nothing() {
/// Replace Pattern Art is refused, changing nothing, for a missing name or pattern, with no art,
/// while a pattern is edited, and for art painted with the pattern itself, directly, through
/// another pattern, through a symbol, through the paints a graph stores, through a graph design a
/// graph draws its columns with and through the art of a brush on a stroke.
/// graph draws its columns with, through the art of a brush on a stroke and through the symbol of an
/// inline graphic in type.
#[test]
fn replace_art_is_refused_without_changing_anything() {
let mut s = session();
@@ -321,6 +322,9 @@ fn replace_art_is_refused_without_changing_anything() {
s.execute("paint.setFill", &json!({"ids": [brushed.0], "none": true})).unwrap();
s.execute("paint.setStroke", &json!({"ids": [brushed.0], "color": "#000000"})).unwrap();
s.execute("brush.apply", &json!({"name": "Dotted brush", "ids": [brushed.0]})).unwrap();
// Type that shows symbol "Dotted" as an inline graphic.
let typed = id_of(&s.execute("text.create", &json!({"x": 20, "y": 420, "text": "Hi"})).unwrap());
s.execute("text.insertInline", &json!({"id": typed.0, "at": 0, "symbol": "Dotted"})).unwrap();
let plain = blue_rect(&mut s);
let unchanged = |s: &Session, before: &vectorcraft_doc::Document, steps: usize, case: &str| {
assert_eq!(doc(s), before, "{case}: the document stays");
@@ -337,6 +341,7 @@ fn replace_art_is_refused_without_changing_anything() {
("through a graph's paints", json!({"name": "Dots", "ids": [graph.0]}), "art painted with `Dots` can't be its tile".into()),
("through a graph design", json!({"name": "Dots", "ids": [designed.0]}), "art painted with `Dots` can't be its tile".into()),
("through a brush", json!({"name": "Dots", "ids": [brushed.0]}), "art painted with `Dots` can't be its tile".into()),
("through an inline graphic", json!({"name": "Dots", "ids": [typed.0]}), "art painted with `Dots` can't be its tile".into()),
] {
let err = s.execute("object.pattern.replaceArt", &p).unwrap_err();
assert!(err.to_string().contains(&why), "{case}: {err}");
+73 -28
View File
@@ -88,10 +88,36 @@ impl Drop {
}
}
/// The drag held over `resp`, if the panel takes it (paints and art dragged off the canvas, not the
/// Appearance panel's thumbnail).
/// Whether the panel takes drag `d`: paints and art dragged off the canvas, not the Appearance
/// panel's thumbnail.
fn takes(d: &PanelDrag) -> bool {
matches!(d, PanelDrag::Paint { .. } | PanelDrag::Art(_))
}
/// The drag held over `resp`, if the panel takes it ([`takes`]).
fn held(resp: &Response) -> Option<std::sync::Arc<PanelDrag>> {
resp.dnd_hover_payload::<PanelDrag>().filter(|d| matches!(**d, PanelDrag::Paint { .. } | PanelDrag::Art(_)))
resp.dnd_hover_payload::<PanelDrag>().filter(|d| takes(d))
}
/// The drag in progress, if the panel takes it ([`takes`]), wherever the pointer is.
fn dragged(ui: &Ui) -> Option<std::sync::Arc<PanelDrag>> {
egui::DragAndDrop::payload::<PanelDrag>(ui.ctx()).filter(|d| takes(d))
}
/// Where the primary button came up this frame and the modifiers held then, when that was over
/// `resp` with no other layer on top (the test [`egui::Context::rect_contains_pointer`] makes of the
/// pointer). A drop lands there with those modifiers, even when the pointer moved on or a key was
/// let go later in the same frame.
fn released_over(ui: &Ui, resp: &Response) -> Option<(egui::Pos2, egui::Modifiers)> {
let up = ui.input(|i| {
i.events.iter().find_map(|e| match e {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, modifiers } => Some((*pos, *modifiers)),
_ => None,
})
})?;
let ctx = ui.ctx();
let rect = ctx.layer_transform_to_global(resp.layer_id).map_or(resp.interact_rect, |t| t * resp.interact_rect);
(rect.is_positive() && rect.contains(up.0) && ctx.layer_id_at(up.0) == Some(resp.layer_id)).then_some(up)
}
/// The drag a tile or row of `e` starts, moving rows `names`. Colour groups have no paint of their
@@ -158,57 +184,76 @@ pub(super) fn tile_input(ui: &Ui, resp: Response, e: &Entry, items: &[Entry], se
}
/// A drag held over the tile or row `resp` of entry `e` shows where it would land (before or after
/// it by the pointer's half, or into a folder); a release there sets the drop.
/// it by the pointer's half, or into a folder), by where the pointer is and the keys held now. A
/// release over it ([`released_over`]) sets the drop, by where the button came up and the keys held
/// then.
fn tile_drop(ui: &Ui, resp: &Response, e: &Entry, list: bool, ev: &mut TileEvents) {
let Some(d) = held(resp) else { return };
let up = released_over(ui, resp);
let hover = held(resp);
let Some(d) = hover.clone().or_else(|| up.and_then(|_| dragged(ui))) else { return };
let take = || egui::DragAndDrop::take_payload::<PanelDrag>(ui.ctx()).is_some();
// Art held with Alt over a pattern swatch would replace its tile art, and the swatch is
// outlined; other art goes to the list (see [`zone_input`]).
if let PanelDrag::Art(_) = &*d {
if crate::panels::alt_held(ui) && matches!(e, Entry::Swatch { paint: Paint::Pattern { .. }, .. }) {
if !matches!(e, Entry::Swatch { paint: Paint::Pattern { .. }, .. }) {
return;
}
if hover.is_some() && crate::panels::alt_held(ui) {
ev.over = true;
let t = Tokens::get(ui.ctx());
ui.painter().rect_stroke(resp.rect.expand(1.0), 0.0, Stroke::new(1.5, t.accent), StrokeKind::Outside);
if resp.dnd_release_payload::<PanelDrag>().is_some() {
ev.drop = Drop::of(&d, Some(e.name().to_string()), false, true);
}
}
if up.is_some_and(|(_, m)| m.alt) && take() {
ev.drop = Drop::of(&d, Some(e.name().to_string()), false, true);
}
return;
}
let PanelDrag::Paint { rows, .. } = &*d else { return };
let name = e.name();
ev.over = true;
if hover.is_some() {
ev.over = true;
}
// Swatches dropped on one of themselves stay where they are.
if rows.as_ref().is_some_and(|r| r.names.iter().any(|n| n == name)) {
resp.dnd_release_payload::<PanelDrag>();
if up.is_some() {
take();
}
return;
}
let t = Tokens::get(ui.ctx());
let r = resp.rect;
let at = ui.input(|i| i.pointer.interact_pos()).unwrap_or(r.center());
let after = if list { at.y > r.center().y } else { at.x > r.center().x };
// A paint from elsewhere, or swatches over a folder, go into it; otherwise a bar marks the slot.
if rows.as_ref().is_none_or(|d| e.is_folder() && !d.groups) {
ui.painter().rect_stroke(r.expand(1.0), 0.0, Stroke::new(1.5, t.accent), StrokeKind::Outside);
} else if list {
let y = if after { r.bottom() } else { r.top() };
ui.painter().line_segment([pos2(r.left(), y), pos2(r.right(), y)], Stroke::new(2.0, t.accent));
} else {
let x = if after { r.right() + 0.75 } else { r.left() - 0.75 };
ui.painter().line_segment([pos2(x, r.top() - 1.0), pos2(x, r.bottom() + 1.0)], Stroke::new(2.0, t.accent));
let side = |at: egui::Pos2| if list { at.y > r.center().y } else { at.x > r.center().x };
if hover.is_some() {
let t = Tokens::get(ui.ctx());
let after = side(ui.input(|i| i.pointer.interact_pos()).unwrap_or(r.center()));
// A paint from elsewhere, or swatches over a folder, go into it; otherwise a bar marks the slot.
if rows.as_ref().is_none_or(|d| e.is_folder() && !d.groups) {
ui.painter().rect_stroke(r.expand(1.0), 0.0, Stroke::new(1.5, t.accent), StrokeKind::Outside);
} else if list {
let y = if after { r.bottom() } else { r.top() };
ui.painter().line_segment([pos2(r.left(), y), pos2(r.right(), y)], Stroke::new(2.0, t.accent));
} else {
let x = if after { r.right() + 0.75 } else { r.left() - 0.75 };
ui.painter().line_segment([pos2(x, r.top() - 1.0), pos2(x, r.bottom() + 1.0)], Stroke::new(2.0, t.accent));
}
}
if resp.dnd_release_payload::<PanelDrag>().is_some() {
ev.drop = Drop::of(&d, Some(name.to_string()), after, crate::panels::alt_held(ui));
if let Some((at, m)) = up
&& take()
{
ev.drop = Drop::of(&d, Some(name.to_string()), side(at), m.alt);
}
}
/// Drops between and after the tiles (`zone`: the list's viewport) go to the end of the ungrouped
/// swatches (colour groups to the end of the groups); the list is outlined while one is held there.
/// A tile that took the release first leaves nothing to drop here.
pub(super) fn zone_input(ui: &Ui, zone: &Response, ev: &mut TileEvents) {
let Some(d) = held(zone) else { return };
if !ev.over {
if held(zone).is_some() && !ev.over {
ui.painter().rect_stroke(zone.rect, 0.0, Stroke::new(1.5, Tokens::get(ui.ctx()).accent), StrokeKind::Inside);
}
if zone.dnd_release_payload::<PanelDrag>().is_some() {
if released_over(ui, zone).is_some()
&& let Some(d) = dragged(ui)
&& egui::DragAndDrop::take_payload::<PanelDrag>(ui.ctx()).is_some()
{
ev.drop = Drop::of(&d, None, false, false);
}
}
@@ -869,6 +869,53 @@ fn art_alt_dropped_on_a_pattern_swatch_replaces_its_tile_art() {
assert_eq!(tile_art(&app), Some(art), "Dots keeps its tile art");
}
/// A drop lands where the button came up, with the keys held then. Art released with Alt held
/// over pattern swatch Dots replaces the tile art of Dots when Alt is let go, or the pointer moves
/// on to pattern swatch Stripes, later in the same frame. Art released over Dots without Alt makes
/// a new pattern when Alt is pressed later in that frame. A color released with Alt held over Red
/// gives Red that color when Alt is let go later in the frame.
#[test]
fn a_drop_lands_where_the_button_came_up_with_the_keys_held_then() {
let mut app = app();
for (x, name) in [(0, "Dots"), (20, "Stripes")] {
let id = app.run("shape.rectangle", json!({"x": x, "y": 0, "width": 10, "height": 10})).unwrap()["id"].as_u64().unwrap();
app.run("object.pattern.make", json!({"ids": [id], "name": name, "edit": false})).unwrap();
}
let id = app.run("shape.star", json!({"cx": 50, "cy": 50, "radius1": 20, "radius2": 9, "points": 5})).unwrap()["id"].as_u64().unwrap();
let star = vectorcraft_doc::NodeId(id);
let star_kind = app.session.doc().unwrap().doc.node(star).map(|n| n.kind.clone());
let tile_kind =
|app: &VectorcraftApp, name: &str| app.session.doc().unwrap().doc.pattern(name).and_then(|p| p.art.first().map(|n| n.kind.clone()));
let count = |app: &mut VectorcraftApp| app.run("pattern.list", json!({})).unwrap()["patterns"].as_array().map(Vec::len);
let ctx = context();
// In one frame: release over `on` with `up` held, then hold `then` and move over `to`.
let drop = |app: &mut VectorcraftApp, payload: PanelDrag, on: &str, up: Modifiers, then: Modifiers, to: &str, time: f64| {
frame(app, &ctx, vec![], time, show);
let (at, next) = (tile_center(&ctx, on), tile_center(&ctx, to));
egui::DragAndDrop::set_payload(&ctx, payload);
let release = Event::PointerButton { pos: at, button: PointerButton::Primary, pressed: false, modifiers: up };
let events = vec![Event::PointerMoved(at), release, Event::ModifiersChanged(then), Event::PointerMoved(next)];
frame_with(app, &ctx, events, up, time + 0.5, show);
assert!(egui::DragAndDrop::payload::<PanelDrag>(&ctx).is_none(), "{on}: the drop is taken");
};
let stripes = tile_kind(&app, "Stripes");
drop(&mut app, PanelDrag::Art(vec![star]), "Dots", Modifiers::ALT, Modifiers::NONE, "Dots", 0.0);
assert_eq!(tile_kind(&app, "Dots"), star_kind, "Alt let go after the release: {}", app.ui.status);
assert_eq!(count(&mut app), Some(2), "no new pattern");
app.run("edit.undo", json!({})).unwrap();
drop(&mut app, PanelDrag::Art(vec![star]), "Dots", Modifiers::ALT, Modifiers::ALT, "Stripes", 1.0);
assert_eq!(tile_kind(&app, "Dots"), star_kind, "the pointer moved on to Stripes after the release");
assert_eq!(tile_kind(&app, "Stripes"), stripes, "Stripes keeps its tile art");
app.run("edit.undo", json!({})).unwrap();
let dots = tile_kind(&app, "Dots");
drop(&mut app, PanelDrag::Art(vec![star]), "Dots", Modifiers::NONE, Modifiers::ALT, "Dots", 2.0);
assert_eq!(count(&mut app), Some(3), "Alt pressed after a plain release makes a pattern");
assert_eq!(tile_kind(&app, "Dots"), dots, "Dots keeps its tile art");
let rgb = Color::from_hex("#2a6fb0").unwrap();
drop(&mut app, PanelDrag::paint(Paint::solid(rgb)), "Red", Modifiers::ALT, Modifiers::NONE, "Red", 3.0);
assert_eq!(app.session.doc().unwrap().doc.swatch("Red").map(|w| w.paint.color()), Some(Some(rgb)), "Alt let go after the release on Red");
}
#[test]
fn a_proxy_dropped_on_the_panel_becomes_a_swatch() {
let mut app = app();