oxidize-html 0.1.0

A backend-agnostic HTML parser, style engine, layout engine, and painter. Emits flat draw commands with no UI framework dependency.
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
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use crate::{DrawCommand, LayoutNode, NodeContent, Point, Rect, TextAlign};

pub fn paint(node: &LayoutNode, commands: &mut Vec<DrawCommand>) {
    if let Some(bg) = node.style.background_color {
        commands.push(DrawCommand::FillRect {
            rect: node.rect,
            color: bg,
        });
    }

    paint_borders(node, commands);

    if let Some(origin) = node.bullet_origin {
        commands.push(DrawCommand::DrawText {
            text: "•".to_string(),
            origin,
            color: node.style.color,
            font_size: node.style.font_size,
        });
    }

    match &node.content {
        NodeContent::Box => {}
        NodeContent::Hr => {
            commands.push(DrawCommand::DrawLine {
                start: Point {
                    x: node.rect.x,
                    y: node.rect.y + node.rect.height / 2.0,
                },
                end: Point {
                    x: node.rect.right(),
                    y: node.rect.y + node.rect.height / 2.0,
                },
                color: node.style.border.top.color,
                width: node.style.border.top.width.max(1.0),
            });
        }
        NodeContent::Text(layout) => {
            for (index, line) in layout.lines.iter().enumerate() {
                let y = node.rect.y + (index as f32 * layout.line_height);
                let line_width = line.chars().count() as f32 * layout.font_size * 0.55;
                let x = match node.style.text_align {
                    TextAlign::Left => node.rect.x,
                    TextAlign::Center => node.rect.x + (node.rect.width - line_width) / 2.0,
                    TextAlign::Right => node.rect.x + node.rect.width - line_width,
                };
                commands.push(DrawCommand::DrawText {
                    text: line.clone(),
                    origin: Point { x, y },
                    color: node.style.color,
                    font_size: layout.font_size,
                });
            }
        }
        NodeContent::Image {
            width,
            height,
            source,
        } => {
            let rect = Rect {
                x: node.rect.x,
                y: node.rect.y,
                width: *width,
                height: *height,
            };
            if matches!(source, crate::image::ImageSource::Invalid) {
                commands.push(DrawCommand::DrawImagePlaceholder { rect });
            } else {
                commands.push(DrawCommand::DrawImage {
                    rect,
                    source: source.clone(),
                });
            }
        }
    }

    if let Some(href) = &node.style.href {
        commands.push(DrawCommand::Link {
            rect: node.rect,
            href: href.clone(),
        });
    }

    for child in &node.children {
        paint(child, commands);
    }
}

fn paint_borders(node: &LayoutNode, commands: &mut Vec<DrawCommand>) {
    let border = node.style.border;
    if border.top.width > 0.0 {
        commands.push(DrawCommand::DrawLine {
            start: Point {
                x: node.rect.x,
                y: node.rect.y,
            },
            end: Point {
                x: node.rect.right(),
                y: node.rect.y,
            },
            color: border.top.color,
            width: border.top.width,
        });
    }
    if border.right.width > 0.0 {
        commands.push(DrawCommand::DrawLine {
            start: Point {
                x: node.rect.right(),
                y: node.rect.y,
            },
            end: Point {
                x: node.rect.right(),
                y: node.rect.bottom(),
            },
            color: border.right.color,
            width: border.right.width,
        });
    }
    if border.bottom.width > 0.0 {
        commands.push(DrawCommand::DrawLine {
            start: Point {
                x: node.rect.x,
                y: node.rect.bottom(),
            },
            end: Point {
                x: node.rect.right(),
                y: node.rect.bottom(),
            },
            color: border.bottom.color,
            width: border.bottom.width,
        });
    }
    if border.left.width > 0.0 {
        commands.push(DrawCommand::DrawLine {
            start: Point {
                x: node.rect.x,
                y: node.rect.y,
            },
            end: Point {
                x: node.rect.x,
                y: node.rect.bottom(),
            },
            color: border.left.color,
            width: border.left.width,
        });
    }
}