651 lines
26 KiB
Rust
651 lines
26 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 {
|
|
pub(super) project_path: Option<PathBuf>,
|
|
pub(super) manual_saved_at: Option<u64>,
|
|
pub(super) new_requested: bool,
|
|
pub(super) new_after_save: bool,
|
|
pub(super) new_ready: bool,
|
|
opening: Option<(PathBuf, Project)>,
|
|
writing: Option<(PathBuf, String)>,
|
|
pub(super) message: Option<String>,
|
|
}
|
|
impl Editor {
|
|
pub(super) fn project(&self) -> Project {
|
|
let mut p = Project::from_layout(&self.layout);
|
|
p.editor.position_point = self.corner;
|
|
p.editor.position_layer_point = self.position_layer_point;
|
|
p.editor.backdrop_title = self.backdrop_title.clone();
|
|
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
|
|
}
|
|
pub(super) 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),
|
|
recovery: std::mem::take(&mut self.recovery),
|
|
snapping: self.snapping,
|
|
resize_mode: self.resize_mode,
|
|
grid_tool: self.grid_tool,
|
|
pivot_tool: self.pivot_tool,
|
|
navigation_tool: self.navigation_tool,
|
|
layout,
|
|
reference,
|
|
corner: e.position_point,
|
|
position_layer_point: e.position_layer_point,
|
|
backdrop_title: e.backdrop_title,
|
|
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(())
|
|
}
|
|
pub(super) 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);
|
|
} else {
|
|
self.files.new_after_save = false;
|
|
}
|
|
}
|
|
Err(e) => {
|
|
self.files.new_after_save = false;
|
|
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(()) => {
|
|
if contents.trim_start().starts_with('{') && Project::from_json(&contents).is_ok() {
|
|
self.files.project_path = Some(path.clone());
|
|
self.files.manual_saved_at = Some(recovery_ui::now_seconds());
|
|
if self.files.new_after_save {
|
|
self.files.new_ready = true;
|
|
self.files.new_after_save = false;
|
|
}
|
|
}
|
|
format!("Saved {}", path.display())
|
|
}
|
|
Err(e) => {
|
|
self.files.new_after_save = false;
|
|
format!("Could not save {}: {e}", path.display())
|
|
}
|
|
});
|
|
}
|
|
/// Persist only measurement choices; other unsaved edits remain in memory.
|
|
pub(super) fn autosave_position_points(&mut self) {
|
|
let Some(path) = self.files.project_path.as_ref() else {
|
|
return;
|
|
};
|
|
let result = (|| {
|
|
let mut saved = Project::read(path)?;
|
|
saved.editor.position_point = self.corner;
|
|
saved.editor.position_layer_point = self.position_layer_point;
|
|
write_file(path, saved.to_json()?.as_bytes(), true)
|
|
})();
|
|
if let Err(error) = result {
|
|
self.files.message = Some(format!(
|
|
"Could not autosave measurement points to {}: {error}. Selections remain active; use Save project to save them.",
|
|
path.display()
|
|
));
|
|
}
|
|
}
|
|
pub(super) fn project_menu(&mut self, ui: &mut egui::Ui) {
|
|
if ui
|
|
.add_enabled(!self.device.sending, egui::Button::new("New project…"))
|
|
.clicked()
|
|
{
|
|
self.files.new_requested = true;
|
|
ui.close_menu();
|
|
}
|
|
if let Some(error) = &self.recovery.error {
|
|
ui.colored_label(ui.visuals().error_fg_color, error);
|
|
}
|
|
if self.recovery.error.is_some() && ui.button("Retry recovery").clicked() {
|
|
if self.recovery.restore_failed {
|
|
if let Some(path) = self.recovery.path.clone() {
|
|
self.restore_recovery(ui.ctx(), path);
|
|
}
|
|
} else {
|
|
self.recovery.error = None;
|
|
self.autosave_recovery(true);
|
|
}
|
|
}
|
|
if let Some(path) = &self.recovery.path {
|
|
ui.small(if self.recovery.error.is_some() {
|
|
"Recovery autosave paused"
|
|
} else {
|
|
"Recovery autosave on · resumes on launch"
|
|
})
|
|
.on_hover_text(path.display().to_string());
|
|
}
|
|
ui.small(self.manual_save_age());
|
|
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.open_midra_export();
|
|
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);
|
|
self.midra_send_button(ui);
|
|
self.midra_load_button(ui, true);
|
|
if ui.button("Configure Midra export…").clicked() {
|
|
self.open_midra_export();
|
|
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, undo history and recovery autosave. Cancel and save a separate project first if needed.");
|
|
ui.label(self.manual_save_age());
|
|
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(()) => {
|
|
self.files.project_path = Some(path.clone());
|
|
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));
|
|
} else {
|
|
self.files.new_after_save = false;
|
|
}
|
|
}
|
|
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 new_after_save_requires_success_and_does_not_count_autosave() {
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let mut app = Editor::default();
|
|
app.files.new_after_save = true;
|
|
app.write_project_file(
|
|
dir.path().join("missing/layout.json"),
|
|
app.project().to_json().unwrap(),
|
|
false,
|
|
);
|
|
assert!(!app.files.new_ready);
|
|
assert!(!app.files.new_after_save);
|
|
assert!(app.files.manual_saved_at.is_none());
|
|
app.files.new_after_save = true;
|
|
app.write_project_file(
|
|
dir.path().join("layout.json"),
|
|
app.project().to_json().unwrap(),
|
|
false,
|
|
);
|
|
assert!(app.files.new_ready);
|
|
assert!(app.files.manual_saved_at.is_some());
|
|
let time = app.files.manual_saved_at;
|
|
app.autosave_position_points();
|
|
assert_eq!(app.files.manual_saved_at, time);
|
|
}
|
|
|
|
#[test]
|
|
fn measurement_clicks_autosave_only_points_and_exports_keep_project_target() {
|
|
use super::super::tests::{click_text, frame, mouse};
|
|
let ctx = egui::Context::default();
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("layout.json");
|
|
let mut app = Editor::default();
|
|
let saved = app.project();
|
|
app.write_project_file(path.clone(), saved.to_json().unwrap(), false);
|
|
assert_eq!(app.files.project_path.as_ref(), Some(&path));
|
|
app.files.message = None;
|
|
// Other local edits must not be silently saved with the point selection.
|
|
app.layout.nudge(15.0, 30.0).unwrap();
|
|
app.backdrop_title = "Unsaved title".into();
|
|
// Preserve unrelated changes already written by another editor as well.
|
|
let mut external = saved.clone();
|
|
external.editor.backdrop_title = "External title".into();
|
|
write_file(&path, external.to_json().unwrap().as_bytes(), true).unwrap();
|
|
app.sync();
|
|
frame(&mut app, &ctx, vec![]);
|
|
let output = frame(&mut app, &ctx, vec![]);
|
|
let pos = output
|
|
.shapes
|
|
.iter()
|
|
.find_map(|s| match &s.shape {
|
|
egui::Shape::Text(t) if t.galley.text() == "MEASURE POSITION FROM" => {
|
|
Some(t.pos + Vec2::new(84.0, 75.0))
|
|
}
|
|
_ => None,
|
|
})
|
|
.unwrap();
|
|
frame(
|
|
&mut app,
|
|
&ctx,
|
|
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
|
|
);
|
|
frame(&mut app, &ctx, vec![mouse(pos, false)]);
|
|
external.editor.position_point = PositionPoint::BottomRight;
|
|
assert_eq!(Project::read(&path).unwrap(), external);
|
|
click_text(&mut app, &ctx, "Use a different layer point");
|
|
external.editor.position_layer_point = Some(PositionPoint::BottomRight);
|
|
assert_eq!(Project::read(&path).unwrap(), external);
|
|
let output = frame(&mut app, &ctx, vec![]);
|
|
let pos = output
|
|
.shapes
|
|
.iter()
|
|
.find_map(|s| match &s.shape {
|
|
egui::Shape::Text(t) if t.galley.text() == "TO LAYER POINT" => {
|
|
Some(t.pos + Vec2::new(46.0, 49.0))
|
|
}
|
|
_ => None,
|
|
})
|
|
.unwrap();
|
|
frame(
|
|
&mut app,
|
|
&ctx,
|
|
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
|
|
);
|
|
frame(&mut app, &ctx, vec![mouse(pos, false)]);
|
|
external.editor.position_layer_point = Some(PositionPoint::Center);
|
|
assert_eq!(Project::read(&path).unwrap(), external);
|
|
click_text(&mut app, &ctx, "Use a different layer point");
|
|
external.editor.position_layer_point = None;
|
|
assert_eq!(Project::read(&path).unwrap(), external);
|
|
app.write_project_file(
|
|
dir.path().join("layout.svg"),
|
|
saved.to_svg(false).unwrap(),
|
|
false,
|
|
);
|
|
assert_eq!(app.files.project_path.as_ref(), Some(&path));
|
|
let mut reopened = Editor::default();
|
|
reopened
|
|
.install_project(&ctx, Project::read(&path).unwrap())
|
|
.unwrap();
|
|
assert_eq!(reopened.corner, PositionPoint::BottomRight);
|
|
assert_eq!(reopened.position_layer_point, None);
|
|
}
|
|
|
|
#[test]
|
|
fn point_autosave_requires_a_valid_existing_project_and_reports_failure() {
|
|
let mut app = Editor {
|
|
corner: PositionPoint::Center,
|
|
..Default::default()
|
|
};
|
|
app.autosave_position_points();
|
|
assert!(app.files.message.is_none());
|
|
let dir = tempfile::tempdir().unwrap();
|
|
let path = dir.path().join("broken.json");
|
|
std::fs::write(&path, "invalid project").unwrap();
|
|
app.files.project_path = Some(path.clone());
|
|
app.autosave_position_points();
|
|
assert!(
|
|
app.files
|
|
.message
|
|
.as_ref()
|
|
.unwrap()
|
|
.contains("Could not autosave")
|
|
);
|
|
assert_eq!(std::fs::read_to_string(&path).unwrap(), "invalid project");
|
|
assert_eq!(app.corner, PositionPoint::Center);
|
|
std::fs::remove_file(&path).unwrap();
|
|
app.autosave_position_points();
|
|
assert!(!path.exists());
|
|
}
|
|
|
|
#[test]
|
|
fn opening_project_preserves_session_resize_choice() {
|
|
let ctx = egui::Context::default();
|
|
for mode in [ResizeMode::Same, ResizeMode::Mirror, ResizeMode::Opposite] {
|
|
let mut app = Editor {
|
|
resize_mode: mode,
|
|
grid_tool: Some(100),
|
|
pivot_tool: true,
|
|
navigation_tool: NavigationTool::Pan,
|
|
..Default::default()
|
|
};
|
|
app.install_project(&ctx, Project::from_layout(&Layout::default()))
|
|
.unwrap();
|
|
assert_eq!(app.resize_mode, mode);
|
|
assert_eq!(app.grid_tool, Some(100));
|
|
assert!(app.pivot_tool);
|
|
assert_eq!(app.navigation_tool, NavigationTool::Pan);
|
|
assert_eq!(app.active_resize_mode(), ResizeMode::Individual);
|
|
app.layout.set_selection([true; 2]);
|
|
app.sync();
|
|
assert_eq!(app.active_resize_mode(), mode);
|
|
}
|
|
}
|
|
|
|
#[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 = PositionPoint::TopLeft;
|
|
app.position_layer_point = Some(PositionPoint::Center);
|
|
app.backdrop_title = "Conference 2027 · Main stage".into();
|
|
app.keep_aspect_ratio = false;
|
|
app.show_pattern = true;
|
|
app.show_toolbar_icon_names = true;
|
|
app.layout
|
|
.set_layer_pivots(&[(0, [-0.25, 0.75]), (1, [0.1, 0.9])])
|
|
.unwrap();
|
|
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_eq!(restored.pivot_for(0), [-0.25, 0.75]);
|
|
assert_eq!(restored.pivot_for(1), [0.1, 0.9]);
|
|
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");
|
|
}
|
|
}
|