spandex 0.0.2

A modern LaTeX alternative
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
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

//! This module contains the trait and implementation of justification algorithms.

use printpdf::Pt;

use crate::typography::items::Content;
use crate::typography::paragraphs::{algorithm, positionate_items, Paragraph, IDEAL_SPACING};
use crate::typography::Glyph;

/// An algorithm that justifies a paragraph.
pub trait Justifier {
    /// Justifies the paragraph passed as parameter.
    fn justify<'a>(paragraph: &'a Paragraph<'a>, text_width: Pt) -> Vec<Vec<(Glyph<'a>, Pt)>>;
}

/// A naive justifier, that goes to the next line once a word overtakes the text width.
pub struct NaiveJustifier;

impl Justifier for NaiveJustifier {
    fn justify<'a>(paragraph: &'a Paragraph<'a>, text_width: Pt) -> Vec<Vec<(Glyph<'a>, Pt)>> {
        let mut ret = vec![];
        let mut current_line = vec![];
        let mut current_word = vec![];
        let mut current_x = Pt(0.0);

        for item in paragraph.iter() {
            match item.content {
                Content::BoundingBox { .. } => {
                    current_x += item.width;
                    current_word.push(item);
                }
                Content::Glue { .. } => {
                    current_line.push(current_word);
                    current_x += item.width;
                    current_word = vec![];
                }
                Content::Penalty { .. } => (),
            }

            if current_x > text_width && current_line.len() > 1 {
                current_x = Pt(0.0);

                let last_word = current_line.pop().unwrap();

                let mut occupied_width = Pt(0.0);
                for word in &current_line {
                    for glyph in word {
                        occupied_width += glyph.width;
                    }
                }

                let available_space = text_width - occupied_width;

                let word_space = if current_line.len() > 1 {
                    available_space / (current_line.len() - 1) as f64
                } else {
                    IDEAL_SPACING
                };

                let mut current_x = Pt(0.0);
                let mut final_line = vec![];

                for word in current_line {
                    for item in &word {
                        match item.content {
                            Content::BoundingBox(ref glyph) => {
                                final_line.push((glyph.clone(), current_x));
                                current_x += item.width;
                            }

                            _ => (),
                        }
                    }

                    // Put a space after the word
                    current_x += word_space;
                }

                ret.push(final_line);

                current_line = vec![last_word];
            }
        }

        let mut current_x = Pt(0.0);
        let mut final_line = vec![];

        // There is still content in current_line
        for word in current_line {
            for item in word {
                match item.content {
                    Content::BoundingBox(ref glyph) => {
                        final_line.push((glyph.clone(), current_x));
                        current_x += item.width;
                    }
                    _ => (),
                }
            }
            current_x += IDEAL_SPACING;
        }

        ret.push(final_line);

        ret
    }
}

/// The LaTeX style justifier.
pub struct LatexJustifier;

impl Justifier for LatexJustifier {
    fn justify<'a>(paragraph: &'a Paragraph<'a>, text_width: Pt) -> Vec<Vec<(Glyph<'a>, Pt)>> {
        let lines_length = vec![text_width];
        let breakpoints = algorithm(&paragraph, &lines_length);
        let positioned_items = positionate_items(&paragraph.items, &lines_length, &breakpoints);

        let mut output = vec![];

        for items in positioned_items {
            let mut line = vec![];
            for item in items {
                line.push((item.glyph.clone(), item.horizontal_offset));
            }
            output.push(line);
        }

        output
    }
}