1076 lines
44 KiB
Rust
1076 lines
44 KiB
Rust
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,
|
||
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 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.device.prepare_send = true;
|
||
self.device.open = true;
|
||
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 preferences. 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" })
|
||
.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 ui.add_enabled(matches && !selected.is_empty(), egui::Button::new("Import layers")).clicked() {
|
||
let result = screen.import(&selected).and_then(|_| {
|
||
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)
|
||
});
|
||
match result { 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();
|
||
});
|
||
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;
|
||
}
|
||
}
|
||
}
|
||
|
||
#[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!("Midra layer {target}")
|
||
})
|
||
.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!("Layer {}", 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 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 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);
|
||
}
|
||
}
|