//! 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; use posprint::i18n::{tr, trf}; use posprint::label_format::{FormatError, LabelFormat, LabelFormatStore, MediaKind}; use posprint::print::{detect_printer, find_matching_printer, PrinterTarget}; use posprint::protocol::{Detection, DetectionSource, PrinterProtocol}; use posprint::tspl::TsplOptions; /// Label-format form for TSPL label printers (only shown for those). #[derive(Debug, Clone)] pub struct LabelForm { pub model_key: String, pub width: String, pub height: String, pub gap: String, pub media: MediaKind, pub dpi: u16, pub rotate_180: bool, pub calibrate: bool, pub from_printer: bool, pub error: Option, } impl LabelForm { pub fn from_format(model_key: &str, f: &LabelFormat, calibrate: bool, from_printer: bool) -> Self { let n = |v: f32| { let s = format!("{v:.1}"); s.trim_end_matches('0').trim_end_matches('.').to_string() }; Self { model_key: model_key.to_string(), width: n(f.width_mm), height: n(f.height_mm), gap: n(f.gap_mm), media: f.media, dpi: f.dpi, rotate_180: f.rotate_180, calibrate, from_printer, error: None, } } /// Parse and validate; accepts `,` as decimal separator. pub fn to_format(&self) -> Result { let num = |s: &str, label: &str| -> Result { s.trim() .replace(',', ".") .parse::() .map_err(|_| trf("label.err.number", label)) }; let f = LabelFormat { width_mm: num(&self.width, tr("label.width"))?, height_mm: num(&self.height, tr("label.height"))?, gap_mm: if self.media == MediaKind::Continuous { num(&self.gap, tr("label.gap")).unwrap_or(0.0) } else { num(&self.gap, tr("label.gap"))? }, media: self.media, dpi: self.dpi, rotate_180: self.rotate_180, }; f.validate().map_err(|e| { tr(match e { FormatError::Width => "label.err.width", FormatError::Height => "label.err.height", FormatError::Gap => "label.err.gap", FormatError::Dpi => "label.err.dpi", }) .to_string() })?; Ok(f) } } #[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, /// Detected protocol per printer id (filled in the background). pub detections: HashMap, detect_rx: Option>>, /// Open label-format form (TSPL printers only). pub label_form: Option, label_submit: bool, } 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, detections: HashMap::new(), detect_rx: None, label_form: None, label_submit: false, } } } 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.start_protocol_detection(); 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; } } } fn start_protocol_detection(&mut self) { let targets: Vec<(String, PrinterTarget)> = self .printers .iter() .map(|p| (p.id.clone(), p.target.clone())) .collect(); let (tx, rx) = mpsc::channel(); self.detect_rx = Some(rx); std::thread::spawn(move || { let map = targets .into_iter() .map(|(id, t)| (id, detect_printer(&t))) .collect(); let _ = tx.send(map); }); } fn poll_protocol_detection(&mut self) { if let Some(rx) = &self.detect_rx { if let Ok(map) = rx.try_recv() { self.detections = map; self.detect_rx = None; } } } /// The printer that would be used, as discovered device (manual names are /// matched against discovered printers like `open_printer_by_name`). fn effective_device(&self) -> Option<&PrinterDevice> { if self.use_manual_port { find_matching_printer(&self.printers, self.manual_port.trim()) } else { self.selected_printer.and_then(|i| self.printers.get(i)) } } /// Cached detection for the effective printer, if it is a TSPL printer. fn cached_tspl(&self) -> Option<&Detection> { let dev = self.effective_device()?; self.detections .get(&dev.id) .filter(|d| d.protocol == PrinterProtocol::Tspl) } /// Fresh detection at print time (does not rely on the background thread). fn tspl_for_print(&mut self) -> Option<(PrinterTarget, Detection)> { let dev = self.effective_device()?.clone(); let d = match self.detections.get(&dev.id) { Some(d) => d.clone(), None => { let d = detect_printer(&dev.target); self.detections.insert(dev.id.clone(), d.clone()); d } }; (d.protocol == PrinterProtocol::Tspl).then_some((dev.target, d)) } /// Label format to print with, or `None` when the form must be filled in first. fn resolve_label_format( &mut self, target: &PrinterTarget, d: &Detection, ) -> Option<(LabelFormat, TsplOptions)> { if let Some(form) = self.label_form.as_mut().filter(|f| f.model_key == d.model_key) { if !std::mem::take(&mut self.label_submit) { return None; } match form.to_format() { Ok(fmt) => { let mut store = LabelFormatStore::load(); store.set(&d.model_key, fmt.clone()); if let Err(e) = store.save() { form.error = Some(trf("label.err.save", &e)); return None; } let opts = TsplOptions { calibrate: form.calibrate }; self.label_form = None; return Some((fmt, opts)); } Err(e) => { form.error = Some(e); return None; } } } self.label_submit = false; if let Some(fmt) = LabelFormatStore::load().get(&d.model_key) { return Some((fmt.clone(), TsplOptions::default())); } let (fmt, from_printer) = pipeline::suggest_label_format(target, d); self.label_form = Some(LabelForm::from_format(&d.model_key, &fmt, true, from_printer)); None } 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; } }; // Label printers (TSPL): same document, sent as TSPL bitmap labels. // ESC/POS printers keep the bytes above unchanged. let bytes = match self.tspl_for_print() { Some((target, d)) => match self.resolve_label_format(&target, &d) { Some((fmt, opts)) => { match pipeline::encode_pos_file_tspl(&file, base_dir, &self.last_params, &fmt, opts) { Ok(b) => b, Err(e) => { self.error = Some(e.to_string()); return PrintExecuteResult::StillOpen; } } } None => return PrintExecuteResult::StillOpen, }, None => bytes, }; 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, ); } }); } self.poll_protocol_detection(); if self.show_label_ui(ui) { action = PrintDialogAction::Print; } if let Some(err) = &self.error { ui.colored_label(egui::Color32::RED, err); } action } } impl PrintDialog { /// Label-printer section; only drawn for TSPL printers. Returns true when /// "Save and print" was clicked. fn show_label_ui(&mut self, ui: &mut egui::Ui) -> bool { let Some(d) = self.cached_tspl().cloned().or_else(|| { self.label_form.as_ref()?; let dev = self.effective_device()?; self.detections.get(&dev.id).cloned() }) else { return false; }; if d.protocol != PrinterProtocol::Tspl { return false; } let mut submit = false; ui.separator(); ui.heading(tr("label.title")); let source_tip = match d.source { DetectionSource::DeviceId => tr("label.source.device_id"), DetectionSource::UsbVendor => tr("label.source.usb_vendor"), DetectionSource::QueueName => tr("label.source.queue_name"), DetectionSource::Default => "", }; let detected = trf("label.detected", d.protocol.label()); let text = match &d.model_name { Some(m) => format!("{detected} — {m}"), None => detected, }; ui.label(text).on_hover_text(source_tip); let stored = LabelFormatStore::load().get(&d.model_key).cloned(); let mut close_form = false; if let Some(form) = self.label_form.as_mut().filter(|f| f.model_key == d.model_key) { ui.label(tr("label.format_missing")); if form.from_printer { ui.label(tr("label.from_printer")); } egui::Grid::new("label_format_grid").num_columns(2).show(ui, |ui| { ui.label(tr("label.width")).on_hover_text(tr("label.width.tip")); ui.text_edit_singleline(&mut form.width).on_hover_text(tr("label.width.tip")); ui.end_row(); ui.label(tr("label.height")).on_hover_text(tr("label.height.tip")); ui.text_edit_singleline(&mut form.height).on_hover_text(tr("label.height.tip")); ui.end_row(); ui.label(tr("label.media")).on_hover_text(tr("label.media.tip")); ui.horizontal(|ui| { ui.radio_value(&mut form.media, MediaKind::Gap, tr("label.media.gap")) .on_hover_text(tr("label.media.tip")); ui.radio_value(&mut form.media, MediaKind::BlackMark, tr("label.media.black_mark")) .on_hover_text(tr("label.media.tip")); ui.radio_value(&mut form.media, MediaKind::Continuous, tr("label.media.continuous")) .on_hover_text(tr("label.media.tip")); }); ui.end_row(); if form.media != MediaKind::Continuous { ui.label(tr("label.gap")).on_hover_text(tr("label.gap.tip")); ui.text_edit_singleline(&mut form.gap).on_hover_text(tr("label.gap.tip")); ui.end_row(); } ui.label(tr("label.dpi")).on_hover_text(tr("label.dpi.tip")); ui.horizontal(|ui| { for dpi in [203u16, 300, 600] { ui.radio_value(&mut form.dpi, dpi, dpi.to_string()) .on_hover_text(tr("label.dpi.tip")); } }); ui.end_row(); }); ui.checkbox(&mut form.rotate_180, tr("label.rotate")) .on_hover_text(tr("label.rotate.tip")); if form.media != MediaKind::Continuous { ui.checkbox(&mut form.calibrate, tr("label.calibrate")) .on_hover_text(tr("label.calibrate.tip")); } ui.horizontal(|ui| { if ui .button(tr("label.save_print")) .on_hover_text(tr("label.save_print.tip")) .clicked() { submit = true; } if ui .button(tr("label.cancel")) .on_hover_text(tr("label.cancel.tip")) .clicked() { close_form = true; } }); if let Some(err) = &form.error { ui.colored_label(egui::Color32::RED, err); } } else if let Some(f) = stored { ui.horizontal(|ui| { ui.label(format!( "{}: {} × {} mm, {} dpi", tr("label.format"), f.width_mm, f.height_mm, f.dpi )); if ui .button(tr("label.change")) .on_hover_text(tr("label.change.tip")) .clicked() { self.label_form = Some(LabelForm::from_format(&d.model_key, &f, false, false)); } }); } else { ui.label(tr("label.format_missing")); } if close_form { self.label_form = None; } if submit { self.label_submit = true; } submit } } #[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 label_form_parses_and_validates() { let f = LabelFormat { width_mm: 50.0, height_mm: 30.0, dpi: 300, ..Default::default() }; let mut form = LabelForm::from_format("Altec ATP-300 Pro", &f, true, false); assert_eq!(form.width, "50"); assert_eq!(form.to_format().unwrap(), f); form.width = "50,5".into(); assert_eq!(form.to_format().unwrap().width_mm, 50.5); form.width = "abc".into(); assert!(form.to_format().is_err()); form.width = "500".into(); assert!(form.to_format().is_err()); form.width = "50".into(); form.media = MediaKind::Continuous; form.gap = String::new(); assert_eq!(form.to_format().unwrap().gap_mm, 0.0); } #[test] fn escpos_printers_show_no_label_section() { let mut dialog = PrintDialog::default(); dialog.printers = vec![PrinterDevice { id: "a".into(), display_name: "POS".into(), target: PrinterTarget::Serial("COM1".into()), }]; dialog.selected_printer = Some(0); assert!(dialog.cached_tspl().is_none()); assert!(dialog.tspl_for_print().is_none(), "serial printers stay ESC/POS"); let tspl_target = PrinterTarget::UsbDirect { vid: 0x1203, pid: 0x0231, bus: 250, address: 250 }; dialog.printers.push(PrinterDevice { id: "usb:250:250:1203:0231".into(), display_name: "ATP".into(), target: tspl_target.clone(), }); dialog.detections.insert( "usb:250:250:1203:0231".into(), posprint::protocol::detect(&tspl_target, Some("MFG:Altec;CMD:TSPL2;MDL:ATP-300 Pro;")), ); dialog.selected_printer = Some(1); assert_eq!(dialog.cached_tspl().unwrap().model_key, "Altec ATP-300 Pro"); } #[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"); } }