Enum Instruction

pub enum Instruction {
    Compound {
        instructions: Vec<Instruction>,
    },
    Command {
        command: Command,
    },
    VSpace {
        lines: u8,
    },
    Text {
        content: String,
        markdown: bool,
        font: Font,
        justification: Justification,
        replacements: Option<HashSet<String>>,
    },
    DuoTable {
        name: String,
        header: (String, String),
        font: Font,
    },
    TrioTable {
        name: String,
        header: (String, String, String),
    },
    QuadTable {
        name: String,
        header: (String, String, String),
    },
    Image {
        image: EscposImage,
    },
    QRCode {
        name: String,
    },
    Cut,
}

Templates for recurrent prints

The Instruction structure allows the creation of template prints, which could contain certain data that should change between prints (be it text, tables, or even qr codes).

It is not adviced to construct the variants of the enum manually, read the available functions to guarantee a predictable outcome.

Variants

Compound

Compound instruction, composed of multiple instructions that must be executed sequentially

Fields

instructions: Vec<Instruction>

Command

An instruction consisting of a single esc/pos command

Fields

command: Command

VSpace

Short for jumping a specified number of lines

Fields

lines: u8

Text

Raw text

Fields

content: String

Content to be printed

markdown: bool

Indicates if markdown translation should be applied

font: Font

Font to be used with this text

justification: Justification

Justification of the content

replacements: Option<HashSet<String>>

Maps a string to be replaced, to a description of the string

DuoTable

2 column table

Fields

name: String

Name of the table. Required for attaching tuples for printing

header: (String, String)

Header to be displayed on the table

font: Font

Font used for the table

TrioTable

Table with three columns. Might be to tight for 50mm printers

Fields

name: String

header: (String, String, String)

QuadTable

Fancy table for really detailed prints

Fields

name: String

header: (String, String, String)

Image

Contains a static image, that is, does not change with different printing mechanisms

Fields

image: EscposImage

Inner image

QRCode

Prints a QR Code. This field is dynamic

Fields

name: String

Name of the QR code, to be searched in the qr code content list

Cut

Cuts the paper in place. Only for supported printers

Implementations

impl Instruction

pub fn is_compound(&self) -> bool

Returns true if the instruction is compund

pub fn is_text(&self) -> bool

Returns true if the instruction is text

pub fn text<A: Into<String>>( content: A, font: Font, justification: Justification, replacements: Option<HashSet<String>>, ) -> Instruction

Sends simple text to the printer.

Straightfoward text printing. The replacements set specifies which contents of the string should be replaced in a per-impresion basis.

pub fn markdown( content: String, font: Font, justification: Justification, replacements: Option<HashSet<String>>, ) -> Instruction

Sends markdown text to the printer

Allows markdown to be sent to the printer. Not everything is supported, so far the following list works (if the printer supports the corresponding fonts)

• Bold font, with **
• Italics, with _

pub fn image(image: EscposImage) -> Result<Instruction, Error>

Prints an image

For a more precise control of position in the image, it is easier to edit the input image beforehand.

pub fn qr_code(content: String) -> Result<Instruction, Error>

Creates a new QR code that does not change through different print steps

pub fn dynamic_qr_code<A: Into<String>>(name: A) -> Instruction

Creates a dynamic qr code instruction, which requires a string at printing time

pub fn command(command: Command) -> Instruction

Executes a raw escpos command.

pub fn duo_table<A: Into<String>, B: Into<String>, C: Into<String>>( name: A, header: (B, C), font: Font, ) -> Instruction

Creates a table with two columns.

pub fn trio_table<A: Into<String>, B: Into<String>, C: Into<String>, D: Into<String>>( name: A, header: (B, C, D), ) -> Instruction

Creates a table with three columns

pub fn quad_table<A: Into<String>, B: Into<String>, C: Into<String>, D: Into<String>>( name: A, header: (B, C, D), ) -> Instruction

Creates a table with four columns

Tables with four columns can be quite tight in 80mm printers, and unthinkable in 58mm ones or smaller. Use with caution!

pub fn cut() -> Instruction

Cuts the paper (if supported)

pub fn vspace(lines: u8) -> Instruction

Moves the paper a certain amount of vertical spaces

Trait Implementations

impl Add for Instruction

Instruction addition

type Output = Instruction

The resulting type after applying the + operator.

fn add(self, rhs: Instruction) -> Self::Output

Performs the + operation.

impl AddAssign for Instruction

Mutable addition for instructions

fn add_assign(&mut self, other: Self)

Performs the += operation.

impl Clone for Instruction

fn clone(&self) -> Instruction

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Instruction

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Instruction

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl FromIterator<Instruction> for Option<Instruction>

From iterator operation for a vector of instructions

fn from_iter<I: IntoIterator<Item = Instruction>>(iter: I) -> Self

Creates a value from an iterator.

impl Serialize for Instruction

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.