Struct Printer

pub struct Printer { /* private fields */ }

Main escpos-rs structure

The printer represents the thermal printer connected to the computer.

use escpos_rs::{Printer, PrinterModel};

let printer = match Printer::new(PrinterModel::TMT20.usb_profile()) {
    Ok(maybe_printer) => match maybe_printer {
        Some(printer) => printer,
        None => panic!("No printer was found :(")
    },
    Err(e) => panic!("Error: {}", e)
};
// Now we have a printer

Implementations

impl Printer

pub fn new(printer_profile: PrinterProfile) -> Result<Option<Printer>, Error>

Creates a new printer

Creates the printer with the given details, from the printer details provided, and in the given USB context.

Examples found in repository

examples/basic.rs (line 6)

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 6)

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 6)

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_context_feeling_lucky() -> Result<Option<Printer>, Error>

Guesses the printer, and connects to it (not meant for production)

Might help to find which printer you have if you have only one connected. The function will try to connect to a printer, based on the common ones recognized by this library.

pub fn instruction( &self, instruction: &Instruction, print_data: Option<&PrintData>, ) -> Result<(), Error>

Print an instruction

You can pass optional printer data to the printer to fill in the dynamic parts of the instruction.

pub fn print<T: Into<String>>(&self, content: T) -> Result<(), Error>

Print some text.

By default, lines will break when the text exceeds the current font’s width. If you want to break lines with whitespaces, according to the width, you can use the set_space_split function.

pub fn print_gb18030(&self, content: String) -> Result<(), Error>

Print gb18030 text.

Use encoding and send raw data

pub fn println<T: Into<String>>(&self, content: T) -> Result<(), Error>

Print some text, with a newline at the end.

By default, lines will break when the text exceeds the current font’s width. If you want to break lines with whitespaces, according to the width, you can use the set_space_split function.

Examples found in repository

examples/basic.rs (line 15)

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 17)

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)
    }
}

pub fn print_barcode( &self, content: String, position: BarcodePostion, ) -> Result<(), Error>

Print barcode use type code128

You also can set HRI code postion. None Top Bottom Both four postions.

pub fn set_barcode_position( &self, position: BarcodePostion, ) -> Result<(), Error>

pub fn set_font(&mut self, font: Font) -> Result<(), Error>

Sets the current printing font.

The function will return an error if the specified font does not exist in the printer profile.

pub fn set_space_split(&mut self, state: bool)

Enables or disables space splitting for long text printing.

By default, the printer writes text in a single stream to the printer (which splits it wherever the maximum width is reached). To split by whitespaces, you can call this function with true as argument.

Examples found in repository

examples/space_split.rs (line 14)

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 14)

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 jump(&self, n: u8) -> Result<(), Error>

Jumps n number of lines (to leave whitespaces). Basically n * '\n' passed to print

pub fn cut(&self) -> Result<(), Error>

Cuts the paper, in case the instruction is supported by the printer

pub fn duo_table<A: Into<String>, B: Into<String>, C: IntoIterator<Item = (D, E)>, D: Into<String>, E: Into<String>>( &self, headers: (A, B), rows: C, ) -> Result<(), Error>

Prints a table with two columns.

For more details, check Formatter’s duo_table.

Examples found in repository

examples/tables.rs (lines 17-20)

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 trio_table<A: Into<String>, B: Into<String>, C: Into<String>, D: IntoIterator<Item = (E, F, G)>, E: Into<String>, F: Into<String>, G: Into<String>>( &self, headers: (A, B, C), rows: D, ) -> Result<(), Error>

Prints a table with three columns.

For more details, check Formatter’s trio_table.

Examples found in repository

examples/tables.rs (lines 26-29)

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 image(&self, escpos_image: EscposImage) -> Result<(), Error>

pub fn raw<A: AsRef<[u8]>>(&self, bytes: A) -> Result<(), Error>

Sends raw information to the printer

As simple as it sounds

use escpos_rs::{Printer,PrinterProfile};
let printer_profile = PrinterProfile::usb_builder(0x0001, 0x0001).build();
let printer = Printer::new(printer_profile).unwrap().unwrap();
printer.raw(&[0x01, 0x02])?;