Skip to content

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

24.9 KB
Raw Blame
//! Render-only gesture state. Preview changes the captured live scene, never the document.
use crate::{SolveApp, ui_kit, viewport::Hit};
use egui::Modifiers;
use serde_json::{Value, json};
use solidcraft_engine::{
    Sel,
    doc::appearance::Look,
    render::{FaceAppearance, ProductScene},
};
use std::hash::{Hash, Hasher};

#[derive(Clone, Debug, Default)]
pub(crate) struct State {
    pub look: Option<Value>,
    pub painting: bool,
    pub sampling: bool,
    drag: Option<(Value, u64, usize)>,
    preview: Option<Preview>,
    hover: Option<Sel>,
    recent: Vec<Value>,
    context: Option<Sel>,
    replacement: Option<Replacement>,
    replacement_index: usize,
}

#[derive(Clone, Debug)]
struct Replacement {
    from: Value,
    document: std::sync::Weak<solidcraft_engine::doc::Document>,
    revision: u64,
}

#[derive(Clone, Debug)]
pub(crate) struct Preview {
    look: Value,
    targets: Value,
    faces: Vec<(String, usize)>,
    bodies: Vec<String>,
}

fn component(app: &SolveApp, sel: &Sel) -> Option<u64> {
    match sel {
        Sel::Occurrence { path } => app.session.placed_document().path_placement(path).map(|(id, _)| id).filter(|id| *id != 0),
        Sel::Body { name } | Sel::Face { body: name, .. } | Sel::Edge { body: name, .. } => {
            let state = crate::open_meshing::session_world(&app.session);
            state.body(name).map(|body| app.session.doc.model_body_component(body)).filter(|id| *id != 0)
        }
        _ => None,
    }
}

/// Build all targets first; the engine applies them atomically with one history entry.
pub(crate) fn targets(app: &SolveApp, selected: &[Sel]) -> Result<Value, String> {
    let mut bodies = std::collections::BTreeSet::new();
    let mut components = std::collections::BTreeSet::new();
    let mut faces = Vec::new();
    for sel in selected {
        if app.ui.pick_components
            && let Some(id) = component(app, sel)
        {
            components.insert(id.to_string());
            continue;
        }
        match sel {
            Sel::Face { body, point, .. } if !app.ui.pick_bodies && !app.ui.pick_components => {
                faces.push(json!({"body":body,"point":point}));
            }
            Sel::Body { name } => {
                bodies.insert(name.clone());
            }
            Sel::Face { body, .. } | Sel::Edge { body, .. } => {
                bodies.insert(body.clone());
            }
            Sel::Occurrence { path } => {
                bodies.extend(app.session.occurrence_bodies(path, true).map_err(|e| e.to_string())?);
            }
            _ => return Err("selection has no appearance target".into()),
        }
    }
    if bodies.is_empty() && components.is_empty() && faces.is_empty() {
        return Err("pick an object first".into());
    }
    Ok(json!({"bodies":bodies,"components":components,"faces":faces}))
}

fn chain_target(app: &SolveApp, sel: &Sel) -> Result<Value, String> {
    match sel {
        Sel::Face { body, index, .. } => Ok(json!({"body":body,"face":index})),
        Sel::Body { name } | Sel::Edge { body: name, .. } => Ok(json!({"body":name})),
        Sel::Occurrence { .. } => component(app, sel).map(|id| json!({"component":id})).ok_or_else(|| "no component at target".into()),
        _ => Err("pick an object first".into()),
    }
}

fn remember(app: &mut SolveApp, look: Value) {
    let recent = &mut app.render_workspace.view.assign.recent;
    recent.retain(|l| l != &look);
    recent.insert(0, look);
    recent.truncate(6);
}

fn apply(app: &mut SolveApp, look: &Value, targets: Value) -> Result<(), String> {
    let mut params = look.clone();
    let object = params.as_object_mut().ok_or("invalid look")?;
    for (key, value) in targets.as_object().into_iter().flatten() {
        object.insert(key.clone(), value.clone());
    }
    app.run("appearance.assign", params)?;
    Ok(())
}

pub(crate) fn arm(app: &mut SolveApp, look: Value) -> Result<(), String> {
    let look = app.run("appearance.paint", look)?["look"].clone();
    app.tool = None;
    app.render_workspace.view.result = false;
    app.render_workspace.view.assign.look = Some(look);
    app.render_workspace.view.assign.painting = true;
    app.render_workspace.view.assign.sampling = false;
    Ok(())
}

