1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-25 06:47:35 +00:00

LibWeb: Rename LayoutNode classes and move them into Layout namespace

Bring the names of various boxes closer to spec language. This should
hopefully make things easier to understand and hack on. :^)

Some notable changes:

- LayoutNode -> Layout::Node
- LayoutBox -> Layout::Box
- LayoutBlock -> Layout::BlockBox
- LayoutReplaced -> Layout::ReplacedBox
- LayoutDocument -> Layout::InitialContainingBlockBox
- LayoutText -> Layout::TextNode
- LayoutInline -> Layout::InlineNode

Note that this is not strictly a "box tree" as we also hang inline/text
nodes in the same tree, and they don't generate boxes. (Instead, they
contribute line box fragments to their containing block!)
This commit is contained in:
Andreas Kling 2020-11-22 15:53:01 +01:00
parent f358f2255f
commit 5aeab9878e
114 changed files with 863 additions and 880 deletions

View file

@ -68,7 +68,7 @@ InspectorWidget::InspectorWidget()
m_layout_tree_view = top_tab_widget.add_tab<GUI::TreeView>("Layout"); m_layout_tree_view = top_tab_widget.add_tab<GUI::TreeView>("Layout");
m_layout_tree_view->on_selection = [this](auto& index) { m_layout_tree_view->on_selection = [this](auto& index) {
auto* node = static_cast<Web::LayoutNode*>(index.internal_data()); auto* node = static_cast<Web::Layout::Node*>(index.internal_data());
set_inspected_node(node->dom_node()); set_inspected_node(node->dom_node());
}; };

View file

@ -52,10 +52,10 @@
#include <LibWeb/DOMTreeModel.h> #include <LibWeb/DOMTreeModel.h>
#include <LibWeb/Dump.h> #include <LibWeb/Dump.h>
#include <LibWeb/InProcessWebView.h> #include <LibWeb/InProcessWebView.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutInline.h> #include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/Loader/ResourceLoader.h> #include <LibWeb/Loader/ResourceLoader.h>
#include <LibWeb/OutOfProcessWebView.h> #include <LibWeb/OutOfProcessWebView.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>

View file

@ -34,7 +34,7 @@
#include <LibGUI/Model.h> #include <LibGUI/Model.h>
#include <LibGUI/Splitter.h> #include <LibGUI/Splitter.h>
#include <LibMarkdown/Document.h> #include <LibMarkdown/Document.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/OutOfProcessWebView.h> #include <LibWeb/OutOfProcessWebView.h>
namespace Spreadsheet { namespace Spreadsheet {

View file

@ -133,39 +133,39 @@ set(SOURCES
HTML/Parser/StackOfOpenElements.cpp HTML/Parser/StackOfOpenElements.cpp
HighResolutionTime/Performance.cpp HighResolutionTime/Performance.cpp
InProcessWebView.cpp InProcessWebView.cpp
Layout/BlockBox.cpp
Layout/BlockFormattingContext.cpp Layout/BlockFormattingContext.cpp
Layout/Box.cpp
Layout/BoxModelMetrics.cpp Layout/BoxModelMetrics.cpp
Layout/BreakNode.cpp
Layout/ButtonBox.cpp
Layout/CanvasBox.cpp
Layout/CheckBox.cpp
Layout/FormattingContext.cpp Layout/FormattingContext.cpp
Layout/FrameBox.cpp
Layout/ImageBox.cpp
Layout/InitialContainingBlockBox.cpp
Layout/InlineFormattingContext.cpp Layout/InlineFormattingContext.cpp
Layout/LayoutBlock.cpp Layout/InlineNode.cpp
Layout/LayoutBox.cpp
Layout/LayoutBreak.cpp
Layout/LayoutButton.cpp
Layout/LayoutCanvas.cpp
Layout/LayoutCheckBox.cpp
Layout/LayoutDocument.cpp
Layout/LayoutFrame.cpp
Layout/LayoutImage.cpp
Layout/LayoutInline.cpp
Layout/LayoutListItem.cpp
Layout/LayoutListItemMarker.cpp
Layout/LayoutNode.cpp
Layout/LayoutPosition.cpp Layout/LayoutPosition.cpp
Layout/LayoutReplaced.cpp
Layout/LayoutSVG.cpp
Layout/LayoutSVGGraphics.cpp
Layout/LayoutSVGPath.cpp
Layout/LayoutSVGSVG.cpp
Layout/LayoutTable.cpp
Layout/LayoutTableCell.cpp
Layout/LayoutTableRow.cpp
Layout/LayoutTableRowGroup.cpp
Layout/LayoutText.cpp
Layout/LayoutTreeBuilder.cpp Layout/LayoutTreeBuilder.cpp
Layout/LayoutWidget.cpp
Layout/LineBox.cpp Layout/LineBox.cpp
Layout/LineBoxFragment.cpp Layout/LineBoxFragment.cpp
Layout/ListItemBox.cpp
Layout/ListItemMarkerBox.cpp
Layout/Node.cpp
Layout/ReplacedBox.cpp
Layout/SVGBox.cpp
Layout/SVGGraphicsBox.cpp
Layout/SVGPathBox.cpp
Layout/SVGSVGBox.cpp
Layout/TableBox.cpp
Layout/TableCellBox.cpp
Layout/TableFormattingContext.cpp Layout/TableFormattingContext.cpp
Layout/TableRowBox.cpp
Layout/TableRowGroupBox.cpp
Layout/TextNode.cpp
Layout/WidgetBox.cpp
LayoutTreeModel.cpp LayoutTreeModel.cpp
Loader/FrameLoader.cpp Loader/FrameLoader.cpp
Loader/ImageLoader.cpp Loader/ImageLoader.cpp

View file

@ -31,7 +31,7 @@
namespace Web::CSS { namespace Web::CSS {
float Length::relative_length_to_px(const LayoutNode& layout_node) const float Length::relative_length_to_px(const Layout::Node& layout_node) const
{ {
switch (m_type) { switch (m_type) {
case Type::Ex: case Type::Ex:

View file

@ -68,7 +68,7 @@ public:
static Length make_auto() { return Length(0, Type::Auto); } static Length make_auto() { return Length(0, Type::Auto); }
static Length make_px(float value) { return Length(value, Type::Px); } static Length make_px(float value) { return Length(value, Type::Px); }
Length resolved(const Length& fallback_for_undefined, const LayoutNode& layout_node, float reference_for_percent) const Length resolved(const Length& fallback_for_undefined, const Layout::Node& layout_node, float reference_for_percent) const
{ {
if (is_undefined()) if (is_undefined())
return fallback_for_undefined; return fallback_for_undefined;
@ -79,12 +79,12 @@ public:
return *this; return *this;
} }
Length resolved_or_auto(const LayoutNode& layout_node, float reference_for_percent) const Length resolved_or_auto(const Layout::Node& layout_node, float reference_for_percent) const
{ {
return resolved(make_auto(), layout_node, reference_for_percent); return resolved(make_auto(), layout_node, reference_for_percent);
} }
Length resolved_or_zero(const LayoutNode& layout_node, float reference_for_percent) const Length resolved_or_zero(const Layout::Node& layout_node, float reference_for_percent) const
{ {
return resolved(make_px(0), layout_node, reference_for_percent); return resolved(make_px(0), layout_node, reference_for_percent);
} }
@ -117,7 +117,7 @@ public:
} }
float raw_value() const { return m_value; } float raw_value() const { return m_value; }
ALWAYS_INLINE float to_px(const LayoutNode& layout_node) const ALWAYS_INLINE float to_px(const Layout::Node& layout_node) const
{ {
if (is_relative()) if (is_relative())
return relative_length_to_px(layout_node); return relative_length_to_px(layout_node);
@ -155,7 +155,7 @@ public:
} }
private: private:
float relative_length_to_px(const LayoutNode&) const; float relative_length_to_px(const Layout::Node&) const;
const char* unit_name() const; const char* unit_name() const;

View file

@ -173,7 +173,7 @@ void StyleProperties::load_font() const
FontCache::the().set({ font_family, font_weight }, *m_font); FontCache::the().set({ font_family, font_weight }, *m_font);
} }
float StyleProperties::line_height(const LayoutNode& layout_node) const float StyleProperties::line_height(const Layout::Node& layout_node) const
{ {
auto line_height_length = length_or_fallback(CSS::PropertyID::LineHeight, Length::make_auto()); auto line_height_length = length_or_fallback(CSS::PropertyID::LineHeight, Length::make_auto());
if (line_height_length.is_absolute()) if (line_height_length.is_absolute())

View file

@ -72,7 +72,7 @@ public:
return *m_font; return *m_font;
} }
float line_height(const LayoutNode&) const; float line_height(const Layout::Node&) const;
bool operator==(const StyleProperties&) const; bool operator==(const StyleProperties&) const;
bool operator!=(const StyleProperties& other) const { return !(*this == other); } bool operator!=(const StyleProperties& other) const { return !(*this == other); }

View file

@ -25,7 +25,7 @@
*/ */
#include <LibWeb/DOM/Comment.h> #include <LibWeb/DOM/Comment.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
namespace Web::DOM { namespace Web::DOM {

View file

@ -54,7 +54,7 @@
#include <LibWeb/HTML/HTMLTitleElement.h> #include <LibWeb/HTML/HTMLTitleElement.h>
#include <LibWeb/InProcessWebView.h> #include <LibWeb/InProcessWebView.h>
#include <LibWeb/Layout/BlockFormattingContext.h> #include <LibWeb/Layout/BlockFormattingContext.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutTreeBuilder.h> #include <LibWeb/Layout/LayoutTreeBuilder.h>
#include <LibWeb/Namespace.h> #include <LibWeb/Namespace.h>
#include <LibWeb/Origin.h> #include <LibWeb/Origin.h>
@ -271,7 +271,7 @@ void Document::tear_down_layout_tree()
// Gather up all the layout nodes in a vector and detach them from parents // Gather up all the layout nodes in a vector and detach them from parents
// while the vector keeps them alive. // while the vector keeps them alive.
NonnullRefPtrVector<LayoutNode> layout_nodes; NonnullRefPtrVector<Layout::Node> layout_nodes;
m_layout_root->for_each_in_subtree([&](auto& layout_node) { m_layout_root->for_each_in_subtree([&](auto& layout_node) {
layout_nodes.append(layout_node); layout_nodes.append(layout_node);
@ -347,12 +347,12 @@ void Document::layout()
return; return;
if (!m_layout_root) { if (!m_layout_root) {
LayoutTreeBuilder tree_builder; Layout::LayoutTreeBuilder tree_builder;
m_layout_root = static_ptr_cast<LayoutDocument>(tree_builder.build(*this)); m_layout_root = static_ptr_cast<Layout::InitialContainingBlockBox>(tree_builder.build(*this));
} }
Layout::BlockFormattingContext root_formatting_context(*m_layout_root); Layout::BlockFormattingContext root_formatting_context(*m_layout_root);
root_formatting_context.run(LayoutMode::Default); root_formatting_context.run(Layout::LayoutMode::Default);
m_layout_root->set_needs_display(); m_layout_root->set_needs_display();
@ -380,9 +380,9 @@ void Document::update_layout()
layout(); layout();
} }
RefPtr<LayoutNode> Document::create_layout_node(const CSS::StyleProperties*) RefPtr<Layout::Node> Document::create_layout_node(const CSS::StyleProperties*)
{ {
return adopt(*new LayoutDocument(*this, CSS::StyleProperties::create())); return adopt(*new Layout::InitialContainingBlockBox(*this, CSS::StyleProperties::create()));
} }
void Document::set_link_color(Color color) void Document::set_link_color(Color color)
@ -400,14 +400,14 @@ void Document::set_visited_link_color(Color color)
m_visited_link_color = color; m_visited_link_color = color;
} }
const LayoutDocument* Document::layout_node() const const Layout::InitialContainingBlockBox* Document::layout_node() const
{ {
return static_cast<const LayoutDocument*>(Node::layout_node()); return static_cast<const Layout::InitialContainingBlockBox*>(Node::layout_node());
} }
LayoutDocument* Document::layout_node() Layout::InitialContainingBlockBox* Document::layout_node()
{ {
return static_cast<LayoutDocument*>(Node::layout_node()); return static_cast<Layout::InitialContainingBlockBox*>(Node::layout_node());
} }
void Document::set_inspected_node(Node* node) void Document::set_inspected_node(Node* node)

View file

@ -125,8 +125,8 @@ public:
virtual bool is_child_allowed(const Node&) const override; virtual bool is_child_allowed(const Node&) const override;
const LayoutDocument* layout_node() const; const Layout::InitialContainingBlockBox* layout_node() const;
LayoutDocument* layout_node(); Layout::InitialContainingBlockBox* layout_node();
void schedule_style_update(); void schedule_style_update();
@ -212,7 +212,7 @@ public:
private: private:
explicit Document(const URL&); explicit Document(const URL&);
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
void tear_down_layout_tree(); void tear_down_layout_tree();
@ -244,7 +244,7 @@ private:
RefPtr<Window> m_window; RefPtr<Window> m_window;
RefPtr<LayoutDocument> m_layout_root; RefPtr<Layout::InitialContainingBlockBox> m_layout_root;
Optional<Color> m_link_color; Optional<Color> m_link_color;
Optional<Color> m_active_link_color; Optional<Color> m_active_link_color;

View file

@ -34,14 +34,14 @@
#include <LibWeb/DOM/Text.h> #include <LibWeb/DOM/Text.h>
#include <LibWeb/Dump.h> #include <LibWeb/Dump.h>
#include <LibWeb/HTML/Parser/HTMLDocumentParser.h> #include <LibWeb/HTML/Parser/HTMLDocumentParser.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutInline.h> #include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LayoutListItem.h>
#include <LibWeb/Layout/LayoutTable.h>
#include <LibWeb/Layout/LayoutTableCell.h>
#include <LibWeb/Layout/LayoutTableRow.h>
#include <LibWeb/Layout/LayoutTableRowGroup.h>
#include <LibWeb/Layout/LayoutTreeBuilder.h> #include <LibWeb/Layout/LayoutTreeBuilder.h>
#include <LibWeb/Layout/ListItemBox.h>
#include <LibWeb/Layout/TableBox.h>
#include <LibWeb/Layout/TableCellBox.h>
#include <LibWeb/Layout/TableRowBox.h>
#include <LibWeb/Layout/TableRowGroupBox.h>
namespace Web::DOM { namespace Web::DOM {
@ -112,7 +112,7 @@ bool Element::has_class(const FlyString& class_name) const
return false; return false;
} }
RefPtr<LayoutNode> Element::create_layout_node(const CSS::StyleProperties* parent_style) RefPtr<Layout::Node> Element::create_layout_node(const CSS::StyleProperties* parent_style)
{ {
auto style = document().style_resolver().resolve_style(*this, parent_style); auto style = document().style_resolver().resolve_style(*this, parent_style);
const_cast<Element&>(*this).m_resolved_style = style; const_cast<Element&>(*this).m_resolved_style = style;
@ -125,26 +125,26 @@ RefPtr<LayoutNode> Element::create_layout_node(const CSS::StyleProperties* paren
return nullptr; return nullptr;
if (display == CSS::Display::Block) if (display == CSS::Display::Block)
return adopt(*new LayoutBlock(document(), this, move(style))); return adopt(*new Layout::BlockBox(document(), this, move(style)));
if (display == CSS::Display::Inline) { if (display == CSS::Display::Inline) {
if (style->float_().value_or(CSS::Float::None) != CSS::Float::None) if (style->float_().value_or(CSS::Float::None) != CSS::Float::None)
return adopt(*new LayoutBlock(document(), this, move(style))); return adopt(*new Layout::BlockBox(document(), this, move(style)));
return adopt(*new LayoutInline(document(), *this, move(style))); return adopt(*new Layout::InlineNode(document(), *this, move(style)));
} }
if (display == CSS::Display::ListItem) if (display == CSS::Display::ListItem)
return adopt(*new LayoutListItem(document(), *this, move(style))); return adopt(*new Layout::ListItemBox(document(), *this, move(style)));
if (display == CSS::Display::Table) if (display == CSS::Display::Table)
return adopt(*new LayoutTable(document(), *this, move(style))); return adopt(*new Layout::TableBox(document(), *this, move(style)));
if (display == CSS::Display::TableRow) if (display == CSS::Display::TableRow)
return adopt(*new LayoutTableRow(document(), *this, move(style))); return adopt(*new Layout::TableRowBox(document(), *this, move(style)));
if (display == CSS::Display::TableCell) if (display == CSS::Display::TableCell)
return adopt(*new LayoutTableCell(document(), *this, move(style))); return adopt(*new Layout::TableCellBox(document(), *this, move(style)));
if (display == CSS::Display::TableRowGroup || display == CSS::Display::TableHeaderGroup || display == CSS::Display::TableFooterGroup) if (display == CSS::Display::TableRowGroup || display == CSS::Display::TableHeaderGroup || display == CSS::Display::TableFooterGroup)
return adopt(*new LayoutTableRowGroup(document(), *this, move(style))); return adopt(*new Layout::TableRowGroupBox(document(), *this, move(style)));
if (display == CSS::Display::InlineBlock) { if (display == CSS::Display::InlineBlock) {
auto inline_block = adopt(*new LayoutBlock(document(), this, move(style))); auto inline_block = adopt(*new Layout::BlockBox(document(), this, move(style)));
inline_block->set_inline(true); inline_block->set_inline(true);
return inline_block; return inline_block;
} }
@ -206,7 +206,7 @@ void Element::recompute_style()
if (style->display() == CSS::Display::None) if (style->display() == CSS::Display::None)
return; return;
// We need a new layout tree here! // We need a new layout tree here!
LayoutTreeBuilder tree_builder; Layout::LayoutTreeBuilder tree_builder;
tree_builder.build(*this); tree_builder.build(*this);
return; return;
} }

View file

@ -33,7 +33,7 @@
#include <LibWeb/DOM/ParentNode.h> #include <LibWeb/DOM/ParentNode.h>
#include <LibWeb/DOM/TagNames.h> #include <LibWeb/DOM/TagNames.h>
#include <LibWeb/HTML/AttributeNames.h> #include <LibWeb/HTML/AttributeNames.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/QualifiedName.h> #include <LibWeb/QualifiedName.h>
namespace Web::DOM { namespace Web::DOM {
@ -82,8 +82,8 @@ public:
void recompute_style(); void recompute_style();
LayoutNodeWithStyle* layout_node() { return static_cast<LayoutNodeWithStyle*>(Node::layout_node()); } Layout::NodeWithStyle* layout_node() { return static_cast<Layout::NodeWithStyle*>(Node::layout_node()); }
const LayoutNodeWithStyle* layout_node() const { return static_cast<const LayoutNodeWithStyle*>(Node::layout_node()); } const Layout::NodeWithStyle* layout_node() const { return static_cast<const Layout::NodeWithStyle*>(Node::layout_node()); }
String name() const { return attribute(HTML::AttributeNames::name); } String name() const { return attribute(HTML::AttributeNames::name); }
@ -97,7 +97,7 @@ public:
virtual bool is_focusable() const { return false; } virtual bool is_focusable() const { return false; }
protected: protected:
RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
private: private:
Attribute* find_attribute(const FlyString& name); Attribute* find_attribute(const FlyString& name);

View file

@ -39,11 +39,11 @@
#include <LibWeb/DOM/EventListener.h> #include <LibWeb/DOM/EventListener.h>
#include <LibWeb/DOM/Node.h> #include <LibWeb/DOM/Node.h>
#include <LibWeb/HTML/HTMLAnchorElement.h> #include <LibWeb/HTML/HTMLAnchorElement.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutInline.h> #include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
//#define EVENT_DEBUG //#define EVENT_DEBUG
@ -105,7 +105,7 @@ void Node::set_text_content(const String& content)
document().invalidate_layout(); document().invalidate_layout();
} }
RefPtr<LayoutNode> Node::create_layout_node(const CSS::StyleProperties*) RefPtr<Layout::Node> Node::create_layout_node(const CSS::StyleProperties*)
{ {
return nullptr; return nullptr;
} }
@ -230,7 +230,7 @@ void Node::removed_last_ref()
delete this; delete this;
} }
void Node::set_layout_node(Badge<LayoutNode>, LayoutNode* layout_node) const void Node::set_layout_node(Badge<Layout::Node>, Layout::Node* layout_node) const
{ {
if (layout_node) if (layout_node)
m_layout_node = layout_node->make_weak_ptr(); m_layout_node = layout_node->make_weak_ptr();

View file

@ -84,7 +84,7 @@ public:
RefPtr<Node> insert_before(NonnullRefPtr<Node> node, RefPtr<Node> child, bool notify = true); RefPtr<Node> insert_before(NonnullRefPtr<Node> node, RefPtr<Node> child, bool notify = true);
void remove_all_children(); void remove_all_children();
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style); virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style);
virtual FlyString node_name() const = 0; virtual FlyString node_name() const = 0;
@ -115,10 +115,10 @@ public:
virtual void removed_from(Node&) { } virtual void removed_from(Node&) { }
virtual void children_changed() { } virtual void children_changed() { }
const LayoutNode* layout_node() const { return m_layout_node; } const Layout::Node* layout_node() const { return m_layout_node; }
LayoutNode* layout_node() { return m_layout_node; } Layout::Node* layout_node() { return m_layout_node; }
void set_layout_node(Badge<LayoutNode>, LayoutNode*) const; void set_layout_node(Badge<Layout::Node>, Layout::Node*) const;
virtual bool is_child_allowed(const Node&) const { return true; } virtual bool is_child_allowed(const Node&) const { return true; }
@ -138,7 +138,7 @@ protected:
Node(Document&, NodeType); Node(Document&, NodeType);
Document* m_document { nullptr }; Document* m_document { nullptr };
mutable WeakPtr<LayoutNode> m_layout_node; mutable WeakPtr<Layout::Node> m_layout_node;
NodeType m_type { NodeType::INVALID }; NodeType m_type { NodeType::INVALID };
bool m_needs_style_update { true }; bool m_needs_style_update { true };
}; };

View file

@ -25,7 +25,7 @@
*/ */
#include <LibWeb/DOM/Text.h> #include <LibWeb/DOM/Text.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
namespace Web::DOM { namespace Web::DOM {
@ -38,9 +38,9 @@ Text::~Text()
{ {
} }
RefPtr<LayoutNode> Text::create_layout_node(const CSS::StyleProperties*) RefPtr<Layout::Node> Text::create_layout_node(const CSS::StyleProperties*)
{ {
return adopt(*new LayoutText(document(), *this)); return adopt(*new Layout::TextNode(document(), *this));
} }
} }

View file

@ -42,7 +42,7 @@ public:
virtual FlyString node_name() const override { return "#text"; } virtual FlyString node_name() const override { return "#text"; }
private: private:
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
}; };
} }

