ladybird/Libraries/LibHTML/Layout/LayoutInline.cpp

#include <LibHTML/Layout/LayoutBlock.h>
#include <LibHTML/Layout/LayoutInline.h>

LayoutInline::LayoutInline(const Node& node, RefPtr<StyleProperties> style_properties)
    : LayoutNode(&node, move(style_properties))
{
}

LayoutInline::~LayoutInline()
{
}

void LayoutInline::split_into_lines(LayoutBlock& container)
{
    for_each_child([&](auto& child) {
        if (child.is_inline()) {
            static_cast<LayoutInline&>(child).split_into_lines(container);
        } else {
            // FIXME: Support block children of inlines.
        }
    });
}
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/LayoutBlock.h>`
LibHTML: Create some subdirectories. 2019-06-15 23:41:15 +02:00			`#include <LibHTML/Layout/LayoutInline.h>`
LibHTML: Start fleshing out a basic layout tree. 2019-06-15 22:49:44 +02:00
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			`LayoutInline::LayoutInline(const Node& node, RefPtr<StyleProperties> style_properties)`
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^) 2019-09-21 15:32:17 +03:00			`: LayoutNode(&node, move(style_properties))`
LibHTML: Start fleshing out a basic layout tree. 2019-06-15 22:49:44 +02:00			`{`
			`}`

			`LayoutInline::~LayoutInline()`
			`{`
			`}`
LibHTML: Implement LayoutInline::layout() This currently uses a gross hack where it subtracts 11px from the previous sibling bottom to calculate its top. This should be fixed by switching to a proper two-phase line layouting model, were we first distribute inline elements into lines and figure out their horizontal positions and heights; then compute the needed line heights and position inline elements there vertically. 2019-09-25 12:30:13 +03:00
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 LayoutInline::split_into_lines(LayoutBlock& container)`
			`{`
			`for_each_child([&](auto& child) {`
			`if (child.is_inline()) {`
			`static_cast<LayoutInline&>(child).split_into_lines(container);`
			`} else {`
			`// FIXME: Support block children of inlines.`
			`}`
			`});`
			`}`