//! Shared print dialog state and UI (full app and print-only launcher). use std::collections::HashMap; use std::path::PathBuf; use std::sync::mpsc::{self, Receiver, TryRecvError}; use eframe::egui; use posprint::dsl::parse; use posprint::io::{PosFile, PosMetadata}; use posprint::params::{collect_parameters, parse_bool_value, ParamKind, ParamSpec}; use posprint::pipeline; use posprint::print::{ list_printers, open_printer, open_printer_by_name, print_bytes, PrintError, PrinterDevice, }; #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum PrintExecuteResult { StillOpen, Printed, } pub struct PrintDialog { pub param_inputs: HashMap, pub param_specs: Vec, pub last_params: HashMap, pub printers: Vec, pub printers_loading: bool, printers_rx: Option, PrintError>>>, pub selected_printer: Option, pub manual_port: String, pub use_manual_port: bool, pub error: Option, } impl Default for PrintDialog { fn default() -> Self { Self { param_inputs: HashMap::new(), param_specs: Vec::new(), last_params: HashMap::new(), printers: Vec::new(), printers_loading: false, printers_rx: None, selected_printer: None, manual_port: String::new(), use_manual_port: false, error: None, } } } impl PrintDialog { pub fn prepare(&mut self, body: &str) -> Result<(), String> { self.error = None; let doc = parse(body).map_err(|e| e.to_string())?; self.param_specs = collect_parameters(&doc); self.param_inputs.clear(); for spec in &self.param_specs { let value = match spec.kind { ParamKind::Bool => self .last_params .get(&spec.name) .cloned() .filter(|v| parse_bool_value(v).is_some()) .unwrap_or_else(|| "false".into()), ParamKind::Text => self .last_params .get(&spec.name) .cloned() .unwrap_or_default(), }; self.param_inputs.insert(spec.name.clone(), value); } self.start_printer_discovery(); Ok(()) } pub fn start_printer_discovery(&mut self) { self.printers_loading = true; self.error = None; let (tx, rx) = mpsc::channel(); self.printers_rx = Some(rx); std::thread::spawn(move || { let _ = tx.send(list_printers()); }); } pub fn poll_printer_discovery(&mut self, ctx: &egui::Context) { let Some(rx) = &self.printers_rx else { return; }; match rx.try_recv() { Ok(result) => { self.printers_rx = None; self.printers_loading = false; match result { Ok(list) => { self.printers = list; if self.selected_printer.is_none() && !self.printers.is_empty() { self.selected_printer = Some(0); } } Err(e) => self.error = Some(format!("{e:?}")), } } Err(TryRecvError::Empty) => { ctx.request_repaint(); } Err(TryRecvError::Disconnected) => { self.printers_rx = None; self.printers_loading = false; } } } pub fn refresh_printers(&mut self) { self.start_printer_discovery(); } pub fn apply_inputs_to_last_params(&mut self) { self.last_params = self.param_inputs.clone(); } pub fn execute_print( &mut self, body: &str, metadata: &PosMetadata, file_path: Option<&PathBuf>, ) -> PrintExecuteResult { self.error = None; if parse(body).is_err() { self.error = Some("Template has parse errors".into()); return PrintExecuteResult::StillOpen; } for spec in &self.param_specs { if !self.param_inputs.contains_key(&spec.name) { self.error = Some(format!("Missing value for parameter {}", spec.name)); return PrintExecuteResult::StillOpen; } if spec.kind == ParamKind::Bool { let raw = self.param_inputs.get(&spec.name).map(String::as_str).unwrap_or(""); if parse_bool_value(raw).is_none() { self.error = Some(format!( "Invalid boolean for {}: use true/false", spec.name )); return PrintExecuteResult::StillOpen; } } } self.last_params = self.param_inputs.clone(); let base_dir = file_path.and_then(|p| p.parent()); let file = PosFile { version: 1, metadata: metadata.clone(), body: body.to_string(), }; let bytes = match pipeline::encode_pos_file(&file, base_dir, &self.last_params) { Ok(b) => b, Err(e) => { self.error = Some(e.to_string()); return PrintExecuteResult::StillOpen; } }; let transport_result = if self.use_manual_port { let name = self.manual_port.trim(); if name.is_empty() { self.error = Some("Select a printer or enter a port/queue name".into()); return PrintExecuteResult::StillOpen; } open_printer_by_name(name) } else if let Some(target) = self.selected_printer_target() { open_printer(target) } else { self.error = Some("Select a printer".into()); return PrintExecuteResult::StillOpen; }; match transport_result { Ok(mut transport) => match print_bytes(transport.as_mut(), &bytes) { Ok(()) => PrintExecuteResult::Printed, Err(e) => { self.error = Some(format!("{e:?}")); PrintExecuteResult::StillOpen } }, Err(e) => { self.error = Some(format!("{e:?}")); PrintExecuteResult::StillOpen } } } fn selected_printer_target(&self) -> Option<&posprint::print::PrinterTarget> { if self.use_manual_port { return None; } self.selected_printer .and_then(|i| self.printers.get(i)) .map(|p| &p.target) } pub fn show_ui(&mut self, ui: &mut egui::Ui, cancel_label: &str) -> PrintDialogAction { ui.heading("Parameters"); if self.param_specs.is_empty() { ui.label("No parameters in this template."); } else { for spec in self.param_specs.clone() { ui.horizontal(|ui| { match spec.kind { ParamKind::Text => { ui.label(format!("{}:", spec.name)); let entry = self .param_inputs .entry(spec.name.clone()) .or_insert_with(String::new); ui.text_edit_singleline(entry); } ParamKind::Bool => { let mut checked = self .param_inputs .get(&spec.name) .and_then(|v| parse_bool_value(v)) .unwrap_or(false); if ui.checkbox(&mut checked, &spec.name).changed() { self.param_inputs.insert( spec.name.clone(), if checked { "true" } else { "false" }.into(), ); } } } }); } } ui.separator(); ui.heading("Printer"); ui.horizontal(|ui| { if ui .add_enabled(!self.printers_loading, egui::Button::new("Refresh")) .clicked() { self.refresh_printers(); } if self.printers_loading { ui.spinner(); ui.label("Discovering printers…"); } }); ui.checkbox(&mut self.use_manual_port, "Enter port or queue manually"); if self.use_manual_port { ui.horizontal(|ui| { ui.label("Port / queue:"); ui.text_edit_singleline(&mut self.manual_port); }); ui.label("Examples: COM3, printer queue name (Windows), /dev/ttyUSB0 (Linux)"); } else if self.printers_loading && self.printers.is_empty() { ui.label("Searching for USB, spooler, and serial printers…"); } else if self.printers.is_empty() { ui.label( "No printers found. Connect a USB POS printer, refresh, or enter a port/queue manually.", ); } else { // Keep Cancel/Print reachable when many devices are listed. let list_height = (self.printers.len() as f32 * 22.0).clamp(44.0, 180.0); egui::ScrollArea::vertical() .id_salt("print_dialog_printer_list") .max_height(list_height) .auto_shrink([false, true]) .show(ui, |ui| { for (i, printer) in self.printers.iter().enumerate() { ui.selectable_value( &mut self.selected_printer, Some(i), &printer.display_name, ); } }); } if let Some(err) = &self.error { ui.colored_label(egui::Color32::RED, err); } let mut action = PrintDialogAction::None; ui.horizontal(|ui| { if ui.button(cancel_label).clicked() { action = PrintDialogAction::Cancel; } if ui.button("Print").clicked() { action = PrintDialogAction::Print; } }); action } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum PrintDialogAction { None, Cancel, Print, }