pub(crate) fn tile(app: &mut SolveApp, look: Value, drag: bool) -> Result<(), String> {
    let look = app.run("appearance.paint", look)?["look"].clone();
    app.render_workspace.view.assign.look = Some(look.clone());
    if drag {
        let identity = std::sync::Arc::as_ptr(&app.session.doc) as usize;
        app.render_workspace.view.assign.drag = Some((look, app.session.revision, identity));
        app.render_workspace.view.assign.painting = false;
        app.render_workspace.view.assign.sampling = false;
        Ok(())
    } else if app.session.selection.is_empty() {
        arm(app, look)
    } else {
        apply(app, &look, targets(app, &app.session.selection)?)
    }
}

pub(crate) fn stop(app: &mut SolveApp) {
    let state = &mut app.render_workspace.view.assign;
    state.painting = false;
    state.sampling = false;
    state.drag = None;
    state.preview = None;
    state.hover = None;
    state.replacement = None;
}

/// The tool owns the first Escape before the shell's ordinary selection clearing.
pub(crate) fn cancel(app: &mut SolveApp) -> bool {
    let state = &app.render_workspace.view.assign;
    if !super::active(app) || !(state.painting || state.sampling || state.drag.is_some()) {
        return false;
    }
    let _ = app.run("appearance.paint", json!({"done":true}));
    stop(app);
    true
}

pub(crate) fn start(app: &mut SolveApp, id: &str) -> bool {
    if id == "appearance.library" && super::active(app) {
        super::library::focus_library(app);
        return true;
    }
    if !matches!(
        id,
        "appearance.paint"
            | "appearance.pick_up"
            | "appearance.copy"
            | "appearance.paste"
            | "appearance.chain"
            | "appearance.replace"
            | "appearance.favorite"
    ) {
        return false;
    }
    let result = (|| {
        if !super::active(app) {
            super::enter(app, true)?;
        }
        if id == "appearance.paint" {
            let look = app.render_workspace.view.assign.look.clone().ok_or_else(|| app.tr("render.choose_look").to_string())?;
            arm(app, look)
        } else if id == "appearance.pick_up" {
            app.run(id, json!({}))?;
            stop(app);
            app.tool = None;
            app.render_workspace.view.assign.sampling = true;
            Ok(())
        } else if id == "appearance.copy" {
            let sel = app.session.selection.last().ok_or("pick an object first")?;
            let target = chain_target(app, sel)?;
            app.run(id, json!({"target":target}))?;
            Ok(())
        } else if id == "appearance.paste" {
            let target = targets(app, &app.session.selection)?;
            app.run(id, target)?;
            Ok(())
        } else {
            let sel = app.session.selection.last().ok_or("pick an object first")?;
            let target = chain_target(app, sel)?;
            if id == "appearance.chain" {
                app.run(id, json!({"target":target}))?;
                app.run("view.render_stage", json!({"stage":"look"}))?;
            } else {
                let look = app.run("appearance.pick_up", json!({"target":target}))?["look"].clone();
                if id == "appearance.replace" {
                    app.render_workspace.view.assign.replacement =
                        Some(Replacement { from: look, document: std::sync::Arc::downgrade(&app.session.doc), revision: app.session.revision });
                    app.render_workspace.view.assign.replacement_index = 0;
                } else {
                    let favorite = !is_favorite(app, &look);
                    app.run(id, json!({"look":look, "favorite":favorite}))?;
                }
            }
            Ok(())
        }
    })();
    if let Err(error) = result {
        app.set_status(error, true);
    }
    true
}

pub(crate) fn candidate(app: &SolveApp, hits: &[Hit], mods: Modifiers) -> Option<(Hit, Sel)> {
    if app.render_workspace.view.assign.drag.is_some() {
        let hit = hits.iter().find(|h| matches!(h, Hit::Face { .. }))?;
        if let Hit::Face { body, index, point } = hit {
            let sel = if mods.shift {
                Sel::Face { body: body.clone(), index: *index, point: *point }
            } else if mods.ctrl || mods.command {
                crate::viewport::component_selection(app, body)
            } else {
                return crate::viewport::candidate(app, std::slice::from_ref(hit));
            };
            return Some((hit.clone(), sel));
        }
    }
    crate::viewport::candidate(app, hits)
}

