SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.
//! Shared tree content, independent of the panels which present it.
//!
//! A frame has one app-owned begin/finalize pair. Each presentation owns its range order,
//! anchor, geometry and transient input; the document, selection, folds and row cache remain
//! in `SolveApp`. Hosts and future adapters can render the same content through `show`.
use std::cell::RefCell;
use std::collections::{BTreeMap, HashMap, HashSet};
use egui::{Rect, Ui};
use crate::SolveApp;
/// A presentation identity, independent of its placement or content composition.
#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq, PartialOrd, Ord)]
pub struct ContentOwner(pub u64);
impl ContentOwner {
pub const BROWSER: Self = Self(0);
pub const HISTORY: Self = Self(1);
}
/// Runtime identity of the document and presentation which produced an interaction.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) struct ContentSource {
pub(crate) session: u64,
pub(crate) owner: ContentOwner,
}
#[derive(Clone)]
pub(crate) struct FeatureDrag {
pub(crate) source: ContentSource,
pub(crate) features: Vec<u64>,
}
/// Existing row compositions. This interface deliberately contains no panel or host policy.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub(crate) enum ContentRequest {
Browser { shrink_height: bool },
ActiveBodiesOrigin,
}
pub type DrawnRow = (String, Rect, Option<Rect>, Option<bool>);
pub type DrawnOccurrence = (Vec<u64>, String, Rect, bool);
/// Geometry belongs to one presentation and expires at the next semantic frame.
#[derive(Clone, Default)]
pub struct Output {
pub rows: Vec<DrawnRow>,
pub occurrences: Vec<DrawnOccurrence>,
pointer_owned: bool,
}
thread_local! {
// Compatibility/automation snapshots, published by the owner rather than by each row.
static PUBLISHED: RefCell<BTreeMap<ContentOwner, Output>> = const { RefCell::new(BTreeMap::new()) };
}
pub fn output(owner: ContentOwner) -> Output {
PUBLISHED.with(|outputs| outputs.borrow().get(&owner).cloned().unwrap_or_default())
}
#[derive(Default)]
pub(crate) struct OwnerState {
pub(crate) order: Vec<String>,
pub(crate) previous: Vec<String>,
pub(crate) anchor: Option<String>,
pub(crate) feature_drags: HashMap<egui::Id, FeatureDrag>,
order_len: usize,
output: Output,
actions: Option<crate::browser::Actions>,
presented: bool,
}
impl OwnerState {
pub(crate) fn remember(&mut self, key: &str) {
if let Some(slot) = self.order.get_mut(self.order_len) {
if slot != key {
slot.clear();
slot.push_str(key);
}
} else {
self.order.push(key.to_owned());
}
self.order_len += 1;
}
pub(crate) fn current_order(&self) -> &[String] {
self.order.get(..self.order_len).unwrap_or(&[])
}
}
#[derive(Default)]
pub(crate) struct Frame {
session: Option<u64>,
context: Option<egui::Context>,
owners: BTreeMap<ContentOwner, OwnerState>,
active: Option<(ContentOwner, ContentRequest)>,
last_bodies: Vec<String>,
last_plane: Option<String>,
plane_underlay: Option<String>,
finalized: bool,
}
impl Frame {
pub(crate) fn owner(&self, owner: ContentOwner) -> Option<&OwnerState> {
self.owners.get(&owner)
}
pub(crate) fn current_mut(&mut self) -> &mut OwnerState {
let owner = self.active.map_or(ContentOwner::BROWSER, |(owner, _)| owner);
self.owners.entry(owner).or_default()
}
pub(crate) fn browser_presentation(&self) -> bool {
matches!(self.active, Some((ContentOwner::BROWSER, ContentRequest::Browser { .. })))
}
}
fn active_id() -> egui::Id {
egui::Id::unique("sc_semantic_content_owner")
}
fn output_id(owner: ContentOwner) -> egui::Id {
egui::Id::unique(("sc_semantic_content_output", owner))
}
fn capture_id() -> egui::Id {
egui::Id::unique("sc_semantic_content_eye_owner")
}
#[derive(Clone, Copy)]
struct EyeCapture {
source: ContentSource,
widget: egui::Id,
target: bool,
}
#[derive(Clone, Copy)]
struct RowCapture {
source: ContentSource,
widget: egui::Id,
}
#[derive(Clone, Default)]
struct InputClaims {
frame: u64,
actions: HashSet<egui::Id>,
}
/// Egui may repeat layout within an input frame. A consumed row action must not execute a
/// second time on that pass (in particular a Ctrl toggle or an eye visibility command).
pub(crate) fn claim_action(ui: &Ui, widget: egui::Id) -> bool {
let frame = ui.ctx().cumulative_frame_nr();
ui.ctx().data_mut(|data| {
let claims = data.get_temp_mut_or_default::<InputClaims>(egui::Id::unique("sc_semantic_content_input_claims"));
if claims.frame != frame {
claims.frame = frame;
claims.actions.clear();
}
claims.actions.insert(widget)
})
}
fn row_capture_id() -> egui::Id {
egui::Id::unique("sc_semantic_content_row_capture")
}
pub(crate) fn current_source(app: &SolveApp) -> Option<ContentSource> {
let (owner, _) = app.tree.content.active?;
(app.tree.content.session == Some(app.session.uid)).then_some(ContentSource { session: app.session.uid, owner })
}
pub(crate) fn same_document(ui: &Ui, source: ContentSource) -> bool {
ui.ctx().data(|data| data.get_temp::<ContentSource>(active_id())).is_some_and(|active| active.session == source.session)
}
pub(crate) fn source_present(app: &SolveApp, source: ContentSource) -> bool {
app.tree.content.session == Some(source.session)
&& app.session.uid == source.session
&& app.tree.content.owner(source.owner).is_some_and(|state| state.presented)
}
/// Called while the outgoing session (and its undo stack) is still active. Context is retained
/// solely for cancelling owned egui capture when a tab changes outside the drawing callback.
pub(crate) fn leave_document(app: &mut SolveApp) {
let context = app.tree.content.context.clone();
if let (Some(ctx), Some(session)) = (&context, app.tree.content.session) {
if ctx.data(|data| data.get_temp::<EyeCapture>(capture_id())).is_some_and(|capture| capture.source.session == session) {
crate::browser::end_eye_drag(app, ctx);
}
if let Some(capture) = ctx.data(|data| data.get_temp::<RowCapture>(row_capture_id())).filter(|capture| capture.source.session == session) {
if ctx.dragged_id() == Some(capture.widget) {
ctx.stop_dragging();
}
ctx.data_mut(|data| data.remove::<RowCapture>(row_capture_id()));
}
crate::browser::cancel_content_drag(ctx, session);
ctx.data_mut(|data| {
if data.get_temp::<ContentSource>(active_id()).is_some_and(|source| source.session == session) {
data.remove::<ContentSource>(active_id());
}
for owner in app.tree.content.owners.keys() {
data.remove::<Output>(output_id(*owner));
}
});
}
crate::browser::discard_eye_press(app);
let _ = expire_hover(app);
app.tree.content = Frame { context, ..Default::default() };
PUBLISHED.with(|outputs| outputs.borrow_mut().clear());
}
/// Also protects callers which replace a Session without passing through Documents.
pub(crate) fn ensure_session(app: &mut SolveApp, ctx: &egui::Context) {
crate::browser::sync_reveals(app);
if app.tree.content.session != Some(app.session.uid) {
leave_document(app);
app.tree.content.session = Some(app.session.uid);
}
app.tree.content.context = Some(ctx.clone());
}
/// An external producer replaced this slot. Its ownership supersedes our previous write even
/// when the new vector contains precisely the same names (Select Other is one such producer).
pub(crate) fn set_external_body_hover(app: &mut SolveApp, bodies: Vec<String>) {
app.tree.content.last_bodies.clear();
app.viewport.hover_bodies = bodies;
}
fn expire_hover(app: &mut SolveApp) -> (Vec<String>, Option<String>) {
let old_bodies = std::mem::take(&mut app.tree.content.last_bodies);
let old_plane = app.tree.content.last_plane.take();
for body in &old_bodies {
if let Some(index) = app.viewport.hover_bodies.iter().position(|candidate| candidate == body) {
app.viewport.hover_bodies.remove(index);
}
}
let plane_underlay = app.tree.content.plane_underlay.take();
if old_plane.is_some() && app.viewport.hover_plane == old_plane {
app.viewport.hover_plane = plane_underlay;
}
(old_bodies, old_plane)
}
pub(crate) fn begin(app: &mut SolveApp, ctx: &egui::Context) {
ensure_session(app, ctx);
let frame = &mut app.tree.content;
frame.active = None;
frame.finalized = false;
for state in frame.owners.values_mut() {
if state.presented {
std::mem::swap(&mut state.previous, &mut state.order);
}
state.order_len = 0;
state.output = Output::default();
state.actions = None;
state.presented = false;
}
PUBLISHED.with(|outputs| outputs.borrow_mut().clear());
ctx.data_mut(|data| data.remove::<ContentSource>(active_id()));
crate::browser::prune_reveals(app);
}
/// Render into an existing UI. Stable item IDs and command paths belong to the row renderers.
pub(crate) fn show(app: &mut SolveApp, ui: &mut Ui, owner: ContentOwner, request: ContentRequest) {
render_scope(app, ui, owner, request, |app, ui| crate::browser::render_content(app, ui, request));
}
pub(crate) fn render_scope(
app: &mut SolveApp,
ui: &mut Ui,
owner: ContentOwner,
request: ContentRequest,
render: impl FnOnce(&mut SolveApp, &mut Ui) -> crate::browser::Actions,
) {
ensure_session(app, ui.ctx());
if app.tree.content.owners.get(&owner).is_some_and(|state| state.presented) {
return;
}
app.tree.content.active = Some((owner, request));
app.tree.content.owners.entry(owner).or_default().presented = presented(ui);
ui.ctx().data_mut(|data| {
data.insert_temp(active_id(), ContentSource { session: app.session.uid, owner });
data.insert_temp(output_id(owner), Output::default());
});
let session = app.session.uid;
let actions = ui.push_id(("semantic_content", session, owner), |ui| render(app, ui)).inner;
if session != app.session.uid {
ensure_session(app, ui.ctx());
return;
}
let output = ui.ctx().data_mut(|data| {
data.remove::<ContentSource>(active_id());
data.remove_temp::<Output>(output_id(owner)).unwrap_or_default()
});
PUBLISHED.with(|outputs| outputs.borrow_mut().insert(owner, output.clone()));
let state = app.tree.content.owners.entry(owner).or_default();
state.order.truncate(state.order_len);
state.output = output;
state.actions = Some(actions);
app.tree.content.active = None;
}
pub(crate) fn record_row(ui: &Ui, row: DrawnRow, response: &crate::ui_kit::RowResp) {
if !presented(ui) {
return;
}
let Some(source) = ui.ctx().data(|data| data.get_temp::<ContentSource>(active_id())) else { return };
let owner = source.owner;
ui.ctx().data_mut(|data| {
let output = data.get_temp_mut_or_default::<Output>(output_id(owner));
output.rows.push(row);
output.pointer_owned |= response.hovered || response.resp.as_ref().is_some_and(|response| response.contains_pointer());
});
if !response.on_control
&& let Some(response) = &response.resp
{
record_capture(ui, response);
}
}
pub(crate) fn record_capture(ui: &Ui, response: &egui::Response) {
if response.drag_started()
&& let Some(source) = ui.ctx().data(|data| data.get_temp::<ContentSource>(active_id()))
{
ui.ctx().data_mut(|data| data.insert_temp(row_capture_id(), RowCapture { source, widget: response.id }));
}
}
pub(crate) fn record_occurrence(ui: &Ui, row: DrawnOccurrence) {
if !presented(ui) {
return;
}
let Some(source) = ui.ctx().data(|data| data.get_temp::<ContentSource>(active_id())) else { return };
let owner = source.owner;
ui.ctx().data_mut(|data| data.get_temp_mut_or_default::<Output>(output_id(owner)).occurrences.push(row));
}
/// The kit's eye gesture keeps its existing shared target value; its capture belongs to the
/// presentation where it began, so another copy of a body cannot apply the same drag again.
pub(crate) fn route_response(ui: &Ui, widget: egui::Id, response: &mut crate::ui_kit::RowResp) {
let Some(source) = ui.ctx().data(|data| data.get_temp::<ContentSource>(active_id())) else { return };
response.hovered &= response.resp.as_ref().is_some_and(|response| response.contains_pointer());
let action =
response.clicked || response.double || response.secondary.is_some() || response.fold || response.eye || response.radio || response.action;
let visible = presented(ui);
if !visible {
response.hovered = false;
response.resp = None;
}
if !visible || (action && !claim_action(ui, widget)) {
response.clicked = false;
response.double = false;
response.secondary = None;
response.fold = false;
response.eye = false;
response.radio = false;
response.action = false;
}
let capture = ui.ctx().data(|data| data.get_temp::<EyeCapture>(capture_id()));
if let Some(capture) = capture {
// A layout repeat may run the kit's drag-start branch again after visibility changed.
// Keep the gesture's original target rather than letting that branch invert it.
ui.ctx().data_mut(|data| data.insert_temp(crate::ui_kit::eye_drag_id(), capture.target));
}
if capture.is_some_and(|capture| capture.source != source) {
response.eye = false;
} else if response.eye
&& let Some(response) = response.resp.as_ref().filter(|response| response.drag_started())
{
ui.ctx().data_mut(|data| {
if let Some(target) = data.get_temp::<bool>(crate::ui_kit::eye_drag_id()) {
data.insert_temp(capture_id(), EyeCapture { source, widget: response.id, target });
}
});
}
}
pub(crate) fn release_eye(ctx: &egui::Context) -> Option<ContentSource> {
let capture = ctx.data_mut(|data| {
let capture = data.get_temp::<EyeCapture>(capture_id());
data.remove::<EyeCapture>(capture_id());
capture
})?;
if ctx.dragged_id() == Some(capture.widget) {
ctx.stop_dragging();
}
Some(capture.source)
}
/// A reveal is acknowledged only after its row is presented in the scroll viewport. An
/// offscreen target requests scrolling again on the next frame until that happens.
pub(crate) fn scroll_acknowledged(ui: &Ui, rect: Rect) -> bool {
scroll_acknowledged_at(ui, rect, egui::Align::Center)
}
/// [`scroll_acknowledged`] placing `rect` at `align` in the viewport.
pub(crate) fn scroll_acknowledged_at(ui: &Ui, rect: Rect, align: egui::Align) -> bool {
ui.scroll_to_rect(rect, Some(align));
presented(ui) && ui.is_rect_visible(rect) && ui.clip_rect().contains(rect.center())
}
fn presented(ui: &Ui) -> bool {
ui.is_visible() && ui.opacity() > 0.0
}
pub(crate) fn finalize(app: &mut SolveApp, ctx: &egui::Context) {
ensure_session(app, ctx);
if app.tree.content.finalized {
return;
}
app.tree.content.finalized = true;
let mut capture = ctx.data(|data| data.get_temp::<EyeCapture>(capture_id())).map(|capture| capture.source);
if capture.is_some_and(|source| !source_present(app, source)) {
crate::browser::end_eye_drag(app, ctx);
capture = None;
}
if let Some(capture) = ctx.data(|data| data.get_temp::<RowCapture>(row_capture_id())) {
if !source_present(app, capture.source) {
crate::browser::cancel_content_drag(ctx, capture.source.session);
if ctx.dragged_id() == Some(capture.widget) {
ctx.stop_dragging();
}
ctx.data_mut(|data| data.remove::<RowCapture>(row_capture_id()));
} else if !ctx.input(|input| input.pointer.primary_down()) {
ctx.data_mut(|data| data.remove::<RowCapture>(row_capture_id()));
}
}
// Keep the previous contribution until finalization: floating viewports paint before
// their overlaid panels. Expire only our contribution, leaving other producers intact.
let (old_bodies, old_plane) = expire_hover(app);
// Egui's response hit testing supplies pointer ownership, including occlusion and capture.
// Stable owner iteration only breaks ties; submission order never decides the winner.
let winner = app.tree.content.owners.iter().find_map(|(owner, state)| {
let actions = state.actions.as_ref()?;
(state.presented
&& actions.session == Some(app.session.uid)
&& capture.is_none_or(|capture| capture.owner == *owner && capture.session == app.session.uid)
&& (state.output.pointer_owned || actions.hovered || actions.hover_plane.is_some()))
.then_some(*owner)
});
let mut effect = None;
for (owner, state) in &mut app.tree.content.owners {
if !state.presented {
state.order.clear();
state.feature_drags.clear();
}
let actions = state.actions.take();
if Some(*owner) == winner {
effect = actions;
}
}
if let Some(actions) = effect {
for body in &actions.hover_bodies {
if !app.viewport.hover_bodies.contains(body) {
app.viewport.hover_bodies.push(body.clone());
app.tree.content.last_bodies.push(body.clone());
}
}
if actions.hover_plane.is_some() && actions.hover_plane != app.viewport.hover_plane {
app.tree.content.plane_underlay = app.viewport.hover_plane.take();
app.tree.content.last_plane.clone_from(&actions.hover_plane);
app.viewport.hover_plane.clone_from(&actions.hover_plane);
}
crate::browser::apply_content_actions(app, actions);
}
if old_bodies != app.tree.content.last_bodies || old_plane != app.tree.content.last_plane {
ctx.request_repaint();
}
}