beffroi-tools/crates/midra-layout/src/project_ui.rs

400 lines
16 KiB
Rust

use super::*;
use base64::{Engine, engine::general_purpose::STANDARD};
use midra_layout::project::{Project, Reference as SavedReference, write_file};
use std::path::PathBuf;
#[derive(Default)]
pub(super) struct FileUi {
opening: Option<(PathBuf, Project)>,
writing: Option<(PathBuf, String)>,
message: Option<String>,
}
impl Editor {
fn project(&self) -> Project {
let mut p = Project::from_layout(&self.layout);
p.editor.position_corner = self.corner;
p.editor.keep_aspect_ratio = self.keep_aspect_ratio;
p.editor.viewport_zoom = self.zoom;
p.editor.viewport_pan = [self.pan.x, self.pan.y];
p.editor.show_source_pattern = self.show_pattern;
p.editor.outline_layers = self.outline_layers;
p.editor.show_toolbar_icon_names = self.show_toolbar_icon_names;
p.reference = self.reference.as_ref().map(|r| SavedReference {
name: r.name.clone(),
image_base64: STANDARD.encode(&r.bytes),
visible: r.visible,
opacity: r.opacity,
preserve_ratio: r.preserve_ratio,
native_size: r.native_size,
offset: r.offset,
});
p
}
fn install_project(&mut self, ctx: &egui::Context, project: Project) -> Result<(), String> {
if self.device.sending {
return Err(
"Wait for the device send and readback before opening another project.".into(),
);
}
let layout = project.layout()?;
let reference = project
.reference
.as_ref()
.map(|r| {
let file = egui::DroppedFile {
name: r.name.clone(),
bytes: Some(r.bytes()?.into()),
..Default::default()
};
let mut reference = super::super::reference::Reference::load(ctx, &file)?;
reference.visible = r.visible;
reference.opacity = r.opacity;
reference.preserve_ratio = r.preserve_ratio;
reference.native_size = r.native_size;
reference.offset = r.offset;
Ok::<_, String>(reference)
})
.transpose()?;
let e = project.editor;
self.device.reset_mappings();
// Replace only after both the document and embedded image are ready.
*self = Self {
device: std::mem::take(&mut self.device),
settings: std::mem::take(&mut self.settings),
snapping: self.snapping,
layout,
reference,
corner: e.position_corner,
keep_aspect_ratio: e.keep_aspect_ratio,
zoom: e.viewport_zoom,
pan: Vec2::from(e.viewport_pan),
show_pattern: e.show_source_pattern,
outline_layers: e.outline_layers,
show_toolbar_icon_names: e.show_toolbar_icon_names,
..Default::default()
};
self.sync();
Ok(())
}
fn save_project_as(&mut self) {
self.layout.finish_drag();
match self.project().to_json() {
Ok(contents) => {
if let Some(path) = rfd::FileDialog::new()
.add_filter("Midra Layout project", &["json"])
.set_file_name("layout.midra.json")
.save_file()
{
self.queue_write(path, contents);
}
}
Err(e) => self.files.message = Some(e),
}
}
fn queue_write(&mut self, path: PathBuf, contents: String) {
if path.try_exists().unwrap_or(true) {
self.files.writing = Some((path, contents));
} else {
self.write_project_file(path, contents, false);
}
}
fn write_project_file(&mut self, path: PathBuf, contents: String, overwrite: bool) {
self.files.message = Some(match write_file(&path, contents.as_bytes(), overwrite) {
Ok(()) => format!("Saved {}", path.display()),
Err(e) => format!("Could not save {}: {e}", path.display()),
});
}
pub(super) fn project_menu(&mut self, ui: &mut egui::Ui) {
if ui.button("Open project…").clicked() {
ui.close_menu();
if let Some(path) = rfd::FileDialog::new()
.add_filter("Midra Layout project", &["json"])
.pick_file()
{
match Project::read(&path) {
Ok(p) => self.files.opening = Some((path, p)),
Err(e) => self.files.message = Some(format!("Cannot open project: {e}")),
}
}
}
if ui.button("Save project…").clicked() {
ui.close_menu();
self.save_project_as();
}
ui.small("Saves applied values and the reference image.");
ui.separator();
if ui
.add_enabled(
self.device.online(),
egui::Button::new("Configure Midra export…"),
)
.on_hover_text("Map editor layers, review device changes and send explicitly.")
.on_disabled_hover_text(
"Read the Midra connection first; layers can be chosen in the review.",
)
.clicked()
{
self.device.prepare_send = true;
self.device.open = true;
ui.close_menu();
}
ui.menu_button("Export", |ui| self.export_menu(ui));
}
pub(super) fn export_menu(&mut self, ui: &mut egui::Ui) {
self.midra_apply_button(ui);
if ui.button("Configure Midra export…").clicked() {
self.device.prepare_send = true;
self.device.open = true;
ui.close_menu();
}
ui.separator();
ui.menu_button("Export SVG", |ui| {
self.transfer_layer_picker(ui, "Choose layers to export…");
ui.menu_button("Specific layer…", |ui| {
egui::ScrollArea::vertical()
.max_height(320.0)
.show(ui, |ui| {
for i in 0..self.layout.layers().len() {
let title = format!(
"{}{}",
self.layout.layer_label(i),
if self.layout.visible(i) {
""
} else {
" (hidden)"
}
);
if ui.button(title).clicked() {
ui.close_menu();
match self.project().to_svg_ids(&[self.layout.layer_info(i).id]) {
Ok(svg) => {
if let Some(path) = rfd::FileDialog::new()
.add_filter("SVG geometry", &["svg"])
.set_file_name("layer.svg")
.save_file()
{
self.queue_write(path, svg);
}
}
Err(e) => self.files.message = Some(e),
}
}
}
});
});
if ui
.add_enabled(
!self.layout.selected_indices().is_empty(),
egui::Button::new("Selected layers…"),
)
.clicked()
{
ui.close_menu();
let ids: Vec<_> = self
.layout
.selected_indices()
.iter()
.map(|i| self.layout.layer_info(*i).id)
.collect();
match self.project().to_svg_ids(&ids) {
Ok(svg) => {
if let Some(path) = rfd::FileDialog::new()
.add_filter("SVG geometry", &["svg"])
.set_file_name("selection.svg")
.save_file()
{
self.queue_write(path, svg);
}
}
Err(e) => self.files.message = Some(e),
}
}
for (title, visible_only) in [("All layers…", false), ("Visible layers only…", true)]
{
if ui.button(title).clicked() {
ui.close_menu();
match self.project().to_svg(visible_only) {
Ok(svg) => {
if let Some(path) = rfd::FileDialog::new()
.add_filter("SVG geometry", &["svg"])
.set_file_name("layout.svg")
.save_file()
{
self.queue_write(path, svg);
}
}
Err(e) => self.files.message = Some(e),
}
}
}
ui.small("Pixel-rounded layer boxes; use JSON to preserve crops and sources.");
});
}
pub(super) fn project_windows(&mut self, ctx: &egui::Context) {
if let Some((path, project)) = self.files.opening.take() {
let mut open = true;
let mut load = false;
let mut cancel = false;
egui::Window::new("Open project?").collapsible(false).open(&mut open).show(ctx,|ui| {
ui.label(path.display().to_string());
ui.label("Opening replaces the current work and undo history. Cancel and save the current project first if needed.");
ui.horizontal(|ui| {load=ui.button("Open project").clicked();cancel=ui.button("Cancel").clicked();});
});
if load {
self.files.message = Some(match self.install_project(ctx, project) {
Ok(()) => format!("Opened {}", path.display()),
Err(e) => format!("Cannot open project; current work kept: {e}"),
});
} else if open && !cancel {
self.files.opening = Some((path, project));
}
}
if let Some((path, contents)) = self.files.writing.take() {
let mut open = true;
let mut replace = false;
let mut cancel = false;
egui::Window::new("Replace existing file?")
.collapsible(false)
.open(&mut open)
.show(ctx, |ui| {
ui.label(path.display().to_string());
ui.horizontal(|ui| {
replace = ui.button("Replace file").clicked();
cancel = ui.button("Cancel").clicked();
});
});
if replace {
self.write_project_file(path, contents, true);
} else if open && !cancel {
self.files.writing = Some((path, contents));
}
}
if let Some(message) = self.files.message.take() {
let mut open = true;
let mut done = false;
egui::Window::new("Project file")
.collapsible(false)
.open(&mut open)
.show(ctx, |ui| {
ui.label(&message);
done = ui.button("OK").clicked();
});
if open && !done {
self.files.message = Some(message);
}
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn project_restores_reference_and_editor_and_failed_image_load_keeps_current_work() {
let ctx = egui::Context::default();
let mut app = Editor::default();
let mut bytes = std::io::Cursor::new(Vec::new());
image::RgbaImage::from_pixel(2, 2, image::Rgba([20, 50, 80, 255]))
.write_to(&mut bytes, image::ImageFormat::Png)
.unwrap();
let original_bytes = bytes.into_inner();
let file = egui::DroppedFile {
name: "guide.png".into(),
bytes: Some(original_bytes.clone().into()),
..Default::default()
};
app.load_reference(&ctx, &file);
app.wait_reference();
let reference = app.reference.as_mut().unwrap();
reference.opacity = 0.4;
reference.visible = false;
reference.preserve_ratio = true;
reference.native_size = true;
reference.offset = [-12.5, 34.25];
app.outline_layers = true;
app.zoom = 2.5;
app.pan = Vec2::new(-20.5, 40.0);
app.corner = Corner::BottomRight;
app.keep_aspect_ratio = false;
app.show_pattern = true;
app.show_toolbar_icon_names = true;
let project = Project::from_json(&app.project().to_json().unwrap()).unwrap();
let mut restored = Editor {
edit_content: true,
..Default::default()
};
let settings_dir = tempfile::tempdir().unwrap();
let settings_path = settings_dir.path().join("settings.json");
restored.settings = settings::Store::at(settings_path.clone()).0;
restored.device.host = "192.168.10.143".into();
restored.install_project(&ctx, project.clone()).unwrap();
assert_eq!(restored.device.host, "192.168.10.143");
assert_eq!(restored.settings.path.as_ref(), Some(&settings_path));
assert!(
!settings_path.exists(),
"opening a project must not save application defaults"
);
assert_eq!(restored.project(), project);
assert!(!restored.edit_content);
assert_eq!(restored.reference.as_ref().unwrap().bytes, original_bytes);
let mut broken = project.clone();
broken.output_resolution.width = 3000;
broken.reference.as_mut().unwrap().image_base64 = STANDARD.encode(b"not an image");
assert!(restored.install_project(&ctx, broken).is_err());
assert_eq!(restored.project(), project);
}
}
#[cfg(test)]
mod confirmation_tests {
use super::*;
use crate::gui::tests::{frame, mouse};
fn click_text(app: &mut Editor, ctx: &egui::Context, text: &str) {
frame(app, ctx, vec![]);
let output = frame(app, ctx, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::Shape::Text(t) if t.galley.text() == text => {
Some(t.pos + t.galley.size() / 2.0)
}
_ => None,
})
.expect("confirmation action rendered");
frame(
app,
ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(app, ctx, vec![mouse(pos, false)]);
}
#[test]
fn open_and_overwrite_confirmations_preserve_work_on_cancel() {
let mut app = Editor::default();
let ctx = egui::Context::default();
let original = app.project();
let mut next = original.clone();
next.output_resolution.width = 2560;
next.output_resolution.height = 1440;
app.files.opening = Some((PathBuf::from("candidate.midra.json"), next.clone()));
click_text(&mut app, &ctx, "Cancel");
assert_eq!(app.project(), original);
assert!(app.files.opening.is_none());
app.files.opening = Some((PathBuf::from("candidate.midra.json"), next.clone()));
click_text(&mut app, &ctx, "Open project");
assert_eq!(app.project(), next);
app.files.message = None;
let dir = tempfile::tempdir().unwrap();
let path = dir.path().join("existing.json");
std::fs::write(&path, b"old contents").unwrap();
app.queue_write(path.clone(), "new contents".into());
assert!(app.files.writing.is_some());
click_text(&mut app, &ctx, "Cancel");
assert_eq!(std::fs::read(&path).unwrap(), b"old contents");
app.queue_write(path.clone(), "new contents".into());
click_text(&mut app, &ctx, "Replace file");
assert_eq!(std::fs::read(&path).unwrap(), b"new contents");
}
}