fn drop_preview(app: &SolveApp, look: Value, hit: &Hit, sel: &Sel, mods: Modifiers) -> Result<Preview, String> {
    let Hit::Face { body, index, point } = hit else {
        return Err("no face under cursor".into());
    };
    let face = mods.shift || (!mods.ctrl && !mods.command && !app.ui.pick_bodies && !app.ui.pick_components);
    if face {
        return Ok(Preview {
            look,
            targets: json!({"faces":[{"body":body,"point":point}]}),
            faces: vec![(body.clone(), *index)],
            bodies: Vec::new(),
        });
    }
    let whole_component = mods.ctrl || mods.command || app.ui.pick_components;
    if whole_component && let Some(id) = component(app, sel) {
        let bodies = crate::open_meshing::session_world(&app.session)
            .bodies
            .iter()
            .filter(|b| {
                app.session.doc.component_within(app.session.doc.model_body_component(b), id)
                    && !app.session.doc.appearances.bodies.contains_key(b.definition_name())
            })
            .map(|b| b.name.clone())
            .collect();
        return Ok(Preview { look, targets: json!({"components":[id.to_string()]}), faces: Vec::new(), bodies });
    }
    Ok(Preview { look, targets: json!({"bodies":[body]}), faces: Vec::new(), bodies: vec![body.clone()] })
}

fn click(app: &mut SolveApp, candidate: Option<&(Hit, Sel)>) -> Result<(), String> {
    let Some((hit, sel)) = candidate else {
        return Ok(());
    };
    if app.render_workspace.view.assign.sampling {
        // Sample the actual visible face even when the Pick size is Body.
        let source = match hit {
            Hit::Face { body, index, .. } => json!({"body":body,"face":index}),
            _ => chain_target(app, sel)?,
        };
        let reply = app.run("appearance.pick_up", json!({"target":source}))?;
        return arm(app, reply["look"].clone());
    }
    if app.render_workspace.view.assign.painting
        && let Some(look) = app.render_workspace.view.assign.look.clone()
    {
        let target = drop_preview(app, look.clone(), hit, sel, Modifiers::NONE)?;
        apply(app, &look, target.targets)?;
    }
    Ok(())
}

pub(crate) fn input(app: &mut SolveApp, ui: &mut egui::Ui, response: &egui::Response, candidate: Option<&(Hit, Sel)>, inside: bool) -> bool {
    let active = {
        let s = &app.render_workspace.view.assign;
        s.painting || s.sampling || s.drag.is_some()
    };
    if !active {
        return false;
    }
    if ui.input(|i| i.key_pressed(egui::Key::Escape)) {
        let _ = app.run("appearance.paint", json!({"done":true}));
        stop(app);
        app.esc_handled = true;
        return true;
    }
    if let Some((look, revision, identity)) = app.render_workspace.view.assign.drag.clone() {
        if revision != app.session.revision
            || identity != std::sync::Arc::as_ptr(&app.session.doc) as usize
            || ui.input(|i| !i.pointer.primary_down() && !i.pointer.button_released(egui::PointerButton::Primary))
        {
            stop(app);
            return true;
        }
        let mods = ui.input(|i| i.modifiers);
        app.render_workspace.view.assign.hover = candidate.filter(|_| inside).map(|(_, sel)| sel.clone());
        app.render_workspace.view.assign.preview = candidate.filter(|_| inside).and_then(|(hit, sel)| drop_preview(app, look, hit, sel, mods).ok());
        if ui.input(|i| i.pointer.button_released(egui::PointerButton::Primary)) {
            let preview = app.render_workspace.view.assign.preview.take();
            app.render_workspace.view.assign.drag = None;
            app.render_workspace.view.assign.hover = None;
            if let Some(preview) = preview
                && let Err(error) = apply(app, &preview.look, preview.targets)
            {
                app.set_status(error, true);
            }
        }
    } else if inside
        && response.clicked_by(egui::PointerButton::Primary)
        && let Err(error) = click(app, candidate)
    {
        app.set_status(error, true);
    }
    let state = &app.render_workspace.view.assign;
    if (state.painting || state.drag.is_some())
        && let Some(look) = &state.look
    {
        ui_kit::sphere_cursor(ui, super::library::tile_sphere(look));
    }
    true
}

