Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-19 15:43:20 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Libraries/LibHTML/Layout/LayoutBlock.h

41 lines
1 KiB
C
Raw Normal View History

LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
#pragma once
LibHTML: Create some subdirectories.
2019-06-15 23:41:15 +02:00
#include <LibHTML/Layout/LayoutNode.h>
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 15:20:13 +02:00
#include <LibHTML/Layout/LineBox.h>
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
class Element;
LibHTML: Add LayoutNodeWithStyle class, make LayoutText style-less Since LayoutText always inherits style, it shouldn't store any style of its own. This patch adds a LayoutNodeWithStyle class to sit between LayoutNode and everyone who wants to inherit from LayoutNode except LayoutText :^) Since LayoutText can never have children, we also know that the parent of any LayoutNode is always going to be a LayoutNodeWithStyle. So this patch makes LayoutNode::parent() return LayoutNodeWithStyle*.
2019-10-07 09:50:31 +02:00
class LayoutBlock : public LayoutNodeWithStyle {
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
public:
LibHTML: LayoutText should always use parent's style properties This patch makes StyleProperties heap-allocated and ref-counted so that a LayoutNode can be without one. The ref-counting also allows anonymous blocks to share style with their parent block. LayoutText never needs a StyleProperties, since text always inherits style from its parent element. This is handled by style_properties().
2019-10-04 12:12:39 +02:00
LayoutBlock(const Node*, NonnullRefPtr<StyleProperties>);
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
virtual ~LayoutBlock() override;
virtual const char* class_name() const override { return "LayoutBlock"; }
LibHTML: Add layout() overrides for LayoutText and LayoutBlock.
2019-06-20 23:00:26 +02:00
virtual void layout() override;
LibHTML: Implement rendering
2019-09-25 12:40:37 +03:00
virtual void render(RenderingContext&) override;
LibHTML: Add layout() overrides for LayoutText and LayoutBlock.
2019-06-20 23:00:26 +02:00
LibHTML: Create anonymous blocks around inline children of blocks.
2019-07-08 17:42:23 +02:00
virtual LayoutNode& inline_wrapper() override;
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 15:20:13 +02:00
bool children_are_inline() const;
Vector<LineBox>& line_boxes() { return m_line_boxes; }
const Vector<LineBox>& line_boxes() const { return m_line_boxes; }
virtual HitTestResult hit_test(const Point&) const override;
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
private:
LibHTML: Start fleshing out block layout. The basic idea of block layout is: width, then children based on width, then height based on height of children.
2019-07-01 07:28:37 +02:00
virtual bool is_block() const override { return true; }
LibHTML: Anonymous blocks *should* inherit some properties Okay, I got that a bit wrong. Here's what CSS 2.1 says: "The properties of anonymous boxes are inherited from the enclosing non-anonymous box. Non-inherited properties have their initial value." This patch implements a better behavior by only copying the inherited properties from the parent style.
2019-10-05 23:47:06 +02:00
NonnullRefPtr<StyleProperties> style_for_anonymous_block() const;
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 15:20:13 +02:00
void layout_inline_children();
void layout_block_children();
LibHTML: Start fleshing out block layout. The basic idea of block layout is: width, then children based on width, then height based on height of children.
2019-07-01 07:28:37 +02:00
void compute_width();
LibHTML: Implement basic block height computation ..and add vertical box properties to the layout tree dumps.
2019-08-18 08:37:53 +02:00
void compute_position();
LibHTML: Start fleshing out block layout. The basic idea of block layout is: width, then children based on width, then height based on height of children.
2019-07-01 07:28:37 +02:00
void compute_height();
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 15:20:13 +02:00
Vector<LineBox> m_line_boxes;
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 22:49:44 +02:00
};
Reference in a new issue Copy permalink