mupdf 0.8.0

Safe Rust wrapper to MuPDF
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85

#![cfg(not(target_arch = "wasm32"))]

use crate::support::{assert_snapshot, render_page};
use mupdf::pdf::PdfDocument;
use mupdf::shape::{PdfColor, Shape, TextOptions};
use mupdf::{Font, Point, Size};

const CUSTOM_FONT_BYTES: &[u8] = include_bytes!("../files/custom.ttf");
const CUSTOM_FONT_SNAPSHOT: &str = "tests/shape/snapshots/text_custom_font.png";

pub mod m5 {
    pub mod fonts {
        use super::super::*;

        #[test]
        fn custom_ttf_snapshot() {
            let mut doc = PdfDocument::new();
            let mut page = doc.new_page(Size::A4).unwrap();
            let rendered = {
                let mut shape = Shape::new(&mut page).unwrap();
                shape
                    .insert_text(
                        Point::new(72.0, 144.0),
                        "Custom font",
                        &TextOptions {
                            fontsize: 32.0,
                            fontname: "PdfCustomSnapshot".to_owned(),
                            fontfile: Some(CUSTOM_FONT_BYTES),
                            color: Some(PdfColor::rgb(0.0, 0.0, 0.0)),
                            ..Default::default()
                        },
                    )
                    .unwrap()
                    .commit(&mut doc, true)
                    .unwrap();
                render_page(shape.page())
            };

            assert_snapshot(CUSTOM_FONT_SNAPSHOT, &rendered);
        }

        #[test]
        fn custom_ttf_unicode_text_uses_font_glyph_ids() {
            let font = Font::from_bytes("PdfCustomUnicode", CUSTOM_FONT_BYTES).unwrap();
            let (ch, glyph) = ['Ω', 'Ж', '✓', '中', 'あ']
                .into_iter()
                .filter_map(|ch| {
                    font.encode_character(ch as i32)
                        .ok()
                        .filter(|glyph| *glyph > 0 && *glyph != ch as i32)
                        .map(|glyph| (ch, glyph))
                })
                .next()
                .expect("custom font should contain at least one non-ASCII test glyph");

            let mut doc = PdfDocument::new();
            let mut page = doc.new_page(Size::A4).unwrap();
            let mut shape = Shape::new(&mut page).unwrap();
            shape
                .insert_text(
                    Point::new(72.0, 144.0),
                    &ch.to_string(),
                    &TextOptions {
                        fontname: "PdfCustomUnicode".to_owned(),
                        fontfile: Some(CUSTOM_FONT_BYTES),
                        ..Default::default()
                    },
                )
                .unwrap();

            let expected = format!("[<{:04x}>] TJ", glyph as u32);
            let codepoint_encoding = format!("[<{:04x}>] TJ", ch as u32);
            assert!(
                shape.text_cont().contains(&expected),
                "{}",
                shape.text_cont()
            );
            assert!(
                !shape.text_cont().contains(&codepoint_encoding),
                "{}",
                shape.text_cont()
            );
        }
    }
}