Struct PrinterProfileBuilder

pub struct PrinterProfileBuilder { /* private fields */ }

Helper structure to create a PrinterProfile

Builder pattern for the PrinterProfile structure.

Implementations

impl PrinterProfileBuilder

pub fn new_usb(vendor_id: u16, product_id: u16) -> PrinterProfileBuilder

Creates a new PrinterProfileBuilder set for usb printing

use escpos_rs::PrinterProfileBuilder;
// Creates a minimum data structure to connect to a printer
let printer_profile_builder = PrinterProfileBuilder::new_usb(0x0001, 0x0001);

The data structure will be properly built just with the vendor id and the product id. The Printer’s new method will try to locate a bulk write endpoint, but it might fail to do so. See with_endpoint for manual setup.

By default, a width of 384 dots and the FontA with 32 columns of width will be loaded with the profile.

pub fn new_terminal() -> PrinterProfileBuilder

Creates a new PrinterProfileBuilder set for terminal printing

use escpos_rs::PrinterProfileBuilder;
// Creates a minimum (probably non-working) data structure to connect to a printer
let printer_profile_builder = PrinterProfileBuilder::new_terminal();

The printer will have a 32-char width for printing text, and a default with of 384 (but it cannot be used, as pictures can’t be printed to the terminal).

pub fn with_endpoint(self, endpoint: u8) -> Result<PrinterProfileBuilder, Error>

Sets the usb endpoint to which the data will be written.

use escpos_rs::PrinterProfileBuilder;
// Creates the printer details with the endpoint 0x02
let printer_profile = PrinterProfileBuilder::new_usb(0x0001, 0x0001)
    .with_endpoint(0x02).unwrap()
    .build();

pub fn with_width(self, width: u16) -> PrinterProfileBuilder

Adds a specific pixel width for the printer (required for printing images)

Defaults to 384, usually for 58mm printers.

use escpos_rs::PrinterProfileBuilder;
let printer_profile = PrinterProfileBuilder::new_usb(0x0001, 0x0001)
    .with_width(384)
    .build();

pub fn with_font_width(self, font: Font, width: u8) -> PrinterProfileBuilder

Adds a specific width per font

This allows the justification, and proper word splitting to work. If you feel insecure about what value to use, the default font (FontA) usually has 32 characters of width for 58mm paper printers, and 48 for 80mm paper. You can also look for the specsheet, or do trial and error.

use escpos_rs::{PrinterProfileBuilder, command::Font};
let printer_profile = PrinterProfileBuilder::new_usb(0x0001, 0x0001)
    .with_font_width(Font::FontA, 32)
    .build();

Examples found in repository

examples/basic.rs (line 4)

fn main() {
    let printer_profile = PrinterProfile::terminal_builder().with_font_width(Font::FontA, 20).build();
    // We pass it to the printer
    let printer = match Printer::new(printer_profile) {
        Ok(maybe_printer) => match maybe_printer {
            Some(printer) => printer,
            None => panic!("No printer was found :(")
        },
        Err(e) => panic!("Error: {}", e)
    };
    
    // We print simple text
    match printer.println("Hello, world!") {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }
}

examples/space_split.rs (line 4)

fn main() {
    let printer_profile = PrinterProfile::terminal_builder().with_font_width(Font::FontA, 32).build();
    // We pass it to the printer
    let mut printer = match Printer::new(printer_profile) {
        Ok(maybe_printer) => match maybe_printer {
            Some(printer) => printer,
            None => panic!("No printer was found :(")
        },
        Err(e) => panic!("Error: {}", e)
    };
    // We set word splitting
    printer.set_space_split(true);

    // We print simple text
    match printer.println("Really long sentence that should be splitted into three components, yay!") {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }
}

examples/tables.rs (line 4)

fn main() {
    let printer_profile = PrinterProfile::terminal_builder().with_font_width(Font::FontA, 20).build();
    // We pass it to the printer
    let mut printer = match Printer::new(printer_profile) {
        Ok(maybe_printer) => match maybe_printer {
            Some(printer) => printer,
            None => panic!("No printer was found :(")
        },
        Err(e) => panic!("Error: {}", e)
    };
    // We set word splitting
    printer.set_space_split(true);
    
    println!("Table with two columns:");
    match printer.duo_table(("Product", "Price"), vec![
        ("Milk", "5.00"),
        ("Cereal", "10.00")
    ]) {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }

    println!("Table with three columns:");
    match printer.trio_table(("Product", "Price", "Qty."), vec![
        ("Milk", "5.00", "3"),
        ("Cereal", "10.00", "1")
    ]) {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }
}

pub fn with_timeout( self, timeout: Duration, ) -> Result<PrinterProfileBuilder, Error>

Adds a bulk write timeout (usb only)

USB devices might fail to write to the bulk endpoint. In such a case, a timeout must be provided to know when to stop waiting for the buffer to flush to the printer. The default value is 2 seconds.

use escpos_rs::PrinterProfileBuilder;
let printer_profile = PrinterProfileBuilder::new_usb(0x0001, 0x0001)
    .with_timeout(std::time::Duration::from_secs(3)).unwrap()
    .build();

pub fn build(self) -> PrinterProfile

Build the PrinterProfile that lies beneath the builder

let printer_profile = PrinterProfileBuilder::new_usb(0x0001, 0x0001).build();

Examples found in repository

examples/basic.rs (line 4)

fn main() {
    let printer_profile = PrinterProfile::terminal_builder().with_font_width(Font::FontA, 20).build();
    // We pass it to the printer
    let printer = match Printer::new(printer_profile) {
        Ok(maybe_printer) => match maybe_printer {
            Some(printer) => printer,
            None => panic!("No printer was found :(")
        },
        Err(e) => panic!("Error: {}", e)
    };
    
    // We print simple text
    match printer.println("Hello, world!") {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }
}

examples/space_split.rs (line 4)

fn main() {
    let printer_profile = PrinterProfile::terminal_builder().with_font_width(Font::FontA, 32).build();
    // We pass it to the printer
    let mut printer = match Printer::new(printer_profile) {
        Ok(maybe_printer) => match maybe_printer {
            Some(printer) => printer,
            None => panic!("No printer was found :(")
        },
        Err(e) => panic!("Error: {}", e)
    };
    // We set word splitting
    printer.set_space_split(true);

    // We print simple text
    match printer.println("Really long sentence that should be splitted into three components, yay!") {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }
}

examples/tables.rs (line 4)

fn main() {
    let printer_profile = PrinterProfile::terminal_builder().with_font_width(Font::FontA, 20).build();
    // We pass it to the printer
    let mut printer = match Printer::new(printer_profile) {
        Ok(maybe_printer) => match maybe_printer {
            Some(printer) => printer,
            None => panic!("No printer was found :(")
        },
        Err(e) => panic!("Error: {}", e)
    };
    // We set word splitting
    printer.set_space_split(true);
    
    println!("Table with two columns:");
    match printer.duo_table(("Product", "Price"), vec![
        ("Milk", "5.00"),
        ("Cereal", "10.00")
    ]) {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }

    println!("Table with three columns:");
    match printer.trio_table(("Product", "Price", "Qty."), vec![
        ("Milk", "5.00", "3"),
        ("Cereal", "10.00", "1")
    ]) {
        Ok(_) => (),
        Err(e) => println!("Error: {}", e)
    }
}