use std::collections::HashMap; use std::path::PathBuf; use eframe::egui; use posprint::dsl::{self, parse}; use posprint::editor_assist::{ at_directive_prefix, barcode_insert_options, directive_completions, image_insert_options, insert_at_cursor, qr_insert_options, }; use posprint::pipeline; use posprint::io::{PosFile, PosMetadata, PreviewMode}; use posprint::params::collect_parameter_names; use posprint::preview::{render_preview, PreviewLine, TextStyle}; use posprint::print::{list_usb_serial_printers, print_bytes, SerialTransport, PrinterDevice}; use posprint::HELP_MARKDOWN; #[derive(Clone, Copy, PartialEq, Eq)] enum Tab { Editor, Preview, Help, } pub struct PosPrintApp { tab: Tab, body: String, metadata: PosMetadata, file_path: Option, dirty: bool, parse_error: Option, status_message: Option, last_params: HashMap, show_print_dialog: bool, print_param_inputs: HashMap, print_param_names: Vec, printers: Vec, selected_printer: Option, print_error: Option, editor_cursor: usize, autocomplete: Vec<&'static str>, } impl Default for PosPrintApp { fn default() -> Self { Self { tab: Tab::Editor, body: default_template(), metadata: PosMetadata::default(), file_path: None, dirty: false, parse_error: None, status_message: None, last_params: HashMap::new(), show_print_dialog: false, print_param_inputs: HashMap::new(), print_param_names: Vec::new(), printers: Vec::new(), selected_printer: None, print_error: None, editor_cursor: 0, autocomplete: Vec::new(), } } } impl PosPrintApp { pub fn new() -> Self { Self::default() } fn title(&self) -> String { let name = self .file_path .as_ref() .and_then(|p| p.file_name()) .map(|s| s.to_string_lossy().to_string()) .or_else(|| self.metadata.title.clone()) .unwrap_or_else(|| "Untitled".into()); if self.dirty { format!("{name} * — posprint") } else { format!("{name} — posprint") } } fn pos_file(&self) -> PosFile { PosFile { version: 1, metadata: self.metadata.clone(), body: self.body.clone(), } } fn load_pos_file(&mut self, path: PathBuf, file: PosFile) { self.body = file.body; self.metadata = file.metadata; self.file_path = Some(path); self.dirty = false; self.parse_error = None; self.status_message = Some("File loaded".into()); } fn validate_parse(&mut self) { self.parse_error = match parse(&self.body) { Ok(_) => None, Err(e) => Some(e.to_string()), }; } fn open_print_dialog(&mut self) { self.print_error = None; match parse(&self.body) { Ok(doc) => { self.print_param_names = collect_parameter_names(&doc); self.print_param_inputs.clear(); for name in &self.print_param_names { let value = self .last_params .get(name) .cloned() .unwrap_or_default(); self.print_param_inputs.insert(name.clone(), value); } self.show_print_dialog = true; self.refresh_printers(); } Err(e) => self.parse_error = Some(e.to_string()), } } fn refresh_printers(&mut self) { match list_usb_serial_printers() { Ok(list) => { self.printers = list; if self.selected_printer.is_none() && !self.printers.is_empty() { self.selected_printer = Some(0); } } Err(e) => self.print_error = Some(e.to_string()), } } fn execute_print(&mut self) { self.print_error = None; if parse(&self.body).is_err() { self.print_error = Some("Template has parse errors".into()); return; } for name in &self.print_param_names { if !self.print_param_inputs.contains_key(name) { self.print_error = Some(format!("Missing value for parameter {name}")); return; } } self.last_params = self.print_param_inputs.clone(); let base_dir = self.file_path.as_ref().and_then(|p| p.parent()); let file = self.pos_file(); let bytes = match pipeline::encode_pos_file(&file, base_dir, &self.last_params) { Ok(b) => b, Err(e) => { self.print_error = Some(e.to_string()); return; } }; let idx = match self.selected_printer { Some(i) if i < self.printers.len() => i, _ => { self.print_error = Some("Select a printer".into()); return; } }; let port = self.printers[idx].port_name.clone(); match SerialTransport::open(&port) { Ok(mut transport) => match print_bytes(&mut transport, &bytes) { Ok(()) => { self.status_message = Some(format!("Printed to {port}")); self.show_print_dialog = false; } Err(e) => self.print_error = Some(format!("{e:?}")), }, Err(e) => self.print_error = Some(format!("{e:?}")), } } } impl eframe::App for PosPrintApp { fn update(&mut self, ctx: &egui::Context, _frame: &mut eframe::Frame) { self.validate_parse(); egui::TopBottomPanel::top("menu").show(ctx, |ui| { ui.horizontal_wrapped(|ui| { if ui.button("New").clicked() { *self = Self::default(); } if ui.button("Open").clicked() { if let Some(path) = rfd::FileDialog::new() .add_filter("POS template", &["pos"]) .pick_file() { match PosFile::load_from_path(&path) { Ok(file) => self.load_pos_file(path, file), Err(e) => self.status_message = Some(format!("Open failed: {e:?}")), } } } if ui.button("Save").clicked() { if let Some(path) = self.file_path.clone() { if let Err(e) = self.pos_file().save_to_path(&path) { self.status_message = Some(format!("Save failed: {e:?}")); } else { self.dirty = false; self.status_message = Some("Saved".into()); } } else if ui.button("Save As").clicked() { // handled below when no path } } if ui.button("Save As").clicked() { if let Some(path) = rfd::FileDialog::new() .add_filter("POS template", &["pos"]) .set_file_name("document.pos") .save_file() { if let Err(e) = self.pos_file().save_to_path(&path) { self.status_message = Some(format!("Save failed: {e:?}")); } else { self.file_path = Some(path); self.dirty = false; self.status_message = Some("Saved".into()); } } } if ui.button("Print").clicked() { self.open_print_dialog(); } ui.menu_button("Insert", |ui| { for opt in image_insert_options() { if ui.button(format!("Image — {}", opt.label)).clicked() { self.insert_snippet(&opt.snippet); ui.close_menu(); } } ui.separator(); ui.menu_button("Barcode", |ui| { for opt in barcode_insert_options() { if ui.button(&opt.label).clicked() { self.insert_snippet(&opt.snippet); ui.close_menu(); } } }); ui.menu_button("QR code", |ui| { for opt in qr_insert_options() { if ui.button(&opt.label).clicked() { self.insert_snippet(&opt.snippet); ui.close_menu(); } } }); ui.separator(); if ui.button("@feed").clicked() { self.insert_snippet("@feed 3\n"); ui.close_menu(); } if ui.button("@cut").clicked() { self.insert_snippet("@cut\n"); ui.close_menu(); } }); }); ui.separator(); ui.horizontal(|ui| { ui.label("Page width (mm):"); let mut width = self.metadata.page_width_mm; if ui .add(egui::DragValue::new(&mut width).range(40.0..=120.0).speed(1.0)) .changed() { self.metadata.page_width_mm = width; self.dirty = true; } ui.label("Preview:"); egui::ComboBox::from_id_salt("preview_mode") .selected_text(match self.metadata.preview_mode { PreviewMode::Autoscale => "Auto-scale", PreviewMode::Fixed => "Fixed width", }) .show_ui(ui, |ui| { if ui .selectable_value( &mut self.metadata.preview_mode, PreviewMode::Autoscale, "Auto-scale", ) .changed() { self.dirty = true; } if ui .selectable_value( &mut self.metadata.preview_mode, PreviewMode::Fixed, "Fixed width", ) .changed() { self.dirty = true; } }); }); if let Some(err) = &self.parse_error { ui.colored_label(egui::Color32::RED, err); } if let Some(msg) = &self.status_message { ui.label(msg); } }); egui::TopBottomPanel::bottom("tabs").show(ctx, |ui| { ui.horizontal(|ui| { ui.selectable_value(&mut self.tab, Tab::Editor, "Editor"); ui.selectable_value(&mut self.tab, Tab::Preview, "Preview"); ui.selectable_value(&mut self.tab, Tab::Help, "Help"); }); }); egui::CentralPanel::default().show(ctx, |ui| match self.tab { Tab::Editor => self.show_editor(ui), Tab::Preview => self.show_preview(ui), Tab::Help => self.show_help(ui), }); if self.show_print_dialog { egui::Window::new("Print") .collapsible(false) .resizable(true) .show(ctx, |ui| self.show_print_dialog_ui(ui)); } ctx.send_viewport_cmd(egui::ViewportCommand::Title(self.title())); } } impl PosPrintApp { fn insert_snippet(&mut self, snippet: &str) { let (body, cursor) = insert_at_cursor(&self.body, self.editor_cursor, snippet); self.body = body; self.editor_cursor = cursor; self.dirty = true; self.tab = Tab::Editor; } fn show_editor(&mut self, ui: &mut egui::Ui) { let output = egui::TextEdit::multiline(&mut self.body) .id_salt("main_editor") .desired_width(f32::INFINITY) .desired_rows(30) .font(egui::TextStyle::Monospace) .show(ui); self.editor_cursor = output .state .cursor .char_range() .map(|r| r.primary.index) .unwrap_or(self.body.len()); if output.response.changed() { self.dirty = true; } if let Some((_start, prefix)) = at_directive_prefix(&self.body, self.editor_cursor) { self.autocomplete = directive_completions(&prefix); if !self.autocomplete.is_empty() { egui::Area::new(egui::Id::new("directive_ac")) .order(egui::Order::Foreground) .show(ui.ctx(), |ui| { ui.set_min_width(120.0); ui.label("Directive autocomplete:"); for dir in &self.autocomplete { if ui.button(format!("@{dir}")).clicked() { let line_start = self.body[..self.editor_cursor] .rfind('\n') .map(|i| i + 1) .unwrap_or(0); let line_end = self.body[self.editor_cursor..] .find('\n') .map(|i| self.editor_cursor + i) .unwrap_or(self.body.len()); let mut line = self.body[line_start..line_end].to_string(); if let Some(at) = line.find('@') { line.replace_range(at + 1.., dir); self.body.replace_range(line_start..line_end, &line); self.editor_cursor = line_start + at + 1 + dir.len(); self.dirty = true; } } } }); } } else { self.autocomplete.clear(); } } fn show_preview(&mut self, ui: &mut egui::Ui) { let Ok(doc) = parse(&self.body) else { ui.label("Fix parse errors to preview."); return; }; let model = render_preview(&doc, &self.metadata); let chars = model.width_chars as f32; let scale = match self.metadata.preview_mode { PreviewMode::Autoscale => { let avail = ui.available_width().max(200.0); (avail / (chars * 8.0)).clamp(0.8, 3.0) } PreviewMode::Fixed => model.width_mm / 80.0, }; egui::Frame::canvas(ui.style()).show(ui, |ui| { let width = chars * 8.0 * scale; let (_id, rect) = ui.allocate_space(egui::vec2(width, ui.available_height())); let painter = ui.painter_at(rect); painter.rect_filled(rect, 4.0, egui::Color32::WHITE); painter.rect_stroke( rect, 4.0, egui::Stroke::new(1.0_f32, egui::Color32::GRAY), egui::StrokeKind::Inside, ); let mut y = rect.min.y + 8.0; let line_height = 18.0 * scale; for line in &model.lines { match line { PreviewLine::Text { content, align, style, } => { let font_id = match style { TextStyle::Heading1 => egui::FontId::proportional(22.0 * scale), TextStyle::Heading2 => egui::FontId::proportional(18.0 * scale), TextStyle::Bold => egui::FontId::proportional(16.0 * scale), TextStyle::Italic => egui::FontId::proportional(15.0 * scale), TextStyle::Code => egui::FontId::monospace(14.0 * scale), TextStyle::Normal => egui::FontId::monospace(14.0 * scale), }; let galley = painter.layout( content.clone(), font_id, egui::Color32::BLACK, width, ); let x = match align { dsl::Align::Left => rect.min.x + 8.0, dsl::Align::Center => { rect.min.x + (width - galley.size().x) / 2.0 } dsl::Align::Right => rect.max.x - galley.size().x - 8.0, }; painter.galley(egui::pos2(x, y), galley, egui::Color32::BLACK); y += line_height; } PreviewLine::Rule => { painter.line_segment( [ egui::pos2(rect.min.x + 8.0, y), egui::pos2(rect.max.x - 8.0, y), ], egui::Stroke::new(1.0_f32, egui::Color32::DARK_GRAY), ); y += line_height; } PreviewLine::Barcode { symbology, data, .. } => { let text = format!("[barcode {symbology}: {data}]"); let galley = painter.layout( text, egui::FontId::monospace(14.0 * scale), egui::Color32::BLACK, width, ); painter.galley(egui::pos2(rect.min.x + 8.0, y), galley, egui::Color32::BLACK); y += line_height * 1.5; } PreviewLine::Qr { data, .. } => { let text = format!("[qr: {data}]"); let galley = painter.layout( text, egui::FontId::monospace(14.0 * scale), egui::Color32::BLACK, width, ); painter.galley(egui::pos2(rect.min.x + 8.0, y), galley, egui::Color32::BLACK); y += line_height * 1.5; } PreviewLine::Image { label, .. } => { let galley = painter.layout( label.clone(), egui::FontId::monospace(14.0 * scale), egui::Color32::DARK_BLUE, width, ); painter.galley(egui::pos2(rect.min.x + 8.0, y), galley, egui::Color32::BLACK); y += line_height * 1.5; } PreviewLine::Spacer(n) => { y += line_height * (*n as f32); } } } }); } fn show_help(&mut self, ui: &mut egui::Ui) { egui::ScrollArea::vertical().show(ui, |ui| { ui.add( egui::Label::new(HELP_MARKDOWN) .wrap() .selectable(true), ); }); } fn show_print_dialog_ui(&mut self, ui: &mut egui::Ui) { ui.heading("Parameters"); if self.print_param_names.is_empty() { ui.label("No parameters in this template."); } else { for name in self.print_param_names.clone() { ui.horizontal(|ui| { ui.label(format!("{name}:")); let entry = self .print_param_inputs .entry(name) .or_insert_with(String::new); ui.text_edit_singleline(entry); }); } } ui.separator(); ui.heading("USB printer"); if ui.button("Refresh").clicked() { self.refresh_printers(); } if self.printers.is_empty() { ui.label("No serial ports found. Connect a USB printer and refresh."); } else { 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.print_error { ui.colored_label(egui::Color32::RED, err); } ui.horizontal(|ui| { if ui.button("Cancel").clicked() { self.show_print_dialog = false; } if ui.button("Print").clicked() { self.execute_print(); } }); } } fn default_template() -> String { r#"# ${StoreName} :center: Receipt: ${DocumentNumber} Date: ${Date} --- :right: **TOTAL: ${GrandTotal}** @barcode CODE128 ${DocumentNumber} @feed 2 @qr https://example.com/r/${DocumentNumber} Thank you! @feed 4 @cut "# .to_string() } #[cfg(test)] mod tests { use super::*; #[test] fn default_template_parses() { let app = PosPrintApp::default(); assert!(parse(&app.body).is_ok()); } #[test] fn collect_params_from_default_template() { let app = PosPrintApp::default(); let doc = parse(&app.body).unwrap(); let names = collect_parameter_names(&doc); assert!(names.contains(&"StoreName".to_string())); assert!(names.contains(&"DocumentNumber".to_string())); } }