2022-03-10 17:38:34 +03:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
|
|
|
|
*
|
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
|
|
*/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <LibWeb/Layout/InlineNode.h>
|
2022-03-11 01:13:37 +03:00
|
|
|
#include <LibWeb/Painting/PaintableBox.h>
|
2024-01-13 15:11:31 +03:00
|
|
|
#include <LibWeb/Painting/PaintableFragment.h>
|
2022-03-10 17:38:34 +03:00
|
|
|
|
|
|
|
namespace Web::Painting {
|
|
|
|
|
|
|
|
class InlinePaintable final : public Paintable {
|
2023-01-11 14:51:49 +03:00
|
|
|
JS_CELL(InlinePaintable, Paintable);
|
|
|
|
|
2022-03-10 17:38:34 +03:00
|
|
|
public:
|
2023-01-11 14:51:49 +03:00
|
|
|
static JS::NonnullGCPtr<InlinePaintable> create(Layout::InlineNode const&);
|
2022-03-10 17:38:34 +03:00
|
|
|
|
|
|
|
virtual void paint(PaintContext&, PaintPhase) const override;
|
|
|
|
|
LibWeb: Move clip rect calculation to happen before painting
With this change, clip rectangles for boxes with hidden overflow or the
clip property are no longer calculated during the recording of painting
commands. Instead, it has moved to the "pre-paint" phase, along with
the assignment of scrolling offsets, and works in the following way:
1. The paintable tree is traversed to collect all paintable boxes that
have hidden overflow or use the CSS clip property. For each of these
boxes, the "final" clip rectangle is calculated by intersecting clip
rectangles in the containing block chain for a box.
2. The paintable tree is traversed another time, and a clip rectangle
is assigned for each paintable box contained by a node with hidden
overflow or the clip property.
This way, clipping becomes much easier during the painting commands
recording phase, as it only concerns the use of already assigned clip
rectangles. The same approach is applied to handle scrolling offsets.
Also, clip rectangle calculation is now implemented more correctly, as
we no longer stop at the stacking context boundary while intersecting
clip rectangles in the containing block chain.
Fixes:
https://github.com/SerenityOS/serenity/issues/22932
https://github.com/SerenityOS/serenity/issues/22883
https://github.com/SerenityOS/serenity/issues/22679
https://github.com/SerenityOS/serenity/issues/22534
2024-01-26 23:47:26 +03:00
|
|
|
virtual void before_paint(PaintContext& context, PaintPhase) const override;
|
|
|
|
virtual void after_paint(PaintContext& context, PaintPhase) const override;
|
|
|
|
|
2022-03-10 17:38:34 +03:00
|
|
|
Layout::InlineNode const& layout_node() const;
|
|
|
|
auto const& box_model() const { return layout_node().box_model(); }
|
|
|
|
|
2023-12-14 10:16:45 +03:00
|
|
|
CSSPixelRect bounding_rect() const;
|
2024-01-13 15:11:31 +03:00
|
|
|
Vector<PaintableFragment> const& fragments() const { return m_fragments; }
|
|
|
|
Vector<PaintableFragment>& fragments() { return m_fragments; }
|
2023-12-14 10:16:45 +03:00
|
|
|
|
2024-01-03 04:40:31 +03:00
|
|
|
virtual bool is_inline_paintable() const override { return true; }
|
|
|
|
|
2024-02-13 23:34:07 +03:00
|
|
|
virtual TraversalDecision hit_test(CSSPixelPoint, HitTestType, Function<TraversalDecision(HitTestResult)> const& callback) const override;
|
2024-01-03 21:00:04 +03:00
|
|
|
|
2024-01-13 17:32:31 +03:00
|
|
|
void set_box_shadow_data(Vector<ShadowData>&& box_shadow_data) { m_box_shadow_data = move(box_shadow_data); }
|
|
|
|
Vector<ShadowData> const& box_shadow_data() const { return m_box_shadow_data; }
|
|
|
|
|
2024-02-11 03:56:39 +03:00
|
|
|
void set_outline_data(Optional<BordersData> outline_data) { m_outline_data = outline_data; }
|
|
|
|
Optional<BordersData> const& outline_data() const { return m_outline_data; }
|
|
|
|
|
|
|
|
void set_outline_offset(CSSPixels outline_offset) { m_outline_offset = outline_offset; }
|
|
|
|
CSSPixels outline_offset() const { return m_outline_offset; }
|
|
|
|
|
2024-02-08 19:30:07 +03:00
|
|
|
void set_enclosing_scroll_frame(RefPtr<ScrollFrame> scroll_frame) { m_enclosing_scroll_frame = scroll_frame; }
|
|
|
|
void set_enclosing_clip_frame(RefPtr<ClipFrame> clip_frame) { m_enclosing_clip_frame = clip_frame; }
|
|
|
|
|
|
|
|
Optional<int> scroll_frame_id() const;
|
|
|
|
Optional<CSSPixelPoint> enclosing_scroll_frame_offset() const;
|
|
|
|
Optional<CSSPixelRect> clip_rect() const;
|
LibWeb: Move clip rect calculation to happen before painting
With this change, clip rectangles for boxes with hidden overflow or the
clip property are no longer calculated during the recording of painting
commands. Instead, it has moved to the "pre-paint" phase, along with
the assignment of scrolling offsets, and works in the following way:
1. The paintable tree is traversed to collect all paintable boxes that
have hidden overflow or use the CSS clip property. For each of these
boxes, the "final" clip rectangle is calculated by intersecting clip
rectangles in the containing block chain for a box.
2. The paintable tree is traversed another time, and a clip rectangle
is assigned for each paintable box contained by a node with hidden
overflow or the clip property.
This way, clipping becomes much easier during the painting commands
recording phase, as it only concerns the use of already assigned clip
rectangles. The same approach is applied to handle scrolling offsets.
Also, clip rectangle calculation is now implemented more correctly, as
we no longer stop at the stacking context boundary while intersecting
clip rectangles in the containing block chain.
Fixes:
https://github.com/SerenityOS/serenity/issues/22932
https://github.com/SerenityOS/serenity/issues/22883
https://github.com/SerenityOS/serenity/issues/22679
https://github.com/SerenityOS/serenity/issues/22534
2024-01-26 23:47:26 +03:00
|
|
|
|
2022-03-10 17:38:34 +03:00
|
|
|
private:
|
|
|
|
InlinePaintable(Layout::InlineNode const&);
|
|
|
|
|
|
|
|
template<typename Callback>
|
|
|
|
void for_each_fragment(Callback) const;
|
2024-01-13 17:32:31 +03:00
|
|
|
|
LibWeb: Move clip rect calculation to happen before painting
With this change, clip rectangles for boxes with hidden overflow or the
clip property are no longer calculated during the recording of painting
commands. Instead, it has moved to the "pre-paint" phase, along with
the assignment of scrolling offsets, and works in the following way:
1. The paintable tree is traversed to collect all paintable boxes that
have hidden overflow or use the CSS clip property. For each of these
boxes, the "final" clip rectangle is calculated by intersecting clip
rectangles in the containing block chain for a box.
2. The paintable tree is traversed another time, and a clip rectangle
is assigned for each paintable box contained by a node with hidden
overflow or the clip property.
This way, clipping becomes much easier during the painting commands
recording phase, as it only concerns the use of already assigned clip
rectangles. The same approach is applied to handle scrolling offsets.
Also, clip rectangle calculation is now implemented more correctly, as
we no longer stop at the stacking context boundary while intersecting
clip rectangles in the containing block chain.
Fixes:
https://github.com/SerenityOS/serenity/issues/22932
https://github.com/SerenityOS/serenity/issues/22883
https://github.com/SerenityOS/serenity/issues/22679
https://github.com/SerenityOS/serenity/issues/22534
2024-01-26 23:47:26 +03:00
|
|
|
Optional<CSSPixelRect> m_clip_rect;
|
2024-02-08 19:30:07 +03:00
|
|
|
RefPtr<ScrollFrame const> m_enclosing_scroll_frame;
|
|
|
|
RefPtr<ClipFrame const> m_enclosing_clip_frame;
|
LibWeb: Move clip rect calculation to happen before painting
With this change, clip rectangles for boxes with hidden overflow or the
clip property are no longer calculated during the recording of painting
commands. Instead, it has moved to the "pre-paint" phase, along with
the assignment of scrolling offsets, and works in the following way:
1. The paintable tree is traversed to collect all paintable boxes that
have hidden overflow or use the CSS clip property. For each of these
boxes, the "final" clip rectangle is calculated by intersecting clip
rectangles in the containing block chain for a box.
2. The paintable tree is traversed another time, and a clip rectangle
is assigned for each paintable box contained by a node with hidden
overflow or the clip property.
This way, clipping becomes much easier during the painting commands
recording phase, as it only concerns the use of already assigned clip
rectangles. The same approach is applied to handle scrolling offsets.
Also, clip rectangle calculation is now implemented more correctly, as
we no longer stop at the stacking context boundary while intersecting
clip rectangles in the containing block chain.
Fixes:
https://github.com/SerenityOS/serenity/issues/22932
https://github.com/SerenityOS/serenity/issues/22883
https://github.com/SerenityOS/serenity/issues/22679
https://github.com/SerenityOS/serenity/issues/22534
2024-01-26 23:47:26 +03:00
|
|
|
|
2024-01-13 17:32:31 +03:00
|
|
|
Vector<ShadowData> m_box_shadow_data;
|
2024-02-11 03:56:39 +03:00
|
|
|
Optional<BordersData> m_outline_data;
|
|
|
|
CSSPixels m_outline_offset { 0 };
|
2024-01-13 15:11:31 +03:00
|
|
|
Vector<PaintableFragment> m_fragments;
|
2022-03-10 17:38:34 +03:00
|
|
|
};
|
|
|
|
|
2024-03-02 11:54:45 +03:00
|
|
|
template<>
|
|
|
|
inline bool Paintable::fast_is<InlinePaintable>() const { return is_inline_paintable(); }
|
|
|
|
|
2022-03-10 17:38:34 +03:00
|
|
|
}
|