usvg 0.2.0

An SVG simplification library.
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

// This Source Code Form is subject to the terms of the Mozilla Public
// License, v. 2.0. If a copy of the MPL was not distributed with this
// file, You can obtain one at http://mozilla.org/MPL/2.0/.

use unicode_segmentation::UnicodeSegmentation;
use svgdom::{
    NodeType,
    NumberList,
};

use super::prelude::*;


pub fn prepare_text_nodes(doc: &mut Document) {
    // Resolve rotation for each character before any preprocessing,
    // Because rotate angles depend on text children tree structure.
    {
        for mut node in doc.root().descendants().filter(|n| n.is_tag_name(EId::Text)) {
            if !node.descendants().any(|n| n.has_attribute(AId::Rotate)) {
                continue;
            }

            let mut rotate_list = Vec::new();
            resolve_rotate(&node, 0, &mut rotate_list);
            if !rotate_list.is_empty() {
                node.set_attribute((AId::Rotate, NumberList::from(rotate_list)));
            }
        }
    }

    let mut rm_nodes = Vec::new();

    for mut node in doc.root().descendants().filter(|n| n.is_tag_name(EId::Text)) {
        let mut new_text_elem = doc.create_element(EId::Text);
        new_text_elem.set_id(node.id().clone());
        prepare_text_elem(doc, &node, &mut new_text_elem);

        rm_nodes.push(node.clone());

        if !new_text_elem.has_children() {
            continue;
        }

        node.insert_before(new_text_elem.clone());

        for (_, attr) in node.attributes().iter().svg() {
            new_text_elem.set_attribute(attr.clone());
        }
    }

    for node in rm_nodes {
        doc.remove_node(node);
    }
}

fn resolve_rotate(parent: &Node, mut offset: usize, list: &mut Vec<f64>) {
    for child in parent.children() {
        if child.is_text() {
            let chars_count = UnicodeSegmentation::graphemes(child.text().as_str(), true).count();
            // TODO: should stop at the root 'text'
            if let Some(p) = child.find_node_with_attribute(AId::Rotate) {
                let attrs = p.attributes();
                if let Some(rotate_list) = attrs.get_number_list(AId::Rotate) {
                    for i in 0..chars_count {
                        let r = match rotate_list.get(i + offset) {
                            Some(r) => *r,
                            None => {
                                // Use last angle if the index is out of bounds.
                                *rotate_list.last().unwrap_or(&0.0)
                            }
                        };

                        list.push(r);
                    }

                    offset += chars_count;
                }
            }
        } else if child.is_tag_name(EId::Tspan) {
            // Use parent rotate list if it is not set.
            let sub_offset = if child.has_attribute(AId::Rotate) { 0 } else { offset };
            resolve_rotate(&child, sub_offset, list);

            // 'tspan' represent a single char.
            offset += 1;
        }
    }
}

fn prepare_text_elem(doc: &mut Document, elem: &Node, new_elem: &mut Node) {
    for node in elem.descendants().filter(|n| n.is_text()) {
        let text_parent = node.parent().unwrap();

        if node.text().is_empty() {
            continue;
        }

        if let Some(id) = text_parent.tag_id() {
            if id != EId::Text && id != EId::Tspan {
                warn!("Unsupported text child: {:?}.", id);
                continue;
            }
        } else {
            // Text node parent must be an SVG element.
            warn!("Invalid text node parent.");
            continue;
        }

        let attrs = text_parent.attributes();

        let mut new_tspan = doc.create_element(EId::Tspan);
        new_elem.append(new_tspan.clone());

        let new_text_node = doc.create_node(NodeType::Text, node.text().clone());
        new_tspan.append(new_text_node.clone());

        for (aid, attr) in attrs.iter().svg() {
            match aid {
                AId::X | AId::Y | AId::Dx | AId::Dy => {
                    if text_parent.is_tag_name(EId::Tspan) {
                        if text_parent.first_child() == Some(node.clone()) {
                            new_tspan.set_attribute(attr.clone());
                        }
                    }
                }
                _ => new_tspan.set_attribute(attr.clone()),
            }
        }
    }
}