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

1958 lines
35 KiB
JSON
Raw Normal View History

LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
{
LibWeb: Parse and plumb the `accent-color` CSS property
2023-03-18 20:49:00 +01:00
"accent-color": {
"inherited": true,
"initial": "auto",
"valid-types": [
"color"
],
"valid-identifiers": [
"auto"
]
},
LibWeb: Parse the CSS align-content property
2022-10-14 13:50:06 +02:00
"align-content": {
"inherited": false,
"initial": "stretch",
"valid-types": [
"align-content"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"align-items": {
"inherited": false,
LibWeb: Correct initial values in Properties.json - `align-items`: `normal` is the initial value in the CSS-ALIGN spec, but `stretch` is in CSS-FLEXBOX. The FLEXBOX spec is the one we've actually implemented elsewhere, and ALIGN adds new values with special syntax, so it's not trivial to add it here. - `border-spacing`: `0` is equivalent to `0px 0px` and we don't yet parse the double-value syntax. - `text-decoration-thickness`: Had the wrong value.
2021-11-10 13:27:16 +00:00
"initial": "stretch",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"align-items"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Honor `align-self` over `align-items` when non-auto on flex item
2022-07-11 23:52:36 +02:00
"align-self": {
"inherited": false,
"initial": "auto",
"valid-types": [
"align-self"
]
},
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"animation": {
"affects-layout": true,
"inherited": false,
"initial": "none 0s ease 1 normal running 0s none",
"longhands": [
"animation-name",
"animation-duration",
"animation-timing-function",
"animation-iteration-count",
"animation-direction",
"animation-play-state",
"animation-delay",
"animation-fill-mode"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-delay": {
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"affects-layout": true,
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "0s",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-types": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"time [-∞,∞]"
]
},
"animation-direction": {
"affects-layout": false,
"inherited": false,
"initial": "normal",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"normal",
"reverse",
"alternate",
"alternate-reverse"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
"animation-duration": {
"affects-layout": true,
"inherited": false,
"initial": "0s",
"valid-types": [
"time [0,∞]"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-fill-mode": {
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"affects-layout": true,
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "none",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"none",
"forwards",
"backwards",
"both"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
"animation-iteration-count": {
"affects-layout": true,
"inherited": false,
"initial": "1",
"valid-types": [
"number [0,∞]"
],
"valid-identifiers": [
"infinite"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-name": {
"affects-layout": true,
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "none",
"valid-types": [
"string",
"custom-ident"
],
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"none"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
"animation-play-state": {
"affects-layout": false,
"inherited": false,
"initial": "running",
"valid-identifiers": [
"running",
"paused"
]
},
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"animation-timing-function": {
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"affects-layout": true,
"inherited": false,
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"initial": "ease",
"__comment": "FIXME: This is like...wrong.",
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-identifiers": [
LibWeb: Alphabetize animation properties I didn't notice this when they were added, whoops
2023-06-09 14:07:59 +01:00
"ease",
"linear",
"ease-in-out",
"ease-in",
"ease-out"
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
]
},
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
"appearance": {
"inherited": false,
"initial": "auto",
"valid-types": [
"appearance"
]
},
LibWeb+Meta: Parse the `backdrop-filter` CSS property Note: The parsing and style value completely ignores the SVG filters part of the spec for now... That's a yak for another day :^)
2022-09-15 08:31:17 +01:00
"backdrop-filter": {
"affects-layout": false,
LibWeb: Establish stacking context when backdrop-filter is not 'none'
2022-10-24 16:05:10 +01:00
"affects-stacking-context": true,
LibWeb+Meta: Parse the `backdrop-filter` CSS property Note: The parsing and style value completely ignores the SVG filters part of the spec for now... That's a yak for another day :^)
2022-09-15 08:31:17 +01:00
"inherited": false,
"initial": "none",
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"__comment": "FIXME: List `filter-value-list` as a valid-type once it's generically supported.",
LibWeb+Meta: Parse the `backdrop-filter` CSS property Note: The parsing and style value completely ignores the SVG filters part of the spec for now... That's a yak for another day :^)
2022-09-15 08:31:17 +01:00
"valid-identifiers": [
"none"
]
},
LibWeb: Add initial values and longhands to `background` definition There is no specified initial value, but `transparent` is equivalent to setting all the background properties to their defaults.
2021-11-10 13:29:41 +00:00
"background": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add initial values and longhands to `background` definition There is no specified initial value, but `transparent` is equivalent to setting all the background properties to their defaults.
2021-11-10 13:29:41 +00:00
"inherited": false,
"initial": "transparent",
"longhands": [
"background-attachment",
"background-clip",
"background-color",
"background-image",
"background-origin",
"background-position",
"background-repeat",
"background-size"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"background-attachment": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "scroll",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"background-attachment"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"background-clip": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"inherited": false,
"initial": "border-box",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"background-box"
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"background-color": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "transparent",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"background-image": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
"valid-types": [
"image"
],
"valid-identifiers": [
"none"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"background-origin": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
"inherited": false,
"initial": "padding-box",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"background-box"
LibWeb: Parse `background-clip` and `background-origin` Including as part of the `background` shorthand. :^)
2021-11-03 20:28:34 +00:00
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"background-position": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0% 0%",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"bottom",
"center",
"left",
"right",
"top"
],
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
"quirks": [
"unitless-length"
],
"longhands": [
"background-position-x",
"background-position-y"
]
},
"background-position-x": {
"inherited": false,
"affects-layout": false,
"initial": "0%",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
],
"valid-identifiers": [
"center",
"left",
"right"
]
},
"background-position-y": {
"inherited": false,
"affects-layout": false,
"initial": "0%",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add longhand properties for background-position If background-position was not longhand enough for you, we've now got background-position-x and background-position-y :^)
2023-04-02 22:52:54 +01:00
],
"valid-identifiers": [
"center",
"bottom",
"top"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"background-repeat": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Combine background-repeat-x/y pseudo-properties While right now this doesn't save much complexity, it will do once we care about multiple background layers per node. Then, having a single repeat value per layer will simplify things. It also means we can remove the pseudo-property concept entirely! :^)
2021-11-04 16:51:34 +00:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "repeat",
"max-values": 2,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"repeat"
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
"repeat-x",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"repeat-y"
LibWeb: Support two-value background-repeat The background-repeat value may be specified as either one- or two-value identifiers (to be interpreted as horizontal and vertical repeat). This adds two pseudo-properties, background-repeat-x and background-repeat-y, to handle this. One-value identifiers are mapped to two-value in accordance with the spec.
2021-04-05 12:05:35 -04:00
]
},
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
"background-size": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
"inherited": false,
"initial": "auto",
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Parse `background-size` property
2021-11-05 13:44:37 +00:00
],
"valid-identifiers": [
"auto",
"cover",
"contain"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-width",
"border-style",
"border-color"
]
},
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"border-top": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"longhands": [
"border-top-width",
"border-top-style",
"border-top-color"
]
},
"border-right": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"longhands": [
"border-right-width",
"border-right-style",
"border-right-color"
]
},
"border-bottom": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"longhands": [
"border-bottom-width",
"border-bottom-style",
"border-bottom-color"
]
},
"border-left": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "medium currentcolor none",
LibWeb: Expand border-{top,right,bottom-left} CSS shorthand properties This code is pretty rough, but it's something that will also improve with the eventual new CSS parser.
2020-06-10 16:14:31 +02:00
"longhands": [
"border-left-width",
"border-left-style",
"border-left-color"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-bottom-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add preliminary support for CSS animations This partially implements CSS-Animations-1 (though there are references to CSS-Animations-2). Current limitations: - Multi-selector keyframes are not supported. - Most animation properties are ignored. - Timing functions are not applied. - Non-absolute values are not interpolated unless the target is also of the same non-absolute type (e.g. 10% -> 25%, but not 10% -> 20px). - The JavaScript interface is left as an exercise for the next poor soul looking at this code. With those said, this commit implements: - Interpolation for most common types - Proper keyframe resolution (including the synthetic from-keyframe containing the initial state) - Properly driven animations, and proper style invalidation Co-Authored-By: Andreas Kling <kling@serenityos.org>
2023-05-26 23:30:54 +03:30
"valid-types": [
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"border-bottom-left-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
"border-bottom-right-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-bottom-style": {
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-bottom-width": {
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "currentcolor",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-top-color",
"border-right-color",
"border-bottom-color",
"border-left-color"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
"border-collapse": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "separate",
LibWeb: Parse `border-collapse` property for HTML table
2023-01-02 23:01:29 +01:00
"valid-types": [
"border-collapse"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-left-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-left-style": {
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-left-width": {
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"border-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0",
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"longhands": [
"border-top-left-radius",
"border-top-right-radius",
"border-bottom-left-radius",
"border-bottom-right-radius"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-right-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-right-style": {
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-right-width": {
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-spacing": {
"inherited": true,
LibWeb: Correct initial values in Properties.json - `align-items`: `normal` is the initial value in the CSS-ALIGN spec, but `stretch` is in CSS-FLEXBOX. The FLEXBOX spec is the one we've actually implemented elsewhere, and ALIGN adds new values with special syntax, so it's not trivial to add it here. - `border-spacing`: `0` is equivalent to `0px 0px` and we don't yet parse the double-value syntax. - `text-decoration-thickness`: Had the wrong value.
2021-11-10 13:27:16 +00:00
"initial": "0",
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [0,∞]"
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-style": {
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "none",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-top-style",
"border-right-style",
"border-bottom-style",
"border-left-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"max-values": 4,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
"border-top-color": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Make "currentcolor" lowercase in Properties.json It's technically case-insensitive, but the spec always defines it as "currentcolor" so it feels wrong to capitalise it differently there.
2021-09-16 20:59:45 +01:00
"initial": "currentcolor",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
"border-top-left-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
"border-top-right-radius": {
LibWeb: Mark a bunch of CSS border-* properties as not affecting layout border*-width and border-collapse affect layout, but all the color, style and radius ones will only need a repaint if changed. :^)
2022-03-16 20:34:48 +01:00
"affects-layout": false,
LibWeb: Quote all initial values in Properties.json This is in preparation for parsing these into StyleValues automatically. Having them all be Strings makes the generation code simpler.
2021-08-16 17:09:34 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
"max-values": 2,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add border-radius to the CSS-parser And resolve the shorthands.
2021-05-14 21:36:26 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"border-top-style": {
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inherited": false,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-top-width": {
"initial": "medium",
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"border-width": {
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "medium",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"border-top-width",
"border-right-width",
"border-bottom-width",
"border-left-width"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
"bottom": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"box-shadow": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add box-shadow as a known ValueID
2021-07-23 21:21:39 +02:00
"inherited": false,
LibWeb: Parse "none" value for box-shadow property Previously, `box-shadow: none` would fail to parse, meaning that in this example: ```css p { box-shadow: 20px 10px 5px magenta; } p.foo { box-shadow: none; } ``` ... a `<p class="foo">` would still have a box-shadow, when it should not have one. Now, we handle the `none` value. :^)
2021-10-15 19:25:27 +01:00
"initial": "none",
"valid-identifiers": [
"none"
]
LibWeb: Add box-shadow as a known ValueID
2021-07-23 21:21:39 +02:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"box-sizing": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "content-box",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"box-sizing"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"caption-side": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "top",
"valid-identifiers": [
"bottom",
"top"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"clear": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"clear"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"clip": {
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
"auto"
],
LibWeb: Parse rect style value Add ability to parse a rect when it is used as the value of a style property.
2022-07-31 18:46:35 +02:00
"valid-types": [
"rect"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"color": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Correct some initial values and add missing ones - The `text-decoration-foo` values now match the spec. - Added values for `border-foo` since those are needed soon. - Make `color`'s initial value be `-libweb-palette-base-text`.
2021-09-17 17:18:06 +01:00
"initial": "-libweb-palette-base-text",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
"color"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"hashless-hex-color"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"column-gap": {
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"valid-identifiers": [
"auto"
]
},
LibWeb: Parse the `content` property For now, we only understand `none`, `normal`, `<image>` and `<string>`. The various other functions and identifiers can be added later. We can *almost* use a StyleValueList for this, except it's divided into two parts - the content, and the optional "alt text". So, I've added a new StyleValue for it.
2022-02-23 19:56:25 +00:00
"content": {
"inherited": false,
"initial": "normal",
"__comment": "FIXME: This accepts a whole lot of other types and identifiers!",
"valid-types": [
"string"
],
"valid-identifiers": [
"normal",
"none"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"cursor": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-types": [
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"url",
"cursor"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"direction": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "ltr",
"valid-identifiers": [
"ltr",
"rtl"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"display": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "inline",
LibWeb: Set max-values for display CSS property
2023-04-26 19:49:02 +02:00
"max-values": 3,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-identifiers": [
"block",
LibWeb: Add missing valid-identifiers for display CSS property
2023-04-25 13:37:24 +02:00
"contents",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"flex",
LibWeb: Add missing valid-identifiers for display CSS property
2023-04-25 13:37:24 +02:00
"flow-root",
LibWeb: Parse grid display value
2022-08-23 10:13:07 +02:00
"grid",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inline",
"inline-block",
LibWeb: Parse `display: inline-flex` This was already handled in the CSS machinery, we just never parsed it.
2022-02-07 17:29:36 +00:00
"inline-flex",
LibWeb: Add missing inline-grid for display CSS property
2023-04-26 19:46:36 +02:00
"inline-grid",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"inline-table",
"list-item",
"none",
LibWeb: Add missing valid-identifiers for display CSS property
2023-04-25 13:37:24 +02:00
"ruby",
"run-in",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"table",
"table-caption",
"table-cell",
"table-column",
"table-column-group",
"table-footer-group",
"table-header-group",
"table-row",
"table-row-group"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"fill": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "black",
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"__comment": "FIXME: Use `paint` as the type, once we have a PaintStyleValue and generic parsing for it.",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Fill in some missing property data and bodge extra types We don't yet have generic parsing support for `<filter-value-list>` or `<paint>`, so listing them here confuses the new StyleValue parsing code I'm working on. For now, let's skip `<filter-value-list>` since it's only used in one pkace which manually parses it, and list the parts of `<paint>` instead which are taken from here: https://www.w3.org/TR/SVG2/painting.html#SpecifyingPaint
2023-05-10 17:19:08 +01:00
"color",
"url"
LibWeb: Add `none` as a valid identifier for `fill` and `stroke`
2022-01-24 15:40:45 +00:00
],
"valid-identifiers": [
"none"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"fill-opacity": {
"affects-layout": false,
"inherited": true,
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
]
},
LibWeb: Parse and resolve flex: shorthand
2021-06-01 15:50:17 +02:00
"flex": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0 1 auto",
LibWeb: Use new StyleValue parsing for flex To make this work, we also add `none` as a valid identifier for `flex`. (This is correct, we just didn't need it before.)
2023-05-18 16:21:10 +01:00
"valid-identifiers": [
"none"
],
LibWeb: Parse and resolve flex: shorthand
2021-06-01 15:50:17 +02:00
"longhands": [
"flex-grow",
"flex-shrink",
"flex-basis"
]
},
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
"flex-basis": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto",
"content"
]
LibWeb: Parse flex-basis Flex-basis accepts either 'content' or a Length.
2021-05-30 14:23:43 +02:00
},
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
"flex-direction": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "row",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"flex-direction"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Parse the CSS "flex-direction" property
2021-01-18 17:41:57 +01:00
},
LibWeb: Parse and resolve flex-flow property
2021-05-30 12:25:10 +02:00
"flex-flow": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "row nowrap",
LibWeb: Parse and resolve flex-flow property
2021-05-30 12:25:10 +02:00
"longhands": [
"flex-direction",
"flex-wrap"
]
},
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
"flex-grow": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "0",
"valid-types": [
LibWeb: Reject negative values for `flex-grow` and `flex-shrink`
2022-07-18 21:52:30 +02:00
"number [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
},
"flex-shrink": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "1",
"valid-types": [
LibWeb: Reject negative values for `flex-grow` and `flex-shrink`
2022-07-18 21:52:30 +02:00
"number [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add flex-grow and flex-shrink They get parsed and are available to the programmer of Layouts :^)
2021-05-30 20:22:25 +02:00
},
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
"flex-wrap": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "nowrap",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"flex-wrap"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing for flex-wrap property
2021-05-30 12:11:32 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"float": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"float"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
"font": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": true,
"initial": "normal medium sans-serif",
LibWeb: Start parsing font property
2021-04-13 20:41:57 +03:00
"longhands": [
"font-family",
"font-size",
"font-variant",
"font-weight"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"font-family": {
"inherited": true,
"initial": "sans-serif"
},
"font-size": {
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "medium",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"large",
"larger",
"medium",
"small",
"smaller",
"x-large",
"x-small",
"xx-large",
"xx-small",
"xxx-large"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse font-stretch CSS property
2023-02-03 14:27:09 +03:00
"font-stretch": {
"inherited": true,
"initial": "normal",
"valid-types": [
"percentage [0,∞]"
],
"valid-identifiers": [
"normal",
"ultra-condensed",
"extra-condensed",
"condensed",
"semi-condensed",
"semi-expanded",
"expanded",
"extra-expanded",
"ultra-expanded"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"font-style": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-identifiers": [
"italic",
"normal",
"oblique"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"font-variant": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"font-variant"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"font-weight": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-types": [
LibWeb: Add range-checking to property_accepts_value() For `number` and `integer` types, you can add a range afterwards to add a range check, using similar syntax to that used in the CSS specs. For example: ```json "font-weight": { ... "valid-types": [ "number [1,1000]" ], ... } ``` This limits any numbers to the range `1 <= n <= 1000`.
2021-09-23 12:45:08 +01:00
"number [1,1000]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"bold",
"bolder",
"lighter",
"normal"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"gap": {
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"max-values": 2,
"valid-identifiers": [
"auto"
],
"longhands": [
"row-gap",
"column-gap"
]
},
LibWeb: Parse `grid-area` CSS property
2023-01-16 19:02:39 +01:00
"grid-area": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
],
"longhands": [
"grid-column-end",
"grid-column-start",
"grid-row-end",
"grid-row-start"
]
},
LibWeb: Parse grid-column and grid-row CSS values
2022-08-23 20:00:16 +02:00
"grid-column": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
],
"longhands": [
"grid-column-end",
"grid-column-start"
]
},
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
"grid-column-end": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"grid-column-gap": {
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"valid-identifiers": [
"auto"
]
},
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
"grid-column-start": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"grid-gap": {
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"max-values": 2,
"valid-identifiers": [
"auto"
],
"longhands": [
"grid-row-gap",
"grid-column-gap"
]
},
LibWeb: Parse grid-column and grid-row CSS values
2022-08-23 20:00:16 +02:00
"grid-row": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
],
"longhands": [
"grid-row-end",
"grid-row-start"
]
},
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
"grid-row-end": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"grid-row-gap": {
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"valid-identifiers": [
"auto"
]
},
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
"grid-row-start": {
"inherited": false,
"initial": "auto",
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb: Add basic parsing of grid shorthand CSS property Introduces incomplete parsing of grid shorthand property. Only <grid-template> part of syntax is supported for now but it is enough to significantly improve rendering of websites that use this shorthand to define grid :)
2023-05-27 02:58:19 +03:00
"grid": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
],
"longhands": [
"grid-template"
]
},
LibWeb: Parse `grid-template` property
2023-04-29 19:32:56 +02:00
"grid-template": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
],
"longhands": [
"grid-template-areas",
"grid-template-rows",
"grid-template-columns"
]
},
LibWeb: Parse `grid-template-areas` CSS property
2023-01-16 18:17:05 +01:00
"grid-template-areas": {
"inherited": false,
"initial": "auto",
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
"valid-identifiers": [
"auto"
],
"valid-types": [
"string"
]
},
LibWeb/CSS: Implement parsing of grid-auto-columns and grid-auto-rows
2023-05-21 18:08:41 +03:00
"grid-auto-columns": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
]
},
"grid-auto-rows": {
"inherited": false,
"initial": "auto",
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
]
},
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"grid-template-columns": {
"inherited": false,
LibWeb: Use none as initial value for grid-template-column/rows This fixes the issue that currently we use "auto" as initial value for grid-template-column and grid-template-rows although spec says it should be "none". This makes a lot of difference for these properties because currently we represent "auto" as a list with one auto-sized track which means initial value for grid-template-column defines one "explicit" track while it should define none of them. This change makes grid-auto-columns/rows be applied to the correct tracks when initial values is used for grid-template-column/rows.
2023-06-07 13:04:06 +03:00
"initial": "none",
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"max-values": 4,
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
]
},
"grid-template-rows": {
"inherited": false,
LibWeb: Use none as initial value for grid-template-column/rows This fixes the issue that currently we use "auto" as initial value for grid-template-column and grid-template-rows although spec says it should be "none". This makes a lot of difference for these properties because currently we represent "auto" as a list with one auto-sized track which means initial value for grid-template-column defines one "explicit" track while it should define none of them. This change makes grid-auto-columns/rows be applied to the correct tracks when initial values is used for grid-template-column/rows.
2023-06-07 13:04:06 +03:00
"initial": "none",
LibWeb: Parse grid-template-columns and grid-template-rows Add functionality to begin parsing grid-template-columns and grid-template-rows. There are still things to be added, like parsing functions, but I would say a couple of the major points are already adressed like length, percentage, and flexible-length.
2022-08-23 19:49:07 +02:00
"max-values": 4,
"valid-identifiers": [
"auto"
],
"valid-types": [
"length",
"percentage",
"string"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"height": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
"image-rendering": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
"inherited": true,
"initial": "auto",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"image-rendering"
LibWeb: Add support for CSS image-rendering property Currently only "auto" and "pixelated" values are supported.
2022-02-18 12:21:27 +01:00
]
},
LibWeb: Add support for parsing 'inset' shorthand CSS property
2023-05-29 21:43:37 -04:00
"inset": {
"inherited": false,
"initial": "auto",
"longhands": [
"top",
"right",
"bottom",
"left"
],
"max-values": 4,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add support for parsing 'inset' shorthand CSS property
2023-05-29 21:43:37 -04:00
],
"valid-identifiers": [
"auto"
]
},
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
"justify-content": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "flex-start",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"justify-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add parsing for the justify-content property
2021-07-16 18:38:26 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"left": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"letter-spacing": {
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "normal",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"normal"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"line-height": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"number [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"normal"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"list-style": {
LibWeb: Replace is_inherited_property() with generated code We already include the inheritance for each property in Properties.json, so made sense to use that instead of a list in StyleResolver. Added `inherited: true` to a couple of properties to match the previous code's behavior. One of those had a FIXME which I've moved to the JSON file, which is hacky, but it works.
2021-08-16 16:07:13 +01:00
"inherited": true,
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"initial": "outside disc",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"list-style-type",
"list-style-position",
"list-style-image"
]
},
"list-style-image": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
"valid-types": [
"image"
],
"valid-identifiers": [
"none"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"list-style-position": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "outside",
LibWeb: Support list-style-position This moves the ::marker inside of <summary> actually inside. :^)
2023-06-02 23:05:15 +02:00
"valid-types": [
"list-style-position"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"list-style-type": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "disc",
"valid-types": [
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"string",
"list-style-type"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"margin": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"margin-block": {
"logical-alias-for": [
"margin"
],
"max-values": 2
},
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"margin-block-start": {
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
"margin-block-end": {
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"margin-bottom": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"margin-inline": {
"logical-alias-for": [
"margin"
],
"max-values": 2
},
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"margin-inline-start": {
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
"margin-inline-end": {
"logical-alias-for": [
"margin-top",
"margin-right",
"margin-bottom",
"margin-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"margin-left": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"margin-right": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"margin-top": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"max-height": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"none"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"max-inline-size": {
LibWeb: Make CSS/Properties.json "logical-aliases-for" an array This allows us to specify all aliases properties instead of just one.
2023-06-06 10:35:16 +02:00
"logical-alias-for": [
"max-width",
"max-height"
],
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"initial": "none"
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"max-width": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "none",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Accept fit-content as a value for min-width and max-width This starts working immediately in BFC thanks to calculate_inner_width being used for width constraints. :^)
2023-05-26 19:08:28 +02:00
"fit-content",
LibWeb: Support `max-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:18:34 +02:00
"max-content",
LibWeb: Support `min-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:24:55 +02:00
"min-content",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"none"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"min-height": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Add missing "auto" identifiers for min-width/height Both of these have "auto" as their initial value, so the only reason they work currently is that "auto" is implicitly a Length.
2022-01-16 21:35:33 +00:00
"auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"none"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"min-inline-size": {
LibWeb: Make CSS/Properties.json "logical-aliases-for" an array This allows us to specify all aliases properties instead of just one.
2023-06-06 10:35:16 +02:00
"logical-alias-for": [
"min-width",
"min-height"
],
LibWeb: Support min-inline-size & max-inline-size Currently this assumes that writing-mode is horizontal, and therefore only affects the min-width/max-width
2023-05-23 00:29:01 -07:00
"initial": "0"
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"min-width": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Add missing "auto" identifiers for min-width/height Both of these have "auto" as their initial value, so the only reason they work currently is that "auto" is implicitly a Length.
2022-01-16 21:35:33 +00:00
"auto",
LibWeb: Accept fit-content as a value for min-width and max-width This starts working immediately in BFC thanks to calculate_inner_width being used for width constraints. :^)
2023-05-26 19:08:28 +02:00
"fit-content",
LibWeb: Support `max-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:18:34 +02:00
"max-content",
LibWeb: Support `min-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:24:55 +02:00
"min-content",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"none"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse and store the opacity property
2021-07-23 13:18:09 +03:00
"opacity": {
LibWeb: Only invalidate stacking context tree for opacity/z-index change I came across some websites that change an elements CSS "opacity" in their :hover selectors. That caused us to relayout on hover, which we'd like to avoid. With this patch, we now check if a property only affects the stacking context tree, and if nothing layout-affecting has changed, we only invalidate the stacking context tree, causing it to be rebuilt on next paint or hit test. This makes :hover { opacity: ... } rules much faster. :^)
2022-03-21 10:58:51 +01:00
"affects-layout": false,
"affects-stacking-context": true,
LibWeb: Parse and store the opacity property
2021-07-23 13:18:09 +03:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Parse and store the opacity property
2021-07-23 13:18:09 +03:00
},
LibWeb: Fix order/formatting of Properties.json
2023-06-02 17:23:00 +01:00
"order": {
"inherited": false,
"initial": "0",
"valid-types": [
"integer [-∞,∞]"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"outline": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"__comment": "FIXME: Initial value is really `medium invert none` but we don't yet parse the outline shorthand.",
"initial": "none",
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"longhands": [
"outline-color",
"outline-style",
"outline-width"
]
},
"outline-color": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "invert",
"valid-types": [
"color"
],
"valid-identifiers": [
"invert"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
"outline-style": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"line-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
"outline-width": {
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "medium",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"medium",
"thick",
"thin"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
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
"overflow": {
"longhands": [
"overflow-x",
"overflow-y"
],
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
"max-values": 2,
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"overflow"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
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
},
"overflow-x": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"overflow"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
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
},
"overflow-y": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"overflow"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
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
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"padding": {
LibWeb: Add initial values for all CSS properties It's a little verbose to repeat these in cases like the borders, but if everything has an initial value, we can guarantee that `property_initial_value()` will return something! :^)
2021-11-10 13:43:52 +00:00
"inherited": false,
"initial": "0",
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"longhands": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
],
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"max-values": 4,
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
]
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"padding-block": {
"logical-alias-for": [
"padding"
],
"max-values": 2
},
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"padding-block-start": {
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
"padding-block-end": {
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"padding-bottom": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add naive support for {margin,padding}-{block,inline} Like other logical properties, we just alias these to the LTR TB default properties for now.
2023-06-07 09:13:21 +02:00
"padding-inline": {
"logical-alias-for": [
"padding"
],
"max-values": 2
},
LibWeb: Add CSS logical property aliases for margin and padding sides These just map to the LTR+TB defaults for now, as we don't yet resolve any of the inputs to the logical property selection algorithm.
2023-06-06 12:24:08 +02:00
"padding-inline-start": {
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
"padding-inline-end": {
"logical-alias-for": [
"padding-top",
"padding-right",
"padding-bottom",
"padding-left"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"padding-left": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"padding-right": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"padding-top": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add support for parsing place-content shorthand CSS property
2023-05-29 16:34:53 -04:00
"place-content": {
"inherited": false,
"initial": "normal",
"longhands": [
"align-content",
"justify-content"
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"pointer-events": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": true,
LibWeb: Add initial version of pointer-events CSS property
2021-10-05 19:47:13 +01:00
"initial": "auto",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"pointer-events"
LibWeb: Add initial version of pointer-events CSS property
2021-10-05 19:47:13 +01:00
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Add the CSS "position" property to CSS/Properties.json
2019-11-19 18:20:54 +01:00
"position": {
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "static",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"position"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Add the CSS "position" property to CSS/Properties.json
2019-11-19 18:20:54 +01:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"right": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Parse CSS gap property Including the legacy grid-gap, grid-column-gap and grid-row-gap properties.
2022-11-06 12:42:22 +01:00
"row-gap": {
"inherited": false,
"initial": "auto",
"valid-types": [
"length [0,∞]",
"percentage [0,∞]"
],
"valid-identifiers": [
"auto"
]
},
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
"stroke": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
"inherited": true,
LibWeb: Add `none` as a valid identifier for `fill` and `stroke`
2022-01-24 15:40:45 +00:00
"initial": "none",
LibWeb/SVG: Support url() in the stroke attribute This allows you to draw gradients in strokes, for example.
2023-06-06 20:40:10 +01:00
"__comment": "FIXME: Use `paint` as the type, once we have a PaintStyleValue and generic parsing for it.",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb/SVG: Support url() in the stroke attribute This allows you to draw gradients in strokes, for example.
2023-06-06 20:40:10 +01:00
"color",
"url"
LibWeb: Add `none` as a valid identifier for `fill` and `stroke`
2022-01-24 15:40:45 +00:00
],
"valid-identifiers": [
"none"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
},
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"stroke-opacity": {
"affects-layout": false,
"inherited": true,
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
]
},
LibWeb: Add stop-color as a CSS property (This is to set the color of a stop for an SVG gradient)
2023-04-19 18:51:00 +01:00
"stop-color": {
"affects-layout": false,
"inherited": false,
"initial": "black",
"valid-types": [
"color"
]
},
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
"stop-opacity": {
"affects-layout": false,
"inherited": false,
"initial": "1",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"number [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Implement SVG opacity properties This implements the stop-opacity, fill-opacity, and stroke-opacity properties (in CSS). This replaces the existing more ad-hoc fill-opacity attribute handling.
2023-05-19 20:35:39 +01:00
]
},
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
"stroke-width": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "1px",
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"number [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibWeb: Add for CSS `fill/stroke/stroke-color` properties for SVG In the spec, `fill` and `stroke` are supposed to be a shorthands for various properties. But since the spec is still a working draft, and neither Firefox or Chrome support the `fill-color` or `stroke-color` properties, we'll stick with `fill` and `stroke` as simple colors for now. Also, note that SVG expects things in "user units", and we are assuming that 1px = 1 user unit for now.
2021-09-16 12:28:14 +01:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"text-align": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "left",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-align"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"text-decoration": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
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
"inherited": false,
"initial": "none",
"longhands": [
"text-decoration-color",
"text-decoration-line",
"text-decoration-style",
"text-decoration-thickness"
]
},
"text-decoration-color": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
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
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "currentcolor",
"valid-types": [
"color"
]
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
},
"text-decoration-line": {
LibWeb: Replace is_inherited_property() with generated code We already include the inheritance for each property in Properties.json, so made sense to use that instead of a list in StyleResolver. Added `inherited: true` to a couple of properties to match the previous code's behavior. One of those had a FIXME which I've moved to the JSON file, which is hacky, but it works.
2021-08-16 16:07:13 +01:00
"__comment": "FIXME: This property is not supposed to be inherited, but we currently rely on inheritance to propagate decorations into line boxes.",
LibWeb: Annotate which CSS properties may affect layout This patch adds CSS::property_affects_layout(PropertyID) which tells us whether a CSS property would affect layout if it were changed. This will be used to avoid unnecessary relayout work when something changes that really only requires us to repaint the page. To mark a property as not affecting layout, set "affects-layout" to false in the corresponding Properties.json entry. Note that all properties affect layout by default.
2022-03-16 17:46:24 +01:00
"affects-layout": false,
LibWeb: Replace is_inherited_property() with generated code We already include the inheritance for each property in Properties.json, so made sense to use that instead of a list in StyleResolver. Added `inherited: true` to a couple of properties to match the previous code's behavior. One of those had a FIXME which I've moved to the JSON file, which is hacky, but it works.
2021-08-16 16:07:13 +01:00
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-decoration-line"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
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
},
"text-decoration-style": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
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
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "solid",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-decoration-style"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
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
},
"text-decoration-thickness": {
LibWeb: Mark all text-decoration* CSS properties as not affecting layout
2022-03-16 19:11:25 +01:00
"affects-layout": false,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Correct initial values in Properties.json - `align-items`: `normal` is the initial value in the CSS-ALIGN spec, but `stretch` is in CSS-FLEXBOX. The FLEXBOX spec is the one we've actually implemented elsewhere, and ALIGN adds new values with special syntax, so it's not trivial to add it here. - `border-spacing`: `0` is equivalent to `0px 0px` and we don't yet parse the double-value syntax. - `text-decoration-thickness`: Had the wrong value.
2021-11-10 13:27:16 +00:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto",
"from-font"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"text-indent": {
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "0",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
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
"text-justify": {
"inherited": true,
"initial": "auto",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-justify"
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
]
},
LibWeb: Parse and compute text-shadow property
2022-03-23 21:16:36 +00:00
"text-shadow": {
"affects-layout": false,
"inherited": true,
"initial": "none",
"valid-identifiers": [
"none"
]
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"text-transform": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "none",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"text-transform"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"top": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01: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
"transform": {
"inherited": false,
LibWeb: Mark `transform` property as affecting stacking contexts
2022-07-19 16:05:58 +01:00
"initial": "none",
"affects-stacking-context": true
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: Parse the CSS transform-origin property This is almost a PositionStyleValue, but it's serialized differently, so let's use a StyleValueList with 2 length-percentage values.
2022-03-21 19:11:06 +01:00
"transform-origin": {
"affects-layout": false,
"inherited": false,
"initial": "50% 50%",
"max-values": 3,
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Parse the CSS transform-origin property This is almost a PositionStyleValue, but it's serialized differently, so let's use a StyleValueList with 2 length-percentage values.
2022-03-21 19:11:06 +01:00
],
"valid-identifiers": [
"bottom",
"center",
"left",
"right",
"top"
]
},
LibWeb: Resolve the `transition-delay` property
2023-05-27 22:05:48 +02:00
"transition-delay": {
"inherited": false,
"initial": "0s",
"valid-types": [
LibWeb: Make CSS/Properties.json "logical-aliases-for" an array This allows us to specify all aliases properties instead of just one.
2023-06-06 10:35:16 +02:00
"time"
LibWeb: Resolve the `transition-delay` property
2023-05-27 22:05:48 +02:00
]
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"user-select": {
LibWeb: Mark more CSS properties as not affecting layout - background properties - box-shadow - cursor - SVG fill/stroke properties - image-rendering - outline properties - pointer-events - user-select This should be basically all of them. I skipped `opacity` and `transform` since establishing a stacking context feels like a layout-affecting thing, but I could be very wrong on that!
2022-03-18 15:34:26 +00:00
"affects-layout": false,
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-identifiers": [
"all",
"auto",
"contain",
"none",
"text"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"vertical-align": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "baseline",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"vertical-align"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"visibility": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "visible",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"visibility"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"width": {
"inherited": false,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "auto",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Assign limits to CSS properties that cannot be negative I believe this is all of them, but I may have missed some. Several properties technically do not allow negative numbers but the description says to accept these as valid, and then clamp them afterwards to the desired range. As such, we don't reject them during parsing.
2022-03-26 15:00:49 +00:00
"length [0,∞]",
"percentage [0,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
LibWeb: Add fit-content as a valid size value for CSS width
2023-05-26 18:58:06 +02:00
"auto",
LibWeb: Support `max-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:18:34 +02:00
"fit-content",
LibWeb: Support `min-content` for `width`, `min-width` and `max-width` We're gonna need to handle this in many more places, this patch only adds it to calculate_inner_width().
2023-05-28 18:24:55 +02:00
"max-content",
"min-content"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"white-space": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
LibWeb: Use generated enum code for property value validation This has the nice benefit of removing a lot of duplicated lists of values from Properties.json. :^)
2022-04-14 11:23:23 +01:00
"valid-types": [
"white-space"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
"word-spacing": {
"inherited": true,
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"initial": "normal",
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"length [-∞,∞]",
"percentage [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"normal"
],
LibWeb: Add CSS quirks information to Properties.json Two CSS quirks are specced to only apply to specific properties: - The hashless hex color quirk https://quirks.spec.whatwg.org/#the-hashless-hex-color-quirk - The unitless length quirk https://quirks.spec.whatwg.org/#the-unitless-length-quirk These are now represented in `Properties.json` like so: ```json "property-name-here": { "quirks": [ "hashless-hex-color", "unitless-length" ] } ``` Every property that either of those two quirks applies to is included in `Properties.json` and now has their quirks listed. :^)
2021-09-10 21:43:03 +01:00
"quirks": [
"unitless-length"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
},
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
"word-wrap": {
"inherited": true,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "normal",
"valid-identifiers": [
"anywhere",
"break-word",
"normal"
]
LibWeb: Add handful of CSS properties and identifiers This is just to make the CSS parser stop whining when it encounters some very common properties and identifiers. More work will be required to actually support these things. :^)
2021-09-13 15:23:36 +02:00
},
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"z-index": {
LibWeb: Only invalidate stacking context tree for opacity/z-index change I came across some websites that change an elements CSS "opacity" in their :hover selectors. That caused us to relayout on hover, which we'd like to avoid. With this patch, we now check if a property only affects the stacking context tree, and if nothing layout-affecting has changed, we only invalidate the stacking context tree, causing it to be rebuilt on next paint or hit test. This makes :hover { opacity: ... } rules much faster. :^)
2022-03-21 10:58:51 +01:00
"affects-layout": false,
"affects-stacking-context": true,
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
"inherited": false,
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
"initial": "auto",
"valid-types": [
LibWeb: Add missing value ranges to CSS properties ...except those related to `grid`, because I can't figure out how the 17 different properties interact with each other, and what values apply to which ones. 😅 All but 1 of these are the infinite range `[-∞,∞]`. As such, specifying that range does not change anything, but it does make it explicit that we've looked at what the range should be, instead of just not having added it.
2023-06-02 17:11:41 +01:00
"integer [-∞,∞]"
LibWeb: Add valid-value information to Properties.json
2021-09-22 20:10:01 +01:00
],
"valid-identifiers": [
"auto"
]
LibHTML: Start building a simple code generator for CSS properties Code for parsing and stringifying CSS properties is now generated based on LibHTML/CSS/Properties.json At the moment, the file tells us three things: - The name of a property - Its initial value - Whether it's inherited Also, for shorthand properties, it provides a list of all the longhand properties it may expand too. This is not actually used in the engine yet though. This *finally* makes layout tree dumps show the names of CSS properties in effect, instead of "CSS::PropertyID(32)" and such. :^)
2019-11-18 11:12:58 +01:00
}
}
Reference in a new issue Copy permalink