LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2024-11-10 13:00:29 +03:00
Code Issues Packages Projects Releases Wiki Activity
3bb0cb2202
ladybird/Libraries/LibWeb/Dump.cpp

404 lines
16 KiB
C++
Raw Normal View History

Meta: Add license header to source files As suggested by Joshua, this commit adds the 2-clause BSD license as a comment block to the top of every source file. For the first pass, I've just added myself for simplicity. I encourage everyone to add themselves as copyright holders of any file they've added or modified in some significant way. If I've added myself in error somewhere, feel free to replace it with the appropriate copyright holder instead. Going forward, all new source files should include a license header.
2020-01-18 11:38:21 +03:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
*
* 1. Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimer in the documentation
* and/or other materials provided with the distribution.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
LibWeb: Dump layout node style properties in alphabetical order
2020-06-14 19:47:21 +03:00
#include <AK/QuickSort.h>
LibWeb: Colorize tag names in layout tree dumps + show element IDs Showing element IDs in layout tree dumps makes it much easier to compare against the DOM.
2020-05-23 22:05:26 +03:00
#include <AK/StringBuilder.h>
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
#include <AK/Utf8View.h>
LibWeb: Rename directory LibHTML => LibWeb Let's rename this to LibWeb since it aims to provide more parts of the web platform than just HTML. :^)
2020-03-07 12:32:51 +03:00
#include <LibWeb/CSS/PropertyID.h>
#include <LibWeb/CSS/StyleSheet.h>
#include <LibWeb/DOM/Comment.h>
#include <LibWeb/DOM/Document.h>
LibWeb: Make dump_tree() look okay for DocumentFragments
2020-03-25 20:49:29 +03:00
#include <LibWeb/DOM/DocumentFragment.h>
LibWeb: Rename directory LibHTML => LibWeb Let's rename this to LibWeb since it aims to provide more parts of the web platform than just HTML. :^)
2020-03-07 12:32:51 +03:00
#include <LibWeb/DOM/DocumentType.h>
#include <LibWeb/DOM/Element.h>
#include <LibWeb/DOM/Text.h>
#include <LibWeb/Dump.h>
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-20 00:30:33 +03:00
#include <LibWeb/HTML/HTMLTemplateElement.h>
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!)
2020-11-22 17:53:01 +03:00
#include <LibWeb/Layout/BlockBox.h>
#include <LibWeb/Layout/Node.h>
#include <LibWeb/Layout/TextNode.h>
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
#include <stdio.h>
LibWeb: Move everything into the Web namespace
2020-03-07 12:27:02 +03:00
namespace Web {
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
void dump_tree(const DOM::Node& node)
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
{
static int indent = 0;
for (int i = 0; i < indent; ++i)
LibHTML: Let's put debug output on the debugger stream
2019-10-03 11:25:00 +03:00
dbgprintf(" ");
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
if (is<DOM::Document>(node)) {
LibHTML: Let's put debug output on the debugger stream
2019-10-03 11:25:00 +03:00
dbgprintf("*Document*\n");
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
} else if (is<DOM::Element>(node)) {
dbgprintf("<%s", downcast<DOM::Element>(node).local_name().characters());
downcast<DOM::Element>(node).for_each_attribute([](auto& name, auto& value) {
LibHTML: Let's put debug output on the debugger stream
2019-10-03 11:25:00 +03:00
dbgprintf(" %s=%s", name.characters(), value.characters());
LibHTML: Basic element attribute parsing.
2019-06-15 22:08:36 +03:00
});
LibHTML: Let's put debug output on the debugger stream
2019-10-03 11:25:00 +03:00
dbgprintf(">\n");
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
} else if (is<DOM::Text>(node)) {
dbgprintf("\"%s\"\n", downcast<DOM::Text>(node).data().characters());
} else if (is<DOM::DocumentType>(node)) {
Base: Replace <!DOCTYPE> with <!DOCTYPE html> in a few files (#1511) <!DOCTYPE> by itself is not a valid document type declaration.
2020-03-26 09:37:12 +03:00
dbgprintf("<!DOCTYPE html>\n");
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
} else if (is<DOM::Comment>(node)) {
dbgprintf("<!--%s-->\n", downcast<DOM::Comment>(node).data().characters());
} else if (is<DOM::DocumentFragment>(node)) {
LibWeb: Make dump_tree() look okay for DocumentFragments
2020-03-25 20:49:29 +03:00
dbgprintf("#document-fragment\n");
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
}
++indent;
LibWeb: Move DOM classes into the Web::DOM namespace LibWeb keeps growing and the Web namespace is filling up fast. Let's put DOM stuff into Web::DOM, just like we already started doing with SVG stuff in Web::SVG.
2020-07-26 20:37:56 +03:00
if (is<DOM::ParentNode>(node)) {
LibWeb: Implement <template> parsing Note that there is currently no way to display them as we can't currently clone nodes. Adds special case for templates for dumping to console. Doesn't add it to the DOM inspector as I'm not sure how to do it.
2020-08-20 00:30:33 +03:00
if (!is<HTML::HTMLTemplateElement>(node)) {
static_cast<const DOM::ParentNode&>(node).for_each_child([](auto& child) {
dump_tree(child);
});
} else {
auto& template_element = downcast<HTML::HTMLTemplateElement>(node);
dump_tree(template_element.content());
}
LibHTML: Start working on a simple HTML library. I'd like to have rich text, and we might as well use HTML for that. :^)
2019-06-15 19:55:47 +03:00
}
--indent;
}
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 23:49:44 +03:00
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
void dump_tree(const Layout::Node& layout_node, bool show_box_model, bool show_specified_style)
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
{
StringBuilder builder;
dump_tree(builder, layout_node, show_box_model, show_specified_style, true);
dbgprintf("%s", builder.to_string().characters());
}
void dump_tree(StringBuilder& builder, const Layout::Node& layout_node, bool show_box_model, bool show_specified_style, bool interactive)
LibHTML: Start fleshing out a basic layout tree.
2019-06-15 23:49:44 +03:00
{
AK: Make Vector use size_t for its size and capacity
2020-02-25 16:49:47 +03:00
static size_t indent = 0;
for (size_t i = 0; i < indent; ++i)
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.append(" ");
LibHTML: Give LayoutNodes a rect. Also improve the layout tree dump format somewhat.
2019-06-16 12:28:47 +03:00
LibWeb: Use FlyString for Element tag names This makes selector matching a lot more efficient, and also reduces the number of strings on the heap.
2020-03-22 21:10:43 +03:00
FlyString tag_name;
LibHTML: Give LayoutNodes a rect. Also improve the layout tree dump format somewhat.
2019-06-16 12:28:47 +03:00
if (layout_node.is_anonymous())
tag_name = "(anonymous)";
LibWeb: Rename LayoutNode::node() => LayoutNode::dom_node()
2020-11-22 16:46:36 +03:00
else if (is<DOM::Text>(layout_node.dom_node()))
LibHTML: Give LayoutNodes a rect. Also improve the layout tree dump format somewhat.
2019-06-16 12:28:47 +03:00
tag_name = "#text";
LibWeb: Rename LayoutNode::node() => LayoutNode::dom_node()
2020-11-22 16:46:36 +03:00
else if (is<DOM::Document>(layout_node.dom_node()))
LibHTML: Give LayoutNodes a rect. Also improve the layout tree dump format somewhat.
2019-06-16 12:28:47 +03:00
tag_name = "#document";
LibWeb: Rename LayoutNode::node() => LayoutNode::dom_node()
2020-11-22 16:46:36 +03:00
else if (is<DOM::Element>(layout_node.dom_node()))
tag_name = downcast<DOM::Element>(*layout_node.dom_node()).local_name();
LibHTML: Give LayoutNodes a rect. Also improve the layout tree dump format somewhat.
2019-06-16 12:28:47 +03:00
else
tag_name = "???";
LibWeb: Colorize tag names in layout tree dumps + show element IDs Showing element IDs in layout tree dumps makes it much easier to compare against the DOM.
2020-05-23 22:05:26 +03:00
String identifier = "";
LibWeb: Rename LayoutNode::node() => LayoutNode::dom_node()
2020-11-22 16:46:36 +03:00
if (layout_node.dom_node() && is<DOM::Element>(*layout_node.dom_node())) {
auto& element = downcast<DOM::Element>(*layout_node.dom_node());
LibWeb: Include class names in layout tree dumps This makes it a lot easier to see which layout node is which DOM node.
2020-06-12 14:23:07 +03:00
StringBuilder builder;
auto id = element.attribute(HTML::AttributeNames::id);
LibWeb: Colorize tag names in layout tree dumps + show element IDs Showing element IDs in layout tree dumps makes it much easier to compare against the DOM.
2020-05-23 22:05:26 +03:00
if (!id.is_empty()) {
builder.append('#');
builder.append(id);
}
LibWeb: Include class names in layout tree dumps This makes it a lot easier to see which layout node is which DOM node.
2020-06-12 14:23:07 +03:00
for (auto& class_name : element.class_names()) {
builder.append('.');
builder.append(class_name);
}
identifier = builder.to_string();
LibWeb: Colorize tag names in layout tree dumps + show element IDs Showing element IDs in layout tree dumps makes it much easier to compare against the DOM.
2020-05-23 22:05:26 +03:00
}
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
const char* nonbox_color_on = "";
const char* box_color_on = "";
const char* positioned_color_on = "";
const char* floating_color_on = "";
const char* inline_block_color_on = "";
const char* line_box_color_on = "";
const char* fragment_color_on = "";
const char* color_off = "";
if (interactive) {
nonbox_color_on = "\033[33m";
box_color_on = "\033[34m";
positioned_color_on = "\033[31;1m";
floating_color_on = "\033[32;1m";
inline_block_color_on = "\033[36;1m";
line_box_color_on = "\033[34;1m";
fragment_color_on = "\033[35;1m";
color_off = "\033[0m";
}
LibHTML: Introduce LayoutBox and LayoutNodeWithStyleAndBoxModelMetrics To streamline the layout tree and remove irrelevant data from classes that don't need it, this patch adds two new LayoutNode subclasses. LayoutNodeWithStyleAndBoxModelMetrics should be inherited by any layout node that cares about box model metrics (margin, border, and padding.) LayoutBox should be inherited by any layout node that can have a rect. This makes LayoutText significantly smaller (from 140 to 40 bytes) and clarifies a lot of things about the layout tree. I'm also adding next_sibling() and previous_sibling() overloads to LayoutBlock that return a LayoutBlock*. This is okay since blocks only ever have block siblings. Do also note that the semantics of is<T> slightly change in this patch: is<T>(nullptr) now returns true, to facilitate allowing to<T>(nullptr).
2019-10-15 17:48:38 +03:00
if (!layout_node.is_box()) {
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendff("{}{}{} <{}{}{}>",
nonbox_color_on,
layout_node.class_name(),
color_off,
tag_name,
nonbox_color_on,
identifier,
color_off);
if (interactive)
builder.appendff(" @{:p}", &layout_node);
builder.append("\n");
LibHTML: Introduce LayoutBox and LayoutNodeWithStyleAndBoxModelMetrics To streamline the layout tree and remove irrelevant data from classes that don't need it, this patch adds two new LayoutNode subclasses. LayoutNodeWithStyleAndBoxModelMetrics should be inherited by any layout node that cares about box model metrics (margin, border, and padding.) LayoutBox should be inherited by any layout node that can have a rect. This makes LayoutText significantly smaller (from 140 to 40 bytes) and clarifies a lot of things about the layout tree. I'm also adding next_sibling() and previous_sibling() overloads to LayoutBlock that return a LayoutBlock*. This is okay since blocks only ever have block siblings. Do also note that the semantics of is<T> slightly change in this patch: is<T>(nullptr) now returns true, to facilitate allowing to<T>(nullptr).
2019-10-15 17:48:38 +03:00
} else {
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
auto& box = downcast<Layout::Box>(layout_node);
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendff("{}{}{} <{}{}{}{}> ",
box_color_on,
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
box.class_name(),
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
color_off,
box_color_on,
tag_name,
color_off,
identifier.characters());
if (interactive)
builder.appendff("@{:p} ", &layout_node);
builder.appendff("at ({},{}) size {}x{}",
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
(int)box.absolute_x(),
(int)box.absolute_y(),
(int)box.width(),
(int)box.height());
if (box.is_positioned())
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendff(" {}positioned{}", positioned_color_on, color_off);
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
if (box.is_floating())
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendff(" {}floating{}", floating_color_on, color_off);
if (box.is_inline_block())
builder.appendff(" {}inline-block{}", inline_block_color_on, color_off);
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
if (show_box_model) {
// Dump the horizontal box properties
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendf(" [%g+%g+%g %g %g+%g+%g]",
LibWeb: Store layout box model metrics as floats Instead of storing them as CSS::Lengths, we now store the resolved values for margin/padding/border/offset top/right/bottom/left with each Layout::NodeWithStyleAndBoxModelMetrics. This simplifies a lot of code since it's no longer necessary to resolve values before using them.
2020-12-12 23:02:06 +03:00
box.box_model().margin.left,
box.box_model().border.left,
box.box_model().padding.left,
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
box.width(),
LibWeb: Store layout box model metrics as floats Instead of storing them as CSS::Lengths, we now store the resolved values for margin/padding/border/offset top/right/bottom/left with each Layout::NodeWithStyleAndBoxModelMetrics. This simplifies a lot of code since it's no longer necessary to resolve values before using them.
2020-12-12 23:02:06 +03:00
box.box_model().padding.right,
box.box_model().border.right,
box.box_model().margin.right);
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
// And the vertical box properties
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendf(" [%g+%g+%g %g %g+%g+%g]",
LibWeb: Store layout box model metrics as floats Instead of storing them as CSS::Lengths, we now store the resolved values for margin/padding/border/offset top/right/bottom/left with each Layout::NodeWithStyleAndBoxModelMetrics. This simplifies a lot of code since it's no longer necessary to resolve values before using them.
2020-12-12 23:02:06 +03:00
box.box_model().margin.top,
box.box_model().border.top,
box.box_model().padding.top,
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
box.height(),
LibWeb: Store layout box model metrics as floats Instead of storing them as CSS::Lengths, we now store the resolved values for margin/padding/border/offset top/right/bottom/left with each Layout::NodeWithStyleAndBoxModelMetrics. This simplifies a lot of code since it's no longer necessary to resolve values before using them.
2020-12-12 23:02:06 +03:00
box.box_model().padding.bottom,
box.box_model().border.bottom,
box.box_model().margin.bottom);
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
}
LibHTML: Finish the block width calculation Also add horizontal box values to the layout tree dump.
2019-08-18 09:09:56 +03:00
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.append("\n");
LibHTML: Introduce LayoutBox and LayoutNodeWithStyleAndBoxModelMetrics To streamline the layout tree and remove irrelevant data from classes that don't need it, this patch adds two new LayoutNode subclasses. LayoutNodeWithStyleAndBoxModelMetrics should be inherited by any layout node that cares about box model metrics (margin, border, and padding.) LayoutBox should be inherited by any layout node that can have a rect. This makes LayoutText significantly smaller (from 140 to 40 bytes) and clarifies a lot of things about the layout tree. I'm also adding next_sibling() and previous_sibling() overloads to LayoutBlock that return a LayoutBlock*. This is okay since blocks only ever have block siblings. Do also note that the semantics of is<T> slightly change in this patch: is<T>(nullptr) now returns true, to facilitate allowing to<T>(nullptr).
2019-10-15 17:48:38 +03:00
}
LibHTML: Add an empty CSS parser.
2019-06-21 21:54:13 +03: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!)
2020-11-22 17:53:01 +03:00
if (layout_node.is_block() && static_cast<const Layout::BlockBox&>(layout_node).children_are_inline()) {
auto& block = static_cast<const Layout::BlockBox&>(layout_node);
AK: Make Vector use size_t for its size and capacity
2020-02-25 16:49:47 +03:00
for (size_t line_box_index = 0; line_box_index < block.line_boxes().size(); ++line_box_index) {
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
auto& line_box = block.line_boxes()[line_box_index];
AK: Make Vector use size_t for its size and capacity
2020-02-25 16:49:47 +03:00
for (size_t i = 0; i < indent; ++i)
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.append(" ");
builder.appendff(" {}line {}{} width: {}\n",
line_box_color_on,
line_box_index,
color_off,
(int)line_box.width());
AK: Make Vector use size_t for its size and capacity
2020-02-25 16:49:47 +03:00
for (size_t fragment_index = 0; fragment_index < line_box.fragments().size(); ++fragment_index) {
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
auto& fragment = line_box.fragments()[fragment_index];
AK: Make Vector use size_t for its size and capacity
2020-02-25 16:49:47 +03:00
for (size_t i = 0; i < indent; ++i)
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.append(" ");
builder.appendff(" {}frag {}{} from {} ",
fragment_color_on,
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
fragment_index,
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
color_off,
fragment.layout_node().class_name());
if (interactive)
builder.appendff("@{:p}, ", &fragment.layout_node());
builder.appendff("start: {}, length: {}, rect: {}\n",
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
fragment.start(),
fragment.length(),
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
enclosing_int_rect(fragment.absolute_rect()).to_string());
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
if (fragment.layout_node().is_text()) {
AK: Make Vector use size_t for its size and capacity
2020-02-25 16:49:47 +03:00
for (size_t i = 0; i < indent; ++i)
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.append(" ");
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!)
2020-11-22 17:53:01 +03:00
auto& layout_text = static_cast<const Layout::TextNode&>(fragment.layout_node());
LibHTML: Use LayoutText::text_for_rendering() in layout tree dumps This way the fragment offsets make a lot more sense, since they assume whitespace has already been collapsed.
2019-11-19 20:36:33 +03:00
auto fragment_text = layout_text.text_for_rendering().substring(fragment.start(), fragment.length());
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.appendff(" \"{}\"\n", fragment_text);
LibHTML: Rewrite inline and text layout Inline layout is now done by LayoutBlock. Blocks with inline children will split them into line boxes during layout. A LayoutBlock can have zero or more LineBox objects. Each LineBox represents one visual line. A LineBox can have any number of LineBoxFragment children. A fragment is an offset+length into a specific LayoutNode. To paint a LayoutBlock with inline children, we walk its line boxes, and walk their fragments, painting each fragment at a time by calling LineBoxFragment::render(), which in turn calls the LayoutNode via LayoutText::render_fragment(). Hit testing works similarly. This is very incomplete and has many bugs, but should make it easier for us to move forward with this code.
2019-10-03 16:20:13 +03:00
}
}
}
}
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
if (show_specified_style) {
struct NameAndValue {
String name;
String value;
};
Vector<NameAndValue> properties;
layout_node.specified_style().for_each_property([&](auto property_id, auto& value) {
properties.append({ CSS::string_from_property_id(property_id), value.to_string() });
});
quick_sort(properties, [](auto& a, auto& b) { return a.name < b.name; });
LibWeb: Dump layout node style properties in alphabetical order
2020-06-14 19:47:21 +03:00
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
for (auto& property : properties) {
for (size_t i = 0; i < indent; ++i)
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
builder.append(" ");
builder.appendf(" (%s: %s)\n", property.name.characters(), property.value.characters());
LibWeb: Make layout tree dumps nicer This patch removes a bunch of the less generally useful information from layout tree dumps and puts it behind some optional bool params. We also show layout units as integers instead of floats for now, since fractional layout almost never happen anyway (yet) and this makes it much easier to read.
2020-12-07 21:36:13 +03:00
}
LibWeb: Dump layout node style properties in alphabetical order
2020-06-14 19:47:21 +03:00
}
LibHTML: Get rid of the style tree We now create a layout tree directly from the DOM tree. This way we don't actually lose text nodes ^)
2019-09-21 15:32:17 +03:00
LibHTML: Start building the style tree. Walk the DOM and construct a parallel style tree that points back to the DOM and has the relevant CSS property values hanging off of them. The values are picked based on naive selector matching. There's no cascade or specificity taken into account yet.
2019-06-28 22:17:34 +03:00
++indent;
LibWeb: Allow dumping layout tree into a StringBuilder
2020-12-09 00:11:02 +03:00
layout_node.for_each_child([&](auto& child) {
dump_tree(builder, child, show_box_model, show_specified_style, interactive);
LibHTML: Start building the style tree. Walk the DOM and construct a parallel style tree that points back to the DOM and has the relevant CSS property values hanging off of them. The values are picked based on naive selector matching. There's no cascade or specificity taken into account yet.
2019-06-28 22:17:34 +03:00
});
--indent;
}
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
void dump_selector(const CSS::Selector& selector)
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 21:40:21 +03:00
{
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
dbgprintf(" CSS::Selector:\n");
LibHTML: Implement compound selectors This patch moves the Selector object model closer to the specification objects in Selectors Level 4. A "Selector" in LibHTML is now a { Vector<ComplexSelector> }, which is a { Relation, CompoundSelector }. A CompoundSelector is really just a Vector<SimpleSelector>, and SimpleSelector is "Component" renamed. This makes a lot more selectors actually match on the Ubuntu Apache2 default homepage. :^)
2019-11-27 22:37:36 +03:00
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
for (auto& complex_selector : selector.complex_selectors()) {
dbgprintf(" ");
const char* relation_description = "";
switch (complex_selector.relation) {
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::ComplexSelector::Relation::None:
LibWeb: Support more advanced selectors in document.querySelectorAll() I made some mistakes in the selector parsing code. It's now able to parse selectors composed of multiple complex selectors, instead of just one complex selector.
2020-03-29 23:45:38 +03:00
relation_description = "None";
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::ComplexSelector::Relation::ImmediateChild:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
relation_description = "ImmediateChild";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::ComplexSelector::Relation::Descendant:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
relation_description = "Descendant";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::ComplexSelector::Relation::AdjacentSibling:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
relation_description = "AdjacentSibling";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::ComplexSelector::Relation::GeneralSibling:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
relation_description = "GeneralSibling";
break;
}
LibHTML: Implement compound selectors This patch moves the Selector object model closer to the specification objects in Selectors Level 4. A "Selector" in LibHTML is now a { Vector<ComplexSelector> }, which is a { Relation, CompoundSelector }. A CompoundSelector is really just a Vector<SimpleSelector>, and SimpleSelector is "Component" renamed. This makes a lot more selectors actually match on the Ubuntu Apache2 default homepage. :^)
2019-11-27 22:37:36 +03:00
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
if (*relation_description)
dbgprintf("{%s} ", relation_description);
for (size_t i = 0; i < complex_selector.compound_selector.size(); ++i) {
auto& simple_selector = complex_selector.compound_selector[i];
const char* type_description = "Unknown";
switch (simple_selector.type) {
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::Type::Invalid:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
type_description = "Invalid";
LibHTML: Various little improvements to the CSS parser The parser now kinda recognizes immediate child selectors, !important, and various other little things. It's still extremely far from robust and/or correct. :^)
2019-10-06 10:28:10 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::Type::Universal:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
type_description = "Universal";
LibHTML: Various little improvements to the CSS parser The parser now kinda recognizes immediate child selectors, !important, and various other little things. It's still extremely far from robust and/or correct. :^)
2019-10-06 10:28:10 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::Type::Id:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
type_description = "Id";
LibHTML: Parse descendant relations in CSS selectors "div p" now generates a Selector with two components where the second component is a type=TagName, value="p", relation=Descendant. We still don't handle matching of these, but at least we parse them.
2019-10-06 12:05:57 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::Type::Class:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
type_description = "Class";
LibHTML: Add adjacent (+) and general (~) sibling combinators This patch implements two more selector features: - "div + p" matches the <p> sibling immediately after a <div>. - "div ~ p" matches all <p> siblings after a <div>.
2019-10-06 20:59:07 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::Type::TagName:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
type_description = "TagName";
break;
}
const char* attribute_match_type_description = "";
switch (simple_selector.attribute_match_type) {
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::AttributeMatchType::None:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::AttributeMatchType::HasAttribute:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
attribute_match_type_description = "HasAttribute";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::AttributeMatchType::ExactValueMatch:
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
attribute_match_type_description = "ExactValueMatch";
LibHTML: Implement some attribute selector support This patch adds a[foo] and a[foo=bar] attribute selectors. Note that an attribute selector is an optional part of a selector component, and not a component on its own.
2019-11-21 22:07:43 +03:00
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::AttributeMatchType::Contains:
LibWeb: Parse and match basic "contains" attribute selectors (~=)
2020-06-10 16:43:41 +03:00
attribute_match_type_description = "Contains";
break;
LibHTML: Implement some attribute selector support This patch adds a[foo] and a[foo=bar] attribute selectors. Note that an attribute selector is an optional part of a selector component, and not a component on its own.
2019-11-21 22:07:43 +03:00
}
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
const char* pseudo_class_description = "";
switch (simple_selector.pseudo_class) {
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::Link:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "Link";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::Visited:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "Visited";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::None:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "None";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::Root:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "Root";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::Focus:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "Focus";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::Empty:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "Empty";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::Hover:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "Hover";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::LastChild:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "LastChild";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::FirstChild:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "FirstChild";
break;
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
case CSS::Selector::SimpleSelector::PseudoClass::OnlyChild:
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
pseudo_class_description = "OnlyChild";
break;
}
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
dbgprintf("%s:%s", type_description, simple_selector.value.characters());
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
if (simple_selector.pseudo_class != CSS::Selector::SimpleSelector::PseudoClass::None)
LibWeb: Include selector pseudo-class in style sheet dumps
2020-06-13 01:43:06 +03:00
dbgprintf(" pseudo_class=%s", pseudo_class_description);
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
if (simple_selector.attribute_match_type != CSS::Selector::SimpleSelector::AttributeMatchType::None) {
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
dbgprintf(" [%s, name='%s', value='%s']", attribute_match_type_description, simple_selector.attribute_name.characters(), simple_selector.attribute_value.characters());
LibHTML: Implement some attribute selector support This patch adds a[foo] and a[foo=bar] attribute selectors. Note that an attribute selector is an optional part of a selector component, and not a component on its own.
2019-11-21 22:07:43 +03:00
}
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
if (i != complex_selector.compound_selector.size() - 1)
dbgprintf(", ");
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 21:40:21 +03:00
}
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
dbgprintf("\n");
}
}
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
void dump_rule(const CSS::StyleRule& rule)
LibWeb: Add naive support for document.querySelectorAll() This currently returns a JS::Array of elements matching a selector. The more correct behavior would be to return a static NodeList, but as we don't have NodeLists right now, that'll be a task for the future.
2020-03-29 23:24:23 +03:00
{
dbgprintf("Rule:\n");
for (auto& selector : rule.selectors()) {
dump_selector(selector);
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 21:40:21 +03:00
}
LibHTML: Let's put debug output on the debugger stream
2019-10-03 11:25:00 +03:00
dbgprintf(" Declarations:\n");
LibHTML: Fix incorrect CSS object model A StyleRule has a StyleDeclaration which has many StyleProperty. :^)
2019-09-30 21:06:17 +03:00
for (auto& property : rule.declaration().properties()) {
LibHTML: Implement some attribute selector support This patch adds a[foo] and a[foo=bar] attribute selectors. Note that an attribute selector is an optional part of a selector component, and not a component on its own.
2019-11-21 22:07:43 +03:00
dbgprintf(" %s: '%s'\n", CSS::string_from_property_id(property.property_id), property.value->to_string().characters());
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 21:40:21 +03:00
}
}
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 21:01:35 +03:00
void dump_sheet(const CSS::StyleSheet& sheet)
LibHTML: Add an empty CSS parser.
2019-06-21 21:54:13 +03:00
{
LibC: Fix some incorrect printf usages
2020-12-25 07:15:12 +03:00
dbgprintf("StyleSheet{%p}: %zu rule(s)\n", &sheet, sheet.rules().size());
LibHTML: Flesh out the code to dump a StyleSheet object graph.
2019-06-25 07:31:47 +03:00
for (auto& rule : sheet.rules()) {
LibHTML: Implement some very simple selector matching. We walk the entire DOM and check all selectors against all elements. Only id, class and tag name are checked right now. There's no ancestor stack or compound selectors. All in good time :^)
2019-06-27 21:40:21 +03:00
dump_rule(rule);
LibHTML: Flesh out the code to dump a StyleSheet object graph.
2019-06-25 07:31:47 +03:00
}
LibHTML: Add an empty CSS parser.
2019-06-21 21:54:13 +03:00
}
LibWeb: Move everything into the Web namespace
2020-03-07 12:27:02 +03:00
}
Reference in New Issue Copy Permalink