pub(crate) fn banner(app: &mut SolveApp, ui: &mut egui::Ui) {
    let s = &app.render_workspace.view.assign;
    if !s.painting && !s.sampling {
        return;
    }
    let text = if s.sampling {
        app.tr("render.pick_up_prompt").to_string()
    } else {
        crate::i18n::format("render.painting_with", &[("name", s.look.as_ref().and_then(|l| l["name"].as_str()).unwrap_or(""))])
    };
    ui_kit::text(ui, &text, ui_kit::Text::Inline);
    if ui_kit::button(ui, app.tr_label("Done"), ui_kit::Button::Normal).clicked() {
        let _ = app.run("appearance.paint", json!({"done":true}));
        stop(app);
    }
}

pub(crate) fn preview(app: &SolveApp) -> Option<Preview> {
    app.render_workspace.view.assign.preview.clone()
}
pub(crate) fn preview_key(app: &SolveApp) -> u64 {
    let mut hash = std::collections::hash_map::DefaultHasher::new();
    if let Some(p) = &app.render_workspace.view.assign.preview {
        p.look.to_string().hash(&mut hash);
        p.targets.to_string().hash(&mut hash);
    }
    hash.finish()
}

pub(crate) fn preview_scene(scene: &mut ProductScene, preview: Option<&Preview>) -> Result<(), String> {
    let Some(preview) = preview else {
        return Ok(());
    };
    let color = crate::dialogs_appearance::parse_color(&preview.look["color"]).ok_or("invalid preview look")?;
    let look = Look {
        name: preview.look["name"].as_str().unwrap_or("").into(),
        color,
        opacity: preview.look["opacity"].as_f64().unwrap_or(1.0),
        pbr: preview.look.get("pbr").filter(|p| !p.is_null()).map(|p| serde_json::from_value(p.clone())).transpose().map_err(|e| e.to_string())?,
    };
    let surface = look.opaque_surface().map_err(|e| e.to_string())?;
    for mesh in &mut scene.meshes {
        if preview.bodies.contains(&mesh.name) {
            mesh.color = look.color;
            mesh.opacity = look.opacity;
            mesh.surface = surface;
        }
        for (_, face) in preview.faces.iter().filter(|(name, _)| name == &mesh.name) {
            let face = u32::try_from(*face).map_err(|_| "invalid preview face")?;
            mesh.faces.retain(|f| f.face != face);
            mesh.faces.push(FaceAppearance { face, color: look.color, opacity: look.opacity, surface, transmission: None });
        }
    }
    Ok(())
}

pub(crate) fn menu(app: &SolveApp, body: &str) -> crate::context_menu::Item {
    use crate::context_menu::{Item, cmd};
    let selected_face = app
        .render_workspace
        .view
        .assign
        .context
        .as_ref()
        .filter(|s| matches!(s, Sel::Face {body:name,..} if name == body))
        .or_else(|| app.session.selection.iter().find(|s| matches!(s,Sel::Face {body:name,..} if name == body)));
    let sel = selected_face.cloned().unwrap_or(Sel::Body { name: body.into() });
    let targets = targets(app, std::slice::from_ref(&sel)).unwrap_or_else(|_| json!({"bodies":[body]}));
    let mut menu = Item::action("appearance.assign", app.tr("cmd.appearance_assign"), "");
    menu.children.push(Item::heading(app.tr("render.recent_looks")));
    for look in &app.render_workspace.view.assign.recent {
        let mut params = look.clone();
        if let Some(object) = params.as_object_mut() {
            for (k, v) in targets.as_object().into_iter().flatten() {
                object.insert(k.clone(), v.clone());
            }
        }
        menu.children.push(cmd(app, "appearance.assign", look["name"].as_str().unwrap_or("")).with(params));
    }
    menu.children.push(Item::sep());
    menu.children.push(cmd(app, "appearance.library", app.tr("render.browse_looks")));
    menu.children.push(cmd(app, "appearance.assign", app.tr("cmd.appearance_assign")));
    menu.children.push(cmd(app, "appearance.chain", app.tr("cmd.appearance_chain")));
    menu.children.push(cmd(app, "appearance.replace", app.tr("render.replace_all")));
    menu.children.push(cmd(app, "appearance.pick_up", app.tr("cmd.appearance_pick_up")));
    if let Ok(target) = chain_target(app, &sel) {
        menu.children.push(cmd(app, "appearance.copy", app.tr("cmd.appearance_copy")).with(json!({"target":target})));
    }
    menu.children
        .push(cmd(app, "appearance.paste", app.tr("cmd.appearance_paste")).with(targets.clone()).on(app.session.appearance_clipboard.is_some()));
    menu.children.push(cmd(app, "appearance.assign", app.tr("render.remove_override")).with(targets));
    menu
}

