| AnonymousContentKey.h |
values to identify particular subtrees of native anonymous content |
1731 |
| AspectRatio.cpp |
|
1418 |
| AspectRatio.h |
The aspect ratio of a box, in a "width / height" format. |
5523 |
| AutoCopyListener.h |
OnSelectionChange() is called when a Selection whose NotifyAutoCopy() was
called is changed.
@param aDocument The document of the Selection. May be nullptr.
@param aSelection The selection.
@param aReason The reasons of the change.
See nsISelectionListener::*_REASON.
|
1800 |
| BlockReflowState.cpp |
state used in reflow of block frames |
44284 |
| BlockReflowState.h |
state used in reflow of block frames |
17119 |
| BRFrame.cpp |
rendering object for HTML <br> elements |
9110 |
| broken-image.png |
|
160 |
| ColumnSetWrapperFrame.cpp |
|
12567 |
| ColumnSetWrapperFrame.h |
|
3292 |
| ColumnUtils.cpp |
A namespace class for static muti-column utilities. |
1662 |
| ColumnUtils.h |
A namespace class for static muti-column utilities. |
1342 |
| crashtests |
|
|
| CSSAlignUtils.cpp |
Utility code for performing CSS Box Alignment |
6276 |
| CSSAlignUtils.h |
Utility code for performing CSS Box Alignment |
2835 |
| CSSOrderAwareFrameIterator.cpp |
Iterator class for frame lists that respect CSS "order" during layout |
2550 |
| CSSOrderAwareFrameIterator.h |
Iterator class for frame lists that respect CSS "order" during layout |
9030 |
| folder.png |
|
529 |
| frame-graph.py |
Take the *.framedata files from graph-frameclasses.js and combine them
into a single graphviz file.
stdin: a list of .framedata file names (e.g. from xargs)
stdout: a graphviz file
e.g. `find <objdir> -name "*.framedata" | python aggregate-frameclasses.py |
dot -Tpng -o frameclasses-graph.png -`
|
1070 |
| FrameClass.py |
|
593 |
| FrameClasses.py |
|
10356 |
| GenerateFrameLists.py |
|
1645 |
| jar.mn |
|
271 |
| JustificationUtils.h |
Jutification Algorithm
The justification algorithm is based on expansion opportunities
between justifiable clusters. By this algorithm, there is one
expansion opportunity at each side of a justifiable cluster, and
at most one opportunity between two clusters. For example, if there
is a line in a Chinese document is: "你好世界hello world", then
the expansion opportunities (marked as '*') would be:
你*好*世*界*hello*' '*world
The spacing left in a line will then be distributed equally to each
opportunities. Because we want that, only justifiable clusters get
expanded, and the split point between two justifiable clusters would
be at the middle of the spacing, each expansion opportunities will be
filled by two justification gaps. The example above would be:
你 | 好 | 世 | 界 |hello| ' ' |world
In the algorithm, information about expansion opportunities is stored
in structure JustificationInfo, and the assignment of justification
gaps is in structure JustificationAssignment.
|
4385 |
| LayoutMessageUtils.h |
|
1683 |
| MathMLTextRunFactory.cpp |
Entries for the mathvariant lookup tables. mKey represents the Unicode
character to be transformed and is used for searching the tables.
mReplacement represents the mapped mathvariant Unicode character.
|
26323 |
| MathMLTextRunFactory.h |
Builds textruns that render their text with MathML specific renderings.
|
1731 |
| MiddleCroppingBlockFrame.cpp |
aIsCropped = |
7292 |
| MiddleCroppingBlockFrame.h |
Crop aText to fit inside aWidth using the styles of aFrame.
@return true if aText was modified
|
2184 |
| moz.build |
|
7834 |
| nsAbsoluteContainingBlock.cpp |
code for managing absolutely positioned children of a rendering
object that is a containing block for them
|
44758 |
| nsAbsoluteContainingBlock.h |
code for managing absolutely positioned children of a rendering
object that is a containing block for them
|
7363 |
| nsAtomicContainerFrame.h |
base class for rendering objects that need child lists but behave like leaf
|
1701 |
| nsBackdropFrame.cpp |
rendering object for CSS "::backdrop" |
3284 |
| nsBackdropFrame.h |
rendering object for CSS "::backdrop" |
1623 |
| nsBlockDebugFlags.h |
|
1309 |
| nsBlockFrame.cpp |
rendering object for CSS display:block, inline-block, and list-item
boxes, also used for various anonymous boxes
|
349885 |
| nsBlockFrame.h |
rendering object for CSS display:block, inline-block, and list-item
boxes, also used for various anonymous boxes
|
44421 |
| nsBlockReflowContext.cpp |
class that a parent frame uses to reflow a block frame |
17879 |
| nsBlockReflowContext.h |
class that a parent frame uses to reflow a block frame |
3516 |
| nsCanvasFrame.cpp |
rendering object that goes directly inside the document's scrollbars |
33664 |
| nsCanvasFrame.h |
rendering object that goes directly inside the document's scrollbars |
7130 |
| nsColumnSetFrame.cpp |
rendering object for css3 multi-column layout |
57455 |
| nsColumnSetFrame.h |
rendering object for css3 multi-column layout |
8207 |
| nsContainerFrame.cpp |
base class #1 for rendering objects that have child lists |
123030 |
| nsContainerFrame.h |
base class #1 for rendering objects that have child lists |
47675 |
| nsContainerFrameInlines.h |
|
3872 |
| nsDirection.h |
|
628 |
| nsFirstLetterFrame.cpp |
rendering object for CSS :first-letter pseudo-element |
20296 |
| nsFirstLetterFrame.h |
rendering object for CSS :first-letter pseudo-element |
4352 |
| nsFlexContainerFrame.cpp |
rendering object for CSS "display: flex" |
291095 |
| nsFlexContainerFrame.h |
rendering object for CSS "display: flex" and "display: -webkit-box" |
30972 |
| nsFloatManager.cpp |
class that manages rules for positioning floats |
128263 |
| nsFloatManager.h |
class that manages rules for positioning floats |
18659 |
| nsFontInflationData.cpp |
Per-block-formatting-context manager of font size inflation for pan and zoom
UI. |
14053 |
| nsFontInflationData.h |
Per-block-formatting-context manager of font size inflation for pan and zoom
UI. |
2328 |
| nsFrameList.cpp |
|
14795 |
| nsFrameList.h |
for FILE* |
15540 |
| nsFrameSelection.cpp |
Implementation of nsFrameSelection
|
117058 |
| nsFrameSelection.h |
PeekOffsetStruct is used to group various arguments (both input and output)
that are passed to nsIFrame::PeekOffset(). See below for the description of
individual arguments.
|
44285 |
| nsFrameSetFrame.cpp |
rendering object for HTML <frameset> elements |
54781 |
| nsFrameSetFrame.h |
rendering object for HTML <frameset> elements |
6645 |
| nsFrameState.cpp |
constants for frame state bits and a type to store them in a uint64_t |
3930 |
| nsFrameState.h |
constants for frame state bits and a type to store them in a uint64_t |
2207 |
| nsFrameStateBits.h |
a list of all frame state bits, for preprocessing |
31597 |
| nsGridContainerFrame.cpp |
rendering object for CSS "display: grid | inline-grid" |
431391 |
| nsGridContainerFrame.h |
rendering object for CSS "display: grid | inline-grid" |
26381 |
| nsHTMLCanvasFrame.cpp |
rendering object for the HTML <canvas> element |
20055 |
| nsHTMLCanvasFrame.h |
rendering object for the HTML <canvas> element |
3270 |
| nsHTMLParts.h |
factory functions for rendering object classes |
9147 |
| nsIAnonymousContentCreator.h |
interface for rendering objects that manually create subtrees of
anonymous content
|
2374 |
| nsIFrame.cpp |
base class of all rendering objects |
459486 |
| nsIFrame.h |
interface for all rendering objects |
226407 |
| nsIFrameInlines.h |
|
6532 |
| nsILineIterator.cpp |
|
2446 |
| nsILineIterator.h |
Line iterator API.
Lines are numbered from 0 to N, where 0 is the top line and N is
the bottom line.
Obtain this interface from frames via nsIFrame::GetLineIterator.
This iterator belongs to the frame from which it was obtained, and should
not be deleted by the caller.
Note that any modification of the frame will invalidate the iterator!
Users must get a new iterator any time the target may have been touched.
|
4551 |
| nsImageFrame.cpp |
rendering object for replaced elements with image data |
103390 |
| nsImageFrame.h |
rendering object for replaced elements with image data |
15830 |
| nsImageMap.cpp |
code for HTML client-side image maps |
25864 |
| nsImageMap.h |
code for HTML client-side image maps |
3121 |
| nsInlineFrame.cpp |
rendering object for CSS display:inline objects |
41212 |
| nsInlineFrame.h |
rendering object for CSS display:inline objects |
7533 |
| nsIntervalSet.cpp |
a set of ranges on a number-line |
2427 |
| nsIntervalSet.h |
a set of ranges on a number-line |
1931 |
| nsIScrollPositionListener.h |
Provides a way to learn about scroll position changes of
ScrollContainerFrame's.
|
751 |
| nsIStatefulFrame.h |
interface for rendering objects whose state is saved in
session-history (back-forward navigation)
|
1231 |
| nsLeafFrame.cpp |
base class for rendering objects that do not have child lists |
1555 |
| nsLeafFrame.h |
base class for rendering objects that do not have child lists |
1865 |
| nsLineBox.cpp |
representation of one line within a block frame, a CSS line box |
21411 |
| nsLineBox.h |
representation of one line within a block frame, a CSS line box |
35650 |
| nsLineLayout.cpp |
state and methods used while laying out a single line of a block frame |
137109 |
| nsLineLayout.h |
state and methods used while laying out a single line of a block frame |
26021 |
| nsPageContentFrame.cpp |
|
18818 |
| nsPageContentFrame.h |
Return our canvas frame.
|
2412 |
| nsPageFrame.cpp |
|
43714 |
| nsPageFrame.h |
|
6753 |
| nsPageSequenceFrame.cpp |
Members are: {mNumPages, mLargerNumTracks} |
29842 |
| nsPageSequenceFrame.h |
This class maintains various shared data that is used by printing-related
frames. The nsPageSequenceFrame strongly owns an instance of this class,
which lives for as long as the nsPageSequenceFrame does.
|
6951 |
| nsPlaceholderFrame.cpp |
rendering object for the point that anchors out-of-flow rendering
objects such as floats and absolutely positioned elements
|
8636 |
| nsPlaceholderFrame.h |
rendering object for the point that anchors out-of-flow rendering
objects such as floats and absolutely positioned elements
|
7181 |
| nsQueryFrame.h |
|
6783 |
| nsRubyBaseContainerFrame.cpp |
rendering object for CSS "display: ruby-base-container" |
33231 |
| nsRubyBaseContainerFrame.h |
rendering object for CSS "display: ruby-base-container" |
3548 |
| nsRubyBaseFrame.cpp |
rendering object for CSS "display: ruby-base" |
1415 |
| nsRubyBaseFrame.h |
rendering object for CSS "display: ruby-base" |
1331 |
| nsRubyContentFrame.cpp |
base class for ruby rendering objects that directly contain content |
1045 |
| nsRubyContentFrame.h |
base class for ruby rendering objects that directly contain content |
1155 |
| nsRubyFrame.cpp |
rendering object for CSS "display: ruby" |
17399 |
| nsRubyFrame.h |
rendering object for CSS "display: ruby" |
2413 |
| nsRubyTextContainerFrame.cpp |
rendering object for CSS "display: ruby-text-container" |
6273 |
| nsRubyTextContainerFrame.h |
rendering object for CSS "display: ruby-text-container" |
2547 |
| nsRubyTextFrame.cpp |
rendering object for CSS "display: ruby-text" |
2792 |
| nsRubyTextFrame.h |
rendering object for CSS "display: ruby-text" |
1759 |
| nsSplittableFrame.cpp |
base class for rendering objects that can be split across lines,
columns, or pages
|
12101 |
| nsSplittableFrame.h |
base class for rendering objects that can be split across lines,
columns, or pages
|
6424 |
| nsSubDocumentFrame.cpp |
rendering object for replaced elements that contain a document, such
as <frame>, <iframe>, and some <object>s
|
48649 |
| nsSubDocumentFrame.h |
nsSubDocumentFrame
*************************************************************************** |
7879 |
| nsTextFrame.cpp |
rendering object for textual content of elements |
421724 |
| nsTextFrame.h |
An implementation of gfxTextRun::PropertyProvider that computes spacing and
hyphenation based on CSS properties for a text frame.
|
45755 |
| nsTextFrameUtils.cpp |
static |
15383 |
| nsTextFrameUtils.h |
Returns true if aChars/aLength are something that make a space
character not be whitespace when they follow the space character
(combining mark or join control, ignoring intervening direction
controls).
|
7298 |
| nsTextPaintStyle.cpp |
|
21797 |
| nsTextPaintStyle.h |
This helper object computes colors used for painting, and also IME
underline information. The data is computed lazily and cached as necessary.
These live for just the duration of one paint operation.
|
6133 |
| nsTextRunTransformations.cpp |
|
39562 |
| nsTextRunTransformations.h |
Builds textruns that transform the text in some way (e.g., capitalize)
and then render the text using some other textrun implementation.
This factory also supports "text-security" transforms that convert all
characters to a single symbol.
|
11154 |
| nsVideoFrame.cpp |
rendering object for the HTML <video> element |
26178 |
| nsVideoFrame.h |
rendering object for the HTML <video> element |
5279 |
| PrintedSheetFrame.cpp |
Rendering object for a printed or print-previewed sheet of paper |
17801 |
| PrintedSheetFrame.h |
Rendering object for a printed or print-previewed sheet of paper |
6074 |
| ReflowInput.cpp |
struct containing the input to nsIFrame::Reflow |
129798 |
| ReflowInput.h |
struct containing the input to nsIFrame::Reflow |
41349 |
| ReflowOutput.cpp |
struct containing the output from nsIFrame::Reflow |
3215 |
| ReflowOutput.h |
struct containing the output from nsIFrame::Reflow |
9861 |
| RubyUtils.cpp |
static |
7022 |
| RubyUtils.h |
Reserved ISize
With some exceptions, each ruby internal box has two isizes, which
are the reflowed isize and the final isize. The reflowed isize is
what a box itself needs. It is determined when the box gets reflowed.
The final isize is what a box should be as the final result. For a
ruby base/text box, the final isize is the size of its ruby column.
For a ruby base/text container, the final isize is the size of its
ruby segment. The final isize is never smaller than the reflowed
isize. It is initially determined when a ruby column/segment gets
fully reflowed, and may be advanced when a box is expanded, e.g.
for justification.
The difference between the reflowed isize and the final isize is
reserved in the line layout after reflowing a box, hence it is called
"Reserved ISize" here. It is used to expand the ruby boxes from their
reflowed isize to the final isize during alignment of the line.
There are three exceptions for the final isize:
1. A ruby text container has a larger final isize only if it is for
a span or collapsed annotations.
2. A ruby base container has a larger final isize only if at least
one of its ruby text containers does.
3. If a ruby text container has a larger final isize, its children
must not have.
|
7362 |
| ScrollAnchorContainer.cpp |
Set the appropriate frame flags for a frame that has become or is no longer
an anchor node.
|
30274 |
| ScrollAnchorContainer.h |
A scroll anchor container finds a descendent element of a scroll container
frame to be an anchor node. After every reflow, the scroll anchor will apply
scroll adjustments to keep the anchor node in the same relative position.
See: https://drafts.csswg.org/css-scroll-anchoring/
|
6783 |
| ScrollAnimationBezierPhysics.cpp |
|
6063 |
| ScrollAnimationBezierPhysics.h |
|
3507 |
| ScrollAnimationMSDPhysics.cpp |
|
6951 |
| ScrollAnimationMSDPhysics.h |
|
2495 |
| ScrollAnimationPhysics.h |
|
2392 |
| ScrollbarActivity.cpp |
|
5311 |
| ScrollbarActivity.h |
ScrollbarActivity
This class manages scrollbar behavior that imitates the native Mac OS X
Lion overlay scrollbar behavior: Scrollbars are only shown while "scrollbar
activity" occurs, and they're hidden with a fade animation after a short
delay.
Scrollbar activity has these states:
- inactive:
Scrollbars are hidden.
- ongoing activity:
Scrollbars are visible and being operated on in some way, for example
because they're hovered or pressed.
- active, but waiting for fade out
Scrollbars are still completely visible but are about to fade away.
- fading out
Scrollbars are subject to a fade-out animation.
Initial scrollbar activity needs to be reported by the scrollbar holder that
owns the ScrollbarActivity instance. This needs to happen via a call to
ActivityOccurred(), for example when the current scroll position or the size
of the scroll area changes.
As soon as scrollbars are visible, the ScrollbarActivity class manages the
rest of the activity behavior: It ensures that mouse motions inside the
scroll area keep the scrollbars visible, and that scrollbars don't fade away
while they're being hovered / dragged. It also sets a sticky hover attribute
on the most recently hovered scrollbar.
ScrollbarActivity falls into hibernation after the scrollbars have faded
out. It only starts acting after the next call to ActivityOccurred() /
ActivityStarted().
|
3468 |
| ScrollbarPreferences.h |
|
559 |
| ScrollContainerFrame.cpp |
rendering object to wrap rendering objects that should be scrollable |
321231 |
| ScrollContainerFrame.h |
rendering object to wrap rendering objects that should be scrollable |
61475 |
| ScrollGeneration.cpp |
|
1433 |
| ScrollGeneration.h |
|
1926 |
| ScrollOrigin.h |
|
3041 |
| ScrollPositionUpdate.cpp |
static |
4854 |
| ScrollPositionUpdate.h |
This class represents an update to the scroll position that is initiated by
something on the main thread. A list of these classes is accumulated by
scrollframes on the main thread, and the list is sent over as part of a
paint transaction to the compositor. The compositor can then iterate through
the scroll updates and apply/merge them with scrolling that has already
occurred independently on the compositor side.
|
5439 |
| ScrollSnap.cpp |
Keeps track of the current best edge to snap to. The criteria for
adding an edge depends on the scrolling unit.
|
34917 |
| ScrollSnap.h |
GetSnapPointForDestination determines which point to snap to after
scrolling. |aStartPos| gives the position before scrolling and
|aDestination| gives the position after scrolling, with no snapping.
Behaviour is dependent on the value of |aUnit|.
|aSnapInfo| and |aScrollRange| are characteristics of the scroll frame for
which snapping is being performed.
If a suitable snap point could be found, it is returned. Otherwise, an
empty Maybe is returned.
IMPORTANT NOTE: This function is designed to be called both on and off
the main thread. If modifying its implementation, be sure
not to touch main-thread-only data structures without
appropriate locking.
|
3918 |
| ScrollSnapInfo.cpp |
|
3643 |
| ScrollSnapInfo.h |
|
5433 |
| ScrollSnapTargetId.h |
|
1151 |
| ScrollVelocityQueue.cpp |
Calculate the velocity of the scroll frame, in appunits / second.
|
2937 |
| ScrollVelocityQueue.h |
ScrollVelocityQueue is used to determine the current velocity of a
scroll frame, derived from scroll position samples.
Using the last iteration's scroll position, stored in mLastPosition, a
delta of the scroll position is calculated and accumulated in mAccumulator
until the refresh driver returns a new timestamp for MostRecentRefresh().
When there is a new timestamp from the refresh driver, the accumulated
change in scroll position is divided by the delta of the timestamp to
get an average velocity over that period. This velocity is pushed into
mQueue as a std::pair associating each velocity with the
duration over which it was sampled.
Samples are removed from mQueue, leaving only those necessary to determine
the average velocity over the recent relevant period, which has a duration
set by the apz.velocity_relevance_time_ms preference.
The velocity of each sample is clamped to a value set by the
layout.css.scroll-snap.prediction-max-velocity.
As the average velocity will later be integrated over a duration set by
the layout.css.scroll-snap.prediction-sensitivity preference and the
velocity samples are clamped to a set value, the maximum expected scroll
offset can be calculated. This maximum offset is used to clamp
mAccumulator, eliminating samples that would otherwise result in scroll
snap position selection that is not consistent with the user's perception
of scroll velocity.
|
3488 |
| SelectionMovementUtils.cpp |
|
26983 |
| SelectionMovementUtils.h |
@brief Creates a new `RangeBoundary` which moves `aAmount` into
`aDirection` from the input range boundary.
@param aRangeBoundary The input range boundary.
@param aDirection The direction into which the new boundary should be
moved.
@param aHint The `CaretAssociationHint` (is the caret before or
after the boundary point)
@param aCaretBidiLevel The `BidiEmbeddingLevel`.
@param aAmount The amount which the range boundary should be
moved.
@param aOptions Additional options, see `PeekOffsetOption`.
@param aAncestorLimiter The content node that limits where Selection may be
expanded to.
@return Returns a new `RangeBoundary` which is moved from `aRangeBoundary`
by `aAmount` into `aDirection`.
|
8221 |
| StickyScrollContainer.cpp |
compute sticky positioning, both during reflow and when the scrolling
container scrolls
|
15843 |
| StickyScrollContainer.h |
compute sticky positioning, both during reflow and when the scrolling
container scrolls
|
3816 |
| test |
|
|
| TextDrawTarget.h |
|
24126 |
| TextOverflow.cpp |
|
36194 |
| TextOverflow.h |
A class for rendering CSS3 text-overflow.
Usage:
1. allocate an object using WillProcessLines
2. then call ProcessLine for each line you are building display lists for
Note that this class is non-reassignable; we don't want to be making
arbitrary copies. (But we do have a move constructor, since that's required
in order to be stored in Maybe<>).
|
13391 |
| ViewportFrame.cpp |
rendering object that is the root of the frame tree, which contains
the document's scrollbars and contains fixed-positioned elements
|
19015 |
| ViewportFrame.h |
rendering object that is the root of the frame tree, which contains
contains fixed-positioned elements
|
4209 |
| Visibility.h |
Declares visibility-related types. @Visibility is an enumeration of the
possible visibility states of a frame. @OnNonvisible is an enumeration that
allows callers to request a specific action when a frame transitions from
visible to nonvisible.
|
1750 |
| WBRFrame.cpp |
rendering object for HTML <wbr> elements |
2537 |
| WritingModes.h |
mozilla::WritingMode is an immutable class representing a
writing mode.
It efficiently stores the writing mode and can rapidly compute
interesting things about it for use in layout.
Writing modes are computed from the CSS 'direction',
'writing-mode', and 'text-orientation' properties.
See CSS3 Writing Modes for more information
http://www.w3.org/TR/css3-writing-modes/
|
72709 |
