use data_url::mime::Mime;
use glib::prelude::*;
use markup5ever::QualName;
use std::collections::hash_map::Entry;
use std::collections::HashMap;
use std::fmt;
use std::include_str;
use std::io::Cursor;
use std::rc::Rc;
use std::str::FromStr;
use std::sync::Arc;
use std::{cell::RefCell, sync::OnceLock};
use crate::accept_language::UserLanguage;
use crate::bbox::BoundingBox;
use crate::borrow_element_as;
use crate::css::{self, Origin, Stylesheet};
use crate::dpi::Dpi;
use crate::drawing_ctx::{draw_tree, with_saved_cr, DrawingMode, SvgNesting};
use crate::error::{AcquireError, InternalRenderingError, LoadingError, NodeIdError};
use crate::io::{self, BinaryData};
use crate::is_element_of_type;
use crate::limits;
use crate::node::{CascadedValues, Node, NodeBorrow, NodeData};
use crate::rect::Rect;
use crate::session::Session;
use crate::structure::IntrinsicDimensions;
use crate::surface_utils::shared_surface::SharedImageSurface;
use crate::url_resolver::{AllowedUrl, UrlResolver};
use crate::xml::{xml_load_from_possibly_compressed_stream, Attributes};
#[derive(Debug, PartialEq, Clone)]
pub enum NodeId {
Internal(String),
External(String, String),
}
impl NodeId {
pub fn parse(href: &str) -> Result<NodeId, NodeIdError> {
let (url, id) = match href.rfind('#') {
None => (Some(href), None),
Some(0) => (None, Some(&href[1..])),
Some(p) => (Some(&href[..p]), Some(&href[(p + 1)..])),
};
match (url, id) {
(None, Some(id)) if !id.is_empty() => Ok(NodeId::Internal(String::from(id))),
(Some(url), Some(id)) if !id.is_empty() => {
Ok(NodeId::External(String::from(url), String::from(id)))
}
_ => Err(NodeIdError::NodeIdRequired),
}
}
}
impl fmt::Display for NodeId {
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
match self {
NodeId::Internal(id) => write!(f, "#{id}"),
NodeId::External(url, id) => write!(f, "{url}#{id}"),
}
}
}
pub struct LoadOptions {
pub url_resolver: UrlResolver,
pub unlimited_size: bool,
pub keep_image_data: bool,
}
impl LoadOptions {
pub fn new(url_resolver: UrlResolver) -> Self {
LoadOptions {
url_resolver,
unlimited_size: false,
keep_image_data: false,
}
}
pub fn with_unlimited_size(mut self, unlimited: bool) -> Self {
self.unlimited_size = unlimited;
self
}
pub fn keep_image_data(mut self, keep: bool) -> Self {
self.keep_image_data = keep;
self
}
pub fn copy_with_base_url(&self, base_url: &AllowedUrl) -> Self {
let mut url_resolver = self.url_resolver.clone();
url_resolver.base_url = Some((**base_url).clone());
LoadOptions {
url_resolver,
unlimited_size: self.unlimited_size,
keep_image_data: self.keep_image_data,
}
}
}
pub struct Document {
tree: Node,
session: Session,
ids: HashMap<String, Node>,
resources: RefCell<Resources>,
load_options: Arc<LoadOptions>,
stylesheets: Vec<Stylesheet>,
}
impl Document {
pub fn load_from_stream(
session: Session,
load_options: Arc<LoadOptions>,
stream: &gio::InputStream,
cancellable: Option<&gio::Cancellable>,
) -> Result<Document, LoadingError> {
xml_load_from_possibly_compressed_stream(
session.clone(),
DocumentBuilder::new(session, load_options.clone()),
load_options,
stream,
cancellable,
)
}
#[cfg(test)]
pub fn load_from_bytes(input: &'static [u8]) -> Document {
let bytes = glib::Bytes::from_static(input);
let stream = gio::MemoryInputStream::from_bytes(&bytes);
Document::load_from_stream(
Session::new_for_test_suite(),
Arc::new(LoadOptions::new(UrlResolver::new(None))),
&stream.upcast(),
None::<&gio::Cancellable>,
)
.unwrap()
}
pub fn root(&self) -> Node {
self.tree.clone()
}
fn lookup_node(&self, node_id: &NodeId) -> Option<Node> {
match node_id {
NodeId::Internal(id) => self.lookup_internal_node(id),
NodeId::External(url, id) => self
.resources
.borrow_mut()
.lookup_node(&self.session, &self.load_options, url, id)
.ok(),
}
}
pub fn lookup_internal_node(&self, id: &str) -> Option<Node> {
self.ids.get(id).map(|n| (*n).clone())
}
fn lookup_image(&self, url: &str) -> Result<SharedImageSurface, LoadingError> {
let aurl = self
.load_options
.url_resolver
.resolve_href(url)
.map_err(|_| LoadingError::BadUrl)?;
self.resources
.borrow_mut()
.lookup_image(&self.session, &self.load_options, &aurl)
}
fn lookup_resource(&self, url: &str) -> Result<Resource, LoadingError> {
let aurl = self
.load_options
.url_resolver
.resolve_href(url)
.map_err(|_| LoadingError::BadUrl)?;
self.resources
.borrow_mut()
.lookup_resource(&self.session, &self.load_options, &aurl, None)
}
pub fn cascade(&mut self, extra: &[Stylesheet], session: &Session) {
let stylesheets = {
static UA_STYLESHEETS: OnceLock<Vec<Stylesheet>> = OnceLock::new();
UA_STYLESHEETS.get_or_init(|| {
vec![Stylesheet::from_data(
include_str!("ua.css"),
&UrlResolver::new(None),
Origin::UserAgent,
Session::default(),
)
.expect("could not parse user agent stylesheet for librsvg, there's a bug!")]
})
};
css::cascade(
&mut self.tree,
stylesheets,
&self.stylesheets,
extra,
session,
);
}
pub fn get_intrinsic_dimensions(&self) -> IntrinsicDimensions {
let root = self.root();
let cascaded = CascadedValues::new_from_node(&root);
let values = cascaded.get();
borrow_element_as!(self.root(), Svg).get_intrinsic_dimensions(values)
}
pub fn render_document(
&self,
session: &Session,
cr: &cairo::Context,
viewport: &cairo::Rectangle,
user_language: &UserLanguage,
dpi: Dpi,
svg_nesting: SvgNesting,
is_testing: bool,
) -> Result<(), InternalRenderingError> {
let root = self.root();
self.render_layer(
session,
cr,
root,
viewport,
user_language,
dpi,
svg_nesting,
is_testing,
)
}
pub fn render_layer(
&self,
session: &Session,
cr: &cairo::Context,
node: Node,
viewport: &cairo::Rectangle,
user_language: &UserLanguage,
dpi: Dpi,
svg_nesting: SvgNesting,
is_testing: bool,
) -> Result<(), InternalRenderingError> {
cr.status()?;
let root = self.root();
let viewport = Rect::from(*viewport);
with_saved_cr(cr, || {
draw_tree(
session.clone(),
DrawingMode::LimitToStack { node, root },
cr,
viewport,
user_language,
dpi,
svg_nesting,
false,
is_testing,
&mut AcquiredNodes::new(self),
)
.map(|_bbox| ())
})
}
fn geometry_for_layer(
&self,
session: &Session,
node: Node,
viewport: Rect,
user_language: &UserLanguage,
dpi: Dpi,
is_testing: bool,
) -> Result<(Rect, Rect), InternalRenderingError> {
let root = self.root();
let target = cairo::ImageSurface::create(cairo::Format::Rgb24, 1, 1)?;
let cr = cairo::Context::new(&target)?;
let bbox = draw_tree(
session.clone(),
DrawingMode::LimitToStack { node, root },
&cr,
viewport,
user_language,
dpi,
SvgNesting::Standalone,
true,
is_testing,
&mut AcquiredNodes::new(self),
)?;
let ink_rect = bbox.ink_rect.unwrap_or_default();
let logical_rect = bbox.rect.unwrap_or_default();
Ok((ink_rect, logical_rect))
}
pub fn get_geometry_for_layer(
&self,
session: &Session,
node: Node,
viewport: &cairo::Rectangle,
user_language: &UserLanguage,
dpi: Dpi,
is_testing: bool,
) -> Result<(cairo::Rectangle, cairo::Rectangle), InternalRenderingError> {
let viewport = Rect::from(*viewport);
let (ink_rect, logical_rect) =
self.geometry_for_layer(session, node, viewport, user_language, dpi, is_testing)?;
Ok((
cairo::Rectangle::from(ink_rect),
cairo::Rectangle::from(logical_rect),
))
}
fn get_bbox_for_element(
&self,
session: &Session,
node: &Node,
user_language: &UserLanguage,
dpi: Dpi,
is_testing: bool,
) -> Result<BoundingBox, InternalRenderingError> {
let target = cairo::ImageSurface::create(cairo::Format::Rgb24, 1, 1)?;
let cr = cairo::Context::new(&target)?;
let node = node.clone();
draw_tree(
session.clone(),
DrawingMode::OnlyNode(node),
&cr,
unit_rectangle(),
user_language,
dpi,
SvgNesting::Standalone,
true,
is_testing,
&mut AcquiredNodes::new(self),
)
}
pub fn get_geometry_for_element(
&self,
session: &Session,
node: Node,
user_language: &UserLanguage,
dpi: Dpi,
is_testing: bool,
) -> Result<(cairo::Rectangle, cairo::Rectangle), InternalRenderingError> {
let bbox = self.get_bbox_for_element(session, &node, user_language, dpi, is_testing)?;
let ink_rect = bbox.ink_rect.unwrap_or_default();
let logical_rect = bbox.rect.unwrap_or_default();
let ofs = (-ink_rect.x0, -ink_rect.y0);
Ok((
cairo::Rectangle::from(ink_rect.translate(ofs)),
cairo::Rectangle::from(logical_rect.translate(ofs)),
))
}
pub fn render_element(
&self,
session: &Session,
cr: &cairo::Context,
node: Node,
element_viewport: &cairo::Rectangle,
user_language: &UserLanguage,
dpi: Dpi,
is_testing: bool,
) -> Result<(), InternalRenderingError> {
cr.status()?;
let bbox = self.get_bbox_for_element(session, &node, user_language, dpi, is_testing)?;
if bbox.ink_rect.is_none() || bbox.rect.is_none() {
return Ok(());
}
let ink_r = bbox.ink_rect.unwrap_or_default();
if ink_r.is_empty() {
return Ok(());
}
with_saved_cr(cr, || {
let factor = (element_viewport.width() / ink_r.width())
.min(element_viewport.height() / ink_r.height());
cr.translate(element_viewport.x(), element_viewport.y());
cr.scale(factor, factor);
cr.translate(-ink_r.x0, -ink_r.y0);
draw_tree(
session.clone(),
DrawingMode::OnlyNode(node),
cr,
unit_rectangle(),
user_language,
dpi,
SvgNesting::Standalone,
false,
is_testing,
&mut AcquiredNodes::new(self),
)
.map(|_bbox| ())
})
}
}
fn unit_rectangle() -> Rect {
Rect::from_size(1.0, 1.0)
}
#[derive(Clone)]
pub enum Resource {
Document(Rc<Document>),
Image(SharedImageSurface),
}
struct Resources {
resources: HashMap<AllowedUrl, Result<Resource, LoadingError>>,
}
impl Resources {
fn new() -> Resources {
Resources {
resources: Default::default(),
}
}
fn lookup_node(
&mut self,
session: &Session,
load_options: &LoadOptions,
url: &str,
id: &str,
) -> Result<Node, LoadingError> {
self.get_extern_document(session, load_options, url)
.and_then(|resource| match resource {
Resource::Document(doc) => doc.lookup_internal_node(id).ok_or(LoadingError::BadUrl),
_ => unreachable!("get_extern_document() should already have ensured the document"),
})
}
fn get_extern_document(
&mut self,
session: &Session,
load_options: &LoadOptions,
href: &str,
) -> Result<Resource, LoadingError> {
let aurl = load_options
.url_resolver
.resolve_href(href)
.map_err(|_| LoadingError::BadUrl)?;
let resource = self.lookup_resource(session, load_options, &aurl, None)?;
match resource {
Resource::Document(_) => Ok(resource),
_ => Err(LoadingError::Other(format!(
"{href} is not an SVG document"
))),
}
}
fn lookup_image(
&mut self,
session: &Session,
load_options: &LoadOptions,
aurl: &AllowedUrl,
) -> Result<SharedImageSurface, LoadingError> {
let resource = self.lookup_resource(session, load_options, aurl, None)?;
match resource {
Resource::Image(image) => Ok(image),
_ => Err(LoadingError::Other(format!("{aurl} is not a raster image"))),
}
}
fn lookup_resource(
&mut self,
session: &Session,
load_options: &LoadOptions,
aurl: &AllowedUrl,
cancellable: Option<&gio::Cancellable>,
) -> Result<Resource, LoadingError> {
match self.resources.entry(aurl.clone()) {
Entry::Occupied(e) => e.get().clone(),
Entry::Vacant(e) => {
let resource_result = load_resource(session, load_options, aurl, cancellable);
e.insert(resource_result.clone());
resource_result
}
}
}
}
fn load_resource(
session: &Session,
load_options: &LoadOptions,
aurl: &AllowedUrl,
cancellable: Option<&gio::Cancellable>,
) -> Result<Resource, LoadingError> {
let data = io::acquire_data(aurl, cancellable)?;
let svg_mime_type = Mime::from_str("image/svg+xml").unwrap();
if data.mime_type == svg_mime_type {
load_svg_resource_from_bytes(session, load_options, aurl, data, cancellable)
} else {
load_image_resource_from_bytes(load_options, aurl, data)
}
}
fn load_svg_resource_from_bytes(
session: &Session,
load_options: &LoadOptions,
aurl: &AllowedUrl,
data: BinaryData,
cancellable: Option<&gio::Cancellable>,
) -> Result<Resource, LoadingError> {
let BinaryData {
data: input_bytes,
mime_type: _mime_type,
} = data;
let bytes = glib::Bytes::from_owned(input_bytes);
let stream = gio::MemoryInputStream::from_bytes(&bytes);
let document = Document::load_from_stream(
session.clone(),
Arc::new(load_options.copy_with_base_url(aurl)),
&stream.upcast(),
cancellable,
)?;
Ok(Resource::Document(Rc::new(document)))
}
fn load_image_resource_from_bytes(
load_options: &LoadOptions,
aurl: &AllowedUrl,
data: BinaryData,
) -> Result<Resource, LoadingError> {
let BinaryData {
data: bytes,
mime_type,
} = data;
if bytes.is_empty() {
return Err(LoadingError::Other(String::from("no image data")));
}
let content_type = content_type_for_image(&mime_type);
load_image_with_image_rs(aurl, bytes, content_type, load_options)
}
fn image_format(content_type: &str) -> Result<image::ImageFormat, LoadingError> {
match content_type {
"image/png" => Ok(image::ImageFormat::Png),
"image/jpeg" => Ok(image::ImageFormat::Jpeg),
"image/gif" => Ok(image::ImageFormat::Gif),
"image/webp" => Ok(image::ImageFormat::WebP),
_ => Err(LoadingError::Other(format!(
"unsupported image format {content_type}"
))),
}
}
fn load_image_with_image_rs(
aurl: &AllowedUrl,
bytes: Vec<u8>,
content_type: Option<String>,
load_options: &LoadOptions,
) -> Result<Resource, LoadingError> {
let cursor = Cursor::new(&bytes);
let reader = if let Some(ref content_type) = content_type {
let format = image_format(content_type)?;
image::io::Reader::with_format(cursor, format)
} else {
image::io::Reader::new(cursor)
.with_guessed_format()
.map_err(|_| LoadingError::Other(String::from("unknown image format")))?
};
let image = reader
.decode()
.map_err(|e| LoadingError::Other(format!("error decoding image: {e}")))?;
let bytes = if load_options.keep_image_data {
Some(bytes)
} else {
None
};
let surface = SharedImageSurface::from_image(&image, content_type.as_deref(), bytes)
.map_err(|e| image_loading_error_from_cairo(e, aurl))?;
Ok(Resource::Image(surface))
}
fn content_type_for_image(mime_type: &Mime) -> Option<String> {
let unspecified_mime_type = Mime::from_str("text/plain;charset=US-ASCII").unwrap();
if *mime_type == unspecified_mime_type {
None
} else {
Some(format!("{}/{}", mime_type.type_, mime_type.subtype))
}
}
fn human_readable_url(aurl: &AllowedUrl) -> &str {
if aurl.scheme() == "data" {
"data URL"
} else {
aurl.as_ref()
}
}
fn image_loading_error_from_cairo(status: cairo::Error, aurl: &AllowedUrl) -> LoadingError {
let url = human_readable_url(aurl);
match status {
cairo::Error::NoMemory => LoadingError::OutOfMemory(format!("loading image: {url}")),
cairo::Error::InvalidSize => LoadingError::Other(format!("image too big: {url}")),
_ => LoadingError::Other(format!("cairo error: {status}")),
}
}
pub struct AcquiredNode {
stack: Option<Rc<RefCell<NodeStack>>>,
node: Node,
}
impl Drop for AcquiredNode {
fn drop(&mut self) {
if let Some(ref stack) = self.stack {
let mut stack = stack.borrow_mut();
let last = stack.pop().unwrap();
assert!(last == self.node);
}
}
}
impl AcquiredNode {
pub fn get(&self) -> &Node {
&self.node
}
}
pub struct AcquiredNodes<'i> {
document: &'i Document,
num_elements_acquired: usize,
node_stack: Rc<RefCell<NodeStack>>,
}
impl<'i> AcquiredNodes<'i> {
pub fn new(document: &Document) -> AcquiredNodes<'_> {
AcquiredNodes {
document,
num_elements_acquired: 0,
node_stack: Rc::new(RefCell::new(NodeStack::new())),
}
}
pub fn lookup_image(&self, href: &str) -> Result<SharedImageSurface, LoadingError> {
self.document.lookup_image(href)
}
pub fn lookup_resource(&self, url: &str) -> Result<Resource, LoadingError> {
self.document.lookup_resource(url)
}
pub fn acquire(&mut self, node_id: &NodeId) -> Result<AcquiredNode, AcquireError> {
self.num_elements_acquired += 1;
if self.num_elements_acquired > limits::MAX_REFERENCED_ELEMENTS {
return Err(AcquireError::MaxReferencesExceeded);
}
let node = self
.document
.lookup_node(node_id)
.ok_or_else(|| AcquireError::LinkNotFound(node_id.clone()))?;
if node.borrow_element().is_accessed_by_reference() {
self.acquire_ref(&node)
} else {
Ok(AcquiredNode { stack: None, node })
}
}
pub fn acquire_ref(&self, node: &Node) -> Result<AcquiredNode, AcquireError> {
if self.node_stack.borrow().contains(node) {
Err(AcquireError::CircularReference(node.clone()))
} else {
self.node_stack.borrow_mut().push(node);
Ok(AcquiredNode {
stack: Some(self.node_stack.clone()),
node: node.clone(),
})
}
}
}
pub struct NodeStack(Vec<Node>);
impl NodeStack {
pub fn new() -> NodeStack {
NodeStack(Vec::new())
}
pub fn push(&mut self, node: &Node) {
self.0.push(node.clone());
}
pub fn pop(&mut self) -> Option<Node> {
self.0.pop()
}
pub fn contains(&self, node: &Node) -> bool {
self.0.iter().any(|n| *n == *node)
}
}
pub struct DocumentBuilder {
session: Session,
load_options: Arc<LoadOptions>,
tree: Option<Node>,
ids: HashMap<String, Node>,
stylesheets: Vec<Stylesheet>,
}
impl DocumentBuilder {
pub fn new(session: Session, load_options: Arc<LoadOptions>) -> DocumentBuilder {
DocumentBuilder {
session,
load_options,
tree: None,
ids: HashMap::new(),
stylesheets: Vec::new(),
}
}
pub fn append_stylesheet(&mut self, stylesheet: Stylesheet) {
self.stylesheets.push(stylesheet);
}
pub fn append_element(
&mut self,
name: &QualName,
attrs: Attributes,
parent: Option<Node>,
) -> Node {
let node = Node::new(NodeData::new_element(&self.session, name, attrs));
if let Some(id) = node.borrow_element().get_id() {
self.ids
.entry(id.to_string())
.or_insert_with(|| node.clone());
}
if let Some(parent) = parent {
parent.append(node.clone());
} else if self.tree.is_none() {
self.tree = Some(node.clone());
} else {
panic!("The tree root has already been set");
}
node
}
pub fn append_characters(&mut self, text: &str, parent: &mut Node) {
if !text.is_empty() {
if let Some(child) = parent.last_child().filter(|c| c.is_chars()) {
child.borrow_chars().append(text);
} else {
parent.append(Node::new(NodeData::new_chars(text)));
};
}
}
pub fn build(self) -> Result<Document, LoadingError> {
let DocumentBuilder {
load_options,
session,
tree,
ids,
stylesheets,
..
} = self;
match tree {
Some(root) if root.is_element() => {
if is_element_of_type!(root, Svg) {
let mut document = Document {
tree: root,
session: session.clone(),
ids,
resources: RefCell::new(Resources::new()),
load_options,
stylesheets,
};
document.cascade(&[], &session);
Ok(document)
} else {
Err(LoadingError::NoSvgRoot)
}
}
_ => Err(LoadingError::NoSvgRoot),
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn parses_node_id() {
assert_eq!(
NodeId::parse("#foo").unwrap(),
NodeId::Internal("foo".to_string())
);
assert_eq!(
NodeId::parse("uri#foo").unwrap(),
NodeId::External("uri".to_string(), "foo".to_string())
);
assert!(matches!(
NodeId::parse("uri"),
Err(NodeIdError::NodeIdRequired)
));
}
#[test]
fn unspecified_mime_type_yields_no_content_type() {
let mime = Mime::from_str("text/plain;charset=US-ASCII").unwrap();
assert!(content_type_for_image(&mime).is_none());
}
#[test]
fn strips_mime_type_parameters() {
let mime = Mime::from_str("image/png;charset=utf-8").unwrap();
assert_eq!(
content_type_for_image(&mime),
Some(String::from("image/png"))
);
}
}