mirror of
https://github.com/lexmount/moli.git
synced 2026-11-18 16:08:37 +00:00
fix(svg): provide graphics client rects for measured charts
Resolve SVG object bounds and shaped text through the shared styled SVG scene, then map them through the outer CSS viewport. Project descendant computed styles without mutating the live DOM, preserving use-instance inheritance and outer transform ownership. Cover chart measurement and paint, Chromium-calibrated SVG geometry, referenced shapes, and the formerly empty circle client rectangle.
This commit is contained in:
@@ -54,6 +54,7 @@ struct HtmlSerializationOptions<'a> {
|
||||
// whose owner Document has different scripting state from the outer tree.
|
||||
scripting_enabled_for_node: &'a dyn Fn(NativeNodeId) -> bool,
|
||||
shadow_root_provider: Option<&'a dyn HtmlShadowRootProvider>,
|
||||
attribute_overrides: Option<&'a dyn Fn(NativeNodeId) -> Vec<(String, String)>>,
|
||||
}
|
||||
|
||||
impl<'a> HtmlSerializationOptions<'a> {
|
||||
@@ -65,6 +66,7 @@ impl<'a> HtmlSerializationOptions<'a> {
|
||||
target,
|
||||
scripting_enabled_for_node,
|
||||
shadow_root_provider: None,
|
||||
attribute_overrides: None,
|
||||
}
|
||||
}
|
||||
|
||||
@@ -265,6 +267,9 @@ fn serialize_html_node_frame<'a, S>(
|
||||
out.push('>');
|
||||
}
|
||||
NodeData::Element(element) => {
|
||||
let overrides = options
|
||||
.attribute_overrides
|
||||
.map(|attributes| attributes(node_id));
|
||||
out.push('<');
|
||||
out.push_str(element.local_name());
|
||||
if let Some(is_name) = element.custom_element_is_name()
|
||||
@@ -278,12 +283,31 @@ fn serialize_html_node_frame<'a, S>(
|
||||
if out.limit_exceeded() {
|
||||
return;
|
||||
}
|
||||
if overrides.as_ref().is_some_and(|attributes| {
|
||||
attributes
|
||||
.iter()
|
||||
.any(|(name, _)| attribute.name_matches(name))
|
||||
}) {
|
||||
continue;
|
||||
}
|
||||
out.push(' ');
|
||||
attribute.push_html_serialized_name(|part| out.push_str(part));
|
||||
out.push_str("=\"");
|
||||
escape_html_attribute(attribute.value(), out);
|
||||
out.push('"');
|
||||
}
|
||||
if let Some(overrides) = overrides {
|
||||
for (name, value) in overrides {
|
||||
if out.limit_exceeded() {
|
||||
return;
|
||||
}
|
||||
out.push(' ');
|
||||
out.push_str(&name);
|
||||
out.push_str("=\"");
|
||||
escape_html_attribute(&value, out);
|
||||
out.push('"');
|
||||
}
|
||||
}
|
||||
out.push('>');
|
||||
|
||||
if !is_void_html_element(element.namespace(), element.local_name()) {
|
||||
@@ -482,18 +506,24 @@ pub(super) fn serialize_html_with_limit(
|
||||
dom: &NativeDom,
|
||||
node_id: NativeNodeId,
|
||||
max_bytes: usize,
|
||||
) -> Result<Option<String>, HtmlSerializationLimitExceeded> {
|
||||
serialize_html_with_limit_and_attributes(dom, node_id, max_bytes, None)
|
||||
}
|
||||
|
||||
pub(super) fn serialize_html_with_limit_and_attributes(
|
||||
dom: &NativeDom,
|
||||
node_id: NativeNodeId,
|
||||
max_bytes: usize,
|
||||
attributes: Option<&dyn Fn(NativeNodeId) -> Vec<(String, String)>>,
|
||||
) -> Result<Option<String>, HtmlSerializationLimitExceeded> {
|
||||
let scripting_enabled_for_node = |_: NativeNodeId| true;
|
||||
let mut out = BoundedHtmlSerialization::new(max_bytes);
|
||||
if !serialize_html_into_sink(
|
||||
dom,
|
||||
node_id,
|
||||
HtmlSerializationOptions::new(
|
||||
HtmlSerializationTarget::IncludeNode,
|
||||
&scripting_enabled_for_node,
|
||||
),
|
||||
&mut out,
|
||||
) {
|
||||
let mut options = HtmlSerializationOptions::new(
|
||||
HtmlSerializationTarget::IncludeNode,
|
||||
&scripting_enabled_for_node,
|
||||
);
|
||||
options.attribute_overrides = attributes;
|
||||
if !serialize_html_into_sink(dom, node_id, options, &mut out) {
|
||||
return Ok(None);
|
||||
}
|
||||
out.finish().map(Some)
|
||||
|
||||
@@ -8,7 +8,7 @@ pub(super) use engine::{
|
||||
HtmlSerializationTarget, HtmlSerializedShadowRoot, escape_html_attribute_into_string,
|
||||
serialize_html_with_shadow_root_provider,
|
||||
};
|
||||
use engine::{serialize_html, serialize_html_with_limit};
|
||||
use engine::{serialize_html, serialize_html_with_limit, serialize_html_with_limit_and_attributes};
|
||||
|
||||
/// A bounded serialization stopped before appending bytes past its limit.
|
||||
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
|
||||
@@ -73,6 +73,18 @@ impl NativeDom {
|
||||
serialize_html_with_limit(self, node_id, max_bytes)
|
||||
}
|
||||
|
||||
/// Bounded serialization for derived consumers that need resolved attributes
|
||||
/// without mutating or cloning the live DOM. Replacement names must be valid
|
||||
/// qualified attribute names; values are escaped by the serializer.
|
||||
pub fn outer_html_with_limit_and_attributes(
|
||||
&self,
|
||||
node_id: NativeNodeId,
|
||||
max_bytes: usize,
|
||||
attributes: &dyn Fn(NativeNodeId) -> Vec<(String, String)>,
|
||||
) -> Result<Option<String>, HtmlSerializationLimitExceeded> {
|
||||
serialize_html_with_limit_and_attributes(self, node_id, max_bytes, Some(attributes))
|
||||
}
|
||||
|
||||
pub fn inner_html(&self, node_id: NativeNodeId) -> Option<String> {
|
||||
self.inner_html_with_scripting_enabled(node_id, true)
|
||||
}
|
||||
|
||||
@@ -9,6 +9,44 @@ fn scripting_enabled(_: NativeNodeId) -> bool {
|
||||
true
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn bounded_attribute_projection_preserves_live_dom_and_escapes_values() {
|
||||
let mut dom = NativeDom::new_html(test_url());
|
||||
let root = dom.create_element("div");
|
||||
let child = dom.create_element("span");
|
||||
dom.set_attribute(root, "style", "color:red");
|
||||
dom.append_child(root, child);
|
||||
let original = dom.outer_html(root).unwrap();
|
||||
let attributes = |node| {
|
||||
if node == root {
|
||||
vec![("style".into(), "font-family:\"A&B\"".into())]
|
||||
} else {
|
||||
vec![("id".into(), "derived".into())]
|
||||
}
|
||||
};
|
||||
let projected = dom
|
||||
.outer_html_with_limit_and_attributes(root, 512, &attributes)
|
||||
.unwrap()
|
||||
.unwrap();
|
||||
assert_eq!(
|
||||
projected,
|
||||
"<div style=\"font-family:"A&B"\"><span id=\"derived\"></span></div>"
|
||||
);
|
||||
assert_eq!(dom.outer_html(root).unwrap(), original);
|
||||
assert_eq!(
|
||||
dom.outer_html_with_limit_and_attributes(root, projected.len(), &attributes)
|
||||
.unwrap()
|
||||
.unwrap(),
|
||||
projected
|
||||
);
|
||||
assert_eq!(
|
||||
dom.outer_html_with_limit_and_attributes(root, projected.len() - 1, &attributes),
|
||||
Err(HtmlSerializationLimitExceeded {
|
||||
max_bytes: projected.len() - 1
|
||||
})
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn template_contents_require_the_exact_html_element_identity() {
|
||||
for (namespace, name, is_template) in [
|
||||
|
||||
@@ -5,13 +5,11 @@
|
||||
// it into one bounded, immutable `usvg::Tree`. No SVG child layout tree or
|
||||
// cross-pass resource cache is retained here.
|
||||
//
|
||||
// Because the tree is reparsed in isolation, every inherited input that
|
||||
// affects paint must be projected onto the serialized root: paint group,
|
||||
// resolved `currentColor`, root font, and the inherited text longhands. A
|
||||
// value left behind is not "slightly different styling"; usvg drops nodes it
|
||||
// cannot resolve, so `<text>` disappears from the output entirely.
|
||||
// The isolated tree also needs document CSS: sample the computed SVG paint
|
||||
// and text inputs while serializing, without changing the live DOM. Geometry
|
||||
// queries use the same decoder and font shaping as paint.
|
||||
|
||||
use std::sync::Arc;
|
||||
use std::{cell::RefCell, collections::HashSet, sync::Arc};
|
||||
|
||||
use moli_layout::{LayoutImageResource, PaintColor, ReplacedMetrics, ResolvedLayoutStyle};
|
||||
use style::color::ColorSpace;
|
||||
@@ -20,7 +18,8 @@ use style_traits::ToCss;
|
||||
|
||||
use crate::{
|
||||
document_runtime::DomHandle,
|
||||
dom::native::{DomHost, Element},
|
||||
dom::native::Element,
|
||||
native_bridge::{PageScriptHost, element::StyleObservation},
|
||||
};
|
||||
|
||||
const SVG_NAMESPACE_ATTRIBUTE: &str = " xmlns=\"http://www.w3.org/2000/svg\"";
|
||||
@@ -42,44 +41,12 @@ pub(super) fn replaced_metrics(element: &Element) -> ReplacedMetrics {
|
||||
}
|
||||
|
||||
pub(super) fn replaced_resource(
|
||||
host: &DomHost,
|
||||
runtime: &PageScriptHost,
|
||||
node: DomHandle,
|
||||
style: &ResolvedLayoutStyle,
|
||||
reads: &RefCell<StyleObservation<'_>>,
|
||||
) -> Option<LayoutImageResource> {
|
||||
let declarations = computed_root_declarations(style);
|
||||
let source_limit = moli_image::MAX_ENCODED_SVG_BYTES
|
||||
.saturating_sub(declarations.len())
|
||||
.saturating_sub(SERIALIZED_SOURCE_FIXED_INJECTION_RESERVE);
|
||||
let source = match host.dom().outer_html_with_limit(node, source_limit) {
|
||||
Ok(Some(source)) => source,
|
||||
Ok(None) => return None,
|
||||
Err(error) => {
|
||||
tracing::debug!(
|
||||
node = node.index(),
|
||||
error = ?error,
|
||||
"fresh inline SVG serialization exceeded its input budget"
|
||||
);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let Some(source) = prepare_source(source, &declarations) else {
|
||||
tracing::debug!(
|
||||
node = node.index(),
|
||||
"inline SVG serialization did not produce an SVG root"
|
||||
);
|
||||
return None;
|
||||
};
|
||||
let svg = match moli_image::decode_svg_image(source.as_bytes()) {
|
||||
Ok(svg) => Arc::new(svg),
|
||||
Err(error) => {
|
||||
tracing::debug!(
|
||||
node = node.index(),
|
||||
error = ?error,
|
||||
"fresh inline SVG resource parse failed"
|
||||
);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let svg = Arc::new(parse_live_svg(runtime, node, style, reads, None)?);
|
||||
// Inline SVG box sizing comes from Stylo's width/height presentation
|
||||
// hints. The vector object's own dimensions must use the same resolved
|
||||
// root font context, so use the parsed tree size rather than the
|
||||
@@ -93,7 +60,188 @@ pub(super) fn replaced_resource(
|
||||
})
|
||||
}
|
||||
|
||||
fn prepare_source(mut source: String, declarations: &str) -> Option<String> {
|
||||
pub(super) struct GeometryTarget<'a> {
|
||||
pub node: DomHandle,
|
||||
pub id: &'a str,
|
||||
pub viewport: moli_layout::LayoutSize,
|
||||
}
|
||||
|
||||
pub(super) fn parse_live_svg(
|
||||
runtime: &PageScriptHost,
|
||||
root: DomHandle,
|
||||
root_style: &ResolvedLayoutStyle,
|
||||
reads: &RefCell<StyleObservation<'_>>,
|
||||
geometry: Option<GeometryTarget<'_>>,
|
||||
) -> Option<moli_image::SvgImage> {
|
||||
let host = runtime.dom_host();
|
||||
let mut referenced_ids = HashSet::new();
|
||||
let mut pending = vec![root];
|
||||
while let Some(node) = pending.pop() {
|
||||
if let Some(element) = host.node(node).and_then(|node| node.as_element())
|
||||
&& element.is_svg_element("use")
|
||||
&& let Some(id) = element
|
||||
.attribute("href")
|
||||
.or_else(|| {
|
||||
element
|
||||
.attributes()
|
||||
.iter()
|
||||
.find(|attribute| {
|
||||
attribute.namespace() == "http://www.w3.org/1999/xlink"
|
||||
&& attribute.local_name() == "href"
|
||||
})
|
||||
.map(|attribute| attribute.value())
|
||||
})
|
||||
.and_then(|href| href.strip_prefix('#'))
|
||||
{
|
||||
referenced_ids.insert(id);
|
||||
}
|
||||
pending.extend(host.dom().child_ids(node));
|
||||
}
|
||||
let attributes = |node| {
|
||||
let mut attributes = Vec::new();
|
||||
let Some(element) = host.node(node).and_then(|node| node.as_element()) else {
|
||||
return attributes;
|
||||
};
|
||||
if element.namespace() != "http://www.w3.org/2000/svg" {
|
||||
return attributes;
|
||||
}
|
||||
if let Some(geometry) = geometry.as_ref()
|
||||
&& node == geometry.node
|
||||
&& element.attribute("id").is_none_or(str::is_empty)
|
||||
{
|
||||
attributes.push(("id".into(), geometry.id.into()));
|
||||
}
|
||||
// A referenced definition inherits at its <use> instance, not at its
|
||||
// original DOM position. This also applies to references outside
|
||||
// <defs>. Preserve their authored inheritance instead of freezing it.
|
||||
let mut parent = Some(node);
|
||||
while let Some(ancestor) = parent {
|
||||
if host
|
||||
.node(ancestor)
|
||||
.and_then(|node| node.as_element())
|
||||
.is_some_and(|element| {
|
||||
element.is_svg_element("defs")
|
||||
|| (ancestor != root
|
||||
&& element
|
||||
.attribute("id")
|
||||
.is_some_and(|id| referenced_ids.contains(id)))
|
||||
})
|
||||
{
|
||||
return attributes;
|
||||
}
|
||||
if ancestor == root {
|
||||
break;
|
||||
}
|
||||
parent = host.dom().parent_node(ancestor);
|
||||
}
|
||||
let mut declarations = if node == root {
|
||||
let mut declarations = computed_root_declarations(root_style);
|
||||
// The CSS replaced-element box applies the outer SVG transform.
|
||||
// Reapplying it inside the vector resource would transform both
|
||||
// paint and client geometry twice. Descendant SVG transforms stay.
|
||||
append_serialized_declaration(&mut declarations, "transform", "none");
|
||||
declarations
|
||||
} else {
|
||||
let Some(computed) = reads.borrow_mut().read(node).computed_values() else {
|
||||
return attributes;
|
||||
};
|
||||
let style = ResolvedLayoutStyle::from_stylo(computed);
|
||||
let mut declarations = computed_root_declarations(&style);
|
||||
let computed = style.stylo_computed_values().expect("resolved SVG style");
|
||||
for (name, value) in [
|
||||
("display", computed.clone_display().to_css_string()),
|
||||
("visibility", computed.clone_visibility().to_css_string()),
|
||||
("opacity", computed.clone_opacity().to_css_string()),
|
||||
("text-anchor", computed.clone_text_anchor().to_css_string()),
|
||||
] {
|
||||
append_serialized_declaration(&mut declarations, name, &value);
|
||||
}
|
||||
declarations
|
||||
};
|
||||
if let Some(geometry) = geometry.as_ref()
|
||||
&& node == root
|
||||
{
|
||||
for (name, value) in [
|
||||
("width", geometry.viewport.width),
|
||||
("height", geometry.viewport.height),
|
||||
] {
|
||||
attributes.push((name.into(), value.to_string()));
|
||||
append_serialized_declaration(&mut declarations, name, &format!("{value}px"));
|
||||
}
|
||||
}
|
||||
let declarations = merge_computed_declarations(
|
||||
element.attribute("style").unwrap_or_default(),
|
||||
&declarations,
|
||||
);
|
||||
attributes.push(("style".into(), declarations));
|
||||
attributes
|
||||
};
|
||||
let source_limit =
|
||||
moli_image::MAX_ENCODED_SVG_BYTES.saturating_sub(SERIALIZED_SOURCE_FIXED_INJECTION_RESERVE);
|
||||
let source =
|
||||
match host
|
||||
.dom()
|
||||
.outer_html_with_limit_and_attributes(root, source_limit, &attributes)
|
||||
{
|
||||
Ok(Some(source)) => source,
|
||||
Ok(None) => return None,
|
||||
Err(error) => {
|
||||
tracing::debug!(
|
||||
node = root.index(),
|
||||
error = ?error,
|
||||
"fresh inline SVG serialization exceeded its input budget"
|
||||
);
|
||||
return None;
|
||||
}
|
||||
};
|
||||
let Some(source) = prepare_source(source) else {
|
||||
tracing::debug!(
|
||||
node = root.index(),
|
||||
"inline SVG serialization did not produce an SVG root"
|
||||
);
|
||||
return None;
|
||||
};
|
||||
match moli_image::decode_svg_image(source.as_bytes()) {
|
||||
Ok(svg) => Some(svg),
|
||||
Err(error) => {
|
||||
tracing::debug!(
|
||||
node = root.index(),
|
||||
error = ?error,
|
||||
"fresh inline SVG resource parse failed"
|
||||
);
|
||||
None
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
fn merge_computed_declarations(authored: &str, computed: &str) -> String {
|
||||
// usvg's simplecss parser stops at an empty declaration and gives the
|
||||
// first !important declaration precedence. Normalize authored CSS and
|
||||
// remove the properties whose final values have already been sampled.
|
||||
let options = moli_css_parse::DeclarationParseOptions::default();
|
||||
let computed = moli_css_parse::parse_declaration_list(computed, options);
|
||||
let mut declarations = String::new();
|
||||
for property in moli_css_parse::parse_declaration_list(authored, options) {
|
||||
if !computed
|
||||
.iter()
|
||||
.any(|projected| projected.name.eq_ignore_ascii_case(&property.name))
|
||||
{
|
||||
declarations.push_str(&property.name);
|
||||
declarations.push(':');
|
||||
declarations.push_str(&property.value);
|
||||
if property.important {
|
||||
declarations.push_str(" !important");
|
||||
}
|
||||
declarations.push(';');
|
||||
}
|
||||
}
|
||||
for property in computed {
|
||||
append_serialized_declaration(&mut declarations, &property.name, &property.value);
|
||||
}
|
||||
declarations
|
||||
}
|
||||
|
||||
fn prepare_source(mut source: String) -> Option<String> {
|
||||
if !source.starts_with("<svg")
|
||||
|| !source
|
||||
.as_bytes()
|
||||
@@ -111,23 +259,6 @@ fn prepare_source(mut source: String, declarations: &str) -> Option<String> {
|
||||
source.insert_str(4, SVG_NAMESPACE_ATTRIBUTE);
|
||||
}
|
||||
|
||||
// `outerHTML` carries authored SVG presentation attributes and internal
|
||||
// styles, but external document CSS is not serialized. Project the root's
|
||||
// already-resolved inherited inputs as final inline declarations so
|
||||
// descendant `currentColor` paint and relative SVG lengths see the same
|
||||
// root context as NativeDom/Stylo.
|
||||
// Appending an important declaration also wins over an earlier authored
|
||||
// declaration in the same serialized style attribute; the sampled value
|
||||
// is already the final computed value, so this does not re-run cascade.
|
||||
let root_end = source.find('>')?;
|
||||
if let Some(style_start) = source[..root_end].find(" style=\"") {
|
||||
let value_start = style_start + " style=\"".len();
|
||||
let value_end = value_start + source[value_start..root_end].find('"')?;
|
||||
source.insert_str(value_end, &format!(";{declarations}"));
|
||||
} else {
|
||||
source.insert_str(root_end, &format!(" style=\"{declarations}\""));
|
||||
}
|
||||
|
||||
// HTML serialization uses this named entity while XML has no predefined
|
||||
// `nbsp` entity. Numeric spelling preserves the character for usvg.
|
||||
if source.contains(" ") {
|
||||
@@ -211,10 +342,8 @@ fn computed_root_declarations(style: &ResolvedLayoutStyle) -> String {
|
||||
append_serialized_declaration(
|
||||
&mut declarations,
|
||||
"font-family",
|
||||
// Stylo quotes a family name with double quotes and these declarations
|
||||
// land inside a double-quoted `style` attribute of an XML document, so
|
||||
// the value needs XML escaping; usvg decodes it back to authored text.
|
||||
&escape_serialized_value(&computed.clone_font_family().to_css_string()),
|
||||
// Attribute projection escapes quoted family names at serialization.
|
||||
&computed.clone_font_family().to_css_string(),
|
||||
);
|
||||
append_serialized_declaration(
|
||||
&mut declarations,
|
||||
@@ -283,27 +412,6 @@ fn append_serialized_declaration(declarations: &mut String, name: &str, value: &
|
||||
declarations.push_str(" !important;");
|
||||
}
|
||||
|
||||
/// Escapes a declaration value for a double-quoted `style` attribute of the
|
||||
/// serialized XML document.
|
||||
///
|
||||
/// usvg parses the serialized subtree as XML, where an unescaped `"` would end
|
||||
/// the attribute and a bare `&` would start an entity. Only the characters
|
||||
/// that can appear in an authored font family (or a quoted CSS value) need
|
||||
/// this; the other declarations are numeric or identifier-only.
|
||||
fn escape_serialized_value(value: &str) -> String {
|
||||
let mut escaped = String::with_capacity(value.len());
|
||||
for character in value.chars() {
|
||||
match character {
|
||||
'&' => escaped.push_str("&"),
|
||||
'"' => escaped.push_str("""),
|
||||
'<' => escaped.push_str("<"),
|
||||
'>' => escaped.push_str(">"),
|
||||
other => escaped.push(other),
|
||||
}
|
||||
}
|
||||
escaped
|
||||
}
|
||||
|
||||
fn rgba_css(color: PaintColor) -> String {
|
||||
let channel = |value: f32| {
|
||||
let value = if value.is_finite() { value } else { 0.0 };
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
mod inline_svg;
|
||||
mod source_view;
|
||||
mod style_resolver;
|
||||
mod svg_geometry;
|
||||
|
||||
use std::collections::HashMap;
|
||||
|
||||
@@ -11,6 +12,8 @@ use moli_layout::{
|
||||
|
||||
use crate::{document_runtime::DomHandle, native_bridge::PageScriptHost};
|
||||
|
||||
pub(crate) use svg_geometry::svg_client_rect;
|
||||
|
||||
pub(crate) fn build_native_layout_pass(
|
||||
runtime: &PageScriptHost,
|
||||
root: DomHandle,
|
||||
@@ -52,7 +55,14 @@ fn build_native_layout_pass_recursive(
|
||||
let source = source_view::NativeLayoutSourceView::with_paint_resources(
|
||||
runtime,
|
||||
root,
|
||||
request.requests_paint(),
|
||||
request.requests_paint().then(|| {
|
||||
style_resolver::layout_style_read_scope(
|
||||
runtime,
|
||||
document,
|
||||
request.viewport,
|
||||
environment_override,
|
||||
)
|
||||
}),
|
||||
);
|
||||
let source_ready = profile_started.map(|_| std::time::Instant::now());
|
||||
let mut styles = style_resolver::NativeLayoutStyleResolver::new(
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
use std::collections::{HashMap, HashSet};
|
||||
use std::{
|
||||
cell::RefCell,
|
||||
collections::{HashMap, HashSet},
|
||||
};
|
||||
|
||||
use moli_layout::{
|
||||
LayoutElementCategory, LayoutElementMetadata, LayoutElementSemantics, LayoutImageResource,
|
||||
@@ -13,33 +16,33 @@ use crate::{
|
||||
flat_children, flat_parent, form_control_data, layout_element_classification, list_data,
|
||||
optional_positive_u16_attribute, select_control_data,
|
||||
},
|
||||
native_bridge::PageScriptHost,
|
||||
native_bridge::{PageScriptHost, element::StyleObservation},
|
||||
};
|
||||
|
||||
pub(super) struct NativeLayoutSourceView<'a> {
|
||||
runtime: &'a PageScriptHost,
|
||||
root: DomHandle,
|
||||
document: Option<DomHandle>,
|
||||
include_paint_resources: bool,
|
||||
paint_styles: Option<RefCell<StyleObservation<'a>>>,
|
||||
text_selections: HashMap<DomHandle, LayoutTextSelection>,
|
||||
}
|
||||
|
||||
impl<'a> NativeLayoutSourceView<'a> {
|
||||
#[cfg(test)]
|
||||
pub(super) fn new(runtime: &'a PageScriptHost, root: DomHandle) -> Self {
|
||||
Self::with_paint_resources(runtime, root, false)
|
||||
Self::with_paint_resources(runtime, root, None)
|
||||
}
|
||||
|
||||
pub(super) fn with_paint_resources(
|
||||
runtime: &'a PageScriptHost,
|
||||
root: DomHandle,
|
||||
include_paint_resources: bool,
|
||||
paint_styles: Option<StyleObservation<'a>>,
|
||||
) -> Self {
|
||||
Self {
|
||||
runtime,
|
||||
root,
|
||||
document: runtime.dom_host().owner_document_handle(root),
|
||||
include_paint_resources,
|
||||
paint_styles: paint_styles.map(RefCell::new),
|
||||
text_selections: document_text_selections(runtime, root),
|
||||
}
|
||||
}
|
||||
@@ -238,9 +241,7 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
|
||||
node: Self::NodeId,
|
||||
style: &moli_layout::ResolvedLayoutStyle,
|
||||
) -> Option<LayoutImageResource> {
|
||||
if !self.include_paint_resources {
|
||||
return None;
|
||||
}
|
||||
let paint_styles = self.paint_styles.as_ref()?;
|
||||
let semantics = self
|
||||
.host()
|
||||
.node(node)
|
||||
@@ -257,7 +258,7 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
|
||||
})
|
||||
}
|
||||
Some(LayoutReplacedKind::Svg) => {
|
||||
super::inline_svg::replaced_resource(self.host(), node, style)
|
||||
super::inline_svg::replaced_resource(self.runtime, node, style, paint_styles)
|
||||
}
|
||||
Some(LayoutReplacedKind::Canvas) => {
|
||||
let pixels = self.runtime.canvas_pixels_for_layout(node)?;
|
||||
@@ -273,9 +274,7 @@ impl LayoutSource for NativeLayoutSourceView<'_> {
|
||||
}
|
||||
|
||||
fn css_image_resource(&self, resolved_url: &str) -> Option<LayoutImageResource> {
|
||||
if !self.include_paint_resources {
|
||||
return None;
|
||||
}
|
||||
self.paint_styles.as_ref()?;
|
||||
let parsed = url::Url::parse(resolved_url).ok()?;
|
||||
// Blink shares the fetched bytes using a fragment-free cache key, but
|
||||
// then applies SVG view/element-fragment semantics separately. Until
|
||||
|
||||
@@ -90,7 +90,7 @@ impl<'a> NativeLayoutStyleResolver<'a> {
|
||||
}
|
||||
}
|
||||
|
||||
fn layout_style_read_scope<'a>(
|
||||
pub(super) fn layout_style_read_scope<'a>(
|
||||
runtime: &'a PageScriptHost,
|
||||
document: DomHandle,
|
||||
viewport: LayoutViewport,
|
||||
|
||||
@@ -0,0 +1,158 @@
|
||||
use std::cell::RefCell;
|
||||
|
||||
use moli_layout::{
|
||||
LayoutError, LayoutPoint, LayoutQuad, LayoutQuery, LayoutQueryAnswer, ResolvedLayoutStyle,
|
||||
};
|
||||
|
||||
use crate::{
|
||||
document_runtime::DomHandle,
|
||||
native_bridge::{PageScriptHost, element::StyleObservation},
|
||||
};
|
||||
|
||||
use super::inline_svg::{GeometryTarget, parse_live_svg};
|
||||
|
||||
/// SVG graphics have object geometry rather than CSS layout boxes. CSSOM View
|
||||
/// requires a single transformed object rectangle for these elements.
|
||||
pub(crate) fn svg_client_rect(
|
||||
runtime: &PageScriptHost,
|
||||
document: DomHandle,
|
||||
source: DomHandle,
|
||||
) -> Result<Option<Vec<LayoutQuad>>, LayoutError> {
|
||||
let host = runtime.dom_host();
|
||||
let Some(element) = host.node(source).and_then(|node| node.as_element()) else {
|
||||
return Ok(None);
|
||||
};
|
||||
if element.namespace() != "http://www.w3.org/2000/svg" {
|
||||
return Ok(None);
|
||||
}
|
||||
let mut root = source;
|
||||
let mut ancestor = host.dom().parent_node(source);
|
||||
while let Some(parent) = ancestor {
|
||||
let Some(parent_element) = host.node(parent).and_then(|node| node.as_element()) else {
|
||||
break;
|
||||
};
|
||||
if parent_element.namespace() != "http://www.w3.org/2000/svg" {
|
||||
break;
|
||||
}
|
||||
root = parent;
|
||||
ancestor = host.dom().parent_node(parent);
|
||||
}
|
||||
if root == source
|
||||
|| host
|
||||
.node(root)
|
||||
.is_none_or(|node| node.local_name() != Some("svg"))
|
||||
{
|
||||
// The outer SVG has a CSS replaced-element box, just like <img>.
|
||||
return Ok(None);
|
||||
}
|
||||
let mut reads = StyleObservation::new(runtime);
|
||||
let mut ancestor = Some(source);
|
||||
while let Some(node) = ancestor {
|
||||
if host
|
||||
.node(node)
|
||||
.and_then(|node| node.as_element())
|
||||
.is_some_and(|element| {
|
||||
element.namespace() == "http://www.w3.org/2000/svg"
|
||||
&& matches!(
|
||||
element.local_name(),
|
||||
"defs" | "symbol" | "marker" | "pattern" | "clipPath" | "mask"
|
||||
)
|
||||
})
|
||||
{
|
||||
return Ok(Some(Vec::new()));
|
||||
}
|
||||
if let Some(computed) = reads.read(node).computed_values()
|
||||
&& computed.clone_display().is_none()
|
||||
{
|
||||
return Ok(Some(Vec::new()));
|
||||
}
|
||||
ancestor = host.dom().parent_node(node);
|
||||
if ancestor == Some(document) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
let Some(computed) = reads.read(root).computed_values() else {
|
||||
return Ok(Some(Vec::new()));
|
||||
};
|
||||
let style = ResolvedLayoutStyle::from_stylo(computed);
|
||||
let model = match runtime
|
||||
.answer_layout_query_for_document(document, &LayoutQuery::BoxModel { source: root })?
|
||||
{
|
||||
LayoutQueryAnswer::BoxModel(model) => model,
|
||||
_ => unreachable!("SVG viewport box model query"),
|
||||
};
|
||||
let metrics = match runtime
|
||||
.answer_layout_query_for_document(document, &LayoutQuery::ElementMetrics { source: root })?
|
||||
{
|
||||
LayoutQueryAnswer::ElementMetrics(metrics) => metrics,
|
||||
_ => unreachable!("SVG viewport metrics query"),
|
||||
};
|
||||
// A newly inserted SVG may not yet have a box in the published layout.
|
||||
// Its local geometry can still be measured, using its SVG viewport; once
|
||||
// layout publishes the outer box, include that box's placement/transforms.
|
||||
let metadata = super::inline_svg::replaced_metrics(
|
||||
host.node(root)
|
||||
.and_then(|node| node.as_element())
|
||||
.expect("SVG root"),
|
||||
);
|
||||
let viewport = metrics
|
||||
.as_ref()
|
||||
.map(|metrics| metrics.content_size)
|
||||
.unwrap_or_else(|| {
|
||||
moli_layout::LayoutSize::new(
|
||||
metadata.intrinsic_width.unwrap_or(300.0),
|
||||
metadata.intrinsic_height.unwrap_or(150.0),
|
||||
)
|
||||
});
|
||||
if viewport.width <= 0.0 || viewport.height <= 0.0 {
|
||||
return Ok(Some(Vec::new()));
|
||||
}
|
||||
let marker = format!("__moli_svg_geometry_{}", source.index());
|
||||
let id = element
|
||||
.attribute("id")
|
||||
.filter(|id| !id.is_empty())
|
||||
.unwrap_or(&marker);
|
||||
let Some(svg) = parse_live_svg(
|
||||
runtime,
|
||||
root,
|
||||
&style,
|
||||
&RefCell::new(reads),
|
||||
Some(GeometryTarget {
|
||||
node: source,
|
||||
id,
|
||||
viewport,
|
||||
}),
|
||||
) else {
|
||||
return Ok(Some(Vec::new()));
|
||||
};
|
||||
let Some(node) = svg.tree().node_by_id(id) else {
|
||||
return Ok(Some(Vec::new()));
|
||||
};
|
||||
let bounds = node.bounding_box();
|
||||
let transform = node.abs_transform();
|
||||
let map = |x, y| {
|
||||
let x2 = transform.sx * x + transform.kx * y + transform.tx;
|
||||
let y2 = transform.ky * x + transform.sy * y + transform.ty;
|
||||
if let Some(model) = model.as_ref() {
|
||||
let [origin, right, _, bottom] = model.content.points;
|
||||
LayoutPoint::new(
|
||||
origin.x
|
||||
+ (right.x - origin.x) * x2 / viewport.width
|
||||
+ (bottom.x - origin.x) * y2 / viewport.height,
|
||||
origin.y
|
||||
+ (right.y - origin.y) * x2 / viewport.width
|
||||
+ (bottom.y - origin.y) * y2 / viewport.height,
|
||||
)
|
||||
} else {
|
||||
LayoutPoint::new(x2, y2)
|
||||
}
|
||||
};
|
||||
Ok(Some(vec![LayoutQuad {
|
||||
points: [
|
||||
map(bounds.left(), bounds.top()),
|
||||
map(bounds.right(), bounds.top()),
|
||||
map(bounds.right(), bounds.bottom()),
|
||||
map(bounds.left(), bounds.bottom()),
|
||||
],
|
||||
}]))
|
||||
}
|
||||
@@ -44,6 +44,12 @@ fn published_geometry_query(
|
||||
query: &LayoutQuery<DomHandle>,
|
||||
) -> Result<LayoutQueryAnswer<DomHandle>, LayoutError> {
|
||||
if runtime.layout_policy().uses_real_layout() {
|
||||
if let LayoutQuery::ClientRects { source } = query
|
||||
&& let Some(rects) =
|
||||
crate::layout_renderer::svg_client_rect(runtime, document, *source)?
|
||||
{
|
||||
return Ok(LayoutQueryAnswer::ClientRects(rects));
|
||||
}
|
||||
runtime.answer_layout_query_for_document(document, query)
|
||||
} else {
|
||||
Ok(answer_mock_query(runtime, document, query))
|
||||
@@ -66,7 +72,16 @@ pub(crate) fn published_geometry_batch(
|
||||
batch: &LayoutQueryBatch<DomHandle>,
|
||||
) -> Result<LayoutAnswers<DomHandle>, LayoutError> {
|
||||
if runtime.layout_policy().uses_real_layout() {
|
||||
runtime.answer_layout_for_document(document, batch)
|
||||
let mut answers = runtime.answer_layout_for_document(document, batch)?;
|
||||
for (query, answer) in batch.queries.iter().zip(&mut answers.answers) {
|
||||
if let LayoutQuery::ClientRects { source } = query
|
||||
&& let Some(rects) =
|
||||
crate::layout_renderer::svg_client_rect(runtime, document, *source)?
|
||||
{
|
||||
*answer = LayoutQueryAnswer::ClientRects(rects);
|
||||
}
|
||||
}
|
||||
Ok(answers)
|
||||
} else {
|
||||
Ok(answer_mock_queries(
|
||||
runtime,
|
||||
|
||||
@@ -1,5 +1,126 @@
|
||||
use super::*;
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn inline_svg_client_rects_include_graphics_text_and_viewport_transforms() {
|
||||
run_page_vm_async_test(async move {
|
||||
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
|
||||
let mut page_vm = test_page_vm_with_loader_and_document_url(
|
||||
&loader, Vec::new(), Url::parse("https://example.com/svg-client-rects.html")?,
|
||||
);
|
||||
page_vm.vm_mut().eval(&format!(
|
||||
"document.documentElement.innerHTML = {}; 'installed'",
|
||||
serde_json::to_string(include_str!(concat!(env!("CARGO_MANIFEST_DIR"), "/tests/fixtures/inline-svg-client-rects.html")))?,
|
||||
))?;
|
||||
page_vm.vm_mut().sync_live_document_style_sources();
|
||||
page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(400, 300, 1.0))?;
|
||||
let result = page_vm.vm_mut().eval(r#"JSON.stringify(Object.fromEntries(
|
||||
['scene','shape','axis','hidden','transparent','nested','nested-shape','clipped','label','group'].map(id => {
|
||||
const e=document.getElementById(id), r=e.getBoundingClientRect();
|
||||
return [id, {rect:[r.x,r.y,r.width,r.height],count:e.getClientRects().length}];
|
||||
})))"#)?;
|
||||
let values: serde_json::Value = serde_json::from_str(&result)?;
|
||||
// Chromium 145.0.7632.116, with the same fixture and installed font.
|
||||
for (id, expected) in [
|
||||
("scene", [40.0, 30.0, 300.0, 200.0]),
|
||||
("shape", [70.0, 84.0, 60.0, 30.0]),
|
||||
("axis", [70.0, 144.0, 160.0, 0.0]),
|
||||
("transparent", [240.0, 50.0, 40.0, 20.0]),
|
||||
("nested", [188.0, 122.0, 40.0, 20.0]),
|
||||
("nested-shape", [188.0, 122.0, 40.0, 20.0]),
|
||||
("clipped", [60.0, 40.0, 40.0, 20.0]),
|
||||
] {
|
||||
for (actual, expected) in values[id]["rect"].as_array().unwrap().iter().zip(expected) {
|
||||
assert!((actual.as_f64().unwrap() - expected).abs() < 0.01, "{id}: {values}");
|
||||
}
|
||||
assert_eq!(values[id]["count"], 1);
|
||||
}
|
||||
assert_eq!(values["hidden"]["count"], 0, "{values}");
|
||||
assert_eq!(values["hidden"]["rect"], json!([0,0,0,0]));
|
||||
assert!(values["label"]["rect"][2].as_f64().unwrap() > 100.0, "text must be shaped: {values}");
|
||||
assert!(values["label"]["rect"][3].as_f64().unwrap() > 30.0, "text must be shaped: {values}");
|
||||
assert!(values["group"]["rect"][3].as_f64().unwrap() > 120.0, "group must include text: {values}");
|
||||
|
||||
assert_eq!(page_vm.vm_mut().eval("document.getElementById('shape').getAttribute('fill')")?, "none", "geometry projection must not change authored paint");
|
||||
page_vm.vm_mut().eval("document.getElementById('scene').style.cssText += ';transform:translate(11px,13px) scale(2);transform-origin:0 0'; 'changed'")?;
|
||||
page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(800, 600, 1.0))?;
|
||||
assert_eq!(page_vm.vm_mut().eval("JSON.stringify((r=>[r.x,r.y,r.width,r.height])(document.getElementById('shape').getBoundingClientRect()))")?, "[111,151,120,60]");
|
||||
page_vm.vm_mut().eval("document.getElementById('scene').style.transform = 'matrix(2,0,0,2,11,13)'; 'changed'")?;
|
||||
page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(800, 600, 1.0))?;
|
||||
assert_eq!(page_vm.vm_mut().eval("JSON.stringify((r=>[r.x,r.y,r.width,r.height])(document.getElementById('shape').getBoundingClientRect()))")?, "[111,151,120,60]", "outer CSS transforms must be applied once");
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("SVG client rects must include object geometry");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn inline_svg_chart_can_size_itself_from_group_and_text_client_rects() {
|
||||
run_page_vm_async_test(async move {
|
||||
let loader = crate::network::ResourceRequestClient::new(&FetchConfig::default())?;
|
||||
let mut page_vm = test_page_vm_with_loader_and_document_url(
|
||||
&loader, Vec::new(), Url::parse("https://example.com/svg-measured-chart.html")?,
|
||||
);
|
||||
page_vm.vm_mut().eval(r##"
|
||||
document.head.innerHTML = `<style>
|
||||
html,body {margin:0;background:white}
|
||||
svg {display:block;font:12px "DejaVu Sans"}
|
||||
.axis {stroke:rgb(17,99,41);stroke-width:2px}
|
||||
.label {fill:rgb(89,99,110);font-size:12px}
|
||||
.hidden {display:none}
|
||||
</style>`;
|
||||
document.body.innerHTML = `<svg xmlns="http://www.w3.org/2000/svg"><g>
|
||||
<line class="axis" x1="10" y1="125" x2="240" y2="125"/>
|
||||
<line class="axis" x1="125" y1="10" x2="125" y2="240"/>
|
||||
<path fill="#40c463" d="M125 125 L125 154 L14 125 Z"/>
|
||||
<ellipse class="hidden" cx="500" cy="500" rx="5" ry="5"/>
|
||||
<text class="label" x="125" y="0" text-anchor="middle">Code review</text>
|
||||
<text class="label" x="250" y="125">Issues</text>
|
||||
<text class="label" x="125" y="255" text-anchor="middle">Pull requests</text>
|
||||
<text class="label" x="0" y="125" text-anchor="end">Commits</text>
|
||||
</g></svg>`;
|
||||
'installed'
|
||||
"##)?;
|
||||
page_vm.vm_mut().sync_live_document_style_sources();
|
||||
let result = page_vm.vm_mut().eval(r#"(() => {
|
||||
const svg=document.querySelector('svg'), g=svg.querySelector('g');
|
||||
const rect=g.getBoundingClientRect(), outer=svg.getBoundingClientRect();
|
||||
g.setAttribute('transform', `translate(${-rect.left+outer.left} ${-rect.top+outer.top})`);
|
||||
svg.setAttribute('width', Math.ceil(rect.width));
|
||||
svg.setAttribute('height', Math.ceil(rect.height));
|
||||
return JSON.stringify([rect.width,rect.height]);
|
||||
})()"#)?;
|
||||
let size: Vec<f64> = serde_json::from_str(&result)?;
|
||||
assert!(size[0] > 280.0 && size[0] < 400.0, "chart width: {result}");
|
||||
assert!(size[1] > 250.0 && size[1] < 300.0, "chart height: {result}");
|
||||
let snapshot = page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(400, 300, 1.0))?.unwrap();
|
||||
let raster = moli_paint::raster_snapshot(&snapshot)?;
|
||||
// Text bounds give the group a fractional translation. Measure the
|
||||
// antialiased color coverage over white, without requiring axes and
|
||||
// glyphs to land on whole pixels in every font rasterizer.
|
||||
let color_coverage = |color: [u8; 3]| {
|
||||
raster.rgba.chunks_exact(4).map(|pixel| {
|
||||
let alpha = f64::from(255 - pixel[0]) / f64::from(255 - color[0]);
|
||||
if (1..3).all(|channel| {
|
||||
(f64::from(pixel[channel]) - (255.0 - alpha * f64::from(255 - color[channel]))).abs() < 2.0
|
||||
}) { alpha } else { 0.0 }
|
||||
}).sum::<f64>()
|
||||
};
|
||||
assert!(color_coverage([64,196,99]) > 500.0, "measured SVG must paint the area");
|
||||
assert!(color_coverage([17,99,41]) > 400.0, "external CSS must paint both axes: {}", color_coverage([17,99,41]));
|
||||
assert!(color_coverage([89,99,110]) > 50.0, "external CSS must paint the labels");
|
||||
assert_eq!(page_vm.vm_mut().eval("document.querySelector('svg g').hasAttribute('id')")?, "false", "query identifiers must not leak into the live DOM");
|
||||
|
||||
// Referenced shapes outside <defs> must still inherit from <use>,
|
||||
// rather than freezing the source element's original inherited fill.
|
||||
page_vm.vm_mut().eval(r##"document.body.innerHTML = '<svg width="80" height="40" style="fill:blue"><rect id="shared" width="20" height="20"/><use href="#shared" x="30" style="fill:red"/></svg>'; 'installed'"##)?;
|
||||
page_vm.vm_mut().sync_live_document_style_sources();
|
||||
let snapshot = page_vm.vm_mut().screenshot_layout_snapshot(moli_layout::PaintViewport::new(80,40,1.0))?.unwrap();
|
||||
let raster = moli_paint::raster_snapshot(&snapshot)?;
|
||||
let pixel = |x: usize, y: usize| &raster.rgba[(y * raster.width as usize + x) * 4..][..4];
|
||||
assert_eq!(pixel(10,10), [0,0,255,255]);
|
||||
assert_eq!(pixel(40,10), [255,0,0,255]);
|
||||
Ok::<_, anyhow::Error>(())
|
||||
}).await.expect("SVG chart must measure and paint its group");
|
||||
}
|
||||
|
||||
#[tokio::test(flavor = "current_thread")]
|
||||
async fn screenshot_sizes_viewbox_only_svg_from_available_inline_space() {
|
||||
run_page_vm_async_test(async move {
|
||||
|
||||
@@ -2911,6 +2911,9 @@ const rect = span.getBoundingClientRect();
|
||||
const circle = container.querySelector('circle');
|
||||
yield;
|
||||
const rect = circle.getBoundingClientRect();
|
||||
// Chromium 145: SVG graphics expose their transformed object rectangle,
|
||||
// even though hit testing still resolves to the outer replaced SVG here.
|
||||
check('svg-circle-rect', rect.left === 8 && rect.top === 8 && rect.width === 100 && rect.height === 100);
|
||||
const pos = document.caretPositionFromPoint(50, 50);
|
||||
check('svg-circle', pos instanceof CaretPosition && pos.offsetNode === circle && pos.offset === 0, `${labelNode(pos && pos.offsetNode)},${circle.namespaceURI},${rect.left},${rect.top},${rect.width},${rect.height}`);
|
||||
}
|
||||
@@ -3001,7 +3004,7 @@ const rect = span.getBoundingClientRect();
|
||||
|
||||
assert_eq!(
|
||||
result,
|
||||
"bad-options:pass|light-text:pass|light-text-rect:pass|inline-block-text-rect:pass|sheet-inline-block-text-rect:pass|svg-circle:fail:svg#:1,http://www.w3.org/2000/svg,0,0,0,0|post-svg-text-rect:pass|input:pass|textarea-wrap:fail|textarea-forced:fail:10,23.75,28,63,60|closed-allowed:pass|shadow-hidden:pass|shadow-hidden-rect:pass|shadow-allowed:pass|nested-hidden:pass|nested-inner:pass|nested-outer:pass|nested-both:pass"
|
||||
"bad-options:pass|light-text:pass|light-text-rect:pass|inline-block-text-rect:pass|sheet-inline-block-text-rect:pass|svg-circle-rect:pass|svg-circle:fail:svg#:1,http://www.w3.org/2000/svg,8,8,100,100|post-svg-text-rect:pass|input:pass|textarea-wrap:fail|textarea-forced:fail:10,23.75,28,63,60|closed-allowed:pass|shadow-hidden:pass|shadow-hidden-rect:pass|shadow-allowed:pass|nested-hidden:pass|nested-inner:pass|nested-outer:pass|nested-both:pass"
|
||||
);
|
||||
}
|
||||
#[test]
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
<!doctype html><style>html,body{margin:0}svg{position:absolute;left:40px;top:30px;display:block} .hidden{display:none} .label{font:16px "DejaVu Sans Mono";fill:#234} .axis{stroke:rgb(0,128,0);stroke-width:4px}</style><svg id="scene" width="300" height="200" viewBox="0 0 150 100"><g id="group" transform="translate(5 7)"><rect id="shape" x="10" y="20" width="30" height="15" fill="none" stroke="red" stroke-width="8"/><line id="axis" class="axis" x1="10" y1="50" x2="90" y2="50"/><text id="label" class="label" x="10" y="80">Review</text></g><rect id="hidden" class="hidden" x="70" y="10" width="20" height="20"/><g id="transparent" opacity="0"><rect width="20" height="10" x="100" y="10"/></g><svg id="nested" x="70" y="40" width="60" height="30" viewBox="0 0 30 15"><rect id="nested-shape" x="2" y="3" width="10" height="5"/></svg><rect id="clipped" x="10" y="5" width="20" height="10" clip-path="url(#clip)"/><defs><clipPath id="clip"><rect width="1" height="1"/></clipPath></defs></svg>
|
||||
Reference in New Issue
Block a user