/// Reuse the viewport's shared hover drawing, including modifier-specific drop size.
pub(crate) fn hover(app: &SolveApp) -> Option<&Sel> {
    app.render_workspace.view.assign.hover.as_ref()
}

pub(crate) fn context(app: &mut SolveApp, candidate: &(Hit, Sel)) {
    app.render_workspace.view.assign.context = Some(match &candidate.0 {
        Hit::Face { body, index, point } => Sel::Face { body: body.clone(), index: *index, point: *point },
        _ => candidate.1.clone(),
    });
}

pub(crate) fn assigned(app: &mut SolveApp, result: &Value) {
    if let Some(look) = result.get("appearance").filter(|look| !look.is_null()) {
        remember(app, look.clone());
        app.set_status(crate::i18n::format("render.look_applied", &[("name", look["name"].as_str().unwrap_or(""))]), false);
        app.status_undo = true;
    }
}

fn favorite_key(look: &Value) -> (String, String) {
    ("appearances".into(), super::library::appearance_id(look))
}
fn is_favorite(app: &SolveApp, look: &Value) -> bool {
    app.preferences.render_library_favorites.contains(&favorite_key(look))
}
pub(crate) fn favorite_applied(app: &mut SolveApp, reply: &Value) {
    let key = favorite_key(&reply["look"]);
    if reply["favorite"] == true {
        if app.preferences.render_library_favorites.len() < 256 {
            app.preferences.render_library_favorites.insert(key);
        }
    } else {
        app.preferences.render_library_favorites.remove(&key);
    }
    super::library::invalidate(app);
}

fn selection_name(app: &SolveApp, sel: &Sel) -> String {
    match sel {
        Sel::Body { name } | Sel::Face { body: name, .. } | Sel::Edge { body: name, .. } => name.clone(),
        Sel::Occurrence { path } => {
            path.last().and_then(|id| app.session.doc.occurrences.iter().find(|o| o.id == *id)).map(|o| o.name.clone()).unwrap_or_default()
        }
        _ => String::new(),
    }
}

pub(crate) fn hover_tooltip(app: &mut SolveApp, response: &egui::Response, candidate: Option<&(Hit, Sel)>) {
    let Some((_, sel)) = candidate else { return };
    let Ok(target) = chain_target(app, sel) else { return };
    let Ok(reply) = app.session.execute("appearance.pick_up", &json!({"target":target})) else { return };
    let tip =
        crate::i18n::format("render.hover_look", &[("object", &selection_name(app, sel)), ("look", reply["look"]["name"].as_str().unwrap_or(""))]);
    ui_kit::Container::tooltip(response, &tip);
}

