Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-12-07 21:59:54 +00:00
Code Issues Projects Releases Packages Wiki Activity

LibWeb: Rename PaintContext to DisplayListRecordingContext

Browse source 
PaintContext dates back to a time when display lists didn't exist and it
truly represented "paint context". Renaming it to better align with its
current role.
This commit is contained in:
Aliaksandr Kalenik 2025-07-31 23:07:26 +02:00 • committed by Alexander Kalenik
parent 1001ff2599
commit 61114f6d16
Notes: github-actions[bot] 2025-08-01 09:27:48 +00:00
65 changed files with 160 additions and 174 deletions
Download patch file Download diff file Expand all files Collapse all files

2
Libraries/LibWeb/CMakeLists.txt
View file

@ -729,6 +729,7 @@ set(SOURCES
Painting/DisplayList.cpp Painting/DisplayList.cpp
Painting/DisplayListPlayerSkia.cpp Painting/DisplayListPlayerSkia.cpp
Painting/DisplayListRecorder.cpp Painting/DisplayListRecorder.cpp
Painting/DisplayListRecordingContext.cpp
Painting/FieldSetPaintable.cpp Painting/FieldSetPaintable.cpp
Painting/GradientPainting.cpp Painting/GradientPainting.cpp
Painting/ImagePaintable.cpp Painting/ImagePaintable.cpp
@ -739,7 +740,6 @@ set(SOURCES
Painting/Paintable.cpp Painting/Paintable.cpp
Painting/PaintableBox.cpp Painting/PaintableBox.cpp
Painting/PaintableFragment.cpp Painting/PaintableFragment.cpp
Painting/PaintContext.cpp
Painting/RadioButtonPaintable.cpp Painting/RadioButtonPaintable.cpp
Painting/ScrollFrame.cpp Painting/ScrollFrame.cpp
Painting/ScrollState.cpp Painting/ScrollState.cpp

2
Libraries/LibWeb/CSS/StyleValues/AbstractImageStyleValue.h
View file

@ -37,7 +37,7 @@ public:
virtual void resolve_for_size(Layout::NodeWithStyle const&, CSSPixelSize) const { } virtual void resolve_for_size(Layout::NodeWithStyle const&, CSSPixelSize) const { }
virtual bool is_paintable() const = 0; virtual bool is_paintable() const = 0;
virtual void paint(PaintContext& context, DevicePixelRect const& dest_rect, ImageRendering) const = 0; virtual void paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, ImageRendering) const = 0;
virtual Optional<Gfx::Color> color_if_single_pixel_bitmap() const { return {}; } virtual Optional<Gfx::Color> color_if_single_pixel_bitmap() const { return {}; }
}; };

2
Libraries/LibWeb/CSS/StyleValues/ConicGradientStyleValue.cpp
View file

