293ed5fab7
* Render inspector: selection-following appearance panel with the look chain, Applies to and edit controls * Render appearance: Glass, Clear coat, Maps, Saved optics and Reflections sections * Update Render navigation tests for dedicated editors * Exercise Focus keyboard protection through the Library search field
328 lines
15 KiB
Rust
328 lines
15 KiB
Rust
//! The first local appearance-library consumer, inside the existing Appearance panel.
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
use crate::dialogs_appearance::selected_params;
|
|
use crate::{SolveApp, dialogs_appearance::Ap, selection::SelInput, ui_kit};
|
|
use serde_json::json;
|
|
use solidcraft_engine::io::catalog::Catalog;
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
use solidcraft_engine::io::catalog::Definition;
|
|
use std::sync::Arc;
|
|
|
|
#[derive(Clone, Debug, Default)]
|
|
pub struct LocalLibrary {
|
|
/// A delayed picker may update only the editor that requested it.
|
|
token: Arc<()>,
|
|
pub search: String,
|
|
pub path: String,
|
|
pub catalog: Option<Catalog>,
|
|
pub selected: Option<String>,
|
|
pub overwrite: bool,
|
|
pub materials: bool,
|
|
pub material_name: String,
|
|
}
|
|
|
|
fn display_order(mut catalog: Catalog) -> Catalog {
|
|
catalog.entries.sort_by(|a, b| a.definition.name().cmp(b.definition.name()).then_with(|| a.id.cmp(&b.id)));
|
|
catalog
|
|
}
|
|
|
|
fn editor<'a>(app: &'a mut SolveApp, token: &Arc<()>) -> Option<&'a mut Ap> {
|
|
let crate::dialogs::Kind::Appearance(k) = &mut app.dialog.as_mut()?.kind else { return None };
|
|
Arc::ptr_eq(&k.local.token, token).then_some(k)
|
|
}
|
|
|
|
/// Parameterless UI activation of the existing export command. JSON execution never picks files.
|
|
pub(crate) fn start_export(app: &mut SolveApp) {
|
|
let origin = app.session.doc.clone();
|
|
app.pick_save("my-library.solidcraft-library.json", &["json"], move |app, path| {
|
|
if let Some(path) = path
|
|
&& Arc::ptr_eq(&origin, &app.session.doc)
|
|
&& let Err(error) = app.run("library.export", json!({"path":path,"overwrite":false}))
|
|
{
|
|
app.set_status(error, true);
|
|
}
|
|
});
|
|
}
|
|
|
|
fn save_library(app: &mut SolveApp, token: Arc<()>, overwrite: bool) {
|
|
let origin = app.session.doc.clone();
|
|
app.pick_save("my-library.solidcraft-library.json", &["json"], move |app, path| {
|
|
let Some(path) = path else { return };
|
|
if !Arc::ptr_eq(&origin, &app.session.doc) {
|
|
app.set_status("The library export document changed while choosing its destination", true);
|
|
return;
|
|
}
|
|
match app.run("library.export", json!({"path":path,"overwrite":overwrite})) {
|
|
Ok(result) => {
|
|
let parsed = result.get("catalog").cloned().and_then(|v| serde_json::from_value::<Catalog>(v).ok()).map(display_order);
|
|
let count = parsed.as_ref().map_or(0, |c| c.entries.len());
|
|
if let Some(k) = editor(app, &token) {
|
|
k.local.path = path;
|
|
k.local.catalog = parsed;
|
|
k.local.selected = None;
|
|
k.local.search.clear();
|
|
k.note = Some(format!("Saved {count} reusable definitions. The design is unchanged."));
|
|
}
|
|
}
|
|
Err(error) => {
|
|
if let Some(k) = editor(app, &token) {
|
|
k.note = Some(error);
|
|
}
|
|
}
|
|
}
|
|
});
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn open_library(app: &mut SolveApp, token: Arc<()>) {
|
|
app.pick_open(move |app, path| {
|
|
let Some(path) = path else { return };
|
|
let Some(k) = editor(app, &token) else { return };
|
|
let mut local = k.local.clone();
|
|
local.path = path;
|
|
local.catalog = None;
|
|
local.selected = None;
|
|
let note = load(app, &mut local).unwrap_or_else(|error| error);
|
|
if let Some(k) = editor(app, &token) {
|
|
k.local = local;
|
|
k.note = Some(note);
|
|
}
|
|
});
|
|
}
|
|
|
|
/// Exports the design's library to `path` and shows it as the local library.
|
|
fn export(app: &mut SolveApp, k: &mut Ap, path: String, overwrite: bool) {
|
|
k.note = Some(match app.run("library.export", json!({"path":path,"overwrite":overwrite})) {
|
|
Ok(result) => {
|
|
let parsed = result.get("catalog").cloned().and_then(|v| serde_json::from_value::<Catalog>(v).ok()).map(display_order);
|
|
let count = parsed.as_ref().map_or(0, |c| c.entries.len());
|
|
k.local.path = path;
|
|
k.local.catalog = parsed;
|
|
k.local.selected = None;
|
|
k.local.search.clear();
|
|
format!("Saved {count} reusable definitions. The design is unchanged.")
|
|
}
|
|
Err(error) => error,
|
|
});
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn load(app: &mut SolveApp, library: &mut LocalLibrary) -> Result<String, String> {
|
|
let result = app.run("library.inspect", json!({"path":library.path}))?;
|
|
let catalog: Catalog = serde_json::from_value(result.get("catalog").cloned().ok_or("Library response is missing")?).map_err(|e| e.to_string())?;
|
|
let note = format!("Opened {} ({} entries)", catalog.name, catalog.entries.len());
|
|
library.catalog = Some(display_order(catalog));
|
|
library.selected = None;
|
|
library.search.clear();
|
|
Ok(note)
|
|
}
|
|
|
|
pub fn rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Ap, inputs: &[SelInput]) {
|
|
ui_kit::section(ui, "local_library", "Local library", true, |ui| {
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
import_rows(app, ui, k, inputs);
|
|
#[cfg(target_arch = "wasm32")]
|
|
{
|
|
let _ = inputs;
|
|
ui_kit::text(
|
|
ui,
|
|
crate::i18n::tr_label("Open local libraries in the desktop app. You can export this design's library here."),
|
|
ui_kit::Text::Note("library_platform"),
|
|
);
|
|
}
|
|
ui_kit::checkbox(ui, crate::i18n::tr_label("Replace existing library file"), &mut k.local.overwrite);
|
|
let save = ui_kit::button(ui, crate::i18n::tr_label("Export design library..."), ui_kit::Button::Normal);
|
|
crate::scenario::publish_handle("library:export", save.rect.center());
|
|
if save.clicked() {
|
|
if app.services.pick_save.is_some() {
|
|
save_library(app, k.local.token.clone(), k.local.overwrite);
|
|
} else if !k.local.path.is_empty() {
|
|
export(app, k, k.local.path.clone(), k.local.overwrite);
|
|
}
|
|
}
|
|
ui_kit::text(
|
|
ui,
|
|
crate::i18n::tr_label("Apply your appearance first. Exports assigned appearances and materials created in this design."),
|
|
ui_kit::Text::Note("library_export"),
|
|
);
|
|
});
|
|
}
|
|
|
|
#[cfg(not(target_arch = "wasm32"))]
|
|
fn import_rows(app: &mut SolveApp, ui: &mut egui::Ui, k: &mut Ap, inputs: &[SelInput]) {
|
|
let path = ui_kit::row(ui, "Library file", |ui| {
|
|
let id = ui.make_persistent_id("library_path");
|
|
ui_kit::cell_editor(ui, id, &mut k.local.path, "Library file", false)
|
|
});
|
|
crate::scenario::publish_handle("library:path", path.rect.center());
|
|
if path.changed() {
|
|
k.local.catalog = None;
|
|
k.local.selected = None;
|
|
}
|
|
ui.horizontal(|ui| {
|
|
if ui_kit::button(ui, crate::i18n::tr_label("Open library..."), ui_kit::Button::Normal).clicked() {
|
|
open_library(app, k.local.token.clone());
|
|
}
|
|
let load_button = ui_kit::button(ui, "Load library", ui_kit::Button::Enabled(!k.local.path.is_empty()));
|
|
crate::scenario::publish_handle("library:load", load_button.rect.center());
|
|
if load_button.clicked() {
|
|
k.local.catalog = None;
|
|
k.local.selected = None;
|
|
k.note = Some(load(app, &mut k.local).unwrap_or_else(|error| error));
|
|
}
|
|
});
|
|
if let Some(catalog) = &k.local.catalog {
|
|
ui_kit::text(ui, &catalog.name, ui_kit::Text::Report("library_name", false));
|
|
let mode = ui_kit::checkbox(ui, crate::i18n::tr_label("Physical material definitions"), &mut k.local.materials);
|
|
crate::scenario::publish_handle("library:materials", mode.rect.center());
|
|
if mode.changed() {
|
|
k.local.selected = None;
|
|
k.local.material_name.clear();
|
|
}
|
|
let search = ui_kit::row(ui, "Search this library", |ui| {
|
|
let id = ui.make_persistent_id("library_search");
|
|
ui_kit::search_field(ui, id, &mut k.local.search, "Search this library")
|
|
});
|
|
crate::scenario::publish_handle("library:search", search.rect.center());
|
|
if search.changed() {
|
|
k.local.selected = None;
|
|
}
|
|
let query = k.local.search.trim().to_lowercase();
|
|
let appearances: Vec<_> = catalog
|
|
.entries
|
|
.iter()
|
|
.filter(|entry| {
|
|
matches!(&entry.definition, Definition::Material(_)) == k.local.materials
|
|
&& (entry.definition.name().to_lowercase().contains(&query) || entry.id.contains(&query))
|
|
})
|
|
.collect();
|
|
if appearances.is_empty() {
|
|
let message = if k.local.materials { "No matching physical materials." } else { "No matching appearance presets." };
|
|
ui_kit::text(ui, crate::i18n::tr_label(message), ui_kit::Text::Note("library_empty"));
|
|
}
|
|
let row_height = ui_kit::row_height();
|
|
ui_kit::list_frame(ui, "local_library_entries", |ui| {
|
|
egui::ScrollArea::vertical().id_salt("local_library_entries").max_height(row_height * 5.0).show_rows(
|
|
ui,
|
|
row_height,
|
|
appearances.len(),
|
|
|ui, range| {
|
|
for index in range {
|
|
let Some(entry) = appearances.get(index) else { continue };
|
|
ui.horizontal(|ui| {
|
|
ui.style_mut().wrap_mode = Some(egui::TextWrapMode::Truncate);
|
|
let look = match &entry.definition {
|
|
Definition::Appearance(look) => Some(look),
|
|
Definition::Material(material) => material.appearance.as_ref(),
|
|
};
|
|
if let Some(look) = look {
|
|
let [r, g, b] = look.color;
|
|
ui_kit::color_thumbnail(ui, ui.id().with((&entry.id, "sample")), egui::Color32::from_rgb(r, g, b), &look.name, ());
|
|
}
|
|
let button =
|
|
ui_kit::list_picker(ui, &entry.id, entry.definition.name(), k.local.selected.as_deref() == Some(entry.id.as_str()))
|
|
.on_hover_text(format!(
|
|
"{} · {} · {}",
|
|
entry.id,
|
|
entry.provenance.license,
|
|
entry.provenance.source_url.as_deref().unwrap_or("Local definition")
|
|
));
|
|
crate::scenario::publish_handle(&format!("library:entry:{index}"), button.rect.center());
|
|
if button.clicked() {
|
|
k.local.selected = Some(entry.id.clone());
|
|
k.local.material_name = entry.definition.name().to_string();
|
|
}
|
|
});
|
|
}
|
|
},
|
|
);
|
|
});
|
|
}
|
|
let entry = k
|
|
.local
|
|
.catalog
|
|
.as_ref()
|
|
.and_then(|catalog| {
|
|
catalog.entries.iter().find(|entry| {
|
|
Some(&entry.id) == k.local.selected.as_ref() && matches!(&entry.definition, Definition::Material(_)) == k.local.materials
|
|
})
|
|
})
|
|
.cloned();
|
|
if k.local.materials {
|
|
let name = ui_kit::row(ui, "Name on import", |ui| {
|
|
let id = ui.make_persistent_id("library_material_name");
|
|
ui_kit::cell_editor(ui, id, &mut k.local.material_name, "Name on import", false)
|
|
});
|
|
crate::scenario::publish_handle("library:material-name", name.rect.center());
|
|
if let Some(entry) = &entry
|
|
&& let Definition::Material(material) = &entry.definition
|
|
{
|
|
ui_kit::text(
|
|
ui,
|
|
&format!("{}: {} g/cm³", crate::i18n::tr("material.editor.assigned_density"), material.density_g_cm3),
|
|
ui_kit::Text::Report("library_material_density", false),
|
|
);
|
|
if let Some(card) = &material.physical_card {
|
|
crate::material_card_review::show_record(ui, card);
|
|
}
|
|
}
|
|
ui_kit::text(
|
|
ui,
|
|
crate::i18n::tr_label("Copies the definition only. Assign it from Physical Material when ready."),
|
|
ui_kit::Text::Note("library_material_copy"),
|
|
);
|
|
let copy = ui_kit::button(
|
|
ui,
|
|
crate::i18n::tr_label("Import material into design"),
|
|
ui_kit::Button::Enabled(entry.is_some() && !k.local.material_name.trim().is_empty()),
|
|
);
|
|
crate::scenario::publish_handle("library:material-import", copy.rect.center());
|
|
if copy.clicked()
|
|
&& let Some(entry) = entry
|
|
{
|
|
k.note = Some(
|
|
match app.run("library.apply", json!({"path":k.local.path,"entry":entry.id,"revision":entry.revision,"name":k.local.material_name})) {
|
|
Ok(_) => crate::i18n::tr_label("Material copied. Existing body assignments are unchanged.").to_string(),
|
|
Err(error) => error,
|
|
},
|
|
);
|
|
}
|
|
return;
|
|
}
|
|
let picked = inputs.first().map(|input| input.items.as_slice()).unwrap_or(&[]);
|
|
let selected = selected_params(k, picked);
|
|
let apply = ui_kit::button(ui, "Apply library appearance", ui_kit::Button::Enabled(entry.is_some() && selected.is_some()));
|
|
crate::scenario::publish_handle("library:apply", apply.rect.center());
|
|
if apply.clicked()
|
|
&& let (Some(entry), Some(selected)) = (entry, selected)
|
|
{
|
|
let mut targets = serde_json::Map::new();
|
|
for key in ["bodies", "faces", "components"] {
|
|
if let Some(value) = selected.get(key) {
|
|
targets.insert(key.into(), value.clone());
|
|
}
|
|
}
|
|
k.note = Some(match app.run("library.apply", json!({"path":k.local.path,"entry":entry.id,"revision":entry.revision,"targets":targets})) {
|
|
Ok(_) => {
|
|
if let Definition::Appearance(look) = entry.definition {
|
|
k.color = look.color;
|
|
k.opacity = look.opacity;
|
|
k.pbr = look.pbr;
|
|
k.look = Some(look.name.clone());
|
|
k.preset_id = None;
|
|
k.remove_override = false;
|
|
k.applied = selected_params(k, picked);
|
|
format!("{} copied into this design", look.name)
|
|
} else {
|
|
"This panel applies appearance presets only".into()
|
|
}
|
|
}
|
|
Err(error) => error,
|
|
});
|
|
}
|
|
}
|
|
|
|
#[cfg(all(test, not(target_arch = "wasm32")))]
|
|
#[path = "dialogs_library_tests.rs"]
|
|
mod tests;
|