BlueGit

timfa posprint

Add extended barcode/QR types with native and raster modes.

Support CODE128, EAN, CODE39/93, UPC, ITF, CODABAR, CODE11 via ESC/POS or bitmap.

Co-authored-by: Cursor <cursoragent@cursor.com>

timfa Tim Falken · pushed by timfa

Authored 2026-07-15 · 4 months ago

Hash
0657534d6e1ebac26241b667a9a17867afdde069
Parent
41fce7f2
10 files changed +715 −43
src/cli.rs added +84 −0
@@ -0,0 +1,84 @@
1 use std::collections::HashMap;
2 use std::path::PathBuf;
3
4 use clap::{Parser, Subcommand};
5
6 use crate::pipeline;
7
8 #[derive(Parser, Debug)]
9 #[command(
10 name = "posprint",
11 about = "POS print document designer",
12 disable_version_flag = false
13 )]
14 pub struct Cli {
15 #[command(subcommand)]
16 pub command: Option<Commands>,
17 }
18
19 #[derive(Subcommand, Debug)]
20 pub enum Commands {
21 /// Print a .pos file to a USB-serial printer (all parameters required)
22 Print {
23 /// Path to the `.pos` template file
24 file: PathBuf,
25 /// Serial port (e.g. COM3 on Windows, /dev/ttyUSB0 on Linux)
26 #[arg(short, long)]
27 printer: String,
28 /// Template parameter as NAME=VALUE (repeat for each ${Name} in the template)
29 #[arg(long = "set", value_name = "NAME=VALUE")]
30 set: Vec<String>,
31 },
32 }
33
34 pub fn run(cli: Cli) -> i32 {
35 match cli.command {
36 Some(Commands::Print { file, printer, set }) => match run_print(&file, &printer, &set) {
37 Ok(()) => 0,
38 Err(e) => {
39 eprintln!("{e}");
40 1
41 }
42 },
43 None => {
44 eprintln!("No subcommand specified. Run `posprint --help` or start without arguments for the GUI.");
45 1
46 }
47 }
48 }
49
50 fn run_print(file: &PathBuf, printer: &str, set: &[String]) -> Result<(), String> {
51 let params = parse_params(set)?;
52 pipeline::print_pos_file(file, printer, &params).map_err(|e| e.to_string())
53 }
54
55 pub fn parse_params(pairs: &[String]) -> Result<HashMap<String, String>, String> {
56 let mut map = HashMap::new();
57 for pair in pairs {
58 let Some((name, value)) = pair.split_once('=') else {
59 return Err(format!("invalid parameter '{pair}', expected NAME=VALUE"));
60 };
61 if name.is_empty() {
62 return Err("parameter name cannot be empty".into());
63 }
64 map.insert(name.to_string(), value.to_string());
65 }
66 Ok(map)
67 }
68
69 #[cfg(test)]
70 mod tests {
71 use super::*;
72
73 #[test]
74 fn parses_set_pairs() {
75 let params = parse_params(&["A=1".into(), "B=two".into()]).unwrap();
76 assert_eq!(params.get("A").unwrap(), "1");
77 assert_eq!(params.get("B").unwrap(), "two");
78 }
79
80 #[test]
81 fn rejects_invalid_pair() {
82 assert!(parse_params(&["nope".into()]).is_err());
83 }
84 }
@@ -0,0 +1,84 @@
1use std::collections::HashMap;
2use std::path::PathBuf;
3
4use clap::{Parser, Subcommand};
5
6use crate::pipeline;
7
8#[derive(Parser, Debug)]
9#[command(
10 name = "posprint",
11 about = "POS print document designer",
12 disable_version_flag = false
13)]
14pub struct Cli {
15 #[command(subcommand)]
16 pub command: Option<Commands>,
17}
18
19#[derive(Subcommand, Debug)]
20pub enum Commands {
21 /// Print a .pos file to a USB-serial printer (all parameters required)
22 Print {
23 /// Path to the `.pos` template file
24 file: PathBuf,
25 /// Serial port (e.g. COM3 on Windows, /dev/ttyUSB0 on Linux)
26 #[arg(short, long)]
27 printer: String,
28 /// Template parameter as NAME=VALUE (repeat for each ${Name} in the template)
29 #[arg(long = "set", value_name = "NAME=VALUE")]
30 set: Vec<String>,
31 },
32}
33
34pub fn run(cli: Cli) -> i32 {
35 match cli.command {
36 Some(Commands::Print { file, printer, set }) => match run_print(&file, &printer, &set) {
37 Ok(()) => 0,
38 Err(e) => {
39 eprintln!("{e}");
40 1
41 }
42 },
43 None => {
44 eprintln!("No subcommand specified. Run `posprint --help` or start without arguments for the GUI.");
45 1
46 }
47 }
48}
49
50fn run_print(file: &PathBuf, printer: &str, set: &[String]) -> Result<(), String> {
51 let params = parse_params(set)?;
52 pipeline::print_pos_file(file, printer, &params).map_err(|e| e.to_string())
53}
54
55pub fn parse_params(pairs: &[String]) -> Result<HashMap<String, String>, String> {
56 let mut map = HashMap::new();
57 for pair in pairs {
58 let Some((name, value)) = pair.split_once('=') else {
59 return Err(format!("invalid parameter '{pair}', expected NAME=VALUE"));
60 };
61 if name.is_empty() {
62 return Err("parameter name cannot be empty".into());
63 }
64 map.insert(name.to_string(), value.to_string());
65 }
66 Ok(map)
67}
68
69#[cfg(test)]
70mod tests {
71 use super::*;
72
73 #[test]
74 fn parses_set_pairs() {
75 let params = parse_params(&["A=1".into(), "B=two".into()]).unwrap();
76 assert_eq!(params.get("A").unwrap(), "1");
77 assert_eq!(params.get("B").unwrap(), "two");
78 }
79
80 #[test]
81 fn rejects_invalid_pair() {
82 assert!(parse_params(&["nope".into()]).is_err());
83 }
84}
src/dsl/mod.rs +85 −0
@@ -43,6 +43,7 @@ pub enum Block {
43 43 align: Align,
44 44 },
45 45 Barcode {
46 mode: BarcodeMode,
46 47 symbology: BarcodeSymbology,
47 48 data: String,
48 49 height: u8,
@@ -50,9 +51,11 @@ pub enum Block {
50 51 show_text: bool,
51 52 },
52 53 Qr {
54 mode: QrMode,
53 55 data: String,
54 56 size: u8,
55 57 ecc: QrEcc,
58 version: Option<u8>,
56 59 align: Align,
57 60 },
58 61 }
@@ -65,6 +68,20 @@ pub enum Align {
65 68 Right,
66 69 }
67 70
71 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
72 pub enum BarcodeMode {
73 #[default]
74 Native,
75 Raster,
76 }
77
78 #[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
79 pub enum QrMode {
80 #[default]
81 Native,
82 Raster,
83 }
84
68 85 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
69 86 pub enum ImageWidth {
70 87 Percent(u8),
@@ -78,6 +95,12 @@ pub enum BarcodeSymbology {
78 95 Ean13,
79 96 Ean8,
80 97 Code39,
98 Code93,
99 UpcA,
100 UpcE,
101 Itf,
102 Codabar,
103 Code11,
81 104 }
82 105
83 106 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -97,6 +120,68 @@ pub enum Inline {
97 120 Param(String),
98 121 }
99 122
123 impl BarcodeSymbology {
124 pub const ALL: &'static [BarcodeSymbology] = &[
125 BarcodeSymbology::Code128,
126 BarcodeSymbology::Ean13,
127 BarcodeSymbology::Ean8,
128 BarcodeSymbology::Code39,
129 BarcodeSymbology::Code93,
130 BarcodeSymbology::UpcA,
131 BarcodeSymbology::UpcE,
132 BarcodeSymbology::Itf,
133 BarcodeSymbology::Codabar,
134 BarcodeSymbology::Code11,
135 ];
136
137 pub fn from_name(name: &str) -> Option<Self> {
138 match name.to_ascii_uppercase().as_str() {
139 "CODE128" => Some(Self::Code128),
140 "EAN13" => Some(Self::Ean13),
141 "EAN8" => Some(Self::Ean8),
142 "CODE39" => Some(Self::Code39),
143 "CODE93" => Some(Self::Code93),
144 "UPC-A" | "UPCA" => Some(Self::UpcA),
145 "UPC-E" | "UPCE" => Some(Self::UpcE),
146 "ITF" | "ITF14" | "I25" => Some(Self::Itf),
147 "CODABAR" => Some(Self::Codabar),
148 "CODE11" => Some(Self::Code11),
149 _ => None,
150 }
151 }
152
153 pub fn as_str(self) -> &'static str {
154 match self {
155 Self::Code128 => "CODE128",
156 Self::Ean13 => "EAN13",
157 Self::Ean8 => "EAN8",
158 Self::Code39 => "CODE39",
159 Self::Code93 => "CODE93",
160 Self::UpcA => "UPC-A",
161 Self::UpcE => "UPC-E",
162 Self::Itf => "ITF",
163 Self::Codabar => "CODABAR",
164 Self::Code11 => "CODE11",
165 }
166 }
167
168 pub fn supports_native(self) -> bool {
169 !matches!(self, Self::Code93 | Self::Code11)
170 }
171 }
172
173 impl QrEcc {
174 pub fn from_name(name: &str) -> Option<Self> {
175 match name.to_ascii_uppercase().as_str() {
176 "L" => Some(Self::L),
177 "M" => Some(Self::M),
178 "Q" => Some(Self::Q),
179 "H" => Some(Self::H),
180 _ => None,
181 }
182 }
183 }
184
100 185 mod parser;
101 186
102 187 pub use parser::parse;
@@ -43,6 +43,7 @@ pub enum Block {
43 align: Align,
43 align: Align,
44 },
44 },
45 Barcode {
45 Barcode {
46 mode: BarcodeMode,
46 symbology: BarcodeSymbology,
47 symbology: BarcodeSymbology,
47 data: String,
48 data: String,
48 height: u8,
49 height: u8,
@@ -50,9 +51,11 @@ pub enum Block {
50 show_text: bool,
51 show_text: bool,
51 },
52 },
52 Qr {
53 Qr {
54 mode: QrMode,
53 data: String,
55 data: String,
54 size: u8,
56 size: u8,
55 ecc: QrEcc,
57 ecc: QrEcc,
58 version: Option<u8>,
56 align: Align,
59 align: Align,
57 },
60 },
58}
61}
@@ -65,6 +68,20 @@ pub enum Align {
65 Right,
68 Right,
66}
69}
67
70
71#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
72pub enum BarcodeMode {
73 #[default]
74 Native,
75 Raster,
76}
77
78#[derive(Debug, Clone, Copy, PartialEq, Eq, Default)]
79pub enum QrMode {
80 #[default]
81 Native,
82 Raster,
83}
84
68#[derive(Debug, Clone, Copy, PartialEq, Eq)]
85#[derive(Debug, Clone, Copy, PartialEq, Eq)]
69pub enum ImageWidth {
86pub enum ImageWidth {
70 Percent(u8),
87 Percent(u8),
@@ -78,6 +95,12 @@ pub enum BarcodeSymbology {
78 Ean13,
95 Ean13,
79 Ean8,
96 Ean8,
80 Code39,
97 Code39,
98 Code93,
99 UpcA,
100 UpcE,
101 Itf,
102 Codabar,
103 Code11,
81}
104}
82
105
83#[derive(Debug, Clone, Copy, PartialEq, Eq)]
106#[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -97,6 +120,68 @@ pub enum Inline {
97 Param(String),
120 Param(String),
98}
121}
99
122
123impl BarcodeSymbology {
124 pub const ALL: &'static [BarcodeSymbology] = &[
125 BarcodeSymbology::Code128,
126 BarcodeSymbology::Ean13,
127 BarcodeSymbology::Ean8,
128 BarcodeSymbology::Code39,
129 BarcodeSymbology::Code93,
130 BarcodeSymbology::UpcA,
131 BarcodeSymbology::UpcE,
132 BarcodeSymbology::Itf,
133 BarcodeSymbology::Codabar,
134 BarcodeSymbology::Code11,
135 ];
136
137 pub fn from_name(name: &str) -> Option<Self> {
138 match name.to_ascii_uppercase().as_str() {
139 "CODE128" => Some(Self::Code128),
140 "EAN13" => Some(Self::Ean13),
141 "EAN8" => Some(Self::Ean8),
142 "CODE39" => Some(Self::Code39),
143 "CODE93" => Some(Self::Code93),
144 "UPC-A" | "UPCA" => Some(Self::UpcA),
145 "UPC-E" | "UPCE" => Some(Self::UpcE),
146 "ITF" | "ITF14" | "I25" => Some(Self::Itf),
147 "CODABAR" => Some(Self::Codabar),
148 "CODE11" => Some(Self::Code11),
149 _ => None,
150 }
151 }
152
153 pub fn as_str(self) -> &'static str {
154 match self {
155 Self::Code128 => "CODE128",
156 Self::Ean13 => "EAN13",
157 Self::Ean8 => "EAN8",
158 Self::Code39 => "CODE39",
159 Self::Code93 => "CODE93",
160 Self::UpcA => "UPC-A",
161 Self::UpcE => "UPC-E",
162 Self::Itf => "ITF",
163 Self::Codabar => "CODABAR",
164 Self::Code11 => "CODE11",
165 }
166 }
167
168 pub fn supports_native(self) -> bool {
169 !matches!(self, Self::Code93 | Self::Code11)
170 }
171}
172
173impl QrEcc {
174 pub fn from_name(name: &str) -> Option<Self> {
175 match name.to_ascii_uppercase().as_str() {
176 "L" => Some(Self::L),
177 "M" => Some(Self::M),
178 "Q" => Some(Self::Q),
179 "H" => Some(Self::H),
180 _ => None,
181 }
182 }
183}
184
100mod parser;
185mod parser;
101
186
102pub use parser::parse;
187pub use parser::parse;
src/dsl/parser.rs +83 −23
@@ -1,5 +1,6 @@
1 1 use super::{
2 Align, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc,
2 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc,
3 QrMode,
3 4 };
4 5
5 6 pub fn parse(source: &str) -> Result<Document, ParseError> {
@@ -192,21 +193,44 @@ fn parse_barcode_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, Pa
192 193 return Err(err(
193 194 line_no,
194 195 1,
195 "@barcode requires symbology and data",
196 "@barcode requires symbology and data (or RASTER symbology data)",
196 197 ));
197 198 }
198 let symbology = match parts[0].to_ascii_uppercase().as_str() {
199 "CODE128" => BarcodeSymbology::Code128,
200 "EAN13" => BarcodeSymbology::Ean13,
201 "EAN8" => BarcodeSymbology::Ean8,
202 "CODE39" => BarcodeSymbology::Code39,
203 other => return Err(err(line_no, 1, format!("unknown barcode symbology {other}"))),
199
200 let (mode, sym_idx, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
201 if parts.len() < 3 {
202 return Err(err(
203 line_no,
204 1,
205 "@barcode RASTER requires symbology and data",
206 ));
207 }
208 (BarcodeMode::Raster, 1, 2)
209 } else {
210 (BarcodeMode::Native, 0, 1)
204 211 };
205 let data = parts[1].to_string();
212
213 let symbology = BarcodeSymbology::from_name(parts[sym_idx])
214 .ok_or_else(|| err(line_no, 1, format!("unknown barcode symbology {}", parts[sym_idx])))?;
215
216 if mode == BarcodeMode::Native && !symbology.supports_native() {
217 return Err(err(
218 line_no,
219 1,
220 format!(
221 "{} has no native ESC/POS support; use RASTER {}",
222 symbology.as_str(),
223 symbology.as_str()
224 ),
225 ));
226 }
227
228 let data = parts[data_idx].to_string();
229 let attr_start = data_idx + 1;
206 230 let mut height = 64u8;
207 231 let mut align = Align::Left;
208 232 let mut show_text = true;
209 for attr in &parts[2..] {
233 for attr in &parts[attr_start..] {
210 234 if let Some((k, v)) = attr.split_once('=') {
211 235 match k.to_ascii_lowercase().as_str() {
212 236 "height" => {
@@ -215,14 +239,13 @@ fn parse_barcode_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, Pa
215 239 .map_err(|_| err(line_no, 1, "invalid barcode height"))?;
216 240 }
217 241 "align" => align = parse_align_value(v, line_no)?,
218 "show_text" => {
219 show_text = v == "true";
220 }
242 "show_text" => show_text = v == "true",
221 243 _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))),
222 244 }
223 245 }
224 246 }
225 247 Ok(Block::Barcode {
248 mode,
226 249 symbology,
227 250 data,
228 251 height,
@@ -235,11 +258,23 @@ fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseEr
235 258 if parts.is_empty() {
236 259 return Err(err(line_no, 1, "@qr requires data"));
237 260 }
238 let data = parts[0].to_string();
261
262 let (mode, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
263 if parts.len() < 2 {
264 return Err(err(line_no, 1, "@qr RASTER requires data"));
265 }
266 (QrMode::Raster, 1)
267 } else {
268 (QrMode::Native, 0)
269 };
270
271 let data = parts[data_idx].to_string();
272 let attr_start = data_idx + 1;
239 273 let mut size = 4u8;
240 274 let mut ecc = QrEcc::M;
241 275 let mut align = Align::Left;
242 for attr in &parts[1..] {
276 let mut version = None;
277 for attr in &parts[attr_start..] {
243 278 if let Some((k, v)) = attr.split_once('=') {
244 279 match k.to_ascii_lowercase().as_str() {
245 280 "size" => {
@@ -248,14 +283,24 @@ fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseEr
248 283 .map_err(|_| err(line_no, 1, "invalid qr size"))?
249 284 .clamp(1, 16);
250 285 }
286 "scale" => {
287 size = v
288 .parse::<u8>()
289 .map_err(|_| err(line_no, 1, "invalid qr scale"))?
290 .clamp(1, 16);
291 }
292 "version" => {
293 let ver: u8 = v
294 .parse()
295 .map_err(|_| err(line_no, 1, "invalid qr version"))?;
296 if !(1..=40).contains(&ver) {
297 return Err(err(line_no, 1, "qr version must be 1-40"));
298 }
299 version = Some(ver);
300 }
251 301 "ecc" => {
252 ecc = match v.to_ascii_uppercase().as_str() {
253 "L" => QrEcc::L,
254 "M" => QrEcc::M,
255 "Q" => QrEcc::Q,
256 "H" => QrEcc::H,
257 _ => return Err(err(line_no, 1, "qr ecc must be L, M, Q, or H")),
258 };
302 ecc = QrEcc::from_name(v)
303 .ok_or_else(|| err(line_no, 1, "qr ecc must be L, M, Q, or H"))?;
259 304 }
260 305 "align" => align = parse_align_value(v, line_no)?,
261 306 _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))),
@@ -263,9 +308,11 @@ fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseEr
263 308 }
264 309 }
265 310 Ok(Block::Qr {
311 mode,
266 312 data,
267 313 size,
268 314 ecc,
315 version,
269 316 align,
270 317 })
271 318 }
@@ -388,7 +435,7 @@ fn err(line: usize, column: usize, message: impl Into<String>) -> ParseError {
388 435 #[cfg(test)]
389 436 mod tests {
390 437 use super::*;
391 use crate::dsl::Inline;
438 use crate::dsl::{BarcodeMode, BarcodeSymbology, Inline};
392 439
393 440 #[test]
394 441 fn parses_heading_and_paragraph() {
@@ -438,4 +485,17 @@ mod tests {
438 485 };
439 486 assert_eq!(*align, Align::Center);
440 487 }
488
489 #[test]
490 fn parses_raster_barcode() {
491 let doc = parse("@barcode RASTER CODE128 ABC").unwrap();
492 assert!(matches!(
493 doc.blocks[0],
494 Block::Barcode {
495 mode: BarcodeMode::Raster,
496 symbology: BarcodeSymbology::Code128,
497 ..
498 }
499 ));
500 }
441 501 }
@@ -1,5 +1,6 @@
1use super::{
1use super::{
2 Align, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc,
2 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, ParseError, QrEcc,
3 QrMode,
3};
4};
4
5
5pub fn parse(source: &str) -> Result<Document, ParseError> {
6pub fn parse(source: &str) -> Result<Document, ParseError> {
@@ -192,21 +193,44 @@ fn parse_barcode_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, Pa
192 return Err(err(
193 return Err(err(
193 line_no,
194 line_no,
194 1,
195 1,
195 "@barcode requires symbology and data",
196 "@barcode requires symbology and data (or RASTER symbology data)",
196 ));
197 ));
197 }
198 }
198 let symbology = match parts[0].to_ascii_uppercase().as_str() {
199
199 "CODE128" => BarcodeSymbology::Code128,
200 let (mode, sym_idx, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
200 "EAN13" => BarcodeSymbology::Ean13,
201 if parts.len() < 3 {
201 "EAN8" => BarcodeSymbology::Ean8,
202 return Err(err(
202 "CODE39" => BarcodeSymbology::Code39,
203 line_no,
203 other => return Err(err(line_no, 1, format!("unknown barcode symbology {other}"))),
204 1,
205 "@barcode RASTER requires symbology and data",
206 ));
207 }
208 (BarcodeMode::Raster, 1, 2)
209 } else {
210 (BarcodeMode::Native, 0, 1)
204 };
211 };
205 let data = parts[1].to_string();
212
213 let symbology = BarcodeSymbology::from_name(parts[sym_idx])
214 .ok_or_else(|| err(line_no, 1, format!("unknown barcode symbology {}", parts[sym_idx])))?;
215
216 if mode == BarcodeMode::Native && !symbology.supports_native() {
217 return Err(err(
218 line_no,
219 1,
220 format!(
221 "{} has no native ESC/POS support; use RASTER {}",
222 symbology.as_str(),
223 symbology.as_str()
224 ),
225 ));
226 }
227
228 let data = parts[data_idx].to_string();
229 let attr_start = data_idx + 1;
206 let mut height = 64u8;
230 let mut height = 64u8;
207 let mut align = Align::Left;
231 let mut align = Align::Left;
208 let mut show_text = true;
232 let mut show_text = true;
209 for attr in &parts[2..] {
233 for attr in &parts[attr_start..] {
210 if let Some((k, v)) = attr.split_once('=') {
234 if let Some((k, v)) = attr.split_once('=') {
211 match k.to_ascii_lowercase().as_str() {
235 match k.to_ascii_lowercase().as_str() {
212 "height" => {
236 "height" => {
@@ -215,14 +239,13 @@ fn parse_barcode_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, Pa
215 .map_err(|_| err(line_no, 1, "invalid barcode height"))?;
239 .map_err(|_| err(line_no, 1, "invalid barcode height"))?;
216 }
240 }
217 "align" => align = parse_align_value(v, line_no)?,
241 "align" => align = parse_align_value(v, line_no)?,
218 "show_text" => {
242 "show_text" => show_text = v == "true",
219 show_text = v == "true";
220 }
221 _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))),
243 _ => return Err(err(line_no, 1, format!("unknown barcode attribute {k}"))),
222 }
244 }
223 }
245 }
224 }
246 }
225 Ok(Block::Barcode {
247 Ok(Block::Barcode {
248 mode,
226 symbology,
249 symbology,
227 data,
250 data,
228 height,
251 height,
@@ -235,11 +258,23 @@ fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseEr
235 if parts.is_empty() {
258 if parts.is_empty() {
236 return Err(err(line_no, 1, "@qr requires data"));
259 return Err(err(line_no, 1, "@qr requires data"));
237 }
260 }
238 let data = parts[0].to_string();
261
262 let (mode, data_idx) = if parts[0].eq_ignore_ascii_case("RASTER") {
263 if parts.len() < 2 {
264 return Err(err(line_no, 1, "@qr RASTER requires data"));
265 }
266 (QrMode::Raster, 1)
267 } else {
268 (QrMode::Native, 0)
269 };
270
271 let data = parts[data_idx].to_string();
272 let attr_start = data_idx + 1;
239 let mut size = 4u8;
273 let mut size = 4u8;
240 let mut ecc = QrEcc::M;
274 let mut ecc = QrEcc::M;
241 let mut align = Align::Left;
275 let mut align = Align::Left;
242 for attr in &parts[1..] {
276 let mut version = None;
277 for attr in &parts[attr_start..] {
243 if let Some((k, v)) = attr.split_once('=') {
278 if let Some((k, v)) = attr.split_once('=') {
244 match k.to_ascii_lowercase().as_str() {
279 match k.to_ascii_lowercase().as_str() {
245 "size" => {
280 "size" => {
@@ -248,14 +283,24 @@ fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseEr
248 .map_err(|_| err(line_no, 1, "invalid qr size"))?
283 .map_err(|_| err(line_no, 1, "invalid qr size"))?
249 .clamp(1, 16);
284 .clamp(1, 16);
250 }
285 }
286 "scale" => {
287 size = v
288 .parse::<u8>()
289 .map_err(|_| err(line_no, 1, "invalid qr scale"))?
290 .clamp(1, 16);
291 }
292 "version" => {
293 let ver: u8 = v
294 .parse()
295 .map_err(|_| err(line_no, 1, "invalid qr version"))?;
296 if !(1..=40).contains(&ver) {
297 return Err(err(line_no, 1, "qr version must be 1-40"));
298 }
299 version = Some(ver);
300 }
251 "ecc" => {
301 "ecc" => {
252 ecc = match v.to_ascii_uppercase().as_str() {
302 ecc = QrEcc::from_name(v)
253 "L" => QrEcc::L,
303 .ok_or_else(|| err(line_no, 1, "qr ecc must be L, M, Q, or H"))?;
254 "M" => QrEcc::M,
255 "Q" => QrEcc::Q,
256 "H" => QrEcc::H,
257 _ => return Err(err(line_no, 1, "qr ecc must be L, M, Q, or H")),
258 };
259 }
304 }
260 "align" => align = parse_align_value(v, line_no)?,
305 "align" => align = parse_align_value(v, line_no)?,
261 _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))),
306 _ => return Err(err(line_no, 1, format!("unknown qr attribute {k}"))),
@@ -263,9 +308,11 @@ fn parse_qr_directive(parts: Vec<&str>, line_no: usize) -> Result<Block, ParseEr
263 }
308 }
264 }
309 }
265 Ok(Block::Qr {
310 Ok(Block::Qr {
311 mode,
266 data,
312 data,
267 size,
313 size,
268 ecc,
314 ecc,
315 version,
269 align,
316 align,
270 })
317 })
271}
318}
@@ -388,7 +435,7 @@ fn err(line: usize, column: usize, message: impl Into<String>) -> ParseError {
388#[cfg(test)]
435#[cfg(test)]
389mod tests {
436mod tests {
390 use super::*;
437 use super::*;
391 use crate::dsl::Inline;
438 use crate::dsl::{BarcodeMode, BarcodeSymbology, Inline};
392
439
393 #[test]
440 #[test]
394 fn parses_heading_and_paragraph() {
441 fn parses_heading_and_paragraph() {
@@ -438,4 +485,17 @@ mod tests {
438 };
485 };
439 assert_eq!(*align, Align::Center);
486 assert_eq!(*align, Align::Center);
440 }
487 }
488
489 #[test]
490 fn parses_raster_barcode() {
491 let doc = parse("@barcode RASTER CODE128 ABC").unwrap();
492 assert!(matches!(
493 doc.blocks[0],
494 Block::Barcode {
495 mode: BarcodeMode::Raster,
496 symbology: BarcodeSymbology::Code128,
497 ..
498 }
499 ));
500 }
441}
501}
src/editor_assist.rs added +113 −0
@@ -0,0 +1,113 @@
1 //! Editor snippets, directive autocomplete, and insert helpers.
2
3 pub const DIRECTIVES: &[&str] = &["feed", "cut", "image", "barcode", "qr"];
4
5 pub fn directive_completions(prefix: &str) -> Vec<&'static str> {
6 let p = prefix.to_ascii_lowercase();
7 DIRECTIVES
8 .iter()
9 .copied()
10 .filter(|d| d.starts_with(&p))
11 .collect()
12 }
13
14 pub struct InsertOption {
15 pub label: String,
16 pub snippet: String,
17 }
18
19 pub fn image_insert_options() -> Vec<InsertOption> {
20 vec![InsertOption {
21 label: "Image from file".into(),
22 snippet: "@image logo.png\n".into(),
23 }]
24 }
25
26 pub fn barcode_insert_options() -> Vec<InsertOption> {
27 let mut out = Vec::new();
28 for &sym in crate::dsl::BarcodeSymbology::ALL {
29 if sym.supports_native() {
30 out.push(InsertOption {
31 label: format!("Native {}", sym.as_str()),
32 snippet: format!("@barcode {} ${{Data}}\n", sym.as_str()),
33 });
34 }
35 }
36 for &sym in crate::dsl::BarcodeSymbology::ALL {
37 out.push(InsertOption {
38 label: format!("Raster {}", sym.as_str()),
39 snippet: format!("@barcode RASTER {} ${{Data}}\n", sym.as_str()),
40 });
41 }
42 out
43 }
44
45 pub fn qr_insert_options() -> Vec<InsertOption> {
46 vec![
47 InsertOption {
48 label: "Native QR (ESC/POS)".into(),
49 snippet: "@qr ${Data}\n".into(),
50 },
51 InsertOption {
52 label: "Raster QR (auto version)".into(),
53 snippet: "@qr RASTER ${Data} scale=4 ecc=M\n".into(),
54 },
55 InsertOption {
56 label: "Raster QR (version 5)".into(),
57 snippet: "@qr RASTER ${Data} version=5 scale=4 ecc=M\n".into(),
58 },
59 ]
60 }
61
62 /// If the cursor is after `@` on the current line, return (start_index, typed_prefix).
63 pub fn at_directive_prefix(body: &str, cursor: usize) -> Option<(usize, String)> {
64 let cursor = cursor.min(body.len());
65 let before = &body[..cursor];
66 let line_start = before.rfind('\n').map(|i| i + 1).unwrap_or(0);
67 let line = &before[line_start..];
68 let at = line.find('@')?;
69 if at > 0 && !line[..at].trim().is_empty() {
70 return None;
71 }
72 let fragment = &line[at + 1..];
73 if fragment.contains(' ') {
74 return None;
75 }
76 Some((line_start + at, fragment.to_string()))
77 }
78
79 pub fn insert_at_cursor(body: &str, cursor: usize, text: &str) -> (String, usize) {
80 let cursor = cursor.min(body.len());
81 let mut out = String::with_capacity(body.len() + text.len());
82 out.push_str(&body[..cursor]);
83 out.push_str(text);
84 out.push_str(&body[cursor..]);
85 let new_cursor = cursor + text.len();
86 (out, new_cursor)
87 }
88
89 #[cfg(test)]
90 mod tests {
91 use super::*;
92
93 #[test]
94 fn completes_directives() {
95 let hits = directive_completions("ba");
96 assert!(hits.contains(&"barcode"));
97 }
98
99 #[test]
100 fn detects_at_prefix() {
101 let body = "hello\n@bar";
102 let (start, frag) = at_directive_prefix(body, body.len()).unwrap();
103 assert_eq!(start, 6);
104 assert_eq!(frag, "bar");
105 }
106
107 #[test]
108 fn inserts_snippet() {
109 let (text, cur) = insert_at_cursor("ab", 1, "X");
110 assert_eq!(text, "aXb");
111 assert_eq!(cur, 2);
112 }
113 }
@@ -0,0 +1,113 @@
1//! Editor snippets, directive autocomplete, and insert helpers.
2
3pub const DIRECTIVES: &[&str] = &["feed", "cut", "image", "barcode", "qr"];
4
5pub fn directive_completions(prefix: &str) -> Vec<&'static str> {
6 let p = prefix.to_ascii_lowercase();
7 DIRECTIVES
8 .iter()
9 .copied()
10 .filter(|d| d.starts_with(&p))
11 .collect()
12}
13
14pub struct InsertOption {
15 pub label: String,
16 pub snippet: String,
17}
18
19pub fn image_insert_options() -> Vec<InsertOption> {
20 vec![InsertOption {
21 label: "Image from file".into(),
22 snippet: "@image logo.png\n".into(),
23 }]
24}
25
26pub fn barcode_insert_options() -> Vec<InsertOption> {
27 let mut out = Vec::new();
28 for &sym in crate::dsl::BarcodeSymbology::ALL {
29 if sym.supports_native() {
30 out.push(InsertOption {
31 label: format!("Native {}", sym.as_str()),
32 snippet: format!("@barcode {} ${{Data}}\n", sym.as_str()),
33 });
34 }
35 }
36 for &sym in crate::dsl::BarcodeSymbology::ALL {
37 out.push(InsertOption {
38 label: format!("Raster {}", sym.as_str()),
39 snippet: format!("@barcode RASTER {} ${{Data}}\n", sym.as_str()),
40 });
41 }
42 out
43}
44
45pub fn qr_insert_options() -> Vec<InsertOption> {
46 vec![
47 InsertOption {
48 label: "Native QR (ESC/POS)".into(),
49 snippet: "@qr ${Data}\n".into(),
50 },
51 InsertOption {
52 label: "Raster QR (auto version)".into(),
53 snippet: "@qr RASTER ${Data} scale=4 ecc=M\n".into(),
54 },
55 InsertOption {
56 label: "Raster QR (version 5)".into(),
57 snippet: "@qr RASTER ${Data} version=5 scale=4 ecc=M\n".into(),
58 },
59 ]
60}
61
62/// If the cursor is after `@` on the current line, return (start_index, typed_prefix).
63pub fn at_directive_prefix(body: &str, cursor: usize) -> Option<(usize, String)> {
64 let cursor = cursor.min(body.len());
65 let before = &body[..cursor];
66 let line_start = before.rfind('\n').map(|i| i + 1).unwrap_or(0);
67 let line = &before[line_start..];
68 let at = line.find('@')?;
69 if at > 0 && !line[..at].trim().is_empty() {
70 return None;
71 }
72 let fragment = &line[at + 1..];
73 if fragment.contains(' ') {
74 return None;
75 }
76 Some((line_start + at, fragment.to_string()))
77}
78
79pub fn insert_at_cursor(body: &str, cursor: usize, text: &str) -> (String, usize) {
80 let cursor = cursor.min(body.len());
81 let mut out = String::with_capacity(body.len() + text.len());
82 out.push_str(&body[..cursor]);
83 out.push_str(text);
84 out.push_str(&body[cursor..]);
85 let new_cursor = cursor + text.len();
86 (out, new_cursor)
87}
88
89#[cfg(test)]
90mod tests {
91 use super::*;
92
93 #[test]
94 fn completes_directives() {
95 let hits = directive_completions("ba");
96 assert!(hits.contains(&"barcode"));
97 }
98
99 #[test]
100 fn detects_at_prefix() {
101 let body = "hello\n@bar";
102 let (start, frag) = at_directive_prefix(body, body.len()).unwrap();
103 assert_eq!(start, 6);
104 assert_eq!(frag, "bar");
105 }
106
107 #[test]
108 fn inserts_snippet() {
109 let (text, cur) = insert_at_cursor("ab", 1, "X");
110 assert_eq!(text, "aXb");
111 assert_eq!(cur, 2);
112 }
113}
src/escpos.rs +75 −16
@@ -1,14 +1,18 @@
1 1 use std::path::Path;
2 2
3 use image::GrayImage;
4
3 5 use crate::dsl::{
4 Align, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc,
6 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode,
5 7 };
6 8 use crate::io::PosMetadata;
9 use crate::raster::{self, RasterError};
7 10
8 11 #[derive(Debug)]
9 12 pub enum EscPosError {
10 13 Image(String),
11 14 Barcode(String),
15 Raster(RasterError),
12 16 Io(String),
13 17 }
14 18
@@ -51,7 +55,6 @@ impl EscPosEncoder {
51 55
52 56 fn init(&mut self) {
53 57 self.buffer.extend_from_slice(&[0x1B, b'@']);
54 // ESC t 0 = CP437
55 58 self.buffer.extend_from_slice(&[0x1B, b't', 0]);
56 59 }
57 60
@@ -89,6 +92,7 @@ impl EscPosEncoder {
89 92 self.encode_image(path, *width)?;
90 93 }
91 94 Block::Barcode {
95 mode,
92 96 symbology,
93 97 data,
94 98 height,
@@ -96,16 +100,34 @@ impl EscPosEncoder {
96 100 show_text,
97 101 } => {
98 102 self.set_align(*align);
99 self.encode_barcode(*symbology, data, *height, *show_text)?;
103 match mode {
104 BarcodeMode::Native => {
105 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
106 }
107 BarcodeMode::Raster => {
108 let img = raster::render_barcode(*symbology, data, *height as u32)
109 .map_err(EscPosError::Raster)?;
110 self.encode_gray_raster(&img, ImageWidth::Default)?;
111 }
112 }
100 113 }
101 114 Block::Qr {
115 mode,
102 116 data,
103 117 size,
104 118 ecc,
119 version,
105 120 align,
106 121 } => {
107 122 self.set_align(*align);
108 self.encode_qr(data, *size, *ecc)?;
123 match mode {
124 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
125 QrMode::Raster => {
126 let img = raster::render_qr(data, *version, *ecc, *size as u32)
127 .map_err(EscPosError::Raster)?;
128 self.encode_gray_raster(&img, ImageWidth::Default)?;
129 }
130 }
109 131 }
110 132 }
111 133 Ok(())
@@ -133,7 +155,7 @@ impl EscPosEncoder {
133 155 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
134 156 }
135 157
136 fn encode_barcode(
158 fn encode_barcode_native(
137 159 &mut self,
138 160 symbology: BarcodeSymbology,
139 161 data: &str,
@@ -148,6 +170,20 @@ impl EscPosEncoder {
148 170 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
149 171 self.buffer.extend_from_slice(bytes);
150 172 }
173 BarcodeSymbology::UpcA => {
174 if data.len() != 11 && data.len() != 12 {
175 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
176 }
177 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
178 self.buffer.extend_from_slice(data.as_bytes());
179 }
180 BarcodeSymbology::UpcE => {
181 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
182 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
183 }
184 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
185 self.buffer.extend_from_slice(data.as_bytes());
186 }
151 187 BarcodeSymbology::Ean13 => {
152 188 if data.len() != 12 && data.len() != 13 {
153 189 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
@@ -166,12 +202,29 @@ impl EscPosEncoder {
166 202 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
167 203 self.buffer.extend_from_slice(data.as_bytes());
168 204 }
205 BarcodeSymbology::Itf => {
206 if data.len() % 2 != 0 {
207 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
208 }
209 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
210 self.buffer.extend_from_slice(data.as_bytes());
211 }
212 BarcodeSymbology::Codabar => {
213 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
214 self.buffer.extend_from_slice(data.as_bytes());
215 }
216 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
217 return Err(EscPosError::Barcode(format!(
218 "{} requires RASTER mode",
219 symbology.as_str()
220 )));
221 }
169 222 }
170 223 self.buffer.push(b'\n');
171 224 Ok(())
172 225 }
173 226
174 fn encode_qr(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
227 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
175 228 let ecc_level = match ecc {
176 229 QrEcc::L => 48,
177 230 QrEcc::M => 49,
@@ -183,16 +236,11 @@ impl EscPosEncoder {
183 236 let p_l = (len & 0xFF) as u8;
184 237 let p_h = ((len >> 8) & 0xFF) as u8;
185 238
186 // Model 2
187 239 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
188 // Module size
189 240 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
190 // Error correction
191 241 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
192 // Store data
193 242 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
194 243 self.buffer.extend_from_slice(store);
195 // Print
196 244 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
197 245 self.buffer.push(b'\n');
198 246 Ok(())
@@ -201,6 +249,11 @@ impl EscPosEncoder {
201 249 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
202 250 let resolved = resolve_image_path(path, self.base_dir.as_deref());
203 251 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
252 self.encode_gray_raster(&img.to_luma8(), width)
253 }
254
255 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
256 let (w, h) = gray.dimensions();
204 257 let target_width = match width {
205 258 ImageWidth::Percent(pct) => {
206 259 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
@@ -208,12 +261,10 @@ impl EscPosEncoder {
208 261 ImageWidth::Dots(d) => d as u32,
209 262 ImageWidth::Default => self.metadata.printable_dots() as u32,
210 263 };
211 let gray = img.to_luma8();
212 let (w, h) = gray.dimensions();
213 let new_w = target_width.min(w);
214 let new_h = (h as f32 * (new_w as f32 / w as f32)) as u32;
264 let new_w = target_width.min(w).max(1);
265 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
215 266 let resized = image::imageops::resize(
216 &gray,
267 gray,
217 268 new_w,
218 269 new_h,
219 270 image::imageops::FilterType::Nearest,
@@ -278,6 +329,14 @@ mod tests {
278 329 assert!(bytes.windows(5).any(|w| w == b"Hello"));
279 330 }
280 331
332 #[test]
333 fn encodes_raster_barcode() {
334 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
335 let mut enc = EscPosEncoder::new(PosMetadata::default());
336 let bytes = enc.encode_document(&doc).unwrap();
337 assert!(bytes.windows(4).any(|w| w == [0x1D, b'v', 0, 0]));
338 }
339
281 340 #[test]
282 341 fn encodes_cut_directive() {
283 342 let doc = parse("@cut").unwrap();
@@ -1,14 +1,18 @@
1use std::path::Path;
1use std::path::Path;
2
2
3use image::GrayImage;
4
3use crate::dsl::{
5use crate::dsl::{
4 Align, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc,
6 Align, BarcodeMode, BarcodeSymbology, Block, Document, ImageWidth, Inline, QrEcc, QrMode,
5};
7};
6use crate::io::PosMetadata;
8use crate::io::PosMetadata;
9use crate::raster::{self, RasterError};
7
10
8#[derive(Debug)]
11#[derive(Debug)]
9pub enum EscPosError {
12pub enum EscPosError {
10 Image(String),
13 Image(String),
11 Barcode(String),
14 Barcode(String),
15 Raster(RasterError),
12 Io(String),
16 Io(String),
13}
17}
14
18
@@ -51,7 +55,6 @@ impl EscPosEncoder {
51
55
52 fn init(&mut self) {
56 fn init(&mut self) {
53 self.buffer.extend_from_slice(&[0x1B, b'@']);
57 self.buffer.extend_from_slice(&[0x1B, b'@']);
54 // ESC t 0 = CP437
55 self.buffer.extend_from_slice(&[0x1B, b't', 0]);
58 self.buffer.extend_from_slice(&[0x1B, b't', 0]);
56 }
59 }
57
60
@@ -89,6 +92,7 @@ impl EscPosEncoder {
89 self.encode_image(path, *width)?;
92 self.encode_image(path, *width)?;
90 }
93 }
91 Block::Barcode {
94 Block::Barcode {
95 mode,
92 symbology,
96 symbology,
93 data,
97 data,
94 height,
98 height,
@@ -96,16 +100,34 @@ impl EscPosEncoder {
96 show_text,
100 show_text,
97 } => {
101 } => {
98 self.set_align(*align);
102 self.set_align(*align);
99 self.encode_barcode(*symbology, data, *height, *show_text)?;
103 match mode {
104 BarcodeMode::Native => {
105 self.encode_barcode_native(*symbology, data, *height, *show_text)?;
106 }
107 BarcodeMode::Raster => {
108 let img = raster::render_barcode(*symbology, data, *height as u32)
109 .map_err(EscPosError::Raster)?;
110 self.encode_gray_raster(&img, ImageWidth::Default)?;
111 }
112 }
100 }
113 }
101 Block::Qr {
114 Block::Qr {
115 mode,
102 data,
116 data,
103 size,
117 size,
104 ecc,
118 ecc,
119 version,
105 align,
120 align,
106 } => {
121 } => {
107 self.set_align(*align);
122 self.set_align(*align);
108 self.encode_qr(data, *size, *ecc)?;
123 match mode {
124 QrMode::Native => self.encode_qr_native(data, *size, *ecc)?,
125 QrMode::Raster => {
126 let img = raster::render_qr(data, *version, *ecc, *size as u32)
127 .map_err(EscPosError::Raster)?;
128 self.encode_gray_raster(&img, ImageWidth::Default)?;
129 }
130 }
109 }
131 }
110 }
132 }
111 Ok(())
133 Ok(())
@@ -133,7 +155,7 @@ impl EscPosEncoder {
133 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
155 self.buffer.extend_from_slice(&[0x1D, b'V', 66, 0]);
134 }
156 }
135
157
136 fn encode_barcode(
158 fn encode_barcode_native(
137 &mut self,
159 &mut self,
138 symbology: BarcodeSymbology,
160 symbology: BarcodeSymbology,
139 data: &str,
161 data: &str,
@@ -148,6 +170,20 @@ impl EscPosEncoder {
148 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
170 self.buffer.extend_from_slice(&[0x1D, b'k', 73, bytes.len() as u8]);
149 self.buffer.extend_from_slice(bytes);
171 self.buffer.extend_from_slice(bytes);
150 }
172 }
173 BarcodeSymbology::UpcA => {
174 if data.len() != 11 && data.len() != 12 {
175 return Err(EscPosError::Barcode("UPC-A requires 11-12 digits".into()));
176 }
177 self.buffer.extend_from_slice(&[0x1D, b'k', 65, data.len() as u8]);
178 self.buffer.extend_from_slice(data.as_bytes());
179 }
180 BarcodeSymbology::UpcE => {
181 if data.len() != 6 && data.len() != 7 && data.len() != 8 {
182 return Err(EscPosError::Barcode("UPC-E requires 6-8 digits".into()));
183 }
184 self.buffer.extend_from_slice(&[0x1D, b'k', 66, data.len() as u8]);
185 self.buffer.extend_from_slice(data.as_bytes());
186 }
151 BarcodeSymbology::Ean13 => {
187 BarcodeSymbology::Ean13 => {
152 if data.len() != 12 && data.len() != 13 {
188 if data.len() != 12 && data.len() != 13 {
153 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
189 return Err(EscPosError::Barcode("EAN13 requires 12-13 digits".into()));
@@ -166,12 +202,29 @@ impl EscPosEncoder {
166 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
202 self.buffer.extend_from_slice(&[0x1D, b'k', 69, data.len() as u8]);
167 self.buffer.extend_from_slice(data.as_bytes());
203 self.buffer.extend_from_slice(data.as_bytes());
168 }
204 }
205 BarcodeSymbology::Itf => {
206 if data.len() % 2 != 0 {
207 return Err(EscPosError::Barcode("ITF requires even digit count".into()));
208 }
209 self.buffer.extend_from_slice(&[0x1D, b'k', 70, data.len() as u8]);
210 self.buffer.extend_from_slice(data.as_bytes());
211 }
212 BarcodeSymbology::Codabar => {
213 self.buffer.extend_from_slice(&[0x1D, b'k', 71, data.len() as u8]);
214 self.buffer.extend_from_slice(data.as_bytes());
215 }
216 BarcodeSymbology::Code93 | BarcodeSymbology::Code11 => {
217 return Err(EscPosError::Barcode(format!(
218 "{} requires RASTER mode",
219 symbology.as_str()
220 )));
221 }
169 }
222 }
170 self.buffer.push(b'\n');
223 self.buffer.push(b'\n');
171 Ok(())
224 Ok(())
172 }
225 }
173
226
174 fn encode_qr(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
227 fn encode_qr_native(&mut self, data: &str, size: u8, ecc: QrEcc) -> Result<(), EscPosError> {
175 let ecc_level = match ecc {
228 let ecc_level = match ecc {
176 QrEcc::L => 48,
229 QrEcc::L => 48,
177 QrEcc::M => 49,
230 QrEcc::M => 49,
@@ -183,16 +236,11 @@ impl EscPosEncoder {
183 let p_l = (len & 0xFF) as u8;
236 let p_l = (len & 0xFF) as u8;
184 let p_h = ((len >> 8) & 0xFF) as u8;
237 let p_h = ((len >> 8) & 0xFF) as u8;
185
238
186 // Model 2
187 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
239 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 4, 0, 49, 65, 50, 0]);
188 // Module size
189 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
240 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 67, size]);
190 // Error correction
191 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
241 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 69, ecc_level]);
192 // Store data
193 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
242 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', p_l, p_h, 49, 80, 48]);
194 self.buffer.extend_from_slice(store);
243 self.buffer.extend_from_slice(store);
195 // Print
196 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
244 self.buffer.extend_from_slice(&[0x1D, 0x28, b'k', 3, 0, 49, 81, 48]);
197 self.buffer.push(b'\n');
245 self.buffer.push(b'\n');
198 Ok(())
246 Ok(())
@@ -201,6 +249,11 @@ impl EscPosEncoder {
201 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
249 fn encode_image(&mut self, path: &str, width: ImageWidth) -> Result<(), EscPosError> {
202 let resolved = resolve_image_path(path, self.base_dir.as_deref());
250 let resolved = resolve_image_path(path, self.base_dir.as_deref());
203 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
251 let img = image::open(&resolved).map_err(|e| EscPosError::Image(e.to_string()))?;
252 self.encode_gray_raster(&img.to_luma8(), width)
253 }
254
255 fn encode_gray_raster(&mut self, gray: &GrayImage, width: ImageWidth) -> Result<(), EscPosError> {
256 let (w, h) = gray.dimensions();
204 let target_width = match width {
257 let target_width = match width {
205 ImageWidth::Percent(pct) => {
258 ImageWidth::Percent(pct) => {
206 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
259 (self.metadata.printable_dots() as u32 * pct as u32 / 100) as u32
@@ -208,12 +261,10 @@ impl EscPosEncoder {
208 ImageWidth::Dots(d) => d as u32,
261 ImageWidth::Dots(d) => d as u32,
209 ImageWidth::Default => self.metadata.printable_dots() as u32,
262 ImageWidth::Default => self.metadata.printable_dots() as u32,
210 };
263 };
211 let gray = img.to_luma8();
264 let new_w = target_width.min(w).max(1);
212 let (w, h) = gray.dimensions();
265 let new_h = ((h as f32) * (new_w as f32 / w as f32)).max(1.0) as u32;
213 let new_w = target_width.min(w);
214 let new_h = (h as f32 * (new_w as f32 / w as f32)) as u32;
215 let resized = image::imageops::resize(
266 let resized = image::imageops::resize(
216 &gray,
267 gray,
217 new_w,
268 new_w,
218 new_h,
269 new_h,
219 image::imageops::FilterType::Nearest,
270 image::imageops::FilterType::Nearest,
@@ -278,6 +329,14 @@ mod tests {
278 assert!(bytes.windows(5).any(|w| w == b"Hello"));
329 assert!(bytes.windows(5).any(|w| w == b"Hello"));
279 }
330 }
280
331
332 #[test]
333 fn encodes_raster_barcode() {
334 let doc = parse("@barcode RASTER CODE128 TEST").unwrap();
335 let mut enc = EscPosEncoder::new(PosMetadata::default());
336 let bytes = enc.encode_document(&doc).unwrap();
337 assert!(bytes.windows(4).any(|w| w == [0x1D, b'v', 0, 0]));
338 }
339
281 #[test]
340 #[test]
282 fn encodes_cut_directive() {
341 fn encodes_cut_directive() {
283 let doc = parse("@cut").unwrap();
342 let doc = parse("@cut").unwrap();
src/lib.rs +17 −1
@@ -1,8 +1,24 @@
1 pub mod cli;
1 2 pub mod dsl;
3 pub mod editor_assist;
2 4 pub mod escpos;
3 5 pub mod io;
4 6 pub mod params;
7 pub mod pipeline;
5 8 pub mod preview;
6 9 pub mod print;
10 pub mod raster;
7 11
8 pub const HELP_MARKDOWN: &str = include_str!("../docs/HELP.md");
12 #[cfg(windows)]
13 pub const HELP_MARKDOWN: &str = concat!(
14 include_str!("../docs/HELP.md"),
15 "\n\n",
16 include_str!("../docs/HELP-CLI-WINDOWS.md")
17 );
18
19 #[cfg(not(windows))]
20 pub const HELP_MARKDOWN: &str = concat!(
21 include_str!("../docs/HELP.md"),
22 "\n\n",
23 include_str!("../docs/HELP-CLI-LINUX.md")
24 );
@@ -1,8 +1,24 @@
1pub mod cli;
1pub mod dsl;
2pub mod dsl;
3pub mod editor_assist;
2pub mod escpos;
4pub mod escpos;
3pub mod io;
5pub mod io;
4pub mod params;
6pub mod params;
7pub mod pipeline;
5pub mod preview;
8pub mod preview;
6pub mod print;
9pub mod print;
10pub mod raster;
7
11
8pub const HELP_MARKDOWN: &str = include_str!("../docs/HELP.md");
12#[cfg(windows)]
13pub const HELP_MARKDOWN: &str = concat!(
14 include_str!("../docs/HELP.md"),
15 "\n\n",
16 include_str!("../docs/HELP-CLI-WINDOWS.md")
17);
18
19#[cfg(not(windows))]
20pub const HELP_MARKDOWN: &str = concat!(
21 include_str!("../docs/HELP.md"),
22 "\n\n",
23 include_str!("../docs/HELP-CLI-LINUX.md")
24);
src/params.rs +6 −0
@@ -79,12 +79,14 @@ pub fn substitute_document(
79 79 align: *align,
80 80 },
81 81 Block::Barcode {
82 mode,
82 83 symbology,
83 84 data,
84 85 height,
85 86 align,
86 87 show_text,
87 88 } => Block::Barcode {
89 mode: *mode,
88 90 symbology: *symbology,
89 91 data: substitute_string(data, values),
90 92 height: *height,
@@ -92,14 +94,18 @@ pub fn substitute_document(
92 94 show_text: *show_text,
93 95 },
94 96 Block::Qr {
97 mode,
95 98 data,
96 99 size,
97 100 ecc,
101 version,
98 102 align,
99 103 } => Block::Qr {
104 mode: *mode,
100 105 data: substitute_string(data, values),
101 106 size: *size,
102 107 ecc: *ecc,
108 version: *version,
103 109 align: *align,
104 110 },
105 111 })
@@ -79,12 +79,14 @@ pub fn substitute_document(
79 align: *align,
79 align: *align,
80 },
80 },
81 Block::Barcode {
81 Block::Barcode {
82 mode,
82 symbology,
83 symbology,
83 data,
84 data,
84 height,
85 height,
85 align,
86 align,
86 show_text,
87 show_text,
87 } => Block::Barcode {
88 } => Block::Barcode {
89 mode: *mode,
88 symbology: *symbology,
90 symbology: *symbology,
89 data: substitute_string(data, values),
91 data: substitute_string(data, values),
90 height: *height,
92 height: *height,
@@ -92,14 +94,18 @@ pub fn substitute_document(
92 show_text: *show_text,
94 show_text: *show_text,
93 },
95 },
94 Block::Qr {
96 Block::Qr {
97 mode,
95 data,
98 data,
96 size,
99 size,
97 ecc,
100 ecc,
101 version,
98 align,
102 align,
99 } => Block::Qr {
103 } => Block::Qr {
104 mode: *mode,
100 data: substitute_string(data, values),
105 data: substitute_string(data, values),
101 size: *size,
106 size: *size,
102 ecc: *ecc,
107 ecc: *ecc,
108 version: *version,
103 align: *align,
109 align: *align,
104 },
110 },
105 })
111 })
src/pipeline.rs added +101 −0
@@ -0,0 +1,101 @@
1 use std::collections::HashMap;
2 use std::path::Path;
3
4 use crate::dsl::{parse, Document};
5 use crate::escpos::{EscPosEncoder, EscPosError};
6 use crate::io::{LoadError, PosFile};
7 use crate::params::{collect_parameter_names, substitute_document};
8 use crate::print::{print_bytes, PrintError, SerialTransport};
9
10 #[derive(Debug)]
11 pub enum PipelineError {
12 Load(LoadError),
13 Parse(crate::dsl::ParseError),
14 MissingParams(Vec<String>),
15 Encode(EscPosError),
16 Print(PrintError),
17 }
18
19 impl std::fmt::Display for PipelineError {
20 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21 match self {
22 Self::Load(e) => write!(f, "{e:?}"),
23 Self::Parse(e) => write!(f, "{e}"),
24 Self::MissingParams(names) => {
25 write!(f, "missing parameters: {}", names.join(", "))
26 }
27 Self::Encode(e) => write!(f, "{e:?}"),
28 Self::Print(e) => write!(f, "{e:?}"),
29 }
30 }
31 }
32
33 impl std::error::Error for PipelineError {}
34
35 pub fn missing_parameters(document: &Document, params: &HashMap<String, String>) -> Vec<String> {
36 collect_parameter_names(document)
37 .into_iter()
38 .filter(|name| {
39 params
40 .get(name)
41 .map(|v| v.is_empty())
42 .unwrap_or(true)
43 })
44 .collect()
45 }
46
47 pub fn encode_pos_file(
48 file: &PosFile,
49 base_dir: Option<&Path>,
50 params: &HashMap<String, String>,
51 ) -> Result<Vec<u8>, PipelineError> {
52 let doc = parse(&file.body).map_err(PipelineError::Parse)?;
53 let missing = missing_parameters(&doc, params);
54 if !missing.is_empty() {
55 return Err(PipelineError::MissingParams(missing));
56 }
57 let sub = substitute_document(&doc, params);
58 let mut encoder = EscPosEncoder::new(file.metadata.clone());
59 if let Some(dir) = base_dir {
60 encoder = encoder.with_base_dir(dir);
61 }
62 let bytes = encoder
63 .encode_document(&sub)
64 .map_err(PipelineError::Encode)?;
65 Ok(bytes.to_vec())
66 }
67
68 pub fn print_pos_file(
69 path: &Path,
70 printer_port: &str,
71 params: &HashMap<String, String>,
72 ) -> Result<(), PipelineError> {
73 let file = PosFile::load_from_path(path).map_err(PipelineError::Load)?;
74 let base_dir = path.parent();
75 let bytes = encode_pos_file(&file, base_dir, params)?;
76 let mut transport = SerialTransport::open(printer_port).map_err(PipelineError::Print)?;
77 print_bytes(&mut transport, &bytes).map_err(PipelineError::Print)
78 }
79
80 #[cfg(test)]
81 mod tests {
82 use super::*;
83
84 #[test]
85 fn detects_missing_parameters() {
86 let file = PosFile::new("Hello ${A} ${B}");
87 let doc = parse(&file.body).unwrap();
88 let mut params = HashMap::new();
89 params.insert("A".into(), "1".into());
90 assert_eq!(missing_parameters(&doc, &params), vec!["B".to_string()]);
91 }
92
93 #[test]
94 fn encodes_when_all_params_present() {
95 let file = PosFile::new("Hi ${Name}");
96 let mut params = HashMap::new();
97 params.insert("Name".into(), "Ada".into());
98 let bytes = encode_pos_file(&file, None, &params).unwrap();
99 assert!(bytes.windows(2).any(|w| w == b"Hi"));
100 }
101 }
@@ -0,0 +1,101 @@
1use std::collections::HashMap;
2use std::path::Path;
3
4use crate::dsl::{parse, Document};
5use crate::escpos::{EscPosEncoder, EscPosError};
6use crate::io::{LoadError, PosFile};
7use crate::params::{collect_parameter_names, substitute_document};
8use crate::print::{print_bytes, PrintError, SerialTransport};
9
10#[derive(Debug)]
11pub enum PipelineError {
12 Load(LoadError),
13 Parse(crate::dsl::ParseError),
14 MissingParams(Vec<String>),
15 Encode(EscPosError),
16 Print(PrintError),
17}
18
19impl std::fmt::Display for PipelineError {
20 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
21 match self {
22 Self::Load(e) => write!(f, "{e:?}"),
23 Self::Parse(e) => write!(f, "{e}"),
24 Self::MissingParams(names) => {
25 write!(f, "missing parameters: {}", names.join(", "))
26 }
27 Self::Encode(e) => write!(f, "{e:?}"),
28 Self::Print(e) => write!(f, "{e:?}"),
29 }
30 }
31}
32
33impl std::error::Error for PipelineError {}
34
35pub fn missing_parameters(document: &Document, params: &HashMap<String, String>) -> Vec<String> {
36 collect_parameter_names(document)
37 .into_iter()
38 .filter(|name| {
39 params
40 .get(name)
41 .map(|v| v.is_empty())
42 .unwrap_or(true)
43 })
44 .collect()
45}
46
47pub fn encode_pos_file(
48 file: &PosFile,
49 base_dir: Option<&Path>,
50 params: &HashMap<String, String>,
51) -> Result<Vec<u8>, PipelineError> {
52 let doc = parse(&file.body).map_err(PipelineError::Parse)?;
53 let missing = missing_parameters(&doc, params);
54 if !missing.is_empty() {
55 return Err(PipelineError::MissingParams(missing));
56 }
57 let sub = substitute_document(&doc, params);
58 let mut encoder = EscPosEncoder::new(file.metadata.clone());
59 if let Some(dir) = base_dir {
60 encoder = encoder.with_base_dir(dir);
61 }
62 let bytes = encoder
63 .encode_document(&sub)
64 .map_err(PipelineError::Encode)?;
65 Ok(bytes.to_vec())
66}
67
68pub fn print_pos_file(
69 path: &Path,
70 printer_port: &str,
71 params: &HashMap<String, String>,
72) -> Result<(), PipelineError> {
73 let file = PosFile::load_from_path(path).map_err(PipelineError::Load)?;
74 let base_dir = path.parent();
75 let bytes = encode_pos_file(&file, base_dir, params)?;
76 let mut transport = SerialTransport::open(printer_port).map_err(PipelineError::Print)?;
77 print_bytes(&mut transport, &bytes).map_err(PipelineError::Print)
78}
79
80#[cfg(test)]
81mod tests {
82 use super::*;
83
84 #[test]
85 fn detects_missing_parameters() {
86 let file = PosFile::new("Hello ${A} ${B}");
87 let doc = parse(&file.body).unwrap();
88 let mut params = HashMap::new();
89 params.insert("A".into(), "1".into());
90 assert_eq!(missing_parameters(&doc, &params), vec!["B".to_string()]);
91 }
92
93 #[test]
94 fn encodes_when_all_params_present() {
95 let file = PosFile::new("Hi ${Name}");
96 let mut params = HashMap::new();
97 params.insert("Name".into(), "Ada".into());
98 let bytes = encode_pos_file(&file, None, &params).unwrap();
99 assert!(bytes.windows(2).any(|w| w == b"Hi"));
100 }
101}
src/preview.rs +9 −3
@@ -83,17 +83,23 @@ pub fn render_preview(document: &Document, metadata: &PosMetadata) -> PreviewMod
83 83 align: *align,
84 84 }),
85 85 Block::Barcode {
86 mode,
86 87 symbology,
87 88 data,
88 89 align,
89 90 ..
90 91 } => lines.push(PreviewLine::Barcode {
91 symbology: format!("{symbology:?}"),
92 symbology: format!("{mode:?} {symbology:?}"),
92 93 data: data.clone(),
93 94 align: *align,
94 95 }),
95 Block::Qr { data, align, .. } => lines.push(PreviewLine::Qr {
96 data: data.clone(),
96 Block::Qr {
97 mode,
98 data,
99 align,
100 ..
101 } => lines.push(PreviewLine::Qr {
102 data: format!("[{mode:?}] {data}"),
97 103 align: *align,
98 104 }),
99 105 }
@@ -83,17 +83,23 @@ pub fn render_preview(document: &Document, metadata: &PosMetadata) -> PreviewMod
83 align: *align,
83 align: *align,
84 }),
84 }),
85 Block::Barcode {
85 Block::Barcode {
86 mode,
86 symbology,
87 symbology,
87 data,
88 data,
88 align,
89 align,
89 ..
90 ..
90 } => lines.push(PreviewLine::Barcode {
91 } => lines.push(PreviewLine::Barcode {
91 symbology: format!("{symbology:?}"),
92 symbology: format!("{mode:?} {symbology:?}"),
92 data: data.clone(),
93 data: data.clone(),
93 align: *align,
94 align: *align,
94 }),
95 }),
95 Block::Qr { data, align, .. } => lines.push(PreviewLine::Qr {
96 Block::Qr {
96 data: data.clone(),
97 mode,
98 data,
99 align,
100 ..
101 } => lines.push(PreviewLine::Qr {
102 data: format!("[{mode:?}] {data}"),
97 align: *align,
103 align: *align,
98 }),
104 }),
99 }
105 }
src/raster.rs added +142 −0
@@ -0,0 +1,142 @@
1 use image::{GrayImage, Luma};
2
3 use crate::dsl::{BarcodeSymbology, QrEcc};
4
5 #[derive(Debug)]
6 pub enum RasterError {
7 Encode(String),
8 Image(String),
9 }
10
11 impl std::fmt::Display for RasterError {
12 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13 match self {
14 Self::Encode(msg) | Self::Image(msg) => write!(f, "{msg}"),
15 }
16 }
17 }
18
19 impl std::error::Error for RasterError {}
20
21 pub fn render_barcode(
22 symbology: BarcodeSymbology,
23 data: &str,
24 height: u32,
25 ) -> Result<GrayImage, RasterError> {
26 use barcoders::generators::image::Image as BarcodeImage;
27 use barcoders::sym::codabar::Codabar;
28 use barcoders::sym::code11::Code11;
29 use barcoders::sym::code128::Code128;
30 use barcoders::sym::code39::Code39;
31 use barcoders::sym::code93::Code93;
32 use barcoders::sym::ean13::UPCA;
33 use barcoders::sym::ean13::EAN13;
34 use barcoders::sym::ean8::EAN8;
35 use barcoders::sym::tf::TF;
36
37 let encoded = match symbology {
38 BarcodeSymbology::Code128 => {
39 Code128::new(format!("\u{00C0}{data}"))
40 .map_err(|e| RasterError::Encode(e.to_string()))?
41 .encode()
42 }
43 BarcodeSymbology::Code39 => Code39::new(data)
44 .map_err(|e| RasterError::Encode(e.to_string()))?
45 .encode(),
46 BarcodeSymbology::Code93 => Code93::new(data)
47 .map_err(|e| RasterError::Encode(e.to_string()))?
48 .encode(),
49 BarcodeSymbology::Ean13 => EAN13::new(data)
50 .map_err(|e| RasterError::Encode(e.to_string()))?
51 .encode(),
52 BarcodeSymbology::Ean8 => EAN8::new(data)
53 .map_err(|e| RasterError::Encode(e.to_string()))?
54 .encode(),
55 BarcodeSymbology::UpcA => UPCA::new(data)
56 .map_err(|e| RasterError::Encode(e.to_string()))?
57 .encode(),
58 BarcodeSymbology::UpcE => {
59 return Err(RasterError::Encode(
60 "UPC-E raster is not supported; use native UPC-E".into(),
61 ));
62 }
63 BarcodeSymbology::Itf => TF::interleaved(data)
64 .map_err(|e| RasterError::Encode(e.to_string()))?
65 .encode(),
66 BarcodeSymbology::Codabar => Codabar::new(data)
67 .map_err(|e| RasterError::Encode(e.to_string()))?
68 .encode(),
69 BarcodeSymbology::Code11 => Code11::new(data)
70 .map_err(|e| RasterError::Encode(e.to_string()))?
71 .encode(),
72 };
73
74 let png = BarcodeImage::png(height);
75 let bytes = png
76 .generate(&encoded)
77 .map_err(|e| RasterError::Image(e.to_string()))?;
78 let img = image::load_from_memory(&bytes).map_err(|e| RasterError::Image(e.to_string()))?;
79 Ok(img.to_luma8())
80 }
81
82 pub fn render_qr(
83 data: &str,
84 version: Option<u8>,
85 ecc: QrEcc,
86 module_pixels: u32,
87 ) -> Result<GrayImage, RasterError> {
88 use qrcode::EcLevel;
89 use qrcode::QrCode;
90 use qrcode::Version;
91
92 let ec = match ecc {
93 QrEcc::L => EcLevel::L,
94 QrEcc::M => EcLevel::M,
95 QrEcc::Q => EcLevel::Q,
96 QrEcc::H => EcLevel::H,
97 };
98
99 let code = if let Some(v) = version {
100 let v = v.clamp(1, 40);
101 QrCode::with_version(data.as_bytes(), Version::Normal(i16::from(v)), ec)
102 .map_err(|e| RasterError::Encode(e.to_string()))?
103 } else {
104 QrCode::with_error_correction_level(data.as_bytes(), ec)
105 .map_err(|e| RasterError::Encode(e.to_string()))?
106 };
107
108 let width = code.width() as u32;
109 let scale = module_pixels.max(1);
110 let out_w = width * scale;
111 let mut img = GrayImage::new(out_w, out_w);
112 for y in 0..width {
113 for x in 0..width {
114 let dark = code[(x as usize, y as usize)] == qrcode::Color::Dark;
115 let color = if dark { 0 } else { 255 };
116 for dy in 0..scale {
117 for dx in 0..scale {
118 img.put_pixel(x * scale + dx, y * scale + dy, Luma([color]));
119 }
120 }
121 }
122 }
123 Ok(img)
124 }
125
126 #[cfg(test)]
127 mod tests {
128 use super::*;
129
130 #[test]
131 fn renders_code128_raster() {
132 let img = render_barcode(BarcodeSymbology::Code128, "TEST123", 60).unwrap();
133 assert!(img.width() > 10);
134 assert_eq!(img.height(), 60);
135 }
136
137 #[test]
138 fn renders_qr_raster_with_version() {
139 let img = render_qr("https://example.com", Some(5), QrEcc::M, 4).unwrap();
140 assert!(img.width() >= 20);
141 }
142 }
@@ -0,0 +1,142 @@
1use image::{GrayImage, Luma};
2
3use crate::dsl::{BarcodeSymbology, QrEcc};
4
5#[derive(Debug)]
6pub enum RasterError {
7 Encode(String),
8 Image(String),
9}
10
11impl std::fmt::Display for RasterError {
12 fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
13 match self {
14 Self::Encode(msg) | Self::Image(msg) => write!(f, "{msg}"),
15 }
16 }
17}
18
19impl std::error::Error for RasterError {}
20
21pub fn render_barcode(
22 symbology: BarcodeSymbology,
23 data: &str,
24 height: u32,
25) -> Result<GrayImage, RasterError> {
26 use barcoders::generators::image::Image as BarcodeImage;
27 use barcoders::sym::codabar::Codabar;
28 use barcoders::sym::code11::Code11;
29 use barcoders::sym::code128::Code128;
30 use barcoders::sym::code39::Code39;
31 use barcoders::sym::code93::Code93;
32 use barcoders::sym::ean13::UPCA;
33 use barcoders::sym::ean13::EAN13;
34 use barcoders::sym::ean8::EAN8;
35 use barcoders::sym::tf::TF;
36
37 let encoded = match symbology {
38 BarcodeSymbology::Code128 => {
39 Code128::new(format!("\u{00C0}{data}"))
40 .map_err(|e| RasterError::Encode(e.to_string()))?
41 .encode()
42 }
43 BarcodeSymbology::Code39 => Code39::new(data)
44 .map_err(|e| RasterError::Encode(e.to_string()))?
45 .encode(),
46 BarcodeSymbology::Code93 => Code93::new(data)
47 .map_err(|e| RasterError::Encode(e.to_string()))?
48 .encode(),
49 BarcodeSymbology::Ean13 => EAN13::new(data)
50 .map_err(|e| RasterError::Encode(e.to_string()))?
51 .encode(),
52 BarcodeSymbology::Ean8 => EAN8::new(data)
53 .map_err(|e| RasterError::Encode(e.to_string()))?
54 .encode(),
55 BarcodeSymbology::UpcA => UPCA::new(data)
56 .map_err(|e| RasterError::Encode(e.to_string()))?
57 .encode(),
58 BarcodeSymbology::UpcE => {
59 return Err(RasterError::Encode(
60 "UPC-E raster is not supported; use native UPC-E".into(),
61 ));
62 }
63 BarcodeSymbology::Itf => TF::interleaved(data)
64 .map_err(|e| RasterError::Encode(e.to_string()))?
65 .encode(),
66 BarcodeSymbology::Codabar => Codabar::new(data)
67 .map_err(|e| RasterError::Encode(e.to_string()))?
68 .encode(),
69 BarcodeSymbology::Code11 => Code11::new(data)
70 .map_err(|e| RasterError::Encode(e.to_string()))?
71 .encode(),
72 };
73
74 let png = BarcodeImage::png(height);
75 let bytes = png
76 .generate(&encoded)
77 .map_err(|e| RasterError::Image(e.to_string()))?;
78 let img = image::load_from_memory(&bytes).map_err(|e| RasterError::Image(e.to_string()))?;
79 Ok(img.to_luma8())
80}
81
82pub fn render_qr(
83 data: &str,
84 version: Option<u8>,
85 ecc: QrEcc,
86 module_pixels: u32,
87) -> Result<GrayImage, RasterError> {
88 use qrcode::EcLevel;
89 use qrcode::QrCode;
90 use qrcode::Version;
91
92 let ec = match ecc {
93 QrEcc::L => EcLevel::L,
94 QrEcc::M => EcLevel::M,
95 QrEcc::Q => EcLevel::Q,
96 QrEcc::H => EcLevel::H,
97 };
98
99 let code = if let Some(v) = version {
100 let v = v.clamp(1, 40);
101 QrCode::with_version(data.as_bytes(), Version::Normal(i16::from(v)), ec)
102 .map_err(|e| RasterError::Encode(e.to_string()))?
103 } else {
104 QrCode::with_error_correction_level(data.as_bytes(), ec)
105 .map_err(|e| RasterError::Encode(e.to_string()))?
106 };
107
108 let width = code.width() as u32;
109 let scale = module_pixels.max(1);
110 let out_w = width * scale;
111 let mut img = GrayImage::new(out_w, out_w);
112 for y in 0..width {
113 for x in 0..width {
114 let dark = code[(x as usize, y as usize)] == qrcode::Color::Dark;
115 let color = if dark { 0 } else { 255 };
116 for dy in 0..scale {
117 for dx in 0..scale {
118 img.put_pixel(x * scale + dx, y * scale + dy, Luma([color]));
119 }
120 }
121 }
122 }
123 Ok(img)
124}
125
126#[cfg(test)]
127mod tests {
128 use super::*;
129
130 #[test]
131 fn renders_code128_raster() {
132 let img = render_barcode(BarcodeSymbology::Code128, "TEST123", 60).unwrap();
133 assert!(img.width() > 10);
134 assert_eq!(img.height(), 60);
135 }
136
137 #[test]
138 fn renders_qr_raster_with_version() {
139 let img = render_qr("https://example.com", Some(5), QrEcc::M, 4).unwrap();
140 assert!(img.width() >= 20);
141 }
142}