Stowage/ladybird
2
0
Fork 0
mirror of https://github.com/LadybirdBrowser/ladybird.git synced 2025-10-31 21:30:58 +00:00
Code Issues Projects Releases Packages Wiki Activity
ladybird/Userland/Libraries/LibWeb/CSS/StyleProperties.h

104 lines
3.6 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 09:38:21 +01:00
/*
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
*
Everything: Move to SPDX license identifiers in all files. SPDX License Identifiers are a more compact / standardized way of representing file license information. See: https://spdx.dev/resources/use/#identifiers This was done with the `ambr` search and replace tool. ambr --no-parent-ignore --key-from-file --rep-from-file key.txt rep.txt *
2021-04-22 01:24:48 -07:00
* SPDX-License-Identifier: BSD-2-Clause
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 09:38:21 +01: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
#pragma once
#include <AK/HashMap.h>
#include <AK/NonnullRefPtr.h>
LibGfx: Rename from LibDraw :^)
2020-02-06 12:04:00 +01:00
#include <LibGfx/Font.h>
LibGfx: Replace manual forward declarations with <LibGfx/Forward.h>
2020-02-15 00:10:34 +01:00
#include <LibGfx/Forward.h>
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
#include <LibWeb/CSS/ComputedValues.h>
LibWeb: Move the offset, margin and padding boxes into LayoutStyle
2020-06-24 17:45:42 +02:00
#include <LibWeb/CSS/LengthBox.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 10:32:51 +01:00
#include <LibWeb/CSS/StyleValue.h>
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
LibWeb: Move CSS classes into the Web::CSS namespace
2020-07-26 20:01:35 +02:00
namespace Web::CSS {
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
LibHTML: LayoutText should always use parent's style properties This patch makes StyleProperties heap-allocated and ref-counted so that a LayoutNode can be without one. The ref-counting also allows anonymous blocks to share style with their parent block. LayoutText never needs a StyleProperties, since text always inherits style from its parent element. This is handled by style_properties().
2019-10-04 12:12:39 +02:00
class StyleProperties : public RefCounted<StyleProperties> {
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
public:
LibHTML: Replace StyleProperties::create(StyleProperties) with clone()
2020-01-05 16:54:38 +01:00
StyleProperties();
explicit StyleProperties(const StyleProperties&);
AK: Rename adopt() to adopt_ref() This makes it more symmetrical with adopt_own() (which is used to create a NonnullOwnPtr from the result of a naked new.)
2021-04-23 16:46:57 +02:00
static NonnullRefPtr<StyleProperties> create() { return adopt_ref(*new StyleProperties); }
LibHTML: Replace StyleProperties::create(StyleProperties) with clone()
2020-01-05 16:54:38 +01:00
NonnullRefPtr<StyleProperties> clone() const;
LibHTML: LayoutText should always use parent's style properties This patch makes StyleProperties heap-allocated and ref-counted so that a LayoutNode can be without one. The ref-counting also allows anonymous blocks to share style with their parent block. LayoutText never needs a StyleProperties, since text always inherits style from its parent element. This is handled by style_properties().
2019-10-04 12:12:39 +02:00
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
template<typename Callback>
inline void for_each_property(Callback callback) const
{
for (auto& it : m_property_values)
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
callback((CSS::PropertyID)it.key, *it.value);
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
}
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
HashMap<CSS::PropertyID, NonnullRefPtr<StyleValue>>& properties() { return m_property_values; }
HashMap<CSS::PropertyID, NonnullRefPtr<StyleValue>> const& properties() const { return m_property_values; }
LibHTML: Use an enum for CSS property ID's Instead of using string everywhere, have the CSS parser produce enum values, since they are a lot nicer to work with. In the future we should generate most of this code based on a list of supported CSS properties.
2019-10-08 15:34:19 +02:00
void set_property(CSS::PropertyID, NonnullRefPtr<StyleValue> value);
Optional<NonnullRefPtr<StyleValue>> property(CSS::PropertyID) const;
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
LibWeb: Convert width/height and min-/max- versions to LengthPercentage A lot of this is quite ugly, but it should only be so until I remove Length::Type::Percentage entirely. (Which should happen later in this PR, otherwise, yell at me!) For now, a lot of things have to be resolved twice, first from a LengthPercentage to a Length, and then from a Length to a pixel one.
2022-01-19 16:19:43 +00:00
Length length_or_fallback(CSS::PropertyID, Length const& fallback) const;
LengthPercentage length_percentage_or_fallback(CSS::PropertyID, LengthPercentage const& fallback) const;
LibWeb: Oops, not all length boxes should default to 'auto' values Only the offset box (left/top/right/bottom) box defaults to 'auto'. Both the padding and margin boxes default to '0' for all values.
2020-12-15 20:01:00 +01:00
LengthBox length_box(CSS::PropertyID left_id, CSS::PropertyID top_id, CSS::PropertyID right_id, CSS::PropertyID bottom_id, const CSS::Length& default_value) const;
LibWeb: Make StyleValue::to_color() take a Node instead of the Document This is in preparation for the `currentcolor` value, which needs to know what Node it's on so it can check the `color`.
2021-09-16 19:20:20 +01:00
Color color_or_fallback(CSS::PropertyID, Layout::NodeWithStyle const&, Color fallback) const;
LibWeb: Use CSS::ValueID for 'text-align' values Let's start moving away from using raw strings for CSS identifiers. The idea here is to use IdentifierStyleValue with a CSS::ValueID inside for all CSS identifier values.
2020-12-14 18:38:02 +01:00
Optional<CSS::TextAlign> text_align() const;
LibWeb: Add CSS::Display enum and StyleProperties::display() The display property is not interesting after we've built the layout tree, so we don't have to move it into LayoutStyle.
2020-06-24 16:22:16 +02:00
CSS::Display display() const;
LibWeb: Add the 'float' CSS property to LayoutStyle Note that we don't use the property for anything yet, as I'm still wrapping my head around how to implement floats.
2020-06-26 15:08:42 +02:00
Optional<CSS::Float> float_() const;
LibWeb: Naively implement the CSS clear property This is definitely not fully-featured, but basically we now handle the clear property by forcing the cleared box below the bottom-most floated box on the relevant side.
2020-12-06 01:45:51 +01:00
Optional<CSS::Clear> clear() const;
LibWeb: Parese the CSS "cursor" property
2021-02-21 17:41:00 +00:00
Optional<CSS::Cursor> cursor() const;
LibWeb: Move white-space into LayoutStyle
2020-06-24 16:37:44 +02:00
Optional<CSS::WhiteSpace> white_space() const;
LibWeb: Compute the final border-style property before painting Instead of doing a CSS property lookup for the line style of each border edge during paint, we now cache the final CSS::LineStyle to use in the Layout::BorderData.
2020-12-04 16:11:55 +01:00
Optional<CSS::LineStyle> line_style(CSS::PropertyID) const;
LibWeb: Use IdentifierStyleValue for CSS 'text-decoration-line' Also 'text-decoration' is actually a shorthand, so treat it that way.
2020-12-15 13:36:27 +01:00
Optional<CSS::TextDecorationLine> text_decoration_line() const;
LibWeb: Add new property 'text-decoration-style' This patch makes the property 'text-decoration-style' known throughout all the places in LibWeb that care.
2022-01-20 20:27:55 +01:00
Optional<CSS::TextDecorationStyle> text_decoration_style() const;
LibWeb: Use IdentifierStyleValue for CSS 'text-transform'
2020-12-15 14:15:49 +01:00
Optional<CSS::TextTransform> text_transform() const;
LibWeb: Use IdentifierStyleValue for CSS 'list-style-type'
2020-12-15 16:50:39 +01:00
Optional<CSS::ListStyleType> list_style_type() const;
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
Optional<CSS::FlexDirection> flex_direction() const;
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
Optional<CSS::FlexWrap> flex_wrap() const;
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
Optional<CSS::FlexBasisData> flex_basis() const;
LibWeb: Make computed flex-grow and flex-shrink always available These values are not allowed to be absent (auto/none/etc) so we don't need to use Optional<float> for them. This simplifies some things.
2021-10-19 15:22:08 +02:00
float flex_grow() const;
float flex_shrink() const;
LibWeb: Add proper parsing of the AlignItems property This teaches all the relevant places about 'align-items'.
2021-09-15 18:27:20 +02:00
Optional<CSS::AlignItems> align_items() const;
LibWeb: Make computed opacity always available No need to store opacity as Optional<float> as there's always a value (and the default initial value is 1.)
2021-10-19 15:27:40 +02:00
float opacity() const;
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
Optional<CSS::JustifyContent> justify_content() const;
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
Optional<CSS::Overflow> overflow_x() const;
Optional<CSS::Overflow> overflow_y() const;
LibWeb: Render multiple box-shadows Because why not? :^)
2022-02-08 14:48:37 +00:00
Vector<CSS::BoxShadowData> box_shadow() const;
LibWeb: Make things aware of box-sizing Of course, we don't actually *use* the box-sizing property yet, but the value is applied and shows up in the computed style.
2021-10-05 16:55:02 +01:00
CSS::BoxSizing box_sizing() const;
LibWeb: Add initial version of pointer-events CSS property
2021-10-05 19:47:13 +01:00
Optional<CSS::PointerEvents> pointer_events() const;
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
LibWeb: Add transform property to the system This patch adds parsing support as well as all the needed stuctures all over LibWeb to pass Transformations around.
2021-09-18 17:20:00 +02:00
Vector<CSS::Transformation> transformations() const;
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
Gfx::Font const& computed_font() const
{
VERIFY(m_font);
return *m_font;
}
void set_computed_font(NonnullRefPtr<Gfx::Font> font)
{
m_font = move(font);
}
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 15:53:01 +01:00
float line_height(const Layout::Node&) const;
LibHTML: Add StyleProperties::line_height() We currently hard-code the line height to 140% of the font glyph height and this patch doesn't fix the hard-coding, but at least moves it out of LayoutText and into StyleProperties where it can be re-used until the day we go and do a proper implementation of CSS line-height. :^)
2019-10-12 13:42:58 +02:00
LibHTML: Implement basic partial style invalidation This patch makes it possible to call Node::invalidate_style() and have that node and all of its ancestors recompute their style. We then figure out if the new style is visually different from the old style, and if so do a paint invalidation with set_needs_display(). Note that the "are they visually different" code is very incomplete! Use this to make hover effects a lot more efficient. They no longer cause a full relayout+repaint, but only a style invalidation. Style invalidations are still quite heavy though, and there's a lot of room for improvement there. :^)
2019-10-14 18:32:02 +02:00
bool operator==(const StyleProperties&) const;
bool operator!=(const StyleProperties& other) const { return !(*this == other); }
LibWeb: Use IdentifierStyleValue for CSS 'position'
2020-12-14 18:47:00 +01:00
Optional<CSS::Position> position() const;
LibWeb: Respect CSS z-index property while painting To support z-ordering when painting, the layout tree now has a parallel sparse tree of stacking contexts. The rules for which layout boxes establish a stacking context are a bit complex, but the intent is to encapsulate the decision making into establishes_stacking_context(). When we paint, we start from the ICB (LayoutDocument) who always has a StackingContext and then paint the tree of StackingContexts where each node has its children sorted by z-index. This is pretty crude, but gets the basic job done. Note that this does not yet support hit testing; hit testing is still done using a naive treewalk from the root.
2020-06-15 17:29:35 +02:00
Optional<int> z_index() const;
LibWeb: CSS: Add "position: absolute" with top and left This momentarily handles the CSS property "position: absolute;" in combination with the properties "top" and "left", so that elements can be placed anywhere on the page independently from their parents. Statically positioned elements ignore absolute positioned elements when calculating their position as they don't take up space.
2020-03-23 17:29:15 +01:00
LibWeb: Start absolutizing lengths after performing the CSS cascade Once we've performed the cascade on a set of values for an element, we should have enough information to resolve/absolutize some lengths. Basically, any CSS length that isn't "auto" or a percentage can be turned into an absolute length (in pixels) as long as we have the following information: - The viewport rect - The parent element's font - The document element's font - The element's own font To ensure that we can absolutize lengths relative to the element's own font, we now do a separate first pass where font-related properties are defaulted (in the cascade spec sense of the word) and become usable. There's a lot more work to do here, but this should open up a lot of simplification in layout code, since it will no longer need to care about relative lengths. Layout still needs to resolve percentages, since we can't do that for some properties until the containing block dimensions are known.
2021-09-23 13:13:51 +02:00
static NonnullRefPtr<Gfx::Font> font_fallback(bool monospace, bool bold);
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
private:
LibWeb: Rename CSS::StyleResolver => StyleComputer Resolved style is a spec concept that refers to the weird mix of computed style and used style reflected by getComputedStyle(). The purpose of this class is to produce the *computed* style for a given element, so let's call it StyleComputer.
2021-09-24 13:49:57 +02:00
friend class StyleComputer;
LibWeb: Start implementing the CSS cascade The 'C' in "CSS" is for Cascade, so let's actually implement the cascade in LibWeb. :^) StyleResolver::resolve_style() now begins by collecting all the matching CSS rules for the given DOM::Element. Rules are then processed in the spec's cascade order (instead of in the order we encounter them.) With this, "!important" is now honored on CSS properties. After performing the cascade, we do another pass of what the spec calls "defaulting" where we resolve "inherit" and "initial" values. I've left a FIXME about supporting correct "initial" values for every property, since we're currently lacking some coverage there. Note that this mechanism now resolves every known CSS property. This is *not* space-efficient and we'll eventually need to come up with some strategies to reduce memory usage around this. However, this will do fine until we have more of the engine working correctly. :^)
2021-09-21 11:38:18 +02:00
HashMap<CSS::PropertyID, NonnullRefPtr<StyleValue>> m_property_values;
LibWeb: Add parsing and application of CSS "overflow" property We don't actually do anything with the values yet, but now they are available for layout nodes once we are ready to implement them.
2021-02-22 15:20:31 +01:00
Optional<CSS::Overflow> overflow(CSS::PropertyID) const;
LibHTML: Move font loading from LayoutText to StyleProperties Since LayoutText inherits all of its style information from its parent Element anyway, it makes more sense to load the font at a higher level. And since the font depends only on the style and nothing else, this patch moves font loading (and caching) into StyleProperties. This could be made a lot smarter to avoid loading the same font many times, etc.
2019-10-06 11:23:58 +02: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 11:56:38 +01:00
mutable RefPtr<Gfx::Font> m_font;
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
};
LibWeb: Move everything into the Web namespace
2020-03-07 10:27:02 +01:00
}
Reference in a new issue Copy permalink