PaintableBox.h 12 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312
  1. /*
  2. * Copyright (c) 2022, Andreas Kling <kling@serenityos.org>
  3. *
  4. * SPDX-License-Identifier: BSD-2-Clause
  5. */
  6. #pragma once
  7. #include <LibWeb/Painting/BorderPainting.h>
  8. #include <LibWeb/Painting/BorderRadiusCornerClipper.h>
  9. #include <LibWeb/Painting/ClipFrame.h>
  10. #include <LibWeb/Painting/Paintable.h>
  11. #include <LibWeb/Painting/PaintableFragment.h>
  12. #include <LibWeb/Painting/ShadowPainting.h>
  13. namespace Web::Painting {
  14. struct ScrollFrame : public RefCounted<ScrollFrame> {
  15. i32 id { -1 };
  16. CSSPixelPoint offset;
  17. };
  18. class PaintableBox : public Paintable {
  19. JS_CELL(PaintableBox, Paintable);
  20. public:
  21. static JS::NonnullGCPtr<PaintableBox> create(Layout::Box const&);
  22. virtual ~PaintableBox();
  23. virtual void before_paint(PaintContext&, PaintPhase) const override;
  24. virtual void after_paint(PaintContext&, PaintPhase) const override;
  25. virtual void paint(PaintContext&, PaintPhase) const override;
  26. virtual Optional<CSSPixelRect> get_masking_area() const { return {}; }
  27. virtual Optional<Gfx::Bitmap::MaskKind> get_mask_type() const { return {}; }
  28. virtual RefPtr<Gfx::Bitmap> calculate_mask(PaintContext&, CSSPixelRect const&) const { return {}; }
  29. Layout::Box& layout_box() { return static_cast<Layout::Box&>(Paintable::layout_node()); }
  30. Layout::Box const& layout_box() const { return static_cast<Layout::Box const&>(Paintable::layout_node()); }
  31. auto const& box_model() const { return layout_box().box_model(); }
  32. struct OverflowData {
  33. CSSPixelRect scrollable_overflow_rect;
  34. bool has_scrollable_overflow { false };
  35. CSSPixelPoint scroll_offset {};
  36. };
  37. CSSPixelRect absolute_rect() const;
  38. // Offset from the top left of the containing block's content edge.
  39. [[nodiscard]] CSSPixelPoint offset() const;
  40. CSSPixelPoint scroll_offset() const;
  41. void set_scroll_offset(CSSPixelPoint);
  42. void scroll_by(int delta_x, int delta_y);
  43. void set_offset(CSSPixelPoint);
  44. void set_offset(float x, float y) { set_offset({ x, y }); }
  45. CSSPixelSize const& content_size() const { return m_content_size; }
  46. void set_content_size(CSSPixelSize);
  47. void set_content_size(CSSPixels width, CSSPixels height) { set_content_size({ width, height }); }
  48. void set_content_width(CSSPixels width) { set_content_size(width, content_height()); }
  49. void set_content_height(CSSPixels height) { set_content_size(content_width(), height); }
  50. CSSPixels content_width() const { return m_content_size.width(); }
  51. CSSPixels content_height() const { return m_content_size.height(); }
  52. CSSPixelRect absolute_padding_box_rect() const
  53. {
  54. auto absolute_rect = this->absolute_rect();
  55. CSSPixelRect rect;
  56. rect.set_x(absolute_rect.x() - box_model().padding.left);
  57. rect.set_width(content_width() + box_model().padding.left + box_model().padding.right);
  58. rect.set_y(absolute_rect.y() - box_model().padding.top);
  59. rect.set_height(content_height() + box_model().padding.top + box_model().padding.bottom);
  60. return rect;
  61. }
  62. CSSPixelRect absolute_border_box_rect() const
  63. {
  64. auto padded_rect = this->absolute_padding_box_rect();
  65. CSSPixelRect rect;
  66. auto use_collapsing_borders_model = override_borders_data().has_value();
  67. // Implement the collapsing border model https://www.w3.org/TR/CSS22/tables.html#collapsing-borders.
  68. auto border_top = use_collapsing_borders_model ? round(box_model().border.top / 2) : box_model().border.top;
  69. auto border_bottom = use_collapsing_borders_model ? round(box_model().border.bottom / 2) : box_model().border.bottom;
  70. auto border_left = use_collapsing_borders_model ? round(box_model().border.left / 2) : box_model().border.left;
  71. auto border_right = use_collapsing_borders_model ? round(box_model().border.right / 2) : box_model().border.right;
  72. rect.set_x(padded_rect.x() - border_left);
  73. rect.set_width(padded_rect.width() + border_left + border_right);
  74. rect.set_y(padded_rect.y() - border_top);
  75. rect.set_height(padded_rect.height() + border_top + border_bottom);
  76. return rect;
  77. }
  78. CSSPixelRect absolute_paint_rect() const;
  79. CSSPixels border_box_width() const
  80. {
  81. auto border_box = box_model().border_box();
  82. return content_width() + border_box.left + border_box.right;
  83. }
  84. CSSPixels border_box_height() const
  85. {
  86. auto border_box = box_model().border_box();
  87. return content_height() + border_box.top + border_box.bottom;
  88. }
  89. CSSPixels absolute_x() const { return absolute_rect().x(); }
  90. CSSPixels absolute_y() const { return absolute_rect().y(); }
  91. CSSPixelPoint absolute_position() const { return absolute_rect().location(); }
  92. [[nodiscard]] bool has_scrollable_overflow() const { return m_overflow_data->has_scrollable_overflow; }
  93. [[nodiscard]] Optional<CSSPixelRect> scrollable_overflow_rect() const
  94. {
  95. if (!m_overflow_data.has_value())
  96. return {};
  97. return m_overflow_data->scrollable_overflow_rect;
  98. }
  99. void set_overflow_data(OverflowData data) { m_overflow_data = move(data); }
  100. DOM::Node const* dom_node() const { return layout_box().dom_node(); }
  101. DOM::Node* dom_node() { return layout_box().dom_node(); }
  102. virtual void set_needs_display() const override;
  103. virtual void apply_scroll_offset(PaintContext&, PaintPhase) const override;
  104. virtual void reset_scroll_offset(PaintContext&, PaintPhase) const override;
  105. virtual void apply_clip_overflow_rect(PaintContext&, PaintPhase) const override;
  106. virtual void clear_clip_overflow_rect(PaintContext&, PaintPhase) const override;
  107. [[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint position, HitTestType type, Function<TraversalDecision(HitTestResult)> const& callback) const override;
  108. Optional<HitTestResult> hit_test(CSSPixelPoint, HitTestType) const;
  109. virtual bool handle_mousewheel(Badge<EventHandler>, CSSPixelPoint, unsigned buttons, unsigned modifiers, int wheel_delta_x, int wheel_delta_y) override;
  110. enum class ConflictingElementKind {
  111. Cell,
  112. Row,
  113. RowGroup,
  114. Column,
  115. ColumnGroup,
  116. Table,
  117. };
  118. struct BorderDataWithElementKind {
  119. CSS::BorderData border_data;
  120. ConflictingElementKind element_kind;
  121. };
  122. struct BordersDataWithElementKind {
  123. BorderDataWithElementKind top;
  124. BorderDataWithElementKind right;
  125. BorderDataWithElementKind bottom;
  126. BorderDataWithElementKind left;
  127. };
  128. void set_override_borders_data(BordersDataWithElementKind const& override_borders_data) { m_override_borders_data = override_borders_data; }
  129. Optional<BordersDataWithElementKind> const& override_borders_data() const { return m_override_borders_data; }
  130. static BordersData remove_element_kind_from_borders_data(PaintableBox::BordersDataWithElementKind borders_data);
  131. struct TableCellCoordinates {
  132. size_t row_index;
  133. size_t column_index;
  134. size_t row_span;
  135. size_t column_span;
  136. };
  137. void set_table_cell_coordinates(TableCellCoordinates const& table_cell_coordinates) { m_table_cell_coordinates = table_cell_coordinates; }
  138. auto const& table_cell_coordinates() const { return m_table_cell_coordinates; }
  139. enum class ShrinkRadiiForBorders {
  140. Yes,
  141. No
  142. };
  143. BorderRadiiData normalized_border_radii_data(ShrinkRadiiForBorders shrink = ShrinkRadiiForBorders::No) const;
  144. BorderRadiiData const& border_radii_data() const { return m_border_radii_data; }
  145. void set_border_radii_data(BorderRadiiData const& border_radii_data) { m_border_radii_data = border_radii_data; }
  146. void set_box_shadow_data(Vector<ShadowData> box_shadow_data) { m_box_shadow_data = move(box_shadow_data); }
  147. Vector<ShadowData> const& box_shadow_data() const { return m_box_shadow_data; }
  148. void set_transform(Gfx::FloatMatrix4x4 transform) { m_transform = transform; }
  149. Gfx::FloatMatrix4x4 const& transform() const { return m_transform; }
  150. void set_transform_origin(CSSPixelPoint transform_origin) { m_transform_origin = transform_origin; }
  151. CSSPixelPoint const& transform_origin() const { return m_transform_origin; }
  152. void set_outline_data(Optional<BordersData> outline_data) { m_outline_data = outline_data; }
  153. Optional<BordersData> const& outline_data() const { return m_outline_data; }
  154. void set_outline_offset(CSSPixels outline_offset) { m_outline_offset = outline_offset; }
  155. CSSPixels outline_offset() const { return m_outline_offset; }
  156. CSSPixelRect compute_absolute_padding_rect_with_css_transform_applied() const;
  157. Gfx::AffineTransform compute_combined_css_transform() const;
  158. Optional<CSSPixelRect> get_clip_rect() const;
  159. void set_enclosing_scroll_frame(RefPtr<ScrollFrame> scroll_frame) { m_enclosing_scroll_frame = scroll_frame; }
  160. void set_enclosing_clip_frame(RefPtr<ClipFrame> clip_frame) { m_enclosing_clip_frame = clip_frame; }
  161. Optional<int> scroll_frame_id() const;
  162. Optional<CSSPixelPoint> enclosing_scroll_frame_offset() const;
  163. Optional<CSSPixelRect> clip_rect() const;
  164. Span<BorderRadiiClip const> border_radii_clips() const;
  165. protected:
  166. explicit PaintableBox(Layout::Box const&);
  167. virtual void paint_border(PaintContext&) const;
  168. virtual void paint_backdrop_filter(PaintContext&) const;
  169. virtual void paint_background(PaintContext&) const;
  170. virtual void paint_box_shadow(PaintContext&) const;
  171. virtual CSSPixelRect compute_absolute_rect() const;
  172. virtual CSSPixelRect compute_absolute_paint_rect() const;
  173. private:
  174. [[nodiscard]] virtual bool is_paintable_box() const final { return true; }
  175. Optional<OverflowData> m_overflow_data;
  176. CSSPixelPoint m_offset;
  177. CSSPixelSize m_content_size;
  178. Optional<CSSPixelRect> mutable m_absolute_rect;
  179. Optional<CSSPixelRect> mutable m_absolute_paint_rect;
  180. mutable bool m_clipping_overflow { false };
  181. mutable Vector<u32> m_corner_clipper_ids;
  182. RefPtr<ScrollFrame const> m_enclosing_scroll_frame;
  183. RefPtr<ClipFrame const> m_enclosing_clip_frame;
  184. Optional<BordersDataWithElementKind> m_override_borders_data;
  185. Optional<TableCellCoordinates> m_table_cell_coordinates;
  186. BorderRadiiData m_border_radii_data;
  187. Vector<ShadowData> m_box_shadow_data;
  188. Gfx::FloatMatrix4x4 m_transform { Gfx::FloatMatrix4x4::identity() };
  189. CSSPixelPoint m_transform_origin;
  190. Optional<BordersData> m_outline_data;
  191. CSSPixels m_outline_offset { 0 };
  192. };
  193. class PaintableWithLines : public PaintableBox {
  194. JS_CELL(PaintableWithLines, PaintableBox);
  195. public:
  196. static JS::NonnullGCPtr<PaintableWithLines> create(Layout::BlockContainer const&);
  197. virtual ~PaintableWithLines() override;
  198. Layout::BlockContainer const& layout_box() const;
  199. Layout::BlockContainer& layout_box();
  200. Vector<PaintableFragment> const& fragments() const { return m_fragments; }
  201. Vector<PaintableFragment>& fragments() { return m_fragments; }
  202. void add_fragment(Layout::LineBoxFragment const& fragment)
  203. {
  204. m_fragments.append(PaintableFragment { fragment });
  205. }
  206. void set_fragments(Vector<PaintableFragment>&& fragments) { m_fragments = move(fragments); }
  207. template<typename Callback>
  208. void for_each_fragment(Callback callback) const
  209. {
  210. for (auto& fragment : m_fragments) {
  211. if (callback(fragment) == IterationDecision::Break)
  212. return;
  213. }
  214. }
  215. virtual void paint(PaintContext&, PaintPhase) const override;
  216. virtual bool wants_mouse_events() const override { return false; }
  217. [[nodiscard]] virtual TraversalDecision hit_test(CSSPixelPoint position, HitTestType type, Function<TraversalDecision(HitTestResult)> const& callback) const override;
  218. virtual void visit_edges(Cell::Visitor& visitor) override
  219. {
  220. Base::visit_edges(visitor);
  221. for (auto& fragment : m_fragments)
  222. visitor.visit(JS::NonnullGCPtr { fragment.layout_node() });
  223. }
  224. protected:
  225. PaintableWithLines(Layout::BlockContainer const&);
  226. private:
  227. [[nodiscard]] virtual bool is_paintable_with_lines() const final { return true; }
  228. Vector<PaintableFragment> m_fragments;
  229. };
  230. void paint_text_decoration(PaintContext& context, Layout::Node const& text_node, PaintableFragment const& fragment);
  231. void paint_cursor_if_needed(PaintContext& context, Layout::TextNode const& text_node, PaintableFragment const& fragment);
  232. void paint_text_fragment(PaintContext& context, Layout::TextNode const& text_node, PaintableFragment const& fragment, PaintPhase phase);
  233. }