BlueGit

timfa posprint

Files

posprint / src / print_dialog.rs

print_dialog.rs

print_dialog.rs 17.6 KiB Download Raw
1//! Shared print dialog state and UI (full app and print-only launcher).
2
3use std::collections::HashMap;
4use std::path::PathBuf;
5use std::sync::mpsc::{self, Receiver, TryRecvError};
6
7use eframe::egui;
8
9use posprint::dsl::parse;
10use posprint::io::{PosFile, PosMetadata};
11use posprint::params::{collect_parameters, parse_bool_value, ParamKind, ParamSpec};
12use posprint::pipeline;
13use 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};
19use posprint::config::AppConfig;
20
21#[derive(Debug, Clone, Copy, PartialEq, Eq)]
22pub enum PrintExecuteResult {
23 StillOpen,
24 Printed,
25}
26
27/// Progressive printer discovery results from the background thread.
28#[derive(Debug)]
29enum 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
36pub 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
51impl 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
69impl 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)]
434pub enum PrintDialogAction {
435 None,
436 Print,
437}
438
439#[cfg(test)]
440mod 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}