Merge pull request #8114 from dotCooCoo/feat/drag-into-floating-window

Arrange: a Selection drag released in another document's floating window drops the artwork there
This commit is contained in:
BFlat
2026-11-16 23:54:12 +07:00
committed by GitHub
14 changed files with 904 additions and 37 deletions
+12 -5
View File
@@ -495,12 +495,14 @@ impl VectorcraftApp {
/// The canvas panel's body: the document tabs, the canvas (a pane for each document while
/// Window › Arrange › Tile is on) and the isolation bar over it. While the current document is
/// in a floating window, the tab strip's document draws as a pane.
/// in a floating window, the tab strip's document draws as a pane, which a Selection drag's
/// artwork can be released in ([`canvas::note_drop`]).
pub(crate) fn canvas_area(&mut self, ui: &mut egui::Ui) {
let t = theme::Tokens::get(ui.ctx());
// Tools may already occupy the left side of this panel.
ui.painter().rect_filled(ui.available_rect_before_wrap(), 0.0, t.pasteboard);
self.canvas.windows.strip = None;
self.canvas.windows.drops.clear();
if self.ui.screen_mode < 3 {
chrome::doc_tabs(self, ui);
}
@@ -509,10 +511,15 @@ impl VectorcraftApp {
if !canvas::tiled_area(self, ui) {
if floats {
let rect = ui.available_rect_before_wrap();
if let Some(w) = crate::doc_windows::tab_window(self)
&& canvas::pane(self, ui, w, rect)
{
crate::doc_windows::show_window(self, w);
if let Some(w) = crate::doc_windows::tab_window(self) {
let pressed = canvas::pane(self, ui, w, rect);
// A drag from a current window that is an OS window ends in that window.
if !crate::doc_windows::native(self, ui.ctx()) {
canvas::note_drop(self, ui, w, rect);
}
if pressed {
crate::doc_windows::show_window(self, w);
}
}
} else {
canvas::show(self, ui);
+2 -2
View File
@@ -42,7 +42,7 @@ pub use cursor::{HOVER_STILL_SECS, STILL_SECS, ViewKey};
use cursor::{cursor_icon, hover_cursor, hover_wait, still_wait};
use drag::drag_id;
pub use drag::{apply_requests, dispatch, mods};
pub(crate) use drag::{end_document_drag, pose_on_page, release_art_in_window, release_over_panel};
pub(crate) use drag::{art_out, end_art_move, end_document_drag, pose_on_page, release_art_in_window, release_over_panel};
#[cfg(test)]
use drag::{frame_moves, tool_drag_doc_id, tool_drag_moved, tool_frame_moves, tool_press_doc_id};
pub use fill::Fill;
@@ -65,7 +65,7 @@ pub use overlays::SharedPaths;
use overlays::selected_anchor;
use overlays::{HandleLook, blend_widgets_overlay, draw_inside_overlay, draw_overlays, hover_highlight, ime_geometry, selection_overlay};
pub use panes::Panes;
pub(crate) use panes::{consolidate, pane, tile, tiled_area};
pub(crate) use panes::{consolidate, note_drop, noted_cursor, pane, release_on_noted, tile, tiled_area};
use raster::{changed_pixels, frame_ppp, pixel_region, upload};
pub(crate) use raster::{color_image, color_image_owned, render_job};
pub use selection_marks::SelectionMarks;
+11 -2
View File
@@ -29,6 +29,11 @@ pub(crate) fn end_document_drag(ctx: &egui::Context) {
});
}
/// Whether a Selection tool move has left the canvas ([`drag_art_out`]) and still waits there.
pub(crate) fn art_out(ctx: &egui::Context) -> bool {
matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Art))
}
/// Temp-memory key for the active canvas drag state.
pub(super) fn drag_id() -> egui::Id {
egui::Id::unique("canvas-drag")
@@ -320,6 +325,9 @@ pub(super) fn drag_art_out(app: &VectorcraftApp, ui: &Ui, resp: &egui::Response,
/// panel that takes the art ([`widgets::PanelDrag::Art`]) takes it where it was, and no move is
/// left open (#2826). The art stays where it last moved while the pointer is over the panel.
pub(crate) fn release_over_panel(app: &mut VectorcraftApp, ctx: &egui::Context) {
// A floating window's pane, or the main window's while the current window floats, takes the
// art first.
super::release_on_noted(app, ctx);
crate::document_drag::cleanup(app, ctx);
let art = matches!(ctx.data(|d| d.get_temp::<Drag>(drag_id())), Some(Drag::Art));
// Over a floating panel's own OS window the pointer is gone from this window, and the release
@@ -355,8 +363,9 @@ pub(crate) fn release_art_in_window(app: &mut VectorcraftApp, ctx: &egui::Contex
}
}
/// Roll back the art move dragged off the canvas; a panel takes the art instead.
fn end_art_move(app: &mut VectorcraftApp, ctx: &egui::Context) {
/// Roll back the art move dragged off the canvas, and end the canvas's drag; a panel or another
/// window's tiled pane takes the art instead.
pub(crate) fn end_art_move(app: &mut VectorcraftApp, ctx: &egui::Context) {
// With no document open there is nothing to roll back; the tool still gets its mouse-up.
let _ = app.session.cancel_interaction();
let view = app.view_info();
+89 -4
View File
@@ -1,8 +1,9 @@
//! Window › Arrange › Tile: every open document in a pane of its own, edge to edge in the document
//! area. The current document's pane is the canvas ([`super::show`]). Each other pane draws its
//! document from a render of its own, with its artboards, guides and selected objects, and a press
//! in it makes its document the current one. Each view Window › New Window opened has a pane of
//! its own ([`crate::doc_windows`]).
//! in it makes its document the current one. A Selection drag released in it drops the dragged
//! artwork into its document ([`crate::document_drag::drop_on_pane`]). Each view Window › New
//! Window opened has a pane of its own ([`crate::doc_windows`]).
use std::collections::HashMap;
use std::sync::Arc;
@@ -243,12 +244,18 @@ pub(crate) fn tiled_area(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {
let areas: Vec<(Win, egui::Rect)> = cells.iter().map(|(w, cell)| (*w, view_rects(app, *cell, ppp).1)).collect();
let unfitted = refit_resized(app, &areas);
let mut activate = None;
let (mut cursor, mut dropped) = (None, None);
// The other panes first, so that what the canvas draws past its pane (the Contextual Task Bar)
// stays over them.
for (w, cell) in cells.iter().copied().filter(|(w, _)| Some(*w) != active) {
for ((w, cell), (_, area)) in cells.iter().copied().zip(areas.iter().copied()).filter(|((w, _), _)| Some(*w) != active) {
if pane(app, ui, w, cell) {
activate = Some(w);
}
match artwork_over(app, ui, w, area) {
Some(Over::Held(c)) => cursor = Some(c),
Some(Over::Released(at, carried)) => dropped = Some((w, at, carried)),
None => {}
}
ui.painter().rect_stroke(cell, 0.0, Stroke::new(1.0, t.border), StrokeKind::Inside);
}
if let Some((_, cell)) = cells.iter().copied().find(|(w, _)| Some(*w) == active) {
@@ -256,6 +263,10 @@ pub(crate) fn tiled_area(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {
super::show(app, &mut canvas);
ui.painter().rect_stroke(cell, 0.0, Stroke::new(1.5, t.accent), StrokeKind::Inside);
}
// After the canvas, which sets the cursor of the drag it holds.
if let Some(c) = cursor {
ui.ctx().set_cursor_icon(c);
}
// Note the fits this frame made, for `refit_resized`.
for ((w, area), was_unfitted) in areas.iter().zip(unfitted) {
if let (true, Some(v), Some(s)) = (was_unfitted, crate::doc_windows::view(app, *w).filter(|v| v.fitted).copied(), slot(app, *w)) {
@@ -263,12 +274,86 @@ pub(crate) fn tiled_area(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {
}
}
app.canvas.panes.last = cells;
if let Some(w) = activate {
if let Some((w, at, carried)) = dropped {
crate::document_drag::drop_on_pane(app, ui.ctx(), w, at, carried);
} else if let Some(w) = activate {
crate::doc_windows::show_window(app, w);
}
true
}
/// A Selection drag's artwork over another window's tiled pane.
enum Over {
/// Held there: the cursor that shows whether a release moves or copies it.
Held(egui::CursorIcon),
/// Released there, at a document point in the pane's own view.
Released(Point, crate::document_drag::Carried),
}
/// A Selection drag's artwork over `area`, the part of window `w`'s pane inside its rulers and
/// scroll bars, where no panel or floating window is over the pointer. A release there takes the
/// artwork before the canvas sees the release ([`crate::document_drag::take_for_pane`]).
fn artwork_over(app: &mut VectorcraftApp, ui: &Ui, w: Win, area: egui::Rect) -> Option<Over> {
let (uid, _) = slot(app, w)?;
let p = ui.input(crate::document_drag::released_at)?;
if !area.contains(p) || ui.ctx().layer_id_at(p).is_some_and(|l| l != ui.layer_id()) {
return None;
}
let cursor = crate::document_drag::pane_cursor(app, ui.ctx(), uid)?;
if !ui.input(|i| i.pointer.primary_released()) {
return Some(Over::Held(cursor));
}
let v = crate::doc_windows::view(app, w).copied()?;
let at = Xf::at(area, &v, ui.ctx().zoom_factor()).to_doc(p);
Some(Over::Released(at, crate::document_drag::take_for_pane(app, ui.ctx())?))
}
/// Note window `w`'s pane, drawn in `cell` of `ui` outside Tile (a floating window inside the main
/// window, or the main window while the current window floats), as a place a Selection drag's
/// artwork can be released in ([`release_on_noted`]): the part inside its rulers and scroll bars.
pub(crate) fn note_drop(app: &mut VectorcraftApp, ui: &Ui, w: Win, cell: egui::Rect) {
let Some(s) = slot(app, w) else { return };
let area = view_rects(app, cell, ui.ctx().pixels_per_point()).1;
app.canvas.windows.drops.push((s, area, ui.layer_id()));
}
/// The noted pane ([`note_drop`]) at `p`, where no panel or other window is over it: its window
/// and its art area.
fn noted_at(app: &VectorcraftApp, ctx: &egui::Context, p: egui::Pos2) -> Option<(Win, egui::Rect)> {
let top = ctx.layer_id_at(p);
let (s, area, _) = app.canvas.windows.drops.iter().rev().find(|(_, area, layer)| area.contains(p) && top.is_none_or(|l| l == *layer))?;
let w = crate::doc_windows::windows(app).into_iter().find(|w| slot(app, *w) == Some(*s))?;
Some((w, *area))
}
/// A Selection drag's artwork released over a pane the last frame noted ([`note_drop`]) drops into
/// its document ([`crate::document_drag::drop_on_pane`]), at the document point where the button
/// went up, in that pane's own view. Runs at the start of a frame, before any canvas sees the release.
pub(crate) fn release_on_noted(app: &mut VectorcraftApp, ctx: &egui::Context) {
if app.canvas.windows.drops.is_empty() || !ctx.input(|i| i.pointer.primary_released()) {
return;
}
let Some(p) = ctx.input(crate::document_drag::released_at) else { return };
let Some((w, area)) = noted_at(app, ctx, p) else { return };
let Some(v) = crate::doc_windows::view(app, w).copied() else { return };
let at = Xf::at(area, &v, ctx.zoom_factor()).to_doc(p);
if let Some(carried) = crate::document_drag::take_for_pane(app, ctx) {
crate::document_drag::drop_on_pane(app, ctx, w, at, carried);
}
}
/// While a Selection drag's artwork is held over a pane this frame noted ([`note_drop`]), the cursor
/// shows whether a release there moves or copies it ([`crate::document_drag::pane_cursor`]).
pub(crate) fn noted_cursor(app: &VectorcraftApp, ctx: &egui::Context) {
let Some(p) = ctx.input(|i| i.pointer.interact_pos()) else { return };
if let Some((w, _)) = noted_at(app, ctx, p)
&& let Some((uid, _)) = slot(app, w)
&& let Some(c) = crate::document_drag::pane_cursor(app, ctx, uid)
{
ctx.set_cursor_icon(c);
}
}
/// Window `w`'s [`Slot`].
fn slot(app: &VectorcraftApp, (i, n): Win) -> Option<Slot> {
app.session.documents().get(i).map(|d| (d.uid, n))
+248
View File
@@ -165,6 +165,254 @@ fn a_press_in_another_pane_makes_its_document_current_without_drawing() {
assert!(app.session.documents()[1..].iter().all(|d| d.doc.art_bounds().is_none()));
}
/// One headless frame at `time` seconds as the app runs it: a Selection move released off the
/// canvas ends first ([`crate::canvas::release_over_panel`]), then the tabs and the panes draw.
fn timed_frame(app: &mut VectorcraftApp, ctx: &egui::Context, time: Option<f64>, events: Vec<egui::Event>) -> egui::FullOutput {
let raw = egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0))),
max_texture_side: Some(8192),
time,
events,
..Default::default()
};
let mut out = ctx.run_ui(raw, |ui| {
crate::canvas::release_over_panel(app, ui.ctx());
app.canvas_area(ui);
});
out.textures_delta.clear();
out
}
/// [`timed_frame`] without a time. → the cursor.
fn app_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> egui::CursorIcon {
timed_frame(app, ctx, None, events).platform_output.cursor_icon
}
/// Two 400 × 300 pt documents tiled side by side: the first, current, holds a selected 100 pt
/// square at 50, 50 and the second a 50 pt square at 300, 230. The Selection tool is chosen.
fn tiled_pair() -> (VectorcraftApp, egui::Context) {
let mut app = app_with(0);
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 50, "y": 50, "width": 100, "height": 100})).unwrap();
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 300, "y": 230, "width": 50, "height": 50})).unwrap();
app.run("document.activate", json!({"index": 0})).unwrap();
app.select_tool("selection");
app.ui.task_bar = false;
app.run("window.arrange.tile", json!({})).unwrap();
let ctx = egui::Context::default();
app_frame(&mut app, &ctx, vec![]);
app_frame(&mut app, &ctx, vec![]);
(app, ctx)
}
/// Press on document point `at` on the canvas and move the pointer 20 × 10 points, still on the
/// canvas: the Selection tool moves the art under it.
fn grab(app: &mut VectorcraftApp, ctx: &egui::Context, at: Point) {
let p = Xf::at(app.canvas_rect.unwrap(), app.view().unwrap(), 1.0).to_screen(at);
app_frame(app, ctx, vec![egui::Event::PointerMoved(p), button(p, true)]);
app_frame(app, ctx, vec![egui::Event::PointerMoved(p + vec2(20.0, 10.0))]);
assert!(app.session.in_interaction(), "the Selection tool moves the art");
}
/// Window `w`'s pane: the screen point that shows document point `at` in it, and the pane.
fn in_pane(app: &VectorcraftApp, ctx: &egui::Context, w: Win, at: Point) -> (Pos2, egui::Rect) {
let (_, cell) = app.canvas.panes.last.iter().copied().find(|(o, _)| *o == w).unwrap();
let area = view_rects(app, cell, ctx.pixels_per_point()).1;
(Xf::at(area, crate::doc_windows::view(app, w).unwrap(), 1.0).to_screen(at), cell)
}
/// How many objects document `i`'s first layer holds.
fn objects(app: &VectorcraftApp, i: usize) -> usize {
app.session.documents()[i].doc.layers[0].children().map_or(0, Vec::len)
}
/// The bounds of the one object selected in the current document.
fn selected_bounds(app: &VectorcraftApp) -> Rect {
let st = app.session.active().unwrap();
assert_eq!(st.selection.objects.len(), 1, "one object is selected");
st.doc.node(st.selection.objects[0]).unwrap().geometric_bounds().unwrap()
}
#[test]
fn a_selection_drag_released_in_another_documents_pane_copies_the_art_there() {
let (mut app, ctx) = tiled_pair();
// The target's view differs from the source's: the grab point still lands under the pointer.
app.views[1].zoom *= 0.6;
app.views[1].rotation = 30.0;
app_frame(&mut app, &ctx, vec![]);
let source = app.session.documents()[0].doc.clone();
let source_undo = app.session.documents()[0].history.undo.len();
let target = app.session.documents()[1].doc.clone();
let target_undo = app.session.documents()[1].history.undo.len();
let clipboard = app.session.clipboard.clone();
grab(&mut app, &ctx, Point::new(100.0, 100.0));
let (drop, _) = in_pane(&app, &ctx, (1, 1), Point::new(170.0, 120.0));
// The release comes in the first frame the pointer is over the pane.
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop), button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(1), "the pane's document is the current one");
let placed = selected_bounds(&app);
assert!((placed.center().x - 170.0).abs() < 0.01 && (placed.center().y - 120.0).abs() < 0.01, "{placed:?}");
assert_eq!(app.session.documents()[1].history.undo.len(), target_undo + 1, "one step to undo");
assert_eq!(app.session.documents()[0].doc, source, "the source keeps its art where it was");
assert_eq!(app.session.documents()[0].history.undo.len(), source_undo);
assert_eq!(app.session.clipboard, clipboard, "the drag leaves the clipboard alone");
assert!(!app.session.tool_busy());
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.documents()[1].doc, target);
app.run("edit.redo", json!({})).unwrap();
assert_eq!(app.session.documents()[1].history.undo.len(), target_undo + 1);
}
#[test]
fn art_held_over_another_pane_shows_a_copy_and_drags_back_the_other_way() {
let (mut app, ctx) = tiled_pair();
grab(&mut app, &ctx, Point::new(100.0, 100.0));
let (over, _) = in_pane(&app, &ctx, (1, 1), Point::new(200.0, 150.0));
let cursor = app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(over)]);
assert_eq!(cursor, egui::CursorIcon::Copy, "over another document's pane the art is copied");
assert_eq!(app.session.active_index(), Some(0), "holding the art over a pane does not switch documents");
let (drop, _) = in_pane(&app, &ctx, (1, 1), Point::new(120.0, 90.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(1));
assert_eq!(objects(&app, 1), 2, "the copy joins the target's square");
// From the target, now the canvas, back into the first document's pane.
app_frame(&mut app, &ctx, vec![]);
grab(&mut app, &ctx, Point::new(325.0, 255.0));
let (back, _) = in_pane(&app, &ctx, (0, 1), Point::new(300.0, 200.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(back), button(back, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(0));
let placed = selected_bounds(&app);
assert!((placed.center().x - 300.0).abs() < 0.01 && (placed.center().y - 200.0).abs() < 0.01, "{placed:?}");
assert_eq!(objects(&app, 0), 2);
}
#[test]
fn a_selection_drag_into_another_view_of_its_document_moves_the_art() {
let (mut app, ctx) = tiled_pair();
app.run("window.newWindow", json!({})).unwrap();
app.run("window.arrange.tile", json!({})).unwrap();
app_frame(&mut app, &ctx, vec![]);
app_frame(&mut app, &ctx, vec![]);
let current = crate::doc_windows::current(&app).unwrap();
let other = app.canvas.panes.last.iter().map(|(w, _)| *w).find(|w| w.0 == 0 && *w != current).unwrap();
let undo = app.session.documents()[0].history.undo.len();
let target = app.session.documents()[1].doc.clone();
grab(&mut app, &ctx, Point::new(100.0, 100.0));
let (drop, _) = in_pane(&app, &ctx, other, Point::new(250.0, 200.0));
let cursor = app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
assert_eq!(cursor, egui::CursorIcon::Move, "another view of the same document moves the art");
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(crate::doc_windows::current(&app), Some(other), "the pane's view is the current window");
assert_eq!(objects(&app, 0), 1, "the square moved, not copied");
let moved = selected_bounds(&app);
assert!((moved.center().x - 250.0).abs() < 0.01 && (moved.center().y - 200.0).abs() < 0.01, "{moved:?}");
assert_eq!(app.session.documents()[0].history.undo.len(), undo + 1);
assert_eq!(app.session.documents()[1].doc, target, "the other document is untouched");
}
#[test]
fn a_pane_drop_lands_where_the_button_went_up_and_copies_when_alt_was_held_then() {
// A pointer move later in the frame of the release does not move the drop.
let (mut app, ctx) = tiled_pair();
grab(&mut app, &ctx, Point::new(100.0, 100.0));
let (drop, _) = in_pane(&app, &ctx, (1, 1), Point::new(170.0, 120.0));
let (later, _) = in_pane(&app, &ctx, (1, 1), Point::new(80.0, 60.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop), button(drop, false), egui::Event::PointerMoved(later)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(1));
let placed = selected_bounds(&app);
assert!((placed.center().x - 170.0).abs() < 0.01 && (placed.center().y - 120.0).abs() < 0.01, "{placed:?}");
// Alt held at the release and let go later in that frame copies into another view of the source.
let (mut app, ctx) = tiled_pair();
app.run("window.newWindow", json!({})).unwrap();
app.run("window.arrange.tile", json!({})).unwrap();
app_frame(&mut app, &ctx, vec![]);
app_frame(&mut app, &ctx, vec![]);
let current = crate::doc_windows::current(&app).unwrap();
let other = app.canvas.panes.last.iter().map(|(w, _)| *w).find(|w| w.0 == 0 && *w != current).unwrap();
grab(&mut app, &ctx, Point::new(100.0, 100.0));
let (drop, _) = in_pane(&app, &ctx, other, Point::new(250.0, 200.0));
let alt = egui::Modifiers::ALT;
let cursor = app_frame(&mut app, &ctx, vec![egui::Event::ModifiersChanged(alt), egui::Event::PointerMoved(drop)]);
assert_eq!(cursor, egui::CursorIcon::Copy, "Alt shows a copy");
let up = egui::Event::PointerButton { pos: drop, button: egui::PointerButton::Primary, pressed: false, modifiers: alt };
app_frame(&mut app, &ctx, vec![up, egui::Event::ModifiersChanged(egui::Modifiers::NONE)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(crate::doc_windows::current(&app), Some(other));
assert_eq!(objects(&app, 0), 2, "the square was copied, not moved");
}
#[test]
fn art_carried_through_a_tab_drops_into_a_third_documents_pane() {
let (mut app, ctx) = tiled_pair();
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("document.activate", json!({"index": 0})).unwrap();
app.run("window.arrange.tile", json!({})).unwrap();
let source = app.session.documents()[0].doc.clone();
let third = app.session.documents()[2].doc.clone();
let titles = |out: egui::FullOutput| -> Vec<egui::Rect> {
let mut t: Vec<_> = out
.shapes
.iter()
.filter_map(|s| match &s.shape {
Shape::Text(t) if t.galley.text().contains(" @ ") => Some(egui::Rect::from_min_size(t.pos, t.galley.size())),
_ => None,
})
.collect();
t.sort_by(|a, b| a.left().total_cmp(&b.left()));
t
};
timed_frame(&mut app, &ctx, Some(0.0), vec![]);
let tabs = titles(timed_frame(&mut app, &ctx, Some(0.01), vec![]));
assert_eq!(tabs.len(), 3);
let p = Xf::at(app.canvas_rect.unwrap(), app.view().unwrap(), 1.0).to_screen(Point::new(100.0, 100.0));
timed_frame(&mut app, &ctx, Some(0.05), vec![egui::Event::PointerMoved(p), button(p, true)]);
timed_frame(&mut app, &ctx, Some(0.1), vec![egui::Event::PointerMoved(p + vec2(20.0, 10.0))]);
timed_frame(&mut app, &ctx, Some(0.2), vec![egui::Event::PointerMoved(tabs[2].center())]);
timed_frame(&mut app, &ctx, Some(0.25), vec![]);
timed_frame(&mut app, &ctx, Some(0.8), vec![]);
assert_eq!(app.session.active_index(), Some(2), "holding the art over the third tab makes that document current");
timed_frame(&mut app, &ctx, Some(0.85), vec![]);
let (drop, _) = in_pane(&app, &ctx, (1, 1), Point::new(150.0, 100.0));
timed_frame(&mut app, &ctx, Some(0.9), vec![egui::Event::PointerMoved(drop)]);
timed_frame(&mut app, &ctx, Some(1.0), vec![button(drop, false)]);
timed_frame(&mut app, &ctx, Some(1.1), vec![]);
assert_eq!(app.session.active_index(), Some(1), "the pane's document is the current one");
assert_eq!(objects(&app, 1), 2, "the copy joins the second document's square");
let placed = selected_bounds(&app);
assert!((placed.center().x - 150.0).abs() < 0.01 && (placed.center().y - 100.0).abs() < 0.01, "{placed:?}");
assert_eq!(app.session.documents()[0].doc, source);
assert_eq!(app.session.documents()[2].doc, third, "the document the tab showed is untouched");
}
#[test]
fn a_drag_released_off_a_panes_art_area_or_after_escape_changes_nothing() {
for (case, escape) in [("scroll bar", false), ("art area after Escape", true)] {
let (mut app, ctx) = tiled_pair();
let docs: Vec<_> = app.session.documents().iter().map(|d| (d.doc.clone(), d.history.undo.len())).collect();
grab(&mut app, &ctx, Point::new(100.0, 100.0));
let (inside, cell) = in_pane(&app, &ctx, (1, 1), Point::new(200.0, 150.0));
let at = if escape { inside } else { pos2(cell.right() - 2.0, cell.center().y) };
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at)]);
if escape {
let key = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
app_frame(&mut app, &ctx, vec![key]);
}
app_frame(&mut app, &ctx, vec![button(at, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(0), "{case}: the source stays current");
let after: Vec<_> = app.session.documents().iter().map(|d| (d.doc.clone(), d.history.undo.len())).collect();
assert!(after == docs, "{case}: neither document changes");
assert!(!app.session.in_interaction(), "{case}: the move ended");
}
}
#[test]
fn consolidate_all_windows_shows_one_document_again() {
let mut app = app_with(2);
+22 -8
View File
@@ -4,7 +4,9 @@
//! the main window, it is a window inside the app's window, as floating panels are
//! ([`crate::panel_docking`]). The current document's window holds the canvas
//! ([`crate::canvas::show`]); each other window draws its document as a Tile pane does
//! ([`crate::canvas::pane`]), and a press in it makes its document the current one.
//! ([`crate::canvas::pane`]), and a press in it makes its document the current one. In a window
//! inside the app's window, a Selection drag released over that pane drops the dragged artwork into
//! its document ([`crate::canvas::release_on_noted`]); an OS window's pane does not take it.
//!
//! A document tab dragged off the tab strip floats its document in a window under the pointer,
//! and a document window dragged onto the tab strip by its title bar (an OS window by the tab at
@@ -95,6 +97,10 @@ pub struct Windows {
known: Vec<u64>,
/// The documents' views beyond the one each shows ([`views`]).
pub(crate) views: Views,
/// The panes the last frame drew outside Tile that a Selection drag's artwork can be released
/// in ([`crate::canvas::note_drop`]): each window's view ([`views::key`]), the part of its pane
/// inside its rulers and scroll bars in the main window's points, and the layer it drew in.
pub(crate) drops: Vec<((u64, u32), egui::Rect, egui::LayerId)>,
}
impl Windows {
@@ -325,7 +331,7 @@ pub(crate) fn dock_all(app: &mut VectorcraftApp) {
/// floats panels by the same rule), and no control channel is attached. With a control channel the
/// windows stay inside the main window, where `ui.click`, `ui.drag` and `ui.screenshot` reach them
/// and `canvasRect` is in the main window's coordinates.
fn native(app: &VectorcraftApp, ctx: &egui::Context) -> bool {
pub(crate) fn native(app: &VectorcraftApp, ctx: &egui::Context) -> bool {
if ctx.embed_viewports() || app.control_rx.is_some() {
return false;
}
@@ -469,6 +475,8 @@ pub(crate) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
activate = Some(win);
}
}
// After every canvas, which sets the cursor of the drag it holds.
crate::canvas::noted_cursor(app, ctx);
// The tab strip a dragged window would go back under shows where it lands.
if let Some(strip) = app.canvas.windows.strip.filter(|_| over_strip) {
let t = crate::theme::Tokens::get(ctx);
@@ -499,9 +507,10 @@ pub(crate) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {
/// Window `win`'s body in `ui`: the canvas for the current window, else (and while `blocked` by a
/// modal) a pane. The view fits the body again when the body changed size since `fit` and the view
/// has not moved. → whether a press in the pane asks for its window to become the current one, the
/// body's rect and the fit after this frame.
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, (win, blocked): (Win, bool), fit: Option<Fit>) -> (bool, egui::Rect, Option<Fit>) {
/// has not moved. With `drops`, a pane drawn while no modal blocks it is noted as a place a Selection
/// drag's artwork can be released in ([`crate::canvas::note_drop`]). → whether a press in the pane
/// asks for its window to become the current one, the body's rect and the fit after this frame.
fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, (win, blocked): (Win, bool), fit: Option<Fit>, drops: bool) -> (bool, egui::Rect, Option<Fit>) {
let t = crate::theme::Tokens::get(ui.ctx());
let rect = ui.available_rect_before_wrap();
ui.painter().rect_filled(rect, 0.0, t.pasteboard);
@@ -517,7 +526,11 @@ fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, (win, blocked): (Win, bool)
crate::canvas::show(app, ui);
false
} else {
crate::canvas::pane(app, ui, win, rect)
let pressed = crate::canvas::pane(app, ui, win, rect);
if drops && !blocked {
crate::canvas::note_drop(app, ui, win, rect);
}
pressed
};
ui.advance_cursor_after_rect(rect);
let fit = match view(app, win) {
@@ -564,7 +577,8 @@ fn os_window(app: &mut VectorcraftApp, ctx: &egui::Context, w: &DocWindow, (win,
}
let tab = crate::chrome::window_tab(app, ui, win);
let (over_strip, dock) = if blocked { (false, false) } else { drag_tab(app, ui, ((w.uid, w.view), origin), &tab, strip) };
let (pressed, rect, fit) = body(app, ui, (win, blocked), w.fit);
// The OS window's points are not the main window's: its pane takes no artwork.
let (pressed, rect, fit) = body(app, ui, (win, blocked), w.fit, false);
let activate = pressed || (!blocked && (tab.clicked() || tab.drag_started()));
// Keys the window's widgets left over run the main window's shortcuts and tool keys, as a
// floating panel's do.
@@ -649,7 +663,7 @@ fn app_window(app: &mut VectorcraftApp, ctx: &egui::Context, w: &DocWindow, (win
.frame(frame)
.open(&mut open)
.show(ctx, |ui| {
let (pressed, r, f) = body(app, ui, (win, blocked), fit);
let (pressed, r, f) = body(app, ui, (win, blocked), fit, true);
(activate, rect, fit) = (pressed, Some(r), f);
});
// A press on its title bar or edges, which brings the window to the front, also makes its
+300
View File
@@ -925,3 +925,303 @@ fn switching_views_targets_the_artboard_the_view_shows() {
show_window(&mut app, (0, 2));
assert_eq!(app.session.tool_options()["active"], json!(1));
}
/// One headless frame as the app runs it: a Selection move released off the canvas ends first
/// ([`crate::canvas::release_over_panel`]), then the tabs and the canvas or panes, then the floating
/// document windows. → the cursor.
fn app_frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> egui::CursorIcon {
let raw = egui::RawInput {
screen_rect: Some(egui::Rect::from_min_size(Pos2::ZERO, vec2(1200.0, 800.0))),
max_texture_side: Some(8192),
events,
..Default::default()
};
let mut out = ctx.run_ui(raw, |ui| {
crate::canvas::release_over_panel(app, ui.ctx());
app.canvas_area(ui);
show(app, ui.ctx());
});
out.textures_delta.clear();
out.platform_output.cursor_icon
}
/// Two 400 × 300 pt documents on `ctx`: the first, current under its tab, holds a 50 pt square at
/// 300, 230, and the second, in a floating window, a 50 pt square at 50, 50. The Selection tool is
/// chosen.
fn floating_pair(ctx: &egui::Context) -> VectorcraftApp {
let mut app = app_with(0);
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 300, "y": 230, "width": 50, "height": 50})).unwrap();
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 50, "y": 50, "width": 50, "height": 50})).unwrap();
app.run("window.arrange.floatInWindow", json!({})).unwrap();
app.run("document.activate", json!({"index": 0})).unwrap();
app.select_tool("selection");
app.ui.task_bar = false;
app_frame(&mut app, ctx, vec![]);
app_frame(&mut app, ctx, vec![]);
app
}
/// Press on document point `at` on the canvas, clear of document 1's window when it floats, and
/// move the pointer 10 × 5 points: the Selection tool moves the art under it.
fn grab(app: &mut VectorcraftApp, ctx: &egui::Context, at: vectorcraft_geom::Point) {
let p = crate::canvas::Xf::at(app.canvas_rect.unwrap(), app.view().unwrap(), 1.0).to_screen(at);
if app.session.documents().len() > 1 && app.session.active_index() != Some(1) && is_floating(app, 1) {
assert!(!window_of(app, ctx, 1).contains(p), "the art is clear of the floating window");
}
app_frame(app, ctx, vec![egui::Event::PointerMoved(p), button(p, true)]);
app_frame(app, ctx, vec![egui::Event::PointerMoved(p + vec2(10.0, 5.0))]);
assert!(app.session.in_interaction(), "the Selection tool moves the art");
}
/// The screen point that shows document point `at` in window `w`'s pane, which the last frame noted
/// as a place to release artwork in.
fn in_noted(app: &VectorcraftApp, w: Win, at: vectorcraft_geom::Point) -> Pos2 {
let k = key(app, w).unwrap();
let (_, area, _) = app.canvas.windows.drops.iter().find(|(s, _, _)| *s == k).unwrap();
crate::canvas::Xf::at(*area, view(app, w).unwrap(), 1.0).to_screen(at)
}
/// How many objects document `i`'s first layer holds.
fn objects(app: &VectorcraftApp, i: usize) -> usize {
app.session.documents()[i].doc.layers[0].children().map_or(0, Vec::len)
}
/// The center of the one object selected in the current document.
fn selected_center(app: &VectorcraftApp) -> vectorcraft_geom::Point {
let st = app.session.active().unwrap();
assert_eq!(st.selection.objects.len(), 1, "one object is selected");
st.doc.node(st.selection.objects[0]).unwrap().geometric_bounds().unwrap().center()
}
#[test]
fn a_selection_drag_released_in_another_documents_floating_window_copies_the_art_there() {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
// The target's view differs from the source's: the grab point still lands under the pointer.
let v = view_mut(&mut app, (1, 1)).unwrap();
v.zoom *= 0.6;
v.rotation = 30.0;
app_frame(&mut app, &ctx, vec![]);
let source = app.session.documents()[0].doc.clone();
let source_undo = app.session.documents()[0].history.undo.len();
let target = app.session.documents()[1].doc.clone();
let target_undo = app.session.documents()[1].history.undo.len();
let clipboard = app.session.clipboard.clone();
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
let drop = in_noted(&app, (1, 1), vectorcraft_geom::Point::new(170.0, 120.0));
let cursor = app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
assert_eq!(cursor, egui::CursorIcon::Copy, "over another document's window the art is copied");
assert_eq!(app.session.active_index(), Some(0), "holding the art over the window does not switch documents");
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(1), "the window's document is the current one");
assert_eq!(objects(&app, 1), 2, "the copy joins the target's square");
let placed = selected_center(&app);
assert!((placed.x - 170.0).abs() < 0.01 && (placed.y - 120.0).abs() < 0.01, "{placed:?}");
assert_eq!(app.session.documents()[1].history.undo.len(), target_undo + 1, "one step to undo");
assert_eq!(app.session.documents()[0].doc, source, "the source keeps its art where it was");
assert_eq!(app.session.documents()[0].history.undo.len(), source_undo);
assert_eq!(app.session.clipboard, clipboard, "the drag leaves the clipboard alone");
assert!(!app.session.tool_busy());
app.run("edit.undo", json!({})).unwrap();
assert_eq!(app.session.documents()[1].doc, target);
}
#[test]
fn a_release_in_the_first_frame_over_a_floating_window_still_copies_the_art() {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
let source = app.session.documents()[0].doc.clone();
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
let drop = in_noted(&app, (1, 1), vectorcraft_geom::Point::new(200.0, 150.0));
// The canvas has not handed the move over yet: the pane takes it before the canvas sees the
// release.
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop), button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(1));
assert_eq!(objects(&app, 1), 2);
let placed = selected_center(&app);
assert!((placed.x - 200.0).abs() < 0.01 && (placed.y - 150.0).abs() < 0.01, "{placed:?}");
assert_eq!(app.session.documents()[0].doc, source);
}
#[test]
fn a_floating_window_drop_lands_where_the_button_went_up() {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
let drop = in_noted(&app, (1, 1), vectorcraft_geom::Point::new(200.0, 150.0));
let later = in_noted(&app, (1, 1), vectorcraft_geom::Point::new(120.0, 220.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
// A pointer move later in the frame of the release does not move the drop.
app_frame(&mut app, &ctx, vec![button(drop, false), egui::Event::PointerMoved(later)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(1));
assert_eq!(objects(&app, 1), 2);
let placed = selected_center(&app);
assert!((placed.x - 200.0).abs() < 0.01 && (placed.y - 150.0).abs() < 0.01, "{placed:?}");
}
#[test]
fn art_dragged_from_a_floating_window_drops_into_the_main_windows_document() {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
show_window(&mut app, (1, 1));
app_frame(&mut app, &ctx, vec![]);
app_frame(&mut app, &ctx, vec![]);
assert!(current_floats(&app), "the floating window holds the canvas");
let target = app.session.documents()[1].doc.clone();
grab(&mut app, &ctx, vectorcraft_geom::Point::new(75.0, 75.0));
// The main window draws document 0 as a pane; this point is clear of the floating window.
let at = vectorcraft_geom::Point::new(360.0, 40.0);
let drop = in_noted(&app, (0, 1), at);
assert!(!window_of(&app, &ctx, 1).contains(drop), "{drop:?}");
let cursor = app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
assert_eq!(cursor, egui::CursorIcon::Copy);
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(0), "the main window's document is the current one");
assert_eq!(objects(&app, 0), 2);
let placed = selected_center(&app);
assert!((placed.x - at.x).abs() < 0.01 && (placed.y - at.y).abs() < 0.01, "{placed:?}");
assert_eq!(app.session.documents()[1].doc, target, "the source in the floating window is untouched");
}
#[test]
fn a_selection_drag_into_a_floating_view_of_its_document_moves_the_art() {
let ctx = egui::Context::default();
let mut app = app_with(0);
app.run("file.new", json!({"width": 400, "height": 300})).unwrap();
app.run("shape.rectangle", json!({"x": 300, "y": 230, "width": 50, "height": 50})).unwrap();
app.run("window.newWindow", json!({})).unwrap();
app.run("window.arrange.floatInWindow", json!({})).unwrap();
show_window(&mut app, (0, 1));
app.select_tool("selection");
app.ui.task_bar = false;
app_frame(&mut app, &ctx, vec![]);
app_frame(&mut app, &ctx, vec![]);
assert!(floats(&app, (0, 2)) && current(&app) == Some((0, 1)));
let undo = app.session.documents()[0].history.undo.len();
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
let drop = in_noted(&app, (0, 2), vectorcraft_geom::Point::new(150.0, 100.0));
let cursor = app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
assert_eq!(cursor, egui::CursorIcon::Move, "another view of the same document moves the art");
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(current(&app), Some((0, 2)), "the floating view is the current window");
assert_eq!(objects(&app, 0), 1, "the square moved, not copied");
let moved = selected_center(&app);
assert!((moved.x - 150.0).abs() < 0.01 && (moved.y - 100.0).abs() < 0.01, "{moved:?}");
assert_eq!(app.session.documents()[0].history.undo.len(), undo + 1);
}
#[test]
fn a_drag_released_on_a_floating_windows_title_bar_or_after_escape_changes_nothing() {
for (case, escape) in [("title bar", false), ("art area after Escape", true)] {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
let docs: Vec<_> = app.session.documents().iter().map(|d| (d.doc.clone(), d.history.undo.len())).collect();
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
let (window, body) = (window_of(&app, &ctx, 1), body_of(&app, 1));
let at = if escape {
in_noted(&app, (1, 1), vectorcraft_geom::Point::new(200.0, 150.0))
} else {
pos2(window.left() + 60.0, (window.top() + body.top()) / 2.0)
};
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(at)]);
if escape {
let key = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: Default::default() };
app_frame(&mut app, &ctx, vec![key]);
}
app_frame(&mut app, &ctx, vec![button(at, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.active_index(), Some(0), "{case}: the source stays current");
let after: Vec<_> = app.session.documents().iter().map(|d| (d.doc.clone(), d.history.undo.len())).collect();
assert!(after == docs, "{case}: neither document changes");
assert!(!app.session.in_interaction(), "{case}: the move ended");
}
}
#[test]
fn a_tab_transfer_whose_source_changed_drops_nothing_in_a_floating_window() {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
app.run("file.new", json!({"width": 400, "height": 300, "name": "Third"})).unwrap();
app.run("document.activate", json!({"index": 0})).unwrap();
app.select_tool("selection");
app_frame(&mut app, &ctx, vec![]);
let tab = tab_at(&frame(&mut app, &ctx, vec![]), "Third");
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
// Held over the third document's tab, the drag becomes a transfer to that document.
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(tab)]);
for _ in 0..60 {
if app.session.active_index() == Some(2) {
break;
}
app_frame(&mut app, &ctx, vec![]);
}
assert_eq!(app.session.active_index(), Some(2), "the tab hover switched documents");
let drop = in_noted(&app, (1, 1), vectorcraft_geom::Point::new(200.0, 150.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
// The source changes between frames, as a command from the control channel would change it.
app.session.set_active(0);
app.session.execute("shape.ellipse", &json!({"x": 20, "y": 20, "width": 30, "height": 30})).unwrap();
app.session.set_active(2);
let target = app.session.documents()[1].doc.clone();
let target_undo = app.session.documents()[1].history.undo.len();
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.documents()[1].doc, target, "the floating window's document does not take the changed art");
assert_eq!(app.session.documents()[1].history.undo.len(), target_undo);
assert_eq!(app.session.active_index(), Some(2), "the window does not become current");
}
#[test]
fn a_tab_transfer_whose_target_is_no_longer_current_drops_nothing_in_a_floating_window() {
let ctx = egui::Context::default();
let mut app = floating_pair(&ctx);
app.run("file.new", json!({"width": 400, "height": 300, "name": "Third"})).unwrap();
app.run("document.activate", json!({"index": 0})).unwrap();
app.select_tool("selection");
app_frame(&mut app, &ctx, vec![]);
let tab = tab_at(&frame(&mut app, &ctx, vec![]), "Third");
grab(&mut app, &ctx, vectorcraft_geom::Point::new(325.0, 255.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(tab)]);
for _ in 0..60 {
if app.session.active_index() == Some(2) {
break;
}
app_frame(&mut app, &ctx, vec![]);
}
assert_eq!(app.session.active_index(), Some(2), "the tab hover switched documents");
let drop = in_noted(&app, (1, 1), vectorcraft_geom::Point::new(200.0, 150.0));
app_frame(&mut app, &ctx, vec![egui::Event::PointerMoved(drop)]);
// Another document becomes current between frames, as a command from the control channel
// would make it.
app.session.set_active(0);
let target = app.session.documents()[1].doc.clone();
let target_undo = app.session.documents()[1].history.undo.len();
app_frame(&mut app, &ctx, vec![button(drop, false)]);
app_frame(&mut app, &ctx, vec![]);
assert_eq!(app.session.documents()[1].doc, target, "the floating window's document does not take the art");
assert_eq!(app.session.documents()[1].history.undo.len(), target_undo);
assert_eq!(app.session.active_index(), Some(0), "the window does not become current");
}
#[test]
fn an_os_windows_pane_is_not_a_place_to_release_art_in_the_main_windows_points() {
let _host = native_host();
let ctx = egui::Context::default();
ctx.set_embed_viewports(false);
if !native(&app_with(0), &ctx) {
// Wayland: the windows are inside the main window.
return;
}
let mut app = floating_pair(&ctx);
assert!(app.canvas.windows.drops.is_empty(), "the other document's OS window is not noted");
show_window(&mut app, (1, 1));
app_frame(&mut app, &ctx, vec![]);
assert!(app.canvas.windows.drops.is_empty(), "nor is the main window's pane while an OS window holds the canvas");
}
+120 -6
View File
@@ -1,4 +1,5 @@
//! A selection dragged across document tabs remains editable and leaves its source intact.
//! A selection dragged across document tabs, or into another document's tiled pane or floating
//! window, remains editable and leaves its source intact.
use std::sync::Arc;
@@ -90,13 +91,15 @@ pub(crate) fn cleanup(app: &VectorcraftApp, ctx: &Context) {
|| i.multi_touch().is_some()
|| i.events.iter().any(|e| matches!(e, egui::Event::Touch { phase: egui::TouchPhase::Cancel, .. }))
});
let outside_release =
ctx.input(|i| i.pointer.primary_released() && !app.canvas_rect.is_some_and(|r| i.pointer.interact_pos().is_some_and(|p| r.contains(p))));
// The canvas and the other windows' tiled panes take a release ([`drop_on_pane`]).
let target = |p: egui::Pos2| app.canvas_rect.is_some_and(|r| r.contains(p)) || app.canvas.panes.last.iter().any(|(_, r)| r.contains(p));
let outside_release = ctx.input(|i| i.pointer.primary_released() && !released_at(i).is_some_and(target));
if !valid || cancel || outside_release || app.ui.dialog.is_some() {
egui::DragAndDrop::clear_payload(ctx);
}
}
if !ctx.input(|i| i.pointer.primary_down()) {
// The source and grab point last through the release, for the pane it is released over.
if !ctx.input(|i| i.pointer.primary_down() || i.pointer.primary_released()) {
ctx.data_mut(|d| {
d.remove::<Origin>(origin_id());
d.remove::<Hover>(hover_id());
@@ -193,11 +196,17 @@ pub(crate) fn drop_on_canvas(app: &mut VectorcraftApp, resp: &Response, xf: &can
if resp.contains_pointer() {
resp.ctx.set_cursor_icon(if same && !copy { egui::CursorIcon::Move } else { egui::CursorIcon::Copy });
}
if let Some(art) = resp.dnd_release_payload::<Artwork>()
&& let Some(at) = resp.ctx.input(|i| i.pointer.interact_pos()).map(|p| xf.to_doc(p))
// The canvas takes a release where the button went up, as [`cleanup`] judges it, and not where
// a later move in the same frame leaves the pointer.
let ctx = &resp.ctx;
let over = |p: egui::Pos2| resp.interact_rect.contains(p) && !ctx.layer_id_at(p).is_some_and(|l| l != resp.layer_id);
if let Some(p) = ctx.input(|i| i.pointer.primary_released().then(|| released_at(i)).flatten()).filter(|p| over(*p))
&& let Some(art) = egui::DragAndDrop::take_payload::<Artwork>(ctx)
{
let at = xf.to_doc(p);
let result = if same {
// Back in the source tab, resume the ordinary move (Alt copies).
let copy = release_alt(&resp.ctx);
app.run("object.move", json!({"ids": art.ids, "dx": at.x-art.origin.grab.x, "dy": at.y-art.origin.grab.y, "copy": copy}))
} else {
app.run(
@@ -210,3 +219,108 @@ pub(crate) fn drop_on_canvas(app: &mut VectorcraftApp, resp: &Response, xf: &can
}
}
}
/// The artwork a Selection drag carries out of its canvas, taken by another window's tiled pane
/// ([`take_for_pane`]): its source and grab point, and the objects that travel.
pub(crate) struct Carried {
origin: Origin,
ids: Vec<NodeId>,
}
/// The artwork a Selection drag carries: the transfer a tab hover started, or a Selection move of
/// the current document that left its canvas. The canvas hands that move over as a panel drag
/// ([`widgets::PanelDrag::Art`]) the frame after the pointer leaves, and Escape drops that; until
/// then the move under way is the drag. Either way the objects the move started with travel, not
/// an Alt-drag's preview copies.
fn carried(app: &VectorcraftApp, ctx: &Context) -> Option<Carried> {
if ctx.input(|i| !i.focused || i.multi_touch().is_some() || i.key_pressed(egui::Key::Escape)) || app.ui.dialog.is_some() {
return None;
}
if let Some(art) = egui::DragAndDrop::payload::<Artwork>(ctx) {
// The same checks as [`cleanup`]: a floating window's pane takes the release before cleanup
// runs, and an edited or closed source, or a target that is no longer the current
// document, carries nothing.
let source = app.session.documents().iter().any(|d| d.uid == art.origin.uid && d.same_content(&art.source));
let target = app.session.active().is_some_and(|d| d.uid == art.target);
return (source && target).then(|| Carried { origin: art.origin.clone(), ids: art.ids.clone() });
}
let origin = ctx.data(|d| d.get_temp::<Origin>(origin_id()))?;
let st = app.session.active().filter(|d| d.uid == origin.uid)?;
let ids = match egui::DragAndDrop::payload::<widgets::PanelDrag>(ctx).as_deref() {
Some(widgets::PanelDrag::Art(ids)) => ids.clone(),
Some(_) => return None,
None if canvas::art_out(ctx) => return None,
None => st.interaction.as_ref().filter(|i| i.label == "Move" || i.label == "Copy")?.selection.objects.clone(),
};
(!ids.is_empty()).then_some(Carried { origin, ids })
}
/// Over the tiled pane of a window of document `uid`, while a Selection drag carries artwork: the
/// cursor that shows a move for another view of the source document without Alt, and a copy
/// otherwise. None when no artwork is carried.
pub(crate) fn pane_cursor(app: &VectorcraftApp, ctx: &Context, uid: u64) -> Option<egui::CursorIcon> {
let c = carried(app, ctx)?;
let copy = ctx.input(|i| i.modifiers.alt);
Some(if c.origin.uid == uid && !copy { egui::CursorIcon::Move } else { egui::CursorIcon::Copy })
}
/// A release over another window's tiled pane takes the carried artwork: the drag ends, and a
/// move still under way on the canvas goes back to where it started, before the canvas sees the
/// release ([`canvas::end_art_move`]).
pub(crate) fn take_for_pane(app: &mut VectorcraftApp, ctx: &Context) -> Option<Carried> {
let c = carried(app, ctx)?;
let moving = !egui::DragAndDrop::has_payload_of_type::<Artwork>(ctx) && app.session.in_interaction();
egui::DragAndDrop::clear_payload(ctx);
ctx.data_mut(|d| d.remove::<Origin>(origin_id()));
if moving {
canvas::end_art_move(app, ctx);
}
Some(c)
}
/// The artwork `c` taken over window `w`'s tiled pane ([`take_for_pane`]), released at document
/// point `at` in that pane's view: `w` becomes the current window, and the artwork lands with its
/// grab point at `at`. Into another document it is copied (`edit.dropSelection`), and the source
/// stays as it was; in another view of the source document it moves, and Alt copies it
/// (`object.move`). When the command fails, the window that was current stays current and the
/// status bar shows the error.
pub(crate) fn drop_on_pane(app: &mut VectorcraftApp, ctx: &Context, w: crate::doc_windows::Win, at: Point, c: Carried) {
let Carried { origin, ids } = c;
let Some(uid) = app.session.documents().get(w.0).map(|d| d.uid) else { return };
let before = crate::doc_windows::current(app);
app.ui.home = None;
crate::doc_windows::show_window(app, w);
let result = if uid == origin.uid {
let copy = release_alt(ctx);
app.run("object.move", json!({"ids": ids, "dx": at.x - origin.grab.x, "dy": at.y - origin.grab.y, "copy": copy}))
} else {
app.run("edit.dropSelection", json!({"sourceDocument": origin.uid, "ids": ids, "grab": [origin.grab.x, origin.grab.y], "at": [at.x, at.y]}))
};
if let Err(e) = result {
if let Some(b) = before {
crate::doc_windows::show_window(app, b);
}
app.status(e);
}
ctx.request_repaint();
}
/// The primary button's release in this frame: where it went up, and the modifiers held then.
fn primary_release(i: &egui::InputState) -> Option<(egui::Pos2, egui::Modifiers)> {
i.events.iter().find_map(|e| match e {
egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed: false, modifiers } => Some((*pos, *modifiers)),
_ => None,
})
}
/// Where the primary button went up in this frame, else where the pointer is. A pointer move later
/// in the frame of the release does not change where the artwork is released.
pub(crate) fn released_at(i: &egui::InputState) -> Option<egui::Pos2> {
primary_release(i).map(|(p, _)| p).or(i.pointer.interact_pos())
}
/// Whether Alt was held when the primary button went up in this frame, else whether it is held now.
/// Alt let go later in the frame of the release still copies.
fn release_alt(ctx: &Context) -> bool {
ctx.input(|i| primary_release(i).map_or(i.modifiers.alt, |(_, m)| m.alt))
}
+45
View File
@@ -291,6 +291,51 @@ fn hovering_back_to_source_resumes_move_instead_of_copying() {
assert!((bounds.x0 - 150.0).abs() < 0.001 && (bounds.y0 - 150.0).abs() < 0.001, "{bounds:?}");
}
/// Verify that a drop back in the source tab lands where the button went up and copies when Alt was
/// held then, though the pointer moves and Alt is let go later in the frame of the release.
#[test]
fn a_drop_back_in_the_source_uses_the_release_position_and_alt() {
let (mut app, ctx, _, tabs) = drag_fixture();
frame(&mut app, &ctx, 0.2, vec![Event::PointerMoved(tabs[1].center())]);
frame(&mut app, &ctx, 0.25, vec![]);
frame(&mut app, &ctx, 0.8, vec![]);
frame(&mut app, &ctx, 0.9, vec![Event::PointerMoved(tabs[0].center())]);
frame(&mut app, &ctx, 1.4, vec![]);
assert_eq!(app.session.active_index(), Some(0));
let xf = canvas::Xf::new(app.canvas_rect.unwrap(), app.view().unwrap());
let drop = xf.to_screen(Point::new(175.0, 180.0));
let later = xf.to_screen(Point::new(300.0, 250.0));
let alt = egui::Modifiers::ALT;
frame(&mut app, &ctx, 1.5, vec![Event::ModifiersChanged(alt), Event::PointerMoved(drop)]);
let up = Event::PointerButton { pos: drop, button: PointerButton::Primary, pressed: false, modifiers: alt };
frame(&mut app, &ctx, 1.6, vec![up, Event::PointerMoved(later), Event::ModifiersChanged(egui::Modifiers::NONE)]);
let st = app.session.active().unwrap();
assert_eq!(st.doc.layers[0].children().map_or(0, Vec::len), 2, "Alt at the release copies the original");
assert_eq!(st.selection.objects.len(), 1);
let bounds = st.doc.node(st.selection.objects[0]).unwrap().geometric_bounds().unwrap();
assert!((bounds.x0 - 150.0).abs() < 0.001 && (bounds.y0 - 150.0).abs() < 0.001, "{bounds:?}");
}
/// Verify that a release inside the other document's canvas drops the artwork there, though the
/// pointer moves onto the tab strip later in the frame of the release.
#[test]
fn a_release_in_the_canvas_drops_though_the_pointer_then_leaves_it() {
let (mut app, ctx, _, tabs) = drag_fixture();
frame(&mut app, &ctx, 0.2, vec![Event::PointerMoved(tabs[1].center())]);
frame(&mut app, &ctx, 0.25, vec![]);
frame(&mut app, &ctx, 0.8, vec![]);
assert_eq!(app.session.active_index(), Some(1));
let before = app.session.active().unwrap().doc.layers[0].children().map_or(0, Vec::len);
let drop = canvas::Xf::new(app.canvas_rect.unwrap(), app.view().unwrap()).to_screen(Point::new(175.0, 180.0));
assert!(!app.canvas_rect.unwrap().contains(tabs[0].center()));
frame(&mut app, &ctx, 0.9, vec![Event::PointerMoved(drop)]);
frame(&mut app, &ctx, 1.0, vec![button(drop, false), Event::PointerMoved(tabs[0].center())]);
let st = app.session.active().unwrap();
assert_eq!(st.doc.layers[0].children().map_or(0, Vec::len), before + 1);
let bounds = st.doc.node(st.selection.objects[0]).unwrap().geometric_bounds().unwrap();
assert!((bounds.x0 - 150.0).abs() < 0.001 && (bounds.y0 - 150.0).abs() < 0.001, "{bounds:?}");
}
/// Back in the source tab, the move resumes even when coming to the front measured the source's
/// type again in its own composite fonts, which replaces the document without editing it.
#[test]
+30 -1
View File
@@ -497,7 +497,36 @@ to the source tab resumes a move (Alt copies). Escape or release outside the can
Changing the source revision or unexpectedly changing/closing the destination cancels a stale
transfer; focus loss, touch cancellation and multitouch cancel too. Moving tabs under a stationary
pointer does not activate further tabs until the pointer moves. The close icon does not activate a tab during a drag. Overflow-menu hover activation and
cross-window dragging remain outside this change.
dragging into a floating document window that is an OS window of its own remain outside this change.
Under Window › Arrange › Tile, a Selection move released over another document's pane copies the
artwork into that document through `edit.dropSelection`, with no tab hover first. The pane becomes
the current window, the grab point lands under the pointer in that pane's own zoom and rotation, and
the source move is rolled back, including when the pointer enters the pane and the button is released
in the same frame. A release over another view of the source document (Window › New Window) moves the
artwork there with `object.move`, and Alt copies it. While the artwork is held over a pane, the cursor
shows a copy or a move. A release over a pane's rulers or scroll bars, or after Escape, changes
neither document. A press in another pane with no artwork carried still only makes its document
current. Page 14 of [the help page](https://help.adobe.com/archive/en_US/illustrator/cs4/illustrator_cs4_help.pdf)
describes documents arranged side by side, with items dragged from one document into another.
Evidence: the `canvas::panes` tests drive real pointer frames from the current pane into another
document's pane, back the other way, into another view, through a tab into a third document's pane,
and off a pane's art area.
The same release works for documents in floating windows (Window › Arrange › Float in Window) where
those windows are drawn inside the main window: on the web, on Wayland and with a control channel
attached. A Selection move released over the art area of another document's floating window copies
the artwork into that document, and one released over the pane the main window draws while the
current document floats copies it into the main window's document. A floating window that shows
another view of the source document takes a move, and Alt copies. The release is taken at the start
of the frame, before any canvas sees it, so a release in the first frame over a window still drops the
artwork. A release on a window's title bar, rulers or scroll bars, or after Escape, changes neither
document. A floating window that is an OS window of its own, the default on Windows, macOS and X11,
does not take the artwork: its pointer positions are in that window's points, not the main window's.
Evidence: the `doc_windows` tests drive real pointer frames from the main window's canvas into a
floating window (rotated and zoomed, and in the frame the pointer arrives), from a floating window
into the main window's pane, into a floating view of the same document, and onto a title bar and
after Escape, and check that no OS window's pane is noted.
The cited regressions assert the internal clipboard; they do not exercise the native
system-clipboard adapter. Tab activation resets the Selection tool through
`Session::set_active`; gesture regressions verify it is idle after switching, dropping
+6 -2
View File
@@ -875,8 +875,12 @@ sampling coexistence. Scores and estimates unchanged. See [development.md](devel
Selection drags activate another visible document tab after 400 ms, then copy editable artwork
on canvas release with the original grab point. Source and clipboard preservation, resource
rendering, swatch conflicts, cancellation, rotated/zoomed views and target Undo/Redo have regression
coverage (`tests_document_drag`, `tests_clipboard`). Overflow-menu and cross-window drag remain
separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
coverage (`tests_document_drag`, `tests_clipboard`). Under Window › Arrange › Tile, a release over
another document's pane copies the artwork into that document as well, and a release over another
view of the source document moves it (`canvas::panes` tests). A release over a floating document
window drawn inside the main window, or over the main window's pane while the current document
floats, does the same (`doc_windows` tests); a floating window that is an OS window of its own does
not take the artwork yet. Overflow-menu drag remains separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
## Pathfinder › Trap (2026-10-23)
+6 -2
View File
@@ -201,8 +201,12 @@ sampling coexistence. Scores and estimates unchanged. See [development.md](devel
Selection drags activate another visible document tab after 400 ms, then copy editable artwork
on canvas release with the original grab point. Source and clipboard preservation, resource
rendering, swatch conflicts, cancellation, rotated/zoomed views and target Undo/Redo have regression
coverage (`tests_document_drag`, `tests_clipboard`). Overflow-menu and cross-window drag remain
separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
coverage (`tests_document_drag`, `tests_clipboard`). Under Window › Arrange › Tile, a release over
another document's pane copies the artwork into that document as well, and a release over another
view of the source document moves it (`canvas::panes` tests). A release over a floating document
window drawn inside the main window, or over the main window's pane while the current document
floats, does the same (`doc_windows` tests); a floating window that is an OS window of its own does
not take the artwork yet. Overflow-menu drag remains separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
## Revision history
+6 -2
View File
@@ -2291,8 +2291,12 @@ sampling coexistence. Scores and estimates unchanged. See [development.md](devel
Selection drags activate another visible document tab after 400 ms, then copy editable artwork
on canvas release with the original grab point. Source and clipboard preservation, resource
rendering, swatch conflicts, cancellation, rotated/zoomed views and target Undo/Redo have regression
coverage (`tests_document_drag`, `tests_clipboard`). Overflow-menu and cross-window drag remain
separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
coverage (`tests_document_drag`, `tests_clipboard`). Under Window › Arrange › Tile, a release over
another document's pane copies the artwork into that document as well, and a release over another
view of the source document moves it (`canvas::panes` tests). A release over a floating document
window drawn inside the main window, or over the main window's pane while the current document
floats, does the same (`doc_windows` tests); a floating window that is an OS window of its own does
not take the artwork yet. Overflow-menu drag remains separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
## Gradient dither (2026-10-22)
+7 -3
View File
@@ -385,7 +385,7 @@ next unit in the order a right-click on a ruler lists them, from Feet back to Po
| Interaction | Status | Evidence |
|---|---|---|
| Ordinary Save refused by filesystem permissions/read-only storage offers Save As | focused UI regressions passed; native acceptance pending | #6146; `io::tests_read_only_save`; same name/format suggested; unchanged format keeps options, changed format opens its Save options; Documents folder, UID-bound continuation; cancellation and automation isolation |
| Selection artwork drag hovers a visible document tab to activate it, then drops editable artwork on its canvas | done | `tests_document_drag`, `edit.dropSelection`, lossless resource and one-step Undo regressions; overflow and cross-window drag remain separate |
| Selection artwork drag hovers a visible document tab to activate it, then drops editable artwork on its canvas | done | `tests_document_drag`, `edit.dropSelection`, lossless resource and one-step Undo regressions; a release over another document's tiled pane copies it there too (`canvas::panes` tests), and so does a release over a floating window drawn inside the main window (`doc_windows` tests); overflow-menu drag and floating OS windows remain separate |
| A document tab dragged along the tab strip moves its document; a line marks where it goes, the current document and every document's view stay as they were, and a drag off the strip still floats it | done | #5663, [public source](https://helpx.adobe.com/illustrator/using/customizing-workspace.html); `document.move`; `tests::tab_reorder`, `chrome::tests` (drop index with floating and view tabs), `engine` `tests::document_move` |
| A middle-click on a document tab or its × closes it as the × does; closing a modified document's last view asks to save first (VectorCraft addition, as in PhotoCraft) | done | #6506; `chrome::tests::a_middle_click_on_a_tab_closes_it_as_the_close_box_does`; not scored |
| Panels hidden by Tab or Shift+Tab show for a while when the pointer rests on the left or right edge of the window, over the canvas, and hide again when it moves away; Tab shows them for good | done | Part of #5661; `window.panels.peek` ([Workspace basics](https://web.archive.org/web/2014/https://helpx.adobe.com/illustrator/using/workspace-basics.html), "Hide or show all panels"); VectorCraft's own choices: the 6 pt band and the 0.3 s delays, only the docked panels on that side show (floating panels, Tools and the Control bar stay hidden), and nothing shows in Presentation Mode; `panel_docking::tests::resting_on_the_right_edge_shows_the_hidden_panels_over_the_canvas_until_the_pointer_leaves` and the tests after it |
@@ -543,8 +543,12 @@ sampling coexistence. Scores and estimates unchanged. See [development.md](devel
Selection drags activate another visible document tab after 400 ms, then copy editable artwork
on canvas release with the original grab point. Source and clipboard preservation, resource
rendering, swatch conflicts, cancellation, rotated/zoomed views and target Undo/Redo have regression
coverage (`tests_document_drag`, `tests_clipboard`). Overflow-menu and cross-window drag remain
separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
coverage (`tests_document_drag`, `tests_clipboard`). Under Window › Arrange › Tile, a release over
another document's pane copies the artwork into that document as well, and a release over another
view of the source document moves it (`canvas::panes` tests). A release over a floating document
window drawn inside the main window, or over the main window's pane while the current document
floats, does the same (`doc_windows` tests); a floating window that is an OS window of its own does
not take the artwork yet. Overflow-menu drag remains separate. Scores and hours unchanged. [Behavior and command details](development.md#drag-artwork-between-document-tabs-2026-10-22).
## Live Paint Bucket