View file

@ -37,9 +37,9 @@
#include <LibWeb/DOM/Text.h> #include <LibWeb/DOM/Text.h>
#include <LibWeb/Dump.h> #include <LibWeb/Dump.h>
#include <LibWeb/HTML/HTMLTemplateElement.h> #include <LibWeb/HTML/HTMLTemplateElement.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
#include <stdio.h> #include <stdio.h>
namespace Web { namespace Web {
@ -80,7 +80,7 @@ void dump_tree(const DOM::Node& node)
--indent; --indent;
} }
void dump_tree(const LayoutNode& layout_node) void dump_tree(const Layout::Node& layout_node)
{ {
static size_t indent = 0; static size_t indent = 0;
for (size_t i = 0; i < indent; ++i) for (size_t i = 0; i < indent; ++i)
@ -117,7 +117,7 @@ void dump_tree(const LayoutNode& layout_node)
if (!layout_node.is_box()) { if (!layout_node.is_box()) {
dbgprintf("%s {\033[33m%s\033[0m%s}\n", layout_node.class_name(), tag_name.characters(), identifier.characters()); dbgprintf("%s {\033[33m%s\033[0m%s}\n", layout_node.class_name(), tag_name.characters(), identifier.characters());
} else { } else {
auto& layout_box = downcast<LayoutBox>(layout_node); auto& layout_box = downcast<Layout::Box>(layout_node);
dbgprintf("%s {\033[34m%s\033[0m%s} at (%g,%g) size %gx%g", dbgprintf("%s {\033[34m%s\033[0m%s} at (%g,%g) size %gx%g",
layout_box.class_name(), layout_box.class_name(),
tag_name.characters(), tag_name.characters(),
@ -150,8 +150,8 @@ void dump_tree(const LayoutNode& layout_node)
dbgprintf("\n"); dbgprintf("\n");
} }
if (layout_node.is_block() && static_cast<const LayoutBlock&>(layout_node).children_are_inline()) { if (layout_node.is_block() && static_cast<const Layout::BlockBox&>(layout_node).children_are_inline()) {
auto& block = static_cast<const LayoutBlock&>(layout_node); auto& block = static_cast<const Layout::BlockBox&>(layout_node);
for (size_t i = 0; i < indent; ++i) for (size_t i = 0; i < indent; ++i)
dbgprintf(" "); dbgprintf(" ");
dbgprintf(" Line boxes (%d):\n", block.line_boxes().size()); dbgprintf(" Line boxes (%d):\n", block.line_boxes().size());
@ -174,7 +174,7 @@ void dump_tree(const LayoutNode& layout_node)
if (fragment.layout_node().is_text()) { if (fragment.layout_node().is_text()) {
for (size_t i = 0; i < indent; ++i) for (size_t i = 0; i < indent; ++i)
dbgprintf(" "); dbgprintf(" ");
auto& layout_text = static_cast<const LayoutText&>(fragment.layout_node()); auto& layout_text = static_cast<const Layout::TextNode&>(fragment.layout_node());
auto fragment_text = layout_text.text_for_rendering().substring(fragment.start(), fragment.length()); auto fragment_text = layout_text.text_for_rendering().substring(fragment.start(), fragment.length());
dbgprintf(" text: \"%s\"\n", fragment_text.characters()); dbgprintf(" text: \"%s\"\n", fragment_text.characters());
} }

View file

@ -31,7 +31,7 @@
namespace Web { namespace Web {
void dump_tree(const DOM::Node&); void dump_tree(const DOM::Node&);
void dump_tree(const LayoutNode&); void dump_tree(const Layout::Node&);
void dump_sheet(const CSS::StyleSheet&); void dump_sheet(const CSS::StyleSheet&);
void dump_rule(const CSS::StyleRule&); void dump_rule(const CSS::StyleRule&);
void dump_selector(const CSS::Selector&); void dump_selector(const CSS::Selector&);

View file

@ -26,10 +26,6 @@
#pragma once #pragma once
namespace Web {
enum class LayoutMode;
}
namespace Web::CSS { namespace Web::CSS {
class Selector; class Selector;
class StyleProperties; class StyleProperties;
@ -151,9 +147,18 @@ class SVGSVGElement;
} }
namespace Web::Layout { namespace Web::Layout {
enum class LayoutMode;
class BlockBox;
class BlockFormattingContext; class BlockFormattingContext;
class Box;
class ButtonBox;
class CheckBox;
class InitialContainingBlockBox;
class FormattingContext; class FormattingContext;
class InlineFormattingContext; class InlineFormattingContext;
class Node;
class NodeWithStyle;
class ReplacedBox;
} }
namespace Web { namespace Web {
@ -161,14 +166,6 @@ class EventHandler;
class Frame; class Frame;
class FrameLoader; class FrameLoader;
class InProcessWebView; class InProcessWebView;
class LayoutBlock;
class LayoutBox;
class LayoutButton;
class LayoutCheckBox;
class LayoutDocument;
class LayoutNode;
class LayoutNodeWithStyle;
class LayoutReplaced;
class LineBox; class LineBox;
class LineBoxFragment; class LineBoxFragment;
class LoadRequest; class LoadRequest;

View file

@ -25,7 +25,7 @@
*/ */
#include <LibWeb/HTML/HTMLBRElement.h> #include <LibWeb/HTML/HTMLBRElement.h>
#include <LibWeb/Layout/LayoutBreak.h> #include <LibWeb/Layout/BreakNode.h>
namespace Web::HTML { namespace Web::HTML {
@ -38,9 +38,9 @@ HTMLBRElement::~HTMLBRElement()
{ {
} }
RefPtr<LayoutNode> HTMLBRElement::create_layout_node(const CSS::StyleProperties*) RefPtr<Layout::Node> HTMLBRElement::create_layout_node(const CSS::StyleProperties*)
{ {
return adopt(*new LayoutBreak(document(), *this)); return adopt(*new Layout::BreakNode(document(), *this));
} }
} }

View file

@ -37,7 +37,7 @@ public:
HTMLBRElement(DOM::Document&, const QualifiedName& qualified_name); HTMLBRElement(DOM::Document&, const QualifiedName& qualified_name);
virtual ~HTMLBRElement() override; virtual ~HTMLBRElement() override;
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
}; };
} }

View file

@ -28,7 +28,7 @@
#include <LibWeb/CSS/StyleProperties.h> #include <LibWeb/CSS/StyleProperties.h>
#include <LibWeb/CSS/StyleValue.h> #include <LibWeb/CSS/StyleValue.h>
#include <LibWeb/HTML/HTMLBlinkElement.h> #include <LibWeb/HTML/HTMLBlinkElement.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
namespace Web::HTML { namespace Web::HTML {

View file

@ -30,7 +30,7 @@
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/HTML/CanvasRenderingContext2D.h> #include <LibWeb/HTML/CanvasRenderingContext2D.h>
#include <LibWeb/HTML/HTMLCanvasElement.h> #include <LibWeb/HTML/HTMLCanvasElement.h>
#include <LibWeb/Layout/LayoutCanvas.h> #include <LibWeb/Layout/CanvasBox.h>
namespace Web::HTML { namespace Web::HTML {
@ -55,12 +55,12 @@ unsigned HTMLCanvasElement::height() const
return attribute(HTML::AttributeNames::height).to_uint().value_or(150); return attribute(HTML::AttributeNames::height).to_uint().value_or(150);
} }
RefPtr<LayoutNode> HTMLCanvasElement::create_layout_node(const CSS::StyleProperties* parent_style) RefPtr<Layout::Node> HTMLCanvasElement::create_layout_node(const CSS::StyleProperties* parent_style)
{ {
auto style = document().style_resolver().resolve_style(*this, parent_style); auto style = document().style_resolver().resolve_style(*this, parent_style);
if (style->display() == CSS::Display::None) if (style->display() == CSS::Display::None)
return nullptr; return nullptr;
return adopt(*new LayoutCanvas(document(), *this, move(style))); return adopt(*new Layout::CanvasBox(document(), *this, move(style)));
} }
CanvasRenderingContext2D* HTMLCanvasElement::get_context(String type) CanvasRenderingContext2D* HTMLCanvasElement::get_context(String type)

View file

@ -32,8 +32,6 @@
namespace Web::HTML { namespace Web::HTML {
class LayoutDocument;
class HTMLCanvasElement final : public HTMLElement { class HTMLCanvasElement final : public HTMLElement {
public: public:
using WrapperType = Bindings::HTMLCanvasElementWrapper; using WrapperType = Bindings::HTMLCanvasElementWrapper;
@ -51,7 +49,7 @@ public:
unsigned height() const; unsigned height() const;
private: private:
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
RefPtr<Gfx::Bitmap> m_bitmap; RefPtr<Gfx::Bitmap> m_bitmap;
RefPtr<CanvasRenderingContext2D> m_context; RefPtr<CanvasRenderingContext2D> m_context;

View file

@ -27,7 +27,7 @@
#include <AK/StringBuilder.h> #include <AK/StringBuilder.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/HTML/HTMLElement.h> #include <LibWeb/HTML/HTMLElement.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
namespace Web::HTML { namespace Web::HTML {
@ -117,10 +117,10 @@ String HTMLElement::inner_text()
if (!layout_node()) if (!layout_node())
return text_content(); return text_content();
Function<void(const LayoutNode&)> recurse = [&](auto& node) { Function<void(const Layout::Node&)> recurse = [&](auto& node) {
for (auto* child = node.first_child(); child; child = child->next_sibling()) { for (auto* child = node.first_child(); child; child = child->next_sibling()) {
if (child->is_text()) if (child->is_text())
builder.append(downcast<LayoutText>(*child).text_for_rendering()); builder.append(downcast<Layout::TextNode>(*child).text_for_rendering());
if (child->is_break()) if (child->is_break())
builder.append('\n'); builder.append('\n');
recurse(*child); recurse(*child);

View file

@ -35,8 +35,7 @@
#include <LibWeb/HTML/HTMLIFrameElement.h> #include <LibWeb/HTML/HTMLIFrameElement.h>
#include <LibWeb/HTML/Parser/HTMLDocumentParser.h> #include <LibWeb/HTML/Parser/HTMLDocumentParser.h>
#include <LibWeb/InProcessWebView.h> #include <LibWeb/InProcessWebView.h>
#include <LibWeb/Layout/LayoutFrame.h> #include <LibWeb/Layout/FrameBox.h>
#include <LibWeb/Layout/LayoutWidget.h>
#include <LibWeb/Loader/ResourceLoader.h> #include <LibWeb/Loader/ResourceLoader.h>
#include <LibWeb/Origin.h> #include <LibWeb/Origin.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
@ -52,10 +51,10 @@ HTMLIFrameElement::~HTMLIFrameElement()
{ {
} }
RefPtr<LayoutNode> HTMLIFrameElement::create_layout_node(const CSS::StyleProperties* parent_style) RefPtr<Layout::Node> HTMLIFrameElement::create_layout_node(const CSS::StyleProperties* parent_style)
{ {
auto style = document().style_resolver().resolve_style(*this, parent_style); auto style = document().style_resolver().resolve_style(*this, parent_style);
return adopt(*new LayoutFrame(document(), *this, move(style))); return adopt(*new Layout::FrameBox(document(), *this, move(style)));
} }
void HTMLIFrameElement::document_did_attach_to_frame(Frame& frame) void HTMLIFrameElement::document_did_attach_to_frame(Frame& frame)

View file

@ -37,7 +37,7 @@ public:
HTMLIFrameElement(DOM::Document&, const QualifiedName& qualified_name); HTMLIFrameElement(DOM::Document&, const QualifiedName& qualified_name);
virtual ~HTMLIFrameElement() override; virtual ~HTMLIFrameElement() override;
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
Frame* content_frame() { return m_content_frame; } Frame* content_frame() { return m_content_frame; }
const Frame* content_frame() const { return m_content_frame; } const Frame* content_frame() const { return m_content_frame; }

View file

@ -31,7 +31,7 @@
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Event.h> #include <LibWeb/DOM/Event.h>
#include <LibWeb/HTML/HTMLImageElement.h> #include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/Layout/LayoutImage.h> #include <LibWeb/Layout/ImageBox.h>
#include <LibWeb/Loader/ResourceLoader.h> #include <LibWeb/Loader/ResourceLoader.h>
namespace Web::HTML { namespace Web::HTML {
@ -83,12 +83,12 @@ void HTMLImageElement::parse_attribute(const FlyString& name, const String& valu
m_image_loader.load(document().complete_url(value)); m_image_loader.load(document().complete_url(value));
} }
RefPtr<LayoutNode> HTMLImageElement::create_layout_node(const CSS::StyleProperties* parent_style) RefPtr<Layout::Node> HTMLImageElement::create_layout_node(const CSS::StyleProperties* parent_style)
{ {
auto style = document().style_resolver().resolve_style(*this, parent_style); auto style = document().style_resolver().resolve_style(*this, parent_style);
if (style->display() == CSS::Display::None) if (style->display() == CSS::Display::None)
return nullptr; return nullptr;
return adopt(*new LayoutImage(document(), *this, move(style), m_image_loader)); return adopt(*new Layout::ImageBox(document(), *this, move(style), m_image_loader));
} }
const Gfx::Bitmap* HTMLImageElement::bitmap() const const Gfx::Bitmap* HTMLImageElement::bitmap() const

View file

@ -53,7 +53,7 @@ private:
void animate(); void animate();
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
ImageLoader m_image_loader; ImageLoader m_image_loader;
}; };

View file

@ -31,9 +31,9 @@
#include <LibWeb/HTML/HTMLFormElement.h> #include <LibWeb/HTML/HTMLFormElement.h>
#include <LibWeb/HTML/HTMLInputElement.h> #include <LibWeb/HTML/HTMLInputElement.h>
#include <LibWeb/InProcessWebView.h> #include <LibWeb/InProcessWebView.h>
#include <LibWeb/Layout/LayoutButton.h> #include <LibWeb/Layout/ButtonBox.h>
#include <LibWeb/Layout/LayoutCheckBox.h> #include <LibWeb/Layout/CheckBox.h>
#include <LibWeb/Layout/LayoutWidget.h> #include <LibWeb/Layout/WidgetBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web::HTML { namespace Web::HTML {
@ -47,7 +47,7 @@ HTMLInputElement::~HTMLInputElement()
{ {
} }
void HTMLInputElement::did_click_button(Badge<LayoutButton>) void HTMLInputElement::did_click_button(Badge<Layout::ButtonBox>)
{ {
dispatch_event(DOM::Event::create("click")); dispatch_event(DOM::Event::create("click"));
@ -60,7 +60,7 @@ void HTMLInputElement::did_click_button(Badge<LayoutButton>)
} }
} }
RefPtr<LayoutNode> HTMLInputElement::create_layout_node(const CSS::StyleProperties* parent_style) RefPtr<Layout::Node> HTMLInputElement::create_layout_node(const CSS::StyleProperties* parent_style)
{ {
ASSERT(document().page()); ASSERT(document().page());
auto& page = *document().page(); auto& page = *document().page();
@ -74,15 +74,15 @@ RefPtr<LayoutNode> HTMLInputElement::create_layout_node(const CSS::StyleProperti
return nullptr; return nullptr;
if (type().equals_ignoring_case("submit") || type().equals_ignoring_case("button")) if (type().equals_ignoring_case("submit") || type().equals_ignoring_case("button"))
return adopt(*new LayoutButton(document(), *this, move(style))); return adopt(*new Layout::ButtonBox(document(), *this, move(style)));
if (type() == "checkbox") if (type() == "checkbox")
return adopt(*new LayoutCheckBox(document(), *this, move(style))); return adopt(*new Layout::CheckBox(document(), *this, move(style)));
auto& text_box = page_view.add<GUI::TextBox>(); auto& text_box = page_view.add<GUI::TextBox>();
text_box.set_text(value()); text_box.set_text(value());
text_box.on_change = [this] { text_box.on_change = [this] {
auto& widget = downcast<LayoutWidget>(layout_node())->widget(); auto& widget = downcast<Layout::WidgetBox>(layout_node())->widget();
const_cast<HTMLInputElement*>(this)->set_attribute(HTML::AttributeNames::value, static_cast<const GUI::TextBox&>(widget).text()); const_cast<HTMLInputElement*>(this)->set_attribute(HTML::AttributeNames::value, static_cast<const GUI::TextBox&>(widget).text());
}; };
int text_width = Gfx::Font::default_font().width(value()); int text_width = Gfx::Font::default_font().width(value());
@ -93,7 +93,7 @@ RefPtr<LayoutNode> HTMLInputElement::create_layout_node(const CSS::StyleProperti
text_width = Gfx::Font::default_font().glyph_width('x') * size.value(); text_width = Gfx::Font::default_font().glyph_width('x') * size.value();
} }
text_box.set_relative_rect(0, 0, text_width + 20, 20); text_box.set_relative_rect(0, 0, text_width + 20, 20);
return adopt(*new LayoutWidget(document(), *this, text_box)); return adopt(*new Layout::WidgetBox(document(), *this, text_box));
} }
void HTMLInputElement::set_checked(bool checked) void HTMLInputElement::set_checked(bool checked)

View file

@ -37,7 +37,7 @@ public:
HTMLInputElement(DOM::Document&, const QualifiedName& qualified_name); HTMLInputElement(DOM::Document&, const QualifiedName& qualified_name);
virtual ~HTMLInputElement() override; virtual ~HTMLInputElement() override;
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
String type() const { return attribute(HTML::AttributeNames::type); } String type() const { return attribute(HTML::AttributeNames::type); }
String value() const { return attribute(HTML::AttributeNames::value); } String value() const { return attribute(HTML::AttributeNames::value); }
@ -48,7 +48,7 @@ public:
bool enabled() const; bool enabled() const;
void did_click_button(Badge<LayoutButton>); void did_click_button(Badge<Layout::ButtonBox>);
private: private:
bool m_checked { false }; bool m_checked { false };

View file

@ -30,7 +30,7 @@
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Event.h> #include <LibWeb/DOM/Event.h>
#include <LibWeb/HTML/HTMLObjectElement.h> #include <LibWeb/HTML/HTMLObjectElement.h>
#include <LibWeb/Layout/LayoutImage.h> #include <LibWeb/Layout/ImageBox.h>
#include <LibWeb/Loader/ResourceLoader.h> #include <LibWeb/Loader/ResourceLoader.h>
namespace Web::HTML { namespace Web::HTML {
@ -61,7 +61,7 @@ void HTMLObjectElement::parse_attribute(const FlyString& name, const String& val
m_image_loader.load(document().complete_url(value)); m_image_loader.load(document().complete_url(value));
} }
RefPtr<LayoutNode> HTMLObjectElement::create_layout_node(const CSS::StyleProperties* parent_style) RefPtr<Layout::Node> HTMLObjectElement::create_layout_node(const CSS::StyleProperties* parent_style)
{ {
if (m_should_show_fallback_content) if (m_should_show_fallback_content)
return HTMLElement::create_layout_node(parent_style); return HTMLElement::create_layout_node(parent_style);
@ -70,7 +70,7 @@ RefPtr<LayoutNode> HTMLObjectElement::create_layout_node(const CSS::StylePropert
if (style->display() == CSS::Display::None) if (style->display() == CSS::Display::None)
return nullptr; return nullptr;
if (m_image_loader.has_image()) if (m_image_loader.has_image())
return adopt(*new LayoutImage(document(), *this, move(style), m_image_loader)); return adopt(*new Layout::ImageBox(document(), *this, move(style), m_image_loader));
return nullptr; return nullptr;
} }

View file

@ -46,7 +46,7 @@ public:
String type() const { return attribute(HTML::AttributeNames::type); } String type() const { return attribute(HTML::AttributeNames::type); }
private: private:
virtual RefPtr<LayoutNode> create_layout_node(const CSS::StyleProperties* parent_style) override; virtual RefPtr<Layout::Node> create_layout_node(const CSS::StyleProperties* parent_style) override;
ImageLoader m_image_loader; ImageLoader m_image_loader;
bool m_should_show_fallback_content { false }; bool m_should_show_fallback_content { false };

View file

@ -46,10 +46,10 @@
#include <LibWeb/HTML/HTMLImageElement.h> #include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/HTML/Parser/HTMLDocumentParser.h> #include <LibWeb/HTML/Parser/HTMLDocumentParser.h>
#include <LibWeb/InProcessWebView.h> #include <LibWeb/InProcessWebView.h>
#include <LibWeb/Layout/LayoutBreak.h> #include <LibWeb/Layout/BreakNode.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
#include <LibWeb/Loader/ResourceLoader.h> #include <LibWeb/Loader/ResourceLoader.h>
#include <LibWeb/Page/EventHandler.h> #include <LibWeb/Page/EventHandler.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
@ -89,21 +89,21 @@ void InProcessWebView::select_all()
if (!layout_root) if (!layout_root)
return; return;
const LayoutNode* first_layout_node = layout_root; const Layout::Node* first_layout_node = layout_root;
for (;;) { for (;;) {
auto* next = first_layout_node->next_in_pre_order(); auto* next = first_layout_node->next_in_pre_order();
if (!next) if (!next)
break; break;
first_layout_node = next; first_layout_node = next;
if (is<LayoutText>(*first_layout_node)) if (is<Layout::TextNode>(*first_layout_node))
break; break;
} }
const LayoutNode* last_layout_node = first_layout_node; const Layout::Node* last_layout_node = first_layout_node;
for (const LayoutNode* layout_node = first_layout_node; layout_node; layout_node = layout_node->next_in_pre_order()) { for (const Layout::Node* layout_node = first_layout_node; layout_node; layout_node = layout_node->next_in_pre_order()) {
if (is<LayoutText>(*layout_node)) if (is<Layout::TextNode>(*layout_node))
last_layout_node = layout_node; last_layout_node = layout_node;
} }
@ -111,8 +111,8 @@ void InProcessWebView::select_all()
ASSERT(last_layout_node); ASSERT(last_layout_node);
int last_layout_node_index_in_node = 0; int last_layout_node_index_in_node = 0;
if (is<LayoutText>(*last_layout_node)) if (is<Layout::TextNode>(*last_layout_node))
last_layout_node_index_in_node = downcast<LayoutText>(*last_layout_node).text_for_rendering().length() - 1; last_layout_node_index_in_node = downcast<Layout::TextNode>(*last_layout_node).text_for_rendering().length() - 1;
layout_root->set_selection({ { first_layout_node, 0 }, { last_layout_node, last_layout_node_index_in_node } }); layout_root->set_selection({ { first_layout_node, 0 }, { last_layout_node, last_layout_node_index_in_node } });
update(); update();
@ -369,16 +369,16 @@ bool InProcessWebView::load(const URL& url)
return page().main_frame().loader().load(url, FrameLoader::Type::Navigation); return page().main_frame().loader().load(url, FrameLoader::Type::Navigation);
} }
const LayoutDocument* InProcessWebView::layout_root() const const Layout::InitialContainingBlockBox* InProcessWebView::layout_root() const
{ {
return document() ? document()->layout_node() : nullptr; return document() ? document()->layout_node() : nullptr;
} }
LayoutDocument* InProcessWebView::layout_root() Layout::InitialContainingBlockBox* InProcessWebView::layout_root()
{ {
if (!document()) if (!document())
return nullptr; return nullptr;
return const_cast<LayoutDocument*>(document()->layout_node()); return const_cast<Layout::InitialContainingBlockBox*>(document()->layout_node());
} }
void InProcessWebView::page_did_request_scroll_into_view(const Gfx::IntRect& rect) void InProcessWebView::page_did_request_scroll_into_view(const Gfx::IntRect& rect)

View file

@ -51,8 +51,8 @@ public:
void set_document(DOM::Document*); void set_document(DOM::Document*);
const LayoutDocument* layout_root() const; const Layout::InitialContainingBlockBox* layout_root() const;
LayoutDocument* layout_root(); Layout::InitialContainingBlockBox* layout_root();
void reload(); void reload();
bool load(const URL&); bool load(const URL&);

View file

@ -28,40 +28,40 @@
#include <LibWeb/CSS/StyleResolver.h> #include <LibWeb/CSS/StyleResolver.h>
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Dump.h> #include <LibWeb/Dump.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutInline.h> #include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
#include <LibWeb/Layout/LayoutWidget.h> #include <LibWeb/Layout/WidgetBox.h>
#include <math.h> #include <math.h>
namespace Web { namespace Web::Layout {
LayoutBlock::LayoutBlock(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> style) BlockBox::BlockBox(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBox(document, node, move(style)) : Box(document, node, move(style))
{ {
} }
LayoutBlock::~LayoutBlock() BlockBox::~BlockBox()
{ {
} }
LayoutNode& LayoutBlock::inline_wrapper() Node& BlockBox::inline_wrapper()
{ {
if (!last_child() || !last_child()->is_block() || last_child()->dom_node() != nullptr) { if (!last_child() || !last_child()->is_block() || last_child()->dom_node() != nullptr) {
append_child(adopt(*new LayoutBlock(document(), nullptr, style_for_anonymous_block()))); append_child(adopt(*new BlockBox(document(), nullptr, style_for_anonymous_block())));
last_child()->set_children_are_inline(true); last_child()->set_children_are_inline(true);
} }
return *last_child(); return *last_child();
} }
void LayoutBlock::paint(PaintContext& context, PaintPhase phase) void BlockBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
LayoutBox::paint(context, phase); Box::paint(context, phase);
// FIXME: Inline backgrounds etc. // FIXME: Inline backgrounds etc.
if (phase == PaintPhase::Foreground) { if (phase == PaintPhase::Foreground) {
@ -94,19 +94,19 @@ void LayoutBlock::paint(PaintContext& context, PaintPhase phase)
} }
} }
HitTestResult LayoutBlock::hit_test(const Gfx::IntPoint& position, HitTestType type) const HitTestResult BlockBox::hit_test(const Gfx::IntPoint& position, HitTestType type) const
{ {
if (!children_are_inline()) if (!children_are_inline())
return LayoutBox::hit_test(position, type); return Box::hit_test(position, type);
HitTestResult last_good_candidate; HitTestResult last_good_candidate;
for (auto& line_box : m_line_boxes) { for (auto& line_box : m_line_boxes) {
for (auto& fragment : line_box.fragments()) { for (auto& fragment : line_box.fragments()) {
if (is<LayoutBox>(fragment.layout_node()) && downcast<LayoutBox>(fragment.layout_node()).stacking_context()) if (is<Box>(fragment.layout_node()) && downcast<Box>(fragment.layout_node()).stacking_context())
continue; continue;
if (enclosing_int_rect(fragment.absolute_rect()).contains(position)) { if (enclosing_int_rect(fragment.absolute_rect()).contains(position)) {
if (fragment.layout_node().is_block()) if (fragment.layout_node().is_block())
return downcast<LayoutBlock>(fragment.layout_node()).hit_test(position, type); return downcast<BlockBox>(fragment.layout_node()).hit_test(position, type);
return { fragment.layout_node(), fragment.text_index_at(position.x()) }; return { fragment.layout_node(), fragment.text_index_at(position.x()) };
} }
if (fragment.absolute_rect().top() <= position.y()) if (fragment.absolute_rect().top() <= position.y())
@ -119,7 +119,7 @@ HitTestResult LayoutBlock::hit_test(const Gfx::IntPoint& position, HitTestType t
return { absolute_rect().contains(position.x(), position.y()) ? this : nullptr }; return { absolute_rect().contains(position.x(), position.y()) ? this : nullptr };
} }
NonnullRefPtr<CSS::StyleProperties> LayoutBlock::style_for_anonymous_block() const NonnullRefPtr<CSS::StyleProperties> BlockBox::style_for_anonymous_block() const
{ {
auto new_style = CSS::StyleProperties::create(); auto new_style = CSS::StyleProperties::create();
@ -131,7 +131,7 @@ NonnullRefPtr<CSS::StyleProperties> LayoutBlock::style_for_anonymous_block() con
return new_style; return new_style;
} }
void LayoutBlock::split_into_lines(LayoutBlock& container, LayoutMode layout_mode) void BlockBox::split_into_lines(BlockBox& container, LayoutMode layout_mode)
{ {
auto* line_box = &container.ensure_last_line_box(); auto* line_box = &container.ensure_last_line_box();
if (layout_mode != LayoutMode::OnlyRequiredLineBreaks && line_box->width() > 0 && line_box->width() + width() > container.width()) { if (layout_mode != LayoutMode::OnlyRequiredLineBreaks && line_box->width() > 0 && line_box->width() + width() > container.width()) {

View file

@ -26,35 +26,35 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
#include <LibWeb/Layout/LineBox.h> #include <LibWeb/Layout/LineBox.h>
namespace Web { namespace Web::Layout {
class LayoutBlock : public LayoutBox { class BlockBox : public Box {
public: public:
LayoutBlock(DOM::Document&, DOM::Node*, NonnullRefPtr<CSS::StyleProperties>); BlockBox(DOM::Document&, DOM::Node*, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutBlock() override; virtual ~BlockBox() override;
virtual const char* class_name() const override { return "LayoutBlock"; } virtual const char* class_name() const override { return "BlockBox"; }
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
virtual LayoutNode& inline_wrapper() override; virtual Node& inline_wrapper() override;
virtual HitTestResult hit_test(const Gfx::IntPoint&, HitTestType) const override; virtual HitTestResult hit_test(const Gfx::IntPoint&, HitTestType) const override;
LayoutBlock* previous_sibling() { return downcast<LayoutBlock>(LayoutNode::previous_sibling()); } BlockBox* previous_sibling() { return downcast<BlockBox>(Node::previous_sibling()); }
const LayoutBlock* previous_sibling() const { return downcast<LayoutBlock>(LayoutNode::previous_sibling()); } const BlockBox* previous_sibling() const { return downcast<BlockBox>(Node::previous_sibling()); }
LayoutBlock* next_sibling() { return downcast<LayoutBlock>(LayoutNode::next_sibling()); } BlockBox* next_sibling() { return downcast<BlockBox>(Node::next_sibling()); }
const LayoutBlock* next_sibling() const { return downcast<LayoutBlock>(LayoutNode::next_sibling()); } const BlockBox* next_sibling() const { return downcast<BlockBox>(Node::next_sibling()); }
template<typename Callback> template<typename Callback>
void for_each_fragment(Callback); void for_each_fragment(Callback);
template<typename Callback> template<typename Callback>
void for_each_fragment(Callback) const; void for_each_fragment(Callback) const;
virtual void split_into_lines(LayoutBlock& container, LayoutMode) override; virtual void split_into_lines(BlockBox& container, LayoutMode) override;
private: private:
virtual bool is_block() const override { return true; } virtual bool is_block() const override { return true; }
@ -63,7 +63,7 @@ private:
}; };
template<typename Callback> template<typename Callback>
void LayoutBlock::for_each_fragment(Callback callback) void BlockBox::for_each_fragment(Callback callback)
{ {
for (auto& line_box : line_boxes()) { for (auto& line_box : line_boxes()) {
for (auto& fragment : line_box.fragments()) { for (auto& fragment : line_box.fragments()) {
@ -74,7 +74,7 @@ void LayoutBlock::for_each_fragment(Callback callback)
} }
template<typename Callback> template<typename Callback>
void LayoutBlock::for_each_fragment(Callback callback) const void BlockBox::for_each_fragment(Callback callback) const
{ {
for (auto& line_box : line_boxes()) { for (auto& line_box : line_boxes()) {
for (auto& fragment : line_box.fragments()) { for (auto& fragment : line_box.fragments()) {
@ -86,6 +86,6 @@ void LayoutBlock::for_each_fragment(Callback callback) const
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutBlock) AK_BEGIN_TYPE_TRAITS(Web::Layout::BlockBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_block(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_block(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -26,18 +26,18 @@
#include <LibWeb/CSS/Length.h> #include <LibWeb/CSS/Length.h>
#include <LibWeb/DOM/Node.h> #include <LibWeb/DOM/Node.h>
#include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/BlockFormattingContext.h> #include <LibWeb/Layout/BlockFormattingContext.h>
#include <LibWeb/Layout/Box.h>
#include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/InlineFormattingContext.h> #include <LibWeb/Layout/InlineFormattingContext.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/ListItemBox.h>
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/WidgetBox.h>
#include <LibWeb/Layout/LayoutDocument.h>
#include <LibWeb/Layout/LayoutListItem.h>
#include <LibWeb/Layout/LayoutWidget.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web::Layout { namespace Web::Layout {
BlockFormattingContext::BlockFormattingContext(LayoutBox& context_box) BlockFormattingContext::BlockFormattingContext(Box& context_box)
: FormattingContext(context_box) : FormattingContext(context_box)
{ {
} }
@ -79,11 +79,11 @@ void BlockFormattingContext::run(LayoutMode layout_mode)
layout_absolutely_positioned_descendants(); layout_absolutely_positioned_descendants();
} }
void BlockFormattingContext::compute_width(LayoutBox& box) void BlockFormattingContext::compute_width(Box& box)
{ {
if (box.is_replaced()) { if (box.is_replaced()) {
// FIXME: This should not be done *by* LayoutReplaced // FIXME: This should not be done *by* ReplacedBox
auto& replaced = downcast<LayoutReplaced>(box); auto& replaced = downcast<ReplacedBox>(box);
replaced.prepare_for_replaced_layout(); replaced.prepare_for_replaced_layout();
auto width = replaced.calculate_width(); auto width = replaced.calculate_width();
replaced.set_width(width); replaced.set_width(width);
@ -214,7 +214,7 @@ void BlockFormattingContext::compute_width(LayoutBox& box)
box.box_model().padding.right = padding_right; box.box_model().padding.right = padding_right;
} }
void BlockFormattingContext::compute_width_for_absolutely_positioned_block(LayoutBox& box) void BlockFormattingContext::compute_width_for_absolutely_positioned_block(Box& box)
{ {
auto& containing_block = context_box(); auto& containing_block = context_box();
auto& style = box.style(); auto& style = box.style();
@ -354,11 +354,11 @@ void BlockFormattingContext::compute_width_for_absolutely_positioned_block(Layou
box.box_model().padding.right = padding_right; box.box_model().padding.right = padding_right;
} }
void BlockFormattingContext::compute_height(LayoutBox& box) void BlockFormattingContext::compute_height(Box& box)
{ {
if (box.is_replaced()) { if (box.is_replaced()) {
// FIXME: This should not be done *by* LayoutReplaced // FIXME: This should not be done *by* ReplacedBox
auto height = downcast<LayoutReplaced>(box).calculate_height(); auto height = downcast<ReplacedBox>(box).calculate_height();
box.set_height(height); box.set_height(height);
return; return;
} }
@ -402,7 +402,7 @@ void BlockFormattingContext::layout_block_level_children(LayoutMode layout_mode)
float content_height = 0; float content_height = 0;
float content_width = 0; float content_width = 0;
context_box().for_each_in_subtree_of_type<LayoutBox>([&](auto& box) { context_box().for_each_in_subtree_of_type<Box>([&](auto& box) {
if (box.is_absolutely_positioned() || box.containing_block() != &context_box()) if (box.is_absolutely_positioned() || box.containing_block() != &context_box())
return IterationDecision::Continue; return IterationDecision::Continue;
@ -415,15 +415,15 @@ void BlockFormattingContext::layout_block_level_children(LayoutMode layout_mode)
else if (box.is_block()) else if (box.is_block())
place_block_level_non_replaced_element_in_normal_flow(box); place_block_level_non_replaced_element_in_normal_flow(box);
else else
dbgln("FIXME: LayoutBlock::layout_contained_boxes doesn't know how to place a {}", box.class_name()); dbgln("FIXME: Layout::BlockBox::layout_contained_boxes doesn't know how to place a {}", box.class_name());
// FIXME: This should be factored differently. It's uncool that we mutate the tree *during* layout! // FIXME: This should be factored differently. It's uncool that we mutate the tree *during* layout!
// Instead, we should generate the marker box during the tree build. // Instead, we should generate the marker box during the tree build.
if (is<LayoutListItem>(box)) if (is<ListItemBox>(box))
downcast<LayoutListItem>(box).layout_marker(); downcast<ListItemBox>(box).layout_marker();
content_height = max(content_height, box.effective_offset().y() + box.height() + box.box_model().margin_box(box).bottom); content_height = max(content_height, box.effective_offset().y() + box.height() + box.box_model().margin_box(box).bottom);
content_width = max(content_width, downcast<LayoutBox>(box).width()); content_width = max(content_width, downcast<Box>(box).width());
return IterationDecision::Continue; return IterationDecision::Continue;
}); });
@ -436,7 +436,7 @@ void BlockFormattingContext::layout_block_level_children(LayoutMode layout_mode)
context_box().set_height(content_height); context_box().set_height(content_height);
} }
void BlockFormattingContext::place_block_level_replaced_element_in_normal_flow(LayoutBox& box) void BlockFormattingContext::place_block_level_replaced_element_in_normal_flow(Box& box)
{ {
auto& containing_block = context_box(); auto& containing_block = context_box();
ASSERT(!containing_block.is_absolutely_positioned()); ASSERT(!containing_block.is_absolutely_positioned());
@ -459,7 +459,7 @@ void BlockFormattingContext::place_block_level_replaced_element_in_normal_flow(L
box.set_offset(x, y); box.set_offset(x, y);
} }
void BlockFormattingContext::place_block_level_non_replaced_element_in_normal_flow(LayoutBox& box) void BlockFormattingContext::place_block_level_non_replaced_element_in_normal_flow(Box& box)
{ {
auto zero_value = CSS::Length::make_px(0); auto zero_value = CSS::Length::make_px(0);
auto& containing_block = context_box(); auto& containing_block = context_box();
@ -488,7 +488,7 @@ void BlockFormattingContext::place_block_level_non_replaced_element_in_normal_fl
// NOTE: Empty (0-height) preceding siblings have their margins collapsed with *their* preceding sibling, etc. // NOTE: Empty (0-height) preceding siblings have their margins collapsed with *their* preceding sibling, etc.
float collapsed_bottom_margin_of_preceding_siblings = 0; float collapsed_bottom_margin_of_preceding_siblings = 0;
auto* relevant_sibling = box.previous_sibling_of_type<LayoutBlock>(); auto* relevant_sibling = box.previous_sibling_of_type<Layout::BlockBox>();
while (relevant_sibling != nullptr) { while (relevant_sibling != nullptr) {
if (!relevant_sibling->is_absolutely_positioned() && !relevant_sibling->is_floating()) { if (!relevant_sibling->is_absolutely_positioned() && !relevant_sibling->is_floating()) {
collapsed_bottom_margin_of_preceding_siblings = max(collapsed_bottom_margin_of_preceding_siblings, relevant_sibling->box_model().margin.bottom.to_px(*relevant_sibling)); collapsed_bottom_margin_of_preceding_siblings = max(collapsed_bottom_margin_of_preceding_siblings, relevant_sibling->box_model().margin.bottom.to_px(*relevant_sibling));
@ -523,7 +523,7 @@ void BlockFormattingContext::layout_initial_containing_block(LayoutMode layout_m
{ {
auto viewport_rect = context_box().frame().viewport_rect(); auto viewport_rect = context_box().frame().viewport_rect();
auto& icb = downcast<LayoutDocument>(context_box()); auto& icb = downcast<Layout::InitialContainingBlockBox>(context_box());
icb.build_stacking_context_tree(); icb.build_stacking_context_tree();
icb.set_width(viewport_rect.width()); icb.set_width(viewport_rect.width());
@ -535,7 +535,7 @@ void BlockFormattingContext::layout_initial_containing_block(LayoutMode layout_m
// FIXME: The ICB should have the height of the viewport. // FIXME: The ICB should have the height of the viewport.
// Instead of auto-sizing the ICB, we should spill into overflow. // Instead of auto-sizing the ICB, we should spill into overflow.
float lowest_bottom = 0; float lowest_bottom = 0;
icb.for_each_child_of_type<LayoutBox>([&](auto& child) { icb.for_each_child_of_type<Box>([&](auto& child) {
lowest_bottom = max(lowest_bottom, child.absolute_rect().bottom()); lowest_bottom = max(lowest_bottom, child.absolute_rect().bottom());
}); });
icb.set_height(lowest_bottom); icb.set_height(lowest_bottom);
@ -546,7 +546,7 @@ void BlockFormattingContext::layout_initial_containing_block(LayoutMode layout_m
// FIXME: This is a total hack. Make sure any GUI::Widgets are moved into place after layout. // FIXME: This is a total hack. Make sure any GUI::Widgets are moved into place after layout.
// We should stop embedding GUI::Widgets entirely, since that won't work out-of-process. // We should stop embedding GUI::Widgets entirely, since that won't work out-of-process.
icb.for_each_in_subtree_of_type<LayoutWidget>([&](auto& widget) { icb.for_each_in_subtree_of_type<Layout::WidgetBox>([&](auto& widget) {
widget.update_widget(); widget.update_widget();
return IterationDecision::Continue; return IterationDecision::Continue;
}); });
@ -554,7 +554,7 @@ void BlockFormattingContext::layout_initial_containing_block(LayoutMode layout_m
void BlockFormattingContext::layout_absolutely_positioned_descendants() void BlockFormattingContext::layout_absolutely_positioned_descendants()
{ {
context_box().for_each_in_subtree_of_type<LayoutBox>([&](auto& box) { context_box().for_each_in_subtree_of_type<Box>([&](auto& box) {
if (box.is_absolutely_positioned() && box.containing_block() == &context_box()) { if (box.is_absolutely_positioned() && box.containing_block() == &context_box()) {
layout_absolutely_positioned_descendant(box); layout_absolutely_positioned_descendant(box);
} }
@ -562,7 +562,7 @@ void BlockFormattingContext::layout_absolutely_positioned_descendants()
}); });
} }
void BlockFormattingContext::layout_absolutely_positioned_descendant(LayoutBox& box) void BlockFormattingContext::layout_absolutely_positioned_descendant(Box& box)
{ {
auto& containing_block = context_box(); auto& containing_block = context_box();
auto& box_model = box.box_model(); auto& box_model = box.box_model();

View file

@ -33,7 +33,7 @@ namespace Web::Layout {
class BlockFormattingContext : public FormattingContext { class BlockFormattingContext : public FormattingContext {
public: public:
explicit BlockFormattingContext(LayoutBox& containing_block); explicit BlockFormattingContext(Box& containing_block);
~BlockFormattingContext(); ~BlockFormattingContext();
virtual void run(LayoutMode) override; virtual void run(LayoutMode) override;
@ -41,21 +41,21 @@ public:
bool is_initial() const; bool is_initial() const;
protected: protected:
void compute_width(LayoutBox&); void compute_width(Box&);
void compute_height(LayoutBox&); void compute_height(Box&);
private: private:
void compute_width_for_absolutely_positioned_block(LayoutBox&); void compute_width_for_absolutely_positioned_block(Box&);
void layout_initial_containing_block(LayoutMode); void layout_initial_containing_block(LayoutMode);
void layout_block_level_children(LayoutMode); void layout_block_level_children(LayoutMode);
void layout_inline_children(LayoutMode); void layout_inline_children(LayoutMode);
void layout_absolutely_positioned_descendants(); void layout_absolutely_positioned_descendants();
void place_block_level_replaced_element_in_normal_flow(LayoutBox&); void place_block_level_replaced_element_in_normal_flow(Box&);
void place_block_level_non_replaced_element_in_normal_flow(LayoutBox&); void place_block_level_non_replaced_element_in_normal_flow(Box&);
void layout_absolutely_positioned_descendant(LayoutBox&); void layout_absolutely_positioned_descendant(Box&);
}; };
} }

View file

@ -27,13 +27,13 @@
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/HTML/HTMLBodyElement.h> #include <LibWeb/HTML/HTMLBodyElement.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web { namespace Web::Layout {
void LayoutBox::paint_border(PaintContext& context, Edge edge, const Gfx::FloatRect& rect, CSS::PropertyID style_property_id, const BorderData& border_data) void Box::paint_border(PaintContext& context, Edge edge, const Gfx::FloatRect& rect, CSS::PropertyID style_property_id, const BorderData& border_data)
{ {
float width = border_data.width; float width = border_data.width;
if (width <= 0) if (width <= 0)
@ -162,7 +162,7 @@ void LayoutBox::paint_border(PaintContext& context, Edge edge, const Gfx::FloatR
} }
} }
void LayoutBox::paint(PaintContext& context, PaintPhase phase) void Box::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -206,7 +206,7 @@ void LayoutBox::paint(PaintContext& context, PaintPhase phase)
paint_border(context, Edge::Bottom, bordered_rect, CSS::PropertyID::BorderBottomStyle, style().border_bottom()); paint_border(context, Edge::Bottom, bordered_rect, CSS::PropertyID::BorderBottomStyle, style().border_bottom());
} }
LayoutNodeWithStyleAndBoxModelMetrics::paint(context, phase); Layout::NodeWithStyleAndBoxModelMetrics::paint(context, phase);
if (phase == PaintPhase::Overlay && dom_node() && document().inspected_node() == dom_node()) { if (phase == PaintPhase::Overlay && dom_node() && document().inspected_node() == dom_node()) {
auto content_rect = absolute_rect(); auto content_rect = absolute_rect();
@ -228,14 +228,14 @@ void LayoutBox::paint(PaintContext& context, PaintPhase phase)
} }
} }
HitTestResult LayoutBox::hit_test(const Gfx::IntPoint& position, HitTestType type) const HitTestResult Box::hit_test(const Gfx::IntPoint& position, HitTestType type) const
{ {
// FIXME: It would be nice if we could confidently skip over hit testing // FIXME: It would be nice if we could confidently skip over hit testing
// parts of the layout tree, but currently we can't just check // parts of the layout tree, but currently we can't just check
// m_rect.contains() since inline text rects can't be trusted.. // m_rect.contains() since inline text rects can't be trusted..
HitTestResult result { absolute_rect().contains(position.x(), position.y()) ? this : nullptr }; HitTestResult result { absolute_rect().contains(position.x(), position.y()) ? this : nullptr };
for_each_child([&](auto& child) { for_each_child([&](auto& child) {
if (is<LayoutBox>(child) && downcast<LayoutBox>(child).stacking_context()) if (is<Box>(child) && downcast<Box>(child).stacking_context())
return; return;
auto child_result = child.hit_test(position, type); auto child_result = child.hit_test(position, type);
if (child_result.layout_node) if (child_result.layout_node)
@ -244,22 +244,22 @@ HitTestResult LayoutBox::hit_test(const Gfx::IntPoint& position, HitTestType typ
return result; return result;
} }
void LayoutBox::set_needs_display() void Box::set_needs_display()
{ {
if (!is_inline()) { if (!is_inline()) {
frame().set_needs_display(enclosing_int_rect(absolute_rect())); frame().set_needs_display(enclosing_int_rect(absolute_rect()));
return; return;
} }
LayoutNode::set_needs_display(); Node::set_needs_display();
} }
bool LayoutBox::is_body() const bool Box::is_body() const
{ {
return dom_node() && dom_node() == document().body(); return dom_node() && dom_node() == document().body();
} }
void LayoutBox::set_offset(const Gfx::FloatPoint& offset) void Box::set_offset(const Gfx::FloatPoint& offset)
{ {
if (m_offset == offset) if (m_offset == offset)
return; return;
@ -267,7 +267,7 @@ void LayoutBox::set_offset(const Gfx::FloatPoint& offset)
did_set_rect(); did_set_rect();
} }
void LayoutBox::set_size(const Gfx::FloatSize& size) void Box::set_size(const Gfx::FloatSize& size)
{ {
if (m_size == size) if (m_size == size)
return; return;
@ -275,14 +275,14 @@ void LayoutBox::set_size(const Gfx::FloatSize& size)
did_set_rect(); did_set_rect();
} }
Gfx::FloatPoint LayoutBox::effective_offset() const Gfx::FloatPoint Box::effective_offset() const
{ {
if (m_containing_line_box_fragment) if (m_containing_line_box_fragment)
return m_containing_line_box_fragment->offset(); return m_containing_line_box_fragment->offset();
return m_offset; return m_offset;
} }
const Gfx::FloatRect LayoutBox::absolute_rect() const const Gfx::FloatRect Box::absolute_rect() const
{ {
Gfx::FloatRect rect { effective_offset(), size() }; Gfx::FloatRect rect { effective_offset(), size() };
for (auto* block = containing_block(); block; block = block->containing_block()) { for (auto* block = containing_block(); block; block = block->containing_block()) {
@ -291,27 +291,27 @@ const Gfx::FloatRect LayoutBox::absolute_rect() const
return rect; return rect;
} }
void LayoutBox::set_containing_line_box_fragment(LineBoxFragment& fragment) void Box::set_containing_line_box_fragment(LineBoxFragment& fragment)
{ {
m_containing_line_box_fragment = fragment.make_weak_ptr(); m_containing_line_box_fragment = fragment.make_weak_ptr();
} }
StackingContext* LayoutBox::enclosing_stacking_context() StackingContext* Box::enclosing_stacking_context()
{ {
for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) { for (auto* ancestor = parent(); ancestor; ancestor = ancestor->parent()) {
if (!ancestor->is_box()) if (!ancestor->is_box())
continue; continue;
auto& ancestor_box = downcast<LayoutBox>(*ancestor); auto& ancestor_box = downcast<Box>(*ancestor);
if (!ancestor_box.establishes_stacking_context()) if (!ancestor_box.establishes_stacking_context())
continue; continue;
ASSERT(ancestor_box.stacking_context()); ASSERT(ancestor_box.stacking_context());
return ancestor_box.stacking_context(); return ancestor_box.stacking_context();
} }
// We should always reach the LayoutDocument stacking context. // We should always reach the Layout::InitialContainingBlockBox stacking context.
ASSERT_NOT_REACHED(); ASSERT_NOT_REACHED();
} }
bool LayoutBox::establishes_stacking_context() const bool Box::establishes_stacking_context() const
{ {
if (!has_style()) if (!has_style())
return false; return false;
@ -328,20 +328,20 @@ bool LayoutBox::establishes_stacking_context() const
return false; return false;
} }
LineBox& LayoutBox::ensure_last_line_box() LineBox& Box::ensure_last_line_box()
{ {
if (m_line_boxes.is_empty()) if (m_line_boxes.is_empty())
return add_line_box(); return add_line_box();
return m_line_boxes.last(); return m_line_boxes.last();
} }
LineBox& LayoutBox::add_line_box() LineBox& Box::add_line_box()
{ {
m_line_boxes.append(LineBox()); m_line_boxes.append(LineBox());
return m_line_boxes.last(); return m_line_boxes.last();
} }
float LayoutBox::width_of_logical_containing_block() const float Box::width_of_logical_containing_block() const
{ {
auto* containing_block = this->containing_block(); auto* containing_block = this->containing_block();
ASSERT(containing_block); ASSERT(containing_block);

View file

@ -28,13 +28,13 @@
#include <AK/OwnPtr.h> #include <AK/OwnPtr.h>
#include <LibGfx/Rect.h> #include <LibGfx/Rect.h>
#include <LibWeb/Layout/LayoutNode.h>
#include <LibWeb/Layout/LineBox.h> #include <LibWeb/Layout/LineBox.h>
#include <LibWeb/Layout/Node.h>
#include <LibWeb/Painting/StackingContext.h> #include <LibWeb/Painting/StackingContext.h>
namespace Web { namespace Web::Layout {
class LayoutBox : public LayoutNodeWithStyleAndBoxModelMetrics { class Box : public NodeWithStyleAndBoxModelMetrics {
public: public:
const Gfx::FloatRect absolute_rect() const; const Gfx::FloatRect absolute_rect() const;
@ -80,8 +80,8 @@ public:
virtual float width_of_logical_containing_block() const; virtual float width_of_logical_containing_block() const;
protected: protected:
LayoutBox(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> style) Box(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutNodeWithStyleAndBoxModelMetrics(document, node, move(style)) : NodeWithStyleAndBoxModelMetrics(document, node, move(style))
{ {
} }
@ -111,6 +111,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutBox) AK_BEGIN_TYPE_TRAITS(Web::Layout::Box)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_box(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_box(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -26,9 +26,9 @@
#include <LibWeb/Layout/BoxModelMetrics.h> #include <LibWeb/Layout/BoxModelMetrics.h>
namespace Web { namespace Web::Layout {
PixelBox BoxModelMetrics::margin_box(const LayoutNode& layout_node) const PixelBox BoxModelMetrics::margin_box(const Node& layout_node) const
{ {
return { return {
margin.top.to_px(layout_node) + border.top.to_px(layout_node) + padding.top.to_px(layout_node), margin.top.to_px(layout_node) + border.top.to_px(layout_node) + padding.top.to_px(layout_node),
@ -38,7 +38,7 @@ PixelBox BoxModelMetrics::margin_box(const LayoutNode& layout_node) const
}; };
} }
PixelBox BoxModelMetrics::padding_box(const LayoutNode& layout_node) const PixelBox BoxModelMetrics::padding_box(const Node& layout_node) const
{ {
return { return {
padding.top.to_px(layout_node), padding.top.to_px(layout_node),
@ -48,7 +48,7 @@ PixelBox BoxModelMetrics::padding_box(const LayoutNode& layout_node) const
}; };
} }
PixelBox BoxModelMetrics::border_box(const LayoutNode& layout_node) const PixelBox BoxModelMetrics::border_box(const Node& layout_node) const
{ {
return { return {
border.top.to_px(layout_node) + padding.top.to_px(layout_node), border.top.to_px(layout_node) + padding.top.to_px(layout_node),

View file

@ -29,7 +29,7 @@
#include <LibGfx/Size.h> #include <LibGfx/Size.h>
#include <LibWeb/CSS/LengthBox.h> #include <LibWeb/CSS/LengthBox.h>
namespace Web { namespace Web::Layout {
struct PixelBox { struct PixelBox {
float top; float top;
@ -45,9 +45,9 @@ public:
CSS::LengthBox border; CSS::LengthBox border;
CSS::LengthBox offset; CSS::LengthBox offset;
PixelBox margin_box(const LayoutNode&) const; PixelBox margin_box(const Node&) const;
PixelBox padding_box(const LayoutNode&) const; PixelBox padding_box(const Node&) const;
PixelBox border_box(const LayoutNode&) const; PixelBox border_box(const Node&) const;
}; };
} }

View file

@ -24,22 +24,22 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutBreak.h> #include <LibWeb/Layout/BreakNode.h>
namespace Web { namespace Web::Layout {
LayoutBreak::LayoutBreak(DOM::Document& document, HTML::HTMLBRElement& element) BreakNode::BreakNode(DOM::Document& document, HTML::HTMLBRElement& element)
: LayoutNodeWithStyleAndBoxModelMetrics(document, &element, CSS::StyleProperties::create()) : Layout::NodeWithStyleAndBoxModelMetrics(document, &element, CSS::StyleProperties::create())
{ {
set_inline(true); set_inline(true);
} }
LayoutBreak::~LayoutBreak() BreakNode::~BreakNode()
{ {
} }
void LayoutBreak::split_into_lines(LayoutBlock& block, LayoutMode) void BreakNode::split_into_lines(BlockBox& block, LayoutMode)
{ {
block.add_line_box(); block.add_line_box();
} }

View file

@ -27,25 +27,25 @@
#pragma once #pragma once
#include <LibWeb/HTML/HTMLBRElement.h> #include <LibWeb/HTML/HTMLBRElement.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
namespace Web { namespace Web::Layout {
class LayoutBreak final : public LayoutNodeWithStyleAndBoxModelMetrics { class BreakNode final : public NodeWithStyleAndBoxModelMetrics {
public: public:
LayoutBreak(DOM::Document&, HTML::HTMLBRElement&); BreakNode(DOM::Document&, HTML::HTMLBRElement&);
virtual ~LayoutBreak() override; virtual ~BreakNode() override;
const HTML::HTMLBRElement& dom_node() const { return downcast<HTML::HTMLBRElement>(*LayoutNode::dom_node()); } const HTML::HTMLBRElement& dom_node() const { return downcast<HTML::HTMLBRElement>(*Node::dom_node()); }
private: private:
virtual bool is_break() const override { return true; } virtual bool is_break() const override { return true; }
virtual const char* class_name() const override { return "LayoutBreak"; } virtual const char* class_name() const override { return "BreakNode"; }
virtual void split_into_lines(LayoutBlock&, LayoutMode) override; virtual void split_into_lines(BlockBox&, LayoutMode) override;
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutBreak) AK_BEGIN_TYPE_TRAITS(Web::Layout::BreakNode)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_break(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_break(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -29,21 +29,21 @@
#include <LibGfx/Font.h> #include <LibGfx/Font.h>
#include <LibGfx/StylePainter.h> #include <LibGfx/StylePainter.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/Layout/LayoutButton.h> #include <LibWeb/Layout/ButtonBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web { namespace Web::Layout {
LayoutButton::LayoutButton(DOM::Document& document, HTML::HTMLInputElement& element, NonnullRefPtr<CSS::StyleProperties> style) ButtonBox::ButtonBox(DOM::Document& document, HTML::HTMLInputElement& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutReplaced(document, element, move(style)) : ReplacedBox(document, element, move(style))
{ {
} }
LayoutButton::~LayoutButton() ButtonBox::~ButtonBox()
{ {
} }
void LayoutButton::prepare_for_replaced_layout() void ButtonBox::prepare_for_replaced_layout()
{ {
auto& font = specified_style().font(); auto& font = specified_style().font();
set_intrinsic_width(font.width(dom_node().value()) + 20); set_intrinsic_width(font.width(dom_node().value()) + 20);
@ -53,12 +53,12 @@ void LayoutButton::prepare_for_replaced_layout()
set_has_intrinsic_height(true); set_has_intrinsic_height(true);
} }
void LayoutButton::paint(PaintContext& context, PaintPhase phase) void ButtonBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
LayoutReplaced::paint(context, phase); ReplacedBox::paint(context, phase);
if (phase == PaintPhase::Foreground) { if (phase == PaintPhase::Foreground) {
bool hovered = document().hovered_node() == &dom_node(); bool hovered = document().hovered_node() == &dom_node();
@ -71,7 +71,7 @@ void LayoutButton::paint(PaintContext& context, PaintPhase phase)
} }
} }
void LayoutButton::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned) void ButtonBox::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{ {
if (button != GUI::MouseButton::Left || !dom_node().enabled()) if (button != GUI::MouseButton::Left || !dom_node().enabled())
return; return;
@ -83,7 +83,7 @@ void LayoutButton::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, u
frame().event_handler().set_mouse_event_tracking_layout_node(this); frame().event_handler().set_mouse_event_tracking_layout_node(this);
} }
void LayoutButton::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned) void ButtonBox::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{ {
if (!m_tracking_mouse || button != GUI::MouseButton::Left || !dom_node().enabled()) if (!m_tracking_mouse || button != GUI::MouseButton::Left || !dom_node().enabled())
return; return;
@ -102,7 +102,7 @@ void LayoutButton::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& posi
protected_frame->event_handler().set_mouse_event_tracking_layout_node(nullptr); protected_frame->event_handler().set_mouse_event_tracking_layout_node(nullptr);
} }
void LayoutButton::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned) void ButtonBox::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{ {
if (!m_tracking_mouse || !dom_node().enabled()) if (!m_tracking_mouse || !dom_node().enabled())
return; return;

View file

@ -27,23 +27,23 @@
#pragma once #pragma once
#include <LibWeb/HTML/HTMLInputElement.h> #include <LibWeb/HTML/HTMLInputElement.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
namespace Web { namespace Web::Layout {
class LayoutButton : public LayoutReplaced { class ButtonBox : public ReplacedBox {
public: public:
LayoutButton(DOM::Document&, HTML::HTMLInputElement&, NonnullRefPtr<CSS::StyleProperties>); ButtonBox(DOM::Document&, HTML::HTMLInputElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutButton() override; virtual ~ButtonBox() override;
virtual void prepare_for_replaced_layout() override; virtual void prepare_for_replaced_layout() override;
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(LayoutReplaced::dom_node()); } const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(ReplacedBox::dom_node()); }
HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(LayoutReplaced::dom_node()); } HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(ReplacedBox::dom_node()); }
private: private:
virtual const char* class_name() const override { return "LayoutButton"; } virtual const char* class_name() const override { return "ButtonBox"; }
virtual bool is_button() const override { return true; } virtual bool is_button() const override { return true; }
virtual bool wants_mouse_events() const override { return true; } virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override; virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
@ -56,6 +56,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutButton) AK_BEGIN_TYPE_TRAITS(Web::Layout::ButtonBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_button(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_button(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -27,20 +27,20 @@
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibGfx/Font.h> #include <LibGfx/Font.h>
#include <LibGfx/StylePainter.h> #include <LibGfx/StylePainter.h>
#include <LibWeb/Layout/LayoutCanvas.h> #include <LibWeb/Layout/CanvasBox.h>
namespace Web { namespace Web::Layout {
LayoutCanvas::LayoutCanvas(DOM::Document& document, HTML::HTMLCanvasElement& element, NonnullRefPtr<CSS::StyleProperties> style) CanvasBox::CanvasBox(DOM::Document& document, HTML::HTMLCanvasElement& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutReplaced(document, element, move(style)) : ReplacedBox(document, element, move(style))
{ {
} }
LayoutCanvas::~LayoutCanvas() CanvasBox::~CanvasBox()
{ {
} }
void LayoutCanvas::prepare_for_replaced_layout() void CanvasBox::prepare_for_replaced_layout()
{ {
set_has_intrinsic_width(true); set_has_intrinsic_width(true);
set_has_intrinsic_height(true); set_has_intrinsic_height(true);
@ -48,12 +48,12 @@ void LayoutCanvas::prepare_for_replaced_layout()
set_intrinsic_height(dom_node().height()); set_intrinsic_height(dom_node().height());
} }
void LayoutCanvas::paint(PaintContext& context, PaintPhase phase) void CanvasBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
LayoutReplaced::paint(context, phase); ReplacedBox::paint(context, phase);
if (phase == PaintPhase::Foreground) { if (phase == PaintPhase::Foreground) {
// FIXME: This should be done at a different level. Also rect() does not include padding etc! // FIXME: This should be done at a different level. Also rect() does not include padding etc!

View file

@ -27,27 +27,27 @@
#pragma once #pragma once
#include <LibWeb/HTML/HTMLCanvasElement.h> #include <LibWeb/HTML/HTMLCanvasElement.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
namespace Web { namespace Web::Layout {
class LayoutCanvas : public LayoutReplaced { class CanvasBox : public ReplacedBox {
public: public:
LayoutCanvas(DOM::Document&, HTML::HTMLCanvasElement&, NonnullRefPtr<CSS::StyleProperties>); CanvasBox(DOM::Document&, HTML::HTMLCanvasElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutCanvas() override; virtual ~CanvasBox() override;
virtual void prepare_for_replaced_layout() override; virtual void prepare_for_replaced_layout() override;
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
const HTML::HTMLCanvasElement& dom_node() const { return static_cast<const HTML::HTMLCanvasElement&>(LayoutReplaced::dom_node()); } const HTML::HTMLCanvasElement& dom_node() const { return static_cast<const HTML::HTMLCanvasElement&>(ReplacedBox::dom_node()); }
private: private:
virtual const char* class_name() const override { return "LayoutCanvas"; } virtual const char* class_name() const override { return "CanvasBox"; }
virtual bool is_canvas() const override { return true; } virtual bool is_canvas() const override { return true; }
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutCanvas) AK_BEGIN_TYPE_TRAITS(Web::Layout::CanvasBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_canvas(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_canvas(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -28,13 +28,13 @@
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibGfx/Font.h> #include <LibGfx/Font.h>
#include <LibGfx/StylePainter.h> #include <LibGfx/StylePainter.h>
#include <LibWeb/Layout/LayoutCheckBox.h> #include <LibWeb/Layout/CheckBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web { namespace Web::Layout {
LayoutCheckBox::LayoutCheckBox(DOM::Document& document, HTML::HTMLInputElement& element, NonnullRefPtr<CSS::StyleProperties> style) CheckBox::CheckBox(DOM::Document& document, HTML::HTMLInputElement& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutReplaced(document, element, move(style)) : ReplacedBox(document, element, move(style))
{ {
set_has_intrinsic_width(true); set_has_intrinsic_width(true);
set_has_intrinsic_height(true); set_has_intrinsic_height(true);
@ -42,23 +42,23 @@ LayoutCheckBox::LayoutCheckBox(DOM::Document& document, HTML::HTMLInputElement&
set_intrinsic_height(13); set_intrinsic_height(13);
} }
LayoutCheckBox::~LayoutCheckBox() CheckBox::~CheckBox()
{ {
} }
void LayoutCheckBox::paint(PaintContext& context, PaintPhase phase) void CheckBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
LayoutReplaced::paint(context, phase); ReplacedBox::paint(context, phase);
if (phase == PaintPhase::Foreground) { if (phase == PaintPhase::Foreground) {
Gfx::StylePainter::paint_check_box(context.painter(), enclosing_int_rect(absolute_rect()), context.palette(), dom_node().enabled(), dom_node().checked(), m_being_pressed); Gfx::StylePainter::paint_check_box(context.painter(), enclosing_int_rect(absolute_rect()), context.palette(), dom_node().enabled(), dom_node().checked(), m_being_pressed);
} }
} }
void LayoutCheckBox::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned) void CheckBox::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned)
{ {
if (button != GUI::MouseButton::Left || !dom_node().enabled()) if (button != GUI::MouseButton::Left || !dom_node().enabled())
return; return;
@ -70,7 +70,7 @@ void LayoutCheckBox::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&,
frame().event_handler().set_mouse_event_tracking_layout_node(this); frame().event_handler().set_mouse_event_tracking_layout_node(this);
} }
void LayoutCheckBox::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned) void CheckBox::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned button, unsigned)
{ {
if (!m_tracking_mouse || button != GUI::MouseButton::Left || !dom_node().enabled()) if (!m_tracking_mouse || button != GUI::MouseButton::Left || !dom_node().enabled())
return; return;
@ -87,7 +87,7 @@ void LayoutCheckBox::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint& po
frame().event_handler().set_mouse_event_tracking_layout_node(nullptr); frame().event_handler().set_mouse_event_tracking_layout_node(nullptr);
} }
void LayoutCheckBox::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned) void CheckBox::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint& position, unsigned, unsigned)
{ {
if (!m_tracking_mouse || !dom_node().enabled()) if (!m_tracking_mouse || !dom_node().enabled())
return; return;

View file

@ -27,22 +27,22 @@
#pragma once #pragma once
#include <LibWeb/HTML/HTMLInputElement.h> #include <LibWeb/HTML/HTMLInputElement.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
namespace Web { namespace Web::Layout {
class LayoutCheckBox : public LayoutReplaced { class CheckBox : public ReplacedBox {
public: public:
LayoutCheckBox(DOM::Document&, HTML::HTMLInputElement&, NonnullRefPtr<CSS::StyleProperties>); CheckBox(DOM::Document&, HTML::HTMLInputElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutCheckBox() override; virtual ~CheckBox() override;
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(LayoutReplaced::dom_node()); } const HTML::HTMLInputElement& dom_node() const { return static_cast<const HTML::HTMLInputElement&>(ReplacedBox::dom_node()); }
HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(LayoutReplaced::dom_node()); } HTML::HTMLInputElement& dom_node() { return static_cast<HTML::HTMLInputElement&>(ReplacedBox::dom_node()); }
private: private:
virtual const char* class_name() const override { return "LayoutCheckBox"; } virtual const char* class_name() const override { return "CheckBox"; }
virtual bool is_check_box() const override { return true; } virtual bool is_check_box() const override { return true; }
virtual bool wants_mouse_events() const override { return true; } virtual bool wants_mouse_events() const override { return true; }
virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override; virtual void handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned button, unsigned modifiers) override;
@ -55,6 +55,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutCheckBox) AK_BEGIN_TYPE_TRAITS(Web::Layout::CheckBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_check_box(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_check_box(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -25,14 +25,14 @@
*/ */
#include <LibWeb/Layout/BlockFormattingContext.h> #include <LibWeb/Layout/BlockFormattingContext.h>
#include <LibWeb/Layout/Box.h>
#include <LibWeb/Layout/FormattingContext.h> #include <LibWeb/Layout/FormattingContext.h>
#include <LibWeb/Layout/InlineFormattingContext.h> #include <LibWeb/Layout/InlineFormattingContext.h>
#include <LibWeb/Layout/LayoutBox.h>
#include <LibWeb/Layout/TableFormattingContext.h> #include <LibWeb/Layout/TableFormattingContext.h>
namespace Web::Layout { namespace Web::Layout {
FormattingContext::FormattingContext(LayoutBox& context_box) FormattingContext::FormattingContext(Box& context_box)
: m_context_box(context_box) : m_context_box(context_box)
{ {
} }
@ -41,7 +41,7 @@ FormattingContext::~FormattingContext()
{ {
} }
void FormattingContext::layout_inside(LayoutBox& box, LayoutMode layout_mode) void FormattingContext::layout_inside(Box& box, LayoutMode layout_mode)
{ {
if (box.is_table()) { if (box.is_table()) {
TableFormattingContext context(box); TableFormattingContext context(box);
@ -55,7 +55,7 @@ void FormattingContext::layout_inside(LayoutBox& box, LayoutMode layout_mode)
} }
} }
static float greatest_child_width(const LayoutBox& box) static float greatest_child_width(const Box& box)
{ {
float max_width = 0; float max_width = 0;
if (box.children_are_inline()) { if (box.children_are_inline()) {
@ -63,14 +63,14 @@ static float greatest_child_width(const LayoutBox& box)
max_width = max(max_width, child.width()); max_width = max(max_width, child.width());
} }
} else { } else {
box.for_each_child_of_type<LayoutBox>([&](auto& child) { box.for_each_child_of_type<Box>([&](auto& child) {
max_width = max(max_width, child.width()); max_width = max(max_width, child.width());
}); });
} }
return max_width; return max_width;
} }
FormattingContext::ShrinkToFitResult FormattingContext::calculate_shrink_to_fit_widths(LayoutBox& box) FormattingContext::ShrinkToFitResult FormattingContext::calculate_shrink_to_fit_widths(Box& box)
{ {
// Calculate the preferred width by formatting the content without breaking lines // Calculate the preferred width by formatting the content without breaking lines
// other than where explicit line breaks occur. // other than where explicit line breaks occur.

View file

@ -34,23 +34,23 @@ class FormattingContext {
public: public:
virtual void run(LayoutMode) = 0; virtual void run(LayoutMode) = 0;
LayoutBox& context_box() { return m_context_box; } Box& context_box() { return m_context_box; }
const LayoutBox& context_box() const { return m_context_box; } const Box& context_box() const { return m_context_box; }
protected: protected:
FormattingContext(LayoutBox&); FormattingContext(Box&);
virtual ~FormattingContext(); virtual ~FormattingContext();
static void layout_inside(LayoutBox&, LayoutMode); static void layout_inside(Box&, LayoutMode);
struct ShrinkToFitResult { struct ShrinkToFitResult {
float preferred_width { 0 }; float preferred_width { 0 };
float preferred_minimum_width { 0 }; float preferred_minimum_width { 0 };
}; };
ShrinkToFitResult calculate_shrink_to_fit_widths(LayoutBox&); ShrinkToFitResult calculate_shrink_to_fit_widths(Box&);
LayoutBox& m_context_box; Box& m_context_box;
}; };
} }

View file

@ -31,24 +31,24 @@
#include <LibGfx/StylePainter.h> #include <LibGfx/StylePainter.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/InProcessWebView.h> #include <LibWeb/InProcessWebView.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/FrameBox.h>
#include <LibWeb/Layout/LayoutFrame.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
//#define DEBUG_HIGHLIGHT_FOCUSED_FRAME //#define DEBUG_HIGHLIGHT_FOCUSED_FRAME
namespace Web { namespace Web::Layout {
LayoutFrame::LayoutFrame(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) FrameBox::FrameBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutReplaced(document, element, move(style)) : ReplacedBox(document, element, move(style))
{ {
} }
LayoutFrame::~LayoutFrame() FrameBox::~FrameBox()
{ {
} }
void LayoutFrame::prepare_for_replaced_layout() void FrameBox::prepare_for_replaced_layout()
{ {
ASSERT(dom_node().content_frame()); ASSERT(dom_node().content_frame());
@ -59,9 +59,9 @@ void LayoutFrame::prepare_for_replaced_layout()
set_intrinsic_height(dom_node().attribute(HTML::AttributeNames::height).to_int().value_or(150)); set_intrinsic_height(dom_node().attribute(HTML::AttributeNames::height).to_int().value_or(150));
} }
void LayoutFrame::paint(PaintContext& context, PaintPhase phase) void FrameBox::paint(PaintContext& context, PaintPhase phase)
{ {
LayoutReplaced::paint(context, phase); ReplacedBox::paint(context, phase);
if (phase == PaintPhase::Foreground) { if (phase == PaintPhase::Foreground) {
auto* hosted_document = dom_node().content_document(); auto* hosted_document = dom_node().content_document();
@ -78,7 +78,7 @@ void LayoutFrame::paint(PaintContext& context, PaintPhase phase)
context.painter().translate(absolute_x(), absolute_y()); context.painter().translate(absolute_x(), absolute_y());
context.set_viewport_rect({ {}, dom_node().content_frame()->size() }); context.set_viewport_rect({ {}, dom_node().content_frame()->size() });
const_cast<LayoutDocument*>(hosted_layout_tree)->paint_all_phases(context); const_cast<Layout::InitialContainingBlockBox*>(hosted_layout_tree)->paint_all_phases(context);
context.set_viewport_rect(old_viewport_rect); context.set_viewport_rect(old_viewport_rect);
context.painter().restore(); context.painter().restore();
@ -91,9 +91,9 @@ void LayoutFrame::paint(PaintContext& context, PaintPhase phase)
} }
} }
void LayoutFrame::did_set_rect() void FrameBox::did_set_rect()
{ {
LayoutReplaced::did_set_rect(); ReplacedBox::did_set_rect();
ASSERT(dom_node().content_frame()); ASSERT(dom_node().content_frame());
dom_node().content_frame()->set_size(size().to_type<int>()); dom_node().content_frame()->set_size(size().to_type<int>());

View file

@ -27,29 +27,29 @@
#pragma once #pragma once
#include <LibWeb/HTML/HTMLIFrameElement.h> #include <LibWeb/HTML/HTMLIFrameElement.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
namespace Web { namespace Web::Layout {
class LayoutFrame final : public LayoutReplaced { class FrameBox final : public ReplacedBox {
public: public:
LayoutFrame(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); FrameBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutFrame() override; virtual ~FrameBox() override;
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
virtual void prepare_for_replaced_layout() override; virtual void prepare_for_replaced_layout() override;
const HTML::HTMLIFrameElement& dom_node() const { return downcast<HTML::HTMLIFrameElement>(LayoutReplaced::dom_node()); } const HTML::HTMLIFrameElement& dom_node() const { return downcast<HTML::HTMLIFrameElement>(ReplacedBox::dom_node()); }
HTML::HTMLIFrameElement& dom_node() { return downcast<HTML::HTMLIFrameElement>(LayoutReplaced::dom_node()); } HTML::HTMLIFrameElement& dom_node() { return downcast<HTML::HTMLIFrameElement>(ReplacedBox::dom_node()); }
private: private:
virtual bool is_frame() const final { return true; } virtual bool is_frame() const final { return true; }
virtual const char* class_name() const override { return "LayoutFrame"; } virtual const char* class_name() const override { return "FrameBox"; }
virtual void did_set_rect() override; virtual void did_set_rect() override;
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutFrame) AK_BEGIN_TYPE_TRAITS(Web::Layout::FrameBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_frame(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_frame(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -28,31 +28,31 @@
#include <LibGfx/Font.h> #include <LibGfx/Font.h>
#include <LibGfx/ImageDecoder.h> #include <LibGfx/ImageDecoder.h>
#include <LibGfx/StylePainter.h> #include <LibGfx/StylePainter.h>
#include <LibWeb/Layout/LayoutImage.h> #include <LibWeb/Layout/ImageBox.h>
namespace Web { namespace Web::Layout {
LayoutImage::LayoutImage(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style, const ImageLoader& image_loader) ImageBox::ImageBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style, const ImageLoader& image_loader)
: LayoutReplaced(document, element, move(style)) : ReplacedBox(document, element, move(style))
, m_image_loader(image_loader) , m_image_loader(image_loader)
{ {
} }
LayoutImage::~LayoutImage() ImageBox::~ImageBox()
{ {
} }
int LayoutImage::preferred_width() const int ImageBox::preferred_width() const
{ {
return dom_node().attribute(HTML::AttributeNames::width).to_int().value_or(m_image_loader.width()); return dom_node().attribute(HTML::AttributeNames::width).to_int().value_or(m_image_loader.width());
} }
int LayoutImage::preferred_height() const int ImageBox::preferred_height() const
{ {
return dom_node().attribute(HTML::AttributeNames::height).to_int().value_or(m_image_loader.height()); return dom_node().attribute(HTML::AttributeNames::height).to_int().value_or(m_image_loader.height());
} }
void LayoutImage::prepare_for_replaced_layout() void ImageBox::prepare_for_replaced_layout()
{ {
if (!m_image_loader.has_loaded_or_failed()) { if (!m_image_loader.has_loaded_or_failed()) {
set_has_intrinsic_width(true); set_has_intrinsic_width(true);
@ -93,7 +93,7 @@ void LayoutImage::prepare_for_replaced_layout()
} }
} }
void LayoutImage::paint(PaintContext& context, PaintPhase phase) void ImageBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -102,7 +102,7 @@ void LayoutImage::paint(PaintContext& context, PaintPhase phase)
if (!context.viewport_rect().intersects(enclosing_int_rect(absolute_rect()))) if (!context.viewport_rect().intersects(enclosing_int_rect(absolute_rect())))
return; return;
LayoutReplaced::paint(context, phase); ReplacedBox::paint(context, phase);
if (phase == PaintPhase::Foreground) { if (phase == PaintPhase::Foreground) {
if (renders_as_alt_text()) { if (renders_as_alt_text()) {
@ -119,14 +119,14 @@ void LayoutImage::paint(PaintContext& context, PaintPhase phase)
} }
} }
bool LayoutImage::renders_as_alt_text() const bool ImageBox::renders_as_alt_text() const
{ {
if (is<HTML::HTMLImageElement>(dom_node())) if (is<HTML::HTMLImageElement>(dom_node()))
return !m_image_loader.has_image(); return !m_image_loader.has_image();
return false; return false;
} }
void LayoutImage::set_visible_in_viewport(Badge<LayoutDocument>, bool visible_in_viewport) void ImageBox::set_visible_in_viewport(Badge<Layout::InitialContainingBlockBox>, bool visible_in_viewport)
{ {
m_image_loader.set_visible_in_viewport(visible_in_viewport); m_image_loader.set_visible_in_viewport(visible_in_viewport);
} }

View file

@ -27,26 +27,26 @@
#pragma once #pragma once
#include <LibWeb/HTML/HTMLImageElement.h> #include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
namespace Web { namespace Web::Layout {
class LayoutImage : public LayoutReplaced { class ImageBox : public ReplacedBox {
public: public:
LayoutImage(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>, const ImageLoader&); ImageBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>, const ImageLoader&);
virtual ~LayoutImage() override; virtual ~ImageBox() override;
virtual void prepare_for_replaced_layout() override; virtual void prepare_for_replaced_layout() override;
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
const DOM::Element& dom_node() const { return static_cast<const DOM::Element&>(LayoutReplaced::dom_node()); } const DOM::Element& dom_node() const { return static_cast<const DOM::Element&>(ReplacedBox::dom_node()); }
bool renders_as_alt_text() const; bool renders_as_alt_text() const;
void set_visible_in_viewport(Badge<LayoutDocument>, bool); void set_visible_in_viewport(Badge<InitialContainingBlockBox>, bool);
private: private:
virtual const char* class_name() const override { return "LayoutImage"; } virtual const char* class_name() const override { return "ImageBox"; }
virtual bool is_image() const override { return true; } virtual bool is_image() const override { return true; }
int preferred_width() const; int preferred_width() const;
@ -57,6 +57,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutImage) AK_BEGIN_TYPE_TRAITS(Web::Layout::ImageBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_image(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_image(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -25,31 +25,31 @@
*/ */
#include <LibWeb/Dump.h> #include <LibWeb/Dump.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/ImageBox.h>
#include <LibWeb/Layout/LayoutImage.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutWidget.h> #include <LibWeb/Layout/WidgetBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
#include <LibWeb/Painting/StackingContext.h> #include <LibWeb/Painting/StackingContext.h>
namespace Web { namespace Web::Layout {
LayoutDocument::LayoutDocument(DOM::Document& document, NonnullRefPtr<CSS::StyleProperties> style) InitialContainingBlockBox::InitialContainingBlockBox(DOM::Document& document, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBlock(document, &document, move(style)) : BlockBox(document, &document, move(style))
{ {
} }
LayoutDocument::~LayoutDocument() InitialContainingBlockBox::~InitialContainingBlockBox()
{ {
} }
void LayoutDocument::build_stacking_context_tree() void InitialContainingBlockBox::build_stacking_context_tree()
{ {
if (stacking_context()) if (stacking_context())
return; return;
set_stacking_context(make<StackingContext>(*this, nullptr)); set_stacking_context(make<StackingContext>(*this, nullptr));
for_each_in_subtree_of_type<LayoutBox>([&](LayoutBox& box) { for_each_in_subtree_of_type<Box>([&](Box& box) {
if (&box == this) if (&box == this)
return IterationDecision::Continue; return IterationDecision::Continue;
if (!box.establishes_stacking_context()) { if (!box.establishes_stacking_context()) {
@ -63,16 +63,16 @@ void LayoutDocument::build_stacking_context_tree()
}); });
} }
void LayoutDocument::did_set_viewport_rect(Badge<Frame>, const Gfx::IntRect& a_viewport_rect) void InitialContainingBlockBox::did_set_viewport_rect(Badge<Frame>, const Gfx::IntRect& a_viewport_rect)
{ {
Gfx::FloatRect viewport_rect(a_viewport_rect.x(), a_viewport_rect.y(), a_viewport_rect.width(), a_viewport_rect.height()); Gfx::FloatRect viewport_rect(a_viewport_rect.x(), a_viewport_rect.y(), a_viewport_rect.width(), a_viewport_rect.height());
for_each_in_subtree_of_type<LayoutImage>([&](auto& layout_image) { for_each_in_subtree_of_type<ImageBox>([&](auto& layout_image) {
const_cast<LayoutImage&>(layout_image).set_visible_in_viewport({}, viewport_rect.intersects(layout_image.absolute_rect())); const_cast<ImageBox&>(layout_image).set_visible_in_viewport({}, viewport_rect.intersects(layout_image.absolute_rect()));
return IterationDecision::Continue; return IterationDecision::Continue;
}); });
} }
void LayoutDocument::paint_all_phases(PaintContext& context) void InitialContainingBlockBox::paint_all_phases(PaintContext& context)
{ {
paint(context, PaintPhase::Background); paint(context, PaintPhase::Background);
paint(context, PaintPhase::Border); paint(context, PaintPhase::Border);
@ -82,17 +82,17 @@ void LayoutDocument::paint_all_phases(PaintContext& context)
paint(context, PaintPhase::Overlay); paint(context, PaintPhase::Overlay);
} }
void LayoutDocument::paint(PaintContext& context, PaintPhase phase) void InitialContainingBlockBox::paint(PaintContext& context, PaintPhase phase)
{ {
stacking_context()->paint(context, phase); stacking_context()->paint(context, phase);
} }
HitTestResult LayoutDocument::hit_test(const Gfx::IntPoint& position, HitTestType type) const HitTestResult InitialContainingBlockBox::hit_test(const Gfx::IntPoint& position, HitTestType type) const
{ {
return stacking_context()->hit_test(position, type); return stacking_context()->hit_test(position, type);
} }
void LayoutDocument::recompute_selection_states() void InitialContainingBlockBox::recompute_selection_states()
{ {
SelectionState state = SelectionState::None; SelectionState state = SelectionState::None;
@ -118,13 +118,13 @@ void LayoutDocument::recompute_selection_states()
}); });
} }
void LayoutDocument::set_selection(const LayoutRange& selection) void InitialContainingBlockBox::set_selection(const LayoutRange& selection)
{ {
m_selection = selection; m_selection = selection;
recompute_selection_states(); recompute_selection_states();
} }
void LayoutDocument::set_selection_end(const LayoutPosition& position) void InitialContainingBlockBox::set_selection_end(const LayoutPosition& position)
{ {
m_selection.set_end(position); m_selection.set_end(position);
recompute_selection_states(); recompute_selection_states();

View file

@ -27,17 +27,17 @@
#pragma once #pragma once
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
namespace Web { namespace Web::Layout {
class LayoutDocument final : public LayoutBlock { class InitialContainingBlockBox final : public BlockBox {
public: public:
explicit LayoutDocument(DOM::Document&, NonnullRefPtr<CSS::StyleProperties>); explicit InitialContainingBlockBox(DOM::Document&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutDocument() override; virtual ~InitialContainingBlockBox() override;
const DOM::Document& dom_node() const { return static_cast<const DOM::Document&>(*LayoutNode::dom_node()); } const DOM::Document& dom_node() const { return static_cast<const DOM::Document&>(*Node::dom_node()); }
virtual const char* class_name() const override { return "LayoutDocument"; } virtual const char* class_name() const override { return "InitialContainingBlockBox"; }
void paint_all_phases(PaintContext&); void paint_all_phases(PaintContext&);
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
@ -62,6 +62,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutDocument) AK_BEGIN_TYPE_TRAITS(Web::Layout::InitialContainingBlockBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_root(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_root(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -27,15 +27,15 @@
#include <LibWeb/CSS/Length.h> #include <LibWeb/CSS/Length.h>
#include <LibWeb/DOM/Node.h> #include <LibWeb/DOM/Node.h>
#include <LibWeb/Dump.h> #include <LibWeb/Dump.h>
#include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/Box.h>
#include <LibWeb/Layout/InlineFormattingContext.h> #include <LibWeb/Layout/InlineFormattingContext.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/ReplacedBox.h>
#include <LibWeb/Layout/LayoutInline.h>
#include <LibWeb/Layout/LayoutReplaced.h>
namespace Web::Layout { namespace Web::Layout {
InlineFormattingContext::InlineFormattingContext(LayoutBox& containing_block) InlineFormattingContext::InlineFormattingContext(Box& containing_block)
: FormattingContext(containing_block) : FormattingContext(containing_block)
{ {
} }
@ -46,7 +46,7 @@ InlineFormattingContext::~InlineFormattingContext()
void InlineFormattingContext::run(LayoutMode layout_mode) void InlineFormattingContext::run(LayoutMode layout_mode)
{ {
auto& containing_block = downcast<LayoutBlock>(context_box()); auto& containing_block = downcast<BlockBox>(context_box());
ASSERT(containing_block.children_are_inline()); ASSERT(containing_block.children_are_inline());
containing_block.line_boxes().clear(); containing_block.line_boxes().clear();
@ -129,7 +129,7 @@ void InlineFormattingContext::run(LayoutMode layout_mode)
} }
if (fragment.layout_node().is_box()) if (fragment.layout_node().is_box())
dimension_box_on_line(const_cast<LayoutBox&>(downcast<LayoutBox>(fragment.layout_node())), layout_mode); dimension_box_on_line(const_cast<Box&>(downcast<Box>(fragment.layout_node())), layout_mode);
float final_line_box_width = 0; float final_line_box_width = 0;
for (auto& fragment : line_box.fragments()) for (auto& fragment : line_box.fragments())
@ -149,19 +149,19 @@ void InlineFormattingContext::run(LayoutMode layout_mode)
containing_block.set_height(content_height); containing_block.set_height(content_height);
} }
void InlineFormattingContext::dimension_box_on_line(LayoutBox& box, LayoutMode layout_mode) void InlineFormattingContext::dimension_box_on_line(Box& box, LayoutMode layout_mode)
{ {
auto& containing_block = downcast<LayoutBlock>(context_box()); auto& containing_block = downcast<BlockBox>(context_box());
if (box.is_replaced()) { if (box.is_replaced()) {
auto& replaced = const_cast<LayoutReplaced&>(downcast<LayoutReplaced>(box)); auto& replaced = const_cast<ReplacedBox&>(downcast<ReplacedBox>(box));
replaced.set_width(replaced.calculate_width()); replaced.set_width(replaced.calculate_width());
replaced.set_height(replaced.calculate_height()); replaced.set_height(replaced.calculate_height());
return; return;
} }
if (box.is_inline_block()) { if (box.is_inline_block()) {
auto& inline_block = const_cast<LayoutBlock&>(downcast<LayoutBlock>(box)); auto& inline_block = const_cast<BlockBox&>(downcast<BlockBox>(box));
if (inline_block.style().width().is_undefined_or_auto()) { if (inline_block.style().width().is_undefined_or_auto()) {
auto result = calculate_shrink_to_fit_widths(inline_block); auto result = calculate_shrink_to_fit_widths(inline_block);

View file

@ -33,13 +33,13 @@ namespace Web::Layout {
class InlineFormattingContext final : public FormattingContext { class InlineFormattingContext final : public FormattingContext {
public: public:
InlineFormattingContext(LayoutBox& containing_block); InlineFormattingContext(Box& containing_block);
~InlineFormattingContext(); ~InlineFormattingContext();
virtual void run(LayoutMode) override; virtual void run(LayoutMode) override;
private: private:
void dimension_box_on_line(LayoutBox&, LayoutMode); void dimension_box_on_line(Box&, LayoutMode);
}; };
} }

View file

@ -25,18 +25,17 @@
*/ */
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/InlineNode.h>
#include <LibWeb/Layout/LayoutInline.h>
namespace Web { namespace Web::Layout {
LayoutInline::LayoutInline(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) InlineNode::InlineNode(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutNodeWithStyleAndBoxModelMetrics(document, &element, move(style)) : Layout::NodeWithStyleAndBoxModelMetrics(document, &element, move(style))
{ {
set_inline(true); set_inline(true);
} }
LayoutInline::~LayoutInline() InlineNode::~InlineNode()
{ {
} }

View file

@ -26,17 +26,15 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
namespace Web { namespace Web::Layout {
class LayoutBlock; class InlineNode : public NodeWithStyleAndBoxModelMetrics {
class LayoutInline : public LayoutNodeWithStyleAndBoxModelMetrics {
public: public:
LayoutInline(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); InlineNode(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutInline() override; virtual ~InlineNode() override;
virtual const char* class_name() const override { return "LayoutInline"; } virtual const char* class_name() const override { return "InlineNode"; }
}; };
} }

View file

@ -24,10 +24,10 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <LibWeb/Layout/LayoutNode.h>
#include <LibWeb/Layout/LayoutPosition.h> #include <LibWeb/Layout/LayoutPosition.h>
#include <LibWeb/Layout/Node.h>
namespace Web { namespace Web::Layout {
LayoutRange LayoutRange::normalized() const LayoutRange LayoutRange::normalized() const
{ {

View file

@ -28,12 +28,12 @@
#include <AK/RefPtr.h> #include <AK/RefPtr.h>
namespace Web { namespace Web::Layout {
class LayoutNode; class Node;
struct LayoutPosition { struct LayoutPosition {
RefPtr<LayoutNode> layout_node; RefPtr<Node> layout_node;
int index_in_node { 0 }; int index_in_node { 0 };
}; };

View file

@ -26,18 +26,18 @@
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/ParentNode.h> #include <LibWeb/DOM/ParentNode.h>
#include <LibWeb/Layout/LayoutNode.h>
#include <LibWeb/Layout/LayoutTable.h>
#include <LibWeb/Layout/LayoutText.h>
#include <LibWeb/Layout/LayoutTreeBuilder.h> #include <LibWeb/Layout/LayoutTreeBuilder.h>
#include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/TableBox.h>
#include <LibWeb/Layout/TextNode.h>
namespace Web { namespace Web::Layout {
LayoutTreeBuilder::LayoutTreeBuilder() LayoutTreeBuilder::LayoutTreeBuilder()
{ {
} }
static RefPtr<LayoutNode> create_layout_tree(DOM::Node& node, const CSS::StyleProperties* parent_style) static RefPtr<Node> create_layout_tree(DOM::Node& node, const CSS::StyleProperties* parent_style)
{ {
auto layout_node = node.create_layout_node(parent_style); auto layout_node = node.create_layout_node(parent_style);
if (!layout_node) if (!layout_node)
@ -46,7 +46,7 @@ static RefPtr<LayoutNode> create_layout_tree(DOM::Node& node, const CSS::StylePr
if (!node.has_children()) if (!node.has_children())
return layout_node; return layout_node;
NonnullRefPtrVector<LayoutNode> layout_children; NonnullRefPtrVector<Node> layout_children;
bool have_inline_children = false; bool have_inline_children = false;
bool have_noninline_children = false; bool have_noninline_children = false;
@ -63,7 +63,7 @@ static RefPtr<LayoutNode> create_layout_tree(DOM::Node& node, const CSS::StylePr
for (auto& layout_child : layout_children) { for (auto& layout_child : layout_children) {
if (have_noninline_children && have_inline_children && layout_child.is_inline()) { if (have_noninline_children && have_inline_children && layout_child.is_inline()) {
if (is<LayoutText>(layout_child) && downcast<LayoutText>(layout_child).text_for_style(*parent_style) == " ") if (is<TextNode>(layout_child) && downcast<TextNode>(layout_child).text_for_style(*parent_style) == " ")
continue; continue;
layout_node->inline_wrapper().append_child(layout_child); layout_node->inline_wrapper().append_child(layout_child);
} else { } else {
@ -77,7 +77,7 @@ static RefPtr<LayoutNode> create_layout_tree(DOM::Node& node, const CSS::StylePr
return layout_node; return layout_node;
} }
RefPtr<LayoutNode> LayoutTreeBuilder::build(DOM::Node& node) RefPtr<Node> LayoutTreeBuilder::build(DOM::Node& node)
{ {
if (!is<DOM::Document>(node) && node.has_children()) { if (!is<DOM::Document>(node) && node.has_children()) {
dbg() << "FIXME: Support building partial layout trees."; dbg() << "FIXME: Support building partial layout trees.";

View file

@ -29,13 +29,13 @@
#include <AK/RefPtr.h> #include <AK/RefPtr.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
namespace Web { namespace Web::Layout {
class LayoutTreeBuilder { class LayoutTreeBuilder {
public: public:
LayoutTreeBuilder(); LayoutTreeBuilder();
RefPtr<LayoutNode> build(DOM::Node&); RefPtr<Node> build(DOM::Node&);
}; };
} }

View file

@ -25,20 +25,20 @@
*/ */
#include <AK/Utf8View.h> #include <AK/Utf8View.h>
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
#include <LibWeb/Layout/LayoutNode.h>
#include <LibWeb/Layout/LayoutText.h>
#include <LibWeb/Layout/LineBox.h> #include <LibWeb/Layout/LineBox.h>
#include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/TextNode.h>
#include <ctype.h> #include <ctype.h>
namespace Web { namespace Web::Layout {
void LineBox::add_fragment(const LayoutNode& layout_node, int start, int length, int width, int height) void LineBox::add_fragment(const Node& layout_node, int start, int length, int width, int height)
{ {
bool text_align_is_justify = layout_node.style().text_align() == CSS::TextAlign::Justify; bool text_align_is_justify = layout_node.style().text_align() == CSS::TextAlign::Justify;
if (!text_align_is_justify && !m_fragments.is_empty() && &m_fragments.last().layout_node() == &layout_node) { if (!text_align_is_justify && !m_fragments.is_empty() && &m_fragments.last().layout_node() == &layout_node) {
// The fragment we're adding is from the last LayoutNode on the line. // The fragment we're adding is from the last Layout::Node on the line.
// Expand the last fragment instead of adding a new one with the same LayoutNode. // Expand the last fragment instead of adding a new one with the same Layout::Node.
m_fragments.last().m_length = (start - m_fragments.last().m_start) + length; m_fragments.last().m_length = (start - m_fragments.last().m_start) + length;
m_fragments.last().set_width(m_fragments.last().width() + width); m_fragments.last().set_width(m_fragments.last().width() + width);
} else { } else {
@ -46,8 +46,8 @@ void LineBox::add_fragment(const LayoutNode& layout_node, int start, int length,
} }
m_width += width; m_width += width;
if (is<LayoutBox>(layout_node)) if (is<Box>(layout_node))
const_cast<LayoutBox&>(downcast<LayoutBox>(layout_node)).set_containing_line_box_fragment(m_fragments.last()); const_cast<Box&>(downcast<Box>(layout_node)).set_containing_line_box_fragment(m_fragments.last());
} }
void LineBox::trim_trailing_whitespace() void LineBox::trim_trailing_whitespace()

View file

@ -30,7 +30,7 @@
#include <AK/Vector.h> #include <AK/Vector.h>
#include <LibWeb/Layout/LineBoxFragment.h> #include <LibWeb/Layout/LineBoxFragment.h>
namespace Web { namespace Web::Layout {
class LineBox { class LineBox {
public: public:
@ -38,7 +38,7 @@ public:
float width() const { return m_width; } float width() const { return m_width; }
void add_fragment(const LayoutNode& layout_node, int start, int length, int width, int height); void add_fragment(const Node& layout_node, int start, int length, int width, int height);
const NonnullOwnPtrVector<LineBoxFragment>& fragments() const { return m_fragments; } const NonnullOwnPtrVector<LineBoxFragment>& fragments() const { return m_fragments; }
NonnullOwnPtrVector<LineBoxFragment>& fragments() { return m_fragments; } NonnullOwnPtrVector<LineBoxFragment>& fragments() { return m_fragments; }
@ -48,8 +48,8 @@ public:
bool ends_in_whitespace() const; bool ends_in_whitespace() const;
private: private:
friend class LayoutBlock; friend class BlockBox;
friend class Layout::InlineFormattingContext; friend class InlineFormattingContext;
NonnullOwnPtrVector<LineBoxFragment> m_fragments; NonnullOwnPtrVector<LineBoxFragment> m_fragments;
float m_width { 0 }; float m_width { 0 };
}; };

View file

@ -26,13 +26,13 @@
#include <AK/Utf8View.h> #include <AK/Utf8View.h>
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutText.h>
#include <LibWeb/Layout/LineBoxFragment.h> #include <LibWeb/Layout/LineBoxFragment.h>
#include <LibWeb/Layout/TextNode.h>
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/PaintContext.h>
#include <ctype.h> #include <ctype.h>
namespace Web { namespace Web::Layout {
void LineBoxFragment::paint(PaintContext& context) void LineBoxFragment::paint(PaintContext& context)
{ {
@ -41,9 +41,8 @@ void LineBoxFragment::paint(PaintContext& context)
return; return;
} }
if (is<LayoutText>(layout_node())) { if (is<TextNode>(layout_node()))
downcast<LayoutText>(layout_node()).paint_fragment(context, *this); downcast<TextNode>(layout_node()).paint_fragment(context, *this);
}
} }
bool LineBoxFragment::ends_in_whitespace() const bool LineBoxFragment::ends_in_whitespace() const
@ -61,9 +60,9 @@ bool LineBoxFragment::is_justifiable_whitespace() const
StringView LineBoxFragment::text() const StringView LineBoxFragment::text() const
{ {
if (!is<LayoutText>(layout_node())) if (!is<TextNode>(layout_node()))
return {}; return {};
return downcast<LayoutText>(layout_node()).text_for_rendering().substring_view(m_start, m_length); return downcast<TextNode>(layout_node()).text_for_rendering().substring_view(m_start, m_length);
} }
const Gfx::FloatRect LineBoxFragment::absolute_rect() const const Gfx::FloatRect LineBoxFragment::absolute_rect() const
@ -78,7 +77,7 @@ int LineBoxFragment::text_index_at(float x) const
{ {
if (!layout_node().is_text()) if (!layout_node().is_text())
return 0; return 0;
auto& layout_text = downcast<LayoutText>(layout_node()); auto& layout_text = downcast<TextNode>(layout_node());
auto& font = layout_text.specified_style().font(); auto& font = layout_text.specified_style().font();
Utf8View view(text()); Utf8View view(text());
@ -100,10 +99,10 @@ int LineBoxFragment::text_index_at(float x) const
Gfx::FloatRect LineBoxFragment::selection_rect(const Gfx::Font& font) const Gfx::FloatRect LineBoxFragment::selection_rect(const Gfx::Font& font) const
{ {
if (layout_node().selection_state() == LayoutNode::SelectionState::None) if (layout_node().selection_state() == Node::SelectionState::None)
return {}; return {};
if (layout_node().selection_state() == LayoutNode::SelectionState::Full) if (layout_node().selection_state() == Node::SelectionState::Full)
return absolute_rect(); return absolute_rect();
auto selection = layout_node().root().selection().normalized(); auto selection = layout_node().root().selection().normalized();
@ -116,7 +115,7 @@ Gfx::FloatRect LineBoxFragment::selection_rect(const Gfx::Font& font) const
const auto end_index = m_start + m_length; const auto end_index = m_start + m_length;
auto text = this->text(); auto text = this->text();
if (layout_node().selection_state() == LayoutNode::SelectionState::StartAndEnd) { if (layout_node().selection_state() == Node::SelectionState::StartAndEnd) {
// we are in the start/end node (both the same) // we are in the start/end node (both the same)
if (start_index > selection.end().index_in_node) if (start_index > selection.end().index_in_node)
return {}; return {};
@ -137,7 +136,7 @@ Gfx::FloatRect LineBoxFragment::selection_rect(const Gfx::Font& font) const
return rect; return rect;
} }
if (layout_node().selection_state() == LayoutNode::SelectionState::Start) { if (layout_node().selection_state() == Node::SelectionState::Start) {
// we are in the start node // we are in the start node
if (end_index < selection.start().index_in_node) if (end_index < selection.start().index_in_node)
return {}; return {};
@ -153,7 +152,7 @@ Gfx::FloatRect LineBoxFragment::selection_rect(const Gfx::Font& font) const
return rect; return rect;
} }
if (layout_node().selection_state() == LayoutNode::SelectionState::End) { if (layout_node().selection_state() == Node::SelectionState::End) {
// we are in the end node // we are in the end node
if (start_index > selection.end().index_in_node) if (start_index > selection.end().index_in_node)
return {}; return {};

View file

@ -31,13 +31,13 @@
#include <LibGfx/Rect.h> #include <LibGfx/Rect.h>
#include <LibWeb/Forward.h> #include <LibWeb/Forward.h>
namespace Web { namespace Web::Layout {
class LineBoxFragment : public Weakable<LineBoxFragment> { class LineBoxFragment : public Weakable<LineBoxFragment> {
friend class LineBox; friend class LineBox;
public: public:
LineBoxFragment(const LayoutNode& layout_node, int start, int length, const Gfx::FloatPoint& offset, const Gfx::FloatSize& size) LineBoxFragment(const Node& layout_node, int start, int length, const Gfx::FloatPoint& offset, const Gfx::FloatSize& size)
: m_layout_node(layout_node) : m_layout_node(layout_node)
, m_start(start) , m_start(start)
, m_length(length) , m_length(length)
@ -46,7 +46,7 @@ public:
{ {
} }
const LayoutNode& layout_node() const { return m_layout_node; } const Node& layout_node() const { return m_layout_node; }
int start() const { return m_start; } int start() const { return m_start; }
int length() const { return m_length; } int length() const { return m_length; }
const Gfx::FloatRect absolute_rect() const; const Gfx::FloatRect absolute_rect() const;
@ -72,7 +72,7 @@ public:
Gfx::FloatRect selection_rect(const Gfx::Font&) const; Gfx::FloatRect selection_rect(const Gfx::Font&) const;
private: private:
const LayoutNode& m_layout_node; const Node& m_layout_node;
int m_start { 0 }; int m_start { 0 };
int m_length { 0 }; int m_length { 0 };
Gfx::FloatPoint m_offset; Gfx::FloatPoint m_offset;

View file

@ -24,21 +24,21 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <LibWeb/Layout/LayoutListItem.h> #include <LibWeb/Layout/ListItemBox.h>
#include <LibWeb/Layout/LayoutListItemMarker.h> #include <LibWeb/Layout/ListItemMarkerBox.h>
namespace Web { namespace Web::Layout {
LayoutListItem::LayoutListItem(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) ListItemBox::ListItemBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBlock(document, &element, move(style)) : Layout::BlockBox(document, &element, move(style))
{ {
} }
LayoutListItem::~LayoutListItem() ListItemBox::~ListItemBox()
{ {
} }
void LayoutListItem::layout_marker() void ListItemBox::layout_marker()
{ {
if (m_marker) { if (m_marker) {
remove_child(*m_marker); remove_child(*m_marker);
@ -49,7 +49,7 @@ void LayoutListItem::layout_marker()
return; return;
if (!m_marker) { if (!m_marker) {
m_marker = adopt(*new LayoutListItemMarker(document())); m_marker = adopt(*new ListItemMarkerBox(document()));
if (first_child()) if (first_child())
m_marker->set_inline(first_child()->is_inline()); m_marker->set_inline(first_child()->is_inline());
append_child(*m_marker); append_child(*m_marker);

View file

@ -27,28 +27,28 @@
#pragma once #pragma once
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
namespace Web { namespace Web::Layout {
class LayoutListItemMarker; class ListItemMarkerBox;
class LayoutListItem final : public LayoutBlock { class ListItemBox final : public BlockBox {
public: public:
LayoutListItem(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); ListItemBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutListItem() override; virtual ~ListItemBox() override;
void layout_marker(); void layout_marker();
private: private:
virtual const char* class_name() const override { return "LayoutListItem"; } virtual const char* class_name() const override { return "ListItemBox"; }
virtual bool is_list_item() const override { return true; } virtual bool is_list_item() const override { return true; }
RefPtr<LayoutListItemMarker> m_marker; RefPtr<ListItemMarkerBox> m_marker;
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutListItem) AK_BEGIN_TYPE_TRAITS(Web::Layout::ListItemBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_list_item(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_list_item(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -25,20 +25,20 @@
*/ */
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibWeb/Layout/LayoutListItemMarker.h> #include <LibWeb/Layout/ListItemMarkerBox.h>
namespace Web { namespace Web::Layout {
LayoutListItemMarker::LayoutListItemMarker(DOM::Document& document) ListItemMarkerBox::ListItemMarkerBox(DOM::Document& document)
: LayoutBox(document, nullptr, CSS::StyleProperties::create()) : Box(document, nullptr, CSS::StyleProperties::create())
{ {
} }
LayoutListItemMarker::~LayoutListItemMarker() ListItemMarkerBox::~ListItemMarkerBox()
{ {
} }
void LayoutListItemMarker::paint(PaintContext& context, PaintPhase phase) void ListItemMarkerBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (phase != PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;

View file

@ -26,19 +26,19 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
namespace Web { namespace Web::Layout {
class LayoutListItemMarker final : public LayoutBox { class ListItemMarkerBox final : public Box {
public: public:
explicit LayoutListItemMarker(DOM::Document&); explicit ListItemMarkerBox(DOM::Document&);
virtual ~LayoutListItemMarker() override; virtual ~ListItemMarkerBox() override;
virtual void paint(PaintContext&, PaintPhase) override; virtual void paint(PaintContext&, PaintPhase) override;
private: private:
virtual const char* class_name() const override { return "LayoutListItemMarker"; } virtual const char* class_name() const override { return "ListItemMarkerBox"; }
}; };
} }

View file

@ -27,15 +27,15 @@
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutDocument.h> #include <LibWeb/Layout/InitialContainingBlockBox.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web { namespace Web::Layout {
LayoutNode::LayoutNode(DOM::Document& document, DOM::Node* node) Node::Node(DOM::Document& document, DOM::Node* node)
: m_document(document) : m_document(document)
, m_dom_node(node) , m_dom_node(node)
{ {
@ -43,24 +43,24 @@ LayoutNode::LayoutNode(DOM::Document& document, DOM::Node* node)
m_dom_node->set_layout_node({}, this); m_dom_node->set_layout_node({}, this);
} }
LayoutNode::~LayoutNode() Node::~Node()
{ {
if (m_dom_node && m_dom_node->layout_node() == this) if (m_dom_node && m_dom_node->layout_node() == this)
m_dom_node->set_layout_node({}, nullptr); m_dom_node->set_layout_node({}, nullptr);
} }
bool LayoutNode::can_contain_boxes_with_position_absolute() const bool Node::can_contain_boxes_with_position_absolute() const
{ {
return style().position() != CSS::Position::Static || is_root(); return style().position() != CSS::Position::Static || is_root();
} }
const LayoutBlock* LayoutNode::containing_block() const const BlockBox* Node::containing_block() const
{ {
auto nearest_block_ancestor = [this] { auto nearest_block_ancestor = [this] {
auto* ancestor = parent(); auto* ancestor = parent();
while (ancestor && !is<LayoutBlock>(*ancestor)) while (ancestor && !is<BlockBox>(*ancestor))
ancestor = ancestor->parent(); ancestor = ancestor->parent();
return downcast<LayoutBlock>(ancestor); return downcast<BlockBox>(ancestor);
}; };
if (is_text()) if (is_text())
@ -72,9 +72,9 @@ const LayoutBlock* LayoutNode::containing_block() const
auto* ancestor = parent(); auto* ancestor = parent();
while (ancestor && !ancestor->can_contain_boxes_with_position_absolute()) while (ancestor && !ancestor->can_contain_boxes_with_position_absolute())
ancestor = ancestor->parent(); ancestor = ancestor->parent();
while (ancestor && (!is<LayoutBlock>(ancestor) || ancestor->is_anonymous())) while (ancestor && (!is<BlockBox>(ancestor) || ancestor->is_anonymous()))
ancestor = ancestor->containing_block(); ancestor = ancestor->containing_block();
return downcast<LayoutBlock>(ancestor); return downcast<BlockBox>(ancestor);
} }
if (position == CSS::Position::Fixed) if (position == CSS::Position::Fixed)
@ -83,7 +83,7 @@ const LayoutBlock* LayoutNode::containing_block() const
return nearest_block_ancestor(); return nearest_block_ancestor();
} }
void LayoutNode::paint(PaintContext& context, PaintPhase phase) void Node::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
@ -91,7 +91,7 @@ void LayoutNode::paint(PaintContext& context, PaintPhase phase)
before_children_paint(context, phase); before_children_paint(context, phase);
for_each_child([&](auto& child) { for_each_child([&](auto& child) {
if (child.is_box() && downcast<LayoutBox>(child).stacking_context()) if (child.is_box() && downcast<Box>(child).stacking_context())
return; return;
child.paint(context, phase); child.paint(context, phase);
}); });
@ -99,13 +99,13 @@ void LayoutNode::paint(PaintContext& context, PaintPhase phase)
after_children_paint(context, phase); after_children_paint(context, phase);
} }
HitTestResult LayoutNode::hit_test(const Gfx::IntPoint& position, HitTestType type) const HitTestResult Node::hit_test(const Gfx::IntPoint& position, HitTestType type) const
{ {
HitTestResult result; HitTestResult result;
for_each_child([&](auto& child) { for_each_child([&](auto& child) {
// Skip over children that establish their own stacking context. // Skip over children that establish their own stacking context.
// The outer loop who called us will take care of those. // The outer loop who called us will take care of those.
if (is<LayoutBox>(child) && downcast<LayoutBox>(child).stacking_context()) if (is<Box>(child) && downcast<Box>(child).stacking_context())
return; return;
auto child_result = child.hit_test(position, type); auto child_result = child.hit_test(position, type);
if (child_result.layout_node) if (child_result.layout_node)
@ -114,38 +114,38 @@ HitTestResult LayoutNode::hit_test(const Gfx::IntPoint& position, HitTestType ty
return result; return result;
} }
const Frame& LayoutNode::frame() const const Frame& Node::frame() const
{ {
ASSERT(document().frame()); ASSERT(document().frame());
return *document().frame(); return *document().frame();
} }
Frame& LayoutNode::frame() Frame& Node::frame()
{ {
ASSERT(document().frame()); ASSERT(document().frame());
return *document().frame(); return *document().frame();
} }
const LayoutDocument& LayoutNode::root() const const InitialContainingBlockBox& Node::root() const
{ {
ASSERT(document().layout_node()); ASSERT(document().layout_node());
return *document().layout_node(); return *document().layout_node();
} }
LayoutDocument& LayoutNode::root() InitialContainingBlockBox& Node::root()
{ {
ASSERT(document().layout_node()); ASSERT(document().layout_node());
return *document().layout_node(); return *document().layout_node();
} }
void LayoutNode::split_into_lines(LayoutBlock& container, LayoutMode layout_mode) void Node::split_into_lines(BlockBox& container, LayoutMode layout_mode)
{ {
for_each_child([&](auto& child) { for_each_child([&](auto& child) {
child.split_into_lines(container, layout_mode); child.split_into_lines(container, layout_mode);
}); });
} }
void LayoutNode::set_needs_display() void Node::set_needs_display()
{ {
if (auto* block = containing_block()) { if (auto* block = containing_block()) {
block->for_each_fragment([&](auto& fragment) { block->for_each_fragment([&](auto& fragment) {
@ -157,17 +157,17 @@ void LayoutNode::set_needs_display()
} }
} }
float LayoutNode::font_size() const float Node::font_size() const
{ {
// FIXME: This doesn't work right for relative font-sizes // FIXME: This doesn't work right for relative font-sizes
auto length = specified_style().length_or_fallback(CSS::PropertyID::FontSize, CSS::Length(10, CSS::Length::Type::Px)); auto length = specified_style().length_or_fallback(CSS::PropertyID::FontSize, CSS::Length(10, CSS::Length::Type::Px));
return length.raw_value(); return length.raw_value();
} }
Gfx::FloatPoint LayoutNode::box_type_agnostic_position() const Gfx::FloatPoint Node::box_type_agnostic_position() const
{ {
if (is_box()) if (is_box())
return downcast<LayoutBox>(*this).absolute_position(); return downcast<Box>(*this).absolute_position();
ASSERT(is_inline()); ASSERT(is_inline());
Gfx::FloatPoint position; Gfx::FloatPoint position;
if (auto* block = containing_block()) { if (auto* block = containing_block()) {
@ -182,14 +182,14 @@ Gfx::FloatPoint LayoutNode::box_type_agnostic_position() const
return position; return position;
} }
bool LayoutNode::is_floating() const bool Node::is_floating() const
{ {
if (!has_style()) if (!has_style())
return false; return false;
return style().float_() != CSS::Float::None; return style().float_() != CSS::Float::None;
} }
bool LayoutNode::is_absolutely_positioned() const bool Node::is_absolutely_positioned() const
{ {
if (!has_style()) if (!has_style())
return false; return false;
@ -197,7 +197,7 @@ bool LayoutNode::is_absolutely_positioned() const
return position == CSS::Position::Absolute || position == CSS::Position::Fixed; return position == CSS::Position::Absolute || position == CSS::Position::Fixed;
} }
bool LayoutNode::is_fixed_position() const bool Node::is_fixed_position() const
{ {
if (!has_style()) if (!has_style())
return false; return false;
@ -205,15 +205,15 @@ bool LayoutNode::is_fixed_position() const
return position == CSS::Position::Fixed; return position == CSS::Position::Fixed;
} }
LayoutNodeWithStyle::LayoutNodeWithStyle(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> specified_style) NodeWithStyle::NodeWithStyle(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> specified_style)
: LayoutNode(document, node) : Node(document, node)
, m_specified_style(move(specified_style)) , m_specified_style(move(specified_style))
{ {
m_has_style = true; m_has_style = true;
apply_style(*m_specified_style); apply_style(*m_specified_style);
} }
void LayoutNodeWithStyle::apply_style(const CSS::StyleProperties& specified_style) void NodeWithStyle::apply_style(const CSS::StyleProperties& specified_style)
{ {
auto& style = static_cast<MutableLayoutStyle&>(m_style); auto& style = static_cast<MutableLayoutStyle&>(m_style);
@ -251,15 +251,15 @@ void LayoutNodeWithStyle::apply_style(const CSS::StyleProperties& specified_styl
style.border_bottom().color = specified_style.color_or_fallback(CSS::PropertyID::BorderBottomColor, document(), Color::Transparent); style.border_bottom().color = specified_style.color_or_fallback(CSS::PropertyID::BorderBottomColor, document(), Color::Transparent);
} }
void LayoutNode::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned) void Node::handle_mousedown(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned)
{ {
} }
void LayoutNode::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned) void Node::handle_mouseup(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned)
{ {
} }
void LayoutNode::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned) void Node::handle_mousemove(Badge<EventHandler>, const Gfx::IntPoint&, unsigned, unsigned)
{ {
} }

View file

@ -38,7 +38,7 @@
#include <LibWeb/Painting/PaintContext.h> #include <LibWeb/Painting/PaintContext.h>
#include <LibWeb/TreeNode.h> #include <LibWeb/TreeNode.h>
namespace Web { namespace Web::Layout {
enum class LayoutMode { enum class LayoutMode {
Default, Default,
@ -47,7 +47,7 @@ enum class LayoutMode {
}; };
struct HitTestResult { struct HitTestResult {
RefPtr<LayoutNode> layout_node; RefPtr<Node> layout_node;
int index_in_node { 0 }; int index_in_node { 0 };
enum InternalPosition { enum InternalPosition {
@ -64,9 +64,9 @@ enum class HitTestType {
TextCursor, // Clicking past the right/bottom edge of text will still hit the text TextCursor, // Clicking past the right/bottom edge of text will still hit the text
}; };
class LayoutNode : public TreeNode<LayoutNode> { class Node : public TreeNode<Node> {
public: public:
virtual ~LayoutNode(); virtual ~Node();
virtual HitTestResult hit_test(const Gfx::IntPoint&, HitTestType) const; virtual HitTestResult hit_test(const Gfx::IntPoint&, HitTestType) const;
@ -80,8 +80,8 @@ public:
const Frame& frame() const; const Frame& frame() const;
Frame& frame(); Frame& frame();
const LayoutDocument& root() const; const InitialContainingBlockBox& root() const;
LayoutDocument& root(); InitialContainingBlockBox& root();
virtual const char* class_name() const = 0; virtual const char* class_name() const = 0;
virtual bool is_root() const { return false; } virtual bool is_root() const { return false; }
@ -130,23 +130,23 @@ public:
bool is_absolutely_positioned() const; bool is_absolutely_positioned() const;
bool is_fixed_position() const; bool is_fixed_position() const;
const LayoutBlock* containing_block() const; const BlockBox* containing_block() const;
bool can_contain_boxes_with_position_absolute() const; bool can_contain_boxes_with_position_absolute() const;
virtual LayoutNode& inline_wrapper() { return *this; } virtual Node& inline_wrapper() { return *this; }
const CSS::StyleProperties& specified_style() const; const CSS::StyleProperties& specified_style() const;
const ImmutableLayoutStyle& style() const; const ImmutableLayoutStyle& style() const;
LayoutNodeWithStyle* parent(); NodeWithStyle* parent();
const LayoutNodeWithStyle* parent() const; const NodeWithStyle* parent() const;
void inserted_into(LayoutNode&) { } void inserted_into(Node&) { }
void removed_from(LayoutNode&) { } void removed_from(Node&) { }
void children_changed() { } void children_changed() { }
virtual void split_into_lines(LayoutBlock& container, LayoutMode); virtual void split_into_lines(BlockBox& container, LayoutMode);
bool is_visible() const { return m_visible; } bool is_visible() const { return m_visible; }
void set_visible(bool visible) { m_visible = visible; } void set_visible(bool visible) { m_visible = visible; }
@ -162,20 +162,20 @@ public:
enum class SelectionState { enum class SelectionState {
None, // No selection None, // No selection
Start, // Selection starts in this LayoutNode Start, // Selection starts in this Node
End, // Selection ends in this LayoutNode End, // Selection ends in this Node
StartAndEnd, // Selection starts and ends in this LayoutNode StartAndEnd, // Selection starts and ends in this Node
Full, // Selection starts before and ends after this LayoutNode Full, // Selection starts before and ends after this Node
}; };
SelectionState selection_state() const { return m_selection_state; } SelectionState selection_state() const { return m_selection_state; }
void set_selection_state(SelectionState state) { m_selection_state = state; } void set_selection_state(SelectionState state) { m_selection_state = state; }
protected: protected:
LayoutNode(DOM::Document&, DOM::Node*); Node(DOM::Document&, DOM::Node*);
private: private:
friend class LayoutNodeWithStyle; friend class NodeWithStyle;
NonnullRefPtr<DOM::Document> m_document; NonnullRefPtr<DOM::Document> m_document;
RefPtr<DOM::Node> m_dom_node; RefPtr<DOM::Node> m_dom_node;
@ -187,9 +187,9 @@ private:
SelectionState m_selection_state { SelectionState::None }; SelectionState m_selection_state { SelectionState::None };
}; };
class LayoutNodeWithStyle : public LayoutNode { class NodeWithStyle : public Node {
public: public:
virtual ~LayoutNodeWithStyle() override { } virtual ~NodeWithStyle() override { }
const CSS::StyleProperties& specified_style() const { return m_specified_style; } const CSS::StyleProperties& specified_style() const { return m_specified_style; }
void set_specified_style(const CSS::StyleProperties& style) { m_specified_style = style; } void set_specified_style(const CSS::StyleProperties& style) { m_specified_style = style; }
@ -199,7 +199,7 @@ public:
void apply_style(const CSS::StyleProperties&); void apply_style(const CSS::StyleProperties&);
protected: protected:
LayoutNodeWithStyle(DOM::Document&, DOM::Node*, NonnullRefPtr<CSS::StyleProperties>); NodeWithStyle(DOM::Document&, DOM::Node*, NonnullRefPtr<CSS::StyleProperties>);
private: private:
LayoutStyle m_style; LayoutStyle m_style;
@ -208,14 +208,14 @@ private:
CSS::Position m_position; CSS::Position m_position;
}; };
class LayoutNodeWithStyleAndBoxModelMetrics : public LayoutNodeWithStyle { class NodeWithStyleAndBoxModelMetrics : public NodeWithStyle {
public: public:
BoxModelMetrics& box_model() { return m_box_model; } BoxModelMetrics& box_model() { return m_box_model; }
const BoxModelMetrics& box_model() const { return m_box_model; } const BoxModelMetrics& box_model() const { return m_box_model; }
protected: protected:
LayoutNodeWithStyleAndBoxModelMetrics(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> style) NodeWithStyleAndBoxModelMetrics(DOM::Document& document, DOM::Node* node, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutNodeWithStyle(document, node, move(style)) : NodeWithStyle(document, node, move(style))
{ {
} }
@ -223,32 +223,32 @@ private:
BoxModelMetrics m_box_model; BoxModelMetrics m_box_model;
}; };
inline const CSS::StyleProperties& LayoutNode::specified_style() const inline const CSS::StyleProperties& Node::specified_style() const
{ {
if (m_has_style) if (m_has_style)
return static_cast<const LayoutNodeWithStyle*>(this)->specified_style(); return static_cast<const NodeWithStyle*>(this)->specified_style();
return parent()->specified_style(); return parent()->specified_style();
} }
inline const ImmutableLayoutStyle& LayoutNode::style() const inline const ImmutableLayoutStyle& Node::style() const
{ {
if (m_has_style) if (m_has_style)
return static_cast<const LayoutNodeWithStyle*>(this)->style(); return static_cast<const NodeWithStyle*>(this)->style();
return parent()->style(); return parent()->style();
} }
inline const LayoutNodeWithStyle* LayoutNode::parent() const inline const NodeWithStyle* Node::parent() const
{ {
return static_cast<const LayoutNodeWithStyle*>(TreeNode<LayoutNode>::parent()); return static_cast<const NodeWithStyle*>(TreeNode<Node>::parent());
} }
inline LayoutNodeWithStyle* LayoutNode::parent() inline NodeWithStyle* Node::parent()
{ {
return static_cast<LayoutNodeWithStyle*>(TreeNode<LayoutNode>::parent()); return static_cast<NodeWithStyle*>(TreeNode<Node>::parent());
} }
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutNodeWithStyle) AK_BEGIN_TYPE_TRAITS(Web::Layout::NodeWithStyle)
static bool is_type(const Web::LayoutNode& node) { return node.has_style(); } static bool is_type(const Web::Layout::Node& node) { return node.has_style(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -25,23 +25,23 @@
*/ */
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
namespace Web { namespace Web::Layout {
LayoutReplaced::LayoutReplaced(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) ReplacedBox::ReplacedBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBox(document, &element, move(style)) : Box(document, &element, move(style))
{ {
// FIXME: Allow non-inline replaced elements. // FIXME: Allow non-inline replaced elements.
set_inline(true); set_inline(true);
} }
LayoutReplaced::~LayoutReplaced() ReplacedBox::~ReplacedBox()
{ {
} }
float LayoutReplaced::calculate_width() const float ReplacedBox::calculate_width() const
{ {
// 10.3.2 [Inline,] replaced elements // 10.3.2 [Inline,] replaced elements
@ -92,7 +92,7 @@ float LayoutReplaced::calculate_width() const
return used_width; return used_width;
} }
float LayoutReplaced::calculate_height() const float ReplacedBox::calculate_height() const
{ {
// 10.6.2 Inline replaced elements, block-level replaced elements in normal flow, // 10.6.2 Inline replaced elements, block-level replaced elements in normal flow,
// 'inline-block' replaced elements in normal flow and floating replaced elements // 'inline-block' replaced elements in normal flow and floating replaced elements
@ -117,7 +117,7 @@ float LayoutReplaced::calculate_height() const
return used_height; return used_height;
} }
void LayoutReplaced::split_into_lines(LayoutBlock& container, LayoutMode) void ReplacedBox::split_into_lines(Layout::BlockBox& container, LayoutMode)
{ {
// FIXME: This feels out of place. It would be nice if someone at a higher level // FIXME: This feels out of place. It would be nice if someone at a higher level
// made sure we had usable geometry by the time we start splitting. // made sure we had usable geometry by the time we start splitting.

View file

@ -27,17 +27,17 @@
#pragma once #pragma once
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
namespace Web { namespace Web::Layout {
class LayoutReplaced : public LayoutBox { class ReplacedBox : public Box {
public: public:
LayoutReplaced(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); ReplacedBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutReplaced() override; virtual ~ReplacedBox() override;
const DOM::Element& dom_node() const { return downcast<DOM::Element>(*LayoutNode::dom_node()); } const DOM::Element& dom_node() const { return downcast<DOM::Element>(*Node::dom_node()); }
DOM::Element& dom_node() { return downcast<DOM::Element>(*LayoutNode::dom_node()); } DOM::Element& dom_node() { return downcast<DOM::Element>(*Node::dom_node()); }
virtual bool is_replaced() const final { return true; } virtual bool is_replaced() const final { return true; }
@ -63,10 +63,10 @@ public:
virtual void prepare_for_replaced_layout() { } virtual void prepare_for_replaced_layout() { }
protected: protected:
virtual void split_into_lines(LayoutBlock& container, LayoutMode) override; virtual void split_into_lines(Layout::BlockBox& container, LayoutMode) override;
private: private:
virtual const char* class_name() const override { return "LayoutReplaced"; } virtual const char* class_name() const override { return "ReplacedBox"; }
bool m_has_intrinsic_width { false }; bool m_has_intrinsic_width { false };
bool m_has_intrinsic_height { false }; bool m_has_intrinsic_height { false };
@ -78,6 +78,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutReplaced) AK_BEGIN_TYPE_TRAITS(Web::Layout::ReplacedBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_replaced(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_replaced(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -27,27 +27,27 @@
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibGfx/Font.h> #include <LibGfx/Font.h>
#include <LibGfx/StylePainter.h> #include <LibGfx/StylePainter.h>
#include <LibWeb/Layout/LayoutSVG.h> #include <LibWeb/Layout/SVGBox.h>
namespace Web { namespace Web::Layout {
LayoutSVG::LayoutSVG(DOM::Document& document, SVG::SVGElement& element, NonnullRefPtr<CSS::StyleProperties> style) SVGBox::SVGBox(DOM::Document& document, SVG::SVGElement& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutReplaced(document, element, move(style)) : ReplacedBox(document, element, move(style))
{ {
} }
void LayoutSVG::before_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) void SVGBox::before_children_paint(PaintContext& context, PaintPhase phase)
{ {
LayoutNode::before_children_paint(context, phase); Node::before_children_paint(context, phase);
if (phase != LayoutNode::PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
context.svg_context().save(); context.svg_context().save();
} }
void LayoutSVG::after_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) void SVGBox::after_children_paint(PaintContext& context, PaintPhase phase)
{ {
LayoutNode::after_children_paint(context, phase); Node::after_children_paint(context, phase);
if (phase != LayoutNode::PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
context.svg_context().restore(); context.svg_context().restore();
} }

View file

@ -26,22 +26,22 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutReplaced.h> #include <LibWeb/Layout/ReplacedBox.h>
#include <LibWeb/SVG/SVGElement.h> #include <LibWeb/SVG/SVGElement.h>
#include <LibWeb/SVG/SVGGraphicsElement.h> #include <LibWeb/SVG/SVGGraphicsElement.h>
namespace Web { namespace Web::Layout {
class LayoutSVG : public LayoutReplaced { class SVGBox : public ReplacedBox {
public: public:
LayoutSVG(DOM::Document&, SVG::SVGElement&, NonnullRefPtr<CSS::StyleProperties>); SVGBox(DOM::Document&, SVG::SVGElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutSVG() override = default; virtual ~SVGBox() override = default;
virtual void before_children_paint(PaintContext& context, PaintPhase phase) override; virtual void before_children_paint(PaintContext& context, PaintPhase phase) override;
virtual void after_children_paint(PaintContext& context, PaintPhase phase) override; virtual void after_children_paint(PaintContext& context, PaintPhase phase) override;
private: private:
virtual const char* class_name() const override { return "LayoutSVG"; } virtual const char* class_name() const override { return "SVGBox"; }
}; };
} }

View file

@ -24,19 +24,19 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <LibWeb/Layout/LayoutSVGGraphics.h> #include <LibWeb/Layout/SVGGraphicsBox.h>
namespace Web { namespace Web::Layout {
LayoutSVGGraphics::LayoutSVGGraphics(DOM::Document& document, SVG::SVGGraphicsElement& element, NonnullRefPtr<CSS::StyleProperties> properties) SVGGraphicsBox::SVGGraphicsBox(DOM::Document& document, SVG::SVGGraphicsElement& element, NonnullRefPtr<CSS::StyleProperties> properties)
: LayoutSVG(document, element, properties) : SVGBox(document, element, properties)
{ {
} }
void LayoutSVGGraphics::before_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) void SVGGraphicsBox::before_children_paint(PaintContext& context, PaintPhase phase)
{ {
LayoutSVG::before_children_paint(context, phase); SVGBox::before_children_paint(context, phase);
if (phase != LayoutNode::PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
auto& graphics_element = downcast<SVG::SVGGraphicsElement>(dom_node()); auto& graphics_element = downcast<SVG::SVGGraphicsElement>(dom_node());

View file

@ -26,21 +26,21 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutSVG.h> #include <LibWeb/Layout/SVGBox.h>
#include <LibWeb/SVG/SVGElement.h> #include <LibWeb/SVG/SVGElement.h>
#include <LibWeb/SVG/SVGGraphicsElement.h> #include <LibWeb/SVG/SVGGraphicsElement.h>
namespace Web { namespace Web::Layout {
class LayoutSVGGraphics : public LayoutSVG { class SVGGraphicsBox : public SVGBox {
public: public:
LayoutSVGGraphics(DOM::Document&, SVG::SVGGraphicsElement&, NonnullRefPtr<CSS::StyleProperties>); SVGGraphicsBox(DOM::Document&, SVG::SVGGraphicsElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutSVGGraphics() override = default; virtual ~SVGGraphicsBox() override = default;
virtual void before_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) override; virtual void before_children_paint(PaintContext& context, PaintPhase phase) override;
private: private:
virtual const char* class_name() const override { return "LayoutSVGGraphics"; } virtual const char* class_name() const override { return "SVGGraphicsBox"; }
}; };
} }

View file

@ -25,17 +25,17 @@
*/ */
#include <LibGfx/Painter.h> #include <LibGfx/Painter.h>
#include <LibWeb/Layout/LayoutSVGPath.h> #include <LibWeb/Layout/SVGPathBox.h>
#include <LibWeb/SVG/SVGPathElement.h> #include <LibWeb/SVG/SVGPathElement.h>
namespace Web { namespace Web::Layout {
LayoutSVGPath::LayoutSVGPath(DOM::Document& document, SVG::SVGPathElement& element, NonnullRefPtr<CSS::StyleProperties> properties) SVGPathBox::SVGPathBox(DOM::Document& document, SVG::SVGPathElement& element, NonnullRefPtr<CSS::StyleProperties> properties)
: LayoutSVGGraphics(document, element, properties) : SVGGraphicsBox(document, element, properties)
{ {
} }
void LayoutSVGPath::prepare_for_replaced_layout() void SVGPathBox::prepare_for_replaced_layout()
{ {
auto& bounding_box = dom_node().get_path().bounding_box(); auto& bounding_box = dom_node().get_path().bounding_box();
set_has_intrinsic_width(true); set_has_intrinsic_width(true);
@ -47,14 +47,14 @@ void LayoutSVGPath::prepare_for_replaced_layout()
set_offset(bounding_box.top_left()); set_offset(bounding_box.top_left());
} }
void LayoutSVGPath::paint(PaintContext& context, LayoutNode::PaintPhase phase) void SVGPathBox::paint(PaintContext& context, PaintPhase phase)
{ {
if (!is_visible()) if (!is_visible())
return; return;
LayoutSVGGraphics::paint(context, phase); SVGGraphicsBox::paint(context, phase);
if (phase != LayoutNode::PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
auto& path_element = dom_node(); auto& path_element = dom_node();

View file

@ -26,22 +26,22 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutSVGGraphics.h> #include <LibWeb/Layout/SVGGraphicsBox.h>
namespace Web { namespace Web::Layout {
class LayoutSVGPath final : public LayoutSVGGraphics { class SVGPathBox final : public SVGGraphicsBox {
public: public:
LayoutSVGPath(DOM::Document&, SVG::SVGPathElement&, NonnullRefPtr<CSS::StyleProperties>); SVGPathBox(DOM::Document&, SVG::SVGPathElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutSVGPath() override = default; virtual ~SVGPathBox() override = default;
SVG::SVGPathElement& dom_node() { return downcast<SVG::SVGPathElement>(LayoutSVGGraphics::dom_node()); } SVG::SVGPathElement& dom_node() { return downcast<SVG::SVGPathElement>(SVGGraphicsBox::dom_node()); }
virtual void prepare_for_replaced_layout() override; virtual void prepare_for_replaced_layout() override;
virtual void paint(PaintContext& context, PaintPhase phase) override; virtual void paint(PaintContext& context, PaintPhase phase) override;
private: private:
virtual const char* class_name() const override { return "LayoutSVGPath"; } virtual const char* class_name() const override { return "SVGPathBox"; }
}; };
} }

View file

@ -24,16 +24,16 @@
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/ */
#include <LibWeb/Layout/LayoutSVGSVG.h> #include <LibWeb/Layout/SVGSVGBox.h>
namespace Web { namespace Web::Layout {
LayoutSVGSVG::LayoutSVGSVG(DOM::Document& document, SVG::SVGSVGElement& element, NonnullRefPtr<CSS::StyleProperties> properties) SVGSVGBox::SVGSVGBox(DOM::Document& document, SVG::SVGSVGElement& element, NonnullRefPtr<CSS::StyleProperties> properties)
: LayoutSVGGraphics(document, element, properties) : SVGGraphicsBox(document, element, properties)
{ {
} }
void LayoutSVGSVG::prepare_for_replaced_layout() void SVGSVGBox::prepare_for_replaced_layout()
{ {
set_has_intrinsic_width(true); set_has_intrinsic_width(true);
set_has_intrinsic_height(true); set_has_intrinsic_height(true);
@ -41,21 +41,21 @@ void LayoutSVGSVG::prepare_for_replaced_layout()
set_intrinsic_height(dom_node().height()); set_intrinsic_height(dom_node().height());
} }
void LayoutSVGSVG::before_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) void SVGSVGBox::before_children_paint(PaintContext& context, PaintPhase phase)
{ {
if (phase != LayoutNode::PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
if (!context.has_svg_context()) if (!context.has_svg_context())
context.set_svg_context(SVGContext()); context.set_svg_context(SVGContext());
LayoutSVGGraphics::before_children_paint(context, phase); SVGGraphicsBox::before_children_paint(context, phase);
} }
void LayoutSVGSVG::after_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) void SVGSVGBox::after_children_paint(PaintContext& context, PaintPhase phase)
{ {
LayoutSVGGraphics::after_children_paint(context, phase); SVGGraphicsBox::after_children_paint(context, phase);
if (phase != LayoutNode::PaintPhase::Foreground) if (phase != PaintPhase::Foreground)
return; return;
} }

View file

@ -26,25 +26,25 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutSVGGraphics.h> #include <LibWeb/Layout/SVGGraphicsBox.h>
#include <LibWeb/SVG/SVGSVGElement.h> #include <LibWeb/SVG/SVGSVGElement.h>
namespace Web { namespace Web::Layout {
class LayoutSVGSVG final : public LayoutSVGGraphics { class SVGSVGBox final : public SVGGraphicsBox {
public: public:
LayoutSVGSVG(DOM::Document&, SVG::SVGSVGElement&, NonnullRefPtr<CSS::StyleProperties>); SVGSVGBox(DOM::Document&, SVG::SVGSVGElement&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutSVGSVG() override = default; virtual ~SVGSVGBox() override = default;
SVG::SVGSVGElement& dom_node() { return downcast<SVG::SVGSVGElement>(LayoutSVGGraphics::dom_node()); } SVG::SVGSVGElement& dom_node() { return downcast<SVG::SVGSVGElement>(SVGGraphicsBox::dom_node()); }
virtual void prepare_for_replaced_layout() override; virtual void prepare_for_replaced_layout() override;
virtual void before_children_paint(PaintContext& context, LayoutNode::PaintPhase phase) override; virtual void before_children_paint(PaintContext& context, PaintPhase phase) override;
virtual void after_children_paint(PaintContext& context, PaintPhase phase) override; virtual void after_children_paint(PaintContext& context, PaintPhase phase) override;
private: private:
const char* class_name() const override { return "LayoutSVGSVG"; } const char* class_name() const override { return "SVGSVGBox"; }
}; };
} }

View file

@ -25,18 +25,16 @@
*/ */
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutTable.h> #include <LibWeb/Layout/TableBox.h>
#include <LibWeb/Layout/LayoutTableCell.h>
#include <LibWeb/Layout/LayoutTableRow.h>
namespace Web { namespace Web::Layout {
LayoutTableRow::LayoutTableRow(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) TableBox::TableBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBox(document, &element, move(style)) : Layout::BlockBox(document, &element, move(style))
{ {
} }
LayoutTableRow::~LayoutTableRow() TableBox::~TableBox()
{ {
} }

View file

@ -26,22 +26,22 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
namespace Web { namespace Web::Layout {
class LayoutTable final : public LayoutBlock { class TableBox final : public Layout::BlockBox {
public: public:
LayoutTable(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); TableBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutTable() override; virtual ~TableBox() override;
private: private:
virtual bool is_table() const override { return true; } virtual bool is_table() const override { return true; }
virtual const char* class_name() const override { return "LayoutTable"; } virtual const char* class_name() const override { return "TableBox"; }
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutTable) AK_BEGIN_TYPE_TRAITS(Web::Layout::TableBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_table(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_table(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -25,29 +25,29 @@
*/ */
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutTableCell.h> #include <LibWeb/Layout/TableCellBox.h>
#include <LibWeb/Layout/LayoutTableRow.h> #include <LibWeb/Layout/TableRowBox.h>
namespace Web { namespace Web::Layout {
LayoutTableCell::LayoutTableCell(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) TableCellBox::TableCellBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBlock(document, &element, move(style)) : Layout::BlockBox(document, &element, move(style))
{ {
} }
LayoutTableCell::~LayoutTableCell() TableCellBox::~TableCellBox()
{ {
} }
size_t LayoutTableCell::colspan() const size_t TableCellBox::colspan() const
{ {
ASSERT(dom_node()); ASSERT(dom_node());
return downcast<DOM::Element>(*dom_node()).attribute(HTML::AttributeNames::colspan).to_uint().value_or(1); return downcast<DOM::Element>(*dom_node()).attribute(HTML::AttributeNames::colspan).to_uint().value_or(1);
} }
float LayoutTableCell::width_of_logical_containing_block() const float TableCellBox::width_of_logical_containing_block() const
{ {
if (auto* row = first_ancestor_of_type<LayoutTableRow>()) if (auto* row = first_ancestor_of_type<TableRowBox>())
return row->width(); return row->width();
return 0; return 0;
} }

View file

@ -26,28 +26,28 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
namespace Web { namespace Web::Layout {
class LayoutTableCell final : public LayoutBlock { class TableCellBox final : public BlockBox {
public: public:
LayoutTableCell(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); TableCellBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutTableCell() override; virtual ~TableCellBox() override;
LayoutTableCell* next_cell() { return next_sibling_of_type<LayoutTableCell>(); } TableCellBox* next_cell() { return next_sibling_of_type<TableCellBox>(); }
const LayoutTableCell* next_cell() const { return next_sibling_of_type<LayoutTableCell>(); } const TableCellBox* next_cell() const { return next_sibling_of_type<TableCellBox>(); }
size_t colspan() const; size_t colspan() const;
private: private:
virtual bool is_table_cell() const override { return true; } virtual bool is_table_cell() const override { return true; }
virtual const char* class_name() const override { return "LayoutTableCell"; } virtual const char* class_name() const override { return "TableCellBox"; }
virtual float width_of_logical_containing_block() const override; virtual float width_of_logical_containing_block() const override;
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutTableCell) AK_BEGIN_TYPE_TRAITS(Web::Layout::TableCellBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_table_cell(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_table_cell(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -26,19 +26,19 @@
#include <LibWeb/CSS/Length.h> #include <LibWeb/CSS/Length.h>
#include <LibWeb/DOM/Node.h> #include <LibWeb/DOM/Node.h>
#include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/Box.h>
#include <LibWeb/Layout/InlineFormattingContext.h> #include <LibWeb/Layout/InlineFormattingContext.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/TableBox.h>
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/TableCellBox.h>
#include <LibWeb/Layout/LayoutTable.h>
#include <LibWeb/Layout/LayoutTableCell.h>
#include <LibWeb/Layout/LayoutTableRow.h>
#include <LibWeb/Layout/LayoutTableRowGroup.h>
#include <LibWeb/Layout/TableFormattingContext.h> #include <LibWeb/Layout/TableFormattingContext.h>
#include <LibWeb/Layout/TableRowBox.h>
#include <LibWeb/Layout/TableRowGroupBox.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
namespace Web::Layout { namespace Web::Layout {
TableFormattingContext::TableFormattingContext(LayoutBox& context_box) TableFormattingContext::TableFormattingContext(Box& context_box)
: BlockFormattingContext(context_box) : BlockFormattingContext(context_box)
{ {
} }
@ -51,19 +51,19 @@ void TableFormattingContext::run(LayoutMode)
{ {
compute_width(context_box()); compute_width(context_box());
context_box().for_each_child_of_type<LayoutTableRowGroup>([&](auto& box) { context_box().for_each_child_of_type<TableRowGroupBox>([&](auto& box) {
compute_width(box); compute_width(box);
auto column_count = box.column_count(); auto column_count = box.column_count();
Vector<float> column_widths; Vector<float> column_widths;
column_widths.resize(column_count); column_widths.resize(column_count);
box.template for_each_child_of_type<LayoutTableRow>([&](auto& row) { box.template for_each_child_of_type<TableRowBox>([&](auto& row) {
calculate_column_widths(row, column_widths); calculate_column_widths(row, column_widths);
}); });
float content_height = 0; float content_height = 0;
box.template for_each_child_of_type<LayoutTableRow>([&](auto& row) { box.template for_each_child_of_type<TableRowBox>([&](auto& row) {
row.set_offset(0, content_height); row.set_offset(0, content_height);
layout_row(row, column_widths); layout_row(row, column_widths);
content_height += row.height(); content_height += row.height();
@ -75,12 +75,12 @@ void TableFormattingContext::run(LayoutMode)
compute_height(context_box()); compute_height(context_box());
} }
void TableFormattingContext::calculate_column_widths(LayoutBox& row, Vector<float>& column_widths) void TableFormattingContext::calculate_column_widths(Box& row, Vector<float>& column_widths)
{ {
size_t column_index = 0; size_t column_index = 0;
auto* table = row.first_ancestor_of_type<LayoutTable>(); auto* table = row.first_ancestor_of_type<TableBox>();
bool use_auto_layout = !table || table->style().width().is_undefined_or_auto(); bool use_auto_layout = !table || table->style().width().is_undefined_or_auto();
row.for_each_child_of_type<LayoutTableCell>([&](auto& cell) { row.for_each_child_of_type<TableCellBox>([&](auto& cell) {
compute_width(cell); compute_width(cell);
if (use_auto_layout) { if (use_auto_layout) {
layout_inside(cell, LayoutMode::OnlyRequiredLineBreaks); layout_inside(cell, LayoutMode::OnlyRequiredLineBreaks);
@ -92,15 +92,15 @@ void TableFormattingContext::calculate_column_widths(LayoutBox& row, Vector<floa
}); });
} }
void TableFormattingContext::layout_row(LayoutBox& row, Vector<float>& column_widths) void TableFormattingContext::layout_row(Box& row, Vector<float>& column_widths)
{ {
size_t column_index = 0; size_t column_index = 0;
float tallest_cell_height = 0; float tallest_cell_height = 0;
float content_width = 0; float content_width = 0;
auto* table = row.first_ancestor_of_type<LayoutTable>(); auto* table = row.first_ancestor_of_type<TableBox>();
bool use_auto_layout = !table || table->style().width().is_undefined_or_auto(); bool use_auto_layout = !table || table->style().width().is_undefined_or_auto();
row.for_each_child_of_type<LayoutTableCell>([&](auto& cell) { row.for_each_child_of_type<TableCellBox>([&](auto& cell) {
cell.set_offset(row.effective_offset().translated(content_width, 0)); cell.set_offset(row.effective_offset().translated(content_width, 0));
// Layout the cell contents a second time, now that we know its final width. // Layout the cell contents a second time, now that we know its final width.

View file

@ -33,14 +33,14 @@ namespace Web::Layout {
class TableFormattingContext final : public BlockFormattingContext { class TableFormattingContext final : public BlockFormattingContext {
public: public:
explicit TableFormattingContext(LayoutBox& containing_block); explicit TableFormattingContext(Box& containing_block);
~TableFormattingContext(); ~TableFormattingContext();
virtual void run(LayoutMode) override; virtual void run(LayoutMode) override;
private: private:
void calculate_column_widths(LayoutBox& row, Vector<float>& column_widths); void calculate_column_widths(Box& row, Vector<float>& column_widths);
void layout_row(LayoutBox& row, Vector<float>& column_widths); void layout_row(Box& row, Vector<float>& column_widths);
}; };
} }

View file

@ -25,17 +25,16 @@
*/ */
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutTable.h> #include <LibWeb/Layout/TableRowBox.h>
#include <LibWeb/Layout/LayoutTableRow.h>
namespace Web { namespace Web::Layout {
LayoutTable::LayoutTable(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) TableRowBox::TableRowBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBlock(document, &element, move(style)) : Box(document, &element, move(style))
{ {
} }
LayoutTable::~LayoutTable() TableRowBox::~TableRowBox()
{ {
} }

View file

@ -26,24 +26,22 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBox.h> #include <LibWeb/Layout/Box.h>
namespace Web { namespace Web::Layout {
class LayoutTableCell; class TableRowBox final : public Box {
class LayoutTableRow final : public LayoutBox {
public: public:
LayoutTableRow(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); TableRowBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutTableRow() override; virtual ~TableRowBox() override;
private: private:
virtual bool is_table_row() const override { return true; } virtual bool is_table_row() const override { return true; }
virtual const char* class_name() const override { return "LayoutTableRow"; } virtual const char* class_name() const override { return "TableRowBox"; }
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutTableRow) AK_BEGIN_TYPE_TRAITS(Web::Layout::TableRowBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_table_row(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_table_row(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -25,27 +25,27 @@
*/ */
#include <LibWeb/DOM/Element.h> #include <LibWeb/DOM/Element.h>
#include <LibWeb/Layout/LayoutTableCell.h> #include <LibWeb/Layout/TableCellBox.h>
#include <LibWeb/Layout/LayoutTableRow.h> #include <LibWeb/Layout/TableRowBox.h>
#include <LibWeb/Layout/LayoutTableRowGroup.h> #include <LibWeb/Layout/TableRowGroupBox.h>
namespace Web { namespace Web::Layout {
LayoutTableRowGroup::LayoutTableRowGroup(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style) TableRowGroupBox::TableRowGroupBox(DOM::Document& document, DOM::Element& element, NonnullRefPtr<CSS::StyleProperties> style)
: LayoutBlock(document, &element, move(style)) : Layout::BlockBox(document, &element, move(style))
{ {
} }
LayoutTableRowGroup::~LayoutTableRowGroup() TableRowGroupBox::~TableRowGroupBox()
{ {
} }
size_t LayoutTableRowGroup::column_count() const size_t TableRowGroupBox::column_count() const
{ {
size_t table_column_count = 0; size_t table_column_count = 0;
for_each_child_of_type<LayoutTableRow>([&](auto& row) { for_each_child_of_type<TableRowBox>([&](auto& row) {
size_t row_column_count = 0; size_t row_column_count = 0;
row.template for_each_child_of_type<LayoutTableCell>([&](auto& cell) { row.template for_each_child_of_type<TableCellBox>([&](auto& cell) {
row_column_count += cell.colspan(); row_column_count += cell.colspan();
}); });
table_column_count = max(table_column_count, row_column_count); table_column_count = max(table_column_count, row_column_count);

View file

@ -26,24 +26,24 @@
#pragma once #pragma once
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
namespace Web { namespace Web::Layout {
class LayoutTableRowGroup final : public LayoutBlock { class TableRowGroupBox final : public BlockBox {
public: public:
LayoutTableRowGroup(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>); TableRowGroupBox(DOM::Document&, DOM::Element&, NonnullRefPtr<CSS::StyleProperties>);
virtual ~LayoutTableRowGroup() override; virtual ~TableRowGroupBox() override;
size_t column_count() const; size_t column_count() const;
private: private:
virtual bool is_table_row_group() const override { return true; } virtual bool is_table_row_group() const override { return true; }
virtual const char* class_name() const override { return "LayoutTableRowGroup"; } virtual const char* class_name() const override { return "TableRowGroupBox"; }
}; };
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutTableRowGroup) AK_BEGIN_TYPE_TRAITS(Web::Layout::TableRowGroupBox)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_table_row_group(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_table_row_group(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

View file

@ -30,20 +30,20 @@
#include <LibGUI/Painter.h> #include <LibGUI/Painter.h>
#include <LibGfx/Font.h> #include <LibGfx/Font.h>
#include <LibWeb/DOM/Document.h> #include <LibWeb/DOM/Document.h>
#include <LibWeb/Layout/LayoutBlock.h> #include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/LayoutText.h> #include <LibWeb/Layout/TextNode.h>
#include <LibWeb/Page/Frame.h> #include <LibWeb/Page/Frame.h>
#include <ctype.h> #include <ctype.h>
namespace Web { namespace Web::Layout {
LayoutText::LayoutText(DOM::Document& document, DOM::Text& text) TextNode::TextNode(DOM::Document& document, DOM::Text& text)
: LayoutNode(document, &text) : Node(document, &text)
{ {
set_inline(true); set_inline(true);
} }
LayoutText::~LayoutText() TextNode::~TextNode()
{ {
} }
@ -56,7 +56,7 @@ static bool is_all_whitespace(const StringView& string)
return true; return true;
} }
const String& LayoutText::text_for_style(const CSS::StyleProperties& style) const const String& TextNode::text_for_style(const CSS::StyleProperties& style) const
{ {
static String one_space = " "; static String one_space = " ";
if (is_all_whitespace(dom_node().data())) { if (is_all_whitespace(dom_node().data())) {
@ -66,7 +66,7 @@ const String& LayoutText::text_for_style(const CSS::StyleProperties& style) cons
return dom_node().data(); return dom_node().data();
} }
void LayoutText::paint_fragment(PaintContext& context, const LineBoxFragment& fragment) const void TextNode::paint_fragment(PaintContext& context, const LineBoxFragment& fragment) const
{ {
auto& painter = context.painter(); auto& painter = context.painter();
painter.set_font(specified_style().font()); painter.set_font(specified_style().font());
@ -106,7 +106,7 @@ void LayoutText::paint_fragment(PaintContext& context, const LineBoxFragment& fr
paint_cursor_if_needed(context, fragment); paint_cursor_if_needed(context, fragment);
} }
void LayoutText::paint_cursor_if_needed(PaintContext& context, const LineBoxFragment& fragment) const void TextNode::paint_cursor_if_needed(PaintContext& context, const LineBoxFragment& fragment) const
{ {
if (!frame().is_focused_frame()) if (!frame().is_focused_frame())
return; return;
@ -133,7 +133,7 @@ void LayoutText::paint_cursor_if_needed(PaintContext& context, const LineBoxFrag
} }
template<typename Callback> template<typename Callback>
void LayoutText::for_each_chunk(Callback callback, LayoutMode layout_mode, bool do_wrap_lines, bool do_wrap_breaks) const void TextNode::for_each_chunk(Callback callback, LayoutMode layout_mode, bool do_wrap_lines, bool do_wrap_breaks) const
{ {
Utf8View view(m_text_for_rendering); Utf8View view(m_text_for_rendering);
if (view.is_empty()) if (view.is_empty())
@ -185,7 +185,7 @@ void LayoutText::for_each_chunk(Callback callback, LayoutMode layout_mode, bool
commit_chunk(view.end(), false, true); commit_chunk(view.end(), false, true);
} }
void LayoutText::split_into_lines_by_rules(LayoutBlock& container, LayoutMode layout_mode, bool do_collapse, bool do_wrap_lines, bool do_wrap_breaks) void TextNode::split_into_lines_by_rules(BlockBox& container, LayoutMode layout_mode, bool do_collapse, bool do_wrap_lines, bool do_wrap_breaks)
{ {
auto& font = specified_style().font(); auto& font = specified_style().font();
float space_width = font.glyph_width(' ') + font.glyph_spacing(); float space_width = font.glyph_width(' ') + font.glyph_spacing();
@ -285,7 +285,7 @@ void LayoutText::split_into_lines_by_rules(LayoutBlock& container, LayoutMode la
} }
} }
void LayoutText::split_into_lines(LayoutBlock& container, LayoutMode layout_mode) void TextNode::split_into_lines(BlockBox& container, LayoutMode layout_mode)
{ {
bool do_collapse = true; bool do_collapse = true;
bool do_wrap_lines = true; bool do_wrap_lines = true;

View file

@ -27,33 +27,33 @@
#pragma once #pragma once
#include <LibWeb/DOM/Text.h> #include <LibWeb/DOM/Text.h>
#include <LibWeb/Layout/LayoutNode.h> #include <LibWeb/Layout/Node.h>
namespace Web { namespace Web::Layout {
class LineBoxFragment; class LineBoxFragment;
class LayoutText : public LayoutNode { class TextNode : public Node {
public: public:
LayoutText(DOM::Document&, DOM::Text&); TextNode(DOM::Document&, DOM::Text&);
virtual ~LayoutText() override; virtual ~TextNode() override;
const DOM::Text& dom_node() const { return static_cast<const DOM::Text&>(*LayoutNode::dom_node()); } const DOM::Text& dom_node() const { return static_cast<const DOM::Text&>(*Node::dom_node()); }
const String& text_for_style(const CSS::StyleProperties&) const; const String& text_for_style(const CSS::StyleProperties&) const;
const String& text_for_rendering() const { return m_text_for_rendering; } const String& text_for_rendering() const { return m_text_for_rendering; }
virtual const char* class_name() const override { return "LayoutText"; } virtual const char* class_name() const override { return "TextNode"; }
virtual bool is_text() const final { return true; } virtual bool is_text() const final { return true; }
void paint_fragment(PaintContext&, const LineBoxFragment&) const; void paint_fragment(PaintContext&, const LineBoxFragment&) const;
virtual void split_into_lines(LayoutBlock& container, LayoutMode) override; virtual void split_into_lines(BlockBox& container, LayoutMode) override;
const CSS::StyleProperties& specified_style() const { return parent()->specified_style(); } const CSS::StyleProperties& specified_style() const { return parent()->specified_style(); }
private: private:
void split_into_lines_by_rules(LayoutBlock& container, LayoutMode, bool do_collapse, bool do_wrap_lines, bool do_wrap_breaks); void split_into_lines_by_rules(BlockBox& container, LayoutMode, bool do_collapse, bool do_wrap_lines, bool do_wrap_breaks);
void paint_cursor_if_needed(PaintContext&, const LineBoxFragment&) const; void paint_cursor_if_needed(PaintContext&, const LineBoxFragment&) const;
template<typename Callback> template<typename Callback>
@ -64,6 +64,6 @@ private:
} }
AK_BEGIN_TYPE_TRAITS(Web::LayoutText) AK_BEGIN_TYPE_TRAITS(Web::Layout::TextNode)
static bool is_type(const Web::LayoutNode& layout_node) { return layout_node.is_text(); } static bool is_type(const Web::Layout::Node& layout_node) { return layout_node.is_text(); }
AK_END_TYPE_TRAITS() AK_END_TYPE_TRAITS()

Some files were not shown because too many files have changed in this diff Show more