VectorCraft: An open-source, vector art tool written by scratch in pure Rust
Window: Float in Window, Float All in Windows and Cascade float documents
dotCooCoo2c0ef0f24e91
diff --git a/crates/ui-egui/src/app.rs b/crates/ui-egui/src/app.rsindex 404eaa81b..38b3c83d7 100644--- a/crates/ui-egui/src/app.rs+++ b/crates/ui-egui/src/app.rs@@ -85,6 +85,7 @@ impl VectorcraftApp {hover_cursor: None,presented: None,panes: Default::default(),+ windows: Default::default(),},perf: Perf::default(),dock_rt: Default::default(),@@ -427,18 +428,31 @@ 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.+ /// 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.pub(crate) fn canvas_area(&mut self, ui: &mut egui::Ui) {let t = theme::Tokens::get(ui.ctx());ui.painter().rect_filled(ui.max_rect(), 0.0, t.pasteboard);if self.ui.screen_mode < 3 {chrome::doc_tabs(self, ui);}+ self.canvas.windows.area = Some(ui.available_rect_before_wrap());+ let floats = crate::doc_windows::current_floats(self);if !canvas::tiled_area(self, ui) {- canvas::show(self, ui);+ if floats {+ let rect = ui.available_rect_before_wrap();+ if let Some(i) = crate::doc_windows::tab_document(self)+ && canvas::pane(self, ui, i, rect)+ {+ chrome::show_document(self, i);+ }+ } else {+ canvas::show(self, ui);+ }}// Over the canvas inside the rulers, so the rulers and scroll bars stay uncovered.if self.ui.screen_mode < 3+ && !floats&& !menus::home_showing(self)&& let Some(area) = self.canvas_rect{@@ -510,6 +524,7 @@ impl VectorcraftApp {panels::library_panel::tidy(self);// The canvas and the panels: one docking layout. Tab hides the panels but not the canvas.egui::CentralPanel::default().frame(egui::Frame::NONE.fill(t.pasteboard)).show(ui, |ui| panel_docking::show(self, ui));+ crate::doc_windows::show(self, &ctx);dialogs::show(self, &ctx);updates_ui::show(self, &ctx);export_progress::show(self, &ctx);diff --git a/crates/ui-egui/src/caches.rs b/crates/ui-egui/src/caches.rsindex 1e50de228..736100377 100644--- a/crates/ui-egui/src/caches.rs+++ b/crates/ui-egui/src/caches.rs@@ -60,6 +60,8 @@ pub struct CanvasCache {pub presented: Option<egui::Rect>,/// Window › Arrange › Tile: the renders the panes of the other documents draw.pub panes: canvas::Panes,+ /// Window › Arrange › Float in Window: what the floating document windows keep between frames.+ pub windows: crate::doc_windows::Windows,}/// [`CanvasCache::slices`]: the layout of the slices of (document uid, revision).diff --git a/crates/ui-egui/src/canvas.rs b/crates/ui-egui/src/canvas.rsindex afcd2c37b..065907b4f 100644--- a/crates/ui-egui/src/canvas.rs+++ b/crates/ui-egui/src/canvas.rs@@ -61,7 +61,7 @@ use outline::{OVERLAY_MAX_ANCHORS, c32, node_outline, walk_drawn};use overlays::selected_anchor;use overlays::{HandleLook, draw_inside_overlay, draw_overlays, hover_highlight, ime_geometry, selection_overlay};pub use panes::Panes;-pub(crate) use panes::{consolidate, tile, tiled_area};+pub(crate) use panes::{consolidate, pane, tile, tiled_area};use raster::{changed_pixels, pixel_region, upload};pub(crate) use raster::{color_image, color_image_owned};use task_bar::task_bar;diff --git a/crates/ui-egui/src/canvas/panes.rs b/crates/ui-egui/src/canvas/panes.rsindex 43e2e4e60..c9e8b1fe8 100644--- a/crates/ui-egui/src/canvas/panes.rs+++ b/crates/ui-egui/src/canvas/panes.rs@@ -140,9 +140,11 @@ pub(crate) fn cells(n: usize, area: egui::Rect) -> Vec<egui::Rect> {(0..n).map(|i| egui::Rect::from_min_max(pos2(x(i % cols), y(i / cols)), pos2(x(i % cols + 1), y(i / cols + 1)))).collect()}-/// `window.arrange.tile`: every open document in a pane of its own, each fitted to its pane.+/// `window.arrange.tile`: every open document in a pane of its own, each fitted to its pane. The+/// documents in floating windows come back under the tabs for it.pub(crate) fn tile(app: &mut VectorcraftApp) -> Result<serde_json::Value, String> {app.sync_views();+ crate::doc_windows::dock_all(app);let n = app.session.documents().len();app.ui.tiled = n > 0;if n > 0 {@@ -154,65 +156,80 @@ pub(crate) fn tile(app: &mut VectorcraftApp) -> Result<serde_json::Value, StringOk(json!({"tiled": app.ui.tiled, "panes": n}))}-/// `window.arrange.consolidateAllWindows`: one document at a time again, under its tab.+/// `window.arrange.consolidateAllWindows`: one document at a time again, under its tab, the+/// documents in floating windows included.pub(crate) fn consolidate(app: &mut VectorcraftApp) -> Result<serde_json::Value, String> {app.ui.tiled = false;+ crate::doc_windows::dock_all(app);app.canvas.panes.clear();- Ok(json!({"tiled": false}))+ Ok(json!({"tiled": false, "floating": []}))}-/// Draw the document area as panes while Tile is on and more than one document is open, outside-/// the Home screen and Presentation Mode. False when it did not: the caller draws the canvas.+/// Draw the document area as panes while Tile is on and more than one document is under the tabs,+/// outside the Home screen and Presentation Mode. False when it did not: the caller draws the+/// canvas. The documents in floating windows have no pane.pub(crate) fn tiled_area(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {- let n = app.session.documents().len();- if n == 0 {+ if app.session.documents().is_empty() {app.ui.tiled = false;}+ let docked = crate::doc_windows::docked(app);+ let n = docked.len();let tiling = app.ui.tiled && n > 1 && app.ui.screen_mode < 3 && !crate::menus::home_showing(app);- let Some(active) = app.session.active_index().filter(|_| tiling) else {- if !app.canvas.panes.shown.is_empty() || !app.canvas.panes.last.is_empty() {+ if !tiling {+ // The floating windows draw their panes from the same renders.+ if app.ui.floating.is_empty() && (!app.canvas.panes.shown.is_empty() || !app.canvas.panes.last.is_empty()) {app.canvas.panes.clear();}+ app.canvas.panes.last.clear();return false;- };+ }+ // The current document's pane is the canvas, unless it is in a floating window.+ let active = app.session.active_index().filter(|a| docked.contains(a));app.sync_views();let live: Vec<usize> = app.session.documents().iter().map(|d| d.uid as usize).collect();app.canvas.panes.shown.retain(|uid, _| live.contains(uid));app.canvas.panes.pending.retain(|uid, _| live.contains(uid));app.canvas.panes.fits.retain(|uid, _| live.contains(uid));- // A document opened or closed changes the grid, and so does coming back to the panes from one- // document: each document fits its new pane.- if app.canvas.panes.last.len() != n {- for v in &mut app.views {- v.fitted = false;+ // A document opened, closed, floated or docked changes the grid, and so does coming back to the+ // panes from one document: each document fits its new pane.+ if app.canvas.panes.last.iter().map(|(i, _)| *i).ne(docked.iter().copied()) {+ for i in &docked {+ if let Some(v) = app.views.get_mut(*i) {+ v.fitted = false;+ }}}let t = Tokens::get(ui.ctx());let ppp = ui.ctx().pixels_per_point();- let cells = cells(n, ui.available_rect_before_wrap());- let areas: Vec<egui::Rect> = cells.iter().map(|c| view_rects(app, *c, ppp).1).collect();+ let cells: Vec<(usize, egui::Rect)> = docked.iter().copied().zip(cells(n, ui.available_rect_before_wrap())).collect();+ let mut areas: Vec<Option<egui::Rect>> = vec![None; app.session.documents().len()];+ for (i, cell) in &cells {+ if let Some(a) = areas.get_mut(*i) {+ *a = Some(view_rects(app, *cell, ppp).1);+ }+ }let unfitted = refit_resized(app, &areas);let mut activate = None;// The other panes first, so that what the canvas draws past its pane (the Contextual Task Bar)// stays over them.- for (i, cell) in cells.iter().copied().enumerate().filter(|(i, _)| *i != active) {+ for (i, cell) in cells.iter().copied().filter(|(i, _)| Some(*i) != active) {if pane(app, ui, i, cell) {activate = Some(i);}ui.painter().rect_stroke(cell, 0.0, Stroke::new(1.0, t.border), StrokeKind::Inside);}- if let Some(cell) = cells.get(active).copied() {+ if let Some((_, cell)) = cells.iter().copied().find(|(i, _)| Some(*i) == active) {let mut canvas = ui.new_child(egui::UiBuilder::new().max_rect(cell));super::show(app, &mut canvas);ui.painter().rect_stroke(cell, 0.0, Stroke::new(1.5, t.accent), StrokeKind::Inside);}// Note the fits this frame made, for `refit_resized`.for ((i, area), was_unfitted) in areas.iter().enumerate().zip(unfitted) {- if let (true, Some(v), Some(d)) = (was_unfitted, app.views.get(i).filter(|v| v.fitted), app.session.documents().get(i)) {+ if let (Some(area), true, Some(v), Some(d)) = (area, was_unfitted, app.views.get(i).filter(|v| v.fitted), app.session.documents().get(i)) {app.canvas.panes.fits.insert(d.uid as usize, (area.size(), v.zoom, v.center));}}- app.canvas.panes.last = cells.into_iter().enumerate().collect();+ app.canvas.panes.last = cells;if let Some(i) = activate {crate::chrome::show_document(app, i);}@@ -220,14 +237,15 @@ pub(crate) fn tiled_area(app: &mut VectorcraftApp, ui: &mut Ui) -> bool {}/// Unfit each document whose view is still where a pane fit left it when its view's area (in-/// `areas`, by document index) has changed size, as when the window or a panel is resized: it-/// fits its pane again. A view zoomed or scrolled since keeps its place. → which views are-/// unfitted now.-fn refit_resized(app: &mut VectorcraftApp, areas: &[egui::Rect]) -> Vec<bool> {+/// `areas`, by document index; None for a document without a pane) has changed size, as when the+/// window or a panel is resized: it fits its pane again. A view zoomed or scrolled since keeps its+/// place. → which views are unfitted now.+fn refit_resized(app: &mut VectorcraftApp, areas: &[Option<egui::Rect>]) -> Vec<bool> {let fits = &app.canvas.panes.fits;let docs = app.session.documents();for ((v, d), area) in app.views.iter_mut().zip(docs).zip(areas) {- if let Some((size, zoom, center)) = fits.get(&(d.uid as usize))+ if let Some(area) = area+ && let Some((size, zoom, center)) = fits.get(&(d.uid as usize))&& *size != area.size()&& *zoom == v.zoom&& *center == v.center@@ -251,8 +269,9 @@ fn fit_pane(v: &mut View, doc: &vectorcraft_doc::Document, rect: egui::Rect) {/// The pane of document `i`, not the current one, in `cell`: its paper, art, grid, artboards,/// guides and selected objects, and its rulers and the room of the canvas's scroll bars, so the/// document stays where it is when the pane becomes the canvas. True when a press in the pane asks-/// for its document to become the current one.-fn pane(app: &mut VectorcraftApp, ui: &Ui, i: usize, cell: egui::Rect) -> bool {+/// for its document to become the current one. A floating document's window draws its document+/// with this too ([`crate::doc_windows`]).+pub(crate) fn pane(app: &mut VectorcraftApp, ui: &Ui, i: usize, cell: egui::Rect) -> bool {let t = Tokens::get(ui.ctx());let ppp = ui.ctx().pixels_per_point();let (full, rect) = view_rects(app, cell, ppp);diff --git a/crates/ui-egui/src/canvas/panes/tests.rs b/crates/ui-egui/src/canvas/panes/tests.rsindex 49bca9938..943734c0e 100644--- a/crates/ui-egui/src/canvas/panes/tests.rs+++ b/crates/ui-egui/src/canvas/panes/tests.rs@@ -151,7 +151,7 @@ fn consolidate_all_windows_shows_one_document_again() {app.run("window.arrange.tile", json!({})).unwrap();frame(&mut app, &ctx, vec![]);assert_eq!(panes(&app).0.len(), 2);- assert_eq!(app.run("window.arrange.consolidateAllWindows", json!({})).unwrap(), json!({"tiled": false}));+ assert_eq!(app.run("window.arrange.consolidateAllWindows", json!({})).unwrap(), json!({"tiled": false, "floating": []}));frame(&mut app, &ctx, vec![]);assert!(panes(&app).0.is_empty() && app.canvas.panes.shown.is_empty());assert_eq!(app.canvas_rect, Some(tabbed), "the current document fills the document area again");diff --git a/crates/ui-egui/src/chrome.rs b/crates/ui-egui/src/chrome.rsindex c61974804..c65d0f515 100644--- a/crates/ui-egui/src/chrome.rs+++ b/crates/ui-egui/src/chrome.rs@@ -27,10 +27,10 @@ pub use hints::{hint_bar, hint_strings};pub use status_bar::status_bar;#[cfg(test)]use status_bar::{StatusReadoutWidths, status_readouts};-pub(crate) use tabs::show_document;#[cfg(test)]use tabs::{CLOSE_BEFORE_TITLE, first_tab_shown, tab_title};pub use tabs::{doc_tabs, isolation_bar, step_document};+pub(crate) use tabs::{document_window_title, show_document};/// The application bar's height, in points (compact, as in PhotoCraft).pub const APP_BAR_HEIGHT: f32 = 32.0;diff --git a/crates/ui-egui/src/chrome/tabs.rs b/crates/ui-egui/src/chrome/tabs.rsindex cd0fad1f3..d8b214e9f 100644--- a/crates/ui-egui/src/chrome/tabs.rs+++ b/crates/ui-egui/src/chrome/tabs.rs@@ -19,6 +19,12 @@ pub(super) fn doc_tab_title(app: &VectorcraftApp, i: usize, d: &vectorcraft_engitab_title(d, zoom, view.is_some_and(|v| v.outline), app.session.prefs.display_print_size)}+/// The title of document `i`'s floating window ([`crate::doc_windows`]): its tab's title.+pub(crate) fn document_window_title(app: &VectorcraftApp, i: usize) -> Option<String> {+ let d = app.session.documents().get(i)?;+ Some(doc_tab_title(app, i, d))+}+/// Whether a document tab's × comes before its title (macOS) rather than after it (Windows,/// Linux and the web).pub(super) const CLOSE_BEFORE_TITLE: bool = cfg!(target_os = "macos");@@ -37,6 +43,8 @@ pub(super) fn first_tab_shown(widths: &[f32], active: Option<usize>, room: f32)/// Document tab strip: "Name* @ 66.67% (RGB/Preview)". User Interface › Large Tabs makes the tabs/// taller, with larger titles. Tabs that don't fit are reached from a » button at the strip's/// right end, which lists every open document, and the active tab is always in view (#746).+/// Documents in floating windows have no tab ([`crate::doc_windows`]); while the current document+/// is in one, the tab of the document the strip shows is the highlighted one.pub fn doc_tabs(app: &mut VectorcraftApp, ui: &mut Ui) {/// The width of the » button.const MORE: f32 = 30.0;@@ -46,15 +54,16 @@ pub fn doc_tabs(app: &mut VectorcraftApp, ui: &mut Ui) {ui.painter().rect_filled(strip, 0.0, t.tab_strip);ui.painter().line_segment([strip.left_bottom(), strip.right_bottom()], Stroke::new(1.0, t.border));// On the Home screen no tab is the current one.- let active = app.session.active_index().filter(|_| app.ui.home.is_none());- let tabs: Vec<(String, std::sync::Arc<egui::Galley>)> = app- .session- .documents()+ let shown = crate::doc_windows::tab_document(app).filter(|_| app.ui.home.is_none());+ // The documents under the tabs, by index; `active` is the position of the highlighted one.+ let docked = crate::doc_windows::docked(app);+ let active = docked.iter().position(|i| Some(*i) == shown);+ let tabs: Vec<(String, std::sync::Arc<egui::Galley>)> = docked.iter()- .enumerate()+ .filter_map(|i| Some((*i, app.session.documents().get(*i)?))).map(|(i, d)| {let title = doc_tab_title(app, i, d);- let color = if Some(i) == active { t.text_strong } else { t.text_dim };+ let color = if Some(i) == shown { t.text_strong } else { t.text_dim };(title.clone(), ui.painter().layout_no_wrap(title, theme::semibold(title_size), color))}).collect();@@ -66,11 +75,12 @@ pub fn doc_tabs(app: &mut VectorcraftApp, ui: &mut Ui) {let mut activate = None;let mut close = None;let mut hovering_art = false;- for (i, ((_, galley), w)) in tabs.iter().zip(&widths).enumerate().skip(first) {- if x + w > strip.left() + room && Some(i) != active {+ for (k, ((_, galley), w)) in tabs.iter().zip(&widths).enumerate().skip(first) {+ if x + w > strip.left() + room && Some(k) != active {break;}- let is_active = Some(i) == active;+ let Some(&i) = docked.get(k) else { break };+ let is_active = Some(k) == active;let r = egui::Rect::from_min_size(egui::pos2(x, strip.top()), vec2(*w, strip.height() - 1.0));let resp = ui.interact(r, ui.scope_id().with(("tab", i)), Sense::click());if is_active {@@ -95,10 +105,12 @@ pub fn doc_tabs(app: &mut VectorcraftApp, ui: &mut Ui) {x += w;}crate::document_drag::finish_tabs(ui.ctx(), hovering_art);- // The » button: every open document, the active one checked. The list scrolls once it- // reaches the bottom of the window, so every document of a large session stays reachable- // (#4017).+ // The » button: every open document, floating ones included, the active one checked. The list+ // scrolls once it reaches the bottom of the window, so every document of a large session stays+ // reachable (#4017).if overflow {+ let current = app.session.active_index().filter(|_| app.ui.home.is_none());+ let titles: Vec<String> = (0..app.session.documents().len()).map(|i| document_window_title(app, i).unwrap_or_default()).collect();let more = egui::Rect::from_min_max(egui::pos2(strip.right() - MORE, strip.top()), egui::pos2(strip.right(), strip.bottom() - 1.0));let resp = ui.interact(more, ui.scope_id().with("tabs-more"), Sense::click());ui.painter().rect_filled(more, 0.0, if resp.hovered() { t.hover.gamma_multiply(0.4) } else { t.tab_strip });@@ -106,8 +118,8 @@ pub fn doc_tabs(app: &mut VectorcraftApp, ui: &mut Ui) {let resp = resp.on_hover_text(tl!("Show all open documents"));egui::Popup::menu(&resp).show(|ui| {widgets::menu_scroll(ui, |ui| {- for (i, (title, _)) in tabs.iter().enumerate() {- if widgets::menu_item_name(ui, title, true, Some(i) == active) {+ for (i, title) in titles.iter().enumerate() {+ if widgets::menu_item_name(ui, title, true, Some(i) == current) {activate = Some(i);ui.close();}diff --git a/crates/ui-egui/src/control.rs b/crates/ui-egui/src/control.rsindex c374b62ee..7f1c6cf03 100644--- a/crates/ui-egui/src/control.rs+++ b/crates/ui-egui/src/control.rs@@ -200,6 +200,9 @@ pub fn inspect(app: &VectorcraftApp, ctx: &egui::Context) -> Value {"rect": [c.left(), c.top(), c.width(), c.height()],"active": app.session.active_index() == Some(*i),})).collect::<Vec<_>>(),+ // Window › Arrange › Float in Window: the documents in floating windows, by index. While+ // the current one floats, `canvasRect` is in its window's coordinates.+ "floating": (0..app.session.documents().len()).filter(|i| crate::doc_windows::is_floating(app, *i)).collect::<Vec<_>>(),"window": [r.width(), r.height()],"documents": app.session.documents().iter().map(|d| json!({"title": d.title(), "dirty": d.is_dirty()})).collect::<Vec<_>>(),"activeDocument": app.session.active_index(),diff --git a/crates/ui-egui/src/doc_windows.rs b/crates/ui-egui/src/doc_windows.rsnew file mode 100644index 000000000..24fa105c3--- /dev/null+++ b/crates/ui-egui/src/doc_windows.rs@@ -0,0 +1,497 @@+//! Window › Arrange › Float in Window, Float All in Windows and Cascade: documents in floating+//! windows of their own, out of the tab strip, until Consolidate All Windows. On the desktop each+//! window is an OS window; on the web, on Wayland and wherever egui draws every viewport inside+//! 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.++use serde_json::{Value, json};++use crate::VectorcraftApp;++/// How far apart Cascade sets the windows, down and to the right, in points.+pub(crate) const CASCADE_STEP: f32 = 30.0;+/// How far the first cascaded window is from the document area's top-left corner, in points.+const CASCADE_MARGIN: f32 = 24.0;+/// The smallest size of a document window, in points.+const MIN_SIZE: egui::Vec2 = egui::vec2(240.0, 180.0);++/// A document in a floating window.+#[derive(Clone, Debug)]+pub struct DocWindow {+ /// The document ([`vectorcraft_engine::DocState::uid`]).+ pub uid: u64,+ /// Where the window goes, in the main window's points.+ pub place: egui::Rect,+ /// Counts the moves Cascade gives the window after it opened.+ generation: u32,+ /// The OS window's position on the screen when it opened or last moved, and the generation of+ /// that move. Repeated each frame, so egui sees an unchanged window.+ screen: Option<(egui::Pos2, u32)>,+ /// Its OS window had the keyboard focus in the last frame.+ focused: bool,+ /// Where the last frame drew its document, in its window's coordinates.+ pub(crate) body: Option<egui::Rect>,+ /// The size of the body its document was last fitted to, and the zoom and center that fit+ /// gave: a window resized while its view is still there fits its document again.+ fit: Option<Fit>,+}++/// [`DocWindow::fit`]: a body size, and a view's zoom and center.+type Fit = (egui::Vec2, f64, vectorcraft_geom::Point);++impl DocWindow {+ fn new(uid: u64, place: egui::Rect) -> Self {+ Self { uid, place, generation: 0, screen: None, focused: false, body: None, fit: None }+ }+}++/// What the document windows keep between frames.+#[derive(Default)]+pub struct Windows {+ /// The document area of the main window (the tabs and the canvas) in its last frame.+ pub(crate) area: Option<egui::Rect>,+ /// The current document (its uid) when the windows were last drawn: a floating document that+ /// becomes the current one comes to the front.+ current: Option<u64>,+ /// While Presentation Mode is on: the floating documents (their uids) it has shown.+ presented: Option<Vec<u64>>,+}++/// Whether document `i` is in a floating window.+pub(crate) fn is_floating(app: &VectorcraftApp, i: usize) -> bool {+ app.session.documents().get(i).is_some_and(|d| app.ui.floating.iter().any(|w| w.uid == d.uid))+}++/// The documents under the tab strip, by index, in tab order.+pub(crate) fn docked(app: &VectorcraftApp) -> Vec<usize> {+ (0..app.session.documents().len()).filter(|i| !is_floating(app, *i)).collect()+}++/// The document the tab strip shows: the current one when it is under the tabs, else the tabbed+/// document that was current last, else the first tabbed one.+pub(crate) fn tab_document(app: &VectorcraftApp) -> Option<usize> {+ let docked = docked(app);+ let active = app.session.active_index();+ if let Some(a) = active.filter(|a| docked.contains(a)) {+ return Some(a);+ }+ let last = app.ui.tab_document.and_then(|uid| app.session.documents().iter().position(|d| d.uid == uid));+ last.filter(|i| docked.contains(i)).or(docked.first().copied())+}++/// Whether the current document is in a floating window, outside the Home screen and Presentation+/// Mode: the main window's canvas then draws the tab strip's document as a pane.+pub(crate) fn current_floats(app: &VectorcraftApp) -> bool {+ app.session.active_index().is_some_and(|i| is_floating(app, i)) && !crate::menus::home_showing(app) && !presenting(app)+}++/// Whether Presentation Mode is on: the main window shows the current document, and the floating+/// windows are hidden until it ends.+fn presenting(app: &VectorcraftApp) -> bool {+ app.ui.screen_mode >= 3+}++/// The places Cascade gives `n` windows in `area`: each the same size, the first near the area's+/// top-left corner and each next one [`CASCADE_STEP`] further down and to the right, starting+/// again at the corner when the next one would leave the area. Every place lies inside `area`.+pub(crate) fn cascade_places(area: egui::Rect, n: usize) -> Vec<egui::Rect> {+ let size = (area.size() * 0.6).max(MIN_SIZE).min(area.size());+ let room = (area.size() - size).min_elem().max(0.0);+ let steps = if room > CASCADE_MARGIN { ((room - CASCADE_MARGIN) / CASCADE_STEP).floor() as usize + 1 } else { 1 };+ (0..n)+ .map(|k| {+ let offset = (CASCADE_MARGIN + (k % steps) as f32 * CASCADE_STEP).min(room);+ egui::Rect::from_min_size(area.min + egui::vec2(offset, offset), size)+ })+ .collect()+}++/// The document area windows open in: the main window's last one, else a 1200 × 800 area.+fn area(app: &VectorcraftApp) -> egui::Rect {+ app.canvas.windows.area.filter(|r| r.is_positive()).unwrap_or(egui::Rect::from_min_size(egui::Pos2::ZERO, egui::vec2(1200.0, 800.0)))+}++/// Float documents `docs` (indices), each at the next cascade place after the windows already+/// open. Each fits its window.+fn float(app: &mut VectorcraftApp, docs: &[usize]) {+ app.sync_views();+ let first = app.ui.floating.len();+ let places = cascade_places(area(app), first + docs.len());+ for (k, i) in docs.iter().enumerate() {+ let Some(uid) = app.session.documents().get(*i).map(|d| d.uid) else { continue };+ if app.ui.floating.iter().any(|w| w.uid == uid) {+ continue;+ }+ let place = places.get(first + k).copied().unwrap_or(egui::Rect::from_min_size(egui::Pos2::ZERO, MIN_SIZE));+ app.ui.floating.push(DocWindow::new(uid, place));+ if let Some(v) = app.views.get_mut(*i) {+ v.fitted = false;+ }+ }+ if !docs.is_empty() {+ app.ui.home = None;+ }+}++/// The floating documents' indices, in the order their windows opened.+fn floating_indices(app: &VectorcraftApp) -> Vec<usize> {+ app.ui.floating.iter().filter_map(|w| app.session.documents().iter().position(|d| d.uid == w.uid)).collect()+}++/// `window.arrange.floatInWindow`: the current document leaves the tab strip for a floating window+/// of its own. A document already floating stays where it is. Returns `{floating}`.+pub(crate) fn float_in_window(app: &mut VectorcraftApp) -> Result<Value, String> {+ if let Some(i) = app.session.active_index().filter(|i| !is_floating(app, *i)) {+ float(app, &[i]);+ }+ Ok(json!({ "floating": floating_indices(app) }))+}++/// `window.arrange.floatAllInWindows`: every document under the tab strip goes to a floating window+/// of its own. Returns `{floating}`.+pub(crate) fn float_all(app: &mut VectorcraftApp) -> Result<Value, String> {+ let docked = docked(app);+ float(app, &docked);+ Ok(json!({ "floating": floating_indices(app) }))+}++/// `window.arrange.cascade`: every document in a floating window, the windows stacked from the+/// document area's upper left to its lower right in tab order, each fitted to its window, the+/// current document's in front. Returns `{floating}`.+pub(crate) fn cascade(app: &mut VectorcraftApp) -> Result<Value, String> {+ app.ui.tiled = false;+ let docked = docked(app);+ float(app, &docked);+ let order: Vec<u64> = app.session.documents().iter().map(|d| d.uid).collect();+ app.ui.floating.sort_by_key(|w| order.iter().position(|u| *u == w.uid));+ let places = cascade_places(area(app), app.ui.floating.len());+ for (w, place) in app.ui.floating.iter_mut().zip(places) {+ w.place = place;+ w.generation += 1;+ }+ for v in &mut app.views {+ v.fitted = false;+ }+ // The current document's window comes to the front.+ app.canvas.windows.current = None;+ Ok(json!({ "floating": floating_indices(app) }))+}++/// Every floating document back under the tab strip ([`crate::canvas::consolidate`], Tile), each+/// fitted to where it shows.+pub(crate) fn dock_all(app: &mut VectorcraftApp) {+ let floating = floating_indices(app);+ for i in floating {+ if let Some(v) = app.views.get_mut(i) {+ v.fitted = false;+ }+ }+ app.ui.floating.clear();+}++/// Whether the floating windows are OS windows: egui runs viewports of their own, the session is+/// not Wayland, where the main window cannot learn where its other windows are (craft-ui's docking+/// 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 {+ if ctx.embed_viewports() || app.control_rx.is_some() {+ return false;+ }+ #[cfg(any(target_os = "linux", target_os = "freebsd", target_os = "dragonfly", target_os = "netbsd", target_os = "openbsd"))]+ {+ let set = |name: &str| std::env::var_os(name).is_some_and(|v| !v.is_empty());+ if set("WAYLAND_DISPLAY") || set("WAYLAND_SOCKET") {+ // Under XWayland the main window reports where it is.+ return ctx.input_for(egui::ViewportId::ROOT, |i| i.viewport().outer_rect.is_some());+ }+ }+ true+}++/// The OS window of document window `uid`.+fn viewport_id(uid: u64) -> egui::ViewportId {+ egui::ViewportId::from_hash_of(("vectorcraft-document-window", uid))+}++/// The id of document window `w` inside the main window: a new one for each Cascade move, so egui+/// opens it at its new place and size.+fn window_id(w: &DocWindow) -> egui::Id {+ egui::Id::unique(("vectorcraft-document-window", w.uid, w.generation))+}++/// What happened in a document window this frame.+#[derive(Default)]+struct Shown {+ /// Its close button was pressed.+ close: bool,+ /// Its document asks to become the current one.+ activate: bool,+ /// Its OS window has the keyboard focus.+ focused: bool,+ /// Where it drew its document.+ body: Option<egui::Rect>,+ /// [`DocWindow::fit`] after this frame.+ fit: Option<Fit>,+}++/// Draw the floating document windows, after the main window's canvas. Call once per frame from+/// the main window.+pub(crate) fn show(app: &mut VectorcraftApp, ctx: &egui::Context) {+ let live: Vec<u64> = app.session.documents().iter().map(|d| d.uid).collect();+ app.ui.floating.retain(|w| live.contains(&w.uid));+ let current = app.session.active().map(|d| d.uid);+ if let Some(uid) = current.filter(|u| !app.ui.floating.iter().any(|w| w.uid == *u)) {+ app.ui.tab_document = Some(uid);+ }+ // Presentation Mode fits each floating document it shows to the main window: back in their+ // floating windows, those documents fit their windows again.+ let presenting = presenting(app);+ if presenting {+ let shown = app.canvas.windows.presented.get_or_insert_default();+ if let Some(uid) = current.filter(|u| app.ui.floating.iter().any(|w| w.uid == *u) && !shown.contains(u)) {+ shown.push(uid);+ if let Some(v) = app.session.active_index().and_then(|i| app.views.get_mut(i)) {+ v.fitted = false;+ ctx.request_repaint();+ }+ }+ } else if let Some(shown) = app.canvas.windows.presented.take() {+ for (d, v) in app.session.documents().iter().zip(app.views.iter_mut()) {+ if shown.contains(&d.uid) {+ v.fitted = false;+ }+ }+ }+ // While Presentation Mode hides the windows, `current` keeps the document whose window was in+ // front, so a document made current meanwhile comes to the front when it ends.+ if presenting {+ return;+ }+ if app.ui.floating.is_empty() {+ app.canvas.windows.current = current;+ return;+ }+ let raise = current.filter(|u| app.canvas.windows.current != Some(*u));+ let native = native(app, ctx);+ // Windows inside the main window that come back (after Presentation Mode) all go to the front+ // in their old order, so the raise waits for the next frame.+ let returning = !native+ && app.ui.floating.iter().any(|w| {+ let layer = egui::LayerId::new(egui::Order::Middle, window_id(w));+ ctx.memory(|m| m.area_rect(layer.id).is_some() && !m.areas().visible_last_frame(&layer))+ });+ if raise.is_some() && returning {+ ctx.request_repaint();+ } else {+ app.canvas.windows.current = current;+ }+ #[cfg(not(target_arch = "wasm32"))]+ if native {+ input::register(ctx, app.services.native_input_hook.clone(), app.ui.floating.iter().map(|w| viewport_id(w.uid)).collect());+ }+ // While a dialog or other modal is open the windows take no input, as the main window behind+ // it takes none: each draws its document as a pane, the current one included.+ let blocked = crate::panel_docking::modal_open(app, ctx);+ let mut close = None;+ let mut activate = None;+ for w in app.ui.floating.clone() {+ let Some(i) = app.session.documents().iter().position(|d| d.uid == w.uid) else { continue };+ let shown = if native {+ os_window(app, ctx, &w, (i, blocked), raise == Some(w.uid))+ } else {+ app_window(app, ctx, &w, (i, blocked), raise == Some(w.uid))+ };+ if blocked {+ continue;+ }+ if let Some(win) = app.ui.floating.iter_mut().find(|x| x.uid == w.uid) {+ // The OS window took the keyboard: its document becomes the current one.+ if shown.focused && !win.focused && app.session.active_index() != Some(i) {+ activate = Some(i);+ }+ win.focused = shown.focused;+ win.body = shown.body;+ win.fit = shown.fit;+ }+ if shown.close {+ close = Some(i);+ } else if shown.activate && app.session.active_index() != Some(i) {+ activate = Some(i);+ }+ }+ if let Some(i) = close {+ // The save prompt opens in the main window.+ if let Err(e) = crate::unsaved::close(app, i) {+ app.status(e);+ }+ if native && app.ui.dialog.is_some() {+ ctx.send_viewport_cmd_to(egui::ViewportId::ROOT, egui::ViewportCommand::Focus);+ }+ } else if let Some(i) = activate {+ crate::chrome::show_document(app, i);+ app.canvas.windows.current = app.session.active().map(|d| d.uid);+ }+}++/// Document `i`'s window body in `ui`: the canvas for the current document, else (and while+/// `blocked` by a modal) a pane. The document fits the body again when the body changed size since+/// `fit` and its view has not moved. → whether a press in the pane asks for its document to become+/// the current one, the body's rect and the fit after this frame.+fn body(app: &mut VectorcraftApp, ui: &mut egui::Ui, (i, blocked): (usize, bool), fit: Option<Fit>) -> (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);+ if let (Some(v), Some((size, zoom, center))) = (app.views.get_mut(i), fit)+ && size != rect.size()+ && zoom == v.zoom+ && center == v.center+ {+ v.fitted = false;+ }+ let was_fitted = app.views.get(i).is_some_and(|v| v.fitted);+ let pressed = if !blocked && app.session.active_index() == Some(i) && !crate::menus::home_showing(app) {+ crate::canvas::show(app, ui);+ false+ } else {+ crate::canvas::pane(app, ui, i, rect)+ };+ ui.advance_cursor_after_rect(rect);+ let fit = match app.views.get(i) {+ Some(v) if v.fitted && !was_fitted => Some((rect.size(), v.zoom, v.center)),+ _ => fit,+ };+ (pressed, rect, fit)+}++/// Document `i`'s window `w` as an OS window of its own, `blocked` by a modal or not; `raise`+/// brings it to the front.+fn os_window(app: &mut VectorcraftApp, ctx: &egui::Context, w: &DocWindow, (i, blocked): (usize, bool), raise: bool) -> Shown {+ let vid = viewport_id(w.uid);+ let origin = ctx.input(|inp| inp.viewport().inner_rect.map(|r| r.min)).filter(|p| p.is_finite()).unwrap_or(egui::Pos2::ZERO);+ let screen = match w.screen {+ Some((pos, generation)) if generation == w.generation => pos,+ moved => {+ let pos = origin + w.place.min.to_vec2();+ if moved.is_some() {+ ctx.send_viewport_cmd_to(vid, egui::ViewportCommand::OuterPosition(pos));+ ctx.send_viewport_cmd_to(vid, egui::ViewportCommand::InnerSize(w.place.size()));+ }+ if let Some(win) = app.ui.floating.iter_mut().find(|x| x.uid == w.uid) {+ win.screen = Some((pos, w.generation));+ }+ pos+ }+ };+ if raise {+ ctx.send_viewport_cmd_to(vid, egui::ViewportCommand::Focus);+ }+ let title = crate::chrome::document_window_title(app, i).unwrap_or_default();+ let builder =+ egui::ViewportBuilder::default().with_title(title).with_position(screen).with_inner_size(w.place.size()).with_min_inner_size(MIN_SIZE);+ let mut forwarded = (Vec::new(), None);+ let shown = ctx.show_viewport_immediate(vid, builder, |ui, _| {+ let (close, focused) = ui.input(|inp| (inp.viewport().close_requested(), inp.viewport().focused == Some(true)));+ if close {+ // The OS window stays until its document closes, which stops drawing it: a save prompt+ // or a modal can keep the document open.+ ui.ctx().send_viewport_cmd(egui::ViewportCommand::CancelClose);+ }+ let (activate, rect, fit) = body(app, ui, (i, blocked), w.fit);+ // Keys the window's widgets left over run the main window's shortcuts and tool keys, as a+ // floating panel's do.+ if !blocked && !ui.memory(|m| m.focused().is_some()) {+ forwarded = ui.input(|inp| {+ let events: Vec<egui::Event> = inp+ .events+ .iter()+ .filter(|e| {+ matches!(e, egui::Event::Key { .. } | egui::Event::Text(_) | egui::Event::Copy | egui::Event::Cut | egui::Event::Paste(_))+ })+ .cloned()+ .collect();+ (events, Some(inp.modifiers))+ });+ }+ Shown { close, activate, focused, body: Some(rect), fit }+ });+ if !forwarded.0.is_empty() {+ crate::panel_docking::forward_keys(app, ctx, forwarded.0, forwarded.1);+ }+ shown+}++/// Document `i`'s window `w` as a window inside the main window, `blocked` by a modal or not;+/// `raise` brings it to the front.+fn app_window(app: &mut VectorcraftApp, ctx: &egui::Context, w: &DocWindow, (i, blocked): (usize, bool), raise: bool) -> Shown {+ let id = window_id(w);+ if raise {+ ctx.move_to_top(egui::LayerId::new(egui::Order::Middle, id));+ }+ let title = crate::chrome::document_window_title(app, i).unwrap_or_default();+ let mut open = true;+ let (mut activate, mut rect, mut fit) = (false, None, w.fit);+ let frame = egui::Frame::window(&ctx.global_style()).inner_margin(0.0);+ let shown = egui::Window::new(title)+ .id(id)+ .default_rect(w.place)+ .min_size(MIN_SIZE)+ .collapsible(false)+ .resizable(true)+ .constrain_to(ctx.content_rect())+ .frame(frame)+ .open(&mut open)+ .show(ctx, |ui| {+ let (pressed, r, f) = body(app, ui, (i, blocked), fit);+ (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+ // document the current one.+ activate |= shown.is_some_and(|s| s.response.contains_pointer()) && ctx.input(|inp| inp.pointer.any_pressed());+ Shown { close: !open, activate, focused: false, body: rect, fit }+}++/// The host's rewrites of raw input ([`crate::services::Services::native_input_hook`]) for the+/// document windows' OS windows: eframe runs the host's hook for the main window only.+#[cfg(not(target_arch = "wasm32"))]+mod input {+ use std::collections::HashSet;++ use crate::services::NativeInputHook;++ /// Runs the hook on the input of the document windows' OS windows.+ #[derive(Default)]+ struct DocumentWindowInput {+ hook: Option<NativeInputHook>,+ windows: HashSet<egui::ViewportId>,+ }++ impl egui::Plugin for DocumentWindowInput {+ fn debug_name(&self) -> &'static str {+ "vectorcraft document windows input"+ }++ fn input_hook(&mut self, _: &egui::Context, input: &mut egui::RawInput) {+ if let Some(hook) = self.hook.as_ref().filter(|_| self.windows.contains(&input.viewport_id)) {+ hook(input);+ }+ }+ }++ /// Run `hook` on the input of `windows` from their next frame on.+ pub(super) fn register(ctx: &egui::Context, hook: Option<NativeInputHook>, windows: HashSet<egui::ViewportId>) {+ if hook.is_none() && ctx.with_plugin(|_: &mut DocumentWindowInput| ()).is_none() {+ return;+ }+ ctx.add_plugin(DocumentWindowInput::default());+ ctx.with_plugin(|p: &mut DocumentWindowInput| {+ p.hook = hook;+ p.windows = windows;+ });+ }+}++#[cfg(test)]+mod tests;diff --git a/crates/ui-egui/src/doc_windows/tests.rs b/crates/ui-egui/src/doc_windows/tests.rsnew file mode 100644index 000000000..f49728e95--- /dev/null+++ b/crates/ui-egui/src/doc_windows/tests.rs@@ -0,0 +1,459 @@+use egui::{Pos2, Shape, pos2, vec2};+use vectorcraft_engine::Session;++use super::*;+use crate::menus::enabled;++/// An app with `n` new 400 × 300 pt documents, the last one current.+fn app_with(n: usize) -> VectorcraftApp {+ let mut app = VectorcraftApp::new(Session::new(), Default::default());+ for _ in 0..n {+ app.run("file.new", json!({"width": 400, "height": 300})).unwrap();+ }+ app+}++/// One headless frame of the canvas panel's body (the tabs and the canvas or panes) on a+/// 1200 × 800 window, then the floating document windows, which egui draws inside the window →+/// the shapes it drew, `Shape::Vec`s flattened.+fn frame(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>) -> Vec<Shape> {+ fn flat(s: Shape, out: &mut Vec<Shape>) {+ match s {+ Shape::Vec(v) => v.into_iter().for_each(|s| flat(s, out)),+ s => out.push(s),+ }+ }+ 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| {+ app.canvas_area(ui);+ show(app, ui.ctx());+ });+ out.textures_delta.clear();+ let mut shapes = vec![];+ out.shapes.into_iter().for_each(|c| flat(c.shape, &mut shapes));+ shapes+}++fn button(pos: Pos2, pressed: bool) -> egui::Event {+ egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: Default::default() }+}++/// A press and release at `pos`, then a frame to settle.+fn click(app: &mut VectorcraftApp, ctx: &egui::Context, pos: Pos2) {+ frame(app, ctx, vec![egui::Event::PointerMoved(pos), button(pos, true)]);+ frame(app, ctx, vec![button(pos, false)]);+ frame(app, ctx, vec![]);+}++/// Where the last frame drew document `i`'s window body.+fn body_of(app: &VectorcraftApp, i: usize) -> egui::Rect {+ let uid = app.session.documents()[i].uid;+ app.ui.floating.iter().find(|w| w.uid == uid).and_then(|w| w.body).unwrap()+}++/// The whole of document `i`'s window inside the main window, title bar included.+fn window_of(app: &VectorcraftApp, ctx: &egui::Context, i: usize) -> egui::Rect {+ let uid = app.session.documents()[i].uid;+ let w = app.ui.floating.iter().find(|w| w.uid == uid).unwrap();+ ctx.memory(|m| m.area_rect(egui::Id::unique(("vectorcraft-document-window", w.uid, w.generation)))).unwrap()+}++/// A drag with the primary button from `from` to `to`, then a frame to settle.+fn drag(app: &mut VectorcraftApp, ctx: &egui::Context, from: Pos2, to: Pos2) {+ frame(app, ctx, vec![egui::Event::PointerMoved(from)]);+ frame(app, ctx, vec![button(from, true)]);+ for k in 1..=4 {+ frame(app, ctx, vec![egui::Event::PointerMoved(from + (to - from) * (k as f32 / 4.0))]);+ }+ frame(app, ctx, vec![button(to, false)]);+ frame(app, ctx, vec![]);+}++/// Whether the last frame drew text holding `title` in the tab strip (the top 35 points).+fn tab_drawn(shapes: &[Shape], title: &str) -> bool {+ shapes.iter().any(|s| matches!(s, Shape::Text(t) if t.pos.y < 35.0 && t.galley.text().contains(title)))+}++#[test]+fn cascade_places_step_down_and_right_inside_the_area() {+ let area = egui::Rect::from_min_size(pos2(10.0, 35.0), vec2(1190.0, 765.0));+ let places = cascade_places(area, 5);+ assert_eq!(places.len(), 5);+ for (k, p) in places.iter().enumerate() {+ assert!(area.contains_rect(*p), "place {k} is inside the area: {p:?}");+ assert_eq!(p.size(), places[0].size(), "every window is the same size");+ let offset = CASCADE_MARGIN + k as f32 * CASCADE_STEP;+ assert_eq!(p.min, area.min + vec2(offset, offset), "place {k} is {offset} pt down and right");+ }+ // A small area holds fewer steps: the stack starts again at the corner and stays inside.+ let small = egui::Rect::from_min_size(pos2(0.0, 0.0), vec2(500.0, 400.0));+ let places = cascade_places(small, 12);+ assert!(places.iter().all(|p| small.contains_rect(*p)), "{places:?}");+ assert!(places.iter().skip(1).any(|p| p.min == places[0].min), "the stack starts again: {places:?}");+ // An area smaller than a window: the window fills it.+ let tiny = egui::Rect::from_min_size(pos2(5.0, 5.0), vec2(100.0, 80.0));+ assert_eq!(cascade_places(tiny, 2), [tiny, tiny]);+}++#[test]+fn a_control_channel_keeps_the_windows_inside_the_main_window() {+ let ctx = egui::Context::default();+ ctx.set_embed_viewports(false);+ let plain = app_with(0);+ let wayland = ["WAYLAND_DISPLAY", "WAYLAND_SOCKET"].iter().any(|n| std::env::var_os(n).is_some_and(|v| !v.is_empty()));+ if !wayland {+ assert!(native(&plain, &ctx), "without a control channel the windows are OS windows");+ }+ let (_tx, rx) = std::sync::mpsc::channel();+ let controlled = VectorcraftApp::new(Session::new(), Default::default()).with_control(rx);+ assert!(!native(&controlled, &ctx), "with a control channel the windows stay inside the main window");+ ctx.set_embed_viewports(true);+ assert!(!native(&plain, &ctx), "where egui draws every viewport inside the main window");+}++#[test]+fn float_in_window_moves_the_current_document_out_of_the_tabs() {+ let mut app = app_with(3);+ let ctx = egui::Context::default();+ let shapes = frame(&mut app, &ctx, vec![]);+ let title = app.session.documents()[2].title();+ assert!(tab_drawn(&shapes, &title), "the current document has a tab");+ let tabbed = app.canvas_rect.unwrap();+ assert_eq!(app.run("window.arrange.floatInWindow", json!({})).unwrap(), json!({"floating": [2]}));+ frame(&mut app, &ctx, vec![]);+ let shapes = frame(&mut app, &ctx, vec![]);+ assert!(!tab_drawn(&shapes, &title), "a floating document has no tab");+ assert!(tab_drawn(&shapes, &app.session.documents()[0].title()));+ assert_eq!(docked(&app), [0, 1]);+ assert_eq!(app.session.active_index(), Some(2), "the floating document stays the current one");+ // Its window holds the canvas, fitted to the window; the main window shows a tabbed document.+ let body = body_of(&app, 2);+ let canvas = app.canvas_rect.unwrap();+ assert!(body.contains_rect(canvas) && canvas.width() < tabbed.width(), "the canvas is in the window: {canvas:?} in {body:?}");+ assert!(app.views[2].fitted);+ assert_eq!(tab_document(&app), Some(0));+ assert_eq!(crate::control::inspect(&app, &ctx)["floating"], json!([2]));+ // Floating it again leaves it where it is.+ assert_eq!(app.run("window.arrange.floatInWindow", json!({})).unwrap(), json!({"floating": [2]}));+ assert_eq!(app.ui.floating.len(), 1);+}++#[test]+fn a_press_in_another_documents_window_or_the_main_window_makes_its_document_current() {+ let mut app = app_with(3);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("document.activate", json!({"index": 0})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ app.run("document.activate", json!({"index": 1})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ assert_eq!(app.session.active_index(), Some(1));+ // The lower left of document 0's window, clear of document 1's window, which cascades below+ // and to the right of it, and of the window's resize edges.+ let body = body_of(&app, 0);+ click(&mut app, &ctx, pos2(body.left() + 12.0, body.bottom() - 12.0));+ assert_eq!(app.session.active_index(), Some(0), "a press in its window makes document 0 current");+ assert!(body_of(&app, 0).contains_rect(app.canvas_rect.unwrap()), "its window holds the canvas now");+ // The main window shows the only tabbed document as a pane: a press there makes it current.+ assert_eq!(tab_document(&app), Some(2));+ click(&mut app, &ctx, pos2(1100.0, 700.0));+ assert_eq!(app.session.active_index(), Some(2));+ // A press on the title bar of document 0's window, in front, makes document 0 current again.+ let (window, body) = (window_of(&app, &ctx, 0), body_of(&app, 0));+ click(&mut app, &ctx, pos2(window.left() + 60.0, (window.top() + body.top()) / 2.0));+ assert_eq!(app.session.active_index(), Some(0), "a press on its title bar makes document 0 current");+}++#[test]+fn a_resized_window_fits_its_document_again_unless_it_was_zoomed() {+ let mut app = app_with(2);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("document.activate", json!({"index": 0})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ app.run("document.activate", json!({"index": 1})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ let (before, other) = (app.views[1].zoom, app.views[0].zoom);+ // Document 1's window, in front and holding the canvas, grows from its lower-right corner.+ let window = window_of(&app, &ctx, 1);+ drag(&mut app, &ctx, window.right_bottom() - vec2(2.0, 2.0), window.right_bottom() + vec2(150.0, 100.0));+ assert!(window_of(&app, &ctx, 1).width() > window.width() + 100.0, "the window grew");+ frame(&mut app, &ctx, vec![]);+ assert_eq!(app.session.active_index(), Some(1));+ assert!(app.views[1].zoom > before, "the document fits its larger window: {before} → {}", app.views[1].zoom);+ assert_eq!(app.views[0].zoom, other, "the other window keeps its size and its document's zoom");+ // A zoomed view keeps its zoom when its window changes size again.+ app.run("view.zoomIn", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ let zoomed = app.views[1].zoom;+ let window = window_of(&app, &ctx, 1);+ drag(&mut app, &ctx, window.right_bottom() - vec2(2.0, 2.0), window.right_bottom() - vec2(100.0, 60.0));+ frame(&mut app, &ctx, vec![]);+ assert_eq!(app.views[1].zoom, zoomed, "a zoomed document keeps its zoom");+}++#[test]+fn cascade_floats_every_document_and_stacks_the_windows() {+ let mut app = app_with(3);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("window.arrange.tile", json!({})).unwrap();+ app.run("document.activate", json!({"index": 1})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ assert_eq!(app.run("window.arrange.cascade", json!({})).unwrap(), json!({"floating": [0, 1, 2]}));+ assert!(!app.ui.tiled, "Cascade ends Tile");+ assert!(docked(&app).is_empty());+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ let area = app.canvas.windows.area.unwrap();+ let places: Vec<egui::Rect> = app.ui.floating.iter().map(|w| w.place).collect();+ assert_eq!(places, cascade_places(area, 3), "the windows stack in tab order, document 1's moved from where it floated");+ for (i, place) in places.iter().copied().enumerate() {+ let body = body_of(&app, i);+ assert!((body.left() - place.left()).abs() < 4.0 && body.top() > place.top(), "document {i}'s window is at its place: {body:?} {place:?}");+ assert!(app.views[i].fitted, "document {i} fits its window");+ }+ assert!(body_of(&app, 1).contains_rect(app.canvas_rect.unwrap()), "the current document's window holds the canvas");+}++#[test]+fn float_all_in_windows_floats_the_tabbed_documents_and_consolidate_brings_them_back() {+ let mut app = app_with(3);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ let tabbed = app.canvas_rect.unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ let first = app.ui.floating[0].place;+ assert_eq!(app.run("window.arrange.floatAllInWindows", json!({})).unwrap(), json!({"floating": [2, 0, 1]}));+ assert_eq!(app.ui.floating[0].place, first, "a window already floating stays where it is");+ assert!(docked(&app).is_empty());+ frame(&mut app, &ctx, vec![]);+ assert_eq!(app.run("window.arrange.consolidateAllWindows", json!({})).unwrap(), json!({"tiled": false, "floating": []}));+ frame(&mut app, &ctx, vec![]);+ let shapes = frame(&mut app, &ctx, vec![]);+ assert_eq!(docked(&app), [0, 1, 2]);+ for d in app.session.documents() {+ assert!(tab_drawn(&shapes, &d.title()), "{} has its tab again", d.title());+ }+ assert_eq!(app.canvas_rect, Some(tabbed), "the canvas is under the tabs again");+ assert!(app.views[2].fitted);+}++#[test]+fn tile_brings_floating_documents_back_into_the_grid() {+ let mut app = app_with(3);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("window.arrange.tile", json!({})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ let docs: Vec<usize> = app.canvas.panes.last.iter().map(|(i, _)| *i).collect();+ assert_eq!(docs, [0, 1], "a floating document leaves the grid; the tabbed ones share it");+ assert_eq!(app.run("window.arrange.tile", json!({})).unwrap(), json!({"tiled": true, "panes": 3}));+ frame(&mut app, &ctx, vec![]);+ let docs: Vec<usize> = app.canvas.panes.last.iter().map(|(i, _)| *i).collect();+ assert_eq!(docs, [0, 1, 2]);+ assert!(app.ui.floating.is_empty());+}++#[test]+fn closing_a_floating_window_closes_its_document_and_asks_to_save_an_unsaved_one() {+ let mut app = app_with(2);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("window.arrange.floatAllInWindows", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ // Document 0's window is behind document 1's: its close button is at the top right of its+ // title bar, clear of document 1's window to the right and below.+ let close_button = |app: &VectorcraftApp, i: usize| {+ let uid = app.session.documents()[i].uid;+ let w = app.ui.floating.iter().find(|w| w.uid == uid).unwrap();+ let area = ctx.memory(|m| m.area_rect(egui::Id::unique(("vectorcraft-document-window", w.uid, w.generation)))).unwrap();+ let body = w.body.unwrap();+ (area, body)+ };+ let (area0, body0) = close_button(&app, 0);+ assert!(body0.top() > area0.top(), "the window has a title bar");+ // Close document 1 (in front): it is unsaved after an edit, so the app asks first.+ app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 40})).unwrap();+ assert!(app.session.documents()[1].is_dirty());+ frame(&mut app, &ctx, vec![]);+ // The close button sits near the right end of the title bar.+ let press_close = |app: &mut VectorcraftApp, i: usize| {+ let (area, body) = close_button(app, i);+ let bar = (area.top() + body.top()) / 2.0;+ let n = app.session.documents().len();+ for dx in (4..40).step_by(3) {+ click(app, &ctx, pos2(area.right() - dx as f32, bar));+ if app.ui.dialog.is_some() || app.session.documents().len() < n {+ return true;+ }+ }+ false+ };+ assert!(press_close(&mut app, 1), "the close button of document 1's window acts");+ assert!(app.ui.dialog.is_some(), "an unsaved document asks to be saved");+ assert_eq!(app.session.documents().len(), 2);+ // While the prompt is open the windows take no press.+ let body = body_of(&app, 0);+ click(&mut app, &ctx, pos2(body.left() + 12.0, body.bottom() - 12.0));+ assert_eq!(app.session.active_index(), Some(1), "a press in another window waits for the prompt");+ app.ui.dialog = None;+ // Document 0 has no changes: its window closes with it.+ app.run("document.activate", json!({"index": 0})).unwrap();+ frame(&mut app, &ctx, vec![]);+ assert!(press_close(&mut app, 0), "the close button of document 0's window acts");+ assert_eq!(app.session.documents().len(), 1);+ frame(&mut app, &ctx, vec![]);+ assert_eq!(app.ui.floating.len(), 1, "its window has gone");+}++#[test]+fn presentation_mode_shows_the_floating_current_document_in_the_main_window() {+ let mut app = app_with(2);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("window.arrange.floatAllInWindows", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ let body = body_of(&app, 1);+ assert!(body.contains_rect(app.canvas_rect.unwrap()), "the current document's window holds the canvas");+ let windowed = (app.views[0].zoom, app.views[1].zoom);+ app.run("view.presentation", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ let shown = app.canvas_rect.unwrap();+ assert!(shown.width() > body.width() + 100.0, "the main window shows the current document: {shown:?}, its window was {body:?}");+ // The presentation goes on to the other floating document, fitted to the main window, then+ // ends on the first one.+ app.run("document.activate", json!({"index": 0})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ app.run("document.activate", json!({"index": 1})).unwrap();+ frame(&mut app, &ctx, vec![]);+ assert!(app.views[0].zoom > windowed.0, "the presentation fitted document 0 to the main window");+ app.run("view.presentation", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ assert!(body_of(&app, 1).contains_rect(app.canvas_rect.unwrap()), "the window holds the canvas again");+ assert_eq!(app.ui.floating.len(), 2, "the windows come back");+ for (i, before) in [windowed.0, windowed.1].into_iter().enumerate() {+ assert!((app.views[i].zoom - before).abs() < 1e-6, "document {i} fits its window again: {before} → {}", app.views[i].zoom);+ }+}++#[test]+fn a_document_made_current_in_presentation_mode_comes_to_the_front_after_it() {+ let mut app = app_with(2);+ let ctx = egui::Context::default();+ frame(&mut app, &ctx, vec![]);+ app.run("window.arrange.floatAllInWindows", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ let layer = |app: &VectorcraftApp, i: usize| {+ let uid = app.session.documents()[i].uid;+ let w = app.ui.floating.iter().find(|w| w.uid == uid).unwrap();+ egui::LayerId::new(egui::Order::Middle, egui::Id::unique(("vectorcraft-document-window", w.uid, w.generation)))+ };+ let top = |ctx: &egui::Context| ctx.memory(|m| m.areas().top_layer_id(egui::Order::Middle));+ assert_eq!(top(&ctx), Some(layer(&app, 1)), "the current document's window is in front");+ app.run("view.presentation", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ app.run("document.activate", json!({"index": 0})).unwrap();+ frame(&mut app, &ctx, vec![]);+ app.run("view.presentation", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ frame(&mut app, &ctx, vec![]);+ assert_eq!(top(&ctx), Some(layer(&app, 0)), "document 0's window comes to the front");+}++/// A stand-in for the window system of the documents' OS windows: it runs each one's frame, asks+/// each to close while `close` is set, and records the commands the windows were sent.+#[derive(Default)]+struct Host {+ close: bool,+ commands: Vec<(egui::ViewportId, egui::ViewportCommand)>,+}++fn native_host() -> std::rc::Rc<std::cell::RefCell<Host>> {+ let host = std::rc::Rc::new(std::cell::RefCell::new(Host::default()));+ let shared = host.clone();+ egui::Context::set_immediate_viewport_renderer(move |ctx, mut viewport| {+ let id = viewport.ids.this;+ let events = if shared.borrow().close { vec![egui::ViewportEvent::Close] } else { vec![] };+ let rect = egui::Rect::from_min_size(Pos2::ZERO, vec2(500.0, 400.0));+ let info = egui::ViewportInfo { events, inner_rect: Some(rect), outer_rect: Some(rect), focused: Some(false), ..Default::default() };+ let input =+ egui::RawInput { viewport_id: id, viewports: std::iter::once((id, info)).collect(), screen_rect: Some(rect), ..Default::default() };+ let mut full = ctx.run_ui(input, |ui| (viewport.viewport_ui_cb)(ui));+ full.textures_delta.clear();+ let mut host = shared.borrow_mut();+ for (vid, output) in full.viewport_output {+ host.commands.extend(output.commands.into_iter().map(|c| (vid, c)));+ }+ });+ host+}++#[test]+fn closing_an_os_window_keeps_it_while_its_unsaved_document_stays_open() {+ let host = native_host();+ let ctx = egui::Context::default();+ ctx.set_embed_viewports(false);+ let mut app = app_with(2);+ if !native(&app, &ctx) {+ // Wayland: the windows are inside the main window.+ return;+ }+ frame(&mut app, &ctx, vec![]);+ app.run("shape.rectangle", json!({"x": 10, "y": 10, "width": 50, "height": 40})).unwrap();+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ frame(&mut app, &ctx, vec![]);+ let vid = viewport_id(app.session.documents()[1].uid);+ host.borrow_mut().close = true;+ frame(&mut app, &ctx, vec![]);+ host.borrow_mut().close = false;+ assert!(app.ui.dialog.is_some(), "the unsaved document asks to be saved");+ assert_eq!(app.session.documents().len(), 2);+ assert!(is_floating(&app, 1), "the document still floats");+ assert!(+ host.borrow().commands.iter().any(|(id, c)| *id == vid && *c == egui::ViewportCommand::CancelClose),+ "its OS window is kept open: {:?}",+ host.borrow().commands+ );+}++#[test]+fn the_arrange_items_are_enabled_as_the_documents_allow() {+ let ids = [+ "window.arrange.cascade",+ "window.arrange.tile",+ "window.arrange.floatInWindow",+ "window.arrange.floatAllInWindows",+ "window.arrange.consolidateAllWindows",+ ];+ let states = |app: &VectorcraftApp| ids.map(|id| enabled(app, id));+ let mut app = app_with(0);+ assert_eq!(states(&app), [false; 5], "no document");+ app.run("file.new", json!({"width": 400, "height": 300})).unwrap();+ assert_eq!(states(&app), [false, false, true, true, false], "one tabbed document");+ app.run("file.new", json!({"width": 400, "height": 300})).unwrap();+ assert_eq!(states(&app), [true, true, true, true, false], "two tabbed documents");+ app.run("window.arrange.floatInWindow", json!({})).unwrap();+ assert_eq!(states(&app), [true, true, false, true, true], "the current document floats, one is tabbed");+ app.run("window.arrange.floatAllInWindows", json!({})).unwrap();+ assert_eq!(states(&app), [true, true, false, false, true], "every document floats");+ app.run("document.activate", json!({"index": 0})).unwrap();+ app.run("window.arrange.consolidateAllWindows", json!({})).unwrap();+ assert_eq!(states(&app), [true, true, true, true, false], "consolidated");+}diff --git a/crates/ui-egui/src/i18n/bg.tsv b/crates/ui-egui/src/i18n/bg.tsvindex 9b878ba85..fe8c162df 100644--- a/crates/ui-egui/src/i18n/bg.tsv+++ b/crates/ui-egui/src/i18n/bg.tsv@@ -1177,6 +1177,7 @@ font-technology Variable ПроменливиFlip Row Order Обръщане реда на редоветеFlip Vertical Вертикално обръщанеFloat in Window Плаващ прозорец+ Float All in Windows Всички в плаващи прозорциFocal Fill Фокусно запълванеFocal Stroke Фокусен щрихFolder Папкаdiff --git a/crates/ui-egui/src/i18n/bs.tsv b/crates/ui-egui/src/i18n/bs.tsvindex 9534ca7a9..003a6189a 100644--- a/crates/ui-egui/src/i18n/bs.tsv+++ b/crates/ui-egui/src/i18n/bs.tsv@@ -628,6 +628,7 @@Cascade KaskadnoTile PopločajFloat in Window Odvoji u prozor+ Float All in Windows Odvoji sve u prozoreConsolidate All Windows Objedini sve prozoreWorkspace Radni prostorReset Essentials Vrati Osnove na početnodiff --git a/crates/ui-egui/src/i18n/ca.tsv b/crates/ui-egui/src/i18n/ca.tsvindex e8ca95295..a28db5502 100644--- a/crates/ui-egui/src/i18n/ca.tsv+++ b/crates/ui-egui/src/i18n/ca.tsv@@ -1610,6 +1610,7 @@ digits Malayalam MalaiàlamFlip Vertical Inverteix verticalmentFlip: Inverteix:Float in Window Flota a la finestra+ Float All in Windows Flota-ho tot en finestresFloat Panel Flota el panellFloat Tool Group Flota el grup d’einesFocal Fill Farciment focaldiff --git a/crates/ui-egui/src/i18n/cs.tsv b/crates/ui-egui/src/i18n/cs.tsvindex 7f4beb00c..f69545e1b 100644--- a/crates/ui-egui/src/i18n/cs.tsv+++ b/crates/ui-egui/src/i18n/cs.tsv@@ -636,6 +636,7 @@Cascade Do kaskádyTile Vedle sebeFloat in Window Uvolnit do samostatného okna+ Float All in Windows Uvolnit vše do samostatných okenConsolidate All Windows Sloučit všechna oknaWorkspace Pracovní prostorReset Essentials Obnovit Essentialsdiff --git a/crates/ui-egui/src/i18n/da.tsv b/crates/ui-egui/src/i18n/da.tsvindex f19aa9edf..d78046e91 100644--- a/crates/ui-egui/src/i18n/da.tsv+++ b/crates/ui-egui/src/i18n/da.tsv@@ -586,6 +586,7 @@Cascade KaskadeTile FliselægFloat in Window Flyd i vindue+ Float All in Windows Flyd alle i vinduerConsolidate All Windows Saml alle vinduerWorkspace ArbejdsområdeReset Essentials Nulstil Essentialsdiff --git a/crates/ui-egui/src/i18n/de.tsv b/crates/ui-egui/src/i18n/de.tsvindex 6d39cdcde..cde85a2c0 100644--- a/crates/ui-egui/src/i18n/de.tsv+++ b/crates/ui-egui/src/i18n/de.tsv@@ -1208,6 +1208,7 @@ file-filter Templates VorlagenFlip Row Order Zeilenreihenfolge umkehrenFlip Vertical Vertikal spiegelnFloat in Window In eigenem Fenster anzeigen+ Float All in Windows Alle in eigenen Fenstern anzeigenFocal Fill Fläche im FokusFocal Stroke Kontur im FokusFolder Ordnerdiff --git a/crates/ui-egui/src/i18n/el.tsv b/crates/ui-egui/src/i18n/el.tsvindex 644ebd5ee..1dbe39f0f 100644--- a/crates/ui-egui/src/i18n/el.tsv+++ b/crates/ui-egui/src/i18n/el.tsv@@ -1150,6 +1150,7 @@ font-technology Variable ΜεταβλητέςFlip Row Order Αντιστροφή σειράς γραμμώνFlip Vertical Κατακόρυφη αναστροφήFloat in Window Μετατροπή σε ανεξάρτητο παράθυρο+ Float All in Windows Μετατροπή όλων σε ανεξάρτητα παράθυραFocal Fill Εστιακό γέμισμαFocal Stroke Εστιακό περίγραμμαFolder Φάκελοςdiff --git a/crates/ui-egui/src/i18n/es.tsv b/crates/ui-egui/src/i18n/es.tsvindex 43bf0eac6..ad2759838 100644--- a/crates/ui-egui/src/i18n/es.tsv+++ b/crates/ui-egui/src/i18n/es.tsv@@ -1226,6 +1226,7 @@ font-technology Variable VariablesFlip Row Order Invertir orden de filasFlip Vertical Voltear verticalmenteFloat in Window Flotar en ventana+ Float All in Windows Flotar todo en ventanasFocal Fill Relleno focalFocal Stroke Trazo focalFolder Carpetadiff --git a/crates/ui-egui/src/i18n/fi.tsv b/crates/ui-egui/src/i18n/fi.tsvindex 725e924db..294c51387 100644--- a/crates/ui-egui/src/i18n/fi.tsv+++ b/crates/ui-egui/src/i18n/fi.tsv@@ -627,6 +627,7 @@Cascade PorrastaTile VierekkäinFloat in Window Kelluta ikkunassa+ Float All in Windows Kelluta kaikki ikkunoissaConsolidate All Windows Yhdistä kaikki ikkunatWorkspace TyötilaReset Essentials Palauta Essentialsdiff --git a/crates/ui-egui/src/i18n/fr.tsv b/crates/ui-egui/src/i18n/fr.tsvindex b68eef31c..f5e604a25 100644--- a/crates/ui-egui/src/i18n/fr.tsv+++ b/crates/ui-egui/src/i18n/fr.tsv@@ -1220,6 +1220,7 @@ font-technology Variable VariablesFlip Row Order Inverser l’ordre des lignesFlip Vertical Retourner verticalementFloat in Window Flottant dans une fenêtre+ Float All in Windows Tout flottant dans des fenêtresFocal Fill Fond actifFocal Stroke Contour actifFolder Dossierdiff --git a/crates/ui-egui/src/i18n/hu.tsv b/crates/ui-egui/src/i18n/hu.tsvindex 70c29f4e2..1ce300e5d 100644--- a/crates/ui-egui/src/i18n/hu.tsv+++ b/crates/ui-egui/src/i18n/hu.tsv@@ -1528,6 +1528,7 @@ file-filter Templates SablonokFlip Vertical Függőleges tükrözésFlip: Tükrözés:Float in Window Lebegtetés ablakban+ Float All in Windows Összes lebegtetése ablakokbanFloat Panel Panel lebegtetéseFloat Tool Group Eszközcsoport lebegtetéseFocal Fill Aktív kitöltésdiff --git a/crates/ui-egui/src/i18n/id.tsv b/crates/ui-egui/src/i18n/id.tsvindex 5973cf3b6..336e64182 100644--- a/crates/ui-egui/src/i18n/id.tsv+++ b/crates/ui-egui/src/i18n/id.tsv@@ -586,6 +586,7 @@Cascade BertingkatTile UbinFloat in Window Mengambang di jendela+ Float All in Windows Mengambangkan semua di jendelaConsolidate All Windows Konsolidasikan semua jendelaWorkspace Ruang kerjaReset Essentials Atur ulang Essentialsdiff --git a/crates/ui-egui/src/i18n/it.tsv b/crates/ui-egui/src/i18n/it.tsvindex 0b1ba1faf..72d8ab51f 100644--- a/crates/ui-egui/src/i18n/it.tsv+++ b/crates/ui-egui/src/i18n/it.tsv@@ -1238,6 +1238,7 @@ file-filter Templates ModelliFlip Row Order Inverti ordine delle righeFlip Vertical Capovolgi verticalmenteFloat in Window Rendi mobile nella finestra+ Float All in Windows Rendi tutto mobile nelle finestreFocal Fill Riempimento attivoFocal Stroke Traccia attivaFolder Cartelladiff --git a/crates/ui-egui/src/i18n/ja.tsv b/crates/ui-egui/src/i18n/ja.tsvindex b0ce51082..2fd494bd3 100644--- a/crates/ui-egui/src/i18n/ja.tsv+++ b/crates/ui-egui/src/i18n/ja.tsv@@ -648,6 +648,7 @@ digits Malayalam マラヤーラム数字Cascade 重ねて表示Tile 並べて表示Float in Window ウィンドウを分離+ Float All in Windows すべてをウィンドウに分離Consolidate All Windows すべてのウィンドウを統合Workspace ワークスペースReset Essentials 初期設定をリセットdiff --git a/crates/ui-egui/src/i18n/ka.tsv b/crates/ui-egui/src/i18n/ka.tsvindex 649aeb95c..3ab0c61b4 100644--- a/crates/ui-egui/src/i18n/ka.tsv+++ b/crates/ui-egui/src/i18n/ka.tsv@@ -538,6 +538,7 @@Cascade კასკადადTile ფილებადFloat in Window ცალკე ფანჯარაში გამოტანა+ Float All in Windows ყველას ცალკე ფანჯრებში გამოტანაConsolidate All Windows ყველა ფანჯრის გაერთიანებაWorkspace სამუშაო სივრცეReset Essentials Essentials-ის ჩამოყრაdiff --git a/crates/ui-egui/src/i18n/ko.tsv b/crates/ui-egui/src/i18n/ko.tsvindex f3efc9cbb..7f9542920 100644--- a/crates/ui-egui/src/i18n/ko.tsv+++ b/crates/ui-egui/src/i18n/ko.tsv@@ -641,6 +641,7 @@ digits Malayalam 말라얄람어Cascade 계단식 배열Tile 바둑판식 배열Float in Window 창에 플로팅+ Float All in Windows 모두 창에 플로팅Consolidate All Windows 모든 창 통합Workspace 작업 영역Reset Essentials Essentials 재설정diff --git a/crates/ui-egui/src/i18n/nl.tsv b/crates/ui-egui/src/i18n/nl.tsvindex 9c34aff5a..65a015fd2 100644--- a/crates/ui-egui/src/i18n/nl.tsv+++ b/crates/ui-egui/src/i18n/nl.tsv@@ -600,6 +600,7 @@Cascade Trapsgewijs schikkenTile Naast elkaar schikkenFloat in Window In venster zweven+ Float All in Windows Alles in vensters zwevenConsolidate All Windows Alle vensters samenvoegenWorkspace WerkruimteReset Essentials Essentials herstellendiff --git a/crates/ui-egui/src/i18n/pl.tsv b/crates/ui-egui/src/i18n/pl.tsvindex bfa3d2c57..3eb6257e7 100644--- a/crates/ui-egui/src/i18n/pl.tsv+++ b/crates/ui-egui/src/i18n/pl.tsv@@ -594,6 +594,7 @@Cascade KaskadowoTile SąsiadującoFloat in Window Pływające w oknie+ Float All in Windows Wszystkie pływające w oknachConsolidate All Windows Scal wszystkie oknaWorkspace Obszar roboczyReset Essentials Resetuj Essentialsdiff --git a/crates/ui-egui/src/i18n/pt-br.tsv b/crates/ui-egui/src/i18n/pt-br.tsvindex 3135901d4..15bccd1f7 100644--- a/crates/ui-egui/src/i18n/pt-br.tsv+++ b/crates/ui-egui/src/i18n/pt-br.tsv@@ -1091,6 +1091,7 @@Flip Row Order Inverter Ordem das LinhasFlip Vertical Espelhar VerticalmenteFloat in Window Flutuar na Janela+ Float All in Windows Flutuar Tudo em JanelasFolder PastaFolder Name: Nome da Pasta:Font Fontediff --git a/crates/ui-egui/src/i18n/ru.tsv b/crates/ui-egui/src/i18n/ru.tsvindex 581cecc4f..ccf399ddf 100644--- a/crates/ui-egui/src/i18n/ru.tsv+++ b/crates/ui-egui/src/i18n/ru.tsv@@ -1235,6 +1235,7 @@ file-filter Templates ШаблоныFlip Row Order Изменить порядок строкFlip Vertical Отразить по вертикалиFloat in Window Плавать в окне+ Float All in Windows Все плавающие в окнахFocal Fill Фокусная заливкаFocal Stroke Фокусная обводкаFolder Папкаdiff --git a/crates/ui-egui/src/i18n/sv.tsv b/crates/ui-egui/src/i18n/sv.tsvindex a5c492ff0..4ee641f80 100644--- a/crates/ui-egui/src/i18n/sv.tsv+++ b/crates/ui-egui/src/i18n/sv.tsv@@ -1185,6 +1185,7 @@ font-technology Variable VariablaFlip Row Order Vänd radordningFlip Vertical Vänd lodrättFloat in Window Gör flytande i fönster+ Float All in Windows Gör alla flytande i fönsterFocal Fill Fokal fyllningFocal Stroke Fokal konturFolder Mappdiff --git a/crates/ui-egui/src/i18n/tr.tsv b/crates/ui-egui/src/i18n/tr.tsvindex f1058a616..cbf5bf629 100644--- a/crates/ui-egui/src/i18n/tr.tsv+++ b/crates/ui-egui/src/i18n/tr.tsv@@ -1179,6 +1179,7 @@ font-technology Variable DeğişkenFlip Row Order Satır Sırasını ÇevirFlip Vertical Dikey ÇevirFloat in Window Pencerede Yüzer Yap+ Float All in Windows Tümünü Pencerelerde Yüzer YapFocal Fill Odak DolgusuFocal Stroke Odak KonturuFolder Klasördiff --git a/crates/ui-egui/src/i18n/uk.tsv b/crates/ui-egui/src/i18n/uk.tsvindex ed181d4e5..037d98050 100644--- a/crates/ui-egui/src/i18n/uk.tsv+++ b/crates/ui-egui/src/i18n/uk.tsv@@ -1232,6 +1232,7 @@ file-filter Templates ШаблониFlip Row Order Змінити порядок рядківFlip Vertical Відобразити по вертикаліFloat in Window Відкріпити у вікні+ Float All in Windows Відкріпити все у вікнаFocal Fill Фокусна заливкаFocal Stroke Фокусне обведенняFolder Папкаdiff --git a/crates/ui-egui/src/i18n/vi.tsv b/crates/ui-egui/src/i18n/vi.tsvindex 882c2d9d0..c4666f6ca 100644--- a/crates/ui-egui/src/i18n/vi.tsv+++ b/crates/ui-egui/src/i18n/vi.tsv@@ -1431,6 +1431,7 @@ file-filter Templates MẫuFlip Vertical Lật dọcFlip: Lật:Float in Window Nổi trong cửa sổ+ Float All in Windows Nổi tất cả trong cửa sổFloat Panel Thả nổi bảngFloat Tool Group Thả nổi nhóm công cụFocal Fill Tô tiêu điểmdiff --git a/crates/ui-egui/src/i18n/zh-hans.tsv b/crates/ui-egui/src/i18n/zh-hans.tsvindex a86bb6fcd..0a0bee4c1 100644--- a/crates/ui-egui/src/i18n/zh-hans.tsv+++ b/crates/ui-egui/src/i18n/zh-hans.tsv@@ -1176,6 +1176,7 @@ file-filter Templates 模板Flip Row Order 反转行顺序Flip Vertical 垂直翻转Float in Window 在窗口中浮动+ Float All in Windows 全部在窗口中浮动Focal Fill 焦点填色Focal Stroke 焦点描边Folder 文件夹diff --git a/crates/ui-egui/src/i18n/zh-hant.tsv b/crates/ui-egui/src/i18n/zh-hant.tsvindex 9e547232c..b96f2a2a1 100644--- a/crates/ui-egui/src/i18n/zh-hant.tsv+++ b/crates/ui-egui/src/i18n/zh-hant.tsv@@ -1202,6 +1202,7 @@ file-filter Templates 範本Flip Row Order 反轉列順序Flip Vertical 垂直翻轉Float in Window 在視窗中浮動+ Float All in Windows 全部在視窗中浮動Focal Fill 焦點填色Focal Stroke 焦點筆畫Folder 資料夾diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rsindex de33cfcce..bdfcaffff 100644--- a/crates/ui-egui/src/lib.rs+++ b/crates/ui-egui/src/lib.rs@@ -34,6 +34,7 @@ pub mod credits;pub mod cursors;mod custom_toolbars;pub mod dialogs;+pub mod doc_windows;pub mod dock;mod edit_toolbar;pub mod export_progress;diff --git a/crates/ui-egui/src/menus/run.rs b/crates/ui-egui/src/menus/run.rsindex 5ba39f237..d54173c3d 100644--- a/crates/ui-egui/src/menus/run.rs+++ b/crates/ui-egui/src/menus/run.rs@@ -545,7 +545,10 @@ fn run_ui_part6(app: &mut VectorcraftApp, id: &str, p: &Value) -> Option<Result<None => Err("brightness must be dark|mediumDark|mediumLight|light".into()),},"window.newWindow" => Err("New Window isn't available yet: a document opens in one window".into()),+ "window.arrange.cascade" => crate::doc_windows::cascade(app),"window.arrange.tile" => crate::canvas::tile(app),+ "window.arrange.floatInWindow" => crate::doc_windows::float_in_window(app),+ "window.arrange.floatAllInWindows" => crate::doc_windows::float_all(app),"window.arrange.consolidateAllWindows" => crate::canvas::consolidate(app),"window.nextDocument" => crate::chrome::step_document(app, true),"window.previousDocument" => crate::chrome::step_document(app, false),diff --git a/crates/ui-egui/src/menus/state.rs b/crates/ui-egui/src/menus/state.rsindex 26904fcae..523d930e0 100644--- a/crates/ui-egui/src/menus/state.rs+++ b/crates/ui-egui/src/menus/state.rs@@ -283,11 +283,18 @@ pub fn enabled(app: &VectorcraftApp, id: &str) -> bool {app.session.active().is_some() && crate::dialogs::perspective_presets::slot_preset(app, id).is_some()}"ui.perspectivePlane" => app.session.active().is_some(),- // Only one window per document so far: greyed out, as Cascade and Float in Window are (#3724).+ // Only one window per document so far: grayed out (#3724)."window.newWindow" => false,- // Tile with two documents or more; Consolidate All Windows while they are tiled.- "window.arrange.tile" => app.session.documents().len() > 1,- "window.arrange.consolidateAllWindows" => app.ui.tiled && !app.session.documents().is_empty(),+ // Tile and Cascade with two documents or more; Float in Window for a current document under+ // the tabs; Float All in Windows while a document is under the tabs; Consolidate All+ // Windows while documents are tiled or floating.+ "window.arrange.tile" | "window.arrange.cascade" => app.session.documents().len() > 1,+ "window.arrange.floatInWindow" => app.session.active_index().is_some_and(|i| !crate::doc_windows::is_floating(app, i)),+ "window.arrange.floatAllInWindows" => !crate::doc_windows::docked(app).is_empty(),+ "window.arrange.consolidateAllWindows" => {+ let n = app.session.documents().len();+ n > 0 && (app.ui.tiled || crate::doc_windows::docked(app).len() < n)+ }"window.nextDocument" | "window.previousDocument" => !app.session.documents().is_empty(),_ => true,}diff --git a/crates/ui-egui/src/menus/tree.rs b/crates/ui-egui/src/menus/tree.rsindex d197ee906..3a55ab37c 100644--- a/crates/ui-egui/src/menus/tree.rs+++ b/crates/ui-egui/src/menus/tree.rs@@ -612,9 +612,10 @@ pub fn menu_tree_named(english_names: bool) -> Vec<(&'static str, Vec<Item>)> {sub("Arrange",vec![- todo("Cascade"),+ c("Cascade", "window.arrange.cascade"),c("Tile", "window.arrange.tile"),- todo("Float in Window"),+ c("Float in Window", "window.arrange.floatInWindow"),+ c("Float All in Windows", "window.arrange.floatAllInWindows"),c("Consolidate All Windows", "window.arrange.consolidateAllWindows"),],),diff --git a/crates/ui-egui/src/menus/ui_commands.rs b/crates/ui-egui/src/menus/ui_commands.rsindex f0446a766..c97450093 100644--- a/crates/ui-egui/src/menus/ui_commands.rs+++ b/crates/ui-egui/src/menus/ui_commands.rs@@ -581,17 +581,35 @@ pub const UI_COMMANDS: &[(&str, &str, &str, &str)] = &[("window.workspace.rename", "Rename Workspace", "", "{name, to}"),("window.workspace.list", "List Workspaces", "", "{}"),("window.newWindow", "New Window", "", "{}"),+ (+ "window.arrange.cascade",+ "Cascade",+ "",+ "{} put every open document in a floating window of its own and stack the windows from the upper left of the document area to its lower right, 30 pt apart, in tab order, each fitted to its window, the current document's in front; on the desktop each is an OS window, on the web and Wayland a window inside the app's window; returns {floating} (document indices)",+ ),("window.arrange.tile","Tile","",- "{} show every open document at once, edge to edge in the document area, one pane each in a grid (columns: the square root of the number of documents, rounded up), each fitted to its pane; the current document's pane takes the tools, a click in another pane makes its document the current one; the tabs stay; returns {tiled: true, panes}",+ "{} show every open document at once, edge to edge in the document area, one pane each in a grid (columns: the square root of the number of documents, rounded up), each fitted to its pane; the current document's pane takes the tools, a click in another pane makes its document the current one; the tabs stay; documents in floating windows come back under the tabs first; returns {tiled: true, panes}",+ ),+ (+ "window.arrange.floatInWindow",+ "Float in Window",+ "",+ "{} move the current document out of the tab strip into a floating window of its own, fitted to it; the window holding the current document takes the tools, a click in another document's window makes its document the current one; a document already floating stays where it is; returns {floating} (document indices)",+ ),+ (+ "window.arrange.floatAllInWindows",+ "Float All in Windows",+ "",+ "{} move every document under the tab strip into a floating window of its own, at the next places of a cascade; returns {floating} (document indices)",),("window.arrange.consolidateAllWindows","Consolidate All Windows","",- "{} show one document at a time again, under its tab, after Tile; returns {tiled: false}",+ "{} show one document at a time again, under its tab, after Tile, Float in Window, Float All in Windows or Cascade; returns {tiled: false, floating: []}",),("window.nextDocument",diff --git a/crates/ui-egui/src/panel_docking.rs b/crates/ui-egui/src/panel_docking.rsindex 0375ed76f..9d8c71538 100644--- a/crates/ui-egui/src/panel_docking.rs+++ b/crates/ui-egui/src/panel_docking.rs@@ -1177,8 +1177,9 @@ pub(crate) fn modal_open(app: &VectorcraftApp, ctx: &egui::Context) -> bool {/// Keys, text and clipboard events that a floating panel's own OS window left over run the main/// window's shortcuts, tool keys and clipboard on its next frame ([`VectorcraftApp::raw_input_hook`])./// craft-ui forwards nothing while a field in that window has the keyboard. A field of the main-/// window loses it, as a click elsewhere in one window would take it.-fn forward_keys(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>, modifiers: Option<egui::Modifiers>) {+/// window loses it, as a click elsewhere in one window would take it. A floating document's OS+/// window forwards its keys here too ([`crate::doc_windows`]).+pub(crate) fn forward_keys(app: &mut VectorcraftApp, ctx: &egui::Context, events: Vec<egui::Event>, modifiers: Option<egui::Modifiers>) {if events.is_empty() {return;}diff --git a/crates/ui-egui/src/state.rs b/crates/ui-egui/src/state.rsindex ccced4813..4dd6d9012 100644--- a/crates/ui-egui/src/state.rs+++ b/crates/ui-egui/src/state.rs@@ -463,6 +463,15 @@ pub struct UiState {/// Consolidate All Windows. Not saved: the reference app does not save windows with a document.#[serde(skip)]pub tiled: bool,+ /// Window › Arrange › Float in Window, Float All in Windows and Cascade: the documents in+ /// floating windows of their own, out of the tab strip, until Consolidate All Windows. Not+ /// saved, as `tiled` is not.+ #[serde(skip)]+ pub floating: Vec<crate::doc_windows::DocWindow>,+ /// The document (its uid) the tab strip shows while the current document is in a floating+ /// window: the tabbed document that was current last.+ #[serde(skip)]+ pub tab_document: Option<u64>,/// Draw Normal / Behind / Inside.pub draw_mode: u8,pub about: bool,@@ -944,6 +953,8 @@ impl Default for UiState {palette_query: String::new(),screen_mode: 0,tiled: false,+ floating: Vec::new(),+ tab_document: None,draw_mode: 0,about: false,action_sets: crate::panels::actions::default_sets(),diff --git a/docs/gaps.md b/docs/gaps.mdindex d7276abea..292905bb7 100644--- a/docs/gaps.md+++ b/docs/gaps.md@@ -592,7 +592,8 @@ from G14 and the budget run of G15: **~170–270 h** one agent, ~50–80 h wall- **Done (#4135):** floating panels open in OS windows of their own on the desktop, so they can sit on another monitor; on the web and on Wayland they float inside the window.- **Done:** View › New View… and Edit Views… ([public source](https://helpx.adobe.com/illustrator/using/viewing-artwork.html)): a document keeps up to 25 named views (zoom, centre and rotation), saved with the file; every one is listed by name at the bottom of the View menu (`view.goto1`–`view.goto25`), and choosing one changes the current window to it. Edit Views… lists them to rename or delete, applied together on OK as one undo step (`view.saved.edit {edits}`); a file's views are checked when it opens. Estimate unchanged.- **Done:** Window › Arrange › Tile (`window.arrange.tile`) shows every open document in its own pane, edge to edge in the document area, and Consolidate All Windows (`window.arrange.consolidateAllWindows`) goes back to one document under its tab, on the desktop and the web. Estimate unchanged.-- **Missing:** multiple windows and the rest of Window › Arrange (Cascade, Float in Window, Float All in Windows).+- **Done:** Window › Arrange › Float in Window (`window.arrange.floatInWindow`), Float All in Windows (`window.arrange.floatAllInWindows`) and Cascade (`window.arrange.cascade`) move documents out of the tab strip into floating windows of their own, OS windows on the desktop and windows inside the app's window on the web and on Wayland; Cascade stacks them from the upper left to the lower right. Consolidate All Windows brings them back under the tabs. Estimate unchanged.+- **Missing:** several windows of one document (Window › New Window), dragging a tab out to float its document and back in to dock it.- **Estimate:** 15–25 h.## G6 Automation and scriptingdiff --git a/docs/mcp.md b/docs/mcp.mdindex f18766a0a..4db07abae 100644--- a/docs/mcp.md+++ b/docs/mcp.md@@ -3639,10 +3639,18 @@ the current one.`window.arrange.tile` (Window › Arrange › Tile) shows every open document in its own pane, edge to edge in the documentarea, in a grid of as many columns as the square root of the number of documents, rounded up, and fits each document toits pane; it returns `{tiled, panes}`. The current document's pane is the canvas, and a press in another pane makes its-document the current one. `window.arrange.consolidateAllWindows` (Window › Arrange › Consolidate All Windows) shows one-document under its tab again and returns `{tiled: false}`. The arrangement is not saved. `ui.inspect` reports `tiled`-and `panes` (each pane's `document` index, `rect` and whether it is `active`); canvas coordinates map to the current-document's pane (`canvasRect`).+document the current one. `window.arrange.floatInWindow` (Window › Arrange › Float in Window) moves the current document+out of the tab strip into a floating window of its own, `window.arrange.floatAllInWindows` (Float All in Windows) does+so for every tabbed document, and `window.arrange.cascade` (Cascade) floats every document and stacks the windows 30 pt+apart from the upper left of the document area; each returns `{floating}`, the floating documents' indices. On the+desktop each window is an OS window; on the web, on Wayland and while the control channel is attached (`--control`),+it is a window inside the app's window, so `ui.click`, `ui.drag` and `ui.screenshot` reach it. The current+document's window holds the canvas, and a press in another document's window makes its document the current one.+`window.arrange.consolidateAllWindows` (Window › Arrange › Consolidate All Windows) shows one document under its tab+again, floating ones included, and returns `{tiled: false, floating: []}`; Tile brings floating documents back into its+grid. The arrangement is not saved. `ui.inspect` reports `tiled`, `panes` (each pane's `document` index, `rect` and+whether it is `active`) and `floating`; canvas coordinates map to the current document's pane or window+(`canvasRect`), in that window's coordinates while it floats.```json{"name":"run_command","arguments":{"command":"file.new","params":{"preset":"A4","orientation":"landscape","artboards":4,"artboardLayout":{"columns":2},"bleed":9}}}diff --git a/docs/target-app-parity.md b/docs/target-app-parity.mdindex df438c409..3d5685c43 100644--- a/docs/target-app-parity.md+++ b/docs/target-app-parity.md@@ -527,6 +527,7 @@ Moved from the ROADMAP's "Shipped so far" on 2026-10-10. Update it when a featur- **Video display options (#2849):** Artboard Options' Show Video Safe Areas and Video Ruler Pixel Aspect Ratio, and View › Rulers › Show Video Rulers ([Set video display options for artboards](https://helpx.adobe.com/illustrator/desktop/create-manage-artboards/organize-manage-artboards/set-video-display-options-for-artboards.html)). Each artboard has its own (`artboard.setProps`/`artboard.new` `showVideoSafeAreas`, `videoRulerPixelAspectRatio` 0.1–10, default 1), set in one undo step and written to the native format only when on or not 1, so other documents save byte for byte as before. The help page names the safe areas without numbers; our choice is [EBU R 95](https://tech.ebu.ch/docs/r/r095.pdf)'s (note 5): the canvas outlines the action-safe area 3.5% and the title-safe (graphics-safe) area 5% in from each edge, 1 point wide and turned with the view; exports and print leave them out. Show Video Rulers (`view.videoRulers`) shows the rulers counting the active artboard in pixels from its top-left corner, whatever the ruler origin: a pixel is as many points wide as the ratio and one point tall, so a 720 × 480 pt artboard at 0.9 reads 800 × 480. Hide Video Rulers returns them to the General unit; Shift ruler-tick snapping of new guides keeps the General unit. Regression tests: `tests/panelcmds.rs` (`artboard_video_display_options_*`, `artboard_display_marks_stay_out_of_exports`), `tests/docsetup.rs` (`an_artboard_shows_its_video_safe_areas`), `canvas.rs` (`video_rulers_count_the_artboard_in_pixels_of_its_aspect_ratio`), `tests/ruler_origin.rs` (`show_video_rulers_counts_the_active_artboard_in_pixels`), `dialogs/tests.rs` (`artboard_options_show_video_display_options`).- **Saved views (G7):** View › New View… and Edit Views… ([public source](https://helpx.adobe.com/illustrator/using/viewing-artwork.html): up to 25 views per document, saved with it, renamed or deleted in Edit Views, chosen from the bottom of the View menu). Each view keeps the zoom, centre and rotation; the View menu lists all 25 (`view.goto1`–`view.goto25`), and Edit Views… lists them to rename or delete, applied together as one undo step. A file's views are checked when it opens (at most 25, unique names up to 255 characters, a finite centre and a positive zoom). Tests: `saved_views_round_trip_and_from_a_file_are_tidied` (`crates/format/tests/prop_format.rs`), `crates/engine/src/cmd/views.rs`, `crates/ui-egui/src/dialogs/edit_views.rs` and `every_saved_view_is_listed_at_the_bottom_of_the_view_menu` (`crates/ui-egui/src/menus.rs`).- **Window › Arrange › Tile (G7):** Tile (`window.arrange.tile`) shows every open document at once, edge to edge in the document area ([public source](https://helpx.adobe.com/illustrator/using/viewing-artwork.html): "Tile displays windows edge to edge"), one pane each in a grid of as many columns as the square root of the number of documents, rounded up, each fitted to its pane. The current document's pane is the canvas; the other panes draw their documents with their artboards, guides and selected objects, and a press in one makes its document the current one. Consolidate All Windows (`window.arrange.consolidateAllWindows`) shows one document under its tab again. The grid and when the two items are enabled (Tile with two documents or more, Consolidate All Windows while they are tiled) are VectorCraft's own. Tests: `crates/ui-egui/src/canvas/panes/tests.rs`.+- **Window › Arrange › Float in Window, Float All in Windows and Cascade (G7):** documents float in windows of their own, out of the tab strip ([public source](https://helpx.adobe.com/illustrator/using/customizing-workspace.html): "drag the window's tab out of the group"). Float in Window (`window.arrange.floatInWindow`) floats the current document, Float All in Windows (`window.arrange.floatAllInWindows`) every tabbed one, and Cascade (`window.arrange.cascade`) floats every document and stacks the windows from the upper left to the lower right ([public source](https://helpx.adobe.com/illustrator/using/viewing-artwork.html): "Cascade displays windows stacked and descending from the upper-left to the lower-right of the screen"). On the desktop each window is an OS window; on the web and on Wayland it is a window inside the app's window. The window of the current document holds the canvas; the others draw their documents as Tile's panes do, and a press in one makes its document the current one. Closing a window closes its document, asking to save unsaved changes. Consolidate All Windows brings every document back under the tabs, and Tile brings them back into its grid. The cascade's 30 pt step, the windows' size and when the items are enabled (Cascade with two documents or more, Float in Window for a tabbed current document, Float All in Windows while a document is tabbed, Consolidate All Windows while documents are tiled or floating) are VectorCraft's own. Tests: `crates/ui-egui/src/doc_windows/tests.rs`.- **Document Setup modal handoff:** Document Setup → Edit Artboards applies valid settings, closes the dialog and activates the Artboard tool. Pointer-click tests cover successful handoff, invalid settings, OK, Cancel and Undo in `dialogs/document_setup.rs`.- **Control bar with the Artboard tool:** while the Artboard tool is in use, the Control bar shows the active artboard's controls in place of the object controls: Preset, Portrait and Landscape, New Artboard, Delete Artboard, the Name field, Artboard Options, Rearrange All Artboards, the Transform link, Move and Scale Artwork with Artboard and, while the bar has room, the reference point with X and Y, and W and H with the Constrain Width and Height Proportions link. Each runs the command its Properties or Transform panel counterpart runs (`artboard.setProps`, `artboard.new`, `artboard.delete`, `tool.options {tool: "artboard"}`), and the reference point is the one the Transform panel uses. In an 800-point window the controls up to the Transform link fit, Move and Scale Artwork with Artboard show as their boxes alone with their names in tooltips, and the link opens the Transform panel with the artboard's position and size. Pointer and key tests in `panels/artboards.rs` cover the controls, W about the reference point, the orientation and the name. Public reference: [Using multiple artboards](https://web.archive.org/web/20210925094818/https://helpx.adobe.com/illustrator/using/using-multiple-artboards.html) (archived copy).