mirrors/ladybird
0
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-04-22 04:25:13 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 9

LibHTML: Move layout tree building to Node

Browse source 
This also fixes another bug with inline wrappers. Namely,
we should only add inline wrappers if a block node has
both non-block (inline or text) and block children.
This commit is contained in:
Sergey Bugaev 2019-09-25 12:17:29 +03:00 • committed by Andreas Kling
parent 841ae44392
commit 599edba7a3
Notes: sideshowbarker 2024-07-19 11:56:25 +09:00
3 changed files with 70 additions and 43 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

63
Libraries/LibHTML/DOM/Node.cpp
View file

@ -1,5 +1,11 @@
#include <LibHTML/DOM/Node.h>
#include <LibHTML/DOM/Element.h>
#include <LibHTML/CSS/StyleResolver.h>
#include <LibHTML/Layout/LayoutNode.h>
#include <LibHTML/Layout/LayoutBlock.h>
#include <LibHTML/Layout/LayoutDocument.h>
#include <LibHTML/Layout/LayoutInline.h>
#include <LibHTML/Layout/LayoutText.h>
Node::Node(NodeType type)
: m_type(type)
@ -9,3 +15,60 @@ Node::Node(NodeType type)
Node::~Node()
{
}
RefPtr<LayoutNode> Node::create_layout_node(const StyleResolver& resolver, const StyleProperties* parent_properties) const
{
if (is_document())
return adopt(*new LayoutDocument(static_cast<const Document&>(*this), {}));
auto style_properties = resolver.resolve_style(static_cast<const Element&>(*this), parent_properties);
auto display_property = style_properties.property("display");
String display = display_property.has_value() ? display_property.release_value()->to_string() : "inline";
if (is_text())
return adopt(*new LayoutText(static_cast<const Text&>(*this), move(style_properties)));
if (display == "none")
return nullptr;
if (display == "block" || display == "list-item")
return adopt(*new LayoutBlock(this, move(style_properties)));
if (display == "inline")
return adopt(*new LayoutInline(*this, move(style_properties)));
ASSERT_NOT_REACHED();
}
RefPtr<LayoutNode> Node::create_layout_tree(const StyleResolver& resolver, const StyleProperties* parent_properties) const
{
auto layout_node = create_layout_node(resolver, parent_properties);
if (!layout_node)
return nullptr;
if (!has_children())
return layout_node;
Vector<RefPtr<LayoutNode>> layout_children;
bool have_inline_children = false;
bool have_block_children = false;
static_cast<const ParentNode&>(*this).for_each_child([&](const Node& child) {
auto layout_child = child.create_layout_tree(resolver, &layout_node->style_properties());
if (!layout_child)
return;
if (!layout_child->is_block())
have_inline_children = true;
if (layout_child->is_block())
have_block_children = true;
layout_children.append(move(layout_child));
});
for (auto layout_child : layout_children)
if (have_block_children && have_inline_children && !layout_child->is_block()) {
if (layout_child->is_text() && static_cast<const LayoutText&>(*layout_child).text() == " ")
continue;
layout_node->inline_wrapper().append_child(*layout_child);
} else {
layout_node->append_child(*layout_child);
}
return layout_node;
}

6
Libraries/LibHTML/DOM/Node.h
View file

@ -13,6 +13,9 @@ enum class NodeType : unsigned {
};
class ParentNode;
class LayoutNode;
class StyleResolver;
class StyleProperties;
class Node : public TreeNode<Node> {
public:
@ -24,6 +27,9 @@ public:
bool is_document() const { return type() == NodeType::DOCUMENT_NODE; }
bool is_parent_node() const { return is_element() || is_document(); }
RefPtr<LayoutNode> create_layout_node(const StyleResolver&, const StyleProperties* parent_properties) const;
RefPtr<LayoutNode> create_layout_tree(const StyleResolver&, const StyleProperties* parent_properties) const;
protected:
explicit Node(NodeType);

44
Libraries/LibHTML/Frame.cpp
View file

@ -22,54 +22,12 @@ void Frame::set_document(Document* document)
m_document = document;
}
RefPtr<LayoutNode> Frame::generate_layout_tree()
{
auto resolver = m_document->style_resolver();
auto create_layout_node = [&](const Node& node) -> RefPtr<LayoutNode> {
if (node.is_document())
return adopt(*new LayoutDocument(static_cast<const Document&>(node), {}));
auto style_properties = resolver.resolve_style(static_cast<const Element&>(node));
auto display_property = style_properties.property("display");
String display = display_property.has_value() ? display_property.release_value()->to_string() : "inline";
if (display == "none")
return nullptr;
if (display == "block")
return adopt(*new LayoutBlock(&node, move(style_properties)));
if (display == "inline")
return adopt(*new LayoutInline(node, move(style_properties)));
ASSERT_NOT_REACHED();
};
Function<RefPtr<LayoutNode>(const Node&)> build_layout_tree;
build_layout_tree = [&](const Node& node) -> RefPtr<LayoutNode> {
auto layout_node = create_layout_node(node);
if (!layout_node)
return nullptr;
if (!node.has_children())
return layout_node;
static_cast<const ParentNode&>(node).for_each_child([&](const Node& child) {
auto layout_child = build_layout_tree(child);
if (!layout_child)
return;
if (layout_child->is_inline())
layout_node->inline_wrapper().append_child(*layout_child);
else
layout_node->append_child(*layout_child);
});
return layout_node;
};
return build_layout_tree(*m_document);
}
void Frame::layout()
{
if (!m_document)
return;
auto layout_root = generate_layout_tree();
auto layout_root = m_document->create_layout_tree(m_document->style_resolver(), nullptr);
layout_root->style().size().set_width(m_size.width());