//! 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::{ find_preferred_printer_index, list_printers, manual_printer_preference_key, open_printer, open_printer_by_name, print_bytes, printer_preference_key, PrintError, PrinterDevice, }; use posprint::config::AppConfig; #[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; self.apply_preferred_printer(AppConfig::load().last_printer_key.as_deref()); } 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(); } /// Prefer the last successful printer when still connected; otherwise keep/default selection. pub fn apply_preferred_printer(&mut self, preferred_key: Option<&str>) { if let Some(key) = preferred_key.map(str::trim).filter(|k| !k.is_empty()) { if let Some(name) = key.strip_prefix("manual:") { let name = name.trim(); if !name.is_empty() { self.use_manual_port = true; self.manual_port = name.to_string(); return; } } else if let Some(i) = find_preferred_printer_index(&self.printers, key) { self.use_manual_port = false; self.selected_printer = Some(i); return; } } if self.selected_printer.is_none() && !self.printers.is_empty() { self.selected_printer = Some(0); } } fn remember_successful_printer(&self) { let key = if self.use_manual_port { let name = self.manual_port.trim(); if name.is_empty() { None } else { Some(manual_printer_preference_key(name)) } } else { self.selected_printer .and_then(|i| self.printers.get(i)) .map(|p| printer_preference_key(&p.target)) }; let Some(key) = key else { return; }; let mut cfg = AppConfig::load(); if cfg.last_printer_key.as_deref() == Some(key.as_str()) { return; } cfg.remember_printer(key); let _ = cfg.save(); } 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(()) => { self.remember_successful_printer(); 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) -> PrintDialogAction { let mut action = PrintDialogAction::None; ui.heading("Parameters"); if self.param_specs.is_empty() { ui.label("No parameters in this template."); } else { egui::ScrollArea::vertical() .id_salt("print_dialog_params") .max_height(140.0) .auto_shrink([false, true]) .show(ui, |ui| { 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 ui.button("Print").clicked() { action = PrintDialogAction::Print; } 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, Bluetooth COM after pairing, printer queue (Windows), /dev/ttyUSB0 or /dev/rfcomm0 (Linux)", ); } else if self.printers_loading && self.printers.is_empty() { ui.label("Searching for USB, spooler, serial, and paired Bluetooth printers…"); } else if self.printers.is_empty() { ui.label( "No printers found. Connect a USB POS printer, pair a Classic Bluetooth SPP printer in the OS, refresh, or enter a port/queue manually.", ); } else { // Fixed height so wheel scrolling works; avoid nesting inside another ScrollArea. const PRINTER_LIST_HEIGHT: f32 = 220.0; egui::ScrollArea::vertical() .id_salt("print_dialog_printer_list") .max_height(PRINTER_LIST_HEIGHT) .min_scrolled_height(PRINTER_LIST_HEIGHT) .auto_shrink([false, false]) .show(ui, |ui| { ui.set_min_width(ui.available_width()); 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); } action } } #[derive(Debug, Clone, Copy, PartialEq, Eq)] pub enum PrintDialogAction { None, Print, } #[cfg(test)] mod tests { use super::*; use posprint::print::PrinterTarget; #[test] fn prefers_last_connected_printer_over_first() { let mut dialog = PrintDialog::default(); dialog.printers = vec![ PrinterDevice { id: "a".into(), display_name: "First".into(), target: PrinterTarget::Serial("COM1".into()), }, PrinterDevice { id: "b".into(), display_name: "Last".into(), target: PrinterTarget::WinSpooler("POS".into()), }, ]; dialog.apply_preferred_printer(Some("winspool:POS")); assert_eq!(dialog.selected_printer, Some(1)); assert!(!dialog.use_manual_port); } #[test] fn falls_back_to_first_when_preferred_missing() { let mut dialog = PrintDialog::default(); dialog.printers = vec![PrinterDevice { id: "a".into(), display_name: "Only".into(), target: PrinterTarget::Serial("COM1".into()), }]; dialog.apply_preferred_printer(Some("winspool:Gone")); assert_eq!(dialog.selected_printer, Some(0)); } #[test] fn restores_manual_preference() { let mut dialog = PrintDialog::default(); dialog.apply_preferred_printer(Some("manual:COM9")); assert!(dialog.use_manual_port); assert_eq!(dialog.manual_port, "COM9"); } }