@ -56,7 +56,7 @@ void ConicGradientStyleValue::resolve_for_size(Layout::NodeWithStyle const& node
m_resolved->position = m_properties.position->resolved(node, CSSPixelRect { { 0, 0 }, size }); m_resolved->position = m_properties.position->resolved(node, CSSPixelRect { { 0, 0 }, size });
} }
void ConicGradientStyleValue::paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const void ConicGradientStyleValue::paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const
{ {
VERIFY(m_resolved.has_value()); VERIFY(m_resolved.has_value());
auto destination_rect = dest_rect.to_type<int>(); auto destination_rect = dest_rect.to_type<int>();

2
Libraries/LibWeb/CSS/StyleValues/ConicGradientStyleValue.h
View file

@ -26,7 +26,7 @@ public:
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
void paint(PaintContext&, DevicePixelRect const& dest_rect, CSS::ImageRendering) const override; void paint(DisplayListRecordingContext&, DevicePixelRect const& dest_rect, CSS::ImageRendering) const override;
virtual bool equals(CSSStyleValue const& other) const override; virtual bool equals(CSSStyleValue const& other) const override;

2
Libraries/LibWeb/CSS/StyleValues/CursorStyleValue.cpp
View file

@ -84,7 +84,7 @@ Optional<Gfx::ImageCursor> CursorStyleValue::make_image_cursor(Layout::NodeWithS
// Paint the cursor into a bitmap. // Paint the cursor into a bitmap.
auto display_list = Painting::DisplayList::create(document.page().client().device_pixels_per_css_pixel()); auto display_list = Painting::DisplayList::create(document.page().client().device_pixels_per_css_pixel());
Painting::DisplayListRecorder display_list_recorder(display_list); Painting::DisplayListRecorder display_list_recorder(display_list);
PaintContext paint_context { display_list_recorder, document.page().palette(), document.page().client().device_pixels_per_css_pixel() }; DisplayListRecordingContext paint_context { display_list_recorder, document.page().palette(), document.page().client().device_pixels_per_css_pixel() };
image.resolve_for_size(layout_node, CSSPixelSize { bitmap.size() }); image.resolve_for_size(layout_node, CSSPixelSize { bitmap.size() });
image.paint(paint_context, DevicePixelRect { bitmap.rect() }, ImageRendering::Auto); image.paint(paint_context, DevicePixelRect { bitmap.rect() }, ImageRendering::Auto);

4
Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.cpp
View file

@ -16,7 +16,7 @@
#include <LibWeb/HTML/PotentialCORSRequest.h> #include <LibWeb/HTML/PotentialCORSRequest.h>
#include <LibWeb/HTML/SharedResourceRequest.h> #include <LibWeb/HTML/SharedResourceRequest.h>
#include <LibWeb/Painting/DisplayListRecorder.h> #include <LibWeb/Painting/DisplayListRecorder.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
#include <LibWeb/Platform/Timer.h> #include <LibWeb/Platform/Timer.h>
namespace Web::CSS { namespace Web::CSS {
@ -150,7 +150,7 @@ Optional<CSSPixelFraction> ImageStyleValue::natural_aspect_ratio() const
return {}; return {};
} }
void ImageStyleValue::paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const void ImageStyleValue::paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const
{ {
if (auto const* b = bitmap(m_current_frame_index, dest_rect.size().to_type<int>()); b != nullptr) { if (auto const* b = bitmap(m_current_frame_index, dest_rect.size().to_type<int>()); b != nullptr) {
auto scaling_mode = to_gfx_scaling_mode(image_rendering, b->rect(), dest_rect.to_type<int>()); auto scaling_mode = to_gfx_scaling_mode(image_rendering, b->rect(), dest_rect.to_type<int>());

2
Libraries/LibWeb/CSS/StyleValues/ImageStyleValue.h
View file

@ -52,7 +52,7 @@ public:
Optional<CSSPixelFraction> natural_aspect_ratio() const override; Optional<CSSPixelFraction> natural_aspect_ratio() const override;
virtual bool is_paintable() const override; virtual bool is_paintable() const override;
void paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const override; void paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const override;
virtual Optional<Gfx::Color> color_if_single_pixel_bitmap() const override; virtual Optional<Gfx::Color> color_if_single_pixel_bitmap() const override;
Gfx::ImmutableBitmap const* current_frame_bitmap(DevicePixelRect const& dest_rect) const; Gfx::ImmutableBitmap const* current_frame_bitmap(DevicePixelRect const& dest_rect) const;

2
Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.cpp
View file

@ -131,7 +131,7 @@ void LinearGradientStyleValue::resolve_for_size(Layout::NodeWithStyle const& nod
} }
} }
void LinearGradientStyleValue::paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const void LinearGradientStyleValue::paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const
{ {
VERIFY(m_resolved.has_value()); VERIFY(m_resolved.has_value());
context.display_list_recorder().fill_rect_with_linear_gradient(dest_rect.to_type<int>(), m_resolved.value()); context.display_list_recorder().fill_rect_with_linear_gradient(dest_rect.to_type<int>(), m_resolved.value());

2
Libraries/LibWeb/CSS/StyleValues/LinearGradientStyleValue.h
View file

@ -73,7 +73,7 @@ public:
void resolve_for_size(Layout::NodeWithStyle const&, CSSPixelSize) const override; void resolve_for_size(Layout::NodeWithStyle const&, CSSPixelSize) const override;
bool is_paintable() const override { return true; } bool is_paintable() const override { return true; }
void paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const override; void paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering image_rendering) const override;
private: private:
LinearGradientStyleValue(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax) LinearGradientStyleValue(GradientDirection direction, Vector<LinearColorStopListElement> color_stop_list, GradientType type, GradientRepeating repeating, Optional<InterpolationMethod> interpolation_method, ColorSyntax color_syntax)

2
Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.cpp
View file

@ -246,7 +246,7 @@ bool RadialGradientStyleValue::equals(CSSStyleValue const& other) const
return m_properties == other_gradient.m_properties; return m_properties == other_gradient.m_properties;
} }
void RadialGradientStyleValue::paint(PaintContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const void RadialGradientStyleValue::paint(DisplayListRecordingContext& context, DevicePixelRect const& dest_rect, CSS::ImageRendering) const
{ {
VERIFY(m_resolved.has_value()); VERIFY(m_resolved.has_value());
auto center = context.rounded_device_point(m_resolved->center).to_type<int>(); auto center = context.rounded_device_point(m_resolved->center).to_type<int>();

2
Libraries/LibWeb/CSS/StyleValues/RadialGradientStyleValue.h
View file

@ -52,7 +52,7 @@ public:
virtual String to_string(SerializationMode) const override; virtual String to_string(SerializationMode) const override;
void paint(PaintContext&, DevicePixelRect const& dest_rect, CSS::ImageRendering) const override; void paint(DisplayListRecordingContext&, DevicePixelRect const& dest_rect, CSS::ImageRendering) const override;
virtual bool equals(CSSStyleValue const& other) const override; virtual bool equals(CSSStyleValue const& other) const override;

2
Libraries/LibWeb/DOM/Document.cpp
View file

@ -6461,7 +6461,7 @@ RefPtr<Painting::DisplayList> Document::record_display_list(HTML::PaintConfig co
VERIFY_NOT_REACHED(); VERIFY_NOT_REACHED();
} }
Web::PaintContext context(display_list_recorder, page().palette(), page().client().device_pixels_per_css_pixel()); Web::DisplayListRecordingContext context(display_list_recorder, page().palette(), page().client().device_pixels_per_css_pixel());
context.set_device_viewport_rect(viewport_rect); context.set_device_viewport_rect(viewport_rect);
context.set_should_show_line_box_borders(config.should_show_line_box_borders); context.set_should_show_line_box_borders(config.should_show_line_box_borders);
context.set_should_paint_overlay(config.paint_overlay); context.set_should_paint_overlay(config.paint_overlay);

2
Libraries/LibWeb/Forward.h
View file

@ -14,13 +14,13 @@
namespace Web { namespace Web {
class DisplayListRecordingContext;
class DragAndDropEventHandler; class DragAndDropEventHandler;
class EventHandler; class EventHandler;
class InputEventsTarget; class InputEventsTarget;
class LoadRequest; class LoadRequest;
class Page; class Page;
class PageClient; class PageClient;
class PaintContext;
class Resource; class Resource;
class ResourceLoader; class ResourceLoader;
class XMLDocumentBuilder; class XMLDocumentBuilder;

6
Libraries/LibWeb/Layout/Node.h
View file

@ -13,7 +13,7 @@
#include <LibWeb/CSS/StyleValues/ImageStyleValue.h> #include <LibWeb/CSS/StyleValues/ImageStyleValue.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
#include <LibWeb/Painting/Paintable.h> #include <LibWeb/Painting/Paintable.h>
#include <LibWeb/TreeNode.h> #include <LibWeb/TreeNode.h>
@ -152,7 +152,7 @@ public:
bool can_contain_boxes_with_position_absolute() const; bool can_contain_boxes_with_position_absolute() const;
Gfx::Font const& first_available_font() const; Gfx::Font const& first_available_font() const;
Gfx::Font const& font(PaintContext&) const; Gfx::Font const& font(DisplayListRecordingContext&) const;
Gfx::Font const& font(float scale_factor) const; Gfx::Font const& font(float scale_factor) const;
CSS::ImmutableComputedValues const& computed_values() const; CSS::ImmutableComputedValues const& computed_values() const;
@ -320,7 +320,7 @@ inline Gfx::Font const& Node::first_available_font() const
return parent()->first_available_font(); return parent()->first_available_font();
} }
inline Gfx::Font const& Node::font(PaintContext& context) const inline Gfx::Font const& Node::font(DisplayListRecordingContext& context) const
{ {
return font(context.device_pixels_per_css_pixel()); return font(context.device_pixels_per_css_pixel());
} }

2
Libraries/LibWeb/Painting/AudioPaintable.cpp
View file

@ -39,7 +39,7 @@ Layout::AudioBox const& AudioPaintable::layout_box() const
return static_cast<Layout::AudioBox const&>(layout_node()); return static_cast<Layout::AudioBox const&>(layout_node());
} }
void AudioPaintable::paint(PaintContext& context, PaintPhase phase) const void AudioPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/AudioPaintable.h
View file

@ -18,7 +18,7 @@ class AudioPaintable final : public MediaPaintable {
public: public:
static GC::Ref<AudioPaintable> create(Layout::AudioBox const&); static GC::Ref<AudioPaintable> create(Layout::AudioBox const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::AudioBox& layout_box(); Layout::AudioBox& layout_box();
Layout::AudioBox const& layout_box() const; Layout::AudioBox const& layout_box() const;

4
Libraries/LibWeb/Painting/BackgroundPainting.cpp
View file

@ -18,7 +18,7 @@
namespace Web::Painting { namespace Web::Painting {
static RefPtr<DisplayList> compute_text_clip_paths(PaintContext& context, Paintable const& paintable, CSSPixelPoint containing_block_location) static RefPtr<DisplayList> compute_text_clip_paths(DisplayListRecordingContext& context, Paintable const& paintable, CSSPixelPoint containing_block_location)
{ {
auto text_clip_paths = DisplayList::create(context.device_pixels_per_css_pixel()); auto text_clip_paths = DisplayList::create(context.device_pixels_per_css_pixel());
DisplayListRecorder display_list_recorder(*text_clip_paths); DisplayListRecorder display_list_recorder(*text_clip_paths);
@ -75,7 +75,7 @@ static BackgroundBox get_box(CSS::BackgroundBox box_clip, BackgroundBox border_b
} }
// https://www.w3.org/TR/css-backgrounds-3/#backgrounds // https://www.w3.org/TR/css-backgrounds-3/#backgrounds
void paint_background(PaintContext& context, PaintableBox const& paintable_box, CSS::ImageRendering image_rendering, ResolvedBackground resolved_background, BorderRadiiData const& border_radii) void paint_background(DisplayListRecordingContext& context, PaintableBox const& paintable_box, CSS::ImageRendering image_rendering, ResolvedBackground resolved_background, BorderRadiiData const& border_radii)
{ {
auto& display_list_recorder = context.display_list_recorder(); auto& display_list_recorder = context.display_list_recorder();

3
Libraries/LibWeb/Painting/BackgroundPainting.h
View file

@ -8,7 +8,6 @@
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
#include <LibWeb/Painting/BorderPainting.h> #include <LibWeb/Painting/BorderPainting.h>
#include <LibWeb/Painting/PaintContext.h>
namespace Web::Painting { namespace Web::Painting {
@ -48,6 +47,6 @@ struct ResolvedBackground {
ResolvedBackground resolve_background_layers(Vector<CSS::BackgroundLayerData> const& layers, PaintableBox const& paintable_box, Color background_color, CSSPixelRect const& border_rect, BorderRadiiData const& border_radii); ResolvedBackground resolve_background_layers(Vector<CSS::BackgroundLayerData> const& layers, PaintableBox const& paintable_box, Color background_color, CSSPixelRect const& border_rect, BorderRadiiData const& border_radii);
void paint_background(PaintContext&, PaintableBox const&, CSS::ImageRendering, ResolvedBackground resolved_background, BorderRadiiData const&); void paint_background(DisplayListRecordingContext&, PaintableBox const&, CSS::ImageRendering, ResolvedBackground resolved_background, BorderRadiiData const&);
} }

2
Libraries/LibWeb/Painting/BorderRadiiData.cpp
View file

@ -6,7 +6,7 @@
*/ */
#include <LibWeb/Painting/BorderRadiiData.h> #include <LibWeb/Painting/BorderRadiiData.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
namespace Web::Painting { namespace Web::Painting {

4
Libraries/LibWeb/Painting/BorderRadiusCornerClipper.cpp
View file

@ -6,11 +6,11 @@
#include <LibWeb/Painting/BorderRadiusCornerClipper.h> #include <LibWeb/Painting/BorderRadiusCornerClipper.h>
#include <LibWeb/Painting/DisplayListRecorder.h> #include <LibWeb/Painting/DisplayListRecorder.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
namespace Web::Painting { namespace Web::Painting {
ScopedCornerRadiusClip::ScopedCornerRadiusClip(PaintContext& context, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip, bool do_apply) ScopedCornerRadiusClip::ScopedCornerRadiusClip(DisplayListRecordingContext& context, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip, bool do_apply)
: m_context(context) : m_context(context)
{ {
m_do_apply = do_apply; m_do_apply = do_apply;

4
Libraries/LibWeb/Painting/BorderRadiusCornerClipper.h
View file

@ -16,7 +16,7 @@ enum class CornerClip {
}; };
struct ScopedCornerRadiusClip { struct ScopedCornerRadiusClip {
ScopedCornerRadiusClip(PaintContext& context, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip = CornerClip::Outside, bool do_apply = true); ScopedCornerRadiusClip(DisplayListRecordingContext& context, DevicePixelRect const& border_rect, BorderRadiiData const& border_radii, CornerClip corner_clip = CornerClip::Outside, bool do_apply = true);
~ScopedCornerRadiusClip(); ~ScopedCornerRadiusClip();
@ -24,7 +24,7 @@ struct ScopedCornerRadiusClip {
AK_MAKE_NONCOPYABLE(ScopedCornerRadiusClip); AK_MAKE_NONCOPYABLE(ScopedCornerRadiusClip);
private: private:
PaintContext& m_context; DisplayListRecordingContext& m_context;
bool m_has_radius { false }; bool m_has_radius { false };
bool m_do_apply; bool m_do_apply;
}; };

4
Libraries/LibWeb/Painting/BordersData.cpp
View file

@ -5,11 +5,11 @@
*/ */
#include <LibWeb/Painting/BordersData.h> #include <LibWeb/Painting/BordersData.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
namespace Web::Painting { namespace Web::Painting {
BordersDataDevicePixels BordersData::to_device_pixels(PaintContext const& context) const BordersDataDevicePixels BordersData::to_device_pixels(DisplayListRecordingContext const& context) const
{ {
return BordersDataDevicePixels { return BordersDataDevicePixels {
BorderDataDevicePixels { BorderDataDevicePixels {

2
Libraries/LibWeb/Painting/BordersData.h
View file

@ -34,7 +34,7 @@ struct BordersData {
CSS::BorderData bottom; CSS::BorderData bottom;
CSS::BorderData left; CSS::BorderData left;
BordersDataDevicePixels to_device_pixels(PaintContext const& context) const; BordersDataDevicePixels to_device_pixels(DisplayListRecordingContext const& context) const;
}; };
} }

3
Libraries/LibWeb/Painting/CanvasPaintable.cpp
View file

@ -4,7 +4,6 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include <LibWeb/HTML/TraversableNavigable.h>
#include <LibWeb/Painting/CanvasPaintable.h> #include <LibWeb/Painting/CanvasPaintable.h>
#include <LibWeb/Painting/DisplayListRecorder.h> #include <LibWeb/Painting/DisplayListRecorder.h>
@ -27,7 +26,7 @@ Layout::CanvasBox const& CanvasPaintable::layout_box() const
return static_cast<Layout::CanvasBox const&>(layout_node()); return static_cast<Layout::CanvasBox const&>(layout_node());
} }
void CanvasPaintable::paint(PaintContext& context, PaintPhase phase) const void CanvasPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/CanvasPaintable.h
View file

@ -18,7 +18,7 @@ class CanvasPaintable final : public PaintableBox {
public: public:
static GC::Ref<CanvasPaintable> create(Layout::CanvasBox const&); static GC::Ref<CanvasPaintable> create(Layout::CanvasBox const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::CanvasBox const& layout_box() const; Layout::CanvasBox const& layout_box() const;

5
Libraries/LibWeb/Painting/CheckBoxPaintable.cpp
View file

@ -5,12 +5,9 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include <LibGfx/Bitmap.h>
#include <LibWeb/HTML/BrowsingContext.h>
#include <LibWeb/HTML/HTMLImageElement.h> #include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/HTML/HTMLInputElement.h> #include <LibWeb/HTML/HTMLInputElement.h>
#include <LibWeb/Layout/CheckBox.h> #include <LibWeb/Layout/CheckBox.h>
#include <LibWeb/Layout/Label.h>
#include <LibWeb/Painting/CheckBoxPaintable.h> #include <LibWeb/Painting/CheckBoxPaintable.h>
#include <LibWeb/Painting/DisplayListRecorder.h> #include <LibWeb/Painting/DisplayListRecorder.h>
#include <LibWeb/Painting/InputColors.h> #include <LibWeb/Painting/InputColors.h>
@ -58,7 +55,7 @@ Layout::CheckBox& CheckBoxPaintable::layout_box()
return static_cast<Layout::CheckBox&>(layout_node()); return static_cast<Layout::CheckBox&>(layout_node());
} }
void CheckBoxPaintable::paint(PaintContext& context, PaintPhase phase) const void CheckBoxPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/CheckBoxPaintable.h
View file

@ -21,7 +21,7 @@ public:
Layout::CheckBox const& layout_box() const; Layout::CheckBox const& layout_box() const;
Layout::CheckBox& layout_box(); Layout::CheckBox& layout_box();
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
private: private:
CheckBoxPaintable(Layout::CheckBox const&); CheckBoxPaintable(Layout::CheckBox const&);

32
Libraries/LibWeb/Painting/PaintContext.cpp → Libraries/LibWeb/Painting/DisplayListRecordingContext.cpp
View file

@ -5,13 +5,13 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
namespace Web { namespace Web {
static u64 s_next_paint_generation_id = 0; static u64 s_next_paint_generation_id = 0;
PaintContext::PaintContext(Painting::DisplayListRecorder& display_list_recorder, Palette const& palette, double device_pixels_per_css_pixel) DisplayListRecordingContext::DisplayListRecordingContext(Painting::DisplayListRecorder& display_list_recorder, Palette const& palette, double device_pixels_per_css_pixel)
: m_display_list_recorder(display_list_recorder) : m_display_list_recorder(display_list_recorder)
, m_palette(palette) , m_palette(palette)
, m_device_pixel_converter(device_pixels_per_css_pixel) , m_device_pixel_converter(device_pixels_per_css_pixel)
@ -19,7 +19,7 @@ PaintContext::PaintContext(Painting::DisplayListRecorder& display_list_recorder,
{ {
} }
CSSPixelRect PaintContext::css_viewport_rect() const CSSPixelRect DisplayListRecordingContext::css_viewport_rect() const
{ {
return { return {
m_device_viewport_rect.x().value() / m_device_pixel_converter.device_pixels_per_css_pixel(), m_device_viewport_rect.x().value() / m_device_pixel_converter.device_pixels_per_css_pixel(),
@ -29,57 +29,57 @@ CSSPixelRect PaintContext::css_viewport_rect() const
}; };
} }
DevicePixels PaintContext::rounded_device_pixels(CSSPixels css_pixels) const DevicePixels DisplayListRecordingContext::rounded_device_pixels(CSSPixels css_pixels) const
{ {
return m_device_pixel_converter.rounded_device_pixels(css_pixels); return m_device_pixel_converter.rounded_device_pixels(css_pixels);
} }
DevicePixels PaintContext::enclosing_device_pixels(CSSPixels css_pixels) const DevicePixels DisplayListRecordingContext::enclosing_device_pixels(CSSPixels css_pixels) const
{ {
return m_device_pixel_converter.enclosing_device_pixels(css_pixels); return m_device_pixel_converter.enclosing_device_pixels(css_pixels);
} }
DevicePixels PaintContext::floored_device_pixels(CSSPixels css_pixels) const DevicePixels DisplayListRecordingContext::floored_device_pixels(CSSPixels css_pixels) const
{ {
return m_device_pixel_converter.floored_device_pixels(css_pixels); return m_device_pixel_converter.floored_device_pixels(css_pixels);
} }
DevicePixelPoint PaintContext::rounded_device_point(CSSPixelPoint point) const DevicePixelPoint DisplayListRecordingContext::rounded_device_point(CSSPixelPoint point) const
{ {
return m_device_pixel_converter.rounded_device_point(point); return m_device_pixel_converter.rounded_device_point(point);
} }
DevicePixelPoint PaintContext::floored_device_point(CSSPixelPoint point) const DevicePixelPoint DisplayListRecordingContext::floored_device_point(CSSPixelPoint point) const
{ {
return m_device_pixel_converter.floored_device_point(point); return m_device_pixel_converter.floored_device_point(point);
} }
DevicePixelRect PaintContext::enclosing_device_rect(CSSPixelRect rect) const DevicePixelRect DisplayListRecordingContext::enclosing_device_rect(CSSPixelRect rect) const
{ {
return m_device_pixel_converter.enclosing_device_rect(rect); return m_device_pixel_converter.enclosing_device_rect(rect);
} }
DevicePixelRect PaintContext::rounded_device_rect(CSSPixelRect rect) const DevicePixelRect DisplayListRecordingContext::rounded_device_rect(CSSPixelRect rect) const
{ {
return m_device_pixel_converter.rounded_device_rect(rect); return m_device_pixel_converter.rounded_device_rect(rect);
} }
DevicePixelSize PaintContext::enclosing_device_size(CSSPixelSize size) const DevicePixelSize DisplayListRecordingContext::enclosing_device_size(CSSPixelSize size) const
{ {
return m_device_pixel_converter.enclosing_device_size(size); return m_device_pixel_converter.enclosing_device_size(size);
} }
DevicePixelSize PaintContext::rounded_device_size(CSSPixelSize size) const DevicePixelSize DisplayListRecordingContext::rounded_device_size(CSSPixelSize size) const
{ {
return m_device_pixel_converter.rounded_device_size(size); return m_device_pixel_converter.rounded_device_size(size);
} }
CSSPixels PaintContext::scale_to_css_pixels(DevicePixels device_pixels) const CSSPixels DisplayListRecordingContext::scale_to_css_pixels(DevicePixels device_pixels) const
{ {
return CSSPixels::nearest_value_for(device_pixels.value() / m_device_pixel_converter.device_pixels_per_css_pixel()); return CSSPixels::nearest_value_for(device_pixels.value() / m_device_pixel_converter.device_pixels_per_css_pixel());
} }
CSSPixelPoint PaintContext::scale_to_css_point(DevicePixelPoint point) const CSSPixelPoint DisplayListRecordingContext::scale_to_css_point(DevicePixelPoint point) const
{ {
return { return {
scale_to_css_pixels(point.x()), scale_to_css_pixels(point.x()),
@ -87,7 +87,7 @@ CSSPixelPoint PaintContext::scale_to_css_point(DevicePixelPoint point) const
}; };
} }
CSSPixelSize PaintContext::scale_to_css_size(DevicePixelSize size) const CSSPixelSize DisplayListRecordingContext::scale_to_css_size(DevicePixelSize size) const
{ {
return { return {
scale_to_css_pixels(size.width()), scale_to_css_pixels(size.width()),
@ -95,7 +95,7 @@ CSSPixelSize PaintContext::scale_to_css_size(DevicePixelSize size) const
}; };
} }
CSSPixelRect PaintContext::scale_to_css_rect(DevicePixelRect rect) const CSSPixelRect DisplayListRecordingContext::scale_to_css_rect(DevicePixelRect rect) const
{ {
return { return {
scale_to_css_point(rect.location()), scale_to_css_point(rect.location()),

8
Libraries/LibWeb/Painting/PaintContext.h → Libraries/LibWeb/Painting/DisplayListRecordingContext.h
View file

@ -16,9 +16,9 @@
namespace Web { namespace Web {
class PaintContext { class DisplayListRecordingContext {
public: public:
PaintContext(Painting::DisplayListRecorder& painter, Palette const& palette, double device_pixels_per_css_pixel); DisplayListRecordingContext(Painting::DisplayListRecorder& painter, Palette const& palette, double device_pixels_per_css_pixel);
Painting::DisplayListRecorder& display_list_recorder() const { return m_display_list_recorder; } Painting::DisplayListRecorder& display_list_recorder() const { return m_display_list_recorder; }
Palette const& palette() const { return m_palette; } Palette const& palette() const { return m_palette; }
@ -67,9 +67,9 @@ public:
CSSPixelSize scale_to_css_size(DevicePixelSize) const; CSSPixelSize scale_to_css_size(DevicePixelSize) const;
CSSPixelRect scale_to_css_rect(DevicePixelRect) const; CSSPixelRect scale_to_css_rect(DevicePixelRect) const;
PaintContext clone(Painting::DisplayListRecorder& painter) const DisplayListRecordingContext clone(Painting::DisplayListRecorder& painter) const
{ {
auto clone = PaintContext(painter, m_palette, m_device_pixel_converter.device_pixels_per_css_pixel()); auto clone = DisplayListRecordingContext(painter, m_palette, m_device_pixel_converter.device_pixels_per_css_pixel());
clone.m_device_viewport_rect = m_device_viewport_rect; clone.m_device_viewport_rect = m_device_viewport_rect;
clone.m_should_show_line_box_borders = m_should_show_line_box_borders; clone.m_should_show_line_box_borders = m_should_show_line_box_borders;
clone.m_should_paint_overlay = m_should_paint_overlay; clone.m_should_paint_overlay = m_should_paint_overlay;

3
Libraries/LibWeb/Painting/FieldSetPaintable.cpp
View file

@ -4,6 +4,7 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include <LibWeb/Layout/FieldSetBox.h>
#include <LibWeb/Layout/LegendBox.h> #include <LibWeb/Layout/LegendBox.h>
#include <LibWeb/Painting/DisplayListRecorder.h> #include <LibWeb/Painting/DisplayListRecorder.h>
#include <LibWeb/Painting/FieldSetPaintable.h> #include <LibWeb/Painting/FieldSetPaintable.h>
@ -32,7 +33,7 @@ Layout::FieldSetBox const& FieldSetPaintable::layout_box() const
return static_cast<Layout::FieldSetBox const&>(layout_node()); return static_cast<Layout::FieldSetBox const&>(layout_node());
} }
void FieldSetPaintable::paint(PaintContext& context, PaintPhase phase) const void FieldSetPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

4
Libraries/LibWeb/Painting/FieldSetPaintable.h
View file

@ -7,8 +7,6 @@
#pragma once #pragma once
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
#include <LibWeb/Layout/FieldSetBox.h>
#include <LibWeb/Painting/PaintContext.h>
#include <LibWeb/Painting/PaintableBox.h> #include <LibWeb/Painting/PaintableBox.h>
namespace Web::Painting { namespace Web::Painting {
@ -20,7 +18,7 @@ class FieldSetPaintable final : public PaintableBox {
public: public:
static GC::Ref<FieldSetPaintable> create(Layout::FieldSetBox const&); static GC::Ref<FieldSetPaintable> create(Layout::FieldSetBox const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
private: private:
Layout::FieldSetBox& layout_box(); Layout::FieldSetBox& layout_box();

5
Libraries/LibWeb/Painting/GradientPainting.h
View file

@ -6,13 +6,8 @@
#pragma once #pragma once
#include <AK/Span.h>
#include <AK/Vector.h>
#include <LibGfx/Color.h>
#include <LibGfx/Gradients.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
#include <LibWeb/Painting/GradientData.h> #include <LibWeb/Painting/GradientData.h>
#include <LibWeb/Painting/PaintContext.h>
namespace Web::Painting { namespace Web::Painting {

2
Libraries/LibWeb/Painting/ImagePaintable.cpp
View file

@ -57,7 +57,7 @@ void ImagePaintable::finalize()
document().unregister_viewport_client(*this); document().unregister_viewport_client(*this);
} }
void ImagePaintable::paint(PaintContext& context, PaintPhase phase) const void ImagePaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/ImagePaintable.h
View file

@ -22,7 +22,7 @@ public:
static GC::Ref<ImagePaintable> create(Layout::ImageBox const& layout_box); static GC::Ref<ImagePaintable> create(Layout::ImageBox const& layout_box);
static GC::Ref<ImagePaintable> create(Layout::SVGImageBox const& layout_box); static GC::Ref<ImagePaintable> create(Layout::SVGImageBox const& layout_box);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
private: private:
// ^JS::Cell // ^JS::Cell

2
Libraries/LibWeb/Painting/MarkerPaintable.cpp
View file

@ -30,7 +30,7 @@ Layout::ListItemMarkerBox const& MarkerPaintable::layout_box() const
constexpr float sin_60_deg = 0.866025403f; constexpr float sin_60_deg = 0.866025403f;
void MarkerPaintable::paint(PaintContext& context, PaintPhase phase) const void MarkerPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/MarkerPaintable.h
View file

@ -18,7 +18,7 @@ class MarkerPaintable final : public PaintableBox {
public: public:
static GC::Ref<MarkerPaintable> create(Layout::ListItemMarkerBox const&); static GC::Ref<MarkerPaintable> create(Layout::ListItemMarkerBox const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::ListItemMarkerBox const& layout_box() const; Layout::ListItemMarkerBox const& layout_box() const;

16
Libraries/LibWeb/Painting/MediaPaintable.cpp
View file

@ -35,7 +35,7 @@ MediaPaintable::MediaPaintable(Layout::ReplacedBox const& layout_box)
{ {
} }
Optional<DevicePixelPoint> MediaPaintable::mouse_position(PaintContext& context, HTML::HTMLMediaElement const& media_element) Optional<DevicePixelPoint> MediaPaintable::mouse_position(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element)
{ {
auto const& layout_mouse_position = media_element.layout_mouse_position({}); auto const& layout_mouse_position = media_element.layout_mouse_position({});
@ -59,7 +59,7 @@ void MediaPaintable::fill_triangle(DisplayListRecorder& painter, Gfx::IntPoint l
}); });
} }
void MediaPaintable::paint_media_controls(PaintContext& context, HTML::HTMLMediaElement const& media_element, DevicePixelRect media_rect, Optional<DevicePixelPoint> const& mouse_position) const void MediaPaintable::paint_media_controls(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element, DevicePixelRect media_rect, Optional<DevicePixelPoint> const& mouse_position) const
{ {
auto components = compute_control_bar_components(context, media_element, media_rect); auto components = compute_control_bar_components(context, media_element, media_rect);
context.display_list_recorder().fill_rect(components.control_box_rect.to_type<int>(), CONTROL_BOX_COLOR.with_alpha(0xd0)); context.display_list_recorder().fill_rect(components.control_box_rect.to_type<int>(), CONTROL_BOX_COLOR.with_alpha(0xd0));
@ -71,7 +71,7 @@ void MediaPaintable::paint_media_controls(PaintContext& context, HTML::HTMLMedia
paint_control_bar_volume(context, media_element, components, mouse_position); paint_control_bar_volume(context, media_element, components, mouse_position);
} }
MediaPaintable::Components MediaPaintable::compute_control_bar_components(PaintContext& context, HTML::HTMLMediaElement const& media_element, DevicePixelRect media_rect) const MediaPaintable::Components MediaPaintable::compute_control_bar_components(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element, DevicePixelRect media_rect) const
{ {
auto maximum_control_box_height = context.rounded_device_pixels(40); auto maximum_control_box_height = context.rounded_device_pixels(40);
auto component_padding = context.rounded_device_pixels(5); auto component_padding = context.rounded_device_pixels(5);
@ -138,7 +138,7 @@ MediaPaintable::Components MediaPaintable::compute_control_bar_components(PaintC
return components; return components;
} }
void MediaPaintable::paint_control_bar_playback_button(PaintContext& context, HTML::HTMLMediaElement const& media_element, Components const& components, Optional<DevicePixelPoint> const& mouse_position) void MediaPaintable::paint_control_bar_playback_button(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element, Components const& components, Optional<DevicePixelPoint> const& mouse_position)
{ {
auto playback_button_size = components.playback_button_rect.width() * 4 / 10; auto playback_button_size = components.playback_button_rect.width() * 4 / 10;
@ -172,7 +172,7 @@ void MediaPaintable::paint_control_bar_playback_button(PaintContext& context, HT
} }
} }
void MediaPaintable::paint_control_bar_timeline(PaintContext& context, HTML::HTMLMediaElement const& media_element, Components const& components) void MediaPaintable::paint_control_bar_timeline(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element, Components const& components)
{ {
if (components.timeline_rect.is_empty()) if (components.timeline_rect.is_empty())
return; return;
@ -190,7 +190,7 @@ void MediaPaintable::paint_control_bar_timeline(PaintContext& context, HTML::HTM
context.display_list_recorder().fill_rect(timeline_future_rect.to_type<int>(), Color::Black); context.display_list_recorder().fill_rect(timeline_future_rect.to_type<int>(), Color::Black);
} }
void MediaPaintable::paint_control_bar_timestamp(PaintContext& context, Components const& components) void MediaPaintable::paint_control_bar_timestamp(DisplayListRecordingContext& context, Components const& components)
{ {
if (components.timestamp_rect.is_empty()) if (components.timestamp_rect.is_empty())
return; return;
@ -198,7 +198,7 @@ void MediaPaintable::paint_control_bar_timestamp(PaintContext& context, Componen
context.display_list_recorder().draw_text(components.timestamp_rect.to_type<int>(), components.timestamp, *components.timestamp_font, Gfx::TextAlignment::CenterLeft, Color::White); context.display_list_recorder().draw_text(components.timestamp_rect.to_type<int>(), components.timestamp, *components.timestamp_font, Gfx::TextAlignment::CenterLeft, Color::White);
} }
void MediaPaintable::paint_control_bar_speaker(PaintContext& context, HTML::HTMLMediaElement const& media_element, Components const& components, Optional<DevicePixelPoint> const& mouse_position) void MediaPaintable::paint_control_bar_speaker(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element, Components const& components, Optional<DevicePixelPoint> const& mouse_position)
{ {
if (components.speaker_button_rect.is_empty()) if (components.speaker_button_rect.is_empty())
return; return;
@ -252,7 +252,7 @@ void MediaPaintable::paint_control_bar_speaker(PaintContext& context, HTML::HTML
} }
} }
void MediaPaintable::paint_control_bar_volume(PaintContext& context, HTML::HTMLMediaElement const& media_element, Components const& components, Optional<DevicePixelPoint> const& mouse_position) void MediaPaintable::paint_control_bar_volume(DisplayListRecordingContext& context, HTML::HTMLMediaElement const& media_element, Components const& components, Optional<DevicePixelPoint> const& mouse_position)
{ {
if (components.volume_rect.is_empty()) if (components.volume_rect.is_empty())
return; return;

16
Libraries/LibWeb/Painting/MediaPaintable.h
View file

@ -19,10 +19,10 @@ class MediaPaintable : public PaintableBox {
protected: protected:
explicit MediaPaintable(Layout::ReplacedBox const&); explicit MediaPaintable(Layout::ReplacedBox const&);
static Optional<DevicePixelPoint> mouse_position(PaintContext&, HTML::HTMLMediaElement const&); static Optional<DevicePixelPoint> mouse_position(DisplayListRecordingContext&, HTML::HTMLMediaElement const&);
static void fill_triangle(DisplayListRecorder& painter, Gfx::IntPoint location, Array<Gfx::IntPoint, 3> coordinates, Color color); static void fill_triangle(DisplayListRecorder& painter, Gfx::IntPoint location, Array<Gfx::IntPoint, 3> coordinates, Color color);
void paint_media_controls(PaintContext&, HTML::HTMLMediaElement const&, DevicePixelRect media_rect, Optional<DevicePixelPoint> const& mouse_position) const; void paint_media_controls(DisplayListRecordingContext&, HTML::HTMLMediaElement const&, DevicePixelRect media_rect, Optional<DevicePixelPoint> const& mouse_position) const;
private: private:
struct Components { struct Components {
@ -47,12 +47,12 @@ private:
virtual DispatchEventOfSameName handle_mouseup(Badge<EventHandler>, CSSPixelPoint, unsigned button, unsigned modifiers) override; virtual DispatchEventOfSameName handle_mouseup(Badge<EventHandler>, CSSPixelPoint, unsigned button, unsigned modifiers) override;
virtual DispatchEventOfSameName handle_mousemove(Badge<EventHandler>, CSSPixelPoint, unsigned buttons, unsigned modifiers) override; virtual DispatchEventOfSameName handle_mousemove(Badge<EventHandler>, CSSPixelPoint, unsigned buttons, unsigned modifiers) override;
Components compute_control_bar_components(PaintContext&, HTML::HTMLMediaElement const&, DevicePixelRect media_rect) const; Components compute_control_bar_components(DisplayListRecordingContext&, HTML::HTMLMediaElement const&, DevicePixelRect media_rect) const;
static void paint_control_bar_playback_button(PaintContext&, HTML::HTMLMediaElement const&, Components const&, Optional<DevicePixelPoint> const& mouse_position); static void paint_control_bar_playback_button(DisplayListRecordingContext&, HTML::HTMLMediaElement const&, Components const&, Optional<DevicePixelPoint> const& mouse_position);
static void paint_control_bar_timeline(PaintContext&, HTML::HTMLMediaElement const&, Components const&); static void paint_control_bar_timeline(DisplayListRecordingContext&, HTML::HTMLMediaElement const&, Components const&);
static void paint_control_bar_timestamp(PaintContext&, Components const&); static void paint_control_bar_timestamp(DisplayListRecordingContext&, Components const&);
static void paint_control_bar_speaker(PaintContext&, HTML::HTMLMediaElement const&, Components const& components, Optional<DevicePixelPoint> const& mouse_position); static void paint_control_bar_speaker(DisplayListRecordingContext&, HTML::HTMLMediaElement const&, Components const& components, Optional<DevicePixelPoint> const& mouse_position);
static void paint_control_bar_volume(PaintContext&, HTML::HTMLMediaElement const&, Components const&, Optional<DevicePixelPoint> const& mouse_position); static void paint_control_bar_volume(DisplayListRecordingContext&, HTML::HTMLMediaElement const&, Components const&, Optional<DevicePixelPoint> const& mouse_position);
enum class Temporary { enum class Temporary {
Yes, Yes,

2
Libraries/LibWeb/Painting/NavigableContainerViewportPaintable.cpp
View file

@ -33,7 +33,7 @@ Layout::NavigableContainerViewport const& NavigableContainerViewportPaintable::l
return static_cast<Layout::NavigableContainerViewport const&>(layout_node()); return static_cast<Layout::NavigableContainerViewport const&>(layout_node());
} }
void NavigableContainerViewportPaintable::paint(PaintContext& context, PaintPhase phase) const void NavigableContainerViewportPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/NavigableContainerViewportPaintable.h
View file

@ -20,7 +20,7 @@ public:
static GC::Ref<NavigableContainerViewportPaintable> create(Layout::NavigableContainerViewport const&); static GC::Ref<NavigableContainerViewportPaintable> create(Layout::NavigableContainerViewport const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::NavigableContainerViewport const& layout_box() const; Layout::NavigableContainerViewport const& layout_box() const;

6
Libraries/LibWeb/Painting/Paintable.h
View file

@ -70,10 +70,10 @@ public:
bool has_stacking_context() const; bool has_stacking_context() const;
StackingContext* enclosing_stacking_context(); StackingContext* enclosing_stacking_context();
virtual void before_paint(PaintContext&, PaintPhase) const { } virtual void before_paint(DisplayListRecordingContext&, PaintPhase) const { }
virtual void after_paint(PaintContext&, PaintPhase) const { } virtual void after_paint(DisplayListRecordingContext&, PaintPhase) const { }
virtual void paint(PaintContext&, PaintPhase) const { } virtual void paint(DisplayListRecordingContext&, PaintPhase) const { }
[[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const; [[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const;

30
Libraries/LibWeb/Painting/PaintableBox.cpp
View file

@ -321,7 +321,7 @@ bool PaintableBox::wants_mouse_events() const
return false; return false;
} }
void PaintableBox::before_paint(PaintContext& context, PaintPhase phase) const void PaintableBox::before_paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -334,7 +334,7 @@ void PaintableBox::before_paint(PaintContext& context, PaintPhase phase) const
apply_scroll_offset(context); apply_scroll_offset(context);
} }
void PaintableBox::after_paint(PaintContext& context, PaintPhase phase) const void PaintableBox::after_paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -432,7 +432,7 @@ Optional<PaintableBox::ScrollbarData> PaintableBox::compute_scrollbar_data(Scrol
return scrollbar_data; return scrollbar_data;
} }
void PaintableBox::paint(PaintContext& context, PaintPhase phase) const void PaintableBox::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -563,7 +563,7 @@ BordersData PaintableBox::remove_element_kind_from_borders_data(PaintableBox::Bo
}; };
} }
void PaintableBox::paint_border(PaintContext& context) const void PaintableBox::paint_border(DisplayListRecordingContext& context) const
{ {
auto borders_data = m_override_borders_data.has_value() ? remove_element_kind_from_borders_data(m_override_borders_data.value()) : BordersData { auto borders_data = m_override_borders_data.has_value() ? remove_element_kind_from_borders_data(m_override_borders_data.value()) : BordersData {
.top = box_model().border.top == 0 ? CSS::BorderData() : computed_values().border_top(), .top = box_model().border.top == 0 ? CSS::BorderData() : computed_values().border_top(),
@ -574,7 +574,7 @@ void PaintableBox::paint_border(PaintContext& context) const
paint_all_borders(context.display_list_recorder(), context.rounded_device_rect(absolute_border_box_rect()), normalized_border_radii_data().as_corners(context.device_pixel_converter()), borders_data.to_device_pixels(context)); paint_all_borders(context.display_list_recorder(), context.rounded_device_rect(absolute_border_box_rect()), normalized_border_radii_data().as_corners(context.device_pixel_converter()), borders_data.to_device_pixels(context));
} }
void PaintableBox::paint_backdrop_filter(PaintContext& context) const void PaintableBox::paint_backdrop_filter(DisplayListRecordingContext& context) const
{ {
auto const& backdrop_filter = computed_values().backdrop_filter(); auto const& backdrop_filter = computed_values().backdrop_filter();
if (!backdrop_filter.has_value()) { if (!backdrop_filter.has_value()) {
@ -587,7 +587,7 @@ void PaintableBox::paint_backdrop_filter(PaintContext& context) const
context.display_list_recorder().apply_backdrop_filter(backdrop_region.to_type<int>(), border_radii_data, backdrop_filter.value()); context.display_list_recorder().apply_backdrop_filter(backdrop_region.to_type<int>(), border_radii_data, backdrop_filter.value());
} }
void PaintableBox::paint_background(PaintContext& context) const void PaintableBox::paint_background(DisplayListRecordingContext& context) const
{ {
// If the body's background properties were propagated to the root element, do no re-paint the body's background. // If the body's background properties were propagated to the root element, do no re-paint the body's background.
if (layout_node_with_style_and_box_metrics().is_body() && document().html_element()->should_use_body_background_properties()) if (layout_node_with_style_and_box_metrics().is_body() && document().html_element()->should_use_body_background_properties())
@ -596,7 +596,7 @@ void PaintableBox::paint_background(PaintContext& context) const
Painting::paint_background(context, *this, computed_values().image_rendering(), m_resolved_background, normalized_border_radii_data()); Painting::paint_background(context, *this, computed_values().image_rendering(), m_resolved_background, normalized_border_radii_data());
} }
void PaintableBox::paint_box_shadow(PaintContext& context) const void PaintableBox::paint_box_shadow(DisplayListRecordingContext& context) const
{ {
auto const& resolved_box_shadow_data = box_shadow_data(); auto const& resolved_box_shadow_data = box_shadow_data();
if (resolved_box_shadow_data.is_empty()) if (resolved_box_shadow_data.is_empty())
@ -647,21 +647,21 @@ Optional<CSSPixelRect> PaintableBox::clip_rect_for_hit_testing() const
return {}; return {};
} }
void PaintableBox::apply_scroll_offset(PaintContext& context) const void PaintableBox::apply_scroll_offset(DisplayListRecordingContext& context) const
{ {
if (scroll_frame_id().has_value()) { if (scroll_frame_id().has_value()) {
context.display_list_recorder().push_scroll_frame_id(scroll_frame_id().value()); context.display_list_recorder().push_scroll_frame_id(scroll_frame_id().value());
} }
} }
void PaintableBox::reset_scroll_offset(PaintContext& context) const void PaintableBox::reset_scroll_offset(DisplayListRecordingContext& context) const
{ {
if (scroll_frame_id().has_value()) { if (scroll_frame_id().has_value()) {
context.display_list_recorder().pop_scroll_frame_id(); context.display_list_recorder().pop_scroll_frame_id();
} }
} }
void PaintableBox::apply_clip_overflow_rect(PaintContext& context, PaintPhase phase) const void PaintableBox::apply_clip_overflow_rect(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!enclosing_clip_frame()) if (!enclosing_clip_frame())
return; return;
@ -672,7 +672,7 @@ void PaintableBox::apply_clip_overflow_rect(PaintContext& context, PaintPhase ph
context.display_list_recorder().push_clip_frame(enclosing_clip_frame()); context.display_list_recorder().push_clip_frame(enclosing_clip_frame());
} }
void PaintableBox::clear_clip_overflow_rect(PaintContext& context, PaintPhase phase) const void PaintableBox::clear_clip_overflow_rect(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!enclosing_clip_frame()) if (!enclosing_clip_frame())
return; return;
@ -683,7 +683,7 @@ void PaintableBox::clear_clip_overflow_rect(PaintContext& context, PaintPhase ph
context.display_list_recorder().pop_clip_frame(); context.display_list_recorder().pop_clip_frame();
} }
void paint_cursor_if_needed(PaintContext& context, TextPaintable const& paintable, PaintableFragment const& fragment) void paint_cursor_if_needed(DisplayListRecordingContext& context, TextPaintable const& paintable, PaintableFragment const& fragment)
{ {
auto const& navigable = *paintable.navigable(); auto const& navigable = *paintable.navigable();
auto const& document = paintable.document(); auto const& document = paintable.document();
@ -734,7 +734,7 @@ void paint_cursor_if_needed(PaintContext& context, TextPaintable const& paintabl
context.display_list_recorder().fill_rect(cursor_device_rect, caret_color); context.display_list_recorder().fill_rect(cursor_device_rect, caret_color);
} }
void paint_text_decoration(PaintContext& context, TextPaintable const& paintable, PaintableFragment const& fragment) void paint_text_decoration(DisplayListRecordingContext& context, TextPaintable const& paintable, PaintableFragment const& fragment)
{ {
auto& painter = context.display_list_recorder(); auto& painter = context.display_list_recorder();
auto& font = fragment.layout_node().first_available_font(); auto& font = fragment.layout_node().first_available_font();
@ -847,7 +847,7 @@ void paint_text_decoration(PaintContext& context, TextPaintable const& paintable
} }
} }
void paint_text_fragment(PaintContext& context, TextPaintable const& paintable, PaintableFragment const& fragment, PaintPhase phase) void paint_text_fragment(DisplayListRecordingContext& context, TextPaintable const& paintable, PaintableFragment const& fragment, PaintPhase phase)
{ {
if (!paintable.is_visible()) if (!paintable.is_visible())
return; return;
@ -885,7 +885,7 @@ void paint_text_fragment(PaintContext& context, TextPaintable const& paintable,
} }
} }
void PaintableWithLines::paint(PaintContext& context, PaintPhase phase) const void PaintableWithLines::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

32
Libraries/LibWeb/Painting/PaintableBox.h
View file

@ -32,10 +32,10 @@ public:
static GC::Ref<PaintableBox> create(Layout::InlineNode const&); static GC::Ref<PaintableBox> create(Layout::InlineNode const&);
virtual ~PaintableBox(); virtual ~PaintableBox();
virtual void before_paint(PaintContext&, PaintPhase) const override; virtual void before_paint(DisplayListRecordingContext&, PaintPhase) const override;
virtual void after_paint(PaintContext&, PaintPhase) const override; virtual void after_paint(DisplayListRecordingContext&, PaintPhase) const override;
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
StackingContext* stacking_context() { return m_stacking_context; } StackingContext* stacking_context() { return m_stacking_context; }
StackingContext const* stacking_context() const { return m_stacking_context; } StackingContext const* stacking_context() const { return m_stacking_context; }
@ -44,7 +44,7 @@ public:
virtual Optional<CSSPixelRect> get_masking_area() const; virtual Optional<CSSPixelRect> get_masking_area() const;
virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const { return {}; } virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const { return {}; }
virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(PaintContext&, CSSPixelRect const&) const { return {}; } virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(DisplayListRecordingContext&, CSSPixelRect const&) const { return {}; }
Layout::NodeWithStyleAndBoxModelMetrics& layout_node_with_style_and_box_metrics() { return static_cast<Layout::NodeWithStyleAndBoxModelMetrics&>(Paintable::layout_node()); } Layout::NodeWithStyleAndBoxModelMetrics& layout_node_with_style_and_box_metrics() { return static_cast<Layout::NodeWithStyleAndBoxModelMetrics&>(Paintable::layout_node()); }
Layout::NodeWithStyleAndBoxModelMetrics const& layout_node_with_style_and_box_metrics() const { return static_cast<Layout::NodeWithStyleAndBoxModelMetrics const&>(Paintable::layout_node()); } Layout::NodeWithStyleAndBoxModelMetrics const& layout_node_with_style_and_box_metrics() const { return static_cast<Layout::NodeWithStyleAndBoxModelMetrics const&>(Paintable::layout_node()); }
@ -134,11 +134,11 @@ public:
virtual void set_needs_display(InvalidateDisplayList = InvalidateDisplayList::Yes) override; virtual void set_needs_display(InvalidateDisplayList = InvalidateDisplayList::Yes) override;
void apply_scroll_offset(PaintContext&) const; void apply_scroll_offset(DisplayListRecordingContext&) const;
void reset_scroll_offset(PaintContext&) const; void reset_scroll_offset(DisplayListRecordingContext&) const;
void apply_clip_overflow_rect(PaintContext&, PaintPhase) const; void apply_clip_overflow_rect(DisplayListRecordingContext&, PaintPhase) const;
void clear_clip_overflow_rect(PaintContext&, PaintPhase) const; void clear_clip_overflow_rect(DisplayListRecordingContext&, PaintPhase) const;
[[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint position, HitTestType type, Function<TraversalDecision(HitTestResult)> const& callback) const override; [[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint position, HitTestType type, Function<TraversalDecision(HitTestResult)> const& callback) const override;
Optional<HitTestResult> hit_test(CSSPixelPoint, HitTestType) const; Optional<HitTestResult> hit_test(CSSPixelPoint, HitTestType) const;
@ -265,10 +265,10 @@ protected:
explicit PaintableBox(Layout::Box const&); explicit PaintableBox(Layout::Box const&);
explicit PaintableBox(Layout::InlineNode const&); explicit PaintableBox(Layout::InlineNode const&);
virtual void paint_border(PaintContext&) const; virtual void paint_border(DisplayListRecordingContext&) const;
virtual void paint_backdrop_filter(PaintContext&) const; virtual void paint_backdrop_filter(DisplayListRecordingContext&) const;
virtual void paint_background(PaintContext&) const; virtual void paint_background(DisplayListRecordingContext&) const;
virtual void paint_box_shadow(PaintContext&) const; virtual void paint_box_shadow(DisplayListRecordingContext&) const;
virtual CSSPixelRect compute_absolute_rect() const; virtual CSSPixelRect compute_absolute_rect() const;
virtual CSSPixelRect compute_absolute_paint_rect() const; virtual CSSPixelRect compute_absolute_paint_rect() const;
@ -379,7 +379,7 @@ public:
} }
} }
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
[[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint position, HitTestType type, Function<TraversalDecision(HitTestResult)> const& callback) const override; [[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint position, HitTestType type, Function<TraversalDecision(HitTestResult)> const& callback) const override;
@ -406,8 +406,8 @@ private:
size_t m_line_index { 0 }; size_t m_line_index { 0 };
}; };
void paint_text_decoration(PaintContext&, TextPaintable const&, PaintableFragment const&); void paint_text_decoration(DisplayListRecordingContext&, TextPaintable const&, PaintableFragment const&);
void paint_cursor_if_needed(PaintContext&, TextPaintable const&, PaintableFragment const&); void paint_cursor_if_needed(DisplayListRecordingContext&, TextPaintable const&, PaintableFragment const&);
void paint_text_fragment(PaintContext&, TextPaintable const&, PaintableFragment const&, PaintPhase); void paint_text_fragment(DisplayListRecordingContext&, TextPaintable const&, PaintableFragment const&, PaintPhase);
} }

2
Libraries/LibWeb/Painting/RadioButtonPaintable.cpp
View file

@ -28,7 +28,7 @@ RadioButtonPaintable::RadioButtonPaintable(Layout::RadioButton const& layout_box
{ {
} }
void RadioButtonPaintable::paint(PaintContext& context, PaintPhase phase) const void RadioButtonPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

2
Libraries/LibWeb/Painting/RadioButtonPaintable.h
View file

@ -18,7 +18,7 @@ class RadioButtonPaintable final : public LabelablePaintable {
public: public:
static GC::Ref<RadioButtonPaintable> create(Layout::RadioButton const&); static GC::Ref<RadioButtonPaintable> create(Layout::RadioButton const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
private: private:
RadioButtonPaintable(Layout::RadioButton const&); RadioButtonPaintable(Layout::RadioButton const&);

2
Libraries/LibWeb/Painting/SVGForeignObjectPaintable.cpp
View file

@ -31,7 +31,7 @@ TraversalDecision SVGForeignObjectPaintable::hit_test(CSSPixelPoint position, Hi
return PaintableWithLines::hit_test(position, type, callback); return PaintableWithLines::hit_test(position, type, callback);
} }
void SVGForeignObjectPaintable::paint(PaintContext& context, PaintPhase phase) const void SVGForeignObjectPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;

4
Libraries/LibWeb/Painting/SVGForeignObjectPaintable.h
View file

@ -23,14 +23,14 @@ public:
virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override; virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override;
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::SVGForeignObjectBox const& layout_box() const; Layout::SVGForeignObjectBox const& layout_box() const;
virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); } virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); }
virtual Optional<CSSPixelRect> get_masking_area() const override { return get_masking_area_of_svg(); } virtual Optional<CSSPixelRect> get_masking_area() const override { return get_masking_area_of_svg(); }
virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const override { return get_mask_type_of_svg(); } virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const override { return get_mask_type_of_svg(); }
virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(PaintContext& paint_context, CSSPixelRect const& masking_area) const override { return calculate_mask_of_svg(paint_context, masking_area); } virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(DisplayListRecordingContext& paint_context, CSSPixelRect const& masking_area) const override { return calculate_mask_of_svg(paint_context, masking_area); }
protected: protected:
SVGForeignObjectPaintable(Layout::SVGForeignObjectBox const&); SVGForeignObjectPaintable(Layout::SVGForeignObjectBox const&);

4
Libraries/LibWeb/Painting/SVGGraphicsPaintable.h
View file

@ -37,7 +37,7 @@ public:
return Gfx::AffineTransform {}.multiply(svg_to_viewbox_transform()).multiply(additional_svg_transform.value_or(Gfx::AffineTransform {})).multiply(svg_transform()); return Gfx::AffineTransform {}.multiply(svg_to_viewbox_transform()).multiply(additional_svg_transform.value_or(Gfx::AffineTransform {})).multiply(svg_transform());
} }
Gfx::AffineTransform svg_to_device_pixels_transform(PaintContext const& context) const Gfx::AffineTransform svg_to_device_pixels_transform(DisplayListRecordingContext const& context) const
{ {
auto css_scale = context.device_pixels_per_css_pixel(); auto css_scale = context.device_pixels_per_css_pixel();
return Gfx::AffineTransform {}.scale({ css_scale, css_scale }).multiply(svg_to_css_pixels_transform(context.svg_transform())); return Gfx::AffineTransform {}.scale({ css_scale, css_scale }).multiply(svg_to_css_pixels_transform(context.svg_transform()));
@ -55,7 +55,7 @@ public:
virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); } virtual GC::Ptr<DOM::Node const> dom_node_of_svg() const override { return dom_node(); }
virtual Optional<CSSPixelRect> get_masking_area() const override { return get_masking_area_of_svg(); } virtual Optional<CSSPixelRect> get_masking_area() const override { return get_masking_area_of_svg(); }
virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const override { return get_mask_type_of_svg(); } virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const override { return get_mask_type_of_svg(); }
virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(PaintContext& paint_context, CSSPixelRect const& masking_area) const override { return calculate_mask_of_svg(paint_context, masking_area); } virtual RefPtr<Gfx::ImmutableBitmap> calculate_mask(DisplayListRecordingContext& paint_context, CSSPixelRect const& masking_area) const override { return calculate_mask_of_svg(paint_context, masking_area); }
void set_computed_transforms(ComputedTransforms computed_transforms) void set_computed_transforms(ComputedTransforms computed_transforms)
{ {

2
Libraries/LibWeb/Painting/SVGMaskable.cpp
View file

@ -73,7 +73,7 @@ Optional<Gfx::Bitmap::MaskKind> SVGMaskable::get_mask_type_of_svg() const
return {}; return {};
} }
RefPtr<Gfx::ImmutableBitmap> SVGMaskable::calculate_mask_of_svg(PaintContext& context, CSSPixelRect const& masking_area) const RefPtr<Gfx::ImmutableBitmap> SVGMaskable::calculate_mask_of_svg(DisplayListRecordingContext& context, CSSPixelRect const& masking_area) const
{ {
auto const& graphics_element = as<SVG::SVGGraphicsElement const>(*dom_node_of_svg()); auto const& graphics_element = as<SVG::SVGGraphicsElement const>(*dom_node_of_svg());
auto mask_rect = context.enclosing_device_rect(masking_area); auto mask_rect = context.enclosing_device_rect(masking_area);

3
Libraries/LibWeb/Painting/SVGMaskable.h
View file

@ -4,7 +4,6 @@
* SPDX-License-Identifier: BSD-2-Clause * SPDX-License-Identifier: BSD-2-Clause
*/ */
#include <LibWeb/Painting/PaintContext.h>
#include <LibWeb/PixelUnits.h> #include <LibWeb/PixelUnits.h>
#pragma once #pragma once
@ -19,7 +18,7 @@ public:
Optional<CSSPixelRect> get_masking_area_of_svg() const; Optional<CSSPixelRect> get_masking_area_of_svg() const;
Optional<Gfx::Bitmap::MaskKind> get_mask_type_of_svg() const; Optional<Gfx::Bitmap::MaskKind> get_mask_type_of_svg() const;
RefPtr<Gfx::ImmutableBitmap> calculate_mask_of_svg(PaintContext&, CSSPixelRect const& masking_area) const; RefPtr<Gfx::ImmutableBitmap> calculate_mask_of_svg(DisplayListRecordingContext&, CSSPixelRect const& masking_area) const;
}; };
} }

2
Libraries/LibWeb/Painting/SVGPathPaintable.cpp
View file

@ -51,7 +51,7 @@ static Gfx::WindingRule to_gfx_winding_rule(SVG::FillRule fill_rule)
} }
} }
void SVGPathPaintable::paint(PaintContext& context, PaintPhase phase) const void SVGPathPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible() || !computed_path().has_value()) if (!is_visible() || !computed_path().has_value())
return; return;

2
Libraries/LibWeb/Painting/SVGPathPaintable.h
View file

@ -21,7 +21,7 @@ public:
virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override; virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override;
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::SVGGraphicsBox const& layout_box() const; Layout::SVGGraphicsBox const& layout_box() const;

4
Libraries/LibWeb/Painting/SVGSVGPaintable.cpp
View file

@ -37,7 +37,7 @@ static Gfx::FloatMatrix4x4 matrix_with_scaled_translation(Gfx::FloatMatrix4x4 ma
return matrix; return matrix;
} }
void SVGSVGPaintable::paint_svg_box(PaintContext& context, PaintableBox const& svg_box, PaintPhase phase) void SVGSVGPaintable::paint_svg_box(DisplayListRecordingContext& context, PaintableBox const& svg_box, PaintPhase phase)
{ {
auto const& computed_values = svg_box.computed_values(); auto const& computed_values = svg_box.computed_values();
@ -107,7 +107,7 @@ void SVGSVGPaintable::paint_svg_box(PaintContext& context, PaintableBox const& s
} }
} }
void SVGSVGPaintable::paint_descendants(PaintContext& context, PaintableBox const& paintable, PaintPhase phase) void SVGSVGPaintable::paint_descendants(DisplayListRecordingContext& context, PaintableBox const& paintable, PaintPhase phase)
{ {
if (phase != PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;

4
Libraries/LibWeb/Painting/SVGSVGPaintable.h
View file

@ -20,8 +20,8 @@ public:
Layout::SVGSVGBox const& layout_box() const; Layout::SVGSVGBox const& layout_box() const;
static void paint_svg_box(PaintContext& context, PaintableBox const& svg_box, PaintPhase phase); static void paint_svg_box(DisplayListRecordingContext& context, PaintableBox const& svg_box, PaintPhase phase);
static void paint_descendants(PaintContext& context, PaintableBox const& paintable, PaintPhase phase); static void paint_descendants(DisplayListRecordingContext& context, PaintableBox const& paintable, PaintPhase phase);
protected: protected:
SVGSVGPaintable(Layout::SVGSVGBox const&); SVGSVGPaintable(Layout::SVGSVGBox const&);

6
Libraries/LibWeb/Painting/ShadowPainting.cpp
View file

@ -9,14 +9,14 @@
#include <LibWeb/Painting/BorderPainting.h> #include <LibWeb/Painting/BorderPainting.h>
#include <LibWeb/Painting/BorderRadiusCornerClipper.h> #include <LibWeb/Painting/BorderRadiusCornerClipper.h>
#include <LibWeb/Painting/DisplayListRecorder.h> #include <LibWeb/Painting/DisplayListRecorder.h>
#include <LibWeb/Painting/DisplayListRecordingContext.h>
#include <LibWeb/Painting/PaintBoxShadowParams.h> #include <LibWeb/Painting/PaintBoxShadowParams.h>
#include <LibWeb/Painting/PaintContext.h>
#include <LibWeb/Painting/PaintableBox.h> #include <LibWeb/Painting/PaintableBox.h>
#include <LibWeb/Painting/ShadowPainting.h> #include <LibWeb/Painting/ShadowPainting.h>
namespace Web::Painting { namespace Web::Painting {
void paint_box_shadow(PaintContext& context, void paint_box_shadow(DisplayListRecordingContext& context,
CSSPixelRect const& bordered_content_rect, CSSPixelRect const& bordered_content_rect,
CSSPixelRect const& borderless_content_rect, CSSPixelRect const& borderless_content_rect,
BordersData const& borders_data, BordersData const& borders_data,
@ -64,7 +64,7 @@ void paint_box_shadow(PaintContext& context,
} }
} }
void paint_text_shadow(PaintContext& context, PaintableFragment const& fragment, Vector<ShadowData> const& shadow_layers) void paint_text_shadow(DisplayListRecordingContext& context, PaintableFragment const& fragment, Vector<ShadowData> const& shadow_layers)
{ {
if (shadow_layers.is_empty()) if (shadow_layers.is_empty())
return; return;

6
Libraries/LibWeb/Painting/ShadowPainting.h
View file

@ -8,20 +8,20 @@
#include <LibGfx/Color.h> #include <LibGfx/Color.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
#include <LibWeb/Painting/DisplayListRecordingContext.h>
#include <LibWeb/Painting/PaintBoxShadowParams.h> #include <LibWeb/Painting/PaintBoxShadowParams.h>
#include <LibWeb/Painting/PaintContext.h>
#include <LibWeb/Painting/PaintableFragment.h> #include <LibWeb/Painting/PaintableFragment.h>
#include <LibWeb/Painting/ShadowData.h> #include <LibWeb/Painting/ShadowData.h>
namespace Web::Painting { namespace Web::Painting {
void paint_box_shadow( void paint_box_shadow(
PaintContext&, DisplayListRecordingContext&,
CSSPixelRect const& bordered_content_rect, CSSPixelRect const& bordered_content_rect,
CSSPixelRect const& borderless_content_rect, CSSPixelRect const& borderless_content_rect,
BordersData const& borders_data, BordersData const& borders_data,
BorderRadiiData const&, BorderRadiiData const&,
Vector<ShadowData> const&); Vector<ShadowData> const&);
void paint_text_shadow(PaintContext&, PaintableFragment const&, Vector<ShadowData> const&); void paint_text_shadow(DisplayListRecordingContext&, PaintableFragment const&, Vector<ShadowData> const&);
} }

14
Libraries/LibWeb/Painting/StackingContext.cpp
View file

@ -24,7 +24,7 @@
namespace Web::Painting { namespace Web::Painting {
static void paint_node(Paintable const& paintable, PaintContext& context, PaintPhase phase) static void paint_node(Paintable const& paintable, DisplayListRecordingContext& context, PaintPhase phase)
{ {
TemporaryChange save_nesting_level(context.display_list_recorder().m_save_nesting_level, 0); TemporaryChange save_nesting_level(context.display_list_recorder().m_save_nesting_level, 0);
@ -84,7 +84,7 @@ static PaintPhase to_paint_phase(StackingContext::StackingContextPaintPhase phas
} }
} }
void StackingContext::paint_node_as_stacking_context(Paintable const& paintable, PaintContext& context) void StackingContext::paint_node_as_stacking_context(Paintable const& paintable, DisplayListRecordingContext& context)
{ {
if (paintable.layout_node().is_svg_svg_box()) { if (paintable.layout_node().is_svg_svg_box()) {
paint_svg(context, static_cast<PaintableBox const&>(paintable), PaintPhase::Foreground); paint_svg(context, static_cast<PaintableBox const&>(paintable), PaintPhase::Foreground);
@ -103,7 +103,7 @@ void StackingContext::paint_node_as_stacking_context(Paintable const& paintable,
paint_descendants(context, paintable, StackingContextPaintPhase::FocusAndOverlay); paint_descendants(context, paintable, StackingContextPaintPhase::FocusAndOverlay);
} }
void StackingContext::paint_svg(PaintContext& context, PaintableBox const& paintable, PaintPhase phase) void StackingContext::paint_svg(DisplayListRecordingContext& context, PaintableBox const& paintable, PaintPhase phase)
{ {
if (phase != PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
@ -115,7 +115,7 @@ void StackingContext::paint_svg(PaintContext& context, PaintableBox const& paint
paintable.after_paint(context, PaintPhase::Foreground); paintable.after_paint(context, PaintPhase::Foreground);
} }
void StackingContext::paint_descendants(PaintContext& context, Paintable const& paintable, StackingContextPaintPhase phase) void StackingContext::paint_descendants(DisplayListRecordingContext& context, Paintable const& paintable, StackingContextPaintPhase phase)
{ {
paintable.for_each_child([&context, phase](auto& child) { paintable.for_each_child([&context, phase](auto& child) {
if (child.has_stacking_context()) if (child.has_stacking_context())
@ -196,14 +196,14 @@ void StackingContext::paint_descendants(PaintContext& context, Paintable const&
}); });
} }
void StackingContext::paint_child(PaintContext& context, StackingContext const& child) void StackingContext::paint_child(DisplayListRecordingContext& context, StackingContext const& child)
{ {
VERIFY(!child.paintable_box().layout_node().is_svg_box()); VERIFY(!child.paintable_box().layout_node().is_svg_box());
const_cast<StackingContext&>(child).set_last_paint_generation_id(context.paint_generation_id()); const_cast<StackingContext&>(child).set_last_paint_generation_id(context.paint_generation_id());
child.paint(context); child.paint(context);
} }
void StackingContext::paint_internal(PaintContext& context) const void StackingContext::paint_internal(DisplayListRecordingContext& context) const
{ {
VERIFY(!paintable_box().layout_node().is_svg_box()); VERIFY(!paintable_box().layout_node().is_svg_box());
if (paintable_box().layout_node().is_svg_svg_box()) { if (paintable_box().layout_node().is_svg_svg_box()) {
@ -299,7 +299,7 @@ static Gfx::FloatMatrix4x4 matrix_with_scaled_translation(Gfx::FloatMatrix4x4 ma
return matrix; return matrix;
} }
void StackingContext::paint(PaintContext& context) const void StackingContext::paint(DisplayListRecordingContext& context) const
{ {
auto opacity = paintable_box().computed_values().opacity(); auto opacity = paintable_box().computed_values().opacity();
if (opacity == 0.0f) if (opacity == 0.0f)

12
Libraries/LibWeb/Painting/StackingContext.h
View file

@ -31,10 +31,10 @@ public:
FocusAndOverlay, FocusAndOverlay,
}; };
static void paint_node_as_stacking_context(Paintable const&, PaintContext&); static void paint_node_as_stacking_context(Paintable const&, DisplayListRecordingContext&);
static void paint_descendants(PaintContext&, Paintable const&, StackingContextPaintPhase); static void paint_descendants(DisplayListRecordingContext&, Paintable const&, StackingContextPaintPhase);
static void paint_svg(PaintContext&, PaintableBox const&, PaintPhase); static void paint_svg(DisplayListRecordingContext&, PaintableBox const&, PaintPhase);
void paint(PaintContext&) const; void paint(DisplayListRecordingContext&) const;
[[nodiscard]] TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const; [[nodiscard]] TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const;
@ -56,8 +56,8 @@ private:
Vector<GC::Ref<PaintableBox const>> m_positioned_descendants_and_stacking_contexts_with_stack_level_0; Vector<GC::Ref<PaintableBox const>> m_positioned_descendants_and_stacking_contexts_with_stack_level_0;
Vector<GC::Ref<PaintableBox const>> m_non_positioned_floating_descendants; Vector<GC::Ref<PaintableBox const>> m_non_positioned_floating_descendants;
static void paint_child(PaintContext&, StackingContext const&); static void paint_child(DisplayListRecordingContext&, StackingContext const&);
void paint_internal(PaintContext&) const; void paint_internal(DisplayListRecordingContext&) const;
}; };
} }

10
Libraries/LibWeb/Painting/TableBordersPainting.cpp
View file

@ -243,7 +243,7 @@ static CSS::BorderData css_border_data_from_device_border_data(DeviceBorderData
}; };
} }
static void paint_collected_edges(PaintContext& context, Vector<BorderEdgePaintingInfo>& border_edge_painting_info_list) static void paint_collected_edges(DisplayListRecordingContext& context, Vector<BorderEdgePaintingInfo>& border_edge_painting_info_list)
{ {
// This sorting step isn't part of the specification, but it matches the behavior of other browsers at border intersections, which aren't // This sorting step isn't part of the specification, but it matches the behavior of other browsers at border intersections, which aren't
// part of border conflict resolution in the specification but it's still desirable to handle them in a way which is consistent with it. // part of border conflict resolution in the specification but it's still desirable to handle them in a way which is consistent with it.
@ -297,7 +297,7 @@ static void paint_collected_edges(PaintContext& context, Vector<BorderEdgePainti
} }
} }
static HashMap<CellCoordinates, DevicePixelRect> snap_cells_to_device_coordinates(HashMap<CellCoordinates, PaintableBox const*> const& cell_coordinates_to_box, size_t row_count, size_t column_count, PaintContext const& context) static HashMap<CellCoordinates, DevicePixelRect> snap_cells_to_device_coordinates(HashMap<CellCoordinates, PaintableBox const*> const& cell_coordinates_to_box, size_t row_count, size_t column_count, DisplayListRecordingContext const& context)
{ {
Vector<DevicePixels> y_line_start_coordinates; Vector<DevicePixels> y_line_start_coordinates;
Vector<DevicePixels> y_line_end_coordinates; Vector<DevicePixels> y_line_end_coordinates;
@ -333,7 +333,7 @@ static HashMap<CellCoordinates, DevicePixelRect> snap_cells_to_device_coordinate
return cell_coordinates_to_device_rect; return cell_coordinates_to_device_rect;
} }
static DeviceBorderDataWithElementKind device_border_data_from_css_border_data(Painting::PaintableBox::BorderDataWithElementKind const& border_data_with_element_kind, PaintContext const& context) static DeviceBorderDataWithElementKind device_border_data_from_css_border_data(Painting::PaintableBox::BorderDataWithElementKind const& border_data_with_element_kind, DisplayListRecordingContext const& context)
{ {
return DeviceBorderDataWithElementKind { return DeviceBorderDataWithElementKind {
.border_data = { .border_data = {
@ -345,7 +345,7 @@ static DeviceBorderDataWithElementKind device_border_data_from_css_border_data(P
}; };
} }
static void paint_separate_cell_borders(PaintableBox const& cell_box, HashMap<CellCoordinates, DevicePixelRect> const& cell_coordinates_to_device_rect, PaintContext& context) static void paint_separate_cell_borders(PaintableBox const& cell_box, HashMap<CellCoordinates, DevicePixelRect> const& cell_coordinates_to_device_rect, DisplayListRecordingContext& context)
{ {
auto borders_data = cell_box.override_borders_data().has_value() ? PaintableBox::remove_element_kind_from_borders_data(cell_box.override_borders_data().value()) : BordersData { auto borders_data = cell_box.override_borders_data().has_value() ? PaintableBox::remove_element_kind_from_borders_data(cell_box.override_borders_data().value()) : BordersData {
.top = cell_box.box_model().border.top == 0 ? CSS::BorderData() : cell_box.computed_values().border_top(), .top = cell_box.box_model().border.top == 0 ? CSS::BorderData() : cell_box.computed_values().border_top(),
@ -357,7 +357,7 @@ static void paint_separate_cell_borders(PaintableBox const& cell_box, HashMap<Ce
paint_all_borders(context.display_list_recorder(), cell_rect, cell_box.normalized_border_radii_data().as_corners(context.device_pixel_converter()), borders_data.to_device_pixels(context)); paint_all_borders(context.display_list_recorder(), cell_rect, cell_box.normalized_border_radii_data().as_corners(context.device_pixel_converter()), borders_data.to_device_pixels(context));
} }
void paint_table_borders(PaintContext& context, PaintableBox const& table_paintable) void paint_table_borders(DisplayListRecordingContext& context, PaintableBox const& table_paintable)
{ {
// Partial implementation of painting according to the collapsing border model: // Partial implementation of painting according to the collapsing border model:
// https://www.w3.org/TR/CSS22/tables.html#collapsing-borders // https://www.w3.org/TR/CSS22/tables.html#collapsing-borders

4
Libraries/LibWeb/Painting/TableBordersPainting.h
View file

@ -6,10 +6,8 @@
#pragma once #pragma once
#include <LibWeb/Painting/PaintContext.h>
namespace Web::Painting { namespace Web::Painting {
void paint_table_borders(PaintContext&, PaintableBox const& table_paintable); void paint_table_borders(DisplayListRecordingContext&, PaintableBox const& table_paintable);
} }

4
Libraries/LibWeb/Painting/VideoPaintable.cpp
View file

@ -48,7 +48,7 @@ Layout::VideoBox const& VideoPaintable::layout_box() const
return static_cast<Layout::VideoBox const&>(layout_node()); return static_cast<Layout::VideoBox const&>(layout_node());
} }
void VideoPaintable::paint(PaintContext& context, PaintPhase phase) const void VideoPaintable::paint(DisplayListRecordingContext& context, PaintPhase phase) const
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -179,7 +179,7 @@ void VideoPaintable::paint(PaintContext& context, PaintPhase phase) const
} }
} }
void VideoPaintable::paint_placeholder_video_controls(PaintContext& context, DevicePixelRect video_rect, Optional<DevicePixelPoint> const& mouse_position) const void VideoPaintable::paint_placeholder_video_controls(DisplayListRecordingContext& context, DevicePixelRect video_rect, Optional<DevicePixelPoint> const& mouse_position) const
{ {
auto maximum_control_box_size = context.rounded_device_pixels(100); auto maximum_control_box_size = context.rounded_device_pixels(100);
auto maximum_playback_button_size = context.rounded_device_pixels(40); auto maximum_playback_button_size = context.rounded_device_pixels(40);

4
Libraries/LibWeb/Painting/VideoPaintable.h
View file

@ -18,7 +18,7 @@ class VideoPaintable final : public MediaPaintable {
public: public:
static GC::Ref<VideoPaintable> create(Layout::VideoBox const&); static GC::Ref<VideoPaintable> create(Layout::VideoBox const&);
virtual void paint(PaintContext&, PaintPhase) const override; virtual void paint(DisplayListRecordingContext&, PaintPhase) const override;
Layout::VideoBox& layout_box(); Layout::VideoBox& layout_box();
Layout::VideoBox const& layout_box() const; Layout::VideoBox const& layout_box() const;
@ -26,7 +26,7 @@ public:
private: private:
VideoPaintable(Layout::VideoBox const&); VideoPaintable(Layout::VideoBox const&);
void paint_placeholder_video_controls(PaintContext&, DevicePixelRect video_rect, Optional<DevicePixelPoint> const& mouse_position) const; void paint_placeholder_video_controls(DisplayListRecordingContext&, DevicePixelRect video_rect, Optional<DevicePixelPoint> const& mouse_position) const;
}; };
} }

2
Libraries/LibWeb/Painting/ViewportPaintable.cpp
View file

@ -61,7 +61,7 @@ void ViewportPaintable::build_stacking_context_tree()
stacking_context()->sort(); stacking_context()->sort();
} }
void ViewportPaintable::paint_all_phases(PaintContext& context) void ViewportPaintable::paint_all_phases(DisplayListRecordingContext& context)
{ {
build_stacking_context_tree_if_needed(); build_stacking_context_tree_if_needed();
context.display_list_recorder().save_layer(); context.display_list_recorder().save_layer();

2
Libraries/LibWeb/Painting/ViewportPaintable.h
View file

@ -20,7 +20,7 @@ public:
static GC::Ref<ViewportPaintable> create(Layout::Viewport const&); static GC::Ref<ViewportPaintable> create(Layout::Viewport const&);
virtual ~ViewportPaintable() override; virtual ~ViewportPaintable() override;
void paint_all_phases(PaintContext&); void paint_all_phases(DisplayListRecordingContext&);
void build_stacking_context_tree_if_needed(); void build_stacking_context_tree_if_needed();
void assign_scroll_frames(); void assign_scroll_frames();

2
Libraries/LibWeb/SVG/SVGDecodedImageData.cpp
View file

@ -18,7 +18,7 @@
#include <LibWeb/HTML/WindowProxy.h> #include <LibWeb/HTML/WindowProxy.h>
#include <LibWeb/Page/Page.h> #include <LibWeb/Page/Page.h>
#include <LibWeb/Painting/DisplayListPlayerSkia.h> #include <LibWeb/Painting/DisplayListPlayerSkia.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/DisplayListRecordingContext.h>
#include <LibWeb/Painting/ViewportPaintable.h> #include <LibWeb/Painting/ViewportPaintable.h>
#include <LibWeb/SVG/SVGDecodedImageData.h> #include <LibWeb/SVG/SVGDecodedImageData.h>
#include <LibWeb/SVG/SVGSVGElement.h> #include <LibWeb/SVG/SVGSVGElement.h>