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

1194 lines
48 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::{
device,
device_send::{self, Plan, Sizing, Target},
};
use std::sync::mpsc::{self, Receiver, TryRecvError};
#[derive(Clone, Copy, Default, PartialEq)]
enum Destination {
#[default]
Skip,
New,
Existing(usize),
}
#[derive(Default)]
pub(super) struct DeviceUi {
pub open: bool,
import_closing: bool,
pub(super) connection_open: bool,
pub(super) prepare_send: bool,
target: Target,
pub(super) allow_program: bool,
pub(super) autoconnect_at_startup: bool,
sizing: Sizing,
pub(super) sending: bool,
message: String,
pub(super) host: String,
pending: Option<Receiver<Result<device::Snapshot, String>>>,
snapshot: Option<device::Snapshot>,
loading: Option<Vec<(usize, midra_layout::MidraLink)>>,
screen: usize,
destinations: Vec<Destination>,
error: String,
}
impl DeviceUi {
pub(super) fn try_startup_connection(&mut self, ctx: &egui::Context) {
if self.autoconnect_at_startup && !self.host.trim().is_empty() {
self.fetch(ctx);
}
}
pub(super) fn reset_mappings(&mut self) {
self.destinations.fill(Destination::Skip);
self.loading = None;
}
pub(super) fn with_connection_preferences(host: String, allow_program: bool) -> Self {
Self {
host,
allow_program,
..Self::default()
}
}
fn linked_plans(&self, layout: &midra_layout::Layout, all: bool) -> Result<Vec<Plan>, String> {
let snapshot = self.snapshot.as_ref().ok_or("Connect to Midra first.")?;
let indices = if all {
(0..layout.layers().len())
.filter(|&i| layout.layer_info(i).midra_link.is_some())
.collect()
} else {
layout.selected_indices()
};
if indices.is_empty() {
return Err("Choose layers and link their Midra destinations first.".into());
}
let mut groups = std::collections::BTreeMap::<String, Vec<(usize, String)>>::new();
for i in indices {
let info = layout.layer_info(i);
let link = info
.midra_link
.as_ref()
.ok_or_else(|| format!("{} has no Midra link.", info.name))?;
groups
.entry(link.screen.clone())
.or_default()
.push((info.id, link.layer.clone()));
}
groups
.into_iter()
.map(|(screen, mappings)| {
let index = snapshot
.screens
.iter()
.position(|s| s.id == screen)
.ok_or_else(|| format!("Linked screen {screen} is unavailable."))?;
Plan::prepare(
snapshot,
layout,
index,
&mappings,
if self.allow_program {
self.target
} else {
Target::Preview
},
self.sizing,
)
})
.collect()
}
pub(super) fn online(&self) -> bool {
self.snapshot.is_some()
}
fn send(&mut self, ctx: &egui::Context, plans: Vec<Plan>) {
let (tx, rx) = mpsc::channel();
self.pending = Some(rx);
self.sending = true;
self.error.clear();
self.message.clear();
let host = self.host.clone();
let ctx = ctx.clone();
std::thread::spawn(move || {
let result = (|| {
let mut last = None;
for (i, plan) in plans.iter().enumerate() {
last = Some(device_send::send(&host, plan).map_err(|e| {
format!(
"Screen {} failed after {i} completed screen sends: {e}",
plan.screen
)
})?);
}
last.ok_or_else(|| "No linked layers to send.".into())
})();
let _ = tx.send(result);
ctx.request_repaint();
});
}
fn fetch(&mut self, ctx: &egui::Context) {
let (tx, rx) = mpsc::channel();
self.pending = Some(rx);
self.snapshot = None;
self.destinations.clear();
self.error.clear();
self.message.clear();
let host = self.host.clone();
let ctx = ctx.clone();
std::thread::spawn(move || {
let result = device::fetch(&host);
let _ = tx.send(result);
ctx.request_repaint();
});
}
fn poll(&mut self) {
let Some(rx) = &self.pending else { return };
let result = match rx.try_recv() {
Ok(result) => result,
Err(TryRecvError::Empty) => return,
Err(TryRecvError::Disconnected) => {
Err("Device reader stopped unexpectedly. Refresh to retry.".into())
}
};
self.pending = None;
let was_sending = std::mem::take(&mut self.sending);
match result {
Ok(snapshot) => {
if was_sending {
self.message =
"Send complete. Preset update sent; geometry verified by device readback."
.into();
}
self.screen = self.screen.min(snapshot.screens.len() - 1);
self.destinations =
vec![Destination::Skip; snapshot.screens[self.screen].layers.len()];
self.snapshot = Some(snapshot);
}
Err(error) => {
self.snapshot = None;
self.error = error;
if was_sending {
self.prepare_send = true;
self.open = true;
}
}
}
}
}
impl Editor {
pub(super) fn midra_load_button(&mut self, ui: &mut egui::Ui, all: bool) {
let enabled = self.device.online() && self.device.pending.is_none();
let tooltip = if self.device.message.is_empty() {
"Read fresh Preview geometry and cropping from Midra into the linked editor layers. Undo restores the previous layout."
} else {
&self.device.message
};
if ui
.add_enabled(
enabled,
egui::Button::new(if self.device.loading.is_some() {
"Loading…"
} else if all {
"Load linked layers"
} else {
"Load mapped layers"
}),
)
.on_hover_text(tooltip)
.clicked()
{
let indices: Vec<_> = if all {
(0..self.layout.layers().len())
.filter(|&i| self.layout.layer_info(i).midra_link.is_some())
.collect()
} else {
self.layout.selected_indices()
};
let links: Result<Vec<_>, String> = indices
.into_iter()
.map(|i| {
let info = self.layout.layer_info(i);
info.midra_link
.clone()
.map(|link| (info.id, link))
.ok_or_else(|| format!("{} has no Midra link.", info.name))
})
.collect();
match links {
Ok(links) if !links.is_empty() => {
self.device.fetch(ui.ctx());
self.device.loading = Some(links);
}
result => {
self.device.error = result.err().unwrap_or_else(|| {
"Choose layers and link their Midra destinations first.".into()
});
self.device.prepare_send = true;
self.device.open = true;
}
}
ui.close_menu();
}
}
fn finish_linked_load(&mut self) {
if self.device.pending.is_some() {
return;
}
let Some(links) = self.device.loading.take() else {
return;
};
let result = self
.device
.snapshot
.as_ref()
.ok_or_else(|| self.device.error.clone())
.and_then(|snapshot| load_linked_layers(&mut self.layout, snapshot, &links));
match result {
Ok(()) => {
self.sync();
self.device.message = format!(
"Loaded {} linked Preview layers. Undo restores the previous layout.",
links.len()
);
}
Err(error) => {
self.device.error = error;
self.device.prepare_send = true;
self.device.open = true;
}
}
}
pub(super) fn open_midra_export(&mut self) {
if let Some(snapshot) = &self.device.snapshot
&& let Some(index) = self.layout.selected_indices().iter().find_map(|&i| {
let link = self.layout.layer_info(i).midra_link.as_ref()?;
snapshot
.screens
.iter()
.position(|screen| screen.id == link.screen)
})
{
self.device.screen = index;
}
self.device.prepare_send = true;
self.device.open = true;
}
pub(super) fn midra_apply_button(&mut self, ui: &mut egui::Ui) {
if ui.add_enabled(
self.device.online() && self.device.pending.is_none(),
egui::Button::new("Apply changes…"),
)
.on_hover_text("Choose layers, destination links and export settings, then click Send mapped layers.")
.on_disabled_hover_text("Connect to Midra and wait for any transfer to finish.")
.clicked() {
self.open_midra_export();
ui.close_menu();
}
}
pub(super) fn midra_send_button(&mut self, ui: &mut egui::Ui) {
let plans = self.device.linked_plans(&self.layout, true);
let enabled = self.device.online() && self.device.pending.is_none();
let tooltip = if self.device.sending {
"Sending and checking readback…".into()
} else if !self.device.message.is_empty() {
self.device.message.clone()
} else {
match &plans {
Ok(plans) => format!(
"Send {} linked screen(s) to {:?} using saved layer destinations.",
plans.len(),
plans[0].target
),
Err(e) => e.clone(),
}
};
if apply_button(
ui,
if self.device.sending {
"Applying…"
} else {
"Send all linked layers"
},
enabled,
)
.on_hover_text(&tooltip)
.on_disabled_hover_text(&tooltip)
.clicked()
{
match plans {
Ok(plans) => {
self.device.send(ui.ctx(), plans);
}
Err(error) => {
self.device.error = error;
self.device.prepare_send = true;
self.device.open = true;
}
}
ui.close_menu();
}
}
fn connection_window(&mut self, ctx: &egui::Context) {
if !self.device.connection_open {
return;
}
let mut open = true;
let before = self.device.host.clone();
egui::Window::new("Midra connection").open(&mut open).collapsible(false)
.default_width(420.0).show(ctx, |ui| {
ui.label("Device IP");
if ui.add_enabled(self.device.pending.is_none(), egui::TextEdit::singleline(&mut self.device.host).hint_text("192.168.…")).changed() {
self.device.snapshot = None;
self.device.reset_mappings();
self.device.error.clear();
self.device.message.clear();
}
ui.weak("Address saved automatically in application settings. Connect reads device data; it does not change layers.");
ui.horizontal(|ui| {
if ui.add_enabled(self.device.pending.is_none(), egui::Button::new(if self.device.online() { "Refresh connection" } else { "Connect" })).clicked() { self.device.fetch(ctx); }
if ui.add_enabled(self.device.online() && self.device.pending.is_none(), egui::Button::new("Disconnect")).clicked() {
self.device.snapshot = None;
self.device.reset_mappings();
self.device.message.clear();
}
});
if self.device.pending.is_some() {
ui.spinner();
ui.label(if self.device.sending { "Sending and checking readback…" } else { "Connecting…" });
if !self.device.sending && ui.button("Cancel connection").clicked() { self.device.pending = None; }
}
if let Some(snapshot) = &self.device.snapshot { ui.label(format!("Online · {}", snapshot.identity)); }
else { ui.label("Offline"); }
if !self.device.error.is_empty() { ui.colored_label(ui.visuals().error_fg_color, &self.device.error); }
if let Some(error) = &self.settings.error { ui.colored_label(ui.visuals().error_fg_color, error); }
});
self.device.connection_open = open;
if before != self.device.host {
self.settings.save(&self.application_settings(ctx));
}
}
pub(super) fn device_window(&mut self, ctx: &egui::Context) {
if !self.device.allow_program {
self.device.target = Target::Preview;
}
self.device.poll();
self.finish_linked_load();
self.connection_window(ctx);
if !self.device.open {
return;
}
let mut open = true;
let mut imported = false;
let mut send_plan = None;
egui::Window::new(if self.device.prepare_send { "Send layers to Midra" } else { "Import layers from Midra" })
.enabled(!self.format_draft.as_ref().is_some_and(|d| d.pending(&self.layout)))
.open(&mut open).default_width(660.0).collapsible(false)
.max_height((ctx.screen_rect().height() - 100.0).max(200.0)).vscroll(true)
.show(ctx, |ui| {
if self.device.prepare_send {
self.transfer_layer_picker(ui, "Choose editor layers to send…");
}
ui.horizontal(|ui| {
if ui.button("Connection settings…").clicked() { self.device.connection_open = true; }
if ui.add_enabled(self.device.online() && self.device.pending.is_none(), egui::Button::new("Refresh layers")).clicked() { self.device.fetch(ctx); }
});
if !self.device.online() && self.device.pending.is_none() { ui.label("Connect to a Midra in Connection settings before transferring layers."); }
if self.device.pending.is_some() {
ui.horizontal(|ui| { ui.spinner(); ui.label(if self.device.sending { "Sending and checking readback…" } else { "Reading device… editing remains available." }); });
if !self.device.sending && ui.button("Cancel read").clicked() { self.device.pending = None; }
}
if !self.device.error.is_empty() { ui.colored_label(ui.visuals().error_fg_color, &self.device.error); }
if !self.device.message.is_empty() { ui.label(&self.device.message); }
if let Some(snapshot) = &self.device.snapshot {
ui.separator();
ui.strong(&snapshot.identity);
let previous = self.device.screen;
egui::ComboBox::from_id_salt("midra_screen")
.selected_text(format!("Screen {}", snapshot.screens[self.device.screen].id))
.show_ui(ui, |ui| {
for (i, screen) in snapshot.screens.iter().enumerate() { ui.selectable_value(&mut self.device.screen, i, format!("Screen {} · {} × {}", screen.id, screen.resolution[0], screen.resolution[1])); }
});
let screen = &snapshot.screens[self.device.screen];
if previous != self.device.screen { self.device.destinations = vec![Destination::Skip; screen.layers.len()]; }
ui.label(format!("Captured Preview bank: {}. Refresh to read subsequent changes.", screen.preview_bank));
let matches = screen.resolution == self.layout.formats().output;
if !matches { ui.colored_label(ui.visuals().warn_fg_color, format!("Device canvas {} × {}; editor {} × {}. Match output resolution before importing.", screen.resolution[0], screen.resolution[1], self.layout.formats().output[0], self.layout.formats().output[1])); }
if self.device.prepare_send {
let screen_id = screen.id.clone();
let mut targets: std::collections::BTreeMap<_, _> = self.layout.selected_indices().into_iter().map(|i| {
let info = self.layout.layer_info(i);
(info.id, info.midra_link.as_ref().filter(|link| link.screen == screen_id).map(|link| link.layer.clone()).unwrap_or_default())
}).collect();
let previous = targets.clone();
send_plan = send_review(ui, &self.layout, snapshot, self.device.screen, &mut targets,
&mut self.device.target, &mut self.device.sizing, self.device.pending.is_some(), self.device.allow_program);
for (id, destination) in targets {
if previous.get(&id) != Some(&destination) {
let i = (0..self.layout.layers().len()).find(|&i| self.layout.layer_info(i).id == id).unwrap();
let link = (!destination.is_empty()).then_some(midra_layout::MidraLink { screen: screen_id.clone(), layer: destination });
if let Err(e) = self.layout.set_midra_link(i, link) { self.device.error = e; }
}
}
self.midra_load_button(ui, false);
self.midra_send_button(ui);
return;
}
egui::ScrollArea::vertical().max_height(300.0).show(ui, |ui| {
for (i, layer) in screen.layers.iter().enumerate() {
ui.horizontal(|ui| {
ui.label(format!("Layer {} · {}", layer.id, layer.source));
ui.add_enabled_ui(layer.unsupported.is_none(), |ui| {
let destination = &mut self.device.destinations[i];
let label = match *destination {
Destination::Skip => "Do not import".into(),
Destination::New => "New layer".into(),
Destination::Existing(id) => self.layout.layers().iter().enumerate()
.find(|(j, _)| self.layout.layer_info(*j).id == id)
.map(|(j, _)| self.layout.layer_label(j)).unwrap_or("Removed layer — choose again".into()),
};
egui::ComboBox::from_id_salt(("midra_destination", i)).selected_text(label).show_ui(ui, |ui| {
ui.selectable_value(destination, Destination::Skip, "Do not import");
ui.selectable_value(destination, Destination::New, "New layer");
for j in 0..self.layout.layers().len() {
ui.add_enabled_ui(self.layout.visible(j) && !self.layout.locked(j), |ui| {
ui.selectable_value(destination, Destination::Existing(self.layout.layer_info(j).id), self.layout.layer_label(j));
});
}
});
});
ui.label(format!("{} × {} at {}, {}", midra_layout::view_pixels(layer.geometry.width), midra_layout::view_pixels(layer.geometry.height), midra_layout::view_pixels(layer.geometry.x), midra_layout::view_pixels(layer.geometry.y)));
});
if let Some(reason) = &layer.unsupported { ui.weak(reason); }
}
});
ui.weak("Centered layers import visible bounds and crop framing. Other modes import container geometry only. Source routing, shared input settings and effects stay on the device.");
let selected: Vec<_> = self.device.destinations.iter().enumerate().filter_map(|(i, dest)| (*dest != Destination::Skip).then_some(i)).collect();
ui.label(format!("{} device layers to import", selected.len()));
if apply_button(ui, "Import layers", matches && !selected.is_empty()).clicked() {
match self.apply_device_import() { Ok(()) => imported = true, Err(e) => self.device.error = e }
}
ui.weak("Choose an existing destination or New layer beside each device layer. Your editor selection does not limit this import.");
}
ui.separator();
});
if !open
&& !self.device.prepare_send
&& self
.device
.destinations
.iter()
.any(|d| *d != Destination::Skip)
{
self.device.import_closing = true;
}
if self.device.import_closing {
open = true;
match pending_close(ctx, "device-import-close", &self.device.error) {
Some(true) => {
self.device.import_closing = false;
match self.apply_device_import() {
Ok(()) => imported = true,
Err(e) => self.device.error = e,
}
}
Some(false) => {
self.device.import_closing = false;
self.device.reset_mappings();
open = false;
}
None => {}
}
}
self.device.open = open;
if let Some(plan) = send_plan {
self.device.send(ctx, vec![plan]);
}
if imported {
self.sync();
self.device.error.clear();
self.device.open = false;
self.device.reset_mappings();
}
}
fn apply_device_import(&mut self) -> Result<(), String> {
let snapshot = self
.device
.snapshot
.as_ref()
.ok_or("Connect to Midra first.")?;
let screen = &snapshot.screens[self.device.screen];
if screen.resolution != self.layout.formats().output {
return Err("Match output resolution before importing.".into());
}
let selected: Vec<_> = self
.device
.destinations
.iter()
.enumerate()
.filter_map(|(i, d)| (*d != Destination::Skip).then_some(i))
.collect();
screen.import(&selected)?;
let values: Vec<_> = selected
.iter()
.map(|&i| {
let target = match self.device.destinations[i] {
Destination::Existing(id) => Some(id),
_ => None,
};
(target, screen.layers[i].geometry, screen.layers[i].framing)
})
.collect();
self.layout.import_device_layers(&values)
}
}
#[allow(clippy::too_many_arguments)]
fn send_review(
ui: &mut egui::Ui,
layout: &midra_layout::Layout,
snapshot: &device::Snapshot,
screen_index: usize,
targets: &mut std::collections::BTreeMap<usize, String>,
target_mode: &mut Target,
sizing: &mut Sizing,
busy: bool,
allow_program: bool,
) -> Option<Plan> {
let screen = &snapshot.screens[screen_index];
if !allow_program {
*target_mode = Target::Preview;
}
ui.horizontal(|ui| {
ui.label("Target");
ui.selectable_value(target_mode, Target::Preview, "Preview");
if allow_program {
ui.selectable_value(target_mode, Target::Program, "Program");
}
});
ui.horizontal(|ui| {
ui.label("Device container");
ui.selectable_value(sizing, Sizing::OutputBox, "Output-sized");
ui.selectable_value(sizing, Sizing::SourceAspect, "Source aspect");
});
let selected = layout.selected_indices();
targets.retain(|id, _| selected.iter().any(|&i| layout.layer_info(i).id == *id));
ui.strong(format!(
"{} selected editor layers → Screen {}",
selected.len(),
screen.id
));
if selected.is_empty() {
ui.label("Select editor layers to prepare their destination mapping.");
}
let mut used = std::collections::BTreeSet::new();
for i in selected {
let info = layout.layer_info(i);
let id = info.id;
if let Some(link) = &info.midra_link {
ui.weak(format!(
"Saved link: screen {} · layer {}",
link.screen, link.layer
));
}
let target = targets.entry(id).or_default();
ui.separator();
ui.horizontal(|ui| {
ui.strong(layout.layer_label(i));
egui::ComboBox::from_id_salt(("midra_send_target", id))
.selected_text(if target.is_empty() {
"Choose Midra layer".into()
} else {
format!("Screen {} · Layer {target}", screen.id)
})
.show_ui(ui, |ui| {
ui.selectable_value(target, String::new(), "Choose Midra layer");
for layer in &screen.layers {
ui.selectable_value(
target,
layer.id.clone(),
format!("Screen {} · Layer {}", screen.id, layer.id),
);
}
});
});
if let Some(layer) = screen.layers.iter().find(|layer| layer.id == *target) {
if !used.insert(target.clone()) {
ui.colored_label(
ui.visuals().error_fg_color,
"Each editor layer needs a different Midra destination.",
);
}
ui.label(format!(
"Preview snapshot container: {}",
container_label(layer.container)
));
if let Some(reason) = &layer.unsupported {
ui.weak(reason);
}
}
ui.label(format!(
"Requested visible box: {}",
container_label(layout.layers()[i])
));
if let Ok(mapping) = layout.formats().mapping(i, layout.layers()[i]) {
ui.label(format!(
"Content zoom: {:.1}% · offset: {:.1}, {:.1}",
mapping.framing.zoom * 100.0,
mapping.framing.offset[0],
mapping.framing.offset[1]
));
}
}
ui.separator();
let mappings: Vec<_> = targets
.iter()
.map(|(id, destination)| (*id, destination.clone()))
.collect();
match Plan::prepare(
snapshot,
layout,
screen_index,
&mappings,
*target_mode,
*sizing,
) {
Ok(plan) => {
ui.label(format!(
"{:?} · screen {} · physical bank {} · {} changed fields",
plan.target,
plan.screen,
plan.bank,
plan.changes.len()
));
ui.collapsing("Exact device changes", |ui| {
for change in &plan.changes {
ui.label(format!(
"{}: {} → {}",
change.path[8..].join("/"),
change.before,
change.after
));
}
});
if apply_button(ui, "Send mapped layers", !busy).clicked() {
return Some(plan);
}
if plan.changes.is_empty() {
ui.weak("Geometry matches the stored values. Send applies them to the hardware.");
}
}
Err(error) => {
ui.colored_label(ui.visuals().warn_fg_color, error);
}
}
None
}
fn load_linked_layers(
layout: &mut midra_layout::Layout,
snapshot: &device::Snapshot,
links: &[(usize, midra_layout::MidraLink)],
) -> Result<(), String> {
let mut values = Vec::new();
for (id, link) in links {
let screen = snapshot
.screens
.iter()
.find(|s| s.id == link.screen)
.ok_or_else(|| format!("Linked screen {} is unavailable.", link.screen))?;
if screen.resolution != layout.formats().output {
return Err(format!(
"Screen {} resolution does not match the editor output.",
screen.id
));
}
let index = screen
.layers
.iter()
.position(|l| l.id == link.layer)
.ok_or_else(|| {
format!(
"Screen {} layer {} is unavailable.",
link.screen, link.layer
)
})?;
screen.import(&[index])?;
let layer = &screen.layers[index];
values.push((Some(*id), layer.geometry, layer.framing));
}
layout.import_device_layers(&values)
}
fn container_label(geometry: midra_layout::Geometry) -> String {
let center = geometry.center();
format!(
"{:.1} × {:.1} px · center {:.1}, {:.1}",
geometry.width, geometry.height, center[0], center[1]
)
}
#[cfg(test)]
mod tests {
use super::*;
fn linked_test_snapshot() -> device::Snapshot {
let layer = serde_json::json!({"position":{"pp":{"posH":500,"posV":300}},"size":{"pp":{"sizeH":640,"sizeV":360}},"source":{"pp":{"input":"INPUT_4"}},"status":{"pp":{"contentWidth":1920,"contentHeight":1080}},"crop":{"pp":{"left":0,"right":0,"top":0,"bottom":0,"aspectOverride":"GLOBAL_SETTING"}},"mask":{"pp":{"left":0,"right":0,"top":0,"bottom":0}}});
let raw = serde_json::json!({"device": {"transition":{"screenList":{"items":{"1":{"status":{"pp":{"transition":"AT_DOWN"}}}}}},"screenList":{"items":{"1":{"canvas":{"status":{"size":{"pp":{"sizeH":1920,"sizeV":1080}}}},"presetList":{"items":{"UP":{"liveLayerList":{"items":{"1":layer,"2":layer}}},"DOWN":{"liveLayerList":{"items":{"1":layer,"2":layer}}}}}}}}}});
device::Snapshot::parse(
&serde_json::json!({"type":"Eikos 4K","version":{"major":3,"minor":3,"patch":10}}),
&raw,
)
.unwrap()
}
#[test]
fn closing_import_review_applies_locally_and_never_starts_a_send() {
let ctx = egui::Context::default();
let mut app = Editor::default();
let before = app.layout.layers().clone();
app.device.snapshot = Some(linked_test_snapshot());
app.device.destinations = vec![Destination::Existing(1), Destination::Skip];
app.device.open = true;
app.device.import_closing = true;
super::super::tests::click_text(&mut app, &ctx, "Apply");
assert!(!app.device.open);
assert!(!app.device.sending);
assert!(app.device.pending.is_none());
assert_ne!(*app.layout.layers(), before);
app.layout.undo();
assert_eq!(*app.layout.layers(), before);
}
#[test]
fn startup_connection_requires_opt_in_and_an_address_and_never_sends() {
let ctx = egui::Context::default();
for (enabled, host, expected) in [
(false, "invalid-ip", false),
(true, " ", false),
(true, "invalid-ip", true),
] {
// Invalid IP fails before any network access, while exercising the real worker path.
let mut state = DeviceUi {
autoconnect_at_startup: enabled,
host: host.into(),
..Default::default()
};
state.try_startup_connection(&ctx);
assert_eq!(state.pending.is_some(), expected);
assert!(!state.sending);
assert!(!state.online());
}
}
#[test]
fn saved_screen_distinguishes_same_numbered_layers_and_restores_picker() {
let mut app = Editor::default();
let mut snapshot = linked_test_snapshot();
let mut second = snapshot.screens[0].clone();
second.id = "2".into();
second.layers[0].geometry.x += 200.0;
snapshot.screens.push(second);
let mut links = Vec::new();
for i in 0..2 {
let link = midra_layout::MidraLink {
screen: (i + 1).to_string(),
layer: "1".into(),
};
app.layout.set_midra_link(i, Some(link.clone())).unwrap();
links.push((app.layout.layer_info(i).id, link));
}
load_linked_layers(&mut app.layout, &snapshot, &links).unwrap();
assert_eq!(
app.layout.layers()[0],
snapshot.screens[0].layers[0].geometry
);
assert_eq!(
app.layout.layers()[1],
snapshot.screens[1].layers[0].geometry
);
assert_ne!(app.layout.layers()[0], app.layout.layers()[1]);
app.device.snapshot = Some(snapshot);
for i in [1, 0] {
app.layout.select(Some(i));
app.open_midra_export();
assert_eq!(app.device.screen, i);
assert!(app.device.pending.is_none());
}
}
#[test]
fn linked_load_is_atomic_undoable_and_keeps_links() {
let snapshot = linked_test_snapshot();
let mut layout = midra_layout::Layout::default();
let link = midra_layout::MidraLink {
screen: "1".into(),
layer: "2".into(),
};
layout.set_midra_link(0, Some(link.clone())).unwrap();
let id = layout.layer_info(0).id;
let before = layout.layers().clone();
let bad = midra_layout::MidraLink {
screen: "9".into(),
layer: "1".into(),
};
assert!(
load_linked_layers(&mut layout, &snapshot, &[(id, link.clone()), (id, bad)]).is_err()
);
assert_eq!(*layout.layers(), before);
load_linked_layers(&mut layout, &snapshot, &[(id, link.clone())]).unwrap();
assert_eq!(layout.layers()[0], snapshot.screens[0].layers[1].geometry);
assert_eq!(layout.layers()[1], before[1]);
assert_eq!(layout.layer_info(0).midra_link, Some(link.clone()));
layout.undo();
assert_eq!(*layout.layers(), before);
layout.set_locked(0, true);
assert!(load_linked_layers(&mut layout, &snapshot, &[(id, link)]).is_err());
assert_eq!(*layout.layers(), before);
}
#[test]
fn linked_load_finishes_from_fresh_read_without_sending() {
let mut app = Editor::default();
let link = midra_layout::MidraLink {
screen: "1".into(),
layer: "1".into(),
};
app.layout.set_midra_link(0, Some(link.clone())).unwrap();
app.device.loading = Some(vec![(app.layout.layer_info(0).id, link)]);
let (tx, rx) = mpsc::channel();
app.device.pending = Some(rx);
let snapshot = linked_test_snapshot();
let expected = snapshot.screens[0].layers[0].geometry;
tx.send(Ok(snapshot)).unwrap();
app.device.poll();
app.finish_linked_load();
assert_eq!(app.layout.layers()[0], expected);
assert!(app.device.loading.is_none());
assert!(app.device.pending.is_none());
assert!(!app.device.sending);
assert!(!app.device.open);
assert!(app.device.message.contains("Loaded 1"));
}
#[test]
fn all_linked_plans_include_hidden_locked_unselected_layers_across_screens() {
let mut snapshot = linked_test_snapshot();
let second = snapshot.raw["device"]["screenList"]["items"]["1"].clone();
snapshot.raw["device"]["screenList"]["items"]["2"] = second;
let transition = snapshot.raw["device"]["transition"]["screenList"]["items"]["1"].clone();
snapshot.raw["device"]["transition"]["screenList"]["items"]["2"] = transition;
let mut screen = snapshot.screens[0].clone();
screen.id = "2".into();
snapshot.screens.push(screen);
let mut state = DeviceUi {
snapshot: Some(snapshot),
..Default::default()
};
let mut layout = midra_layout::Layout::default();
for i in 0..2 {
layout
.set_midra_link(
i,
Some(midra_layout::MidraLink {
screen: (i + 1).to_string(),
layer: "1".into(),
}),
)
.unwrap();
}
layout.set_visible(0, false);
layout.set_locked(1, true);
layout.select(None);
assert!(state.linked_plans(&layout, false).is_err());
let plans = state.linked_plans(&layout, true).unwrap();
assert_eq!(plans.len(), 2);
assert_eq!(plans[0].screen, "1");
assert_eq!(plans[1].screen, "2");
assert!(plans.iter().all(|p| !p.changes.is_empty()));
state.reset_mappings();
assert_eq!(state.linked_plans(&layout, true).unwrap().len(), 2);
layout
.set_midra_link(
1,
Some(midra_layout::MidraLink {
screen: "1".into(),
layer: "1".into(),
}),
)
.unwrap();
assert!(state.linked_plans(&layout, true).is_err());
layout.set_midra_link(1, None).unwrap();
assert_eq!(state.linked_plans(&layout, true).unwrap().len(), 1);
}
#[test]
fn program_destination_is_hidden_and_reset_until_enabled() {
for allow in [false, true] {
let ctx = egui::Context::default();
let layout = midra_layout::Layout::default();
let snapshot = device::Snapshot {
identity: "Test".into(),
raw: serde_json::Value::Null,
screens: vec![device::Screen {
id: "1".into(),
resolution: [1920, 1080],
preview_bank: "UP".into(),
layers: vec![],
}],
};
let mut target = Target::Program;
let mut targets = Default::default();
let output = ctx.run(egui::RawInput::default(), |ctx| {
egui::CentralPanel::default().show(ctx, |ui| {
send_review(
ui,
&layout,
&snapshot,
0,
&mut targets,
&mut target,
&mut Sizing::OutputBox,
false,
allow,
);
});
});
assert_eq!(
target,
if allow {
Target::Program
} else {
Target::Preview
}
);
let program_visible = output.shapes.iter().any(|s| matches!(&s.shape, egui::epaint::Shape::Text(t) if t.galley.job.text == "Program"));
assert_eq!(program_visible, allow);
}
}
#[test]
fn send_all_linked_starts_without_opening_export_window() {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.device.snapshot = Some(linked_test_snapshot());
// Empty host ensures the worker cannot contact real hardware.
app.device.host.clear();
app.layout
.set_midra_link(
0,
Some(midra_layout::MidraLink {
screen: "1".into(),
layer: "1".into(),
}),
)
.unwrap();
app.layout.select(None);
let mut pos = egui::Pos2::ZERO;
for events in [vec![], vec![]] {
let _ = ctx.run(
egui::RawInput {
events,
..Default::default()
},
|ctx| {
egui::CentralPanel::default().show(ctx, |ui| {
pos = ui.cursor().min + Vec2::new(30.0, 10.0);
app.midra_send_button(ui);
});
},
);
}
for pressed in [true, false] {
let _ = ctx.run(
egui::RawInput {
events: vec![
egui::Event::PointerMoved(pos),
super::super::tests::mouse(pos, pressed),
],
..Default::default()
},
|ctx| {
egui::CentralPanel::default().show(ctx, |ui| app.midra_send_button(ui));
},
);
}
assert!(app.device.sending);
assert!(app.device.pending.is_some());
assert!(!app.device.open);
assert!(!app.device.prepare_send);
}
#[test]
fn status_apply_opens_mapping_without_writing_even_when_linked() {
for linked in [false, true] {
let ctx = egui::Context::default();
let mut app = Editor::default();
app.device.snapshot = Some(linked_test_snapshot());
app.layout.select(Some(0));
if linked {
app.layout
.set_midra_link(
0,
Some(midra_layout::MidraLink {
screen: "1".into(),
layer: "1".into(),
}),
)
.unwrap();
assert!(app.device.linked_plans(&app.layout, false).is_ok());
}
let before = app.layout.layers().clone();
super::super::tests::frame(&mut app, &ctx, vec![]);
let output = super::super::tests::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 changes…" => {
Some(t.pos + Vec2::new(8.0, 6.0))
}
_ => None,
})
.expect("status apply button");
for pressed in [true, false] {
super::super::tests::frame(
&mut app,
&ctx,
vec![
egui::Event::PointerMoved(pos),
super::super::tests::mouse(pos, pressed),
],
);
}
assert!(app.device.open && app.device.prepare_send);
assert!(app.device.pending.is_none());
assert_eq!(*app.layout.layers(), before);
}
}
#[test]
fn send_review_only_maps_selected_layers_and_never_mutates_layout() {
let ctx = egui::Context::default();
let mut layout = midra_layout::Layout::default();
layout.select(Some(1));
let before = layout.layers().clone();
let selected_id = layout.layer_info(1).id;
let mut targets = std::collections::BTreeMap::from([
(layout.layer_info(0).id, "1".into()),
(selected_id, "2".into()),
]);
let screen = device::Screen {
id: "1".into(),
resolution: [1920, 1080],
preview_bank: "UP".into(),
layers: vec![],
};
let snapshot = device::Snapshot {
identity: "Eikos".into(),
screens: vec![screen.clone()],
raw: serde_json::Value::Null,
};
let _ = ctx.run(egui::RawInput::default(), |ctx| {
egui::CentralPanel::default().show(ctx, |ui| {
send_review(
ui,
&layout,
&snapshot,
0,
&mut targets,
&mut Target::Preview,
&mut Sizing::OutputBox,
false,
false,
)
});
});
assert_eq!(
targets,
std::collections::BTreeMap::from([(selected_id, "2".into())])
);
assert_eq!(*layout.layers(), before);
layout.select(None);
let _ = ctx.run(egui::RawInput::default(), |ctx| {
egui::CentralPanel::default().show(ctx, |ui| {
send_review(
ui,
&layout,
&snapshot,
0,
&mut targets,
&mut Target::Preview,
&mut Sizing::OutputBox,
false,
false,
)
});
});
assert!(targets.is_empty());
}
#[test]
fn successful_read_sets_online_and_failure_clears_it() {
let mut state = DeviceUi::default();
assert!(!state.online());
let (tx, rx) = mpsc::channel();
state.pending = Some(rx);
tx.send(Ok(device::Snapshot {
identity: "Eikos".into(),
raw: serde_json::Value::Null,
screens: vec![device::Screen {
id: "1".into(),
resolution: [1920, 1080],
preview_bank: "UP".into(),
layers: vec![],
}],
}))
.unwrap();
state.poll();
assert!(state.online());
let (tx, rx) = mpsc::channel();
state.pending = Some(rx);
tx.send(Err("Unavailable".into())).unwrap();
state.poll();
assert!(!state.online());
}
#[test]
fn disconnected_reader_reports_error_and_can_retry() {
let (tx, rx) = mpsc::channel();
let mut state = DeviceUi {
pending: Some(rx),
..Default::default()
};
state.poll();
assert!(state.pending.is_some());
drop(tx);
state.poll();
assert!(state.pending.is_none());
assert!(state.error.contains("Refresh"));
}
#[test]
fn canceled_read_cannot_install_a_late_snapshot() {
let (tx, rx) = mpsc::channel();
let mut state = DeviceUi {
pending: Some(rx),
..Default::default()
};
state.pending = None;
assert!(tx.send(Err("late response".into())).is_err());
state.poll();
assert!(state.snapshot.is_none());
assert!(state.error.is_empty());
}
#[test]
fn connection_window_does_not_read_or_modify_on_open() {
let ctx = egui::Context::default();
let mut app = Editor::default();
let before = app.layout.layers().clone();
app.device.host = "192.168.10.143".into();
let saved = app.application_settings(&ctx);
let mut app = Editor::with_settings(&ctx, settings::Store::default(), saved);
assert_eq!(app.device.host, "192.168.10.143");
assert!(!app.device.online());
app.device.connection_open = true;
super::super::tests::frame(&mut app, &ctx, vec![]);
assert!(app.device.pending.is_none());
assert!(!app.device.open);
app.device.connection_open = false;
app.device.open = true;
super::super::tests::frame(&mut app, &ctx, vec![]);
assert!(!app.device.connection_open);
assert!(app.device.pending.is_none());
assert_eq!(*app.layout.layers(), before);
}
}