Confirm
489
edits
Changes
→Layout: various terminology updates and clarifications.
type hierarchy, but the type hierarchy is very different: it includes
types like text frames, blocks and inlines, the various parts of tables,
flex and grid containers, and the various types of HTML form controls.
Frames are allocated within an arena owned by the pres shellPresShell. Each
frame is owned by its parent; frames are not reference counted, and code
must not hold on to pointers to frames. To mitigate potential security
Like the content tree, frames must be accessed only from the UI thread.
The frame tree should not store any important data, i.e. any data that cannotbe recomputed on-the-fly. While it the frame tree does
usually persist while a page is being displayed, frames are often
destroyed and recreated in response to certain style changes, and in the
In addition to tracking a rectangle, frames also track two overflow
areas: visual ink overflow and scrollable overflow. These overflow areas
represent the union of the area needed by the frame and by all its
descendants. The visual ink overflow is used for painting-related
optimizations: it is a rectangle covering all of the area that might be
painted when the frame and all of its descendants paint. The scrollable
characteristic of the frame itself. The two overflow areas are
similar, but there are differences: for example, margins are part of
scrollable overflow but not visual ink overflow, whereas text-shadows arepart of visual ink overflow but not scrollable overflow.
When frames are broken across lines, columns, or pages, we create
at some point want to break that invariant.)
Continuations are sometimes siblings of each other(i.e.nsIFrame::GetNextContinuation and nsIFrame::GetNextSibling might returnthe same frame), and sometimes not.
For example, if a paragraph contains a span which contains a link, and
the link is split across lines, then the continuations of the span are
continuations of the link are not siblings (since each continuation of
the link is descended from a different continuation of the span).
Traversing the entire frame tree does '''not''' require consideringexplicit traversalof any frames' continuations-list, since all of the continuations are descendants of theelement containing the break.
We also use continuations for cases (most importantly, bidi reordering,
If an inline frame has non-inline children, then we split the original
inline frame into parts. The original inline's children are
distributed into these parts like so- : The children of the original inline are grouped into runs of inline and non-inline , and runs of inline get an inline parent , while runs of non-inline get an anonymous block parent. This is We call this 'ib-splitting' or 'block-inside-inline-splitting'.
This splitting proceeds recursively up the frame tree until all
non-inlines inside inlines are ancestors of a block frame with anonymous
block wrappers in between. This splitting maintains the relative order
between these child frames , and the relationship between the parts of a
split inline is maintained using an ib-sibling chain. It is important
to note that any wrappers created during frame construction (such as
for tables) may might not be included in the ib-sibling chain depending on
when this wrapper creation takes place.
