Map Midra imports directly to existing or new layers

This commit is contained in:
Dandaedre 2026-11-13 17:50:51 +01:00
parent 932b707680
commit 67b4cd20e1
6 changed files with 211 additions and 25 deletions

View File

@ -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<Receiver<Result<device::Snapshot, String>>>,
snapshot: Option<device::Snapshot>,
screen: usize,
chosen: Vec<bool>,
destinations: Vec<Destination>,
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 {

View File

@ -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,

View File

@ -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<usize>, 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,

View File

@ -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()
);
}

View File

@ -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:

View File

@ -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