Map Midra imports directly to existing or new layers
This commit is contained in:
parent
932b707680
commit
67b4cd20e1
|
|
@ -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 {
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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,
|
||||
|
|
|
|||
|
|
@ -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()
|
||||
);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -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:
|
||||
|
|
|
|||
|
|
@ -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
|
||||
|
|
|
|||
Loading…
Reference in New Issue