winprint 0.3.0

A crate for printing to a Windows printer device using Windows API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70

use super::powershell::{quote, run_sequentially};
use crate::printer::PrinterDevice;
use std::{cell::OnceCell, sync::OnceLock};
use uuid::Uuid;

thread_local! {
    static NULL_DEVICE: OnceCell<NullPrinterDevice> = const { OnceCell::new() };
}
static PORT_AND_DRIVER_INSTALLER: OnceLock<()> = OnceLock::new();

struct NullPrinterDevice {
    printer: PrinterDevice,
}

impl NullPrinterDevice {
    fn new() -> Self {
        PORT_AND_DRIVER_INSTALLER.get_or_init(|| {
            run_sequentially(
                "install null printer driver and port",
                r#"
if (-not (Get-PrinterDriver -Name 'Generic / Text Only' -ErrorAction SilentlyContinue)) {
    Add-PrinterDriver -Name 'Generic / Text Only'
}
if (-not (Get-PrinterPort -Name 'nul:' -ErrorAction SilentlyContinue)) {
    Add-PrinterPort -Name 'nul:'
}
"#,
            )
            .expect("install null printer driver and port");
        });

        // A same executable can be run in multiple processes.
        // Never use process local counters to generate unique names,
        // because they can collide across processes.
        let printer_name = format!(
            "null-device-{}",
            bs58::encode(Uuid::new_v4().as_bytes()).into_string()
        );
        run_sequentially(
            "add null printer",
            &format!(
                "Add-Printer -Name {} -PortName 'nul:' -DriverName 'Generic / Text Only'",
                quote(&printer_name)
            ),
        )
        .expect("add null printer");

        let printer =
            PrinterDevice::by_os_name(&printer_name).expect("find newly created null printer");
        NullPrinterDevice { printer }
    }
}

impl Drop for NullPrinterDevice {
    fn drop(&mut self) {
        // Destructors also run while unwinding; report cleanup failures without panicking.
        if let Err(error) = run_sequentially(
            "remove null printer",
            &format!("Remove-Printer -Name {}", quote(self.printer.name())),
        ) {
            eprintln!("{error}");
        }
    }
}

/// Get a thread-local null printer device.
/// This device is automatically managed and to be deleted when the thread ends.
pub fn thread_local() -> PrinterDevice {
    NULL_DEVICE.with(|f| f.get_or_init(NullPrinterDevice::new).printer.clone())
}