From 67b4cd20e1a74546f38c6d814d85dbb1c7a79cf3 Mon Sep 17 00:00:00 2001 From: Dandaedre Date: Fri, 13 Nov 2026 17:50:51 +0100 Subject: [PATCH] Map Midra imports directly to existing or new layers --- crates/midra-layout/src/device_ui.rs | 106 ++++++++++++++++++++++----- crates/midra-layout/src/gui.rs | 16 +++- crates/midra-layout/src/lib.rs | 39 ++++++++++ crates/midra-layout/tests/device.rs | 57 ++++++++++++++ docs/midra-layout-device-check.md | 12 ++- docs/midra-layout.md | 6 +- 6 files changed, 211 insertions(+), 25 deletions(-) diff --git a/crates/midra-layout/src/device_ui.rs b/crates/midra-layout/src/device_ui.rs index e197b2d..228d820 100644 --- a/crates/midra-layout/src/device_ui.rs +++ b/crates/midra-layout/src/device_ui.rs @@ -2,6 +2,14 @@ use super::*; use midra_layout::device; 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, @@ -9,15 +17,18 @@ pub(super) struct DeviceUi { pending: Option>>, snapshot: Option, screen: usize, - chosen: Vec, + destinations: Vec, error: String, } impl DeviceUi { + pub(super) fn online(&self) -> bool { + self.snapshot.is_some() + } fn fetch(&mut self, ctx: &egui::Context) { let (tx, rx) = mpsc::channel(); self.pending = Some(rx); self.snapshot = None; - self.chosen.clear(); + self.destinations.clear(); self.error.clear(); let host = self.host.clone(); let ctx = ctx.clone(); @@ -39,11 +50,14 @@ impl DeviceUi { self.pending = None; match result { Ok(snapshot) => { - self.chosen = vec![false; snapshot.screens[0].layers.len()]; + self.destinations = vec![Destination::Skip; snapshot.screens[0].layers.len()]; self.screen = 0; self.snapshot = Some(snapshot); } - Err(error) => self.error = error, + Err(error) => { + self.snapshot = None; + self.error = error; + } } } } @@ -54,14 +68,17 @@ impl Editor { return; } let mut open = true; - let mut document = None; + let mut imported = false; egui::Window::new("Midra connection · Preview") .open(&mut open).default_width(660.0).collapsible(false) .show(ctx, |ui| { ui.label("Read a snapshot from your Eikos, then review layer mapping before importing."); ui.horizontal(|ui| { ui.label("Device IP"); - ui.add_enabled(self.device.pending.is_none(), egui::TextEdit::singleline(&mut self.device.host).hint_text("192.168.…")); + 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.destinations.clear(); + } if ui.add_enabled(self.device.pending.is_none(), egui::Button::new("Read / refresh")).clicked() { self.device.fetch(ctx); } }); if self.device.pending.is_some() { @@ -79,39 +96,64 @@ impl Editor { 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.chosen = vec![false; screen.layers.len()]; } + 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])); } egui::ScrollArea::vertical().max_height(300.0).show(ui, |ui| { for (i, layer) in screen.layers.iter().enumerate() { ui.horizontal(|ui| { - ui.add_enabled(layer.unsupported.is_none(), egui::Checkbox::new(&mut self.device.chosen[i], format!("Layer {} · {}", layer.id, layer.source))); + 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("Container geometry only. Source fitting, routing, input crops and effects are not imported. Device slots may include unused layers."); - let selected: Vec<_> = self.device.chosen.iter().enumerate().filter_map(|(i, &on)| on.then_some(i)).collect(); - let targets = self.layout.selected_indices().len(); - ui.label(format!("{} device layers → {targets} selected editor layers", selected.len())); - let valid = matches && targets > 0 && targets == selected.len(); - if ui.add_enabled(valid, egui::Button::new("Review import…")).clicked() { - match screen.import(&selected) { Ok(doc) => document = Some(doc), Err(e) => self.device.error = e } + 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) + }).collect(); + self.layout.import_mapped_layers(&values) + }); + match result { Ok(()) => imported = true, Err(e) => self.device.error = e } } - if !valid { ui.weak("Choose the same number of device and editor layers, with matching screen resolution."); } + ui.weak("Choose an existing destination or New layer beside each device layer. Your editor selection does not limit this import."); } if !self.device.error.is_empty() { ui.colored_label(ui.visuals().error_fg_color, &self.device.error); } ui.separator(); ui.weak("Preview sends are unavailable until addressing stays safe across a TAKE. Program and shared input/output settings will never be written by this connection."); }); self.device.open = open; - if let Some(doc) = document { - self.open_paste(String::new()); - if let Some(paste) = &mut self.paste { - paste.set_document(doc); - } + if imported { + self.sync(); + self.device.error.clear(); self.device.open = false; } } @@ -121,6 +163,30 @@ impl Editor { mod tests { use super::*; #[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(), + 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 { diff --git a/crates/midra-layout/src/gui.rs b/crates/midra-layout/src/gui.rs index 07f3d8c..e6a500e 100644 --- a/crates/midra-layout/src/gui.rs +++ b/crates/midra-layout/src/gui.rs @@ -2364,7 +2364,21 @@ impl Editor { let ink = Ink::new(ui, r); ink.painter .circle_filled(ink.point(24.0, 17.0), 3.0, palette.cyan); - ink.text(36.0, 10.0, "OFFLINE", 11.0, palette.muted); + ink.text( + 36.0, + 10.0, + if self.device.online() { + "ONLINE" + } else { + "OFFLINE" + }, + 11.0, + if self.device.online() { + palette.cyan + } else { + palette.muted + }, + ); ink.text( 116.0, 10.0, diff --git a/crates/midra-layout/src/lib.rs b/crates/midra-layout/src/lib.rs index d1a4a64..ab0ad6d 100644 --- a/crates/midra-layout/src/lib.rs +++ b/crates/midra-layout/src/lib.rs @@ -901,6 +901,45 @@ impl Layout { self.finish_drag(); self.commit(next) } + /// Import device containers into stable layer IDs, or new layers (`None`). + /// Independent of selection; the complete mapping is one atomic undo step. + pub fn import_mapped_layers( + &mut self, + values: &[(Option, Geometry)], + ) -> Result<(), String> { + if values.is_empty() { + return Err("Choose at least one destination layer.".into()); + } + let mut draft = self.clone(); + let mut seen = Vec::new(); + for &(id, geometry) in values { + geometry.validate()?; + let index = if let Some(id) = id { + if seen.contains(&id) { + return Err("Choose a different destination for each device layer.".into()); + } + seen.push(id); + let index = self + .info + .iter() + .position(|info| info.id == id) + .ok_or("A destination layer was removed. Choose its replacement.")?; + if !draft.selectable(index) { + return Err("Destination layers must be visible and unlocked.".into()); + } + index + } else { + draft.add_layer()? + }; + draft.apply(index, geometry)?; + } + self.finish_drag(); + let before = self.snapshot(); + self.restore(draft.snapshot()); + self.next_id = draft.next_id; + self.remember(before); + Ok(()) + } /// Import geometry and optional crop zoom together as one atomic edit. pub fn apply_import_with_zoom( &mut self, diff --git a/crates/midra-layout/tests/device.rs b/crates/midra-layout/tests/device.rs index 2491bd1..020428f 100644 --- a/crates/midra-layout/tests/device.rs +++ b/crates/midra-layout/tests/device.rs @@ -82,3 +82,60 @@ fn disabled_screen_slots_are_ignored() { json!({"status":{"pp":{"transition":"AT_DOWN"}}}); assert_eq!(Snapshot::parse(&identity, &raw).unwrap().screens.len(), 1); } + +#[test] +fn mapped_import_ignores_selection_and_undoes_new_layers_together() { + let mut layout = midra_layout::Layout::default(); + layout.select(None); + let before = layout.layers().clone(); + let id = layout.layer_info(0).id; + let geometry = midra_layout::Geometry { + x: 12.5, + y: 27.0, + width: 945.0, + height: 531.58, + }; + layout + .import_mapped_layers(&[(Some(id), geometry), (None, geometry), (None, geometry)]) + .unwrap(); + assert_eq!(layout.layers().len(), 4); + assert_eq!(layout.layers()[0], geometry); + let new_id = layout.layer_info(3).id; + layout.undo(); + assert_eq!(*layout.layers(), before); + layout.redo(); + assert_eq!(layout.layers().len(), 4); + assert_eq!(layout.layer_info(3).id, new_id); + let added = layout.add_layer().unwrap(); + assert!(layout.layer_info(added).id > new_id); +} + +#[test] +fn invalid_mapping_never_partially_imports() { + let mut layout = midra_layout::Layout::default(); + let before = layout.layers().clone(); + let geometry = before[1]; + let id = layout.layer_info(0).id; + for values in [ + vec![], + vec![(None, geometry), (Some(999), geometry)], + vec![(Some(id), geometry), (Some(id), geometry)], + ] { + assert!(layout.import_mapped_layers(&values).is_err()); + assert_eq!(*layout.layers(), before); + } + layout.set_locked(0, true); + assert!( + layout + .import_mapped_layers(&[(None, geometry), (Some(id), geometry)]) + .is_err() + ); + assert_eq!(*layout.layers(), before); + layout.set_locked(0, false); + layout.set_visible(0, false); + assert!( + layout + .import_mapped_layers(&[(Some(id), geometry)]) + .is_err() + ); +} diff --git a/docs/midra-layout-device-check.md b/docs/midra-layout-device-check.md index 31aa1d9..f75830d 100644 --- a/docs/midra-layout-device-check.md +++ b/docs/midra-layout-device-check.md @@ -49,10 +49,16 @@ above come from the installed device and its own WebRCS bundle. The desktop app now has **Import → Midra Preview…**, also accessible from **Preferences → Midra integration**. Enter the device IP and click **Read / refresh**. Reads run in a worker thread; canceling discards late results. Choose a screen and -exactly as many device layers as selected editor layers, then **Review import…** -opens the existing mapping dialog. Output resolutions must match. Reading never +choose a destination beside each device layer: **Do not import**, **New layer**, +or an existing visible, unlocked editor layer. Click **Import layers** directly +in this window; no prior selection or matching layer count is required. Duplicate +or removed destinations are rejected without partial changes. The entire import, +including new layers, is one undo step. Output resolutions must match. Reading never changes the document; only applying the reviewed import does. No automatic -connection or polling occurs, and no credentials or address are persisted. +connection or polling occurs, and no credentials or address are persisted. The +footer shows **ONLINE** after a successful read (last-read status, not continuous +monitoring), and **OFFLINE** when refreshing, after a failed read, or after editing +the address. The Rust adapter was tested against the same Eikos 3.3.10: two 1920×1080 screens; disabled zero-canvas screen slots are filtered. A CLI smoke check is available: diff --git a/docs/midra-layout.md b/docs/midra-layout.md index c8863f2..4579a07 100644 --- a/docs/midra-layout.md +++ b/docs/midra-layout.md @@ -514,7 +514,11 @@ handles retain their existing behavior. One drag remains one undo step, with Esc The [Eikos 3.3.10 check](midra-layout-device-check.md) records the authorized Preview-only round trip and a read-only snapshot/SVG import helper. The desktop editor also offers **Import → Midra Preview…** for an explicit background read -and reviewed container import. Full device crop mapping and safe Preview writes +and reviewed container import. Each device layer has its own destination selector +(existing layer, new layer, or skip), independent of the editor selection. Import +applies directly from the Midra window as one undoable edit. The footer shows +ONLINE after a successful read; there is no automatic connection polling. +Full device crop mapping and safe Preview writes are pending; this adapter exposes no write endpoints. ## Layer management