genpdf 0.1.0

User-friendly PDF generator written in pure Rust
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
86
87
88
89
90
91
92
93
94
95
96
97
98

// SPDX-FileCopyrightText: 2020 Robin Krahl <robin.krahl@ireas.org>
// SPDX-License-Identifier: Apache-2.0 or MIT

///! Utilities for text wrapping.
use crate::fonts;
use crate::style;
use crate::Mm;

pub struct Wrapper<'c, 's, I: Iterator<Item = style::StyledStr<'s>>> {
    iter: I,
    font_cache: &'c fonts::FontCache,
    width: Mm,
    x: Mm,
    buf: Vec<style::StyledStr<'s>>,
}

impl<'c, 's, I: Iterator<Item = style::StyledStr<'s>>> Wrapper<'c, 's, I> {
    pub fn new(iter: I, font_cache: &'c fonts::FontCache, width: Mm) -> Wrapper<'c, 's, I> {
        Wrapper {
            iter,
            font_cache,
            width,
            x: Mm(0.0),
            buf: Vec::new(),
        }
    }
}

impl<'c, 's, I: Iterator<Item = style::StyledStr<'s>>> Iterator for Wrapper<'c, 's, I> {
    type Item = Vec<style::StyledStr<'s>>;

    fn next(&mut self) -> Option<Vec<style::StyledStr<'s>>> {
        while let Some(s) = self.iter.next() {
            let width = s.style.str_width(self.font_cache, s.s);
            if width > self.width {
                // TODO: handle
                break;
            } else if self.x + width > self.width {
                let v = std::mem::take(&mut self.buf);
                self.buf.push(s);
                self.x = width;
                return Some(v);
            } else {
                self.buf.push(s);
                self.x += width;
            }
        }

        if self.buf.is_empty() {
            None
        } else {
            Some(std::mem::take(&mut self.buf))
        }
    }
}

pub struct Words<'s, I: Iterator<Item = style::StyledStr<'s>>> {
    iter: I,
    offset: usize,
    s: Option<style::StyledStr<'s>>,
}

impl<'s, I: Iterator<Item = style::StyledStr<'s>>> Words<'s, I> {
    pub fn new<IntoIter: IntoIterator<Item = style::StyledStr<'s>, IntoIter = I>>(
        iter: IntoIter,
        offset: usize,
    ) -> Words<'s, I> {
        Words {
            iter: iter.into_iter(),
            offset,
            s: None,
        }
    }
}

impl<'s, I: Iterator<Item = style::StyledStr<'s>>> Iterator for Words<'s, I> {
    type Item = style::StyledStr<'s>;

    fn next(&mut self) -> Option<style::StyledStr<'s>> {
        if self.s.as_ref().map(|s| s.s.is_empty()).unwrap_or(true) {
            self.s = self.iter.next();
        }

        if let Some(s) = &mut self.s {
            if self.offset > 0 {
                s.s = &s.s[self.offset..];
                self.offset = 0;
            }

            let n = s.s.find(' ').map(|i| i + 1).unwrap_or_else(|| s.s.len());
            let (word, rest) = s.s.split_at(n);
            s.s = rest;
            Some(style::StyledStr::new(word, s.style))
        } else {
            None
        }
    }
}