LadybirdBrowser/ladybird
1
1
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-01-08 04:15:23 +03:00
Code Issues Packages Projects Releases Wiki Activity
7fcf61be35
ladybird/Libraries/LibWeb/Layout/LayoutBox.cpp

276 lines
11 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.
*/
LibGUI: Remove leading G from filenames
2020-02-06 22:33:02 +03:00
#include <LibGUI/Painter.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/Document.h>
#include <LibWeb/DOM/HTMLBodyElement.h>
#include <LibWeb/Frame.h>
#include <LibWeb/Layout/LayoutBlock.h>
#include <LibWeb/Layout/LayoutBox.h>
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
//#define DRAW_BOXES_AROUND_LAYOUT_NODES
//#define DRAW_BOXES_AROUND_HOVERED_NODES
LibWeb: Move everything into the Web namespace
2020-03-07 12:27:02 +03:00
namespace Web {
LibGfx: Unpublish FloatRect from the global namespace
2020-02-06 16:33:05 +03:00
void LayoutBox::paint_border(RenderingContext& context, Edge edge, const Gfx::FloatRect& rect, CSS::PropertyID style_property_id, CSS::PropertyID color_property_id, CSS::PropertyID width_property_id)
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
{
auto border_width = style().property(width_property_id);
if (!border_width.has_value())
return;
auto border_style = style().property(style_property_id);
float width = border_width.value()->to_length().to_px();
LibWeb: Don't paint borders with width <= 0px Previously we would only check if the border width property is empty and skip drawing in that case, and enforcing a minimum width of 1px otherwise - but "border: 0;" should not paint a border :^)
2020-05-11 02:03:18 +03:00
if (width <= 0)
return;
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
int int_width = max((int)width, 1);
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
Color color;
auto border_color = style().property(color_property_id);
if (border_color.has_value()) {
color = border_color.value()->to_color(document());
} else {
// FIXME: This is basically CSS "currentColor" which should be handled elsewhere
// in a much more reusable way.
auto current_color = style().property(CSS::PropertyID::Color);
if (current_color.has_value())
color = current_color.value()->to_color(document());
else
color = Color::Black;
}
LibGfx: Unpublish FloatRect from the global namespace
2020-02-06 16:33:05 +03:00
auto first_point_for_edge = [](Edge edge, const Gfx::FloatRect& rect) {
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
switch (edge) {
case Edge::Top:
return rect.top_left();
case Edge::Right:
return rect.top_right();
case Edge::Bottom:
return rect.bottom_left();
case Edge::Left:
default:
return rect.top_left();
}
};
LibGfx: Unpublish FloatRect from the global namespace
2020-02-06 16:33:05 +03:00
auto second_point_for_edge = [](Edge edge, const Gfx::FloatRect& rect) {
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
switch (edge) {
case Edge::Top:
return rect.top_right();
case Edge::Right:
return rect.bottom_right();
case Edge::Bottom:
return rect.bottom_right();
case Edge::Left:
default:
return rect.bottom_left();
}
};
auto p1 = first_point_for_edge(edge, rect);
auto p2 = second_point_for_edge(edge, rect);
if (border_style.has_value() && border_style.value()->to_string() == "inset") {
auto top_left_color = Color::from_rgb(0x5a5a5a);
auto bottom_right_color = Color::from_rgb(0x888888);
color = (edge == Edge::Left || edge == Edge::Top) ? top_left_color : bottom_right_color;
} else if (border_style.has_value() && border_style.value()->to_string() == "outset") {
auto top_left_color = Color::from_rgb(0x888888);
auto bottom_right_color = Color::from_rgb(0x5a5a5a);
color = (edge == Edge::Left || edge == Edge::Top) ? top_left_color : bottom_right_color;
}
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
LibGfx: Replace 'bool dotted' with a LineStyle::{Solid,Dotted} enum Just a bool is insufficient as we'll have to support dashed lines as well.
2020-05-10 13:58:33 +03:00
auto line_style = Gfx::Painter::LineStyle::Solid;
if (border_style.has_value()) {
if (border_style.value()->to_string() == "dotted")
line_style = Gfx::Painter::LineStyle::Dotted;
LibWeb: Add basic support for "border-style: {dotted,dashed}"
2020-05-10 20:08:02 +03:00
if (border_style.value()->to_string() == "dashed")
line_style = Gfx::Painter::LineStyle::Dashed;
}
if (line_style != Gfx::Painter::LineStyle::Solid) {
switch (edge) {
case Edge::Top:
p1.move_by(int_width / 2, int_width / 2);
p2.move_by(-int_width / 2, int_width / 2);
break;
case Edge::Right:
p1.move_by(-int_width / 2, int_width / 2);
p2.move_by(-int_width / 2, -int_width / 2);
break;
case Edge::Bottom:
p1.move_by(int_width / 2, -int_width / 2);
p2.move_by(-int_width / 2, -int_width / 2);
break;
case Edge::Left:
p1.move_by(int_width / 2, int_width / 2);
p2.move_by(int_width / 2, -int_width / 2);
break;
}
context.painter().draw_line({ (int)p1.x(), (int)p1.y() }, { (int)p2.x(), (int)p2.y() }, color, int_width, line_style);
return;
LibGfx: Replace 'bool dotted' with a LineStyle::{Solid,Dotted} enum Just a bool is insufficient as we'll have to support dashed lines as well.
2020-05-10 13:58:33 +03:00
}
LibHTML: Respect "border-style: dotted" Dotted borders are now painted correctly (as long as they are 1px wide) which is yet another little improvement to my Apache2 default page :^)
2019-11-27 22:53:28 +03:00
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
auto draw_line = [&](auto& p1, auto& p2) {
LibGfx: Replace 'bool dotted' with a LineStyle::{Solid,Dotted} enum Just a bool is insufficient as we'll have to support dashed lines as well.
2020-05-10 13:58:33 +03:00
context.painter().draw_line({ (int)p1.x(), (int)p1.y() }, { (int)p2.x(), (int)p2.y() }, color, 1, line_style);
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
};
auto width_for = [&](CSS::PropertyID property_id) -> float {
auto width = style().property(property_id);
if (!width.has_value())
return 0;
return width.value()->to_length().to_px();
};
float p1_step = 0;
float p2_step = 0;
switch (edge) {
case Edge::Top:
p1_step = width_for(CSS::PropertyID::BorderLeftWidth) / (float)int_width;
p2_step = width_for(CSS::PropertyID::BorderRightWidth) / (float)int_width;
for (int i = 0; i < int_width; ++i) {
draw_line(p1, p2);
p1.move_by(p1_step, 1);
p2.move_by(-p2_step, 1);
}
break;
case Edge::Right:
p1_step = width_for(CSS::PropertyID::BorderTopWidth) / (float)int_width;
p2_step = width_for(CSS::PropertyID::BorderBottomWidth) / (float)int_width;
for (int i = int_width - 1; i >= 0; --i) {
draw_line(p1, p2);
p1.move_by(-1, p1_step);
p2.move_by(-1, -p2_step);
}
break;
case Edge::Bottom:
p1_step = width_for(CSS::PropertyID::BorderLeftWidth) / (float)int_width;
p2_step = width_for(CSS::PropertyID::BorderRightWidth) / (float)int_width;
for (int i = int_width - 1; i >= 0; --i) {
draw_line(p1, p2);
p1.move_by(p1_step, -1);
p2.move_by(-p2_step, -1);
}
break;
case Edge::Left:
p1_step = width_for(CSS::PropertyID::BorderTopWidth) / (float)int_width;
p2_step = width_for(CSS::PropertyID::BorderBottomWidth) / (float)int_width;
for (int i = 0; i < int_width; ++i) {
draw_line(p1, p2);
p1.move_by(1, p1_step);
p2.move_by(1, -p2_step);
}
break;
}
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
}
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
void LayoutBox::render(RenderingContext& context)
{
LibHTML: Fix missing backgrounds an borders after LayoutBox refactoring The render() implementation in both LayoutBlock and LayoutBox need to be calling the immediate parent class. :^)
2019-10-15 20:12:12 +03:00
if (!is_visible())
return;
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
#ifdef DRAW_BOXES_AROUND_LAYOUT_NODES
context.painter().draw_rect(m_rect, Color::Blue);
#endif
#ifdef DRAW_BOXES_AROUND_HOVERED_NODES
if (!is_anonymous() && node() == document().hovered_node())
context.painter().draw_rect(m_rect, Color::Red);
#endif
LibGfx: Unpublish FloatRect from the global namespace
2020-02-06 16:33:05 +03:00
Gfx::FloatRect padded_rect;
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
padded_rect.set_x(x() - box_model().padding().left.to_px());
padded_rect.set_width(width() + box_model().padding().left.to_px() + box_model().padding().right.to_px());
padded_rect.set_y(y() - box_model().padding().top.to_px());
padded_rect.set_height(height() + box_model().padding().top.to_px() + box_model().padding().bottom.to_px());
LibHTML: Implement basic tiled background image support It's now possible to set a page background image via <body background>. Also, HtmlView now officially handles rendering the body element's background (color, image or both.) LayoutBox is responsible for all other background rendering. Note that it's not yet possible to use CSS background-image properties directly, since we can't parse them yet. :^)
2019-10-19 12:49:46 +03:00
if (!is_body()) {
auto bgcolor = style().property(CSS::PropertyID::BackgroundColor);
if (bgcolor.has_value() && bgcolor.value()->is_color()) {
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
context.painter().fill_rect(enclosing_int_rect(padded_rect), bgcolor.value()->to_color(document()));
LibHTML: Implement basic tiled background image support It's now possible to set a page background image via <body background>. Also, HtmlView now officially handles rendering the body element's background (color, image or both.) LayoutBox is responsible for all other background rendering. Note that it's not yet possible to use CSS background-image properties directly, since we can't parse them yet. :^)
2019-10-19 12:49:46 +03:00
}
auto bgimage = style().property(CSS::PropertyID::BackgroundImage);
if (bgimage.has_value() && bgimage.value()->is_image()) {
auto& image_value = static_cast<const ImageStyleValue&>(*bgimage.value());
if (image_value.bitmap()) {
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
context.painter().draw_tiled_bitmap(enclosing_int_rect(padded_rect), *image_value.bitmap());
LibHTML: Implement basic tiled background image support It's now possible to set a page background image via <body background>. Also, HtmlView now officially handles rendering the body element's background (color, image or both.) LayoutBox is responsible for all other background rendering. Note that it's not yet possible to use CSS background-image properties directly, since we can't parse them yet. :^)
2019-10-19 12:49:46 +03:00
}
}
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
}
LibGfx: Unpublish FloatRect from the global namespace
2020-02-06 16:33:05 +03:00
Gfx::FloatRect bordered_rect;
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
bordered_rect.set_x(padded_rect.x() - box_model().border().left.to_px());
bordered_rect.set_width(padded_rect.width() + box_model().border().left.to_px() + box_model().border().right.to_px());
bordered_rect.set_y(padded_rect.y() - box_model().border().top.to_px());
bordered_rect.set_height(padded_rect.height() + box_model().border().top.to_px() + box_model().border().bottom.to_px());
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: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
paint_border(context, Edge::Left, bordered_rect, CSS::PropertyID::BorderLeftStyle, CSS::PropertyID::BorderLeftColor, CSS::PropertyID::BorderLeftWidth);
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
paint_border(context, Edge::Right, bordered_rect, CSS::PropertyID::BorderRightStyle, CSS::PropertyID::BorderRightColor, CSS::PropertyID::BorderRightWidth);
LibHTML: Join border edges nicely when painting boxes Always paint border edges so they join nicely with their buddy edges. This makes borders look nice even if all sides have different widths. Also switch the border code to using floating point numbers since otherwise things get very ugly very fast.
2019-11-25 16:12:04 +03:00
paint_border(context, Edge::Top, bordered_rect, CSS::PropertyID::BorderTopStyle, CSS::PropertyID::BorderTopColor, CSS::PropertyID::BorderTopWidth);
LibHTML: Draw each CSS border edge separately with their own style The borders still look very wrong with any border-width other than 1, but at least we can see that they have the right color, and end up in mostly the right place :^)
2019-11-25 15:17:14 +03:00
paint_border(context, Edge::Bottom, bordered_rect, CSS::PropertyID::BorderBottomStyle, CSS::PropertyID::BorderBottomColor, CSS::PropertyID::BorderBottomWidth);
LibHTML: Fix missing backgrounds an borders after LayoutBox refactoring The render() implementation in both LayoutBlock and LayoutBox need to be calling the immediate parent class. :^)
2019-10-15 20:12:12 +03:00
LayoutNodeWithStyleAndBoxModelMetrics::render(context);
LibWeb: Draw the inspected node rect last in LayoutBox::render()
2020-05-11 01:04:26 +03:00
if (node() && document().inspected_node() == node())
context.painter().draw_rect(enclosing_int_rect(m_rect), Color::Magenta);
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
}
LibDraw: Put all classes in the Gfx namespace I started adding things to a Draw namespace, but it somehow felt really wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename the library to LibGfx. :^)
2020-02-06 13:56:38 +03:00
HitTestResult LayoutBox::hit_test(const Gfx::Point& position) const
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
{
// 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
// m_rect.contains() since inline text rects can't be trusted..
LibGfx: Unpublish FloatPoint from the global namespace
2020-02-06 16:35:54 +03:00
HitTestResult result { m_rect.contains(position.x(), position.y()) ? this : nullptr };
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
for_each_child([&](auto& child) {
auto child_result = child.hit_test(position);
if (child_result.layout_node)
result = child_result;
});
return result;
}
void LayoutBox::set_needs_display()
{
auto* frame = document().frame();
ASSERT(frame);
if (!is_inline()) {
LibHTML: Use floating point numbers throughout the layout tree
2019-11-18 18:25:38 +03:00
const_cast<Frame*>(frame)->set_needs_display(enclosing_int_rect(rect()));
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
return;
}
LibHTML: LayoutNode::set_needs_display() needs to invalidate fragments If a LayoutNode is split into line box fragments, we need to walk our fragments and invalidate them. It was not enough to do this only for LayoutBox nodes.
2019-10-15 21:45:52 +03:00
LayoutNode::set_needs_display();
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: Implement basic tiled background image support It's now possible to set a page background image via <body background>. Also, HtmlView now officially handles rendering the body element's background (color, image or both.) LayoutBox is responsible for all other background rendering. Note that it's not yet possible to use CSS background-image properties directly, since we can't parse them yet. :^)
2019-10-19 12:49:46 +03:00
bool LayoutBox::is_body() const
{
return node() && node() == document().body();
}
LibWeb: Move everything into the Web namespace
2020-03-07 12:27:02 +03:00
}
Reference in New Issue Copy Permalink