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

1711 lines
62 KiB
Rust
Raw Blame History

This file contains ambiguous Unicode characters

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

use super::*;
use midra_layout::{AlignTarget, Alignment, Corner, DrawioShape, Geometry, Layout, parse_drawio};
pub struct Editor {
layout: Layout,
corner: Corner,
fields: [String; 4],
error: String,
paste: Option<Paste>,
zoom: f32,
pan: Vec2,
panning: bool,
marquee: Option<Marquee>,
align_target: AlignTarget,
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 {
target: usize,
text: String,
shapes: Vec<DrawioShape>,
choice: usize,
include_size: bool,
include_outline: bool,
error: String,
}
impl Paste {
fn parse(&mut self) {
self.choice = 0;
match parse_drawio(&self.text) {
Ok(shapes) => {
self.shapes = shapes;
self.error.clear();
}
Err(error) => {
self.shapes.clear();
self.error = error;
}
}
}
}
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,
pan: Vec2::ZERO,
panning: false,
marquee: None,
align_target: AlignTarget::Selection,
reference: None,
reference_open: false,
reference_error: String::new(),
};
this.sync();
this
}
}
fn number(n: f64) -> String {
n.to_string()
}
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 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()
&& 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()
},
);
}
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() {
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 let Some(i) = self.layout.selected() {
let g = self.layout.layers()[i];
let [x, y] = self.corner.offsets(g);
self.fields = [number(x), number(y), number(g.width), number(g.height)];
}
self.error.clear();
}
fn open_paste(&mut self, text: String) {
if let Some(target) = self.layout.selected() {
let mut p = Paste {
target,
text,
shapes: Vec::new(),
choice: 0,
include_size: true,
include_outline: false,
error: String::new(),
};
if !p.text.is_empty() {
p.parse();
}
self.paste = Some(p);
} else {
self.error = "Select exactly one layer before pasting.".into();
}
}
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(|v| self.corner.geometry(v[0], v[1], v[2], v[3]));
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!(
"{}\nHorizontal: {} px\nVertical: {} px\nWidth: {} px\nHeight: {} px",
label(i),
number(h),
number(v),
number(g.width),
number(g.height)
)
})
.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.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;
}
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] {
match self.layout.nudge(d[0], d[1]) {
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("drawio-paste")).show(ctx, |ui| {
ui.set_width(530.0);
ui.heading("Paste draw.io geometry");
ui.label(format!("Target: {}", label(p.target)));
ui.label("1 draw.io unit = 1 screen pixel · top-left origin");
ui.label("Paste encoded clipboard text or raw mxGraphModel XML:");
if ui
.add(
egui::TextEdit::multiline(&mut p.text)
.desired_rows(4)
.desired_width(f32::INFINITY),
)
.changed()
{
p.shapes.clear();
p.error.clear();
}
if ui.button("Read geometry").clicked() {
p.parse();
}
if !p.error.is_empty() {
ui.colored_label(AMBER, &p.error);
}
if !p.shapes.is_empty() {
if p.shapes.len() > 1 {
egui::ComboBox::from_label("Rectangle")
.selected_text(&p.shapes[p.choice].id)
.show_ui(ui, |ui| {
for (i, s) in p.shapes.iter().enumerate() {
ui.selectable_value(
&mut p.choice,
i,
format!(
"Cell {} · {} × {}",
s.id, s.geometry.width, s.geometry.height
),
);
}
});
}
ui.checkbox(
&mut p.include_size,
"Include size / format (otherwise position only)",
);
let shape = &p.shapes[p.choice];
ui.add_enabled(
p.include_size && shape.stroke_width > 0.0,
egui::Checkbox::new(&mut p.include_outline, "Include outline in bounds"),
);
if !p.include_size {
ui.small("Outline adjustment requires size import; position-only uses the original top-left.");
} else if shape.stroke_width == 0.0 {
ui.small("No visible outline to include.");
} else {
ui.small(format!("Outline: {} px · extends {} px beyond each edge. Center stays unchanged.", number(shape.stroke_width), number(shape.stroke_width / 2.0)));
}
let before = self.layout.layers()[p.target];
match shape.paste_geometry(before, p.include_size, p.include_outline) {
Ok(after) => {
ui.separator();
ui.columns(2, |cols| {
cols[0].label("Before");
cols[0].label(bounds(before));
cols[1].label("After");
cols[1].label(bounds(after));
});
if after.outside() {
ui.colored_label(
AMBER,
"This rectangle extends outside the screen. Its coordinates are preserved.",
);
}
ui.label("Bounds only; source format, colors and outline appearance are not imported.");
if ui
.add(egui::Button::new("Apply to selected target").fill(PURPLE))
.clicked()
{
match self.layout.apply(p.target, after) {
Ok(()) => {
self.sync();
close = true;
}
Err(e) => p.error = e,
}
}
}
Err(error) => {
ui.colored_label(AMBER, error);
}
}
}
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(), 960.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 FORMAT / VISIBLE BOX", 11.0, MUTED);
ink.card(0.0, 214.0, w, 34.0, FIELD, LINE);
ink.text(
12.0,
223.0,
&format!(
"{} × {} px / {:.4}:1",
number(g.width),
number(g.height),
g.width / g.height
),
13.0,
TEXT,
);
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.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() {
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, "WEBRCS / 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,
"Center convention · device precision unverified",
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 draw.io…", 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_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, "ALIGN TO", 11.0, MUTED);
let half = (w - 12.0) / 2.0;
for (index, title, target) in [
(0, "Selection bounds", AlignTarget::Selection),
(1, "Screen", AlignTarget::Screen),
(2, "Reference: Presenter", AlignTarget::Layer(0)),
(3, "Reference: Slides", AlignTarget::Layer(1)),
] {
let x = if index % 2 == 0 { 0.0 } else { half + 12.0 };
let y = 250.0 + (index / 2) as f32 * 42.0;
ink.button(x, y, half, title, self.align_target == target);
if click(ui, ink, [x, y, half, 34.0], title) {
self.align_target = target;
}
}
for (index, title, alignment) in [
(0, "Align left", Alignment::Left),
(1, "Align top", Alignment::Top),
(2, "Align right", Alignment::Right),
(3, "Align bottom", Alignment::Bottom),
(4, "Center X", Alignment::HorizontalCenter),
(5, "Center Y", Alignment::VerticalCenter),
] {
let x = if index % 2 == 0 { 0.0 } else { half + 12.0 };
let y = 350.0 + (index / 2) as f32 * 46.0;
ink.button(x, y, half, title, false);
if click(ui, ink, [x, y, half, 34.0], title) {
match self.layout.align(alignment, self.align_target) {
Ok(()) => self.sync(),
Err(e) => self.error = e,
}
}
}
ink.text(
0.0,
503.0,
"Alignment changes position, never size.",
12.0,
MUTED,
);
ink.text(0.0, 526.0, "A reference layer stays fixed.", 12.0, MUTED);
ink.line([0.0, 559.0], [w, 559.0], LINE);
ink.text(0.0, 581.0, "WEBRCS / CENTER POSITIONS", 11.0, CYAN);
for (row, i) in self.layout.selected_indices().into_iter().enumerate() {
let y = 615.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, 792.0, w, "Copy selected positions", true);
if click(ui, ink, [0.0, 792.0, w, 34.0], "copy-selected") {
self.copy(ui.ctx());
}
ink.text(
0.0,
849.0,
"Select one layer to edit its size or paste.",
12.0,
MUTED,
);
if !self.error.is_empty() {
ui.put(
Rect::from_min_size(ink.point(0.0, 880.0), Vec2::new(w, 60.0)),
egui::Label::new(egui::RichText::new(&self.error).color(AMBER)).wrap(),
);
}
}
fn workspace(&mut self, ui: &mut egui::Ui) {
let r = ui.max_rect();
let ink = Ink::new(ui, r);
ink.button(24.0, 20.0, 185.0, "Screen 1 · Full HD", false);
ink.text(224.0, 30.0, "1920 × 1080 · fixed for now", 12.0, MUTED);
for (x, w, text) in [
(24.0, 103.0, "Fit screen"),
(139.0, 103.0, "Fit selected"),
(254.0, 80.0, "Undo"),
(346.0, 80.0, "Redo"),
] {
ink.button(x, 67.0, w, text, false);
if click(ui, &ink, [x, 67.0, w, 34.0], text) {
match text {
"Fit screen" => {
self.zoom = 1.0;
self.pan = Vec2::ZERO;
}
"Fit selected" => {
if let Some(g) = self.layout.selection_bounds() {
self.zoom = (1920.0 / g.width).min(1080.0 / g.height) as f32 * 0.8;
self.zoom = self.zoom.clamp(0.02, 32.0);
let c = g.center();
self.pan = Vec2::new(960.0 - c[0] as f32, 540.0 - c[1] as f32);
}
}
"Undo" => {
self.layout.undo();
self.sync();
}
_ => {
self.layout.redo();
self.sync();
}
}
}
}
ink.button(438.0, 67.0, 154.0, "Paste draw.io…", true);
if click(ui, &ink, [438.0, 67.0, 154.0, 34.0], "toolbar-paste") {
self.open_paste(String::new());
}
ink.button(438.0, 20.0, 154.0, "Reference image…", false);
if click(ui, &ink, [438.0, 20.0, 154.0, 34.0], "reference-settings") {
self.reference_open = true;
}
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()) {
(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 choose Reference image…".into()
}),
MUTED,
)
};
ui.put(
Rect::from_min_size(ink.point(25.0, 129.0), Vec2::new(r.width() - 50.0, 58.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) / 1920.0).min((area.height() - 48.0) / 1080.0);
let mut scale = base * self.zoom;
let mut origin = area.center() - Vec2::new(960.0, 540.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.02, 32.0);
scale = base * self.zoom;
self.pan = (p - area.center()) / scale + Vec2::new(960.0, 540.0) - world;
origin = area.center() - Vec2::new(960.0, 540.0) * scale + self.pan * scale;
}
}
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 p = (p - origin) / scale;
let point = [p.x as f64, p.y as f64];
let shift = ui.input(|i| i.modifiers.shift);
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()
&& let Some(p) = pointer
{
let p = (p - origin) / scale;
let hit = 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 {
self.layout.select(hit);
}
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(1920.0, 1080.0) * scale),
);
} else {
screen_artwork(&screen);
}
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 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(),
] {
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() {
let [dx, dy] = self.corner.offsets(g);
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 { 1920.0 } else { 0.0 },
if bottom { 1080.0 } 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:.2} 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:.2} px"),
FontId::proportional(11.0),
AMBER,
);
}
}
ink.text(
24.0,
r.height() - 57.0,
"Drag to move or box-select · Shift-click toggles selection",
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(64.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, 21.0, "MIDRA / LAYOUT", 21.0, TEXT);
ink.line([218.0, 22.0], [218.0, 43.0], LINE);
ink.text(238.0, 26.0, "Offline position helper", 13.0, MUTED);
ink.text(r.width() - 347.0, 27.0, "EIKOS 4K", 12.0, CYAN);
ink.button(r.width() - 212.0, 15.0, 188.0, "Copy coordinates", false);
if click(
ui,
&ink,
[r.width() - 212.0, 15.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,
"Screen pixels / 1920 × 1080",
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);
}
}
impl eframe::App for Editor {
fn update(&mut self, ctx: &egui::Context, _: &mut eframe::Frame) {
self.ui(ctx);
}
}
#[cfg(test)]
mod tests {
use 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 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().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.target, 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 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);
}
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 to selected target" => {
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().target, 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 to selected target"] {
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());
}
#[test]
fn top_and_bottom_buttons_align_rendered_edges_for_every_target() {
for target in [
AlignTarget::Selection,
AlignTarget::Screen,
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 = 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 == title => {
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)]);
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 = 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 == "Align top" => {
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_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());
assert!(app.paste.is_none());
assert!(app.error.contains("exactly one"));
}
}