Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Render workspace: move the Inspector or Browser dock to either side with view.render_dock and a header menu (#7230)

Nathan Dane1781b4d323b9
diff --git a/assets/locales/pending/render-dock.json b/assets/locales/pending/render-dock.json
new file mode 100644
index 0000000000..78c79725fc
--- /dev/null
+++ b/assets/locales/pending/render-dock.json
@@ -0,0 +1,42 @@
+{
+ "en": {
+ "cmd.view.render_dock": "Move Render Dock",
+ "label.move_to_left_side": "Move to left side",
+ "label.move_to_right_side": "Move to right side"
+ },
+ "de": {
+ "cmd.view.render_dock": "Render-Panel verschieben",
+ "label.move_to_left_side": "Auf die linke Seite verschieben",
+ "label.move_to_right_side": "Auf die rechte Seite verschieben"
+ },
+ "ja": {
+ "cmd.view.render_dock": "レンダードックを移動",
+ "label.move_to_left_side": "左側へ移動",
+ "label.move_to_right_side": "右側へ移動"
+ },
+ "zh": {
+ "cmd.view.render_dock": "移动渲染停靠面板",
+ "label.move_to_left_side": "移到左侧",
+ "label.move_to_right_side": "移到右侧"
+ },
+ "ko": {
+ "cmd.view.render_dock": "렌더 도크 이동",
+ "label.move_to_left_side": "왼쪽으로 이동",
+ "label.move_to_right_side": "오른쪽으로 이동"
+ },
+ "ar": {
+ "cmd.view.render_dock": "نقل لوحة التصيير",
+ "label.move_to_left_side": "نقل إلى الجانب الأيسر",
+ "label.move_to_right_side": "نقل إلى الجانب الأيمن"
+ },
+ "he": {
+ "cmd.view.render_dock": "הזז את עגינת הרינדור",
+ "label.move_to_left_side": "העבר לצד שמאל",
+ "label.move_to_right_side": "העבר לצד ימין"
+ },
+ "vi": {
+ "cmd.view.render_dock": "Di chuyển neo kết xuất",
+ "label.move_to_left_side": "Chuyển sang bên trái",
+ "label.move_to_right_side": "Chuyển sang bên phải"
+ }
+}
diff --git a/crates/engine/src/cmd/view_navigation.rs b/crates/engine/src/cmd/view_navigation.rs
index 9fd280a2ef..b2bf1fc9ff 100644
--- a/crates/engine/src/cmd/view_navigation.rs
+++ b/crates/engine/src/cmd/view_navigation.rs
@@ -29,6 +29,11 @@ CommandSpec::new("view.render_stage", "Render Stage", render_stage)
CommandSpec::new("view.shots_strip", "Shots Strip", shots_strip)
.at("RENDER CAMERA", "SHOTS").icon("camera").noundo().doc_only()
.params("visible: bool → {visible}; Render Shots strip UI preference. Headless echo only, no document edits or undo"),
+CommandSpec::new("view.render_dock", "Move Render Dock", crate::checked!("view.render_dock", render_dock))
+ .at("RENDER", "SCENE").icon("settings").noundo().doc_only()
+ .contract(&RENDER_DOCK_CONTRACT)
+ .output(crate::schema::output_schema_for::<crate::schema::view_navigation::RenderDock>)
+ .params("panel: inspector|browser; side: left|right → {panel, side}; Render dock UI preference; headless echo only, no document edits or undo"),
CommandSpec::new("view.layout", "Workspace layout", layout)
.icon("settings").noundo().doc_only().params("mode: floating|compact → validated workspace layout; display only, never opens a dialog"),
CommandSpec::new("view.history_layout", "History layout", history_layout)
@@ -223,6 +228,14 @@ fn render_stage(_s: &mut Session, p: &Value) -> Result<Value> {
Ok(json!({"stage":request.stage}))
}
+const RENDER_DOCK_CONTRACT: crate::schema::TypedContract<crate::schema::view_navigation::RenderDock> = crate::schema::TypedContract::new();
+
+fn render_dock(_s: &mut Session, p: &Value) -> Result<Value> {
+ let request: crate::schema::view_navigation::RenderDock =
+ serde_json::from_value(p.clone()).map_err(|e| bad("view.render_dock", e.to_string()))?;
+ serde_json::to_value(request).map_err(|e| bad("view.render_dock", e.to_string()))
+}
+
fn shots_strip(_s: &mut Session, p: &Value) -> Result<Value> {
#[derive(serde::Deserialize)]
#[serde(deny_unknown_fields)]
@@ -919,3 +932,36 @@ fn render_workspace_stage_validates_without_document_changes_or_evaluation() {
assert!(std::sync::Arc::ptr_eq(&document, &session.doc));
assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty()));
}
+
+#[cfg(test)]
+#[test]
+fn render_workspace_dock_validates_without_mutation() {
+ let mut session = Session::default();
+ session.execute("solid.box", &json!({"length":10,"width":10,"height":10})).unwrap();
+ session.execute("edit.undo", &json!({})).unwrap();
+ let document = session.doc.clone();
+ let before = (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty(), session.camera);
+ for panel in ["inspector", "browser"] {
+ for side in ["left", "right"] {
+ let params = json!({"panel":panel,"side":side});
+ assert_eq!(session.execute("view.render_dock", &params).unwrap(), params);
+ }
+ }
+ for params in [
+ Value::Null,
+ json!([]),
+ json!({}),
+ json!({"panel":"inspector"}),
+ json!({"side":"left"}),
+ json!({"panel":true,"side":"left"}),
+ json!({"panel":"inspector","side":null}),
+ json!({"panel":"inspector","side":1e300}),
+ json!({"panel":"other","side":"left"}),
+ json!({"panel":"inspector","side":"top"}),
+ json!({"panel":"browser","side":"left","unknown":true}),
+ ] {
+ assert!(session.execute("view.render_dock", &params).is_err(), "{params}");
+ }
+ assert!(std::sync::Arc::ptr_eq(&document, &session.doc));
+ assert_eq!(before, (session.undo.len(), session.redo.len(), session.revision, session.evaluations, session.is_dirty(), session.camera));
+}
diff --git a/crates/engine/src/schema/mod.rs b/crates/engine/src/schema/mod.rs
index 0e95a16485..809035c312 100644
--- a/crates/engine/src/schema/mod.rs
+++ b/crates/engine/src/schema/mod.rs
@@ -58,6 +58,7 @@ pub mod edit;
pub mod features;
pub mod inspect;
pub mod sketch_constraints;
+pub mod view_navigation;
pub use check::{Contract, Issue, ParamCheck, TypedContract, input_schema_for, output_schema_for, run_checked, run_checked_as};
pub use types::*;
diff --git a/crates/engine/src/schema/view_navigation.rs b/crates/engine/src/schema/view_navigation.rs
new file mode 100644
index 0000000000..43cf064228
--- /dev/null
+++ b/crates/engine/src/schema/view_navigation.rs
@@ -0,0 +1,24 @@
+//! UI-only Render dock request and echo contract.
+use schemars::JsonSchema;
+use serde::{Deserialize, Serialize};
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(deny_unknown_fields)]
+pub struct RenderDock {
+ pub panel: RenderPanel,
+ pub side: DockSide,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum RenderPanel {
+ Inspector,
+ Browser,
+}
+
+#[derive(Debug, Deserialize, Serialize, JsonSchema)]
+#[serde(rename_all = "lowercase")]
+pub enum DockSide {
+ Left,
+ Right,
+}
diff --git a/crates/engine/src/tests/mesh_convert.rs b/crates/engine/src/tests/mesh_convert.rs
index 33a4bb8414..959d9ef812 100644
--- a/crates/engine/src/tests/mesh_convert.rs
+++ b/crates/engine/src/tests/mesh_convert.rs
@@ -231,6 +231,7 @@ fn send_to_slicer_needs_a_slicer_and_bodies() {
}
/// The chosen-programs list is process-wide: tests that set it take turns.
+#[cfg(unix)]
static CHOSEN_PROGRAMS: std::sync::Mutex<()> = std::sync::Mutex::new(());
/// `file.save_mesh` with a `slicer` writes where the caller said and hands that file over, by the
@@ -437,7 +438,10 @@ fn send_to_slicer_writes_3mf_and_starts_the_program_with_it() {
let _ = std::fs::remove_dir_all(&dir);
std::fs::create_dir_all(&dir).unwrap();
let (script, seen) = (dir.join("fake-slicer"), dir.join("seen"));
- std::fs::write(&script, format!("#!/bin/sh\necho \"$@\" > {}\n", seen.display())).unwrap();
+ // Publish the acknowledgement only after writing it: cleanup must wait for every launch.
+ let writing = dir.join("writing");
+ std::fs::write(&script, format!("#!/bin/sh\nprintf '%s\\n' \"$@\" > '{}'\nmv '{}' '{}'\n", writing.display(), writing.display(), seen.display()))
+ .unwrap();
std::fs::set_permissions(&script, std::fs::Permissions::from_mode(0o755)).unwrap();
run(&mut s, "select.set", json!({"items":[{"type":"body","name":"Mesh"}]}));
// A program nobody chose is refused; once it is among the user's chosen ones it starts.
@@ -452,19 +456,26 @@ fn send_to_slicer_writes_3mf_and_starts_the_program_with_it() {
assert_eq!(r["format"], "3mf");
let file = r["path"].as_str().unwrap().to_string();
assert!(std::fs::read(&file).unwrap().starts_with(b"PK"));
- for _ in 0..100 {
- if seen.exists() && std::fs::metadata(&seen).unwrap().len() > 0 {
- break;
+ let await_launch = |expected: &str| {
+ for _ in 0..100 {
+ if seen.exists() {
+ assert_eq!(std::fs::read_to_string(&seen).unwrap().trim(), expected);
+ std::fs::remove_file(&seen).unwrap();
+ return;
+ }
+ std::thread::sleep(std::time::Duration::from_millis(50));
}
- std::thread::sleep(std::time::Duration::from_millis(50));
- }
- assert_eq!(std::fs::read_to_string(&seen).unwrap().trim(), file);
+ panic!("fake slicer did not acknowledge {expected}");
+ };
+ await_launch(&file);
// Sending the same bodies again replaces the file; the same name in the same private folder.
let again = s.execute("file.send_to_slicer", &json!({"slicer": script})).unwrap();
assert_eq!((again["path"].as_str(), again["numbered"].as_bool()), (Some(file.as_str()), Some(false)));
+ await_launch(&file);
let stl = s.execute("file.send_to_slicer", &json!({"slicer": script, "format": "stl"})).unwrap();
assert!(stl["path"].as_str().unwrap().ends_with(".stl"));
assert_ne!(stl["path"], r["path"]);
+ await_launch(stl["path"].as_str().unwrap());
crate::slicers::set_chosen_programs(&[]);
std::fs::remove_dir_all(std::path::Path::new(&file).parent().unwrap()).unwrap();
std::fs::remove_dir_all(dir).unwrap();
diff --git a/crates/ui-egui/src/browser.rs b/crates/ui-egui/src/browser.rs
index b95d5db42c..d3a0346bf8 100644
--- a/crates/ui-egui/src/browser.rs
+++ b/crates/ui-egui/src/browser.rs
@@ -1080,10 +1080,11 @@ fn render_card(app: &mut SolveApp, ui: &mut egui::Ui, acts: &mut Actions) {
},
);
app.preferences.render_browser_width = width;
- if app.preferences.render_browser_side != side {
- app.preferences.render_inspector_side = if side == "left" { "right" } else { "left" }.into();
+ let requested =
+ content.as_ref().and_then(|c| c.inner.1).map(str::to_string).or_else(|| (app.preferences.render_browser_side != side).then(|| side.clone()));
+ if let Some(side) = requested {
+ let _ = app.run("view.render_dock", serde_json::json!({"panel":"browser","side":side}));
}
- app.preferences.render_browser_side = side.clone();
let rect = content.map(|c| c.response.rect);
app.shell.browser = rect;
crate::shell::register_panel(
diff --git a/crates/ui-egui/src/lib.rs b/crates/ui-egui/src/lib.rs
index f27e39c56f..c1d09e20e3 100644
--- a/crates/ui-egui/src/lib.rs
+++ b/crates/ui-egui/src/lib.rs
@@ -1050,6 +1050,18 @@ impl SolveApp {
self.ui.pick_components = mode == Some("component");
self.ui.pick_off.retain(|kind| kind != "faces");
}
+ if id == "view.render_dock"
+ && let (Some(panel), Some(side)) = (v.get("panel").and_then(Value::as_str), v.get("side").and_then(Value::as_str))
+ {
+ let other = if side == "left" { "right" } else { "left" };
+ if panel == "inspector" {
+ self.preferences.render_inspector_side = side.into();
+ self.preferences.render_browser_side = other.into();
+ } else {
+ self.preferences.render_browser_side = side.into();
+ self.preferences.render_inspector_side = other.into();
+ }
+ }
if id == "view.shots_strip"
&& let Some(visible) = v.get("visible").and_then(Value::as_bool)
{
diff --git a/crates/ui-egui/src/render_workspace_inspector.rs b/crates/ui-egui/src/render_workspace_inspector.rs
index 9b96896f1c..d10bd2d21d 100644
--- a/crates/ui-egui/src/render_workspace_inspector.rs
+++ b/crates/ui-egui/src/render_workspace_inspector.rs
@@ -276,10 +276,14 @@ pub(super) fn panel(app: &mut SolveApp, ui: &mut egui::Ui) {
},
);
app.preferences.render_inspector_width = width;
- if app.preferences.render_inspector_side != side {
- app.preferences.render_browser_side = if side == "left" { "right" } else { "left" }.into();
+ let requested = content
+ .as_ref()
+ .and_then(|c| c.inner.1)
+ .map(str::to_string)
+ .or_else(|| (app.preferences.render_inspector_side != side).then(|| side.clone()));
+ if let Some(side) = requested {
+ let _ = app.run("view.render_dock", serde_json::json!({"panel":"inspector","side":side}));
}
- app.preferences.render_inspector_side = side.clone();
let rect = content.map(|c| c.response.rect);
crate::shell::register_panel(app, "render:inspector", rect, Some(if side == "left" { ui_kit::Edge::Left } else { ui_kit::Edge::Right }));
if let Some(rect) = rect {
diff --git a/crates/ui-egui/src/render_workspace_tests.rs b/crates/ui-egui/src/render_workspace_tests.rs
index 31cae0a5b8..6c4e83e5e7 100644
--- a/crates/ui-egui/src/render_workspace_tests.rs
+++ b/crates/ui-egui/src/render_workspace_tests.rs
@@ -3452,3 +3452,79 @@ fn navigation_bar_render_canvases_filter_slots_and_keep_product_fit() {
assert!(crate::scenario::handle_at(&format!("nav:slot:{slot}")).is_some(), "{slot}");
}
}
+
+#[test]
+fn render_workspace_dock_command_swaps_sides_without_design_edits() {
+ for layout in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] {
+ let mut h = Harness::new();
+ h.app.ui.layout = layout;
+ h.call("ui.resize", json!({"width":1600,"height":1000}));
+ enter(&mut h.app, true).unwrap();
+ h.frames(4);
+ let document = h.app.session.doc.clone();
+ let history = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision);
+ let camera = h.app.cam;
+ let product_camera = h.app.render_workspace.view.draft.camera;
+ let widths = (h.app.preferences.render_browser_width, h.app.preferences.render_inspector_width);
+ assert!(crate::shortcut_box::search(&h.app, "view.render_dock").iter().any(|row| row.0 == "view.render_dock"));
+ for (panel, side, inspector, browser) in [
+ ("inspector", "left", "left", "right"),
+ ("browser", "left", "right", "left"),
+ ("inspector", "right", "right", "left"),
+ ("browser", "right", "left", "right"),
+ ] {
+ h.app.run("view.render_dock", json!({"panel":panel,"side":side})).unwrap();
+ h.frames(3);
+ assert_eq!(h.app.preferences.render_inspector_side, inspector);
+ assert_eq!(h.app.preferences.render_browser_side, browser);
+ let a = h.app.shell.workspace_panels["render:inspector"].0;
+ let b = h.app.shell.workspace_panels["render:browser"].0;
+ assert_eq!(a.center().x < b.center().x, inspector == "left");
+ let view = h.app.viewport.layout.as_ref().unwrap();
+ assert!(view.content.contains_rect(view.axis_view));
+ let edge = if inspector == "left" { view.axis_view.left() - view.content.left() } else { view.content.right() - view.axis_view.right() };
+ assert!(edge.abs() < 0.1);
+ assert!(!view.navigation.intersects(a));
+ assert!(!view.navigation.intersects(b));
+ assert_eq!(h.app.cam, camera);
+ assert_eq!(h.app.render_workspace.view.draft.camera, product_camera);
+ assert_eq!(h.app.session.doc, document);
+ assert_eq!((h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision), history);
+ assert_eq!((h.app.preferences.render_browser_width, h.app.preferences.render_inspector_width), widths);
+ }
+ }
+}
+
+#[test]
+fn render_workspace_dock_grip_menus_dispatch_the_other_side() {
+ for layout in [crate::shell::LayoutMode::Floating, crate::shell::LayoutMode::Docked] {
+ let mut h = Harness::new();
+ h.app.ui.layout = layout;
+ h.call("ui.resize", json!({"width":1600,"height":1000}));
+ enter(&mut h.app, true).unwrap();
+ h.frames(4);
+ let document = h.app.session.doc.clone();
+ let history = (h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision);
+ let camera = h.app.cam;
+ for panel in ["inspector", "inspector", "browser", "browser"] {
+ let before = h.app.preferences.render_inspector_side.clone();
+ let at = crate::scenario::handle_at(&format!("render:{panel}:grip")).unwrap();
+ for pressed in [true, false] {
+ h.frame_with(vec![
+ egui::Event::PointerMoved(at),
+ egui::Event::PointerButton { pos: at, button: egui::PointerButton::Secondary, pressed, modifiers: egui::Modifiers::NONE },
+ ]);
+ }
+ h.frames(2);
+ // Opening the menu must not move either panel.
+ assert_eq!(h.app.preferences.render_inspector_side, before);
+ h.step(&json!({"click":{"handle":format!("render:{panel}:move_side")}})).unwrap();
+ h.frames(3);
+ assert_ne!(h.app.preferences.render_inspector_side, before);
+ assert_ne!(h.app.preferences.render_inspector_side, h.app.preferences.render_browser_side);
+ assert_eq!(h.app.cam, camera);
+ assert_eq!(h.app.session.doc, document);
+ assert_eq!((h.app.session.undo.len(), h.app.session.redo.len(), h.app.session.revision), history);
+ }
+ }
+}
diff --git a/crates/ui-egui/src/ui_kit/panel.rs b/crates/ui-egui/src/ui_kit/panel.rs
index fbc4719127..62b7f10da1 100644
--- a/crates/ui-egui/src/ui_kit/panel.rs
+++ b/crates/ui-egui/src/ui_kit/panel.rs
@@ -284,14 +284,15 @@ impl<'a> Panel<'a> {
}
/// Bounded floating workspace card. The shared grip chooses a side; the inner resize
- /// rail changes its remembered width. Neither gesture changes the document.
+ /// rail changes its remembered width. The inner result pairs the body with a context-menu
+ /// side request, which the caller dispatches through its command. Neither gesture edits the document.
pub(crate) fn workspace<R>(
ui: &mut Ui,
options: WorkspaceOptions<'_>,
side: &mut String,
width: &mut f32,
add: impl FnOnce(&mut Ui) -> R,
- ) -> Option<egui::InnerResponse<R>> {
+ ) -> Option<egui::InnerResponse<(R, Option<&'static str>)>> {
let container = super::Container::floating_card(super::Surface::Panel);
// The ribbon has already reserved the top gap, as for the Design Browser.
let gap = Tokens::get().space_8;
@@ -312,6 +313,7 @@ impl<'a> Panel<'a> {
vec2(*width, bounds.height()),
);
let ctx = ui.ctx().clone();
+ let mut move_side = None;
let response = container.area(egui::Id::new(options.id)).fixed_pos(rect.min).movable(false).order(egui::Order::Middle).show(&ctx, |ui| {
let frame = container.frame(&ctx, t.panel, if left { crate::frame::Side::Left } else { crate::frame::Side::Right }).inner_margin(0.0);
let content = container.show_frame(ui, frame, bounds, |ui| {
@@ -331,8 +333,17 @@ impl<'a> Panel<'a> {
// persistent; their navigation lives in the separately padded body.
ui.spacing_mut().item_spacing.y = 0.0;
let band = egui::Rect::from_min_size(ui.cursor().min, vec2(ui.available_width(), header_height()));
- let grip = ui.interact(band, ui.id().with("workspace_grip"), egui::Sense::drag()).on_hover_cursor(egui::CursorIcon::Grab);
+ let grip = ui.interact(band, ui.id().with("workspace_grip"), egui::Sense::click_and_drag()).on_hover_cursor(egui::CursorIcon::Grab);
scenario::publish_target(&format!("{}:grip", options.id), grip.rect);
+ super::Menu::context(&grip, |ui| {
+ let (target, label) = if left { ("right", "Move to right side") } else { ("left", "Move to left side") };
+ let item = super::MenuItem::new("view.render_dock", label, "").show(ui);
+ scenario::publish_target(&format!("{}:move_side", options.id), item.rect);
+ if item.clicked() {
+ move_side = Some(target);
+ ui.close();
+ }
+ });
header_impl(ui, (options.icon, None), options.title, None, false, || {});
scenario::publish_rect(&format!("{}:header", options.id), band);
if grip.dragged() {
@@ -367,7 +378,7 @@ impl<'a> Panel<'a> {
*width = (*width + delta).clamp(minimum, maximum);
}
}
- content.inner
+ (content.inner, move_side)
});
Some(response)
}
diff --git a/crates/ui-egui/src/viewport.rs b/crates/ui-egui/src/viewport.rs
index cd3327d569..d0a5cfe9a9 100644
--- a/crates/ui-egui/src/viewport.rs
+++ b/crates/ui-egui/src/viewport.rs
@@ -5428,7 +5428,11 @@ pub(crate) fn refresh_layout(app: &mut SolveApp, ctx: &egui::Context) {
let style = app.preferences.navigator_style;
app.viewport.layout = Some(if crate::render_workspace::active(app) {
let navigation = if app.ui.show_navigation_bar { crate::navigation_bar_view::measured(app, ctx, content).rect } else { Rect::NOTHING };
- crate::viewport_layout::Layout::product(rect, content, &docks, ctx.pixels_per_point(), style, corner, navigation)
+ if app.preferences.render_inspector_side == "left" {
+ crate::viewport_layout::Layout::product_left(rect, content, &docks, ctx.pixels_per_point(), style, corner, navigation)
+ } else {
+ crate::viewport_layout::Layout::product(rect, content, &docks, ctx.pixels_per_point(), style, corner, navigation)
+ }
} else {
let content = if app.ui.layout == crate::shell::LayoutMode::Docked { rect } else { content };
let navigation = if app.ui.show_navigation_bar { crate::navigation_bar_view::measured(app, ctx, content).rect } else { Rect::NOTHING };
diff --git a/crates/ui-egui/src/viewport_layout.rs b/crates/ui-egui/src/viewport_layout.rs
index b2bf9d143f..7dcc0eb72d 100644
--- a/crates/ui-egui/src/viewport_layout.rs
+++ b/crates/ui-egui/src/viewport_layout.rs
@@ -62,7 +62,7 @@ impl Layout {
corner: egui::Vec2,
navigation: Rect,
) -> Self {
- Self::build(viewport, content, docks, scale, style, corner, navigation, false)
+ Self::build(viewport, content, docks, scale, style, corner, navigation, None)
}
/// Render fits stay between the docked panels, including beneath a short Browser card.
@@ -75,7 +75,20 @@ impl Layout {
corner: egui::Vec2,
navigation: Rect,
) -> Self {
- Self::build(viewport, content, docks, scale, style, corner, navigation, true)
+ Self::build(viewport, content, docks, scale, style, corner, navigation, Some(crate::frame::Side::Right))
+ }
+
+ /// Render compass at the free canvas edge beside a left-hand Inspector.
+ pub fn product_left(
+ viewport: Rect,
+ content: Rect,
+ docks: &[Rect],
+ scale: f32,
+ style: crate::prefs::NavigatorStyle,
+ corner: egui::Vec2,
+ navigation: Rect,
+ ) -> Self {
+ Self::build(viewport, content, docks, scale, style, corner, navigation, Some(crate::frame::Side::Left))
}
#[allow(clippy::too_many_arguments)]
@@ -87,8 +100,9 @@ impl Layout {
style: crate::prefs::NavigatorStyle,
corner: egui::Vec2,
navigation: Rect,
- fit_in_content: bool,
+ inspector_side: Option<crate::frame::Side>,
) -> Self {
+ let fit_in_content = inspector_side.is_some();
let scale = if scale.is_finite() && scale > 0.0 { scale } else { 1.0 };
let mut obstacles: Vec<_> = docks.iter().take(14).copied().filter(|r| r.is_finite()).map(|r| r.expand(4.0)).collect();
// Navigation is anchored to the viewport, never to transient dialog space.
@@ -106,8 +120,11 @@ impl Layout {
// The axis view starts below the pair while it is shown.
let top = if confirm.is_positive() { confirm.bottom() + CORNER_GAP } else { available.top() };
let cube_size = if fit_in_content { 110.0 } else { super::viewport::axis_view_size(style) };
+ let axis_left = |size| {
+ if inspector_side == Some(crate::frame::Side::Left) { available.left() } else { available.right() - size }
+ };
let mut axis_view = if available.width() >= cube_size && available.bottom() - top >= cube_size {
- Rect::from_min_size(pos2(available.right() - cube_size, top), vec2(cube_size, cube_size))
+ Rect::from_min_size(pos2(axis_left(cube_size), top), vec2(cube_size, cube_size))
} else {
Rect::NOTHING
};
@@ -116,7 +133,7 @@ impl Layout {
if axis_view.intersect(navigation).is_positive() {
let compact = (navigation.top() - top - 4.0).min(cube_size);
axis_view = if style == crate::prefs::NavigatorStyle::Cube && compact >= 96.0 {
- Rect::from_min_size(pos2(content.right() - compact, top), vec2(compact, compact))
+ Rect::from_min_size(pos2(axis_left(compact), top), vec2(compact, compact))
} else {
Rect::NOTHING
};
diff --git a/crates/ui-egui/src/viewport_layout_tests.rs b/crates/ui-egui/src/viewport_layout_tests.rs
index 3307284947..fb90c666ac 100644
--- a/crates/ui-egui/src/viewport_layout_tests.rs
+++ b/crates/ui-egui/src/viewport_layout_tests.rs
@@ -8,6 +8,28 @@ fn bar_rect(canvas: Rect) -> Rect {
crate::navigation_bar_view::measure(canvas, &Default::default(), crate::navigation::NavCaps::MODEL, |_| 0.0).rect
}
+#[test]
+fn render_compass_avoids_the_navigation_bar_on_either_inspector_side() {
+ let viewport = Rect::from_min_size(pos2(0.0, 0.0), vec2(400.0, 140.0));
+ for style in [crate::prefs::NavigatorStyle::Axes, crate::prefs::NavigatorStyle::Cube] {
+ for inspector_left in [false, true] {
+ for bar_left in [false, true] {
+ let navigation = Rect::from_min_size(pos2(if bar_left { 8.0 } else { 312.0 }, 100.0), vec2(80.0, 32.0));
+ let make = if inspector_left { Layout::product_left } else { Layout::product };
+ let layout = make(viewport, viewport, &[], 1.0, style, egui::Vec2::ZERO, navigation);
+ assert!(!layout.axis_view.intersect(navigation).is_positive());
+ if inspector_left != bar_left {
+ assert!(layout.axis_view.is_positive(), "a bar on the opposite side must leave the compass visible");
+ }
+ if layout.axis_view.is_positive() {
+ let edge = if inspector_left { layout.axis_view.left() - viewport.left() } else { viewport.right() - layout.axis_view.right() };
+ assert!(edge.abs() < 0.1, "a compact compass must stay on the Inspector's side");
+ }
+ }
+ }
+ }
+}
+
fn layout(viewport: Rect, docks: &[Rect], scale: f32, style: crate::prefs::NavigatorStyle, visible: bool) -> Layout {
let navigation = if visible {
crate::navigation_bar_view::measure(viewport, &Default::default(), crate::navigation::NavCaps::MODEL, |_| 0.0).rect