pub(crate) fn selection_bar(app: &mut SolveApp, ui: &mut egui::Ui, free: egui::Rect) {
    crate::shell::register_panel(app, "render:selection", None, None);
    if super::result_active(app) || app.render_workspace.view.stage != super::Stage::Look {
        return;
    }
    let Some(sel) = app.session.selection.last().cloned() else { return };
    let Ok(target) = chain_target(app, &sel) else { return };
    let Some(bounds) = crate::viewport::selection_bounds(app) else { return };
    let Some(viewport) = app.viewport.rect else { return };
    let proj = crate::viewport::projection(app, viewport);
    let mut screen = egui::Rect::NOTHING;
    for x in [bounds.min.x, bounds.max.x] {
        for y in [bounds.min.y, bounds.max.y] {
            for z in [bounds.min.z, bounds.max.z] {
                if let Some(p) = proj.to_screen(solidcore_record::Vec3::new(x, y, z)).filter(|p| p.is_finite()) {
                    screen.extend_with(p);
                }
            }
        }
    }
    if !screen.is_positive() || !screen.intersects(free) {
        return;
    }
    let Ok(reply) = app.session.execute("appearance.pick_up", &json!({"target":target})) else { return };
    let favorite = is_favorite(app, &reply["look"]);
    let labels = [app.tr("cmd.appearance_chain"), app.tr("render.replace_all"), app.tr("cmd.appearance_favorite"), app.tr("ui.hide")];
    let actions = ["chain", "reorder", "star", "suppress"]
        .iter()
        .zip(&labels)
        .enumerate()
        .map(|(index, (icon, label))| ui_kit::StageAction {
            icon: Some(icon),
            label,
            enabled: index != 2 || favorite || app.preferences.render_library_favorites.len() < 256,
            primary: index == 2 && favorite,
            reason: None,
        })
        .collect::<Vec<_>>();
    let anchor = egui::pos2(
        crate::shell::within(screen.center().x, free.left(), free.right()),
        crate::shell::within(screen.top() - crate::theme::Tokens::get().space_12, free.top(), free.bottom()),
    );
    let ctx = ui.ctx().clone();
    let pill = ui_kit::Container::selection_card(&ctx, egui::Id::unique("render_selection"), anchor, free, |ui| {
        ui_kit::selection_actions(ui, &selection_name(app, &sel), &actions)
    });
    crate::scenario::publish_rect("render:selection", pill.response.rect);
    crate::shell::register_panel(app, "render:selection", Some(pill.response.rect), None);
    match pill.inner {
        Some(0) => app.start("appearance.chain"),
        Some(1) => app.start("appearance.replace"),
        Some(2) => app.start("appearance.favorite"),
        Some(3) => {
            let params = match &sel {
                Sel::Occurrence { path } => json!({"paths":[path], "visible":false}),
                _ => json!({"items":[selection_name(app, &sel)], "visible":false}),
            };
            let _ = app.run("browser.visibility", params);
        }
        Some(4) => {
            let target = match &sel {
                Sel::Occurrence { path } => crate::context_menu::Target::Occurrence { path: path.clone() },
                _ => crate::context_menu::Target::Body { name: selection_name(app, &sel) },
            };
            crate::context_menu::open_for(app, pill.response.rect.left_bottom(), target);
        }
        _ => {}
    }
}

/// Existing appearance commands exposed alongside the shared inheritance widget.
pub(crate) fn replacement_dialog(app: &mut SolveApp, ctx: &egui::Context) {
    let Some(pending) = app.render_workspace.view.assign.replacement.clone() else { return };
    if pending.revision != app.session.revision || !pending.document.ptr_eq(&std::sync::Arc::downgrade(&app.session.doc)) {
        app.render_workspace.view.assign.replacement = None;
        return;
    }
    let from = pending.from;
    let entries = app.session.execute("appearance.library", &json!({})).ok().and_then(|v| v["appearances"].as_array().cloned()).unwrap_or_default();
    let entries: Vec<_> = entries.into_iter().filter(|entry| entry["available"] != false).collect();
    let mut selected = app.render_workspace.view.assign.replacement_index;
    let title = app.tr("render.replace_all").to_string();
    let (closed, action) = ui_kit::Confirm::new(egui::Id::unique("render_replace_look"), "reorder", &title)
        .actions(&title, app.tr_label("Cancel"), None)
        .show(ctx, !entries.is_empty(), |ui| {
            ui_kit::text(ui, from["name"].as_str().unwrap_or(""), ui_kit::Text::Inline);
            let names: Vec<_> = entries.iter().map(|entry| entry["name"].as_str().unwrap_or("")).collect();
            ui_kit::choice_row(ui, app.tr("render.replace_with"), "render_replace_with", &mut selected, &names);
        });
    app.render_workspace.view.assign.replacement_index = selected;
    if action == ui_kit::Action::Ok {
        if let Some(to) = entries.get(selected) {
            let to = to["id"].as_str().or_else(|| to["name"].as_str()).map(|name| json!(name));
            if let Some(to) = to
                && let Err(error) = app.run("appearance.replace", json!({"from":from,"to":to}))
            {
                app.set_status(error, true);
            }
        }
        app.render_workspace.view.assign.replacement = None;
    } else if closed || action == ui_kit::Action::Cancel {
        app.render_workspace.view.assign.replacement = None;
    }
}

pub(crate) fn replacement_open(app: &SolveApp) -> bool {
    app.render_workspace.view.assign.replacement.is_some()
}