dmaax/ladybird
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
ladybird/Libraries/LibWeb/SVG/SVGPatternElement.cpp
Aliaksandr Kalenik b36e6c9b97 Compositor+LibWeb: Pass AVC trees separately from display lists 
Display lists owned the accumulated visual context tree through a
ref-counted pointer. That tied visual-context state to display-list
lifetime and made compositor updates treat the two as one unit, even
though AVC trees need to become independently updateable compositor
state.

Make accumulated visual context trees plain versioned values, have each
display list store the compatible tree version, and pass the matching
tree alongside display-list updates and replay calls. Replay verifies
that the provided tree matches the display list before executing it.

This prepares the compositor for receiving AVC tree updates separately
from display-list updates: it now accepts the tree as a separate update
parameter, stores it next to the display list, and uses that stored tree
for replay and async-scroll hit testing. Nested display-list resources
carry their own tree snapshots for the same version check.
2026-05-27 18:29:42 +01:00

374 lines
16 KiB
C++
Raw Blame History

/*
* Copyright (c) 2026, Tim Ledbetter <tim.ledbetter@ladybird.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGfx/Matrix4x4.h>
#include <LibWeb/Bindings/Intrinsics.h>
#include <LibWeb/Bindings/SVGPatternElement.h>
#include <LibWeb/CSS/ComputedProperties.h>
#include <LibWeb/DOM/Document.h>
#include <LibWeb/Layout/SVGPatternBox.h>
#include <LibWeb/Layout/SVGSVGBox.h>
#include <LibWeb/Painting/DisplayList.h>
#include <LibWeb/Painting/DisplayListRecorder.h>
#include <LibWeb/Painting/DisplayListRecordingContext.h>
#include <LibWeb/Painting/PaintStyle.h>
#include <LibWeb/Painting/SVGGraphicsPaintable.h>
#include <LibWeb/Painting/StackingContext.h>
#include <LibWeb/SVG/AttributeNames.h>
#include <LibWeb/SVG/AttributeParser.h>
#include <LibWeb/SVG/SVGGraphicsElement.h>
#include <LibWeb/SVG/SVGPatternElement.h>
namespace Web::SVG {
GC_DEFINE_ALLOCATOR(SVGPatternElement);
SVGPatternElement::SVGPatternElement(DOM::Document& document, DOM::QualifiedName qualified_name)
: SVGElement(document, move(qualified_name))
{
}
void SVGPatternElement::initialize(JS::Realm& realm)
{
WEB_SET_PROTOTYPE_FOR_INTERFACE(SVGPatternElement);
Base::initialize(realm);
SVGFitToViewBox::initialize(realm);
}
void SVGPatternElement::visit_edges(Cell::Visitor& visitor)
{
Base::visit_edges(visitor);
SVGURIReferenceMixin::visit_edges(visitor);
SVGFitToViewBox::visit_edges(visitor);
}
void SVGPatternElement::attribute_changed(FlyString const& name, Optional<String> const& old_value, Optional<String> const& value, Optional<FlyString> const& namespace_)
{
Base::attribute_changed(name, old_value, value, namespace_);
SVGFitToViewBox::attribute_changed(*this, name, value);
if (name == AttributeNames::patternUnits) {
m_pattern_units = AttributeParser::parse_units(value.value_or(String {}));
} else if (name == AttributeNames::patternContentUnits) {
m_pattern_content_units = AttributeParser::parse_units(value.value_or(String {}));
} else if (name == AttributeNames::patternTransform) {
if (auto transform_list = AttributeParser::parse_transform(value.value_or(String {})); transform_list.has_value()) {
m_pattern_transform = transform_from_transform_list(*transform_list);
} else {
m_pattern_transform = {};
}
} else if (name == AttributeNames::x) {
m_x = AttributeParser::parse_number_percentage(value.value_or(String {}));
} else if (name == AttributeNames::y) {
m_y = AttributeParser::parse_number_percentage(value.value_or(String {}));
} else if (name == AttributeNames::width) {
m_width = AttributeParser::parse_number_percentage(value.value_or(String {}));
} else if (name == AttributeNames::height) {
m_height = AttributeParser::parse_number_percentage(value.value_or(String {}));
}
}
GC::Ptr<SVGPatternElement const> SVGPatternElement::linked_pattern(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
// FIXME: This can only resolve same-document references. The spec allows cross-document references.
auto link = has_attribute(AttributeNames::href) ? get_attribute(AttributeNames::href) : get_attribute("xlink:href"_fly_string);
if (!link.has_value() || link->is_empty())
return {};
auto url = document().encoding_parse_url(*link);
if (!url.has_value())
return {};
auto id = url->fragment();
if (!id.has_value() || id->is_empty())
return {};
auto element = document().get_element_by_id(id.value());
if (!element)
return {};
if (element == this)
return {};
auto* pattern = as_if<SVGPatternElement>(*element);
if (!pattern)
return {};
// Detect circular references in the template chain.
if (seen_patterns.set(pattern) != AK::HashSetResult::InsertedNewEntry)
return {};
return pattern;
}
GC::Ptr<SVGPatternElement const> SVGPatternElement::pattern_content_element() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_content_element_impl(seen_patterns);
}
GC::Ptr<SVGPatternElement const> SVGPatternElement::pattern_content_element_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (child_element_count() > 0)
return this;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_content_element_impl(seen_patterns);
return {};
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementPatternUnitsAttribute
SVGUnits SVGPatternElement::pattern_units() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_units_impl(seen_patterns);
}
SVGUnits SVGPatternElement::pattern_units_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_pattern_units.has_value())
return *m_pattern_units;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_units_impl(seen_patterns);
// Initial value: objectBoundingBox
return SVGUnits::ObjectBoundingBox;
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementPatternContentUnitsAttribute
SVGUnits SVGPatternElement::pattern_content_units() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_content_units_impl(seen_patterns);
}
SVGUnits SVGPatternElement::pattern_content_units_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_pattern_content_units.has_value())
return *m_pattern_content_units;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_content_units_impl(seen_patterns);
// Initial value: userSpaceOnUse
return SVGUnits::UserSpaceOnUse;
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementPatternTransformAttribute
Optional<Gfx::AffineTransform> SVGPatternElement::pattern_transform() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_transform_impl(seen_patterns);
}
Optional<Gfx::AffineTransform> SVGPatternElement::pattern_transform_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_pattern_transform.has_value())
return m_pattern_transform;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_transform_impl(seen_patterns);
return {};
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementXAttribute
NumberPercentage SVGPatternElement::pattern_x() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_x_impl(seen_patterns);
}
NumberPercentage SVGPatternElement::pattern_x_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_x.has_value())
return *m_x;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_x_impl(seen_patterns);
return NumberPercentage::create_number(0);
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementYAttribute
NumberPercentage SVGPatternElement::pattern_y() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_y_impl(seen_patterns);
}
NumberPercentage SVGPatternElement::pattern_y_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_y.has_value())
return *m_y;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_y_impl(seen_patterns);
return NumberPercentage::create_number(0);
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementWidthAttribute
NumberPercentage SVGPatternElement::pattern_width() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_width_impl(seen_patterns);
}
NumberPercentage SVGPatternElement::pattern_width_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_width.has_value())
return *m_width;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_width_impl(seen_patterns);
return NumberPercentage::create_number(0);
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementHeightAttribute
NumberPercentage SVGPatternElement::pattern_height() const
{
GC::RootHashTable<SVGPatternElement const*> seen_patterns;
return pattern_height_impl(seen_patterns);
}
NumberPercentage SVGPatternElement::pattern_height_impl(GC::RootHashTable<SVGPatternElement const*>& seen_patterns) const
{
if (m_height.has_value())
return *m_height;
if (auto pattern = linked_pattern(seen_patterns))
return pattern->pattern_height_impl(seen_patterns);
return NumberPercentage::create_number(0);
}
Optional<Painting::PaintStyle> SVGPatternElement::to_gfx_paint_style(SVGPaintContext const& paint_context, DisplayListRecordingContext& recording_context, Layout::Node const& target_layout_node) const
{
auto content_element = pattern_content_element();
if (!content_element)
return {};
Layout::SVGPatternBox const* pattern_box = nullptr;
target_layout_node.for_each_child_of_type<Layout::SVGPatternBox>([&](auto const& candidate) {
if (&candidate.dom_node() == content_element.ptr()) {
pattern_box = &candidate;
return IterationDecision::Break;
}
return IterationDecision::Continue;
});
if (!pattern_box)
return {};
auto pattern_paintable = pattern_box->paintable_box();
if (!pattern_paintable)
return {};
float tile_x = 0;
float tile_y = 0;
float tile_width = 0;
float tile_height = 0;
if (pattern_units() == SVGUnits::ObjectBoundingBox) {
// For objectBoundingBox, values are fractions of the bounding box.
// NumberPercentage::value() already normalizes percentages to 0-1 range.
auto const& bbox = paint_context.path_bounding_box;
tile_x = pattern_x().value() * bbox.width() + bbox.x();
tile_y = pattern_y().value() * bbox.height() + bbox.y();
tile_width = pattern_width().value() * bbox.width();
tile_height = pattern_height().value() * bbox.height();
} else {
// For userSpaceOnUse, resolve percentages relative to the viewport.
auto const& viewport = paint_context.viewport;
tile_x = pattern_x().resolve_relative_to(viewport.width());
tile_y = pattern_y().resolve_relative_to(viewport.height());
tile_width = pattern_width().resolve_relative_to(viewport.width());
tile_height = pattern_height().resolve_relative_to(viewport.height());
}
if (tile_width <= 0 || tile_height <= 0)
return {};
auto tile_rect = paint_context.paint_transform.map(Gfx::FloatRect { tile_x, tile_y, tile_width, tile_height });
if (tile_rect.is_empty())
return {};
auto const* svg_node = target_layout_node.first_ancestor_of_type<Layout::SVGSVGBox>();
if (!svg_node || !svg_node->paintable_box())
return {};
auto svg_element_rect = svg_node->paintable_box()->absolute_rect();
auto svg_offset = recording_context.rounded_device_point(svg_element_rect.location()).to_type<int>().to_type<float>();
tile_rect.translate_by(svg_offset);
auto visual_context_tree = Painting::AccumulatedVisualContextTree::create();
auto display_list = Painting::DisplayList::create(visual_context_tree);
Painting::DisplayListRecorder display_list_recorder(*display_list, visual_context_tree, recording_context.display_list_recorder().resource_storage());
auto content_origin = paint_context.paint_transform.map(Gfx::FloatPoint { 0, 0 }) + svg_offset;
display_list_recorder.translate(-Gfx::IntPoint(content_origin.to_type<int>()));
auto paint_context_copy = recording_context.clone(display_list_recorder);
Gfx::AffineTransform target_svg_transform;
auto first_paintable = target_layout_node.first_paintable();
if (auto const* svg_graphics_paintable = as_if<Painting::SVGGraphicsPaintable>(first_paintable.ptr()))
target_svg_transform = svg_graphics_paintable->computed_transforms().svg_transform();
paint_context_copy.set_svg_transform(target_svg_transform);
Painting::StackingContext::paint_svg(paint_context_copy, *pattern_paintable, Painting::PaintPhase::Foreground);
Optional<Gfx::AffineTransform> user_space_pattern_transform;
auto css_transformations = computed_properties()->transformations();
if (!css_transformations.is_empty()) {
auto matrix = Gfx::FloatMatrix4x4::identity();
for (auto const& css_transform : css_transformations)
matrix = matrix * css_transform->to_matrix(*pattern_paintable);
user_space_pattern_transform = extract_2d_affine_transform(matrix);
} else {
user_space_pattern_transform = pattern_transform();
}
Optional<Gfx::AffineTransform> device_pattern_transform;
if (user_space_pattern_transform.has_value()) {
if (!user_space_pattern_transform->inverse().has_value())
return {};
// patternTransform is defined in user space, but the tile rect and shader operate in device pixel space.
// Convert by conjugating with paint_transform.
if (auto inv = paint_context.paint_transform.inverse(); inv.has_value()) {
auto transform = paint_context.paint_transform;
device_pattern_transform = transform.multiply(*user_space_pattern_transform).multiply(*inv);
}
}
return Painting::PaintStyle { Painting::PatternPaintStyle { { *display_list, move(visual_context_tree) }, tile_rect, device_pattern_transform } };
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementXAttribute
GC::Ref<SVGAnimatedLength> SVGPatternElement::x() const
{
// FIXME: Populate the unit type when it is parsed (0 here is "unknown").
// FIXME: Create a proper animated value when animations are supported.
auto base_length = SVGLength::create(realm(), 0, m_x.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::No);
auto anim_length = SVGLength::create(realm(), 0, m_x.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::Yes);
return SVGAnimatedLength::create(realm(), base_length, anim_length);
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementYAttribute
GC::Ref<SVGAnimatedLength> SVGPatternElement::y() const
{
// FIXME: Populate the unit type when it is parsed (0 here is "unknown").
// FIXME: Create a proper animated value when animations are supported.
auto base_length = SVGLength::create(realm(), 0, m_y.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::No);
auto anim_length = SVGLength::create(realm(), 0, m_y.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::Yes);
return SVGAnimatedLength::create(realm(), base_length, anim_length);
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementWidthAttribute
GC::Ref<SVGAnimatedLength> SVGPatternElement::width() const
{
// FIXME: Populate the unit type when it is parsed (0 here is "unknown").
// FIXME: Create a proper animated value when animations are supported.
auto base_length = SVGLength::create(realm(), 0, m_width.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::No);
auto anim_length = SVGLength::create(realm(), 0, m_width.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::Yes);
return SVGAnimatedLength::create(realm(), base_length, anim_length);
}
// https://svgwg.org/svg2-draft/pservers.html#PatternElementHeightAttribute
GC::Ref<SVGAnimatedLength> SVGPatternElement::height() const
{
// FIXME: Populate the unit type when it is parsed (0 here is "unknown").
// FIXME: Create a proper animated value when animations are supported.
auto base_length = SVGLength::create(realm(), 0, m_height.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::No);
auto anim_length = SVGLength::create(realm(), 0, m_height.value_or(NumberPercentage::create_number(0)).value(), SVGLength::ReadOnly::Yes);
return SVGAnimatedLength::create(realm(), base_length, anim_length);
}
}
Reference in a new issue View git blame Copy permalink