3111 lines
119 KiB
Rust
3111 lines
119 KiB
Rust
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")
|
||
);
|
||
}
|
||
}
|