1mod clippath;
5mod converter;
6mod filter;
7mod image;
8mod marker;
9mod mask;
10mod options;
11mod paint_server;
12mod shapes;
13mod style;
14mod svgtree;
15mod switch;
16mod units;
17mod use_node;
18
19#[cfg(feature = "text")]
20mod text;
21#[cfg(feature = "text")]
22pub(crate) use converter::Cache;
23pub use image::{ImageHrefDataResolverFn, ImageHrefResolver, ImageHrefStringResolverFn};
24pub use options::{DEFAULT_MAX_DEPTH, Options};
25#[cfg(feature = "writer")]
26pub(crate) use svgtree::{AId, EId};
27
28#[derive(Debug)]
30pub enum Error {
31 NotAnUtf8Str,
33
34 SvgzFeatureNotEnabled,
36
37 MalformedGZip,
39
40 ElementsLimitReached,
42
43 InvalidSize,
49
50 ParsingFailed(roxmltree::Error),
52}
53
54impl From<roxmltree::Error> for Error {
55 fn from(e: roxmltree::Error) -> Self {
56 Error::ParsingFailed(e)
57 }
58}
59
60impl std::fmt::Display for Error {
61 fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
62 match *self {
63 Error::NotAnUtf8Str => {
64 write!(f, "provided data has not an UTF-8 encoding")
65 }
66 Self::SvgzFeatureNotEnabled => {
67 write!(f, "enable svgz cargo feature to decode SVGZ data")
68 }
69 Error::MalformedGZip => {
70 write!(f, "provided data has a malformed GZip content")
71 }
72 Error::ElementsLimitReached => {
73 write!(f, "the maximum number of SVG elements has been reached")
74 }
75 Error::InvalidSize => {
76 write!(f, "SVG has an invalid size")
77 }
78 Error::ParsingFailed(ref e) => {
79 write!(f, "SVG data parsing failed cause {}", e)
80 }
81 }
82 }
83}
84
85impl std::error::Error for Error {}
86
87pub(crate) trait OptionLog {
88 fn log_none<F: FnOnce()>(self, f: F) -> Self;
89}
90
91impl<T> OptionLog for Option<T> {
92 #[inline]
93 fn log_none<F: FnOnce()>(self, f: F) -> Self {
94 self.or_else(|| {
95 f();
96 None
97 })
98 }
99}
100
101impl crate::Tree {
102 pub fn from_data(data: &[u8], opt: &Options) -> Result<Self, Error> {
106 if data.starts_with(&[0x1f, 0x8b]) {
107 #[cfg(feature = "svgz")]
108 {
109 let data = decompress_svgz(data)?;
110 let text = std::str::from_utf8(&data).map_err(|_| Error::NotAnUtf8Str)?;
111 Self::from_str(text, opt)
112 }
113
114 #[cfg(not(feature = "svgz"))]
115 Err(Error::SvgzFeatureNotEnabled)
116 } else {
117 let text = std::str::from_utf8(data).map_err(|_| Error::NotAnUtf8Str)?;
118 Self::from_str(text, opt)
119 }
120 }
121
122 pub fn from_data_nested(data: &[u8], opt: &Options) -> Result<Self, Error> {
126 let nested_opt = Options {
127 resources_dir: None,
128 dpi: opt.dpi,
129 font_size: opt.font_size,
130 languages: opt.languages.clone(),
131 shape_rendering: opt.shape_rendering,
132 text_rendering: opt.text_rendering,
133 image_rendering: opt.image_rendering,
134 default_size: opt.default_size,
135 image_href_resolver: ImageHrefResolver {
136 resolve_data: Box::new(|a, b, c| (opt.image_href_resolver.resolve_data)(a, b, c)),
137 resolve_string: Box::new(|_, _| None),
139 },
140 #[cfg(feature = "text")]
143 fontdb: opt.fontdb.clone(),
144 #[cfg(feature = "text")]
146 font_resolver: crate::FontResolver {
147 select_font: Box::new(|font, db| (opt.font_resolver.select_font)(font, db)),
148 select_fallback: Box::new(|c, used_fonts, db| {
149 (opt.font_resolver.select_fallback)(c, used_fonts, db)
150 }),
151 },
152 max_depth: opt.max_depth,
153 ..Options::default()
154 };
155
156 Self::from_data(data, &nested_opt)
157 }
158
159 pub fn from_str(text: &str, opt: &Options) -> Result<Self, Error> {
161 let xml_opt = roxmltree::ParsingOptions {
162 allow_dtd: true,
163 ..Default::default()
164 };
165
166 let doc = {
169 let xml = roxmltree::Document::parse_with_options(text, xml_opt)
170 .map_err(Error::ParsingFailed)?;
171 svgtree::Document::parse_tree(&xml, opt.style_sheet.as_deref(), opt.max_depth)?
172 };
173
174 self::converter::convert_doc(&doc, opt)
175 }
176
177 pub fn from_xmltree(doc: &roxmltree::Document, opt: &Options) -> Result<Self, Error> {
179 let doc = svgtree::Document::parse_tree(doc, opt.style_sheet.as_deref(), opt.max_depth)?;
180 self::converter::convert_doc(&doc, opt)
181 }
182}
183
184#[cfg(feature = "svgz")]
186pub fn decompress_svgz(data: &[u8]) -> Result<Vec<u8>, Error> {
187 use std::io::Read;
188
189 let mut decoder = flate2::read::GzDecoder::new(data);
190 let mut decoded = Vec::with_capacity(data.len() * 2);
191 decoder
192 .read_to_end(&mut decoded)
193 .map_err(|_| Error::MalformedGZip)?;
194 Ok(decoded)
195}
196
197#[inline]
198pub(crate) fn f32_bound(min: f32, val: f32, max: f32) -> f32 {
199 debug_assert!(min.is_finite());
200 debug_assert!(max.is_finite());
201
202 if val > max {
203 max
204 } else if val >= min {
205 val
206 } else {
207 min
209 }
210}