Struct Printer

pub struct Printer { /* private fields */ }

Available on non-Android only.

Defines a printer object. Example usage:

use fltk::{prelude::*, *};
let mut but = button::Button::default();
but.set_callback(|widget| {
    let mut printer = printer::Printer::default();
    if printer.begin_job(1).is_ok() {
        printer.begin_page().ok();
        let (width, height) = printer.printable_rect();
        draw::set_draw_color(enums::Color::Black);
        draw::set_line_style(draw::LineStyle::Solid, 2);
        draw::draw_rect(0, 0, width, height);
        draw::set_font(enums::Font::Courier, 12);
        printer.set_origin(width / 2, height / 2);
        printer.print_widget(widget, -widget.w() / 2, -widget.h() / 2);
        printer.end_page().ok();
        printer.end_job();
    }
});

Implementations

impl Printer

pub fn begin_job( &mut self, pagecount: i32, ) -> Result<(Option<i32>, Option<i32>), FltkError>

Begins a print job. pagecount The total number of pages to be created. Use 0 if this number is unknown Returns a tuple (frompage, topage) indicating the chosen pages by the user

Errors

Errors on failure to print

Examples found in repository

examples/editor2.rs (line 426)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn end_page(&mut self) -> Result<(), FltkError>

End the print page

Errors

Errors on failure to end the page

Examples found in repository

examples/editor2.rs (line 444)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn end_job(&mut self)

Ends the print job

Examples found in repository

examples/editor2.rs (line 446)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn begin_page(&mut self) -> Result<(), FltkError>

Begins a print page

Errors

Errors on failure to begin the page

Examples found in repository

examples/editor2.rs (line 442)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn printable_rect(&self) -> (i32, i32)

Returns the width and height of the printable rect

Examples found in repository

examples/editor2.rs (line 427)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn margins(&self) -> (i32, i32, i32, i32)

Returns the coordinates of the printable margins. (left, top, right, bottom)

pub fn origin(&self) -> (i32, i32)

Get the origin coordinates of the printable rect

pub fn set_origin(&mut self, x: i32, y: i32)

Set the origin coordinates of the printable rect

pub fn scale(&mut self, scale_x: f32, scale_y: f32)

Scale the printable rect

pub fn rotate(&mut self, angle: f32)

Rotate the printable rect

pub fn translate(&mut self, x: i32, y: i32)

Translate the printable rect

pub fn untranslate(&mut self)

Untranslate the printable rect

pub fn is_current(&self) -> bool

Check whether the printer is the current printer

pub fn set_current(&mut self)

Set the printer to be the current printer

pub fn print_widget<W: WidgetExt>(&self, widget: &W, delta_x: i32, delta_y: i32)

Print a widget

Examples found in repository

examples/editor2.rs (line 443)

    pub fn launch(&mut self) {
        while self.app.wait() {
            use Message::*;
            if let Some(msg) = self.r.recv() {
                match msg {
                    Changed => {
                        if !self.modified {
                            self.modified = true;
                            self.menu
                                .menu
                                .find_item("&File/&Save\t")
                                .unwrap()
                                .activate();
                            self.menu
                                .menu
                                .find_item("&File/&Quit\t")
                                .unwrap()
                                .set_label_color(Color::Red);
                            let name = match &self.filename {
                                Some(f) => f.to_string_lossy().to_string(),
                                None => "(Untitled)".to_string(),
                            };
                            self.main_win.set_label(&format!("* {name} - RustyEd"));
                        }
                    }
                    New => {
                        if self.buf.text() != "" {
                            let clear = if let Some(x) = dialog::choice(
                                "File unsaved, Do you wish to continue?",
                                "&Yes",
                                "&No!",
                                "",
                            ) {
                                x == 0
                            } else {
                                false
                            };
                            if clear {
                                self.buf.set_text("");
                            }
                        }
                    }
                    Open => {
                        if let Some(c) = nfc_get_file(dialog::NativeFileChooserType::BrowseFile) {
                            if c.exists() {
                                match self.buf.load_file(&c) {
                                    Ok(_) => self.filename = Some(c),
                                    Err(e) => dialog::alert(&format!(
                                        "An issue occured while loading the file: {e}"
                                    )),
                                }
                            } else {
                                dialog::alert("File does not exist!")
                            }
                        }
                    }
                    Save => {
                        self.save_file().unwrap();
                    }
                    SaveAs => {
                        self.save_file_as().unwrap();
                    }
                    Print => {
                        let mut printer = printer::Printer::default();
                        if printer.begin_job(0).is_ok() {
                            let (w, h) = printer.printable_rect();
                            self.printable.resize(
                                self.printable.x(),
                                self.printable.y(),
                                w - 40,
                                h - 40,
                            );
                            // Needs cleanup
                            let line_count = self.printable.count_lines(
                                0,
                                self.printable.buffer().unwrap().length(),
                                true,
                            ) / 45;
                            for i in 0..=line_count {
                                self.printable.scroll(45 * i, 0);
                                printer.begin_page().ok();
                                printer.print_widget(&self.printable, 20, 20);
                                printer.end_page().ok();
                            }
                            printer.end_job();
                        }
                    }
                    Quit => {
                        if self.modified {
                            match dialog::choice(
                                "Would you like to save your work?",
                                "&Yes",
                                "&No",
                                "",
                            ) {
                                Some(0) => {
                                    if self.save_file().unwrap() {
                                        self.app.quit();
                                    }
                                }
                                Some(1) => self.app.quit(),
                                Some(_) | None => (),
                            }
                        } else {
                            self.app.quit();
                        }
                    }
                    Cut => self.editor.cut(),
                    Copy => self.editor.copy(),
                    Paste => self.editor.paste(),
                    About => dialog::message(
                        "This is an example application written in Rust and using the FLTK Gui library.",
                    ),
                }
            }
        }
    }

pub fn print_window<W: WindowExt>(&self, win: &W, x_offset: i32, y_offset: i32)

Print a window

pub fn set_dialog_title(msg: &'static str)

Set the dialog “Title”

pub fn set_dialog_printer(msg: &'static str)

Set the dialog “Printer”

pub fn set_dialog_range(msg: &'static str)

Set dialog “Range”

pub fn set_dialog_copies(msg: &'static str)

Set dialog “Copies”

pub fn set_dialog_all(msg: &'static str)

Set dialog “All”

pub fn set_dialog_pages(msg: &'static str)

Set dialog “Pages”

pub fn set_dialog_from(msg: &'static str)

Set dialog “From”

pub fn set_dialog_to(msg: &'static str)

Set dialog “To”

pub fn set_dialog_properties(msg: &'static str)

Set dialog “Properties”

pub fn set_dialog_copy_number(msg: &'static str)

Set dialog “Number of copies”

pub fn set_dialog_print_button(msg: &'static str)

Set dialog “Print” button

pub fn set_dialog_cancel_button(msg: &'static str)

Set dialog “Cancel” button

pub fn set_dialog_print_to_file(msg: &'static str)

Set dialog “Print to file” button

pub fn set_property_title(msg: &'static str)

Set property “Title”

pub fn set_property_pagesize(msg: &'static str)

Set property “Page Size”

pub fn set_property_mode(msg: &'static str)

Set property “Mode”

pub fn set_property_use(msg: &'static str)

Set property “Use”

pub fn set_property_save(msg: &'static str)

Set property “Save”

pub fn set_property_cancel(msg: &'static str)

Set property “Cancel”

Trait Implementations

impl Default for Printer

fn default() -> Self

Returns the “default value” for a type.

impl Drop for Printer

fn drop(&mut self)

Executes the destructor for this type.