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

133 lines
5.1 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
/*
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
* Copyright (c) 2018-2023, Andreas Kling <kling@serenityos.org>
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
*
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: Move other font-related files to LibGfx/Font/
2022-04-09 09:28:38 +02:00
#include <LibGfx/Font/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: Remove now-unused includes from StyleValue.cpp And add them to all the places that relied on getting them transitively.
2023-03-25 14:11:11 +00:00
#include <LibWeb/CSS/PropertyID.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:
Libraries: Use default constructors/destructors in LibWeb https://isocpp.github.io/CppCoreGuidelines/CppCoreGuidelines#cother-other-default-operation-rules "The compiler is more likely to get the default semantics right and you cannot implement these functions better than the compiler."
2022-03-14 13:21:51 -06:00
StyleProperties() = default;
LibHTML: Replace StyleProperties::create(StyleProperties) with clone()
2020-01-05 16:54:38 +01:00
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
explicit StyleProperties(StyleProperties const&);
LibHTML: Replace StyleProperties::create(StyleProperties) with clone()
2020-01-05 16:54:38 +01:00
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
{
LibWeb: Turn StyleProperties::m_property_values into an Array After style computation, every StyleProperties has a value for every PropertyID. Given this, it's simpler, faster and less memory-heavy to use an Array instead of a HashMap. :^)
2022-02-18 20:21:49 +01:00
for (size_t i = 0; i < m_property_values.size(); ++i) {
if (m_property_values[i])
callback((CSS::PropertyID)i, *m_property_values[i]);
}
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: Turn StyleProperties::m_property_values into an Array After style computation, every StyleProperties has a value for every PropertyID. Given this, it's simpler, faster and less memory-heavy to use an Array instead of a HashMap. :^)
2022-02-18 20:21:49 +01:00
auto& properties() { return m_property_values; }
auto const& properties() const { return m_property_values; }
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
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
void set_property(CSS::PropertyID, NonnullRefPtr<StyleValue const> value);
NonnullRefPtr<StyleValue const> property(CSS::PropertyID) const;
RefPtr<StyleValue const> maybe_null_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: Teach CSS::StyleProperties to create CSS::Size values You can now use StyleProperties::size_value(CSS::PropertyID) to extract a CSS::Size for a given property.
2022-09-25 15:47:40 +02:00
CSS::Size size_value(CSS::PropertyID) const;
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
LengthPercentage length_percentage_or_fallback(CSS::PropertyID, LengthPercentage const& fallback) const;
LibWeb: Use Optional instead of undefined-lengths for widths/heights
2022-02-18 15:10:11 +00:00
Optional<LengthPercentage> length_percentage(CSS::PropertyID) 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 support for the text-justify property This commit adds the text-justify property as defined in: https://drafts.csswg.org/css-text/#propdef-text-justify
2022-03-12 19:31:32 +00:00
Optional<CSS::TextJustify> text_justify() const;
LibWeb: Use rect value in CSS clip property When a rect value is passed to the clip property via CSS, keep it in ComputedValues so that at a later stage can make use of it.
2022-07-31 18:47:09 +02:00
CSS::Clip clip() 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: Compute value for `content` property
2022-02-24 16:52:58 +00:00
CSS::ContentData content() 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: Allow multiple text-decoration-lines The spec grammar for `text-decoration-line` is: `none | [ underline || overline || line-through || blink ]` Which means that it's either `none`, or any combination of the other values. This patch makes that parse for `text-decoration-line` and `text-decoration`, stores the results as a Vector, and adjusts `paint_text_decoration()` to run as a loop over all the values that are provided. As noted, storing a Vector of values is a bit wasteful, as they could be stored as flags in a single `u8`. But I was getting too confused trying to do that in a nice way.
2022-04-14 16:22:35 +01:00
Vector<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: Parse and compute text-shadow property
2022-03-23 21:16:36 +00:00
Vector<CSS::ShadowData> text_shadow() 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: Implement the flex order CSS property Adds support for the flex order property and a test page for it on the browser welcome page.
2022-03-31 22:11:38 +02:00
int order() const;
LibWeb: Parse and plumb the `accent-color` CSS property
2023-03-18 20:49:00 +01:00
Optional<Color> accent_color(Layout::NodeWithStyle const&) const;
LibWeb: Parse the CSS align-content property
2022-10-14 13:50:06 +02:00
Optional<CSS::AlignContent> align_content() 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: Honor `align-self` over `align-items` when non-auto on flex item
2022-07-11 23:52:36 +02:00
Optional<CSS::AlignSelf> align_self() const;
LibWeb: Implement `appearance` CSS property This includes the "compat" values even though they are not strictly necessary.
2022-07-22 16:05:11 +01:00
Optional<CSS::Appearance> appearance() const;
LibWeb: Plumb style/computed values for `backdrop-filter`
2022-09-15 08:31:19 +01:00
CSS::BackdropFilter backdrop_filter() 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: Pick up the CSS "visibility" property an honor it when painting
2022-03-21 15:42:57 +01:00
Optional<CSS::Visibility> visibility() const;
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
Optional<CSS::ImageRendering> image_rendering() 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;
LbWeb: Rename BoxShadowFoo => ShadowFoo The `text-shadow` property is almost identical to `box-shadow`: > Values are interpreted as for box-shadow [CSS-BACKGROUNDS-3]. > (But note that the inset keyword are not allowed.) So, let's use the same data structures and parsing code for both. :^)
2022-03-23 16:55:22 +00:00
Vector<CSS::ShadowData> box_shadow() const;
LibWeb: Return Optional from StyleProperties::box_sizing() This function was written as if it returned `Optional<CSS::BoxSizing>` but actually returned a plain `CSS::BoxSizing`, meaning if the property was not set or was invalid, it would return whichever enum value was first. This wasn't visible because we don't yet pay any attention to the `box-sizing` property.
2022-04-13 19:33:56 +01:00
Optional<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;
LibWeb: Add vertical-align to ComputedValues
2022-02-26 01:34:07 +01:00
Variant<CSS::VerticalAlign, CSS::LengthPercentage> vertical_align() const;
LibWeb: Parse CSS "font-variant" as part of "font" This allows us to parse CSS "font" values that contain e.g "small-caps" or "normal", as used on Acid3.
2022-03-23 14:54:21 +01:00
Optional<CSS::FontVariant> font_variant() const;
LibWeb: Refactor GridTrackSize classes Refactor various classes in the GridTrackSize file for the incoming named_tracks feature. Previously the ExplicitTrackSizing had mixed responsiblities with the newly-named GridRepeat class. This made it so it was not possible to have multiple repeats within a single 'GridTrackSizeList' definition. The MetaGridTrackSize class had both the responsibilities of being a container for minmax values as well as for simple GridSizes. By uniting the different possible values (repeat, minmax, default) into the ExplicitGridTrack class are able to be more expressive as to the different grid size modalities. The GridTrackSizeList will be useful as compared to a Vector<ExplicitGridTrack> since this way can keep track of the declared line names. These same line names are able to be declared within the values of a repeat function, hence the presence of a GridTrackSizeList inside the GridRepeat class.
2022-10-30 13:27:57 +01:00
CSS::GridTrackSizeList grid_template_columns() const;
CSS::GridTrackSizeList grid_template_rows() const;
LibWeb: Parse grid-column-start and related CSS properties Parse grid-column-start, end, and the equivalent for rows.
2022-08-23 19:58:00 +02:00
CSS::GridTrackPlacement grid_column_end() const;
CSS::GridTrackPlacement grid_column_start() const;
CSS::GridTrackPlacement grid_row_end() const;
CSS::GridTrackPlacement grid_row_start() const;
LibWeb: Parse `border-collapse` property for HTML table
2023-01-02 23:01:29 +01:00
Optional<CSS::BorderCollapse> border_collapse() const;
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
Vector<Vector<String>> grid_template_areas() const;
LibWeb: Parse `grid-area` CSS property
2023-01-16 19:02:39 +01:00
String grid_area() 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: Apply the CSS transform-origin property We don't have transform-box yet, so this applies to the border-box for now. This also makes us pass a couple Web Platform Tests as well :^) For example: https://wpt.live/css/css-transforms/css3-transform-scale-002.html
2022-03-21 19:38:00 +01:00
CSS::TransformOrigin transform_origin() const;
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
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;
}
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
void set_computed_font(NonnullRefPtr<Gfx::Font const> font)
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
{
m_font = move(font);
}
LibWeb: Add support for the lh and rlh length units Resolving these units is somewhat tricky because of their interaction with both font-size and line-height, but this implementation seems to work as tested in http://wpt.live/css/css-values/lh-unit-001.html and http://wpt.live/css/css-values/lh-unit-002.html
2023-03-17 23:08:45 +01:00
CSSPixels line_height(CSSPixelRect const& viewport_rect, Gfx::FontPixelMetrics const&, CSSPixels font_size, CSSPixels root_font_size, CSSPixels line_height, CSSPixels root_line_height) const;
LibWeb: Convert Layout::Node to new pixel units
2022-11-08 11:31:24 +00:00
CSSPixels line_height(Layout::Node const&) 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
Everywhere: Run clang-format
2022-04-01 20:58:27 +03:00
bool operator==(StyleProperties const&) const;
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
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+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
static NonnullRefPtr<Gfx::Font const> font_fallback(bool monospace, bool bold);
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
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
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
Array<RefPtr<StyleValue const>, to_underlying(CSS::last_property_id) + 1> 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;
LibWeb: Parse and compute text-shadow property
2022-03-23 21:16:36 +00:00
Vector<CSS::ShadowData> shadow(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
LibWeb+LibIDL: Fix (or paper over) various const-correctness issues There's definitely stuff to iterate on here, but this takes care of making the libraries compile with stricter RP and NNRP.
2023-02-20 18:56:08 +01:00
mutable RefPtr<Gfx::Font const> 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