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

161 lines
7.6 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;
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);
}
}