| 1 | //! Shared print dialog state and UI (full app and print-only launcher).
|
| 2 |
|
| 3 | use std::collections::HashMap;
|
| 4 | use std::path::PathBuf;
|
| 5 | use std::sync::mpsc::{self, Receiver, TryRecvError};
|
| 6 |
|
| 7 | use eframe::egui;
|
| 8 |
|
| 9 | use posprint::dsl::parse;
|
| 10 | use posprint::io::{PosFile, PosMetadata};
|
| 11 | use posprint::params::{collect_parameters, parse_bool_value, ParamKind, ParamSpec};
|
| 12 | use posprint::pipeline;
|
| 13 | use posprint::print::{
|
| 14 | cache_entries_from_devices, find_preferred_printer_index, list_local_printers,
|
| 15 | manual_printer_preference_key, merge_lan_devices, open_printer, open_printer_by_name,
|
| 16 | print_bytes, printer_preference_key, remember_in_cache, scan_local_subnets, validate_cache,
|
| 17 | PrintError, PrinterDevice, PrinterTarget, DEFAULT_PORT,
|
| 18 | };
|
| 19 | use posprint::config::AppConfig;
|
| 20 |
|
| 21 | #[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| 22 | pub enum PrintExecuteResult {
|
| 23 | StillOpen,
|
| 24 | Printed,
|
| 25 | }
|
| 26 |
|
| 27 | /// Progressive printer discovery results from the background thread.
|
| 28 | #[derive(Debug)]
|
| 29 | enum DiscoveryMsg {
|
| 30 | /// Local USB/serial/spooler plus validated LAN cache (shown immediately).
|
| 31 | Partial(Vec<PrinterDevice>),
|
| 32 | /// Final list after optional full LAN scan (and cache update).
|
| 33 | Done(Result<Vec<PrinterDevice>, PrintError>),
|
| 34 | }
|
| 35 |
|
| 36 | pub struct PrintDialog {
|
| 37 | pub param_inputs: HashMap<String, String>,
|
| 38 | pub param_specs: Vec<ParamSpec>,
|
| 39 | pub last_params: HashMap<String, String>,
|
| 40 | pub printers: Vec<PrinterDevice>,
|
| 41 | pub printers_loading: bool,
|
| 42 | /// True while a LAN subnet scan may still be running after the cache partial.
|
| 43 | pub lan_scanning: bool,
|
| 44 | printers_rx: Option<Receiver<DiscoveryMsg>>,
|
| 45 | pub selected_printer: Option<usize>,
|
| 46 | pub manual_port: String,
|
| 47 | pub use_manual_port: bool,
|
| 48 | pub error: Option<String>,
|
| 49 | }
|
| 50 |
|
| 51 | impl Default for PrintDialog {
|
| 52 | fn default() -> Self {
|
| 53 | Self {
|
| 54 | param_inputs: HashMap::new(),
|
| 55 | param_specs: Vec::new(),
|
| 56 | last_params: HashMap::new(),
|
| 57 | printers: Vec::new(),
|
| 58 | printers_loading: false,
|
| 59 | lan_scanning: false,
|
| 60 | printers_rx: None,
|
| 61 | selected_printer: None,
|
| 62 | manual_port: String::new(),
|
| 63 | use_manual_port: false,
|
| 64 | error: None,
|
| 65 | }
|
| 66 | }
|
| 67 | }
|
| 68 |
|
| 69 | impl PrintDialog {
|
| 70 | pub fn prepare(&mut self, body: &str) -> Result<(), String> {
|
| 71 | self.error = None;
|
| 72 | let doc = parse(body).map_err(|e| e.to_string())?;
|
| 73 | self.param_specs = collect_parameters(&doc);
|
| 74 | self.param_inputs.clear();
|
| 75 | for spec in &self.param_specs {
|
| 76 | let value = match spec.kind {
|
| 77 | ParamKind::Bool => self
|
| 78 | .last_params
|
| 79 | .get(&spec.name)
|
| 80 | .cloned()
|
| 81 | .filter(|v| parse_bool_value(v).is_some())
|
| 82 | .unwrap_or_else(|| "false".into()),
|
| 83 | ParamKind::Text => self
|
| 84 | .last_params
|
| 85 | .get(&spec.name)
|
| 86 | .cloned()
|
| 87 | .unwrap_or_default(),
|
| 88 | };
|
| 89 | self.param_inputs.insert(spec.name.clone(), value);
|
| 90 | }
|
| 91 | self.start_printer_discovery();
|
| 92 | Ok(())
|
| 93 | }
|
| 94 |
|
| 95 | pub fn start_printer_discovery(&mut self) {
|
| 96 | self.printers_loading = true;
|
| 97 | self.lan_scanning = false;
|
| 98 | self.error = None;
|
| 99 | let (tx, rx) = mpsc::channel();
|
| 100 | self.printers_rx = Some(rx);
|
| 101 |
|
| 102 | let cfg = AppConfig::load();
|
| 103 | let lan_enabled = cfg.lan_printers_enabled;
|
| 104 | let lan_cache = cfg.lan_printer_cache.clone();
|
| 105 |
|
| 106 | std::thread::spawn(move || {
|
| 107 | let local = match list_local_printers() {
|
| 108 | Ok(list) => list,
|
| 109 | Err(e) => {
|
| 110 | let _ = tx.send(DiscoveryMsg::Done(Err(e)));
|
| 111 | return;
|
| 112 | }
|
| 113 | };
|
| 114 |
|
| 115 | if !lan_enabled {
|
| 116 | let _ = tx.send(DiscoveryMsg::Done(Ok(local)));
|
| 117 | return;
|
| 118 | }
|
| 119 |
|
| 120 | // Phase 1: validate cached LAN hosts (fast) and show them with local devices.
|
| 121 | let validated = validate_cache(&lan_cache);
|
| 122 | let mut partial = local.clone();
|
| 123 | partial.extend(validated.iter().cloned());
|
| 124 | let _ = tx.send(DiscoveryMsg::Partial(partial));
|
| 125 |
|
| 126 | // Phase 2: full subnet scan, merge, persist cache.
|
| 127 | let scanned = scan_local_subnets(DEFAULT_PORT);
|
| 128 | let lan = merge_lan_devices(&validated, &scanned);
|
| 129 | let new_cache = cache_entries_from_devices(&lan);
|
| 130 | let mut cfg = AppConfig::load();
|
| 131 | cfg.lan_printer_cache = new_cache;
|
| 132 | let _ = cfg.save();
|
| 133 |
|
| 134 | let mut final_list = local;
|
| 135 | final_list.extend(lan);
|
| 136 | let _ = tx.send(DiscoveryMsg::Done(Ok(final_list)));
|
| 137 | });
|
| 138 | }
|
| 139 |
|
| 140 | pub fn poll_printer_discovery(&mut self, ctx: &egui::Context) {
|
| 141 | let Some(rx) = &self.printers_rx else {
|
| 142 | return;
|
| 143 | };
|
| 144 |
|
| 145 | match rx.try_recv() {
|
| 146 | Ok(DiscoveryMsg::Partial(list)) => {
|
| 147 | self.printers = list;
|
| 148 | self.lan_scanning = true;
|
| 149 | self.apply_preferred_printer(AppConfig::load().last_printer_key.as_deref());
|
| 150 | ctx.request_repaint();
|
| 151 | }
|
| 152 | Ok(DiscoveryMsg::Done(result)) => {
|
| 153 | self.printers_rx = None;
|
| 154 | self.printers_loading = false;
|
| 155 | self.lan_scanning = false;
|
| 156 | match result {
|
| 157 | Ok(list) => {
|
| 158 | self.printers = list;
|
| 159 | self.apply_preferred_printer(AppConfig::load().last_printer_key.as_deref());
|
| 160 | }
|
| 161 | Err(e) => self.error = Some(format!("{e:?}")),
|
| 162 | }
|
| 163 | }
|
| 164 | Err(TryRecvError::Empty) => {
|
| 165 | ctx.request_repaint();
|
| 166 | }
|
| 167 | Err(TryRecvError::Disconnected) => {
|
| 168 | self.printers_rx = None;
|
| 169 | self.printers_loading = false;
|
| 170 | self.lan_scanning = false;
|
| 171 | }
|
| 172 | }
|
| 173 | }
|
| 174 |
|
| 175 | pub fn refresh_printers(&mut self) {
|
| 176 | self.start_printer_discovery();
|
| 177 | }
|
| 178 |
|
| 179 | /// Prefer the last successful printer when still connected; otherwise keep/default selection.
|
| 180 | pub fn apply_preferred_printer(&mut self, preferred_key: Option<&str>) {
|
| 181 | if let Some(key) = preferred_key.map(str::trim).filter(|k| !k.is_empty()) {
|
| 182 | if let Some(name) = key.strip_prefix("manual:") {
|
| 183 | let name = name.trim();
|
| 184 | if !name.is_empty() {
|
| 185 | self.use_manual_port = true;
|
| 186 | self.manual_port = name.to_string();
|
| 187 | return;
|
| 188 | }
|
| 189 | } else if let Some(i) = find_preferred_printer_index(&self.printers, key) {
|
| 190 | self.use_manual_port = false;
|
| 191 | self.selected_printer = Some(i);
|
| 192 | return;
|
| 193 | }
|
| 194 | }
|
| 195 | if self.selected_printer.is_none() && !self.printers.is_empty() {
|
| 196 | self.selected_printer = Some(0);
|
| 197 | }
|
| 198 | }
|
| 199 |
|
| 200 | fn remember_successful_printer(&self) {
|
| 201 | let mut cfg = AppConfig::load();
|
| 202 |
|
| 203 | if self.use_manual_port {
|
| 204 | let name = self.manual_port.trim();
|
| 205 | if name.is_empty() {
|
| 206 | return;
|
| 207 | }
|
| 208 | if let Some((host, port)) = posprint::print::parse_network_target(name) {
|
| 209 | remember_in_cache(&mut cfg.lan_printer_cache, &host, port);
|
| 210 | }
|
| 211 | let key = manual_printer_preference_key(name);
|
| 212 | if cfg.last_printer_key.as_deref() != Some(key.as_str()) {
|
| 213 | cfg.remember_printer(key);
|
| 214 | }
|
| 215 | } else if let Some(printer) = self.selected_printer.and_then(|i| self.printers.get(i)) {
|
| 216 | if let PrinterTarget::Network { host, port } = &printer.target {
|
| 217 | remember_in_cache(&mut cfg.lan_printer_cache, host, *port);
|
| 218 | }
|
| 219 | let key = printer_preference_key(&printer.target);
|
| 220 | if cfg.last_printer_key.as_deref() != Some(key.as_str()) {
|
| 221 | cfg.remember_printer(key);
|
| 222 | }
|
| 223 | } else {
|
| 224 | return;
|
| 225 | }
|
| 226 |
|
| 227 | let _ = cfg.save();
|
| 228 | }
|
| 229 |
|
| 230 | pub fn apply_inputs_to_last_params(&mut self) {
|
| 231 | self.last_params = self.param_inputs.clone();
|
| 232 | }
|
| 233 |
|
| 234 | pub fn execute_print(
|
| 235 | &mut self,
|
| 236 | body: &str,
|
| 237 | metadata: &PosMetadata,
|
| 238 | file_path: Option<&PathBuf>,
|
| 239 | ) -> PrintExecuteResult {
|
| 240 | self.error = None;
|
| 241 | if parse(body).is_err() {
|
| 242 | self.error = Some("Template has parse errors".into());
|
| 243 | return PrintExecuteResult::StillOpen;
|
| 244 | }
|
| 245 |
|
| 246 | for spec in &self.param_specs {
|
| 247 | if !self.param_inputs.contains_key(&spec.name) {
|
| 248 | self.error = Some(format!("Missing value for parameter {}", spec.name));
|
| 249 | return PrintExecuteResult::StillOpen;
|
| 250 | }
|
| 251 | if spec.kind == ParamKind::Bool {
|
| 252 | let raw = self.param_inputs.get(&spec.name).map(String::as_str).unwrap_or("");
|
| 253 | if parse_bool_value(raw).is_none() {
|
| 254 | self.error = Some(format!(
|
| 255 | "Invalid boolean for {}: use true/false",
|
| 256 | spec.name
|
| 257 | ));
|
| 258 | return PrintExecuteResult::StillOpen;
|
| 259 | }
|
| 260 | }
|
| 261 | }
|
| 262 |
|
| 263 | self.last_params = self.param_inputs.clone();
|
| 264 |
|
| 265 | let base_dir = file_path.and_then(|p| p.parent());
|
| 266 | let file = PosFile {
|
| 267 | version: 1,
|
| 268 | metadata: metadata.clone(),
|
| 269 | body: body.to_string(),
|
| 270 | };
|
| 271 | let bytes = match pipeline::encode_pos_file(&file, base_dir, &self.last_params) {
|
| 272 | Ok(b) => b,
|
| 273 | Err(e) => {
|
| 274 | self.error = Some(e.to_string());
|
| 275 | return PrintExecuteResult::StillOpen;
|
| 276 | }
|
| 277 | };
|
| 278 |
|
| 279 | let transport_result = if self.use_manual_port {
|
| 280 | let name = self.manual_port.trim();
|
| 281 | if name.is_empty() {
|
| 282 | self.error = Some("Select a printer or enter a port/queue name".into());
|
| 283 | return PrintExecuteResult::StillOpen;
|
| 284 | }
|
| 285 | open_printer_by_name(name)
|
| 286 | } else if let Some(target) = self.selected_printer_target() {
|
| 287 | open_printer(target)
|
| 288 | } else {
|
| 289 | self.error = Some("Select a printer".into());
|
| 290 | return PrintExecuteResult::StillOpen;
|
| 291 | };
|
| 292 |
|
| 293 | match transport_result {
|
| 294 | Ok(mut transport) => match print_bytes(transport.as_mut(), &bytes) {
|
| 295 | Ok(()) => {
|
| 296 | self.remember_successful_printer();
|
| 297 | PrintExecuteResult::Printed
|
| 298 | }
|
| 299 | Err(e) => {
|
| 300 | self.error = Some(format!("{e:?}"));
|
| 301 | PrintExecuteResult::StillOpen
|
| 302 | }
|
| 303 | },
|
| 304 | Err(e) => {
|
| 305 | self.error = Some(format!("{e:?}"));
|
| 306 | PrintExecuteResult::StillOpen
|
| 307 | }
|
| 308 | }
|
| 309 | }
|
| 310 |
|
| 311 | fn selected_printer_target(&self) -> Option<&posprint::print::PrinterTarget> {
|
| 312 | if self.use_manual_port {
|
| 313 | return None;
|
| 314 | }
|
| 315 | self.selected_printer
|
| 316 | .and_then(|i| self.printers.get(i))
|
| 317 | .map(|p| &p.target)
|
| 318 | }
|
| 319 |
|
| 320 | pub fn show_ui(&mut self, ui: &mut egui::Ui) -> PrintDialogAction {
|
| 321 | let mut action = PrintDialogAction::None;
|
| 322 |
|
| 323 | ui.heading("Parameters");
|
| 324 | if self.param_specs.is_empty() {
|
| 325 | ui.label("No parameters in this template.");
|
| 326 | } else {
|
| 327 | egui::ScrollArea::vertical()
|
| 328 | .id_salt("print_dialog_params")
|
| 329 | .max_height(140.0)
|
| 330 | .auto_shrink([false, true])
|
| 331 | .show(ui, |ui| {
|
| 332 | for spec in self.param_specs.clone() {
|
| 333 | ui.horizontal(|ui| {
|
| 334 | match spec.kind {
|
| 335 | ParamKind::Text => {
|
| 336 | ui.label(format!("{}:", spec.name));
|
| 337 | let entry = self
|
| 338 | .param_inputs
|
| 339 | .entry(spec.name.clone())
|
| 340 | .or_insert_with(String::new);
|
| 341 | ui.text_edit_singleline(entry);
|
| 342 | }
|
| 343 | ParamKind::Bool => {
|
| 344 | let mut checked = self
|
| 345 | .param_inputs
|
| 346 | .get(&spec.name)
|
| 347 | .and_then(|v| parse_bool_value(v))
|
| 348 | .unwrap_or(false);
|
| 349 | if ui.checkbox(&mut checked, &spec.name).changed() {
|
| 350 | self.param_inputs.insert(
|
| 351 | spec.name.clone(),
|
| 352 | if checked { "true" } else { "false" }.into(),
|
| 353 | );
|
| 354 | }
|
| 355 | }
|
| 356 | }
|
| 357 | });
|
| 358 | }
|
| 359 | });
|
| 360 | }
|
| 361 |
|
| 362 | ui.separator();
|
| 363 | ui.heading("Printer");
|
| 364 | ui.horizontal(|ui| {
|
| 365 | if ui
|
| 366 | .add_enabled(!self.printers_loading, egui::Button::new("Refresh"))
|
| 367 | .clicked()
|
| 368 | {
|
| 369 | self.refresh_printers();
|
| 370 | }
|
| 371 | if ui.button("Print").clicked() {
|
| 372 | action = PrintDialogAction::Print;
|
| 373 | }
|
| 374 | if self.printers_loading {
|
| 375 | ui.spinner();
|
| 376 | if self.lan_scanning {
|
| 377 | ui.label("Scanning LAN for TCP 9100 printers…");
|
| 378 | } else {
|
| 379 | ui.label("Discovering printers…");
|
| 380 | }
|
| 381 | }
|
| 382 | });
|
| 383 |
|
| 384 | ui.checkbox(
|
| 385 | &mut self.use_manual_port,
|
| 386 | "Enter port, queue, or LAN address manually",
|
| 387 | );
|
| 388 | if self.use_manual_port {
|
| 389 | ui.horizontal(|ui| {
|
| 390 | ui.label("Port / queue / host:");
|
| 391 | ui.text_edit_singleline(&mut self.manual_port);
|
| 392 | });
|
| 393 | ui.label(
|
| 394 | "Examples: COM3, /dev/ttyUSB0, Windows queue name, 192.168.1.50, 192.168.1.50:9100",
|
| 395 | );
|
| 396 | } else if self.printers_loading && self.printers.is_empty() {
|
| 397 | ui.label("Searching for USB, spooler, serial, and (if enabled) LAN printers…");
|
| 398 | } else if self.printers.is_empty() {
|
| 399 | ui.label(
|
| 400 | "No printers found. Connect a USB POS printer, enable LAN printers in Settings, refresh, or enter an address manually.",
|
| 401 | );
|
| 402 | } else {
|
| 403 | // Fixed height so wheel scrolling works; avoid nesting inside another ScrollArea.
|
| 404 | const PRINTER_LIST_HEIGHT: f32 = 220.0;
|
| 405 | egui::ScrollArea::vertical()
|
| 406 | .id_salt("print_dialog_printer_list")
|
| 407 | .max_height(PRINTER_LIST_HEIGHT)
|
| 408 | .min_scrolled_height(PRINTER_LIST_HEIGHT)
|
| 409 | .auto_shrink([false, false])
|
| 410 | .show(ui, |ui| {
|
| 411 | ui.set_min_width(ui.available_width());
|
| 412 | for (i, printer) in self.printers.iter().enumerate() {
|
| 413 | ui.selectable_value(
|
| 414 | &mut self.selected_printer,
|
| 415 | Some(i),
|
| 416 | &printer.display_name,
|
| 417 | );
|
| 418 | }
|
| 419 | });
|
| 420 | if self.lan_scanning {
|
| 421 | ui.label("LAN scan still running — list will update when finished.");
|
| 422 | }
|
| 423 | }
|
| 424 |
|
| 425 | if let Some(err) = &self.error {
|
| 426 | ui.colored_label(egui::Color32::RED, err);
|
| 427 | }
|
| 428 |
|
| 429 | action
|
| 430 | }
|
| 431 | }
|
| 432 |
|
| 433 | #[derive(Debug, Clone, Copy, PartialEq, Eq)]
|
| 434 | pub enum PrintDialogAction {
|
| 435 | None,
|
| 436 | Print,
|
| 437 | }
|
| 438 |
|
| 439 | #[cfg(test)]
|
| 440 | mod tests {
|
| 441 | use super::*;
|
| 442 | use posprint::print::PrinterTarget;
|
| 443 |
|
| 444 | #[test]
|
| 445 | fn prefers_last_connected_printer_over_first() {
|
| 446 | let mut dialog = PrintDialog::default();
|
| 447 | dialog.printers = vec![
|
| 448 | PrinterDevice {
|
| 449 | id: "a".into(),
|
| 450 | display_name: "First".into(),
|
| 451 | target: PrinterTarget::Serial("COM1".into()),
|
| 452 | },
|
| 453 | PrinterDevice {
|
| 454 | id: "b".into(),
|
| 455 | display_name: "Last".into(),
|
| 456 | target: PrinterTarget::WinSpooler("POS".into()),
|
| 457 | },
|
| 458 | ];
|
| 459 | dialog.apply_preferred_printer(Some("winspool:POS"));
|
| 460 | assert_eq!(dialog.selected_printer, Some(1));
|
| 461 | assert!(!dialog.use_manual_port);
|
| 462 | }
|
| 463 |
|
| 464 | #[test]
|
| 465 | fn falls_back_to_first_when_preferred_missing() {
|
| 466 | let mut dialog = PrintDialog::default();
|
| 467 | dialog.printers = vec![PrinterDevice {
|
| 468 | id: "a".into(),
|
| 469 | display_name: "Only".into(),
|
| 470 | target: PrinterTarget::Serial("COM1".into()),
|
| 471 | }];
|
| 472 | dialog.apply_preferred_printer(Some("winspool:Gone"));
|
| 473 | assert_eq!(dialog.selected_printer, Some(0));
|
| 474 | }
|
| 475 |
|
| 476 | #[test]
|
| 477 | fn restores_manual_preference() {
|
| 478 | let mut dialog = PrintDialog::default();
|
| 479 | dialog.apply_preferred_printer(Some("manual:COM9"));
|
| 480 | assert!(dialog.use_manual_port);
|
| 481 | assert_eq!(dialog.manual_port, "COM9");
|
| 482 | }
|
| 483 | }
|