1711 lines
62 KiB
Rust
1711 lines
62 KiB
Rust
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"));
|
||
}
|
||
}
|