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

1718 lines
70 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, Debug, Default, PartialEq)]
pub(super) enum TransferScope {
#[default]
All,
Selected,
Folder(String),
}
impl TransferScope {
fn indices(&self, layout: &midra_layout::Layout) -> Vec<usize> {
match self {
Self::All => (0..layout.layers().len()).collect(),
Self::Selected => layout.selected_indices(),
Self::Folder(folder) => layout.folder_members(folder),
}
}
fn label(&self) -> String {
match self {
Self::All => "All layers".into(),
Self::Selected => "Only selected layers".into(),
Self::Folder(folder) => format!("Folder: {folder}"),
}
}
}
#[derive(Clone, Copy, Default, PartialEq)]
enum Destination {
#[default]
Skip,
New,
Existing(usize),
}
#[derive(Default)]
pub(super) struct DeviceUi {
pub(super) input_edits: input_ui::InputEdits,
pub open: bool,
pub(super) scope: TransferScope,
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>,
mapping_scope: Option<(TransferScope, Vec<usize>, String)>,
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.mapping_scope = None;
self.loading = None;
}
pub(super) fn with_connection_preferences(host: String, allow_program: bool) -> Self {
Self {
host,
allow_program,
..Self::default()
}
}
fn scoped_links(&self, layout: &midra_layout::Layout) -> Vec<(usize, midra_layout::MidraLink)> {
self.scope
.indices(layout)
.into_iter()
.filter_map(|i| {
let info = layout.layer_info(i);
info.midra_link.clone().map(|link| (info.id, link))
})
.collect()
}
pub(super) fn set_scope(&mut self, scope: TransferScope) {
if self.scope != scope {
self.scope = scope;
self.destinations.fill(Destination::Skip);
self.mapping_scope = None;
self.message.clear();
self.error.clear();
}
}
pub(super) fn follow_folder(&mut self, folder: &str) {
if matches!(self.scope, TransferScope::Folder(_)) {
self.set_scope(TransferScope::Folder(folder.into()));
}
}
fn linked_plans(&self, layout: &midra_layout::Layout) -> Result<Vec<Plan>, String> {
let snapshot = self.snapshot.as_ref().ok_or("Connect to Midra first.")?;
let links = self.scoped_links(layout);
if links.is_empty() {
return Err(
"No linked layers in this scope. Choose a scope and map its Midra destinations."
.into(),
);
}
let mut groups = std::collections::BTreeMap::<String, Vec<(usize, String)>>::new();
let mut used = std::collections::BTreeSet::new();
for (id, link) in links {
if !used.insert((link.screen.clone(), link.layer.clone())) {
return Err("Several layers in this scope share a Midra destination. Choose one folder, use Only selected layers, or remap the conflicting links.".into());
}
groups
.entry(link.screen)
.or_default()
.push((id, link.layer));
}
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."))?;
let mut plan = Plan::prepare(
snapshot,
layout,
index,
&mappings,
if self.allow_program {
self.target
} else {
Target::Preview
},
self.sizing,
)?;
self.input_edits
.extend_plan(snapshot, &mappings, &mut plan)?;
Ok(plan)
})
.collect()
}
fn seed_import_mapping(&mut self, layout: &midra_layout::Layout) {
let Some(snapshot) = &self.snapshot else {
return;
};
let screen = &snapshot.screens[self.screen];
let indices = self.scope.indices(layout);
let key = (
self.scope.clone(),
indices
.iter()
.map(|&i| layout.layer_info(i).id)
.collect::<Vec<_>>(),
screen.id.clone(),
);
if self.mapping_scope.as_ref() == Some(&key) {
return;
}
if self.mapping_scope.is_some() || self.destinations.len() != screen.layers.len() {
self.destinations = vec![Destination::Skip; screen.layers.len()];
}
for (j, layer) in screen.layers.iter().enumerate() {
if self.destinations[j] != Destination::Skip || layer.unsupported.is_some() {
continue;
}
let matches = indices
.iter()
.copied()
.filter(|&i| {
layout.visible(i)
&& !layout.locked(i)
&& layout
.layer_info(i)
.midra_link
.as_ref()
.is_some_and(|link| link.screen == screen.id && link.layer == layer.id)
})
.collect::<Vec<_>>();
if let [i] = matches.as_slice() {
self.destinations[j] = Destination::Existing(layout.layer_info(*i).id);
}
}
self.mapping_scope = Some(key);
}
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.mapping_scope = None;
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 advanced_input_controls(&mut self, ui: &mut egui::Ui, i: usize) {
self.device.input_edits.show(
ui,
self.device.snapshot.as_ref(),
self.layout.layer_info(i).midra_link.as_ref(),
);
}
pub(super) fn layer_mapping_controls(&mut self, ui: &mut egui::Ui, i: usize) {
let original = self.layout.layer_info(i).midra_link.clone();
let mut link = original.clone();
ui.label("Midra screen / layer");
ui.small("Saved with this layer. Linked sends and loads use this screen and layer. Editing the link does not contact the device.");
if let Some(mapped) = &mut link {
if let Some(snapshot) = &self.device.snapshot {
egui::ComboBox::from_id_salt("property-midra-screen")
.selected_text(format!("Screen {}", mapped.screen))
.show_ui(ui, |ui| {
for screen in &snapshot.screens {
if ui
.selectable_value(
&mut mapped.screen,
screen.id.clone(),
format!("Screen {}", screen.id),
)
.changed()
&& !screen.layers.iter().any(|layer| layer.id == mapped.layer)
&& let Some(layer) = screen.layers.first()
{
mapped.layer = layer.id.clone();
}
}
});
egui::ComboBox::from_id_salt("property-midra-layer")
.selected_text(format!("Layer {}", mapped.layer))
.show_ui(ui, |ui| {
if let Some(screen) = snapshot
.screens
.iter()
.find(|screen| screen.id == mapped.screen)
{
for layer in &screen.layers {
ui.selectable_value(
&mut mapped.layer,
layer.id.clone(),
format!("Layer {}", layer.id),
);
}
}
});
} else {
ui.small("Offline: enter the screen and layer numbers, or connect to choose from the device.");
for (label, value) in [
("Screen ", &mut mapped.screen),
("Layer ", &mut mapped.layer),
] {
let mut number = value.parse::<u64>().unwrap_or(1);
if ui
.add(
egui::DragValue::new(&mut number)
.range(1..=9_999_999_999_999_999_u64)
.prefix(label),
)
.changed()
{
*value = number.to_string();
}
}
}
if ui.button("Unmap").clicked() {
link = None;
}
} else {
ui.label("Unmapped — excluded from linked sends and loads.");
if ui.button("Link to Midra layer").clicked() {
link = self.device.snapshot.as_ref().and_then(|snapshot| {
snapshot.screens.iter().find_map(|screen| {
screen.layers.first().map(|layer| midra_layout::MidraLink {
screen: screen.id.clone(),
layer: layer.id.clone(),
})
})
});
if self.device.snapshot.is_none() {
link = Some(midra_layout::MidraLink {
screen: "1".into(),
layer: "1".into(),
});
}
}
}
if link != original {
match self.layout.set_midra_link(i, link) {
Ok(()) => {
self.device.mapping_scope = None;
self.sync();
}
Err(error) => {
ui.colored_label(ui.visuals().error_fg_color, error);
}
}
}
}
pub(super) fn midra_load_button(&mut self, ui: &mut egui::Ui) {
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 {
match self.device.scope {
TransferScope::All => "Load linked layers",
TransferScope::Selected => "Load selected links",
TransferScope::Folder(_) => "Load folder links",
}
}),
)
.on_hover_text(tooltip)
.clicked()
{
self.start_scoped_load(ui.ctx());
ui.close_menu();
}
}
fn start_scoped_load(&mut self, ctx: &egui::Context) {
let links = self.device.scoped_links(&self.layout);
if links.is_empty() {
self.device.error =
"No linked layers in this scope. Map their destinations first.".into();
self.device.prepare_send = true;
self.device.open = true;
return;
}
self.device.fetch(ctx);
self.device.loading = Some(links);
}
pub(super) fn midra_scope_picker(&mut self, ui: &mut egui::Ui) {
let before = self.device.scope.clone();
egui::ComboBox::from_id_salt("midra-transfer-scope")
.width(175.0)
.selected_text(self.device.scope.label())
.show_ui(ui, |ui| {
ui.selectable_value(&mut self.device.scope, TransferScope::All, "All layers");
ui.selectable_value(&mut self.device.scope, TransferScope::Selected, "Only selected layers");
ui.separator();
for folder in self.layout.folders() {
ui.selectable_value(&mut self.device.scope, TransferScope::Folder(folder.clone()), format!("Folder: {folder}"));
}
}).response.on_hover_text("Scope for both Midra send and load. In Folder mode, clicking a folder in the layer list switches the scope.");
if before != self.device.scope {
self.device.destinations.fill(Destination::Skip);
self.device.mapping_scope = None;
self.device.error.clear();
self.device.message.clear();
}
}
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
.device
.scope
.indices(&self.layout)
.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);
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 {
match self.device.scope {
TransferScope::All => "Send all linked layers",
TransferScope::Selected => "Send selected links",
TransferScope::Folder(_) => "Send folder links",
}
},
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.input_edits.clear();
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.input_edits.clear();
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| {
ui.horizontal(|ui| {
ui.label("Apply to");
self.midra_scope_picker(ui);
});
if self.device.scope == TransferScope::Selected {
self.transfer_layer_picker(ui, "Choose selected layers…");
}
let scope_indices = self.device.scope.indices(&self.layout);
ui.weak(format!("{} editor layers in scope · {} saved links. Unlinked layers are skipped by linked send/load.", scope_indices.len(), self.device.scoped_links(&self.layout).len()));
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 !self.device.prepare_send { self.device.seed_import_mapping(&self.layout); }
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()];
self.device.mapping_scope = None;
}
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<_, _> = scope_indices.iter().copied().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, &scope_indices, snapshot, self.device.screen, &mut targets,
&mut self.device.target, &mut self.device.sizing, self.device.pending.is_some(), self.device.allow_program, &self.device.input_edits);
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);
return;
}
ui.horizontal(|ui| {
if ui.button("Use saved links").clicked() {
self.device.destinations.fill(Destination::Skip);
self.device.mapping_scope = None;
}
if ui.add_enabled(self.device.scope != TransferScope::Selected, egui::Button::new("Import unmapped as new layers")).clicked() {
for (i, layer) in screen.layers.iter().enumerate() {
if self.device.destinations[i] == Destination::Skip && layer.unsupported.is_none() { self.device.destinations[i] = Destination::New; }
}
}
});
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.add_enabled_ui(self.device.scope != TransferScope::Selected, |ui| {
ui.selectable_value(destination, Destination::New, "New layer");
});
for &j in &scope_indices {
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. The scope limits available destinations; each mapping can still be changed.");
}
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 allowed = self.device.scope.indices(&self.layout);
for destination in &self.device.destinations {
if *destination == Destination::New && self.device.scope == TransferScope::Selected {
return Err(
"Only selected layers cannot create new layers. Choose All layers or a folder."
.into(),
);
}
if let Destination::Existing(id) = destination
&& !allowed.iter().any(|&i| self.layout.layer_info(i).id == *id)
{
return Err("An import destination is outside the current scope. Remap it or choose All layers.".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();
let links = selected
.iter()
.map(|&i| midra_layout::MidraLink {
screen: screen.id.clone(),
layer: screen.layers[i].id.clone(),
})
.collect::<Vec<_>>();
let folder = match &self.device.scope {
TransferScope::Folder(folder) => folder.as_str(),
_ => "",
};
self.layout
.import_linked_device_layers(&values, &links, folder)
}
}
#[allow(clippy::too_many_arguments)]
fn send_review(
ui: &mut egui::Ui,
layout: &midra_layout::Layout,
indices: &[usize],
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,
input_edits: &input_ui::InputEdits,
) -> 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 = indices;
targets.retain(|id, _| selected.iter().any(|&i| layout.layer_info(i).id == *id));
ui.strong(format!(
"{} editor layers in scope → Screen {}",
selected.len(),
screen.id
));
if selected.is_empty() {
ui.label("No layers in this scope. Choose All layers, select layers, or choose a folder.");
}
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() {
"Not linked / skip".into()
} else {
format!("Screen {} · Layer {target}", screen.id)
})
.show_ui(ui, |ui| {
ui.selectable_value(target, String::new(), "Not linked / skip");
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()
.filter(|(_, destination)| !destination.is_empty())
.map(|(id, destination)| (*id, destination.clone()))
.collect();
match Plan::prepare(
snapshot,
layout,
screen_index,
&mappings,
*target_mode,
*sizing,
)
.and_then(|mut plan| {
input_edits.extend_plan(snapshot, &mappings, &mut plan)?;
Ok(plan)
}) {
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.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 property_mapping_selects_screen_and_unmaps_without_device_writes() {
use super::super::tests::click_text;
let ctx = egui::Context::default();
let mut app = Editor::default();
let i = app.layout.selected().unwrap();
let before = app.layout.layers().clone();
let mut snapshot = linked_test_snapshot();
let mut second = snapshot.screens[0].clone();
second.id = "2".into();
snapshot.screens.push(second);
app.device.snapshot = Some(snapshot);
app.property_tab = PropertyTab::Mapping;
app.format_draft = Some(FormatDraft::new(&app.layout, i));
click_text(&mut app, &ctx, "Link to Midra layer");
assert_eq!(
app.layout.layer_info(i).midra_link.as_ref().unwrap().screen,
"1"
);
click_text(&mut app, &ctx, "Screen 1");
click_text(&mut app, &ctx, "Screen 2");
assert_eq!(
app.layout.layer_info(i).midra_link.as_ref().unwrap().screen,
"2"
);
assert_eq!(app.device.scoped_links(&app.layout).len(), 1);
let project = midra_layout::project::Project::from_layout(&app.layout);
click_text(&mut app, &ctx, "Unmap");
assert!(app.layout.layer_info(i).midra_link.is_none());
assert!(app.device.scoped_links(&app.layout).is_empty());
assert_eq!(*app.layout.layers(), before);
assert!(!app.device.sending);
assert!(app.device.pending.is_none());
app.layout.undo();
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
project
);
}
#[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);
app.device.scope = TransferScope::Selected;
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);
state.scope = TransferScope::Selected;
assert!(state.linked_plans(&layout).is_err());
state.scope = TransferScope::All;
let plans = state.linked_plans(&layout).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).unwrap().len(), 2);
layout
.set_midra_link(
1,
Some(midra_layout::MidraLink {
screen: "1".into(),
layer: "1".into(),
}),
)
.unwrap();
assert!(state.linked_plans(&layout).is_err());
layout.set_midra_link(1, None).unwrap();
assert_eq!(state.linked_plans(&layout).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,
&TransferScope::All.indices(&layout),
&snapshot,
0,
&mut targets,
&mut target,
&mut Sizing::OutputBox,
false,
allow,
&input_ui::InputEdits::default(),
);
});
});
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).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,
&TransferScope::Selected.indices(&layout),
&snapshot,
0,
&mut targets,
&mut Target::Preview,
&mut Sizing::OutputBox,
false,
false,
&input_ui::InputEdits::default(),
)
});
});
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,
&TransferScope::Selected.indices(&layout),
&snapshot,
0,
&mut targets,
&mut Target::Preview,
&mut Sizing::OutputBox,
false,
false,
&input_ui::InputEdits::default(),
)
});
});
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);
}
fn linked_folders() -> Editor {
let mut app = Editor::default();
app.device.snapshot = Some(linked_test_snapshot());
for i in 0..2 {
app.layout
.set_midra_link(
i,
Some(midra_layout::MidraLink {
screen: "1".into(),
layer: (i + 1).to_string(),
}),
)
.unwrap();
let id = app.layout.layer_info(i).id;
app.layout
.assign_folder(&[id], if i == 0 { "Intro" } else { "Talk" })
.unwrap();
}
app
}
#[test]
fn default_scope_ignores_selection_for_send_load_and_import_mapping() {
let mut app = linked_folders();
assert_eq!(app.device.scope, TransferScope::All);
app.layout.select(Some(1));
assert_eq!(app.device.scoped_links(&app.layout).len(), 2);
assert_eq!(app.device.linked_plans(&app.layout).unwrap().len(), 1);
app.device.seed_import_mapping(&app.layout);
assert!(matches!(
app.device.destinations[0],
Destination::Existing(2)
));
assert!(matches!(
app.device.destinations[1],
Destination::Existing(1)
));
// Selection never changes explicit All scope or its manual remapping.
app.device.destinations[0] = Destination::Skip;
app.layout.select(None);
app.device.seed_import_mapping(&app.layout);
assert!(matches!(app.device.destinations[0], Destination::Skip));
app.device.scope = TransferScope::Selected;
assert!(app.device.scoped_links(&app.layout).is_empty());
assert!(app.device.linked_plans(&app.layout).is_err());
app.layout.select(Some(0));
app.device.seed_import_mapping(&app.layout);
assert!(matches!(
app.device.destinations[0],
Destination::Existing(2)
));
assert!(matches!(app.device.destinations[1], Destination::Skip));
}
#[test]
fn folder_memories_reuse_destinations_without_overwriting_other_links() {
let mut app = linked_folders();
let link = app.layout.layer_info(0).midra_link.clone();
app.layout.set_midra_link(1, link).unwrap();
let before = midra_layout::project::Project::from_layout(&app.layout);
assert!(
app.device
.linked_plans(&app.layout)
.unwrap_err()
.contains("Choose one folder")
);
app.device.scope = TransferScope::Folder("Intro".into());
let first = app.device.linked_plans(&app.layout).unwrap();
assert_eq!(app.device.scoped_links(&app.layout)[0].0, 2);
app.device.follow_folder("Talk");
let second = app.device.linked_plans(&app.layout).unwrap();
assert_eq!(app.device.scoped_links(&app.layout)[0].0, 1);
let values = |plan: &Plan| {
plan.changes
.iter()
.map(|change| (change.path.clone(), change.after.clone()))
.collect::<Vec<_>>()
};
assert_ne!(values(&first[0]), values(&second[0]));
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
app.device.follow_folder("Removed");
assert!(app.device.scoped_links(&app.layout).is_empty());
assert!(app.device.linked_plans(&app.layout).is_err());
}
#[test]
fn folder_import_remapping_is_scoped_and_saves_links_with_atomic_undo() {
let mut app = linked_folders();
app.device.scope = TransferScope::Folder("Talk".into());
app.device.seed_import_mapping(&app.layout);
assert!(matches!(app.device.destinations[0], Destination::Skip));
assert!(matches!(
app.device.destinations[1],
Destination::Existing(1)
));
let before = midra_layout::project::Project::from_layout(&app.layout);
app.device.destinations = vec![Destination::Existing(2), Destination::Skip];
assert!(
app.apply_device_import()
.unwrap_err()
.contains("outside the current scope")
);
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
app.device.destinations = vec![Destination::Existing(1), Destination::New];
app.apply_device_import().unwrap();
assert_eq!(
app.layout.layer_info(1).midra_link.as_ref().unwrap().layer,
"1"
);
assert_eq!(app.layout.layer_info(2).folder, "Talk");
assert_eq!(
app.layout.layer_info(2).midra_link.as_ref().unwrap().layer,
"2"
);
assert_eq!(
app.layout.layer_info(0),
&before.layout().unwrap().layer_info(0).clone()
);
app.layout.undo();
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout).layers,
before.layers
);
}
#[test]
fn changing_folder_during_read_keeps_the_original_load_destinations() {
let mut app = linked_folders();
app.device.scope = TransferScope::Folder("Intro".into());
let links = app.device.scoped_links(&app.layout);
let before_other = app.layout.layers()[1];
app.device.loading = Some(links);
let (tx, rx) = mpsc::channel();
app.device.pending = Some(rx);
app.device.follow_folder("Talk");
tx.send(Ok(linked_test_snapshot())).unwrap();
app.device.poll();
app.finish_linked_load();
assert_eq!(
app.layout.layers()[0],
linked_test_snapshot().screens[0].layers[0].geometry
);
assert_eq!(app.layout.layers()[1], before_other);
assert_eq!(app.device.scope, TransferScope::Folder("Talk".into()));
}
#[test]
fn all_scope_send_review_lists_unselected_layers_and_keeps_manual_destinations() {
let app = linked_folders();
let ctx = egui::Context::default();
let mut targets = std::collections::BTreeMap::from([(1, "2".into()), (2, "1".into())]);
let before = targets.clone();
let _ = ctx.run(egui::RawInput::default(), |ctx| {
egui::CentralPanel::default().show(ctx, |ui| {
send_review(
ui,
&app.layout,
&TransferScope::All.indices(&app.layout),
app.device.snapshot.as_ref().unwrap(),
0,
&mut targets,
&mut Target::Preview,
&mut Sizing::OutputBox,
false,
false,
&input_ui::InputEdits::default(),
);
});
});
assert_eq!(targets, before);
}
#[test]
fn status_scope_picker_changes_transfer_filter_without_changing_selection() {
let mut app = linked_folders();
let ctx = egui::Context::default();
let before = app.layout.selection_mask();
super::super::tests::click_text(&mut app, &ctx, "All layers");
super::super::tests::click_text(&mut app, &ctx, "Only selected layers");
assert_eq!(app.device.scope, TransferScope::Selected);
assert_eq!(app.layout.selection_mask(), before);
assert!(app.device.pending.is_none());
assert!(!app.device.sending);
}
#[test]
fn selected_scope_never_creates_unselected_import_destinations() {
let mut app = linked_folders();
app.device.scope = TransferScope::Selected;
app.device.destinations = vec![Destination::New, Destination::Skip];
let before = midra_layout::project::Project::from_layout(&app.layout);
assert!(
app.apply_device_import()
.unwrap_err()
.contains("cannot create new layers")
);
assert_eq!(
midra_layout::project::Project::from_layout(&app.layout),
before
);
}
}