Struct printpdf::Rgb

pub struct Rgb {
    pub r: f32,
    pub g: f32,
    pub b: f32,
    pub icc_profile: Option<IccProfileRef>,
}

RGB color

Fields

r: f32

g: f32

b: f32

icc_profile: Option<IccProfileRef>

Implementations

impl Rgb

pub fn new(r: f32, g: f32, b: f32, icc_profile: Option<IccProfileRef>) -> Self

Examples found in repository

examples/font.rs (line 23)

fn main() {
    let (doc, page1, layer1) =
        PdfDocument::new("PDF_Document_title", Mm(500.0), Mm(300.0), "Layer 1");
    let current_layer = doc.get_page(page1).get_layer(layer1);

    let text = "Lorem ipsum";
    let text2 = "dolor sit amet";

    let mut font_reader =
        std::io::Cursor::new(include_bytes!("../assets/fonts/RobotoMedium.ttf").as_ref());

    let font = doc.add_external_font(&mut font_reader).unwrap();

    // `use_text` is a wrapper around making a simple string
    current_layer.use_text(text, 48.0, Mm(10.0), Mm(200.0), &font);

    // text fill color = blue
    let blue = Rgb::new(13.0 / 256.0, 71.0 / 256.0, 161.0 / 256.0, None);
    let orange = Rgb::new(244.0 / 256.0, 67.0 / 256.0, 54.0 / 256.0, None);
    current_layer.set_fill_color(Color::Rgb(blue));
    current_layer.set_outline_color(Color::Rgb(orange));

    // For more complex layout of text, you can use functions
    // defined on the PdfLayerReference
    // Make sure to wrap your commands
    // in a `begin_text_section()` and `end_text_section()` wrapper
    current_layer.begin_text_section();

    // setup the general fonts.
    // see the docs for these functions for details
    current_layer.set_font(&font, 33.0);
    current_layer.set_text_cursor(Mm(10.0), Mm(100.0));
    current_layer.set_line_height(33.0);
    current_layer.set_word_spacing(3000.0);
    current_layer.set_character_spacing(10.0);

    // write two lines (one line break)
    current_layer.write_text(text, &font);
    current_layer.add_line_break();
    current_layer.write_text(text2, &font);
    current_layer.add_line_break();

    current_layer.set_text_rendering_mode(TextRenderingMode::FillStroke);
    current_layer.set_character_spacing(0.0);
    current_layer.set_text_matrix(TextMatrix::Rotate(10.0));

    // write one line, but write text2 in superscript
    current_layer.write_text(text, &font);
    current_layer.set_line_offset(10.0);
    current_layer.set_text_rendering_mode(TextRenderingMode::Stroke);
    current_layer.set_font(&font, 18.0);
    current_layer.write_text(text2, &font);

    current_layer.end_text_section();

    // Use text from a built-in font (no external resource needed)
    let text = "Lorem ipsum";
    let font = doc.add_builtin_font(BuiltinFont::TimesBoldItalic).unwrap();
    current_layer.use_text(text, 48.0, Mm(10.0), Mm(200.0), &font);

    doc.save(&mut BufWriter::new(File::create("test_fonts.pdf").unwrap()))
        .unwrap();
}

examples/shape.rs (line 30)

fn main() {
    let (doc, page1, layer1) =
        PdfDocument::new("printpdf graphics test", Mm(400.0), Mm(400.0), "Layer 1");
    let current_layer = doc.get_page(page1).get_layer(layer1);

    // Quadratic shape. The "false" determines if the next (following)
    // point is a bezier handle (for curves)
    // If you want holes, simply reorder the winding of the points to be
    // counterclockwise instead of clockwise.
    let points1 = vec![
        (Point::new(Mm(100.0), Mm(100.0)), false),
        (Point::new(Mm(100.0), Mm(200.0)), false),
        (Point::new(Mm(300.0), Mm(200.0)), false),
        (Point::new(Mm(300.0), Mm(100.0)), false),
    ];

    // Is the shape stroked? Is the shape closed? Is the shape filled?
    let line1 = Line {
        points: points1.clone(),
        is_closed: true,
    };

    let outline_color = Color::Rgb(Rgb::new(0.75, 1.0, 0.64, None));
    let dash_pattern = LineDashPattern {
        dash_1: Some(20),
        ..Default::default()
    };

    // Draw first line
    current_layer.set_outline_color(outline_color);
    current_layer.set_outline_thickness(10.0);
    current_layer.add_line(line1);

    // Triangle shape
    // Note: Line is invisible by default, the previous method of
    // constructing a line is recommended!
    let line2 = Polygon {
        rings: vec![vec![
            (Point::new(Mm(150.0), Mm(150.0)), false),
            (Point::new(Mm(150.0), Mm(250.0)), false),
            (Point::new(Mm(350.0), Mm(250.0)), false),
        ]],
        mode: PaintMode::FillStroke,
        winding_order: WindingOrder::NonZero,
    };

    let fill_color_2 = Color::Cmyk(Cmyk::new(0.0, 0.0, 0.0, 0.0, None));
    let outline_color_2 = Color::Greyscale(Greyscale::new(0.45, None));

    // More advanced graphical options
    current_layer.set_overprint_stroke(true);
    current_layer.set_blend_mode(BlendMode::Seperable(SeperableBlendMode::Multiply));
    current_layer.set_line_dash_pattern(dash_pattern);
    current_layer.set_line_cap_style(LineCapStyle::Round);
    current_layer.set_line_join_style(LineJoinStyle::Round);
    current_layer.set_fill_color(fill_color_2);
    current_layer.set_outline_color(outline_color_2);
    current_layer.set_outline_thickness(15.0);

    // draw second line
    current_layer.add_polygon(line2);

    // quad clip - note: FIRST SET THE CLIP, then paint the path
    current_layer.save_graphics_state();
    let line4 = Polygon {
        rings: vec![points1.clone()],
        mode: PaintMode::Clip,
        winding_order: WindingOrder::NonZero,
    };

    current_layer.add_polygon(line4);

    let points5 = vec![
        (Point::new(Mm(150.0), Mm(150.0)), false),
        (Point::new(Mm(150.0), Mm(250.0)), false),
        (Point::new(Mm(350.0), Mm(250.0)), false),
    ];

    let line3 = Line {
        points: points5.clone(),
        is_closed: true,
    };

    let outline_color2 = Color::Rgb(Rgb::new(1.0, 0.75, 0.0, None));
    current_layer.set_line_dash_pattern(LineDashPattern::default());
    current_layer.set_outline_color(outline_color2);
    current_layer.set_outline_thickness(5.0);
    current_layer.add_line(line3);

    current_layer.restore_graphics_state(); // unset clip again for further operations

    // If this is successful, you should see a PDF two shapes, one rectangle
    // and a dotted line
    doc.save(&mut BufWriter::new(
        File::create("test_graphics.pdf").unwrap(),
    ))
    .unwrap();
}

Trait Implementations

impl Clone for Rgb

fn clone(&self) -> Rgb

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for Rgb

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

Formats the value using the given formatter.

impl PartialEq for Rgb

fn eq(&self, other: &Rgb) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl StructuralPartialEq for Rgb