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

3111 lines
119 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

use super::*;
#[path = "format_ui.rs"]
mod format_ui;
use format_ui::{FormatDraft, OutputDraft};
use midra_layout::import::{DetectedShape, ImportDocument, parse_svg, parse_values};
use midra_layout::{AlignTarget, Alignment, Corner, Geometry, Layout, ResizeHandle, ResizeMode};
pub struct Editor {
layout: Layout,
corner: Corner,
fields: [String; 4],
error: String,
paste: Option<Paste>,
zoom: f32,
camera_one_to_one: bool,
pan: Vec2,
panning: bool,
marquee: Option<Marquee>,
align_target: AlignTarget,
keep_aspect_ratio: bool,
resize_mode: ResizeMode,
format_draft: Option<FormatDraft>,
output_draft: Option<OutputDraft>,
edit_content: bool,
show_pattern: bool,
reference: Option<super::reference::Reference>,
reference_open: bool,
reference_error: String,
}
#[derive(Clone, Copy)]
struct Marquee {
start: [f64; 2],
end: [f64; 2],
base: [bool; 2],
previous: [bool; 2],
}
struct Paste {
targets: Vec<usize>,
text: String,
shapes: Vec<DetectedShape>,
mapping: Vec<Option<usize>>,
ignored: Vec<bool>,
svg: bool,
note: String,
include_size: bool,
include_position: bool,
include_zoom: bool,
include_outline: bool,
error: String,
}
impl Paste {
fn set_document(&mut self, doc: ImportDocument) {
self.shapes = doc.shapes;
self.svg = doc.svg;
self.note = doc.note;
self.ignored = vec![false; self.shapes.len()];
self.reset_mapping();
self.error.clear();
}
fn reset_mapping(&mut self) {
let mut targets = self.targets.iter();
self.mapping = self
.ignored
.iter()
.map(|ignored| {
if *ignored {
None
} else {
targets.next().copied()
}
})
.collect();
}
fn parse(&mut self) {
match parse_values(&self.text) {
Ok(doc) => self.set_document(doc),
Err(e) => {
self.shapes.clear();
self.mapping.clear();
self.ignored.clear();
self.error = e;
}
}
}
fn zoom_available(&self) -> bool {
self.shapes
.iter()
.zip(&self.ignored)
.any(|(s, ignored)| !ignored && s.zoom.is_some())
}
fn geometry(&self, shape: &DetectedShape, before: Geometry) -> Result<Geometry, String> {
let mut g = shape.paste_geometry(before, self.include_size, self.include_outline)?;
if !self.include_position {
g.x = before.x;
g.y = before.y;
}
Ok(g)
}
fn apply(&self, layout: &mut Layout) -> Result<(), String> {
let values = self.values(layout)?;
let zooms: Vec<_> = if self.include_zoom {
self.shapes
.iter()
.enumerate()
.filter_map(|(row, s)| {
if self.ignored[row] {
None
} else {
s.zoom.map(|zoom| (self.mapping[row].unwrap(), zoom))
}
})
.collect()
} else {
Vec::new()
};
layout.apply_import_with_zoom(&values, &zooms)
}
fn values(&self, layout: &Layout) -> Result<Vec<(usize, Geometry)>, String> {
if !self.include_size
&& !self.include_position
&& !(self.include_zoom && self.zoom_available())
{
return Err(
"Choose at least one available value to paste: format, position or zoom.".into(),
);
}
let count = self.ignored.iter().filter(|v| !**v).count();
if count != self.targets.len() {
return Err(format!(
"Layer count mismatch: {} selected, {} detected ({} excluded). Select {} destination layer(s), or supply {} rectangle(s).",
self.targets.len(),
count,
self.shapes.len() - count,
count,
self.targets.len()
));
}
if layout.selected_indices() != self.targets {
return Err(
"Selection changed. Close this review and import again for the current selection."
.into(),
);
}
let mut values = Vec::new();
for (row, shape) in self.shapes.iter().enumerate() {
if self.ignored[row] {
continue;
}
let target =
self.mapping[row].ok_or("Choose a destination for each detected rectangle.")?;
if !self.targets.contains(&target) || values.iter().any(|(i, _)| *i == target) {
return Err("Each selected layer must be mapped exactly once; choose a different destination for duplicate mappings.".into());
}
values.push((target, self.geometry(shape, layout.layers()[target])?));
}
Ok(values)
}
}
impl Default for Editor {
fn default() -> Self {
let mut this = Self {
layout: Layout::default(),
corner: Corner::TopRight,
fields: Default::default(),
error: String::new(),
paste: None,
zoom: 1.0,
camera_one_to_one: false,
pan: Vec2::ZERO,
panning: false,
marquee: None,
align_target: AlignTarget::Selection,
keep_aspect_ratio: true,
resize_mode: ResizeMode::Individual,
format_draft: None,
output_draft: None,
edit_content: false,
show_pattern: false,
reference: None,
reference_open: false,
reference_error: String::new(),
};
this.sync();
this
}
}
fn number(n: f64) -> String {
midra_layout::view_pixels(n)
}
fn label(i: usize) -> &'static str {
if i == 0 {
"01 / Presenter"
} else {
"02 / Slides"
}
}
fn bounds(g: Geometry) -> String {
format!(
"X {} · Y {}\n{} × {} px",
number(g.x),
number(g.y),
number(g.width),
number(g.height)
)
}
impl Editor {
fn load_reference(&mut self, ctx: &egui::Context, file: &egui::DroppedFile) {
match super::reference::Reference::load(ctx, file) {
Ok(reference) => {
self.reference = Some(reference);
self.reference_error.clear();
}
Err(error) => self.reference_error = error,
}
}
fn import_reference_file(&mut self, ctx: &egui::Context) {
if let Some(path) = rfd::FileDialog::new()
.add_filter("Pictures", &["png", "jpg", "jpeg", "bmp"])
.pick_file()
{
self.load_reference(
ctx,
&egui::DroppedFile {
path: Some(path),
..Default::default()
},
);
}
}
fn reference_window(&mut self, ctx: &egui::Context) {
let mut open = self.reference_open;
egui::Window::new("Reference image")
.open(&mut open)
.default_width(420.0)
.show(ctx, |ui| {
if ui.button("Import picture…").clicked() {
self.import_reference_file(ctx);
}
ui.label("Or drag one PNG, JPEG or BMP into the window.");
let mut remove = false;
if let Some(reference) = &mut self.reference {
ui.label(format!(
"{} · {} × {} px",
reference.name, reference.size[0], reference.size[1]
));
ui.checkbox(&mut reference.visible, "Show reference");
ui.add(egui::Slider::new(&mut reference.opacity, 0.0..=1.0).text("Opacity"));
ui.radio_value(
&mut reference.preserve_ratio,
false,
"Fill screen (stretch if needed)",
);
ui.radio_value(
&mut reference.preserve_ratio,
true,
"Fit inside (preserve proportions)",
);
if let Some((severe, warning)) = reference.warning(self.layout.formats().output)
{
ui.colored_label(if severe { Color32::LIGHT_RED } else { AMBER }, warning);
}
remove = ui.button("Remove reference").clicked();
}
if remove {
self.reference = None;
self.reference_error.clear();
}
if !self.reference_error.is_empty() {
ui.colored_label(Color32::LIGHT_RED, &self.reference_error);
}
ui.label("Reference stays fixed behind layers. Warnings never block placement.");
});
self.reference_open = open;
}
fn sync(&mut self) {
if self.layout.selected_indices().len() < 2 {
self.resize_mode = ResizeMode::Individual;
}
if let Some(i) = self.layout.selected() {
let g = self.layout.layers()[i];
let [x, y] = self.corner.offsets_on(g, self.layout.formats().output);
self.fields = [number(x), number(y), number(g.width), number(g.height)];
}
self.error = self.layout.gesture_error.clone().unwrap_or_default();
if self.format_draft.is_some() {
self.format_draft = self
.layout
.selected()
.map(|i| FormatDraft::new(&self.layout, i));
}
}
fn open_paste(&mut self, text: String) {
let targets = self.layout.selected_indices();
if targets.is_empty() {
self.error = "Select one or more destination layers before importing values.".into();
return;
}
let mut p = Paste {
targets,
text,
shapes: Vec::new(),
mapping: Vec::new(),
ignored: Vec::new(),
svg: false,
note: String::new(),
include_size: true,
include_position: true,
include_zoom: true,
include_outline: false,
error: String::new(),
};
if !p.text.is_empty() {
p.parse();
}
self.paste = Some(p);
}
fn import_svg_file(&mut self) {
if self.layout.selected_indices().is_empty() {
self.error = "Select one or more destination layers before importing SVG.".into();
return;
}
if let Some(path) = rfd::FileDialog::new()
.add_filter("SVG", &["svg"])
.pick_file()
{
self.open_paste(String::new());
if let Some(p) = self.paste.as_mut() {
Self::read_svg(&path, p);
}
}
}
fn read_svg(path: &std::path::Path, p: &mut Paste) {
use std::io::Read;
let result = (|| {
let mut text = String::new();
std::fs::File::open(path)
.map_err(|e| format!("Cannot open SVG: {e}"))?
.take(1_048_577)
.read_to_string(&mut text)
.map_err(|e| format!("Cannot read SVG: {e}"))?;
let doc = parse_svg(&text)?;
p.text = text;
Ok(doc)
})();
match result {
Ok(doc) => p.set_document(doc),
Err(e) => {
p.shapes.clear();
p.error = e;
}
}
}
fn apply_fields(&mut self) {
let values: Result<Vec<f64>, _> = self
.fields
.iter()
.map(|s| s.trim().parse::<f64>())
.collect();
let result = values
.map_err(|_| "Enter a number in each field.".to_string())
.and_then(|mut v| {
if let Some(i) = self.layout.selected() {
let g = self.layout.layers()[i];
let [x, y] = self.corner.offsets_on(g, self.layout.formats().output);
let original = [x, y, g.width, g.height];
for j in 0..4 {
if self.fields[j] == number(original[j]) {
v[j] = original[j];
}
}
// Linked numeric fields are displayed rounded, but keep the
// original aspect when only one dimension drives the edit.
if self.keep_aspect_ratio {
if v[2] != g.width && self.fields[3] == number(v[2] * g.height / g.width) {
v[3] = v[2] * g.height / g.width;
} else if v[3] != g.height
&& self.fields[2] == number(v[3] * g.width / g.height)
{
v[2] = v[3] * g.width / g.height;
}
}
}
self.corner
.geometry_on(v[0], v[1], v[2], v[3], self.layout.formats().output)
.map(|mut geometry| {
if let Some(i) = self.layout.selected() {
let old = self.layout.layers()[i];
let offsets = self.corner.offsets_on(old, self.layout.formats().output);
if v[0] == offsets[0] && geometry.width == old.width {
geometry.x = old.x;
}
if v[1] == offsets[1] && geometry.height == old.height {
geometry.y = old.y;
}
}
geometry
})
});
match result {
Ok(g) => {
if let Some(i) = self.layout.selected() {
match self.layout.apply(i, g) {
Ok(()) => self.sync(),
Err(e) => self.error = e,
}
}
}
Err(e) => self.error = e,
}
}
fn copy(&self, ctx: &egui::Context) {
let entries: Vec<_> = self
.layout
.selected_indices()
.into_iter()
.map(|i| {
let g = self.layout.layers()[i];
let [h, v] = g.center();
format!(
"{} — visible box (device container unverified)\nHorizontal: {} px\nVertical: {} px\nWidth: {} px\nHeight: {} px\nCrop zoom: {} %",
label(i),
midra_layout::export_pixels(h),
midra_layout::export_pixels(v),
midra_layout::export_pixels(g.width),
midra_layout::export_pixels(g.height),
number(self.layout.formats().mapping(i, g).unwrap().framing.zoom * 100.0)
)
})
.collect();
if !entries.is_empty() {
ctx.copy_text(entries.join("\n\n"));
}
}
fn shortcuts(&mut self, ctx: &egui::Context) {
if self.paste.is_some() {
return;
}
if ctx.input(|i| i.key_pressed(egui::Key::Escape)) {
self.edit_content = false;
self.resize_mode = ResizeMode::Individual;
self.layout.cancel_drag();
if let Some(m) = self.marquee.take() {
self.layout.set_selection(m.previous);
}
self.sync();
ctx.memory_mut(|m| {
if let Some(id) = m.focused() {
m.surrender_focus(id);
}
});
return;
}
if ctx.wants_keyboard_input() {
return;
}
let paste = ctx.input_mut(|i| {
let mut pasted = None;
i.events.retain(|e| {
if let egui::Event::Paste(s) = e {
pasted = Some(s.clone());
false
} else {
true
}
});
pasted
});
if let Some(text) = paste {
self.open_paste(text);
return;
}
if self.layout.dragging() || self.marquee.is_some() || self.panning {
return;
}
if ctx.input(|i| i.events.iter().any(|e| matches!(e, egui::Event::Copy))) {
self.copy(ctx);
return;
}
let command = ctx.input(|i| i.modifiers.command);
if command {
if ctx.input(|i| i.key_pressed(egui::Key::Z)) {
if ctx.input(|i| i.modifiers.shift) {
self.layout.redo();
} else {
self.layout.undo();
}
self.sync();
} else if ctx.input(|i| i.key_pressed(egui::Key::Y)) {
self.layout.redo();
self.sync();
}
return;
}
let step = if ctx.input(|i| i.modifiers.shift) {
10.0
} else {
1.0
};
let mut d = [0.0, 0.0];
for (key, axis, sign) in [
(egui::Key::ArrowLeft, 0, -1.0),
(egui::Key::ArrowRight, 0, 1.0),
(egui::Key::ArrowUp, 1, -1.0),
(egui::Key::ArrowDown, 1, 1.0),
] {
if ctx.input(|i| i.key_pressed(key)) {
d[axis] += sign * step;
}
}
if d != [0.0, 0.0] {
let result = if self.edit_content
&& let Some(i) = self.layout.selected()
{
let g = self.layout.layers()[i];
self.layout.formats().mapping(i, g).and_then(|m| {
let offset = std::array::from_fn(|axis| {
(m.framing.offset[axis] + d[axis])
.clamp(-m.offset_limits[axis], m.offset_limits[axis])
});
self.layout.set_framing(
i,
midra_layout::formats::Framing {
zoom: m.framing.zoom,
offset,
},
)
})
} else {
self.layout.nudge(d[0], d[1])
};
match result {
Ok(()) => self.sync(),
Err(e) => self.error = e,
}
}
}
fn paste_window(&mut self, ctx: &egui::Context) {
let Some(mut p) = self.paste.take() else {
return;
};
let mut close = false;
let response=egui::Modal::new(egui::Id::new("layer-values-import")).show(ctx,|ui| {
ui.set_width(600.0);
ui.heading("Paste layer(s) values");
ui.label(format!("Selected destinations: {}",p.targets.iter().map(|i|label(*i)).collect::<Vec<_>>().join(", ")));
ui.label("Paste Midra Layout values, draw.io clipboard data or SVG XML, or import SVG.");
egui::ScrollArea::vertical().max_height((ctx.screen_rect().height()-360.0).max(150.0)).show(ui,|ui| {
if ui.add(egui::TextEdit::multiline(&mut p.text).desired_rows(3).desired_width(f32::INFINITY)).changed() {p.shapes.clear();p.error.clear();}
ui.horizontal(|ui| {
if ui.button("Read geometry").clicked() {p.parse();}
if ui.button("Import SVG…").clicked() && let Some(path)=rfd::FileDialog::new().add_filter("SVG", &["svg"]).pick_file() {Self::read_svg(&path,&mut p);}
});
if !p.error.is_empty() {ui.colored_label(AMBER,&p.error);}
if p.shapes.is_empty() {return;}
ui.label(&p.note);
ui.horizontal(|ui| {
ui.checkbox(&mut p.include_size,"Format (width / height)");
ui.checkbox(&mut p.include_position,"Position");
let available=p.zoom_available();
let mut zoom=p.include_zoom && available;
if ui.add_enabled(available,egui::Checkbox::new(&mut zoom,"Crop zoom")).changed() {p.include_zoom=zoom;}
});
if !p.zoom_available() {ui.small("Crop zoom is not included in this data.");}
ui.small("Unchecked values keep the destination settings. Format changes may adjust existing crops to fit.");
ui.add_enabled(p.include_size && p.shapes.iter().any(|s|s.outline.iter().any(|v|*v>0.0)),egui::Checkbox::new(&mut p.include_outline,"Include outline in bounds"));
ui.small("Source format, crop offsets, colors and outline appearance are not imported.");
if !p.include_size {ui.small("Outline adjustment requires Format. Position uses the source top-left when enabled.");}
ui.separator();
ui.strong("Detected rectangles / destination layers");
let mut reset_mapping=false;
for row in 0..p.shapes.len() {
let shape=p.shapes[row].clone();
ui.push_id(row,|ui| {
ui.label(format!("{} · {}",row+1,shape.id));
ui.small(bounds(shape.geometry));
if let Some(zoom)=shape.zoom {ui.small(format!("Crop zoom: {:.1}%{}",zoom*100.0,if p.include_zoom { " (will apply)" } else { " (not applied)" }));}
else if p.include_zoom && p.zoom_available() {ui.small("No crop zoom in this rectangle; destination zoom is retained.");}
if p.svg && shape.background {
reset_mapping|=ui.checkbox(&mut p.ignored[row],"Ignore full-page background").changed();
}
if !p.ignored[row] {
egui::ComboBox::from_id_salt("destination").selected_text(p.mapping[row].map(label).unwrap_or("Choose destination…")).show_ui(ui,|ui| {
for target in &p.targets {ui.selectable_value(&mut p.mapping[row],Some(*target),label(*target));}
});
if let Some(target)=p.mapping[row] {
let before=self.layout.layers()[target];
if let Ok(after)=p.geometry(&shape,before) {
ui.columns(2,|cols| {cols[0].label("Before");cols[0].small(bounds(before));cols[1].label("After");cols[1].small(bounds(after));});
if after.outside_on(self.layout.formats().output) {ui.colored_label(AMBER,"Outside the screen; imported coordinates will be preserved.");}
}
}
}
ui.separator();
});
}
if reset_mapping {p.reset_mapping();}
});
if !p.shapes.is_empty() {
let mut preview=self.layout.clone();
let valid=p.apply(&mut preview);
if let Err(e)=&valid {ui.colored_label(AMBER,e);}
if ui.add_enabled(valid.is_ok(),egui::Button::new("Apply mapped values").fill(PURPLE)).clicked() {
match p.apply(&mut self.layout) {Ok(())=>{self.sync();close=true;},Err(e)=>p.error=e}
}
}
if ui.button("Cancel").clicked() {close=true;}
});
if !close && !response.should_close() {
self.paste = Some(p);
}
}
fn inspector(&mut self, ui: &mut egui::Ui) {
let (r, _) = ui.allocate_exact_size(
Vec2::new(ui.available_width(), 1060.0),
egui::Sense::hover(),
);
let ink = Ink::new(ui, r);
let w = r.width();
ink.text(0.0, 2.0, "LAYERS", 11.0, MUTED);
for i in 0..2 {
let y = 28.0 + i as f32 * 44.0;
let color = if self.layout.selection_mask()[i] {
AMBER
} else {
MUTED
};
ink.card(
0.0,
y,
w,
38.0,
FIELD,
if self.layout.selection_mask()[i] {
color
} else {
LINE
},
);
ink.text(
13.0,
y + 10.0,
label(i),
15.0,
if self.layout.visible(i) { color } else { MUTED },
);
if click(ui, &ink, [0.0, y, w - 136.0, 38.0], ("layer", i)) {
if click_shift_modifier(ui) {
self.layout.toggle(i);
} else {
self.layout.select(Some(i));
}
self.sync();
}
for (kind, x, active, text) in [
(
"lock",
w - 130.0,
self.layout.locked(i),
if self.layout.locked(i) {
"Locked"
} else {
"Lock"
},
),
(
"visibility",
w - 64.0,
!self.layout.visible(i),
if self.layout.visible(i) {
"Hide"
} else {
"Show"
},
),
] {
ink.card(
x,
y + 5.0,
60.0,
28.0,
if active { PURPLE } else { PANEL },
LINE,
);
ink.text(x + 8.0, y + 12.0, text, 12.0, TEXT);
if click(ui, &ink, [x, y + 5.0, 60.0, 28.0], (kind, i)) {
self.marquee = None;
if kind == "lock" {
self.layout.set_locked(i, !active);
} else {
self.layout.set_visible(i, active);
}
self.sync();
}
}
}
ink.line([0.0, 130.0], [w, 130.0], LINE);
if self.layout.selected_indices().len() > 1 {
self.alignment_inspector(ui, &ink, w);
return;
}
let Some(i) = self.layout.selected() else {
ink.text(
0.0,
153.0,
"Select a layer, or drag a selection box.",
16.0,
TEXT,
);
ink.text(
0.0,
182.0,
"Shift-click to add or remove layers.",
13.0,
MUTED,
);
return;
};
let g = self.layout.layers()[i];
ink.text(0.0, 150.0, label(i), 25.0, TEXT);
ink.text(
0.0,
191.0,
"LAYER RESOLUTION · CLICK FOR LAYER PROPERTIES",
11.0,
MUTED,
);
ink.card(0.0, 214.0, w, 34.0, FIELD, LINE);
ink.text(
12.0,
223.0,
&format!(
"{} × {} px / {:.1}:1",
number(g.width),
number(g.height),
g.width / g.height
),
13.0,
TEXT,
);
if click(ui, &ink, [0.0, 214.0, w, 34.0], "open-formats") {
self.format_draft = Some(FormatDraft::new(&self.layout, i));
}
if let Ok(m) = self.layout.formats().mapping(i, g) {
ink.text(
0.0,
251.0,
&format!(
"Input {} · content {:.1}% · offset {:.1}, {:.1}",
self.layout.formats().source_for[i] + 1,
m.framing.zoom * 100.0,
m.framing.offset[0],
m.framing.offset[1]
),
11.0,
MUTED,
);
}
let edit_label = if self.edit_content {
"Done adjusting crop"
} else {
"Adjust layer crop"
};
ink.button(0.0, 275.0, w, edit_label, self.edit_content);
if click(ui, &ink, [0.0, 275.0, w, 34.0], "edit-layer-content") {
self.edit_content = !self.edit_content;
}
ui.put(
Rect::from_min_size(ink.point(0.0, 317.0), Vec2::new(w, 48.0)),
egui::Label::new(egui::RichText::new(
"Changes the crop values inside this layer. Drag content to reposition it; the visible box stays fixed."
).size(12.0).color(MUTED)).wrap().halign(egui::Align::Min),
);
let ink = Ink::new(ui, r.translate(Vec2::new(0.0, 108.0)));
ink.text(0.0, 267.0, "POSITION FROM SCREEN CORNER", 11.0, MUTED);
ink.card(0.0, 292.0, 94.0, 58.0, FIELD, LINE);
for (x, y, c) in [
(8.0, 300.0, Corner::TopLeft),
(84.0, 300.0, Corner::TopRight),
(8.0, 342.0, Corner::BottomLeft),
(84.0, 342.0, Corner::BottomRight),
] {
ink.rect(
x - 3.0,
y - 3.0,
6.0,
6.0,
if c == self.corner { CYAN } else { MUTED },
);
if click(
ui,
&ink,
[x - 10.0, y - 10.0, 20.0, 20.0],
format!("corner-{c:?}"),
) {
self.corner = c;
self.sync();
}
}
let (name, horizontal, vertical) = match self.corner {
Corner::TopLeft => ("Top left", "From left", "From top"),
Corner::TopRight => ("Top right", "From right", "From top"),
Corner::BottomLeft => ("Bottom left", "From left", "From bottom"),
Corner::BottomRight => ("Bottom right", "From right", "From bottom"),
};
ink.text(112.0, 299.0, name, 18.0, TEXT);
ink.text(112.0, 326.0, "Offsets inward · px", 12.0, MUTED);
let half = (w - 12.0) / 2.0;
let mut enter = false;
for (index, x, y, title) in [
(0, 0.0, 368.0, horizontal),
(1, half + 12.0, 368.0, vertical),
(2, 0.0, 449.0, "Layer width"),
(3, half + 12.0, 449.0, "Layer height"),
] {
ink.text(x, y, title, 12.0, MUTED);
let rect = Rect::from_min_size(ink.point(x, y + 23.0), Vec2::new(half, 42.0));
let response = ui.put(
rect,
egui::TextEdit::singleline(&mut self.fields[index])
.id(egui::Id::new(("geometry", index)))
.font(egui::FontId::proportional(18.0))
.margin(Vec2::new(12.0, 10.0)),
);
if response.changed()
&& self.keep_aspect_ratio
&& index >= 2
&& let Ok(value) = self.fields[index].parse::<f64>()
&& value.is_finite()
&& value > 0.0
{
let other = if index == 2 {
value * g.height / g.width
} else {
value * g.width / g.height
};
self.fields[if index == 2 { 3 } else { 2 }] = number(other);
}
if response.lost_focus() && ui.input(|i| i.key_pressed(egui::Key::Enter)) {
enter = true;
}
}
ink.button(0.0, 530.0, w, "Apply position / size", false);
if click(ui, &ink, [0.0, 530.0, w, 34.0], "apply-fields") || enter {
self.apply_fields();
}
if !self.error.is_empty() {
ui.put(
Rect::from_min_size(ink.point(0.0, 575.0), Vec2::new(w, 55.0)),
egui::Label::new(egui::RichText::new(&self.error).color(AMBER)).wrap(),
);
} else if g.outside_on(self.layout.formats().output) {
ink.text(
0.0,
579.0,
"Outside screen · use Fit selected to find it",
12.0,
AMBER,
);
}
ink.line([0.0, 612.0], [w, 612.0], LINE);
ink.text(0.0, 635.0, "VISIBLE BOX / CENTER POSITION", 11.0, CYAN);
let [h, v] = g.center();
ink.field(0.0, 665.0, half, "Horizontal · from left", &number(h));
ink.field(half + 12.0, 665.0, half, "Vertical · from top", &number(v));
ink.text(
0.0,
748.0,
"Layer properties: crops / provisional device mapping",
12.0,
MUTED,
);
ink.button(0.0, 780.0, w, "Copy position values", true);
if click(ui, &ink, [0.0, 780.0, w, 34.0], "copy-values") {
self.copy(ui.ctx());
}
ink.button(0.0, 829.0, w, "Paste layer(s) values", false);
if click(ui, &ink, [0.0, 829.0, w, 34.0], "paste-button") {
self.open_paste(String::new());
}
ink.text(
0.0,
884.0,
"Or Ctrl/Cmd-V with the viewport focused",
12.0,
MUTED,
);
}
fn alignment_menu(&mut self, ui: &mut egui::Ui) {
ui.set_min_width(222.0);
ui.label("ALIGN TO");
if self.align_target == AlignTarget::Screen {
self.align_target = AlignTarget::Selection;
}
let single_layer = self.layout.selected_indices().len() == 1;
let default_name = if single_layer {
"Screen (one selected layer)"
} else {
"Selected layers"
};
let target_name = |target| match target {
AlignTarget::Layer(i) => format!(
"Layer {}: {}",
i + 1,
label(i).split(" / ").last().unwrap_or(label(i))
),
_ => default_name.to_owned(),
};
egui::ComboBox::from_id_salt("alignment-target")
.width(210.0)
.selected_text(target_name(self.align_target))
.show_ui(ui, |ui| {
ui.selectable_value(&mut self.align_target, AlignTarget::Selection, default_name);
for i in 0..self.layout.layers().len() {
ui.selectable_value(
&mut self.align_target,
AlignTarget::Layer(i),
target_name(AlignTarget::Layer(i)),
);
}
});
ui.add_space(8.0);
let (grid, _) = ui.allocate_exact_size(Vec2::new(172.0, 128.0), egui::Sense::hover());
ui.add_enabled_ui(!self.layout.selected_indices().is_empty(), |ui| {
use Alignment::{Bottom, HorizontalCenter, Left, Right, Top, VerticalCenter};
for (col, row, title, horizontal, vertical) in [
(0, 0, "Align top left", Some(Left), Some(Top)),
(1, 0, "Align top", None, Some(Top)),
(2, 0, "Align top right", Some(Right), Some(Top)),
(0, 1, "Align left", Some(Left), None),
(
1,
1,
"Center both axes",
Some(HorizontalCenter),
Some(VerticalCenter),
),
(2, 1, "Align right", Some(Right), None),
(0, 2, "Align bottom left", Some(Left), Some(Bottom)),
(1, 2, "Align bottom", None, Some(Bottom)),
(2, 2, "Align bottom right", Some(Right), Some(Bottom)),
(3, 0, "Center horizontally", Some(HorizontalCenter), None),
(3, 2, "Center vertically", None, Some(VerticalCenter)),
] {
let rect = Rect::from_min_size(
grid.min + Vec2::new(col as f32 * 44.0, row as f32 * 44.0),
Vec2::splat(40.0),
);
if alignment_icon(ui, rect, title, horizontal, vertical).clicked() {
let axes: Vec<_> = [horizontal, vertical].into_iter().flatten().collect();
let target = if self.align_target == AlignTarget::Selection && single_layer {
AlignTarget::Screen
} else {
self.align_target
};
match self.layout.align_axes(&axes, target) {
Ok(()) => {
self.sync();
ui.close_menu();
}
Err(e) => self.error = e,
}
}
}
});
ui.small("Moves selected layers; keeps their sizes.");
if self.layout.selected_indices().is_empty() {
ui.label("Select layers to align.");
}
if !self.error.is_empty() {
ui.colored_label(AMBER, &self.error);
}
}
fn alignment_inspector(&mut self, ui: &mut egui::Ui, ink: &Ink, w: f32) {
ink.text(0.0, 150.0, "2 layers selected", 25.0, TEXT);
ink.text(
0.0,
187.0,
"Drag or nudge to move the selection together.",
12.0,
MUTED,
);
ink.text(
0.0,
225.0,
"Use the toolbar alignment menu to align layers.",
12.0,
MUTED,
);
ui.scope_builder(
egui::UiBuilder::new().max_rect(Rect::from_min_size(
ink.point(0.0, 254.0),
Vec2::new(w, 34.0),
)),
|ui| {
egui::ComboBox::from_id_salt("resize-selected-mode")
.width(w - 12.0)
.selected_text(match self.resize_mode {
ResizeMode::Individual => "Resize: individual layer",
ResizeMode::Same => "Same handles",
ResizeMode::Mirror => "Mirror horizontally",
ResizeMode::Opposite => "Opposite handles",
})
.show_ui(ui, |ui| {
ui.selectable_value(
&mut self.resize_mode,
ResizeMode::Individual,
"Resize: individual layer",
);
ui.selectable_value(
&mut self.resize_mode,
ResizeMode::Same,
"Same handles",
);
ui.add_enabled_ui(self.layout.selected_indices().len() == 2, |ui| {
ui.selectable_value(
&mut self.resize_mode,
ResizeMode::Mirror,
"Mirror horizontally (two layers)",
);
ui.selectable_value(
&mut self.resize_mode,
ResizeMode::Opposite,
"Opposite handles (two layers)",
);
});
});
},
);
ui.put(Rect::from_min_size(ink.point(0.0, 292.0), Vec2::new(w, 52.0)), egui::Label::new(egui::RichText::new(
match self.resize_mode {
ResizeMode::Individual => "Choose a shared resize mode, then drag a selected layer's handle to resize the selection.",
ResizeMode::Same => "Matching handles, equal proportional scaling. Drag any selected handle. Escape exits.",
ResizeMode::Mirror => "Left/right mirrored handles, equal proportional scaling. Two layers. Escape exits.",
ResizeMode::Opposite => "Diagonally opposite corners, equal proportional scaling. Two layers. Escape exits.",
}
).size(12.0).color(MUTED)).wrap().halign(egui::Align::Min));
let shifted = Ink {
painter: ink.painter.clone(),
origin: ink.origin + Vec2::new(0.0, 42.0),
scale: ink.scale,
};
let ink = &shifted;
ink.line([0.0, 319.0], [w, 319.0], LINE);
ink.text(0.0, 341.0, "VISIBLE BOX / CENTER POSITIONS", 11.0, CYAN);
for (row, i) in self.layout.selected_indices().into_iter().enumerate() {
let y = 375.0 + row as f32 * 80.0;
let [x, cy] = self.layout.layers()[i].center();
ink.text(0.0, y, label(i), 13.0, MUTED);
ink.text(
0.0,
y + 25.0,
&format!("H {} V {}", number(x), number(cy)),
19.0,
TEXT,
);
}
ink.button(0.0, 552.0, w, "Copy selected positions", true);
if click(ui, ink, [0.0, 552.0, w, 34.0], "copy-selected") {
self.copy(ui.ctx());
}
ink.text(
0.0,
609.0,
"Numeric edits require one selected layer.",
12.0,
MUTED,
);
if !self.error.is_empty() {
ui.put(
Rect::from_min_size(ink.point(0.0, 640.0), Vec2::new(w, 60.0)),
egui::Label::new(egui::RichText::new(&self.error).color(AMBER)).wrap(),
);
}
}
fn content_hit(&self, pointer: Pos2, origin: Pos2, scale: f32) -> Option<usize> {
if !self.edit_content {
return None;
}
let i = self.layout.selected()?;
let to_rect = |g: &Geometry| {
Rect::from_min_size(
origin + Vec2::new(g.x as f32, g.y as f32) * scale,
Vec2::new(g.width as f32, g.height as f32) * scale,
)
};
let rect = to_rect(&self.layout.layers()[i]);
// The faded preview is behind other visible layers, including locked ones.
if !rect.contains(pointer)
&& self
.layout
.layers()
.iter()
.enumerate()
.any(|(j, g)| j != i && self.layout.visible(j) && to_rect(g).contains(pointer))
{
return None;
}
format_ui::content_bounds(
rect,
self.layout.formats().sources[self.layout.formats().source_for[i]],
self.layout.formats().advanced[i],
)
.filter(|bounds| bounds.contains(pointer))
.map(|_| i)
}
fn resize_handle(
&self,
pointer: Pos2,
origin: Pos2,
scale: f32,
) -> Option<(usize, ResizeHandle)> {
for i in self.layout.selected_indices().into_iter().rev() {
let g = self.layout.layers()[i];
for (corner, [x, y]) in ResizeHandle::positions(g) {
let center = origin + Vec2::new(x as f32, y as f32) * scale;
if Rect::from_center_size(center, Vec2::splat(14.0)).contains(pointer) {
return Some((i, corner));
}
}
}
None
}
fn workspace(&mut self, ui: &mut egui::Ui) {
let r = ui.max_rect();
let ink = Ink::new(ui, r);
let output = self.layout.formats().output;
let [sw, sh] = output.map(|v| v as f32);
ink.button(24.0, 20.0, 185.0, "Output format…", false);
if click(ui, &ink, [24.0, 20.0, 185.0, 34.0], "output-format") {
self.output_draft = Some(OutputDraft::new(output));
}
ink.text(
224.0,
30.0,
&format!("{} × {} px", output[0], output[1]),
12.0,
MUTED,
);
// A single compact strip: view tools, then history tools.
ink.card(24.0, 65.0, 150.0, 36.0, FIELD, LINE);
ink.line([99.0, 73.0], [99.0, 93.0], LINE);
for (x, text, icon) in [
(28.0, "Fit screen", ToolbarIcon::Screen),
(62.0, "Fit selected", ToolbarIcon::Selection),
(104.0, "Undo", ToolbarIcon::Undo),
(138.0, "Redo", ToolbarIcon::Redo),
] {
let rect = Rect::from_min_size(ink.point(x, 67.0), Vec2::splat(32.0));
if toolbar_icon(ui, rect, text, icon).clicked() {
match text {
"Fit screen" => {
self.zoom = 1.0;
self.pan = Vec2::ZERO;
}
"Fit selected" => {
if let Some(g) = self.layout.selection_bounds() {
self.zoom =
(sw as f64 / g.width).min(sh as f64 / g.height) as f32 * 0.8;
self.zoom = self.zoom.clamp(0.0001, 256.0);
let c = g.center();
self.pan = Vec2::new(sw / 2.0 - c[0] as f32, sh / 2.0 - c[1] as f32);
}
}
"Undo" => {
self.layout.undo();
self.sync();
}
_ => {
self.layout.redo();
self.sync();
}
}
}
}
ui.scope_builder(
egui::UiBuilder::new()
.max_rect(Rect::from_min_size(
ink.point(184.0, 66.0),
Vec2::new(36.0, 34.0),
))
.layout(egui::Layout::left_to_right(egui::Align::Center)),
|ui| {
ui.spacing_mut().interact_size = Vec2::new(36.0, 34.0);
ui.spacing_mut().button_padding.x = 11.0;
let menu = ui.menu_button(" ", |ui| self.alignment_menu(ui));
let response = menu.response.on_hover_text("Align selected layers");
response.widget_info(|| {
egui::WidgetInfo::labeled(
egui::WidgetType::Button,
true,
"Align selected layers",
)
});
let c = response.rect.center();
let p = ui.painter();
let stroke = Stroke::new(1.6_f32, TEXT);
p.line_segment(
[c + Vec2::new(-10.0, -9.0), c + Vec2::new(-10.0, 9.0)],
stroke,
);
p.rect_filled(
Rect::from_min_size(c + Vec2::new(-6.0, -7.0), Vec2::new(13.0, 5.0)),
0.0,
TEXT,
);
p.rect_filled(
Rect::from_min_size(c + Vec2::new(-6.0, 3.0), Vec2::new(9.0, 5.0)),
0.0,
TEXT,
);
},
);
ui.scope_builder(
egui::UiBuilder::new()
.max_rect(Rect::from_min_size(
ink.point(232.0, 66.0),
Vec2::new(154.0, 34.0),
))
.layout(egui::Layout::left_to_right(egui::Align::Center)),
|ui| {
ui.spacing_mut().interact_size.y = 34.0;
ui.spacing_mut().button_padding.x = 16.0;
let menu =
ui.menu_button("Import", |ui| {
ui.set_min_width(225.0);
ui.weak("Layer values");
let selected = !self.layout.selected_indices().is_empty();
if ui
.add_enabled(selected, egui::Button::new("SVG file…"))
.on_disabled_hover_text("Select destination layers first.")
.clicked()
{
ui.close_menu();
self.import_svg_file();
}
if ui
.add_enabled(selected, egui::Button::new("Clipboard values"))
.on_hover_text(
"Read the clipboard and review layer mapping. Ctrl/Cmd-V also works.",
)
.on_disabled_hover_text("Select destination layers first.")
.clicked()
{
ui.close_menu();
ui.ctx().memory_mut(|m| {
if let Some(id) = m.focused() { m.surrender_focus(id); }
});
ui.ctx().send_viewport_cmd(egui::ViewportCommand::RequestPaste);
}
ui.separator();
ui.weak("Screen reference");
if ui.button("Reference image…").clicked() {
ui.close_menu();
self.import_reference_file(ui.ctx());
}
if self.reference.is_some() && ui.button("Reference settings…").clicked()
{
ui.close_menu();
self.reference_open = true;
}
});
let c = menu.response.rect.right_center() - Vec2::new(8.0, 0.0);
ui.painter().add(egui::Shape::convex_polygon(
vec![
c + Vec2::new(-3.0, -2.0),
c + Vec2::new(3.0, -2.0),
c + Vec2::new(0.0, 2.0),
],
MUTED,
Stroke::NONE,
));
},
);
ui.put(
Rect::from_min_size(ink.point(24.0, 108.0), Vec2::new(310.0, 20.0)),
egui::Checkbox::new(
&mut self.keep_aspect_ratio,
"Keep aspect ratio when resizing",
),
);
if self.layout.selected().is_none() {
self.edit_content = false;
}
let (text, color) = if !self.reference_error.is_empty() {
(self.reference_error.clone(), Color32::LIGHT_RED)
} else if let Some((severe, warning)) = self
.reference
.as_ref()
.and_then(|r| r.warning(self.layout.formats().output))
{
(warning, if severe { Color32::LIGHT_RED } else { AMBER })
} else {
(
self.reference
.as_ref()
.map(|r| format!("Reference: {} · {} × {} px", r.name, r.size[0], r.size[1]))
.unwrap_or_else(|| {
"Drop a reference picture here, or use Import / Reference image…".into()
}),
MUTED,
)
};
ui.put(
Rect::from_min_size(ink.point(24.0, 135.0), Vec2::new(r.width() - 48.0, 52.0)),
egui::Label::new(egui::RichText::new(text).color(color)).wrap(),
);
let area = Rect::from_min_max(
r.min + Vec2::new(20.0, 204.0),
r.max - Vec2::new(20.0, 85.0),
);
let base = ((area.width() - 48.0) / sw).min((area.height() - 48.0) / sh);
if self.camera_one_to_one {
self.zoom = (1.0 / (base * ui.ctx().pixels_per_point())).clamp(0.0001, 256.0);
self.camera_one_to_one = false;
}
let mut scale = base * self.zoom;
let mut origin = area.center() - Vec2::new(sw / 2.0, sh / 2.0) * scale + self.pan * scale;
let response = ui.interact(area, egui::Id::new("canvas"), egui::Sense::click_and_drag());
let pointer = ui.input(|i| i.pointer.interact_pos());
if response.hovered() && !self.layout.dragging() && !self.panning && self.marquee.is_none()
{
let scroll = ui.input(|i| i.smooth_scroll_delta.y);
if scroll != 0.0
&& let Some(p) = pointer
{
let world = (p - origin) / scale;
self.zoom = (self.zoom * (scroll * 0.002).exp()).clamp(0.0001, 256.0);
scale = base * self.zoom;
self.pan = (p - area.center()) / scale + Vec2::new(sw / 2.0, sh / 2.0) - world;
origin = area.center() - Vec2::new(sw / 2.0, sh / 2.0) * scale + self.pan * scale;
}
}
if response.hovered()
&& pointer.is_some_and(|p| self.content_hit(p, origin, scale).is_some())
{
ui.ctx().set_cursor_icon(egui::CursorIcon::Grab);
}
if !self.edit_content
&& response.hovered()
&& let Some(p) = pointer
&& let Some((_, corner)) = self.resize_handle(p, origin, scale)
{
ui.ctx().set_cursor_icon(match corner {
ResizeHandle::Corner(Corner::TopLeft | Corner::BottomRight) => {
egui::CursorIcon::ResizeNwSe
}
ResizeHandle::Corner(_) => egui::CursorIcon::ResizeNeSw,
ResizeHandle::Left | ResizeHandle::Right => egui::CursorIcon::ResizeHorizontal,
ResizeHandle::Top | ResizeHandle::Bottom => egui::CursorIcon::ResizeVertical,
});
}
if response.drag_started_by(egui::PointerButton::Primary)
|| response.drag_started_by(egui::PointerButton::Middle)
{
ui.ctx().memory_mut(|m| {
if let Some(id) = m.focused() {
m.surrender_focus(id);
}
});
self.panning = ui.input(|i| {
i.key_down(egui::Key::Space) || i.pointer.button_down(egui::PointerButton::Middle)
});
if !self.panning
&& let Some(p) = ui.input(|i| i.pointer.press_origin())
{
let handle = self.resize_handle(p, origin, scale);
let content = self.content_hit(p, origin, scale);
let p = (p - origin) / scale;
let point = [p.x as f64, p.y as f64];
let shift = ui.input(|i| i.modifiers.shift);
if self.edit_content {
if let Some(i) = content {
self.layout.start_content_drag(i, point);
}
} else if let Some((i, corner)) = handle.filter(|_| !shift) {
if let Err(e) = self.layout.start_selected_resize(
i,
corner,
point,
self.keep_aspect_ratio,
self.resize_mode,
) {
self.layout.gesture_error = Some(e);
}
} else if shift || self.layout.hit(point).is_none() {
let previous = self.layout.selection_mask();
let base = if shift { previous } else { [false; 2] };
self.marquee = Some(Marquee {
start: point,
end: point,
base,
previous,
});
self.layout.set_selection(base);
} else {
self.layout.start_drag(point);
}
self.sync();
}
}
if response.dragged() {
if self.panning {
self.pan += response.drag_delta() / scale;
origin += response.drag_delta();
} else if let Some(p) = pointer {
let p = (p - origin) / scale;
let point = [p.x as f64, p.y as f64];
if let Some(m) = self.marquee.as_mut() {
m.end = point;
self.layout.select_region(m.start, point, m.base);
} else {
self.layout.drag_to(point);
}
self.sync();
}
}
if response.drag_stopped() {
if (self.layout.dragging() || self.marquee.is_some())
&& let Some(p) = pointer
{
let p = (p - origin) / scale;
let point = [p.x as f64, p.y as f64];
if let Some(m) = self.marquee.as_mut() {
m.end = point;
self.layout.select_region(m.start, point, m.base);
} else {
self.layout.drag_to(point);
}
self.sync();
}
self.layout.finish_drag();
self.marquee = None;
self.panning = false;
}
if response.clicked()
&& !self.edit_content
&& let Some(p) = pointer
{
let handle = self.resize_handle(p, origin, scale);
let p = (p - origin) / scale;
let hit = handle
.map(|(i, _)| i)
.or_else(|| self.layout.hit([p.x as f64, p.y as f64]));
if click_shift_modifier(ui) {
if let Some(i) = hit {
self.layout.toggle(i);
}
} else {
if self.resize_mode == ResizeMode::Individual
|| hit.is_none_or(|i| !self.layout.selection_mask()[i])
{
self.layout.select(hit);
}
if response.double_clicked_by(egui::PointerButton::Primary) && hit.is_some() {
self.layout.select(hit);
self.edit_content = true;
}
}
self.sync();
ui.ctx().memory_mut(|m| {
if let Some(id) = m.focused() {
m.surrender_focus(id);
}
});
}
let screen = Ink {
painter: ui.painter_at(area),
origin,
scale: scale * 2.0,
};
if let Some(reference) = &self.reference {
reference.paint(
&screen.painter,
Rect::from_min_size(origin, Vec2::new(sw, sh) * scale),
);
} else if output == [1920, 1080] {
screen_artwork(&screen);
} else {
let rect = Rect::from_min_size(origin, Vec2::new(sw, sh) * scale);
screen
.painter
.rect_filled(rect, 0.0, Color32::from_rgb(20, 45, 64));
for n in 0..=10 {
let t = n as f32 / 10.0;
screen.painter.line_segment(
[
rect.left_top() + Vec2::new(rect.width() * t, 0.0),
rect.left_bottom() + Vec2::new(rect.width() * t, 0.0),
],
Stroke::new(1.0_f32, LINE),
);
screen.painter.line_segment(
[
rect.left_top() + Vec2::new(0.0, rect.height() * t),
rect.right_top() + Vec2::new(0.0, rect.height() * t),
],
Stroke::new(1.0_f32, LINE),
);
}
}
if self.edit_content
&& let Some(i) = self.layout.selected()
{
let g = self.layout.layers()[i];
let rect = Rect::from_min_size(
origin + Vec2::new(g.x as f32, g.y as f32) * scale,
Vec2::new(g.width as f32, g.height as f32) * scale,
);
format_ui::paint_content_overflow(
&screen.painter,
rect,
self.layout.formats().sources[self.layout.formats().source_for[i]],
self.layout.formats().advanced[i],
);
}
for (i, g) in self.layout.layers().iter().enumerate() {
if !self.layout.visible(i) {
continue;
}
let color = if self.layout.selection_mask()[i] {
AMBER
} else {
MUTED
};
let rect = Rect::from_min_size(
origin + Vec2::new(g.x as f32, g.y as f32) * scale,
Vec2::new(g.width as f32, g.height as f32) * scale,
);
let p = &screen.painter;
p.rect(
rect,
0.0,
if self.reference.as_ref().is_some_and(|r| r.visible) {
Color32::from_rgba_unmultiplied(23, 59, 80, 35)
} else {
Color32::from_rgb(23, 59, 80)
},
Stroke::new(1.0_f32, color),
StrokeKind::Inside,
);
if self.show_pattern || (self.edit_content && self.layout.selected() == Some(i)) {
format_ui::paint_pattern(
p,
rect,
self.layout.formats().sources[self.layout.formats().source_for[i]],
self.layout.formats().advanced[i],
);
p.rect_stroke(rect, 0.0, Stroke::new(1.0_f32, color), StrokeKind::Inside);
}
if rect.width() > 85.0 && rect.height() > 40.0 {
let clipped = p.with_clip_rect(area.intersect(rect.shrink(5.0)));
clipped.text(
rect.min + Vec2::splat(12.0),
Align2::LEFT_TOP,
label(i),
FontId::proportional(13.0),
color,
);
if rect.height() > 75.0 {
clipped.text(
rect.left_bottom() + Vec2::new(12.0, -20.0),
Align2::LEFT_BOTTOM,
format!("{} × {} px", number(g.width), number(g.height)),
FontId::proportional(12.0),
TEXT,
);
}
}
if self.layout.selection_mask()[i] {
for corner in [
rect.left_top(),
rect.right_top(),
rect.left_bottom(),
rect.right_bottom(),
rect.center_top(),
rect.center_bottom(),
rect.left_center(),
rect.right_center(),
] {
p.rect(
Rect::from_center_size(corner, Vec2::splat(7.0)),
1.0,
PANEL,
Stroke::new(1.0_f32, color),
StrokeKind::Inside,
);
}
p.line_segment(
[
rect.center() - Vec2::new(7.0, 0.0),
rect.center() + Vec2::new(7.0, 0.0),
],
Stroke::new(1.0_f32, color),
);
p.line_segment(
[
rect.center() - Vec2::new(0.0, 7.0),
rect.center() + Vec2::new(0.0, 7.0),
],
Stroke::new(1.0_f32, color),
);
}
}
if let Some(m) = self.marquee {
let from = origin + Vec2::new(m.start[0] as f32, m.start[1] as f32) * scale;
let to = origin + Vec2::new(m.end[0] as f32, m.end[1] as f32) * scale;
screen.painter.rect(
Rect::from_two_pos(from, to),
0.0,
Color32::from_rgba_unmultiplied(246, 197, 119, 25),
Stroke::new(1.0_f32, AMBER),
StrokeKind::Inside,
);
}
if let Some(i) = self.layout.selected() {
let g = self.layout.layers()[i];
if !g.outside_on(self.layout.formats().output) {
let [dx, dy] = self.corner.offsets_on(g, self.layout.formats().output);
let right = matches!(self.corner, Corner::TopRight | Corner::BottomRight);
let bottom = matches!(self.corner, Corner::BottomLeft | Corner::BottomRight);
let edge = origin
+ Vec2::new(
if right {
(g.x + g.width) as f32
} else {
g.x as f32
},
if bottom {
(g.y + g.height) as f32
} else {
g.y as f32
},
) * scale;
let boundary = origin
+ Vec2::new(if right { sw } else { 0.0 }, if bottom { sh } else { 0.0 })
* scale;
let guide = &screen.painter;
let stroke = Stroke::new(1.0_f32, AMBER);
guide.line_segment([edge, Pos2::new(boundary.x, edge.y)], stroke);
guide.line_segment([edge, Pos2::new(edge.x, boundary.y)], stroke);
guide.text(
Pos2::new((edge.x + boundary.x) / 2.0, edge.y + 6.0),
Align2::CENTER_TOP,
format!("{dx:.1} px"),
FontId::proportional(11.0),
AMBER,
);
guide.text(
Pos2::new(edge.x + 6.0, (edge.y + boundary.y) / 2.0),
Align2::LEFT_CENTER,
format!("{dy:.1} px"),
FontId::proportional(11.0),
AMBER,
);
}
}
ink.text(
24.0,
r.height() - 57.0,
match self.resize_mode {
ResizeMode::Individual => "Corners resize · Side handles keep opposite edge fixed · Shift-click selects",
ResizeMode::Same => "Same handles · Matching handles scale selected layers proportionally · Escape exits",
ResizeMode::Mirror => "Mirror horizontally · Left/right mirrored handles · Escape exits",
ResizeMode::Opposite => "Opposite handles · Opposite corners or edges · Escape exits",
},
12.0,
MUTED,
);
ink.text(
24.0,
r.height() - 31.0,
"Scroll to zoom · Space-drag to pan · Reference image stays fixed",
12.0,
MUTED,
);
}
}
// Use the modifiers attached to the click, even if Shift was released later
// in the same input frame.
fn click_shift_modifier(ui: &egui::Ui) -> bool {
ui.input(|input| {
input
.events
.iter()
.rev()
.find_map(|event| match event {
egui::Event::PointerButton {
button: egui::PointerButton::Primary,
pressed: false,
modifiers,
..
} => Some(modifiers.shift),
_ => None,
})
.unwrap_or(input.modifiers.shift)
})
}
fn click(ui: &egui::Ui, ink: &Ink, b: [f32; 4], id: impl std::hash::Hash) -> bool {
let clicked = ui
.interact(
Rect::from_min_size(ink.point(b[0], b[1]), Vec2::new(b[2], b[3])),
egui::Id::new(id),
egui::Sense::click(),
)
.on_hover_cursor(egui::CursorIcon::PointingHand)
.clicked();
if clicked {
ui.ctx().memory_mut(|m| {
if let Some(id) = m.focused() {
m.surrender_focus(id);
}
});
}
clicked
}
impl Editor {
fn ui(&mut self, ctx: &egui::Context) {
let dropped = ctx.input(|i| i.raw.dropped_files.clone());
if !dropped.is_empty() {
if dropped.len() == 1 {
self.load_reference(ctx, &dropped[0]);
} else {
self.reference_error =
"Drop one reference image at a time; current image kept.".into();
}
}
self.shortcuts(ctx);
egui::TopBottomPanel::top("header")
.exact_height(44.0)
.frame(egui::Frame::NONE.fill(PANEL))
.show(ctx, |ui| {
let r = ui.max_rect();
let ink = Ink::new(ui, r);
ink.text(24.0, 11.0, "MIDRA / LAYOUT", 18.0, TEXT);
ink.line([206.0, 13.0], [206.0, 31.0], LINE);
ink.text(222.0, 15.0, "Offline position helper", 13.0, MUTED);
ink.text(r.width() - 347.0, 15.0, "EIKOS 4K", 12.0, CYAN);
ink.button(r.width() - 212.0, 5.0, 188.0, "Copy coordinates", false);
if click(
ui,
&ink,
[r.width() - 212.0, 5.0, 188.0, 34.0],
"header-copy",
) {
self.copy(ctx);
}
});
egui::TopBottomPanel::bottom("status")
.exact_height(34.0)
.frame(egui::Frame::NONE.fill(PANEL))
.show(ctx, |ui| {
let r = ui.max_rect();
let ink = Ink::new(ui, r);
ink.painter.circle_filled(ink.point(24.0, 17.0), 3.0, CYAN);
ink.text(36.0, 10.0, "OFFLINE", 11.0, MUTED);
ink.text(
116.0,
10.0,
if !self.layout.selected_indices().is_empty() {
"Shift-click or drag a box to select layers"
} else {
"Select a layer to move or paste"
},
12.0,
MUTED,
);
ink.text(
r.width() - 278.0,
10.0,
&format!(
"Screen pixels / {} × {}",
self.layout.formats().output[0],
self.layout.formats().output[1]
),
12.0,
MUTED,
);
});
egui::SidePanel::right("inspector")
.exact_width(392.0)
.resizable(false)
.frame(egui::Frame::NONE.fill(PANEL).inner_margin(24.0))
.show(ctx, |ui| {
egui::ScrollArea::vertical()
.drag_to_scroll(false)
.show(ui, |ui| self.inspector(ui));
});
egui::CentralPanel::default()
.frame(egui::Frame::NONE.fill(BG))
.show(ctx, |ui| self.workspace(ui));
self.paste_window(ctx);
self.reference_window(ctx);
self.output_window(ctx);
self.formats_window(ctx);
}
}
impl eframe::App for Editor {
fn update(&mut self, ctx: &egui::Context, _: &mut eframe::Frame) {
self.ui(ctx);
}
}
fn alignment_icon(
ui: &mut egui::Ui,
rect: Rect,
title: &str,
horizontal: Option<Alignment>,
vertical: Option<Alignment>,
) -> egui::Response {
let response = ui.interact(rect, ui.id().with(title), egui::Sense::click());
response.widget_info(|| {
egui::WidgetInfo::labeled(egui::WidgetType::Button, ui.is_enabled(), title)
});
let p = ui.painter();
p.rect(
rect,
3.0,
if response.is_pointer_button_down_on() {
PURPLE
} else if response.hovered() {
PANEL
} else {
FIELD
},
Stroke::new(1.0_f32, LINE),
StrokeKind::Inside,
);
let c = rect.center();
let stroke = Stroke::new(1.6_f32, if response.hovered() { CYAN } else { TEXT });
let x = match horizontal {
Some(Alignment::Left) => -6.0,
Some(Alignment::Right) => 6.0,
_ => 0.0,
};
let y = match vertical {
Some(Alignment::Top) => -6.0,
Some(Alignment::Bottom) => 6.0,
_ => 0.0,
};
// The standalone centering icons indicate the direction of movement.
let (horizontal, vertical) = match (horizontal, vertical) {
(Some(Alignment::HorizontalCenter), None) => (None, Some(Alignment::VerticalCenter)),
(None, Some(Alignment::VerticalCenter)) => (Some(Alignment::HorizontalCenter), None),
axes => axes,
};
for (axis, value) in [(0, horizontal), (1, vertical)] {
if let Some(value) = value {
let offset = match value {
Alignment::Left | Alignment::Top => -12.0,
Alignment::Right | Alignment::Bottom => 12.0,
_ => 0.0,
};
let ends = if axis == 0 {
[c + Vec2::new(offset, -12.0), c + Vec2::new(offset, 12.0)]
} else {
[c + Vec2::new(-12.0, offset), c + Vec2::new(12.0, offset)]
};
p.line_segment(ends, stroke);
}
}
p.rect(
Rect::from_center_size(c + Vec2::new(x, y), Vec2::splat(8.0)),
0.0,
FIELD,
stroke,
StrokeKind::Inside,
);
response.on_hover_text(title)
}
#[derive(Clone, Copy)]
enum ToolbarIcon {
Screen,
Selection,
Undo,
Redo,
}
fn toolbar_icon(ui: &mut egui::Ui, rect: Rect, label: &str, icon: ToolbarIcon) -> egui::Response {
let response = ui.interact(rect, ui.id().with(("toolbar", label)), egui::Sense::click());
response.widget_info(|| egui::WidgetInfo::labeled(egui::WidgetType::Button, true, label));
let painter = ui.painter();
let focused = response.hovered() || response.has_focus();
if focused || response.is_pointer_button_down_on() {
painter.rect_filled(
rect.shrink(1.0),
4.0,
if response.is_pointer_button_down_on() {
PURPLE
} else {
PANEL
},
);
}
let stroke = Stroke::new(1.6_f32, if focused { CYAN } else { TEXT });
let c = rect.center();
let point = |x, y| c + Vec2::new(x, y);
match icon {
ToolbarIcon::Screen => {
painter.rect_stroke(
Rect::from_center_size(point(0.0, -2.0), Vec2::new(20.0, 14.0)),
2.0,
stroke,
StrokeKind::Inside,
);
painter.line_segment([point(0.0, 5.0), point(0.0, 9.0)], stroke);
painter.line_segment([point(-5.0, 9.0), point(5.0, 9.0)], stroke);
}
ToolbarIcon::Selection => {
for (x, y) in [(-1.0, -1.0), (1.0, -1.0), (-1.0, 1.0), (1.0, 1.0)] {
painter.add(egui::Shape::line(
vec![
point(x * 5.0, y * 10.0),
point(x * 10.0, y * 10.0),
point(x * 10.0, y * 5.0),
],
stroke,
));
}
painter.rect_stroke(
Rect::from_center_size(c, Vec2::new(8.0, 6.0)),
0.0,
stroke,
StrokeKind::Inside,
);
}
ToolbarIcon::Undo | ToolbarIcon::Redo => {
let sign = if matches!(icon, ToolbarIcon::Undo) {
1.0
} else {
-1.0
};
let points = [
(-8.0, -4.0),
(-3.0, -7.0),
(3.0, -7.0),
(7.0, -4.0),
(9.0, 0.0),
(8.0, 5.0),
(4.0, 8.0),
(0.0, 8.0),
];
painter.add(egui::Shape::line(
points
.into_iter()
.map(|(x, y)| point(x * sign, y))
.collect(),
stroke,
));
painter.add(egui::Shape::line(
vec![
point(-8.0 * sign, -10.0),
point(-8.0 * sign, -4.0),
point(-2.0 * sign, -4.0),
],
stroke,
));
}
}
response.on_hover_text(match icon {
ToolbarIcon::Screen => "Fit screen — show the entire output",
ToolbarIcon::Selection => "Fit selected — frame the selected layers",
ToolbarIcon::Undo => "Undo (Ctrl/Cmd+Z)",
ToolbarIcon::Redo => "Redo (Ctrl/Cmd+Shift+Z)",
})
}
#[cfg(test)]
mod tests {
use super::*;
pub(super) fn frame(
app: &mut Editor,
ctx: &egui::Context,
events: Vec<egui::Event>,
) -> egui::FullOutput {
let input = egui::RawInput {
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1440.0, 940.0))),
events,
..Default::default()
};
ctx.run(input, |ctx| app.ui(ctx))
}
fn key(key: egui::Key) -> egui::Event {
egui::Event::Key {
key,
physical_key: None,
pressed: true,
repeat: false,
modifiers: egui::Modifiers::NONE,
}
}
#[test]
fn double_click_enters_crop_mode_without_changing_geometry() {
for target in [Some(0), Some(1), None] {
let mut app = Editor::default();
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
let formats = *app.layout.formats();
let pos = target
.map(|i| layer_rects(&output)[i].center())
.unwrap_or(Pos2::new(500.0, 700.0));
for _ in 0..2 {
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
}
assert_eq!(app.edit_content, target.is_some());
assert_eq!(app.layout.selected(), target);
assert_eq!(*app.layout.layers(), before);
assert_eq!(*app.layout.formats(), formats);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
assert!(!app.edit_content);
}
}
#[test]
fn double_click_does_not_edit_a_locked_layer() {
let mut app = Editor::default();
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let pos = layer_rects(&output)[1].center();
app.layout.set_locked(1, true);
for _ in 0..2 {
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
}
assert!(!app.edit_content);
}
#[test]
fn content_mode_drags_only_crop_and_camera_zoom_keeps_document_unchanged() {
let mut app = Editor {
edit_content: true,
..Default::default()
};
let ctx = egui::Context::default();
app.layout
.set_framing(
1,
midra_layout::formats::Framing {
zoom: 2.0,
offset: [0.0; 2],
},
)
.unwrap();
let before = *app.layout.formats();
let boxes = *app.layout.layers();
let output = frame(&mut app, &ctx, vec![]);
let start = layer_rects(&output)[1].center();
let end = start + Vec2::new(30.0, 20.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
let framing = app.layout.formats().mapping(1, boxes[1]).unwrap().framing;
assert!(framing.offset[0] > 0.0 && framing.offset[1] > 0.0);
assert_eq!(*app.layout.layers(), boxes);
app.layout.undo();
assert_eq!(*app.layout.formats(), before);
frame(&mut app, &ctx, vec![key(egui::Key::ArrowRight)]);
assert_eq!(*app.layout.layers(), boxes);
assert!(
(app.layout
.formats()
.mapping(1, boxes[1])
.unwrap()
.framing
.offset[0]
- 1.0)
.abs()
< 1e-8
);
let unchanged = *app.layout.formats();
app.zoom = 2.0;
frame(&mut app, &ctx, vec![]);
assert_eq!(*app.layout.formats(), unchanged);
assert_eq!(*app.layout.layers(), boxes);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
assert!(!app.edit_content);
}
#[test]
fn faded_content_can_be_grabbed_outside_box_at_different_camera_scales() {
for zoom in [0.6, 1.0] {
let mut app = Editor {
edit_content: true,
zoom,
pan: Vec2::new(-30.0, 20.0),
..Default::default()
};
app.layout
.set_framing(
1,
midra_layout::formats::Framing {
zoom: 2.0,
offset: [0.0; 2],
},
)
.unwrap();
let ctx = egui::Context::default();
let before = *app.layout.layers();
let formats = *app.layout.formats();
let output = frame(&mut app, &ctx, vec![]);
let rect = layer_rects(&output)[1];
let start = rect.center_top() - Vec2::new(0.0, 15.0);
assert!(!rect.contains(start));
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
let end = start + Vec2::new(10.0, 10.0);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(*app.layout.layers(), before);
assert_ne!(*app.layout.formats(), formats);
assert_eq!(app.layout.selected(), Some(1));
app.layout.undo();
assert_eq!(*app.layout.formats(), formats);
}
}
#[test]
fn content_hit_excludes_empty_space_and_preview_covered_by_another_layer() {
let mut app = Editor {
edit_content: true,
..Default::default()
};
app.layout
.set_framing(
1,
midra_layout::formats::Framing {
zoom: 4.0,
offset: [0.0; 2],
},
)
.unwrap();
let origin = Pos2::ZERO;
let covered = Pos2::new(700.0, 300.0);
assert_eq!(app.content_hit(covered, origin, 1.0), None);
app.layout.set_visible(0, false);
assert_eq!(app.content_hit(covered, origin, 1.0), Some(1));
assert_eq!(
app.content_hit(Pos2::new(1480.0, -500.0), origin, 1.0),
None
);
app.edit_content = false;
assert_eq!(app.content_hit(covered, origin, 1.0), None);
}
#[test]
fn import_menu_requests_clipboard_and_opens_layer_review() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let mut requested = false;
for label in ["Import", "Clipboard values"] {
let output = frame(&mut app, &ctx, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::epaint::Shape::Text(t) if t.galley.job.text == label => {
Some(t.pos + Vec2::new(10.0, 6.0))
}
_ => None,
})
.unwrap();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
let output = frame(&mut app, &ctx, vec![mouse(pos, false)]);
requested |= output.viewport_output.values().any(|v| {
v.commands
.iter()
.any(|c| matches!(c, egui::ViewportCommand::RequestPaste))
});
}
assert!(requested);
frame(
&mut app,
&ctx,
vec![egui::Event::Paste(
include_str!("../tests/fixtures/drawio-rectangle.txt").into(),
)],
);
let p = app.paste.as_ref().unwrap();
assert!(p.error.is_empty());
assert_eq!(p.shapes.len(), 1);
}
#[test]
fn paste_format_position_and_zoom_are_independent_and_undo_together() {
for size in [false, true] {
for position in [false, true] {
for zoom in [false, true] {
let mut app = Editor::default();
app.layout
.set_framing(
1,
midra_layout::formats::Framing {
zoom: 2.0,
offset: [0.0; 2],
},
)
.unwrap();
let before = *app.layout.layers();
let formats = *app.layout.formats();
app.open_paste("Source — visible box (device container unverified)\nHorizontal: 500 px\nVertical: 600 px\nWidth: 300 px\nHeight: 250 px\nCrop zoom: 300 %".into());
let p = app.paste.as_mut().unwrap();
assert!(p.error.is_empty(), "{}", p.error);
p.include_size = size;
p.include_position = position;
p.include_zoom = zoom;
let result = p.apply(&mut app.layout);
if !size && !position && !zoom {
assert!(result.unwrap_err().contains("Choose at least one"));
} else {
result.unwrap();
let g = app.layout.layers()[1];
assert_eq!(
[g.x, g.y],
if position {
[350.0, 475.0]
} else {
[before[1].x, before[1].y]
}
);
assert_eq!(
[g.width, g.height],
if size {
[300.0, 250.0]
} else {
[before[1].width, before[1].height]
}
);
assert!(
(app.layout.formats().mapping(1, g).unwrap().framing.zoom
- if zoom { 3.0 } else { 2.0 })
.abs()
< 1e-8
);
app.layout.undo();
}
assert_eq!(*app.layout.layers(), before);
assert_eq!(*app.layout.formats(), formats);
}
}
}
let mut app = Editor::default();
app.open_paste(include_str!("../tests/fixtures/drawio-rectangle.txt").into());
let p = app.paste.as_mut().unwrap();
assert!(!p.zoom_available());
p.include_size = false;
p.include_position = false;
assert!(p.apply(&mut app.layout).is_err());
}
#[test]
fn native_copy_paste_round_trip_supports_single_and_multiple_layers() {
for selection in [[false, true], [true, true]] {
let mut app = Editor::default();
app.layout.set_selection(selection);
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
let output = frame(&mut app, &ctx, vec![egui::Event::Copy]);
let text = output
.platform_output
.commands
.iter()
.find_map(|c| match c {
egui::OutputCommand::CopyText(text) => Some(text.clone()),
_ => None,
})
.unwrap();
app.layout.nudge(50.0, 30.0).unwrap();
let moved = *app.layout.layers();
frame(&mut app, &ctx, vec![egui::Event::Paste(text)]);
let p = app.paste.as_ref().unwrap();
assert!(p.error.is_empty(), "{}", p.error);
let values = p.values(&app.layout).unwrap();
assert_eq!(values.len(), selection.iter().filter(|v| **v).count());
app.layout.apply_import(&values).unwrap();
assert_eq!(*app.layout.layers(), before);
app.layout.undo();
assert_eq!(*app.layout.layers(), moved);
}
}
#[test]
fn rounded_fields_do_not_quantize_unchanged_values_and_copy_uses_pixels() {
let mut app = Editor::default();
let ctx = egui::Context::default();
let g = Geometry {
x: 12.36,
y: 20.51,
width: 300.33,
height: 250.58,
};
app.layout.apply(1, g).unwrap();
app.sync();
assert_eq!(app.fields[2], "300.3");
assert_eq!(app.fields[3], "250.6");
app.apply_fields();
assert_eq!(app.layout.layers()[1], g);
let output = ctx.run(egui::RawInput::default(), |ctx| app.copy(ctx));
assert!(output.platform_output.commands.iter().any(|c|matches!(c,egui::OutputCommand::CopyText(text) if text.contains("Width: 300 px") && text.contains("Height: 251 px"))));
assert_eq!(app.layout.layers()[1], g);
}
#[test]
fn selected_resize_mode_control_keeps_selection_during_handle_drag() {
for (title, mode) in [
("Same handles", ResizeMode::Same),
("Mirror horizontally (two layers)", ResizeMode::Mirror),
("Opposite handles (two layers)", ResizeMode::Opposite),
] {
let mut app = Editor::default();
app.layout.set_selection([true; 2]);
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
for text in ["Resize: individual layer", title] {
let output = frame(&mut app, &ctx, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::epaint::Shape::Text(t) if t.galley.job.text == text => {
Some(t.pos + Vec2::new(12.0, 6.0))
}
_ => None,
})
.unwrap();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
}
assert_eq!(app.resize_mode, mode);
let before = *app.layout.layers();
let output = frame(&mut app, &ctx, vec![]);
let start = layer_rects(&output)[1].right_center();
let end = start + Vec2::new(20.0, 0.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(app.layout.selection_mask(), [true; 2]);
assert!(
app.layout
.layers()
.iter()
.zip(before)
.all(|(g, old)| g.width > old.width)
);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
assert_eq!(app.resize_mode, ResizeMode::Individual);
}
}
#[test]
fn side_handle_hit_regions_resize_at_multiple_zoom_levels() {
for zoom in [0.6, 1.0] {
for side in 0..4 {
let mut app = Editor {
zoom,
keep_aspect_ratio: false,
..Default::default()
};
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let rect = layer_rects(&output)[1];
let before = app.layout.layers()[1];
let (start, delta) = match side {
0 => (rect.center_top(), Vec2::new(0.0, -20.0)),
1 => (rect.center_bottom(), Vec2::new(0.0, 20.0)),
2 => (rect.left_center(), Vec2::new(-20.0, 0.0)),
_ => (rect.right_center(), Vec2::new(20.0, 0.0)),
};
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start + delta)],
);
frame(&mut app, &ctx, vec![mouse(start + delta, false)]);
let after = app.layout.layers()[1];
match side {
0 => assert_eq!(after.y + after.height, before.y + before.height),
1 => assert_eq!(after.y, before.y),
2 => assert_eq!(after.x + after.width, before.x + before.width),
_ => assert_eq!(after.x, before.x),
}
if side < 2 {
assert!(after.height > before.height);
assert_eq!(after.width, before.width);
} else {
assert!(after.width > before.width);
assert_eq!(after.height, before.height);
}
app.layout.undo();
assert_eq!(app.layout.layers()[1], before);
}
}
}
#[test]
fn corner_handles_resize_at_different_zoom_levels_and_escape_restores() {
for zoom in [0.6, 1.0] {
for keep_aspect_ratio in [true, false] {
let mut app = Editor {
zoom,
keep_aspect_ratio,
..Default::default()
};
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
let start = layer_rects(&output)[1].right_bottom();
let end = start + Vec2::new(35.0, 5.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
let resized = app.layout.layers()[1];
assert!(resized.width > before[1].width);
assert_eq!([resized.x, resized.y], [before[1].x, before[1].y]);
assert_eq!(app.layout.layers()[0], before[0]);
let ratio_changed =
(resized.width / resized.height - before[1].width / before[1].height).abs()
> 1e-8;
assert_eq!(ratio_changed, !keep_aspect_ratio);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
let output = frame(&mut app, &ctx, vec![]);
let start = layer_rects(&output)[1].left_top();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start - Vec2::splat(20.0))],
);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
assert_eq!(*app.layout.layers(), before);
}
}
}
#[test]
fn dropped_reference_warns_without_editing_layers_and_failed_replace_keeps_image() {
let mut app = Editor::default();
let ctx = egui::Context::default();
let before = *app.layout.layers();
let pixels = image::RgbaImage::from_pixel(16, 10, image::Rgba([50, 90, 120, 255]));
let mut bytes = std::io::Cursor::new(Vec::new());
pixels
.write_to(&mut bytes, image::ImageFormat::Png)
.unwrap();
let _ = ctx.run(
egui::RawInput {
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1440.0, 940.0))),
dropped_files: vec![egui::DroppedFile {
name: "reference.png".into(),
bytes: Some(bytes.into_inner().into()),
..Default::default()
}],
..Default::default()
},
|ctx| app.ui(ctx),
);
assert!(
app.reference
.as_ref()
.unwrap()
.warning([1920, 1080])
.unwrap()
.0
);
assert_eq!(*app.layout.layers(), before);
let output = frame(&mut app, &ctx, vec![]);
assert!(output.shapes.iter().any(|s| matches!(&s.shape, egui::epaint::Shape::Text(t) if t.galley.job.text.contains("SEVERE WARNING"))));
let texture = app.reference.as_ref().unwrap().texture.id();
app.load_reference(
&ctx,
&egui::DroppedFile {
bytes: Some(Vec::from(b"broken").into()),
..Default::default()
},
);
assert!(!app.reference_error.is_empty());
assert_eq!(app.reference.as_ref().unwrap().texture.id(), texture);
app.layout.nudge(1.0, 0.0).unwrap();
assert_eq!(app.layout.layers()[1].x, before[1].x + 1.0);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
assert_eq!(app.reference.as_ref().unwrap().texture.id(), texture);
}
#[test]
fn paste_opens_review_without_editing_and_escape_cancels() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
frame(
&mut app,
&ctx,
vec![egui::Event::Paste(
include_str!("../tests/fixtures/drawio-rectangle.txt").into(),
)],
);
assert_eq!(*app.layout.layers(), before);
let p = app.paste.as_ref().unwrap();
assert_eq!(p.targets, vec![1]);
assert_eq!(p.shapes[0].geometry.width, 945.0);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
assert!(app.paste.is_none());
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn import_review_excludes_background_and_applies_reversed_mapping_atomically() {
let mut app = Editor::default();
let ctx = egui::Context::default();
app.layout.set_selection([true; 2]);
let before = *app.layout.layers();
app.open_paste(r#"<svg width="1920" height="1080"><rect width="1920" height="1080"/><rect id="a" x="12" y="30" width="400" height="300"/><rect id="b" x="800" y="50" width="500" height="400"/></svg>"#.into());
let p = app.paste.as_mut().unwrap();
assert!(
p.values(&app.layout)
.unwrap_err()
.contains("2 selected, 3 detected")
);
p.ignored[0] = true;
p.reset_mapping();
p.mapping[1] = Some(1);
p.mapping[2] = Some(1);
assert!(p.values(&app.layout).is_err());
p.mapping[2] = Some(0);
let expected = [p.shapes[2].geometry, p.shapes[1].geometry];
assert_eq!(*app.layout.layers(), before);
frame(&mut app, &ctx, vec![]);
let output = frame(&mut app, &ctx, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::epaint::Shape::Text(t) if t.galley.job.text == "Apply mapped values" => {
Some(t.pos + Vec2::new(20.0, 6.0))
}
_ => None,
})
.unwrap();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
assert!(app.paste.is_none());
assert_eq!(*app.layout.layers(), expected);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn numeric_focus_keeps_paste_out_of_importer_and_arrows_out_of_geometry() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
ctx.memory_mut(|m| m.request_focus(egui::Id::new(("geometry", 0_usize))));
frame(&mut app, &ctx, vec![]);
assert!(ctx.wants_keyboard_input());
let before = *app.layout.layers();
frame(
&mut app,
&ctx,
vec![egui::Event::Paste("123".into()), key(egui::Key::ArrowLeft)],
);
assert!(app.paste.is_none());
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn invalid_numeric_edits_preserve_document_and_valid_edits_are_reversible() {
let mut app = Editor::default();
let before = *app.layout.layers();
app.fields = ["0".into(), "0".into(), "NaN".into(), "300".into()];
app.apply_fields();
assert!(!app.error.is_empty());
assert_eq!(*app.layout.layers(), before);
app.fields = ["120".into(), "180".into(), "945".into(), "531.58".into()];
app.apply_fields();
assert!(app.error.is_empty());
assert_eq!(app.layout.layers()[1].width, 945.0);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn paste_without_selection_and_invalid_xml_do_not_edit() {
let mut app = Editor::default();
let before = *app.layout.layers();
app.layout.select(None);
app.open_paste("invalid".into());
assert!(app.paste.is_none());
assert!(!app.error.is_empty());
app.layout.select(Some(0));
app.open_paste("invalid".into());
assert!(app.paste.as_ref().unwrap().shapes.is_empty());
assert!(!app.paste.as_ref().unwrap().error.is_empty());
assert_eq!(*app.layout.layers(), before);
}
pub(super) fn mouse(p: Pos2, pressed: bool) -> egui::Event {
egui::Event::PointerButton {
pos: p,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::NONE,
}
}
#[test]
fn modal_apply_button_imports_exact_sample_and_undo_restores() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
frame(
&mut app,
&ctx,
vec![egui::Event::Paste(
include_str!("../tests/fixtures/drawio-rectangle.txt").into(),
)],
);
let output = frame(&mut app, &ctx, vec![]);
let position = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::epaint::Shape::Text(t) if t.galley.job.text == "Apply mapped values" => {
Some(t.pos + Vec2::new(30.0, 6.0))
}
_ => None,
})
.expect("Apply button rendered");
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(position), mouse(position, true)],
);
frame(&mut app, &ctx, vec![mouse(position, false)]);
assert!(app.paste.is_none());
assert_eq!(app.layout.layers()[1].x, 12.0);
assert_eq!(app.layout.layers()[1].height, 531.58);
assert_eq!(app.layout.layers()[0], before[0]);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn pointer_drag_is_one_edit_and_does_not_move_other_layer() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
let start = Pos2::new(700.0, 420.0);
let end = start + Vec2::new(40.0, 20.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(app.layout.layers()[0], before[0]);
assert!(app.layout.layers()[1].x > before[1].x);
assert!(app.layout.layers()[1].y > before[1].y);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn list_selection_then_paste_targets_that_layer() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let p = Pos2::new(1180.0, 135.0);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(p), mouse(p, true)],
);
frame(&mut app, &ctx, vec![mouse(p, false)]);
assert_eq!(app.layout.selected(), Some(0));
frame(
&mut app,
&ctx,
vec![egui::Event::Paste(
include_str!("../tests/fixtures/drawio-rectangle.txt").into(),
)],
);
assert_eq!(app.paste.as_ref().unwrap().targets, vec![0]);
}
#[test]
fn zoom_changes_camera_without_geometry_or_undo_edits() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
frame(
&mut app,
&ctx,
vec![
egui::Event::PointerMoved(Pos2::new(700.0, 420.0)),
egui::Event::MouseWheel {
unit: egui::MouseWheelUnit::Point,
delta: Vec2::new(0.0, 100.0),
modifiers: egui::Modifiers::NONE,
},
],
);
assert!(app.zoom > 1.0);
assert_eq!(*app.layout.layers(), before);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn outline_checkbox_changes_preview_then_applies_as_one_undo_step() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
frame(
&mut app,
&ctx,
vec![egui::Event::Paste(
include_str!("../tests/fixtures/drawio-rectangle.txt").into(),
)],
);
assert!(!app.paste.as_ref().unwrap().include_outline);
for text in ["Include outline in bounds", "Apply mapped values"] {
let output = frame(&mut app, &ctx, vec![]);
let pos = output
.shapes
.iter()
.find_map(|s| match &s.shape {
egui::epaint::Shape::Text(t) if t.galley.job.text == text => {
Some(t.pos + Vec2::new(20.0, 6.0))
}
_ => None,
})
.expect("paste control rendered");
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
if text == "Include outline in bounds" {
assert!(app.paste.as_ref().unwrap().include_outline);
assert_eq!(*app.layout.layers(), before);
}
}
assert!(app.paste.is_none());
assert_eq!(
app.layout.layers()[1],
Geometry {
x: 9.5,
y: 268.5,
width: 950.0,
height: 536.58
}
);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
fn frame_shift(
app: &mut Editor,
ctx: &egui::Context,
events: Vec<egui::Event>,
) -> egui::FullOutput {
ctx.run(
egui::RawInput {
screen_rect: Some(Rect::from_min_size(Pos2::ZERO, Vec2::new(1440.0, 940.0))),
events,
modifiers: egui::Modifiers::SHIFT,
..Default::default()
},
|ctx| app.ui(ctx),
)
}
fn click_shift(app: &mut Editor, ctx: &egui::Context, p: Pos2) {
let event = |pressed| egui::Event::PointerButton {
pos: p,
button: egui::PointerButton::Primary,
pressed,
modifiers: egui::Modifiers::SHIFT,
};
frame_shift(app, ctx, vec![egui::Event::PointerMoved(p), event(true)]);
frame(app, ctx, vec![event(false)]); // Shift released by the end of this frame.
}
fn layer_rects(output: &egui::FullOutput) -> Vec<Rect> {
output
.shapes
.iter()
.filter_map(|s| match &s.shape {
egui::epaint::Shape::Rect(r) if r.fill == Color32::from_rgb(23, 59, 80) => {
Some(r.rect)
}
_ => None,
})
.collect()
}
#[test]
fn layer_buttons_protect_selection_and_toggle_drawing() {
let mut app = Editor::default();
let ctx = egui::Context::default();
frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
for (kind, expected_count) in [
("lock", 2),
("visibility", 1),
("visibility", 2),
("lock", 2),
] {
let rect = ctx
.read_response(egui::Id::new((kind, 1_usize)))
.unwrap()
.rect;
click_shift(&mut app, &ctx, rect.center());
let output = frame(&mut app, &ctx, vec![]);
assert_eq!(layer_rects(&output).len(), expected_count);
assert_eq!(app.layout.selected(), None);
assert_eq!(*app.layout.layers(), before);
}
assert!(!app.layout.locked(1));
assert!(app.layout.visible(1));
let row = ctx
.read_response(egui::Id::new(("layer", 1_usize)))
.unwrap()
.rect;
click_shift(&mut app, &ctx, row.center());
assert_eq!(app.layout.selected(), Some(1));
}
#[test]
fn shift_click_toggles_canvas_and_list_selection() {
let mut app = Editor::default();
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let rects = layer_rects(&output);
assert_eq!(rects.len(), 2);
click_shift(&mut app, &ctx, rects[0].center());
assert_eq!(app.layout.selected_indices(), vec![0, 1]);
click_shift(&mut app, &ctx, rects[1].center());
assert_eq!(app.layout.selected(), Some(0));
click_shift(&mut app, &ctx, Pos2::new(1180.0, 180.0));
assert_eq!(app.layout.selected_indices(), vec![0, 1]);
let row = ctx
.read_response(egui::Id::new(("layer", 0_usize)))
.unwrap()
.rect;
click_shift(&mut app, &ctx, row.center());
assert_eq!(app.layout.selection_mask(), [false, true]);
}
#[test]
fn marquee_selects_both_at_different_camera_transforms_without_moving_them() {
for zoom in [0.6, 1.0] {
let mut app = Editor {
zoom,
pan: Vec2::new(10.0, -8.0),
..Default::default()
};
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let before = *app.layout.layers();
let rects = layer_rects(&output);
let area = rects[0].union(rects[1]).expand(10.0);
let start = area.left_top();
let end = area.right_bottom();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
assert!(app.marquee.is_some());
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(app.layout.selected_indices(), vec![0, 1]);
assert!(app.marquee.is_none());
assert_eq!(*app.layout.layers(), before);
}
}
#[test]
fn escape_cancels_selection_box_and_restores_previous_selection() {
let mut app = Editor::default();
let ctx = egui::Context::default();
let output = frame(&mut app, &ctx, vec![]);
let rects = layer_rects(&output);
let area = rects[0].union(rects[1]).expand(10.0);
let start = area.left_top();
let end = area.right_bottom();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(start), mouse(start, true)],
);
frame(&mut app, &ctx, vec![egui::Event::PointerMoved(end)]);
assert_eq!(app.layout.selected_indices(), vec![0, 1]);
frame(&mut app, &ctx, vec![key(egui::Key::Escape)]);
frame(&mut app, &ctx, vec![mouse(end, false)]);
assert_eq!(app.layout.selected(), Some(1));
assert!(app.marquee.is_none());
}
fn open_alignment_test_menu(app: &mut Editor, ctx: &egui::Context) -> egui::FullOutput {
frame(app, ctx, vec![]);
let pos = Pos2::new(200.0, 127.0);
frame(
app,
ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(app, ctx, vec![mouse(pos, false)]);
frame(app, ctx, vec![])
}
fn alignment_test_position(output: &egui::FullOutput, title: &str) -> Pos2 {
let rects: Vec<_> = output
.shapes
.iter()
.filter_map(|s| match &s.shape {
egui::epaint::Shape::Rect(r) if r.rect.size() == Vec2::splat(40.0) => Some(r.rect),
_ => None,
})
.collect();
rects[if title == "Align top" { 1 } else { 7 }].center()
}
#[test]
fn single_layer_alignment_grid_uses_current_screen_bounds() {
for (index, x, y) in [
(0, Some(0.0), Some(0.0)),
(1, None, Some(0.0)),
(2, Some(1920.0), Some(0.0)),
(3, Some(0.0), None),
(4, Some(960.0), Some(540.0)),
(5, Some(1920.0), None),
(6, Some(0.0), Some(1080.0)),
(7, None, Some(1080.0)),
(8, Some(1920.0), Some(1080.0)),
(9, Some(960.0), None),
(10, None, Some(540.0)),
] {
let mut app = Editor::default();
app.layout.set_output([2560, 1440]).unwrap();
let before = *app.layout.layers();
let formats = *app.layout.formats();
let ctx = egui::Context::default();
let output = open_alignment_test_menu(&mut app, &ctx);
assert!(output.shapes.iter().any(|s| matches!(&s.shape, egui::epaint::Shape::Text(t) if t.galley.job.text == "Screen (one selected layer)")));
let pos = output
.shapes
.iter()
.filter_map(|s| match &s.shape {
egui::epaint::Shape::Rect(r) if r.rect.size() == Vec2::splat(40.0) => {
Some(r.rect.center())
}
_ => None,
})
.nth(index)
.unwrap();
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
let g = app.layout.layers()[1];
assert_eq!(g.x, x.unwrap_or(before[1].x));
assert_eq!(g.y, y.unwrap_or(before[1].y));
assert_eq!([g.width, g.height], [before[1].width, before[1].height]);
assert_eq!(app.layout.layers()[0], before[0]);
assert_eq!(*app.layout.formats(), formats);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
}
#[test]
fn top_and_bottom_buttons_align_rendered_edges_for_every_target() {
for target in [
AlignTarget::Selection,
AlignTarget::Layer(0),
AlignTarget::Layer(1),
] {
for (title, expected_y) in [
(
"Align top",
match target {
AlignTarget::Selection | AlignTarget::Layer(0) => [60.0, 60.0],
AlignTarget::Screen => [0.0, 0.0],
AlignTarget::Layer(_) => [180.0, 180.0],
},
),
(
"Align bottom",
match target {
AlignTarget::Selection | AlignTarget::Layer(1) => [340.0, 180.0],
AlignTarget::Screen => [880.0, 720.0],
AlignTarget::Layer(_) => [60.0, -100.0],
},
),
] {
let mut app = Editor::default();
app.layout
.apply(
0,
Geometry {
x: 90.0,
y: 60.0,
width: 300.0,
height: 200.0,
},
)
.unwrap();
app.layout.set_selection([true; 2]);
app.align_target = target;
let before = *app.layout.layers();
let ctx = egui::Context::default();
let output = open_alignment_test_menu(&mut app, &ctx);
let pos = alignment_test_position(&output, title);
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
let output = frame(&mut app, &ctx, vec![]);
let rects = layer_rects(&output);
assert_eq!(rects.len(), 2);
let edges = if title == "Align top" {
[rects[0].top(), rects[1].top()]
} else {
[rects[0].bottom(), rects[1].bottom()]
};
assert!((edges[0] - edges[1]).abs() < 0.001, "{title}: {target:?}");
for i in 0..2 {
assert_eq!(
app.layout.layers()[i].y,
expected_y[i],
"{title}: {target:?}"
);
assert_eq!(app.layout.layers()[i].x, before[i].x);
assert_eq!(app.layout.layers()[i].height, before[i].height);
}
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
}
}
#[test]
fn alignment_button_updates_selected_layers_and_undo_restores() {
let mut app = Editor::default();
let ctx = egui::Context::default();
app.layout
.apply(
0,
Geometry {
x: 90.0,
y: 60.0,
width: 300.0,
height: 200.0,
},
)
.unwrap();
app.layout.set_selection([true; 2]);
let before = *app.layout.layers();
let output = open_alignment_test_menu(&mut app, &ctx);
let pos = alignment_test_position(&output, "Align top");
frame(
&mut app,
&ctx,
vec![egui::Event::PointerMoved(pos), mouse(pos, true)],
);
frame(&mut app, &ctx, vec![mouse(pos, false)]);
assert_eq!(app.layout.layers()[1].y, 60.0);
assert_eq!(app.layout.layers()[1].x, before[1].x);
assert_eq!(app.layout.layers()[0], before[0]);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
app.open_paste(include_str!("../tests/fixtures/drawio-rectangle.txt").into());
let paste = app.paste.as_ref().unwrap();
assert!(
paste
.values(&app.layout)
.unwrap_err()
.contains("Layer count mismatch")
);
}
}