| Age | Commit message (Collapse) | Author |
|---|
|
Ensure that when a grid item is passed with a span and a fixed end
position, that if the resulting start of this item is less than 0 then
it won't throw. This is a temporary measure until the correct
functionality is implemented.
|
|
Clean up the code by using an OccupationGrid class. This was a neat idea
proposed by MacDue.
|
|
If a span makes a CSS Grid item overflow vertically, then it should be
truncated as done on other web engines.
|
|
For row-constrained items (with a row position defined in the CSS),
should be checking for an available position in that row and not in
another..
|
|
Auto-positioned items should also take into account the span attributes
passed to them.
|
|
These changes improve the parsing of the span property, including
handling negative values for the span (defaults to 1), as well as when
no number is passed (also defaults to 1).
|
|
Use the ident() function instead of to_string() for parsing. Fix this up
in the rect parser as well.
|
|
|
|
After having corrected the tracking of span variables in the
GridTrackPlacement class, now can fix some small bugs for its correct
implementation in the GridFormattingContext class.
|
|
Add some helper functions for checking if a grid-track is
auto-positioned. I think this makes the code more legible.
|
|
Implement span correctly when indicated in the grid-column-start,
grid-row-start, etc. CSS properties. Previously it had been implemented
as if span was something that went alongside the position property, but
actually it seems like if you do 'span 3' in the grid-column-start
property, for example, this means it literally spans 3 blocks, and the
3 has nothing to do with position.
|
|
This fixes something I thought I had already fixed everywhere, where
previously there wasn't the possibility to have an Auto
GridTrackPlacement and so the Auto "implementation" was simply checking
if the position of the track was 0.
|
|
We were skipping over inline flex containers when looking for an
insertion parent. This made us not generate flex items in those cases.
This commit changes the behavior, so that non-inline-level items can
get inserted into an inline-outside parent, as long as the parent isn't
just flow-inside.
|
|
This ensures that the pseudo element wrapper is transformed into a block
container with inline children if needed.
|
|
Now that we don't have to deal with the ad-hoc "inline" flag on layout
nodes anymore, we're free to simply obey the inline-outside flag from
the CSS display value when choosing whether to insert as an inline-level
node or not.
|
|
We were incorrectly caching both ::before and ::after pseudo elements
with the ::before key.
This regressed in 1ab7a8e0dbb5ee5195ab67c7c3f81c7f9f5f3f02.
|
|
We were previously generating an InlineNode, which is not a Box. We need
some type of Box to do flex layout, so let's just make a BlockContainer.
|
|
Before this, whenever encountering something other than dumb text
content in an inline flow, we assumed it had to be either a replaced
element, or an inline-block.
This removes the special-casing of inline-block so that IFC can size and
layout anything as long as it's inline on the outside.
|
|
We can't be capturing the AK::URL by reference here, since on_complete
may be called later, after the value is no longer alive.
|
|
|
|
|
|
|
|
There's no need to make the assumption that any inline-block box will
be represented by a BlockContainer. Nothing we do with the box here
requires that specific type anyway.
|
|
We use comments from MDN here, since the rules for creating a BFC are
inconsistently spread across many different specifications.
|
|
This patch adds a non standard step pushing the realm execution context
of fetching client's settings object onto the execution context stack
before linking a module script. Without the realm execution context
there is no current settings object, leading to a crash in
HostResolveImportedModule.
|
|
This patch adds support for script elements with the type attribute set
to "module". As a first cut the changes are mainly focused around inline
scripts.
Co-authored-by: davidot <davidot@serenityos.org>
|
|
This patch adds support for the HostGetSupportedImportAssertions and
HostResolveImportedModule host hooks.
Co-authored-by: davidot <davidot@serenityos.org>
|
|
This patch adds various algorithms required to fetch and link module
scripts.
Some parts such as actually creating a request and error handling are
not implemented or use temporary non spec compliant code to get us
further.
Co-authored-by: davidot <davidot@serenityos.org>
|
|
This patchs adds the Web::HTML::Script subclass ModuleScript and
JavaScriptModuleScript as a type of ModuleScript as well as various
algorithms related to JavaScript module scripts.
Co-authored-by: davidot <davidot@serenityos.org>
|
|
This patch adds the ModuleMap class used to keep track of the type and
url of a module as well as the fetching state associated. Each
environment settings object now also has a module map.
|
|
This patch adds support for all child classes of Web::HTML::Script to be
used in the [[HostDefined]] field of JS::Modules and JS::Scripts.
|
|
This patch adds the module type allowed steps given a module type string
and an environment settings object.
|
|
Previously we would simply check the an input string against a list of
mime type essences, ignoring that the input might not be a valid mime
type or contain parameters.
This patch moves the helpers into the MimeSniff namespace and properly
parses an input string before comparing the essence.
|
|
This is a more correct check than !is_inline_block(), as it now enters
all elements that have inline behavior on the outside and flow behavior
on the inside.
|
|
|
|
This will return something sensible for style-less nodes as well.
|
|
Now that this flag is no longer used, we can stop setting it.
|
|
This is weird, but matches the behavior we've had so far. Leaving a
FIXME about how this doesn't seem right.
|
|
This element is already covered by spec rules. :^)
|
|
Since all the spec sections are annotated with comments already, let's
also have a comment mentioning that the file starts with ad-hoc rules.
|
|
These were totally ad-hoc before, is_inline() was based on a boolean
flag on Layout::Node that we set in various situations.
Meanwhile, is_inline_block() was a combination on is_inline() plus a
type check to see if the layout node inherited from BlockContainer.
This patch replaces the above mess with simple lookups of the CSS
display value. Note that layout nodes without their own style (i.e text
nodes) are automatically assumed to be inline and non-blocks. This has
to be special-cased since layout nodes without style will consult the
style of their parent, so without short-circuiting this would break.
|
|
This is one of many small steps towards being able to remove the ad-hoc
Layout::Node::is_inline() in favor of honoring the CSS display value
everywhere instead.
|
|
Let create_pseudo_element_if_needed() take care of inserting the pseudo
elements into the layout tree as well.
|
|
Let's make this function a little easier to understand by splitting out
helpers into separate functions.
|
|
We always create a Layout::InitialContainingBlock for the ICB, but in a
future where we always honor the CSS::Display everywhere, we need to
make sure everyone has the right display values.
|
|
With the addition of the 'fetch params' struct, the single ownership
model we had so far falls apart completely.
Additionally, this works nicely for FilteredResponse's internal response
instead of risking a dangling reference.
Replacing the public constructor with a create() function also found a
few instances of a Request being stack-allocated!
|
|
|
|
|
|
|
|
|
