| Age | Commit message (Collapse) | Author |
|---|
|
|
|
An image document is the synthetic DOM::Document we create to wrap an
image when you open the URL of an image directly in a web view.
The path that creates these documents will now also call out to the
separate ImageDecoder process for the actual decoding work.
|
|
This will allow us to use it in more places around LibWeb.
|
|
Some of the code has been slightly rearranged to match the spec order,
but otherwise I've tried not to mess with it.
|
|
Again, this value does not change once we have finished creating the
Token, so it can be more lightweight.
|
|
This value doesn't change once it's assigned to the Token, so it can be
more lightweight than a StringBuilder.
|
|
The Parser no longer needs to mess with Token's internals, since we have
getter functions that are safer.
|
|
If `12.34%` ever produces a Dimension token instead of a Percentage,
then something has gone wrong and we want to know about it!
|
|
This lets us get rid of `try_parse_float()`, and simplifies the various
places we were calling it before.
|
|
This saves user code from having to parse the numbers, as we already did
that while Tokenizing. :^)
As a bonus, we now round extremely large integers to the closest
available value, like the spec tells us to.
|
|
The spec wants us to produce numeric values as the Tokenizer sees them,
rather than waiting until the parse stage. This is a first step towards
that.
|
|
|
|
Browsing contexts are defined by the HTML specification, so let's move
them into the HTML directory. :^)
|
|
All CSS loading is now done by the relevant classes:
- CSSImportRule, which loads its linked stylesheet
- HTMLStyleElement, which "loads" its contents
- HTMLLinkElement, which loads its linked stylesheet
|
|
This is the last use of CSSLoader, which can now be deleted.
|
|
This was only used for making sure `@import` rules got loaded, and since
they handle that themselves now, we can get rid of all this code!
|
|
Now that `@import` rules load themselves, we don't want to also load
them here.
|
|
The changes in commit d462a6720afe721b6821ce14d5b7802d1890b61f meant
that `CSSLoader::load_next_import_if_needed()` was no longer being
called, so no `@import` rules were loading.
The spec does not seem to mention when that loading should take place,
but WebKit does this at parse time, as each rule is added to the style
sheet. If it works for them, it's probably not that bad. :^)
So, that's what we now do here. The `CSSImportRule` creates a fetch
request when it is constructed, so each one is responsible for its own
contents.
|
|
|
|
|
|
This is including the `cover` and `contain` modes.
|
|
|
|
This was causing inputs like `0% 0%` to think only one value was
provided.
|
|
This reimplements image tiling instead of using `Painter::blit_tiled()`,
so that we will be able to handle CSS's more complicated repetition
rules. (Like `background-repeat: space`) Otherwise this does the same as
before. :^)
|
|
We now pass in the Layout Node so that we can read the BoxModelMetrics.
Renamed a couple of variables too for clarity.
|
|
All of this is now passed along to `paint_background()`. :^)
(As always, "all" excludes the background-color since that's not a layer
property.)
|
|
We now entirely use the background-layers to check images.
|
|
These aren't needed now that we render using background_layers instead.
The one casualty is the resolved style for background-repeat, but that
was incorrect anyway.
|
|
|
|
Instead of storing these as individual `background-foo` properties, we
combine them together into layers, since that is how they will be
painted. It also makes it more convenient to pass them around.
|
|
Previously, a `background-repeat` value of `no-repeat` in a direction
would cause the image to be drawn at exactly that size. This was fine if
the image was smaller than the element, but if it was larger, it would
draw outside its bounds. Now, it behaves itself. :^)
|
|
This actually involves doing *less*, because we now just pass the
StyleValueLists through instead of needing to grab their first layer's
value. :^)
|
|
This now outputs valid CSS representing the background, instead of
confusing debug info.
We can't guarantee that all the longhands have the same number of
values, since while that's always the case when parsing, we also create
BackgroundStyleValues when producing the resolved style, which just
combines the longhands together.
|
|
Like the `background-foo` longhand properties (except
`background-color`), `background` allows multiple layers to be defined,
separated by commas. A layer does not necessarily contain something to
actually draw!
This parses as a `BackgroundStyleValue`, holding a `StyleValueList` for
each property. This is mostly to make expansion into longhands simpler -
if we had a list of `BackgroundStyleValue`s instead, one per layer, then
we would have to break it up per-property anyway when computing styles.
|
|
We now can parse lists of values for these properties:
- `background-attachment`
- `background-clip`
- `background-image`
- `background-origin`
- `background-position`
- `background-repeat`
- `background-size`
This uses two new Parser methods:
`parse_simple_comma_separated_value_list()` for the simple case when
each value is parsed from a single token; and
`parse_comma_separated_value_list()` which takes a lambda for when
parsing each value is more involved.
This also means that any unconsumed tokens at the end will make the
parsing fail as it should, where previously we just ignored them.
|
|
This was leading to confusing bugs where I was accidentally passing it
by value and then wondering why tokens weren't getting consumed!
|
|
These are just clutter. Only one was ever used, in one place, and is
easily replaced by just passing `m_token_stream` to it.
|
|
This was only needed when they were all static.
|
|
Past me thought making as much static as possible was a good idea, but
it just makes things more verbose, and awkward if anything isn't also
static.
|
|
|
|
This isn't a complete conversion to ErrorOr<void>, but a good chunk.
The end goal here is to propagate buffer allocation failures to the
caller, and allow the use of TRY() with formatting functions.
|
|
Also add slightly richer parse errors now that we can include a string
literal with returned errors.
This will allow us to use TRY() when working with JSON data.
|
|
|
|
...and make sure to validate the module in WebAssembly::compile()
|
|
|
|
Preparation for using Error.h from Vector.h. This required moving some
things out of line.
|
|
The finale! Users can now be sure that the value is valid, which makes
things simpler.
|
|
This is the initial value for `transform`. We already handle the value
later, we just were not parsing it.
|
|
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! :^)
|
|
There is no specified initial value, but `transparent` is equivalent to
setting all the background properties to their defaults.
|
