custom document name and refactor

mushonnip · mushonnip · commit d98274fc420a · 2025-08-11T13:03:13.000+07:00
diff --git a/Cargo.toml b/Cargo.toml
@@ -3,7 +3,7 @@ name = "raw-printer"
 description = "Direct RAW printing on windows or linux"
 repository = "https://github.com/mushonnip/raw-printer"
 keywords = ["printer"]
-version = "0.1.4"
+version = "0.1.5"
 edition = "2021"
 license = "MIT"
 
diff --git a/src/lib.rs b/src/lib.rs
@@ -1,3 +1,6 @@
+#[cfg(target_os = "windows")]
+use windows::Win32::Foundation::HANDLE;
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -12,7 +15,11 @@ mod tests {
     #[test]
     #[cfg(target_os = "windows")]
     fn test_write_to_device_windows() {
-        let result = write_to_device("ZDesigner ZD220-203dpi ZPL", "^FDhello world", Some("Test Document"));
+        let result = write_to_device(
+            "ZDesigner ZD220-203dpi ZPL",
+            "^FDhello world",
+            Some("Test Document"),
+        );
         assert!(result.is_ok());
     }
 }
@@ -30,37 +37,42 @@ mod tests {
 /// let zpl = "^FDhello world";
 /// let printer = "/dev/usb/lp0";
 /// let result = raw_printer::write_to_device(printer, zpl, Some("My Custom Document"));
-/// 
+///
 /// assert!(result.is_ok());
-/// 
+///
 /// ```
 #[cfg(target_os = "linux")]
-pub fn write_to_device(printer: &str, payload: &str, _document_name: Option<&str>) -> Result<usize, std::io::Error> {
+pub fn write_to_device(
+    printer: &str,
+    payload: &str,
+    _document_name: Option<&str>,
+) -> Result<usize, std::io::Error> {
     use std::fs::OpenOptions;
     use std::io::Write;
 
-    let device_path = OpenOptions::new().write(true).open(printer);
-
-    match device_path {
-        Ok(mut device) => {
-            let bytes_written = device.write(payload.as_bytes())?;
-            Ok(bytes_written)
-        }
-        Err(e) => Err(std::io::Error::new(std::io::ErrorKind::Other, e)),
-    }
+    let mut device = OpenOptions::new().write(true).open(printer)?;
+    let bytes_written = device.write(payload.as_bytes())?;
+    device.flush()?; // Ensure data is written
+    Ok(bytes_written)
 }
 
 #[cfg(target_os = "windows")]
-pub fn write_to_device(printer: &str, payload: &str, document_name: Option<&str>) -> Result<usize, std::io::Error> {
+pub fn write_to_device(
+    printer: &str,
+    payload: &str,
+    document_name: Option<&str>,
+) -> Result<usize, std::io::Error> {
     use std::ffi::CString;
     use std::ptr;
-    use windows::Win32::Foundation::HANDLE;
+    use windows::core::PCSTR;
     use windows::Win32::Graphics::Printing::{
-        ClosePrinter, EndDocPrinter, EndPagePrinter, OpenPrinterA, StartDocPrinterA,
-        StartPagePrinter, WritePrinter, DOC_INFO_1A, PRINTER_ACCESS_USE, PRINTER_DEFAULTSA,
+        EndDocPrinter, EndPagePrinter, OpenPrinterA, StartDocPrinterA, StartPagePrinter,
+        WritePrinter, DOC_INFO_1A, PRINTER_ACCESS_USE, PRINTER_DEFAULTSA,
     };
 
-    let printer_name = CString::new(printer).unwrap_or_default(); // null-terminated string
+    let printer_name = CString::new(printer)
+        .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
+
     let mut printer_handle: HANDLE = HANDLE(std::ptr::null_mut());
 
     // Open the printer
@@ -72,53 +84,94 @@ pub fn write_to_device(printer: &str, payload: &str, document_name: Option<&str>
         };
 
         if OpenPrinterA(
-            windows::core::PCSTR(printer_name.as_bytes().as_ptr()),
+            PCSTR(printer_name.as_ptr() as *const u8),
             &mut printer_handle,
             Some(&pd),
         )
-        .is_ok()
+        .is_err()
         {
-            let doc_name = document_name.unwrap_or("Print Job");
-            let doc_name_cstring = CString::new(doc_name).unwrap_or_default();
-            
-            let doc_info = DOC_INFO_1A {
-                pDocName: windows::core::PSTR(doc_name_cstring.as_ptr() as *mut u8),
-                pOutputFile: windows::core::PSTR::null(),
-                pDatatype: windows::core::PSTR("RAW\0".as_ptr() as *mut u8),
-            };
-
-            // Start the document
-            let job = StartDocPrinterA(printer_handle, 1, &doc_info as *const _ as _);
-            if job == 0 {
-                return Err(std::io::Error::from(windows::core::Error::from_win32()));
-            }
-
-            // Start the page
-            if !StartPagePrinter(printer_handle).as_bool() {
-                return Err(std::io::Error::from(windows::core::Error::from_win32()));
-            }
-
-            let buffer = payload.as_bytes();
-
-            let mut bytes_written: u32 = 0;
-            if !WritePrinter(
-                printer_handle,
-                buffer.as_ptr() as _,
-                buffer.len() as u32,
-                &mut bytes_written,
-            )
-            .as_bool()
-            {
-                return Err(std::io::Error::from(windows::core::Error::from_win32()));
-            }
-
-            // End the page and document
-            let _ = EndPagePrinter(printer_handle);
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                format!("Failed to open printer: {}", printer),
+            ));
+        }
+
+        // Ensure proper cleanup with RAII-style wrapper
+        let _cleanup = PrinterGuard::new(printer_handle);
+
+        let doc_name = document_name.unwrap_or("RAW_Print");
+        let doc_name_cstring = CString::new(doc_name)
+            .map_err(|e| std::io::Error::new(std::io::ErrorKind::InvalidInput, e))?;
+
+        let datatype_cstring = CString::new("RAW").unwrap();
+
+        let doc_info = DOC_INFO_1A {
+            pDocName: windows::core::PSTR(doc_name_cstring.as_ptr() as *mut u8),
+            pOutputFile: windows::core::PSTR::null(),
+            pDatatype: windows::core::PSTR(datatype_cstring.as_ptr() as *mut u8),
+        };
+
+        // Start the document
+        let job_id = StartDocPrinterA(printer_handle, 1, &doc_info as *const _ as _);
+        if job_id == 0 {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "Failed to start document",
+            ));
+        }
+
+        // Start the page
+        if !StartPagePrinter(printer_handle).as_bool() {
             let _ = EndDocPrinter(printer_handle);
-            let _ = ClosePrinter(printer_handle);
-            return Ok(bytes_written as usize);
-        } else {
-            return Err(std::io::Error::from(windows::core::Error::from_win32()));
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "Failed to start page",
+            ));
         }
+
+        let buffer = payload.as_bytes();
+        let mut bytes_written: u32 = 0;
+
+        let write_result = WritePrinter(
+            printer_handle,
+            buffer.as_ptr() as _,
+            buffer.len() as u32,
+            &mut bytes_written,
+        );
+
+        // Always end the page and document, regardless of write success
+        let _ = EndPagePrinter(printer_handle);
+        let _ = EndDocPrinter(printer_handle);
+
+        if !write_result.as_bool() {
+            return Err(std::io::Error::new(
+                std::io::ErrorKind::Other,
+                "Failed to write to printer",
+            ));
+        }
+
+        Ok(bytes_written as usize)
     }
 }
+
+#[cfg(target_os = "windows")]
+struct PrinterGuard {
+    handle: HANDLE,
+}
+
+#[cfg(target_os = "windows")]
+impl PrinterGuard {
+    fn new(handle: HANDLE) -> Self {
+        Self { handle }
+    }
+}
+
+#[cfg(target_os = "windows")]
+impl Drop for PrinterGuard {
+    fn drop(&mut self) {
+        unsafe {
+            use windows::Win32::Graphics::Printing::ClosePrinter;
+            let _ = ClosePrinter(self.handle);
+        }
+    }
+}
