From ca9dd02201c81a8bf2c96686320c9ab7aea66c01 Mon Sep 17 00:00:00 2001 From: phanoob Date: Fri, 23 Oct 2026 14:23:04 +0000 Subject: [PATCH] Reorder design tabs by dragging them (#3187) (#3188) * claim: #3187 Co-Authored-By: Claude Opus 5.5 * Reorder design tabs by dragging them (#3187) A tab dragged along the strip follows the pointer while the others make room, and lands where it is released; Escape, or releasing down the window, leaves the order as it was. With the custom title bar a drag that starts mostly up or down (or on the only tab) still moves the window. The control channel's ui.documents gains a move action (from, to). Co-Authored-By: Claude Opus 5.5 --------- Co-authored-by: Phanoob Co-authored-by: Claude Opus 5.5 --- crates/ui-egui/src/documents.rs | 238 +++++++++++++++++++++++++++++--- 1 file changed, 221 insertions(+), 17 deletions(-) diff --git a/crates/ui-egui/src/documents.rs b/crates/ui-egui/src/documents.rs index 8d7ef4fbe..49fc5ec11 100644 --- a/crates/ui-egui/src/documents.rs +++ b/crates/ui-egui/src/documents.rs @@ -144,6 +144,32 @@ fn swap_in(app: &mut SolveApp, slot: DocSlot) -> DocSlot { out } +/// Move tab `from` to place `to`, the tabs between shifting over (#3187); each design keeps its +/// state and the active one stays active. Not while a "save changes?" prompt is open or tabs are +/// being closed one after another (their tab numbers would change under them). +pub fn move_tab(app: &mut SolveApp, from: usize, to: usize) { + let n = app.docs.slots.len(); + if from >= n || to >= n || from == to || app.docs.closing.is_some() || app.docs.quitting.is_some() || app.docs.batch.is_some() { + return; + } + let slot = app.docs.slots.remove(from); + app.docs.slots.insert(to, slot); + app.docs.active = moved_index(app.docs.active, from, to); +} + +/// Where the tab at `i` ends up when the tab at `from` moves to `to`. +pub fn moved_index(i: usize, from: usize, to: usize) -> usize { + if i == from { + to + } else if from < i && i <= to { + i - 1 + } else if to <= i && i < from { + i + 1 + } else { + i + } +} + /// Make tab `i` the active design. pub fn switch(app: &mut SolveApp, i: usize) { if app.file_picker_busy() { @@ -399,8 +425,8 @@ pub fn tabs_info(app: &SolveApp) -> Vec<(String, bool)> { } /// The control channel's `ui.documents`: list, `new`, `switch`, `close` (by index; `force` -/// closes without asking), `close_others` (all but `index`), `close_all` or `quit`; `answer`: -/// save | dont_save | cancel answers "save changes?". +/// closes without asking), `close_others` (all but `index`), `close_all`, `move` (`from`, `to`) +/// or `quit`; `answer`: save | dont_save | cancel answers "save changes?". pub fn control(app: &mut SolveApp, p: &Value) -> Value { let i = p.get("index").and_then(Value::as_u64).map(|x| x as usize); match p.get("action").and_then(Value::as_str) { @@ -412,6 +438,12 @@ pub fn control(app: &mut SolveApp, p: &Value) -> Value { close_many(app, (0..app.docs.count()).filter(|k| *k != keep).collect()); } Some("close_all") => close_many(app, (0..app.docs.count()).collect()), + Some("move") => { + let at = |k: &str| p.get(k).and_then(Value::as_u64).map(|x| x as usize); + if let (Some(from), Some(to)) = (at("from"), at("to")) { + move_tab(app, from, to); + } + } Some("quit") => request_quit(app), _ => {} } @@ -428,14 +460,21 @@ pub fn control(app: &mut SolveApp, p: &Value) -> Value { json!({"documents": tabs, "active": app.docs.active, "closing": app.docs.closing, "quitting": app.docs.quitting.is_some(), "batch": app.docs.batch}) } +/// A design tab being dragged along the strip to a new place: its index, and where the pointer +/// grabbed it (from the tab's left edge). +#[derive(Clone, Copy, Debug)] +struct TabDrag { + from: usize, + grab: f32, +} + /// The document tabs in the application bar, from `x0` to `x1`: click to switch, × to close, -/// + for a new design. +/// drag to reorder, + for a new design. pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { let t = Tokens::get(); let info = tabs_info(app); let n = info.len(); let (first, shown, w) = layout(n, app.docs.active, x1 - x0); - let mut x = x0; let mut pick: Option = None; let mut shut: Option = None; // Each tab fits its name (up to MAX_FIT) while all of them fit; otherwise they share the room. @@ -453,23 +492,74 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { // A right-click on a tab opens its menu (#3055): the tab and where the menu opens. let menu_id = egui::Id::new("sc_doc_tab_menu"); let mut menu: Option<(usize, egui::Pos2)> = ui.ctx().data(|d| d.get_temp(menu_id)); - for (i, (name, dirty)) in info.iter().enumerate().skip(first).take(shown) { - let w = if fit_all { natural.get(i).copied().unwrap_or(w) } else { w }; - let tr = Rect::from_min_size(pos2(x, r.top() + 4.0), vec2(w - 2.0, r.height() - 8.0)); + // The shown tabs' widths, in strip order. + let widths: Vec = (first..first + shown).map(|i| if fit_all { natural.get(i).copied().unwrap_or(w) } else { w }).collect(); + let width = |i: usize| i.checked_sub(first).and_then(|k| widths.get(k)).copied().unwrap_or(w); + let strip_end = x0 + widths.iter().sum::(); + let title_bar = app.custom_titlebar || app.integrated_titlebar; + // A tab being dragged to a new place follows the pointer and the others make room for it; + // Escape puts it back. + let drag_id = egui::Id::new("sc_doc_tab_drag"); + let (held_down, released, escape) = ui.input(|i| (i.pointer.primary_down(), i.pointer.primary_released(), i.key_pressed(egui::Key::Escape))); + let mut drag = + ui.ctx().data(|d| d.get_temp::(drag_id)).filter(|d| (held_down || released) && !escape && (first..first + shown).contains(&d.from)); + let pointer = ui.ctx().pointer_latest_pos(); + let held = drag.zip(pointer).map(|(d, p)| (d.from, (p.x - d.grab).clamp(x0, (strip_end - width(d.from)).max(x0)))); + let to = held.map(|(from, left)| (from, drop_slot(left, x0, &widths, first, from))); + // Where each shown tab sits: in strip order, or with the dragged tab moved to its slot. + let mut slots: Vec = (first..first + shown).filter(|&i| to.is_none_or(|(from, _)| from != i)).collect(); + if let Some((from, to)) = to { + slots.insert(to.saturating_sub(first).min(slots.len()), from); + } + let mut lefts = vec![x0; shown]; + let mut at = x0; + for &i in &slots { + if let Some(l) = i.checked_sub(first).and_then(|k| lefts.get_mut(k)) { + *l = at; + } + at += width(i); + } + // The dragged tab is drawn last, over the others. + let mut order: Vec = (first..first + shown).filter(|&i| held.is_none_or(|(from, _)| from != i)).collect(); + order.extend(held.map(|(from, _)| from)); + let mut dropped: Option<(usize, usize)> = None; + for i in order { + let Some((name, dirty)) = info.get(i) else { continue }; + let w = width(i); + let left = match held { + Some((from, left)) if from == i => left, + _ => i.checked_sub(first).and_then(|k| lefts.get(k)).copied().unwrap_or(x0), + }; + let tr = Rect::from_min_size(pos2(left, r.top() + 4.0), vec2(w - 2.0, r.height() - 8.0)); let active = !app.home.open && (i == app.docs.active || app.docs.slots.is_empty()); let resp = ui.interact(tr, ui.id().with(("doc_tab", i)), Sense::click_and_drag()); crate::scenario::publish_target(&format!("tab:design:{i}"), tr); - // The tabs are part of the title bar: dragging one moves the window, a double click + // Dragging a tab along the strip moves it. The tabs are also part of the title bar: + // dragging the only tab, or one mostly up or down, moves the window, and a double click // maximizes it. - if app.custom_titlebar || app.integrated_titlebar { - if resp.drag_started_by(egui::PointerButton::Primary) { + if resp.drag_started_by(egui::PointerButton::Primary) { + let origin = ui.input(|i| i.pointer.press_origin()).unwrap_or(tr.center()); + let moved = pointer.unwrap_or(origin) - origin; + if n > 1 && (!title_bar || moved.x.abs() >= moved.y.abs()) { + drag = Some(TabDrag { from: i, grab: origin.x - tr.left() }); + } else if title_bar { ui.ctx().send_viewport_cmd(egui::ViewportCommand::StartDrag); - } else if resp.double_clicked() { - crate::titlebar::toggle_maximize(ui.ctx()); } + } else if title_bar && resp.double_clicked() { + crate::titlebar::toggle_maximize(ui.ctx()); } - tab_shape(ui.painter(), &t, tr, active, resp.hovered() || resp.has_focus()); - let ink = if active || resp.hovered() { t.app_bar_text } else { t.app_bar_text.gamma_multiply(0.7) }; + if resp.drag_stopped() && drag.is_some_and(|d| d.from == i) { + // Released over the bar (not dropped somewhere down the window): the tab lands there. + if let Some((from, to)) = to + && pointer.is_some_and(|p| p.y < r.bottom() + r.height()) + { + dropped = Some((from, to)); + } + drag = None; + } + let lit = resp.hovered() || held.is_some_and(|(from, _)| from == i); + tab_shape(ui.painter(), &t, tr, active, lit || resp.has_focus()); + let ink = if active || lit { t.app_bar_text } else { t.app_bar_text.gamma_multiply(0.7) }; let name_display = crate::i18n::Locale::for_language(&app.preferences.language).given_name(name); let label = format!("{name_display}{}", if *dirty { " •" } else { "" }); let font = if active { @@ -502,11 +592,17 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { } if xresp.on_hover_text("Close").clicked() { shut = Some(i); - } else if resp.on_hover_text(name.as_str()).clicked() { + } else if (if held.is_some() { resp } else { resp.on_hover_text(name.as_str()) }).clicked() { pick = Some(i); } - x += w; } + ui.ctx().data_mut(|d| match drag { + Some(v) => { + d.insert_temp(drag_id, v); + } + None => d.remove::(drag_id), + }); + let mut x = strip_end; // More tabs than fit: a chevron lists them all. if shown < n { let mr = Rect::from_center_size(pos2(x + 12.0, r.center().y), vec2(20.0, 22.0)); @@ -610,10 +706,29 @@ pub fn tabs(app: &mut SolveApp, ui: &mut egui::Ui, r: Rect, x0: f32, x1: f32) { _ if many.is_some() => close_many(app, many.unwrap_or_default()), (Some(i), _) => close(app, i, false), (None, Some(i)) => switch(app, i), - (None, None) => {} + (None, None) => { + if let Some((from, to)) = dropped { + move_tab(app, from, to); + } + } } } +/// The place among the shown tabs (`first..`, `widths` wide in strip order from `x0`) for +/// tab `from` whose left edge is dragged to `left`: the slot whose place for it is nearest. +pub fn drop_slot(left: f32, x0: f32, widths: &[f32], first: usize, from: usize) -> usize { + let mut best = (0, f32::INFINITY); + let mut at = x0; + let others = widths.iter().enumerate().filter(|(k, _)| first + k != from).map(|(_, w)| *w); + for (k, w) in others.map(Some).chain([None]).enumerate() { + if (left - at).abs() < best.1 { + best = (k, (left - at).abs()); + } + at += w.unwrap_or(0.0); + } + first + best.0 +} + /// Tabs are rounded chips on the bar; the active design has the stronger fill. fn tab_shape(painter: &egui::Painter, t: &Tokens, r: Rect, active: bool, hovered: bool) { let fill = if active { @@ -884,6 +999,95 @@ mod tests { assert_eq!(h.app.docs.count(), 1); } + /// #3187: a tab moved to another place keeps its design, and the active design stays + /// active wherever it ends up. + #[test] + fn a_moved_tab_keeps_its_design_and_the_active_one_stays_active() { + let mut a = app(); + a.run("solid.box", json!({"length": 10, "width": 10, "height": 10})).unwrap(); + for k in 1..3 { + open_tab(&mut a, Session::default()).unwrap(); + for _ in 0..=k { + a.run("solid.sphere", json!({"diameter": 4})).unwrap(); + } + } + // Tabs hold 1, 2 and 3 features; the third is active. + let features = |a: &mut SolveApp| { + let back = a.docs.active; + let v: Vec = (0..a.docs.count()) + .map(|i| { + switch(a, i); + a.session.doc.features.len() + }) + .collect(); + switch(a, back); + v + }; + assert_eq!(features(&mut a), [1, 2, 3]); + assert_eq!(a.docs.active, 2); + move_tab(&mut a, 0, 2); + assert_eq!(features(&mut a), [2, 3, 1]); + assert_eq!(a.docs.active, 1, "the active design moved over with the others"); + assert_eq!(a.session.doc.features.len(), 3); + move_tab(&mut a, 1, 0); + assert_eq!(features(&mut a), [3, 2, 1]); + assert_eq!(a.docs.active, 0); + move_tab(&mut a, 0, 9); + assert_eq!(features(&mut a), [3, 2, 1], "out of range: nothing moves"); + assert_eq!(moved_index(5, 5, 1), 1); + assert_eq!(drop_slot(0.0, 100.0, &[90.0; 4], 2, 2), 2); + assert_eq!(drop_slot(240.0, 100.0, &[90.0; 4], 2, 2), 4); + assert_eq!(drop_slot(9000.0, 100.0, &[90.0; 4], 2, 2), 5); + // Tabs fit their names: the slots follow the other tabs' own widths. + assert_eq!(drop_slot(90.0, 0.0, &[80.0, 200.0, 80.0], 0, 0), 0); + assert_eq!(drop_slot(150.0, 0.0, &[80.0, 200.0, 80.0], 0, 0), 1); + assert_eq!(drop_slot(260.0, 0.0, &[80.0, 200.0, 80.0], 0, 0), 2); + } + + /// #3187: dragging a tab along the strip drops it where it is released; a drag mostly down + /// the window (it moves the window) or one Escape cancelled leaves the order as it was. + #[test] + fn dragging_a_tab_along_the_strip_moves_it() { + let mut h = crate::scenario::Harness::new(); + h.app.home.open = false; + h.app.custom_titlebar = true; + h.call("ui.resize", json!({"width": 1400, "height": 720})); + h.app.run("solid.box", json!({"length": 10, "width": 10, "height": 10})).unwrap(); + open_tab(&mut h.app, Session::default()).unwrap(); + open_tab(&mut h.app, Session::default()).unwrap(); + switch(&mut h.app, 0); + h.frames(3); + let at = |h: &mut crate::scenario::Harness, i: usize| { + let [x, y] = h.at(&json!({"handle": format!("tab:design:{i}")})).unwrap(); + egui::pos2(x as f32, y as f32) + }; + let button = + |pos, pressed| egui::Event::PointerButton { pos, button: egui::PointerButton::Primary, pressed, modifiers: egui::Modifiers::NONE }; + let path = |a: egui::Pos2, b: egui::Pos2| (1..=8).map(move |k| egui::Event::PointerMoved(a + (b - a) * (k as f32 / 8.0))); + let (t0, t2) = (at(&mut h, 0), at(&mut h, 2)); + // Down first: that moves the window, and coming back along the bar moves no tab. + let down = t0 + vec2(0.0, 20.0); + h.app.synthetic.extend([egui::Event::PointerMoved(t0), button(t0, true)]); + h.app.synthetic.extend(path(t0, down).chain(path(down, t2))); + h.app.synthetic.push(button(t2, false)); + h.frames(24); + assert_eq!(h.app.docs.active, 0, "a drag down the window leaves the tabs"); + assert_eq!(h.app.session.doc.features.len(), 1); + h.app.synthetic.extend([egui::Event::PointerMoved(t0), button(t0, true)]); + h.app.synthetic.extend(path(t0, t2)); + h.app.synthetic.push(button(t2, false)); + h.frames(16); + assert_eq!(h.app.docs.active, 2, "the dragged tab is now last"); + assert_eq!(h.app.session.doc.features.len(), 1, "and still shows its design"); + let (t2, t1) = (at(&mut h, 2), at(&mut h, 1)); + let escape = egui::Event::Key { key: egui::Key::Escape, physical_key: None, pressed: true, repeat: false, modifiers: egui::Modifiers::NONE }; + h.app.synthetic.extend([egui::Event::PointerMoved(t2), button(t2, true)]); + h.app.synthetic.extend(path(t2, t1)); + h.app.synthetic.extend([escape, egui::Event::PointerMoved(t1), button(t1, false)]); + h.frames(16); + assert_eq!(h.app.docs.active, 2, "Escape put it back"); + } + #[test] fn tabs_keep_their_own_design() { let mut a = app();