161 lines
7.6 KiB
Rust
161 lines
7.6 KiB
Rust
use super::*;
|
||
use midra_layout::device;
|
||
use std::sync::mpsc::{self, Receiver, TryRecvError};
|
||
|
||
#[derive(Default)]
|
||
pub(super) struct DeviceUi {
|
||
pub open: bool,
|
||
host: String,
|
||
pending: Option<Receiver<Result<device::Snapshot, String>>>,
|
||
snapshot: Option<device::Snapshot>,
|
||
screen: usize,
|
||
chosen: Vec<bool>,
|
||
error: String,
|
||
}
|
||
impl DeviceUi {
|
||
fn fetch(&mut self, ctx: &egui::Context) {
|
||
let (tx, rx) = mpsc::channel();
|
||
self.pending = Some(rx);
|
||
self.snapshot = None;
|
||
self.chosen.clear();
|
||
self.error.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;
|
||
match result {
|
||
Ok(snapshot) => {
|
||
self.chosen = vec![false; snapshot.screens[0].layers.len()];
|
||
self.screen = 0;
|
||
self.snapshot = Some(snapshot);
|
||
}
|
||
Err(error) => self.error = error,
|
||
}
|
||
}
|
||
}
|
||
impl Editor {
|
||
pub(super) fn device_window(&mut self, ctx: &egui::Context) {
|
||
self.device.poll();
|
||
if !self.device.open {
|
||
return;
|
||
}
|
||
let mut open = true;
|
||
let mut document = None;
|
||
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::Button::new("Read / refresh")).clicked() { self.device.fetch(ctx); }
|
||
});
|
||
if self.device.pending.is_some() {
|
||
ui.horizontal(|ui| { ui.spinner(); ui.label("Reading device… editing remains available."); });
|
||
if ui.button("Cancel read").clicked() { self.device.pending = None; }
|
||
}
|
||
ui.weak("No automatic polling or device writes. Closing or importing a project never sends commands.");
|
||
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.chosen = vec![false; 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!("{} × {} 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 }
|
||
}
|
||
if !valid { ui.weak("Choose the same number of device and editor layers, with matching screen resolution."); }
|
||
}
|
||
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);
|
||
}
|
||
self.device.open = false;
|
||
}
|
||
}
|
||
}
|
||
|
||
#[cfg(test)]
|
||
mod tests {
|
||
use super::*;
|
||
#[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();
|
||
app.device.open = true;
|
||
super::super::tests::frame(&mut app, &ctx, vec![]);
|
||
assert!(app.device.pending.is_none());
|
||
assert_eq!(*app.layout.layers(), before);
|
||
}
|
||
}
|