| blob | 370aaaff05d83b08cd43afb02e73a81250684a9e |
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 /*
8 * rendering object for CSS display:block, inline-block, and list-item
9 * boxes, also used for various anonymous boxes
10 */
50 #include <algorithm>
69 #include <inttypes.h>
87 }
88 }
90 }
91 }
99 }
101 }
103 // Mark every line at and below the line where the float was
104 // dirty, and mark their lines dirty too. We could probably do
105 // something more efficient --- e.g., just dirty the lines that intersect
106 // the float vertically.
108 }
110 /**
111 * Returns true if aFrame is a block that has one or more float children.
112 */
117 }
120 }
125 }
126 }
128 }
130 /**
131 * Determines whether the given frame is visible or has
132 * visible children that participate in the same line. Frames
133 * that are not line participants do not have their
134 * children checked.
135 */
141 }
148 }
149 }
150 }
152 }
154 /**
155 * Determines whether any of the frames descended from the
156 * given line have inline content with 'visibility: visible'.
157 * This function calls FrameHasVisibleInlineContent to process
158 * each frame in the line's child list.
159 */
166 }
169 }
172 }
174 /**
175 * Iterates through the frame's in-flow children and
176 * unions the ink overflow of all text frames which
177 * participate in the line aFrame belongs to.
178 * If a child of aFrame is not a text frame,
179 * we recurse with the child as the aFrame argument.
180 * If aFrame isn't a line participant, we skip it entirely
181 * and return an empty rect.
182 * The resulting nsRect is offset relative to the parent of aFrame.
183 */
186 nsRect textArea;
190 }
195 }
196 }
197 // add aFrame's position to keep textArea relative to aFrame's parent
199 }
201 /**
202 * Iterates through the line's children and
203 * unions the ink overflow of all text frames.
204 * GetFrameTextArea unions and returns the ink overflow
205 * from all line-participating text frames within the given child.
206 * The nsRect returned from GetLineTextArea is offset
207 * relative to the given line.
208 */
211 nsRect textArea;
218 }
221 }
223 /**
224 * Starting with aFrame, iterates upward through parent frames and checks for
225 * non-transparent background colors. If one is found, we use that as our
226 * backplate color. Otheriwse, we use the default background color from
227 * our high contrast theme.
228 */
233 // NOTE(emilio): We assume themed frames (frame->IsThemed()) have correct
234 // background-color information so as to compute the right backplate color.
235 //
236 // This holds because HTML widgets with author-specified backgrounds or
237 // borders disable theming. So as long as the UA-specified background colors
238 // match the actual theme (which they should because we always use system
239 // colors with the non-native theme, and native system colors should also
240 // match the native theme), then we're alright and we should compute an
241 // appropriate backplate color.
245 }
251 }
253 // Even if there's a background image, if there's no background color we
254 // keep going up the frame tree, see bug 1723938.
256 }
258 // Try to avoid somewhat expensive math in the common case.
261 currentBackgroundColor =
263 }
265 // If fully opaque, we're done, otherwise keep going up blending with our
266 // background.
268 }
269 }
273 }
275 }
277 #ifdef DEBUG
296 };
308 };
309 # define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
317 }
320 }
333 }
345 }
346 }
349 }
353 }
356 }
359 }
360 }
361 }
362 }
364 #endif
366 //----------------------------------------------------------------------
368 // Debugging support code
370 #ifdef DEBUG
373 };
390 }
392 }
394 #endif
396 #ifdef REFLOW_STATUS_COVERAGE
401 // 0: child-is-block
402 // 1: child-is-inline
406 }
408 // Compute new status
417 }
422 }
424 // Log updates to the status that yield different values
428 }
429 }
430 #endif
440 //----------------------------------------------------------------------
444 }
451 }
461 // Add the size of any nsLineBox::mFrames hashtables we might have:
464 }
471 }
472 }
473 }
486 }
488 // destroy overflow lines now
494 }
500 }
505 }
508 }
510 /* virtual */
518 }
520 }
526 #ifdef DEBUG_FRAME_DUMP
529 nsCString str;
537 // Output the lines
542 }
543 }
545 // Output the overflow lines.
556 }
558 }
560 // skip the principal list - we printed the lines above
561 // skip the overflow list - we printed the overflow lines above
566 }
570 }
571 #endif
580 }
582 }
592 }
594 aRebuildDisplayItems);
595 }
600 }
605 BaselineSharingGroup aBaselineGroup,
614 // XXX Is this the right test? We have some bogus empty lines
615 // floating around, but IsEmpty is perhaps too weak.
620 }
622 }
624 }
628 }
631 // `<table>` in inline-block context does not export any baseline.
633 }
642 }
646 }
647 // Ignore relative positioning for baseline calculations.
652 }
654 }
656 }
663 }
667 aExportContext);
668 }
671 aExportContext);
672 }
683 }
685 }
686 }
697 }
699 /////////////////////////////////////////////////////////////////////////////
700 // Child frame enumeration
709 }
715 }
719 }
723 }
726 }
727 }
734 }
738 }
743 }
747 }
748 }
750 /* virtual */
753 /**
754 * Remove the first line from aFromLines and adjust the associated frame list
755 * aFromFrames accordingly. The removed line is assigned to *aOutLine and
756 * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
757 * that were extracted from the head of aFromFrames.
758 * aFromLines must contain at least one line, the line may be empty.
759 * @return true if aFromLines becomes empty
760 */
770 }
772 //////////////////////////////////////////////////////////////////////
773 // Reflow methods
775 /* virtual */
784 }
785 }
788 }
794 }
803 }
804 }
805 }
807 // Whether this line is indented by the text-indent amount.
813 // If not the first line of the block, but 'each-line' is in effect,
814 // check if the previous line was not wrapped.
816 }
818 // There's a prev-in-flow, so this only counts as a first-line if
819 // 'each-line' and the prev-in-flow's last line was not wrapped.
823 }
825 }();
827 // The 'hanging' option inverts which lines are/aren't indented.
829 }
831 /* virtual */
836 }
844 }
849 }
851 #ifdef DEBUG
856 }
858 #endif
863 }
868 }
871 InlineMinISizeData data;
877 #ifdef DEBUG
882 }
884 #endif
893 }
902 }
903 }
904 }
905 #ifdef DEBUG
910 }
911 #endif
912 }
913 }
918 }
920 /* virtual */
925 }
933 }
938 }
940 #ifdef DEBUG
945 }
947 #endif
952 }
957 }
958 InlinePrefISizeData data;
964 #ifdef DEBUG
969 }
971 #endif
973 StyleClear clearType;
978 }
988 // XXXmats should the test below be indent > 0?
991 }
992 }
999 }
1000 }
1001 #ifdef DEBUG
1006 }
1007 #endif
1008 }
1009 }
1014 }
1017 // be conservative
1020 }
1022 }
1024 /* virtual */
1030 }
1035 nsresult rv;
1036 InlinePrefISizeData data;
1053 }
1065 }
1066 }
1067 }
1068 }
1072 }
1074 /**
1075 * Return whether aNewAvailableSpace is smaller *on either side*
1076 * (inline-start or inline-end) than aOldAvailableSpace, so that we know
1077 * if we need to redo layout on an line, replaced block, or block
1078 * formatting context, because its height (which we used to compute
1079 * aNewAvailableSpace) caused it to intersect additional floats.
1080 */
1086 // Positions are not significant if the inline size is zero.
1088 }
1093 "available space should not shrink on the start side and "
1098 "available space should not grow on the start side and "
1105 }
1106 // Have we shrunk on either side?
1109 }
1113 // The issue here is that for a 'height' of 'auto' the reflow input
1114 // code won't know how to calculate the containing block height
1115 // because it's calculated bottom up. So we use our own computed
1116 // size as the dimensions.
1120 // Containing block is relative to the padding edge
1128 }
1130 // We are a wrapped frame for the content (and the wrapper is not the
1131 // canvas frame, whose size is not meaningful here).
1132 // Use the container's dimensions, if they have been precomputed.
1133 // XXX This is a hack! We really should be waiting until the outermost
1134 // frame is fully reflowed and using the resulting dimensions, even
1135 // if they're intrinsic.
1136 // In fact we should be attaching absolute children to the outermost
1137 // frame and not always sticking them in block frames.
1139 // First, find the reflow input for the outermost frame for this content.
1147 }
1151 }
1153 // For scroll containers, we can just use cbSize (which is the padding-box
1154 // size of the scrolled-content frame).
1156 // Assert that we're not missing any frames between the abspos containing
1157 // block and the scroll container.
1158 // the parent.
1162 }
1164 // Same for fieldsets, where the inner anonymous frame has the correct padding
1165 // area with the legend taken into account.
1168 }
1170 // We found a reflow input for the outermost wrapping frame, so use
1171 // its computed metrics if available, converted to our writing mode
1177 }
1181 }
1184 }
1186 /**
1187 * Returns aFrame if it is a non-BFC block frame, and null otherwise.
1188 *
1189 * This is used to determine whether to recurse into aFrame when applying
1190 * -webkit-line-clamp.
1191 */
1196 }
1197 }
1199 }
1204 }
1209 }
1213 }
1217 }
1219 // For now, -webkit-box is the only thing allowed to be a line-clamp root.
1220 // Ideally we'd just make this work everywhere, but for now we're carrying
1221 // this forward as a limitation on the legacy -webkit-line-clamp feature,
1222 // since relaxing this limitation might create webcompat trouble.
1225 // If we're the anonymous block inside the scroll frame, we need to look
1226 // at the original display of our parent frame.
1231 ":-moz-scrolled-content should inherit -webkit-line-clamp, "
1234 }
1236 }();
1238 }
1243 }
1249 }
1252 }
1253 }
1255 }
1257 /**
1258 * Iterator over all descendant inline line boxes, except for those that are
1259 * under an independent formatting context.
1260 */
1269 }
1270 }
1275 // Advances the iterator to the next line line.
1276 //
1277 // Next() shouldn't be called once the iterator is at the end, which can be
1278 // checked for by GetCurrentLine() or GetCurrentFrame() returning null.
1284 }
1290 // Reached the end of the current block. Pop the parent off the
1291 // stack; if there isn't one, then we've reached the end.
1295 }
1309 // Some kind of frame we shouldn't descend into.
1311 }
1315 }
1316 }
1317 }
1319 // The current line within the current block.
1320 //
1321 // When this is equal to mEnd, the iterator is at its end, and mCurrentFrame
1322 // is set to null.
1325 // The iterator end for the current block.
1328 // The current block.
1331 // Stack of mCurrentFrame and mEnd values that we push and pop as we enter and
1332 // exist blocks.
1334 };
1342 }
1343 }
1344 }
1346 }
1354 }
1355 }
1357 // We didn't find a line with the ellipsis; it must have been deleted already.
1359 }
1369 }
1376 #ifdef DEBUG
1383 }
1390 }
1391 #endif
1393 // ColumnSetWrapper's children depend on ColumnSetWrapper's block-size or
1394 // max-block-size because both affect the children's available block-size.
1397 }
1404 }
1405 });
1411 // If we have non-auto block size, we're clipping our kids and we fit,
1412 // make sure our kids fit too.
1418 physicalBlockAxis)) {
1419 LogicalMargin blockDirExtras =
1424 // Block-end margin never causes us to create continuations, so we
1425 // don't need to worry about whether it fits in its entirety.
1428 }
1435 }
1436 }
1440 }
1442 // OK, some lines may be reflowed. Blow away any saved line cursor
1443 // because we may invalidate the nondecreasing
1444 // overflowArea.InkOverflow().y/yMost invariant, and we may even
1445 // delete the line with the line cursor.
1448 // See comment below about oldSize. Use *only* for the
1449 // abs-pos-containing-block-size-change optimization!
1452 // Should we create a float manager?
1455 // XXXldb If we start storing the float manager in the frame rather
1456 // than keeping it around only during reflow then we should create it
1457 // only when there are actually floats to manage. Otherwise things
1458 // like tables will gain significant bloat.
1462 }
1467 }
1469 // Whether to apply text-wrap: balance behavior.
1473 // Struct used to hold the "target" number of lines or clamp position to
1474 // maintain when doing text-wrap: balance.
1476 // If line-clamp is in effect, mContent and mOffset indicate the starting
1477 // position of the first line after the clamp limit. If line-clamp is not
1478 // in use, mContent is null and mOffset is the total number of lines that
1479 // the block must contain.
1485 }
1488 }
1489 };
1491 BalanceTarget balanceTarget;
1493 // Helpers for text-wrap: balance implementation:
1495 // Count the number of lines in the mLines list, but return -1 (to suppress
1496 // balancing) instead if the count is going to exceed aLimit, or if we
1497 // encounter a block.
1503 }
1504 }
1506 };
1508 // Return a BalanceTarget record representing the position at which line-clamp
1509 // will take effect for the current line list. Only to be used when there are
1510 // enough lines that the clamp will apply.
1516 }
1520 }
1524 }
1529 }
1531 };
1533 // "balancing" is implemented by shortening the effective inline-size of the
1534 // lines, so that content will tend to be pushed down to fill later lines of
1535 // the block. `balanceInset` is the current amount of "inset" to apply, and
1536 // `balanceStep` is the increment to adjust it by for the next iteration.
1539 // text-wrap: balance loop, executed only once if balancing is not required.
1540 nsReflowStatus reflowStatus;
1542 needFloatManager);
1544 // Save the initial floatManager state for repeated trial reflows.
1545 // We'll restore (and re-save) the initial state each time we repeat the
1546 // reflow.
1551 reflowStatus =
1554 // Do we need to start a `text-wrap: balance` iteration?
1557 // Don't try to balance an incomplete block.
1560 }
1564 // If there are less than 2 lines, or the number exceeds the limit,
1565 // no balancing is needed; just break from the balance loop.
1567 }
1568 // Initialize the amount of inset to try, and the iteration step size.
1573 // If -webkit-line-clamp is in effect, then we need to maintain the
1574 // content location at which clamping occurs, rather than the total
1575 // number of lines in the block.
1583 }
1584 }
1585 }
1587 // Restore initial floatManager state for a new trial with updated inset.
1590 }
1592 // Helper to determine whether the current trial succeeded (i.e. was able
1593 // to fit the content into the expected number of lines).
1597 }
1601 }
1605 };
1607 // If we're in the process of a balance operation, check whether we've
1608 // inset by too much and either increase or reduce the inset for the next
1609 // iteration.
1615 }
1620 }
1622 // If we were attempting to balance, check whether the final iteration was
1623 // successful, and if not, back up by one step.
1627 }
1632 }
1634 // If we reach here, no balancing was required, so just exit; we don't
1635 // reset (pop) the floatManager state because this is the reflow we're
1636 // going to keep. So the saved state is just dropped.
1640 // If the block direction is right-to-left, we need to update the bounds of
1641 // lines that were placed relative to mContainerSize during reflow, as
1642 // we typically do not know the true container size until we've reflowed all
1643 // its children. So we use a dummy mContainerSize during reflow (see
1644 // BlockReflowState's constructor) and then fix up the positions of the
1645 // lines here, once the final block size is known.
1646 //
1647 // Note that writing-mode:vertical-rl is the only case where the block
1648 // logical direction progresses in a negative physical direction, and
1649 // therefore block-dir coordinate conversion depends on knowing the width
1650 // of the coordinate space in order to translate between the logical and
1651 // physical origins.
1656 // We compute our lines and markers' overflow areas later in
1657 // ComputeOverflowAreas(), so we don't need to adjust their overflow areas
1658 // here.
1662 }
1667 }
1672 }
1673 }
1679 }
1680 }
1681 }
1682 }
1688 // Factor overflow container child bounds into the overflow area
1690 // Factor pushed float child bounds into the overflow area
1693 // Let the absolutely positioned container reflow any absolutely positioned
1694 // child frames that need to be reflowed, e.g., elements with a percentage
1695 // based width/height
1696 // We want to do this under either of two conditions:
1697 // 1. If we didn't do the incremental reflow above.
1698 // 2. If our size changed.
1699 // Even though it's the padding edge that's the containing block, we
1700 // can use our rect (the border edge) since if the border style
1701 // changed, the reflow would have been targeted at us so we'd satisfy
1702 // condition 1.
1703 // XXX checking oldSize is bogus, there are various reasons we might have
1704 // reflowed but our size might not have been changed to what we
1705 // asked for (e.g., we ended up being pushed to a new page)
1706 // When WillReflowAgainForClearance is true, we will reflow again without
1707 // resetting the size. Because of this, we must not reflow our abs-pos
1708 // children in that situation --- what we think is our "new size" will not be
1709 // our real new size. This also happens to be more efficient.
1715 // Make sure that when we reflow again we'll actually reflow all the abs
1716 // pos frames that might conceivably depend on our size (or all of them,
1717 // if we're dirty right now and interrupted; in that case we also need
1718 // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
1719 // better than that, because we don't really know what our size will be,
1720 // and it might in fact not change on the followup reflow!
1725 }
1727 // We're not going to reflow absolute frames; make sure to account for
1728 // their existing overflow areas, which is usually a side effect of this
1729 // reflow.
1730 //
1731 // TODO(emilio): nsAbsoluteContainingBlock::Reflow already checks for
1732 // interrupt, can we just rely on it and unconditionally take the else
1733 // branch below? That's a bit more subtle / risky, since I don't see
1734 // what would reflow them in that case if they depended on our size.
1738 }
1739 }
1741 LogicalSize containingBlockSize =
1745 // Mark frames that depend on changes we just made to this frame as dirty:
1746 // Now we can assume that the padding edge hasn't moved.
1747 // We need to reflow the absolutes if one of them depends on
1748 // its placeholder position, or the containing block size in a
1749 // direction in which the containing block size might have
1750 // changed.
1752 // XXX "width" and "height" in this block will become ISize and BSize
1753 // when nsAbsoluteContainingBlock is logicalized
1756 // If isRoot and we have auto height, then we are the initial
1757 // containing block and the containing block height is the
1758 // viewport height, which can't change during incremental
1759 // reflow.
1769 }
1772 }
1773 // Setup the line cursor here to optimize line searching for
1774 // calculating hypothetical position of absolutely-positioned
1775 // frames.
1780 }
1781 }
1787 #ifdef DEBUG
1788 // Between when we drain pushed floats and when we complete reflow,
1789 // we're allowed to have multiple continuations of the same float on
1790 // our floats list, since a first-in-flow might get pushed to a later
1791 // continuation of its containing block. But it's not permitted
1792 // outside that time.
1809 }
1811 }
1820 }
1833 }
1834 #endif
1835 }
1841 #ifdef DEBUG
1842 // Between when we drain pushed floats and when we complete reflow,
1843 // we're allowed to have multiple continuations of the same float on
1844 // our floats list, since a first-in-flow might get pushed to a later
1845 // continuation of its containing block. But it's not permitted
1846 // outside that time.
1848 #endif
1850 // ALWAYS drain overflow. We never want to leave the previnflow's
1851 // overflow lines hanging around; block reflow depends on the
1852 // overflow line lists being cleared out between reflow passes.
1864 // Handle paginated overflow (see nsContainerFrame.h)
1865 nsReflowStatus ocStatus;
1871 }
1873 // Now that we're done cleaning up our overflow container lists, we can
1874 // give |state| its nsOverflowContinuationTracker.
1878 // Drain & handle pushed floats
1882 // If we're not dirty (which means we'll mark everything dirty later)
1883 // and our inline-size has changed, mark the lines dirty that we need to
1884 // mark dirty for a resize reflow.
1887 }
1889 // The same for percentage text-indent, except conditioned on the
1890 // parent resizing.
1895 }
1897 // For text-wrap:balance trials, we need to reflow all the lines even if
1898 // they're not all "dirty".
1903 }
1905 // Now reflow...
1908 // If we have a next-in-flow, and that next-in-flow has pushed floats from
1909 // this frame from a previous iteration of reflow, then we should not return
1910 // a status with IsFullyComplete() equals to true, since we actually have
1911 // overflow, it's just already been handled.
1913 // NOTE: This really shouldn't happen, since we _should_ pull back our floats
1914 // and reflow them, but just in case it does, this is a safety precaution so
1915 // we don't end up with a placeholder pointing to frames that have already
1916 // been deleted as part of removing our next-in-flow.
1925 }
1927 }
1930 }
1931 }
1935 // If we end in a BR with clear and affected floats continue,
1936 // we need to continue, too.
1941 }
1946 }
1948 #ifdef DEBUG_kipp
1951 #endif
1952 }
1954 // Place the ::marker's frame if it is placed next to a block child.
1955 //
1956 // According to the CSS2 spec, section 12.6.1, the ::marker's box
1957 // participates in the height calculation of the list-item box's
1958 // first line box.
1959 //
1960 // There are exactly two places a ::marker can be placed: near the
1961 // first or second line. It's only placed on the second line in a
1962 // rare case: an empty first line followed by a second line that
1963 // contains a block (example: <LI>\n<P>... ). This is where
1964 // the second case can happen.
1969 // Reflow the ::marker's frame.
1971 // XXX Use the entire line when we fix bug 25888.
1976 nscoord lineBStart =
1985 // We have some lines to align the ::marker with.
1987 // Doing the alignment using the baseline will also cater for
1988 // ::markers that are placed next to a child block (bug 92896)
1990 // Tall ::markers won't look particularly nice here...
1991 LogicalRect bbox =
1998 }
2001 });
2004 }
2005 // Otherwise just leave the ::marker where it is, up against our
2006 // block-start padding.
2007 }
2009 // Clear any existing -webkit-line-clamp ellipsis.
2012 }
2016 // Compute our final size (for this trial layout)
2022 }
2028 }
2031 }
2032 }
2034 }
2037 StyleLineClamp aLineNumber) {
2052 NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
2055 // Don't count a line that only has collapsible white space (as might exist
2056 // after calling e.g. getBoxQuads).
2060 }
2063 // We already previously found our target line, and now we have
2064 // confirmed that there is another line after it.
2067 }
2070 // This is our target line. Continue looping to confirm that we
2071 // have another line after us.
2074 }
2077 }
2082 }
2089 }
2093 nscoord aContentBlockEndEdge) {
2096 }
2101 // The number of lines did not exceed the -webkit-line-clamp value.
2103 }
2105 // Mark the line as having an ellipsis so that TextOverflow will render it.
2109 // Translate the b-end edge of the line up to aFrame's space.
2112 edge +=
2114 }
2117 }
2124 #ifdef NOISY_FINAL_SIZE
2130 #endif
2132 // Compute final inline size
2139 // Return block-end margin information
2140 // rbs says he hit this assertion occasionally (see bug 86947), so
2141 // just set the margin to zero and we'll figure out why later
2142 // NS_ASSERTION(aMetrics.mCarriedOutBEndMargin.IsZero(),
2143 // "someone else set the margin");
2146 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
2147 // line with clearance and a non-zero block-start margin and all
2148 // subsequent lines are empty, then we do not allow our children's
2149 // carried out block-end margin to be carried out of us and collapse
2150 // with our own block-end margin.
2152 // Convert the children's carried out margin to something that
2153 // we will include in our height
2156 }
2160 }
2163 // Shrink wrap our height around our contents.
2166 // When we are a block-end-margin root make sure that our last
2167 // child's block-end margin is fully applied. We also do this when
2168 // we have a computed height, since in that case the carried out
2169 // margin is not going to be applied anywhere, so we should note it
2170 // here to be included in the overflow area.
2171 // Apply the margin only if there's space for it.
2173 // Truncate block-end margin if it doesn't fit to our available BSize.
2174 blockEndEdgeOfChildren =
2177 }
2178 }
2180 // Include the float manager's state to properly account for the
2181 // block-end margin of any floated elements; e.g., inside a table cell.
2182 //
2183 // Note: The block coordinate returned by ClearFloats is always greater than
2184 // or equal to blockEndEdgeOfChildren.
2187 }
2190 // Note: We don't use blockEndEdgeOfChildren because it includes the
2191 // previous margin.
2195 // We don't care about ApplyLineClamp's return value (the line-clamped
2196 // content BSize) in this explicit-BSize codepath, but we do still need to
2197 // call ApplyLineClamp for ellipsis markers to be placed as-needed.
2202 // If the content block-size is larger than the effective computed
2203 // block-size, we extend the block-size to contain all the content.
2204 // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
2206 // Note: finalSize.BSize(wm) is the border-box size, so we compare it with
2207 // the content's block-size plus our border and padding..
2211 }
2213 // Don't carry out a block-end margin when our BSize is fixed.
2214 //
2215 // Note: this also includes the case that aReflowInput.ComputedBSize() is
2216 // calculated from aspect-ratio. i.e. Don't carry out block margin-end if it
2217 // is replaced by the block size from aspect-ratio and inline size.
2223 // If we're size-containing in block axis and we don't have a specified
2224 // block size, then our final size should actually be computed from only
2225 // our border, padding and contain-intrinsic-block-size, ignoring the
2226 // actual contents. Hence this case is a simplified version of the case
2227 // below.
2228 //
2229 // NOTE: We exempt the nsComboboxControlFrame subclass from taking this
2230 // special case when it has 'contain-intrinsic-block-size: none', because
2231 // comboboxes implicitly honors the size-containment behavior on its
2232 // nsComboboxDisplayFrame child (which it shrinkwraps) rather than on the
2233 // nsComboboxControlFrame. (Moreover, the DisplayFrame child doesn't even
2234 // need any special content-size-ignoring behavior in its reflow method,
2235 // because that method just resolves "auto" BSize values to one
2236 // line-height rather than by measuring its contents' BSize.)
2238 nscoord autoBSize =
2244 // Our parent is expected to push this frame to the next page/column so
2245 // what size we set here doesn't really matter.
2259 // Our min-block-size, max-block-size, or -webkit-line-clamp value made
2260 // our bsize change. Don't carry out our kids' block-end margins.
2262 }
2267 // Applying `min-size` made us overflow our available size.
2268 // Clamp it and report that we're Incomplete, or BreakBefore if we have
2269 // 'break-inside: avoid' that is applicable.
2275 }
2276 }
2284 // This should never happen, but it does. See bug 414255
2286 }
2290 // Compute this fragment's block-size, with the max-block-size
2291 // constraint taken into consideration.
2298 // We actually fit after applying `max-size` so we should be
2299 // Overflow-Incomplete instead.
2303 // We cannot fit after applying `max-size` with our block-end BP, so
2304 // we should draw it in our next continuation.
2306 }
2307 }
2309 }
2310 }
2314 // Overflow containers can only be overflow complete.
2315 // Note that auto height overflow containers have no normal children
2319 }
2323 // Currently only used for grid items, but could be used in other contexts.
2324 // The FragStretchBSizeProperty is our expected non-fragmented block-size
2325 // we should stretch to (for align-self:stretch etc). In some fragmentation
2326 // cases though, the last fragment (this frame since we're complete), needs
2327 // to have extra size applied because earlier fragments consumed too much of
2328 // our computed size due to overflowing their containing block. (E.g. this
2329 // ensures we fill the last row when a multi-row grid item is fragmented).
2334 }
2335 }
2337 // Clamp the content size to fit within the margin-box clamp size, if any.
2351 // XXXmats deal with percentages better somehow?
2353 }
2354 }
2355 }
2357 // Screen out negative block sizes --- can happen due to integer overflows :-(
2364 }
2368 #ifdef DEBUG_blocks
2373 }
2374 #endif
2377 }
2384 // Factor in the block-end edge of the children. Child frames will be added
2385 // to the overflow area as we iterate through the lines, but their margins
2386 // won't, so we need to account for block-end margins here.
2387 // REVIEW: For now, we do this for both visual and scrollable area,
2388 // although when we make scrollable overflow area not be a subset of
2389 // visual, we can change this.
2392 // If we are a scrolled inner frame, add our block-end padding to our
2393 // children's block-end edge.
2394 //
2395 // Note: aBEndEdgeOfChildren already includes our own block-start padding
2396 // because it is relative to our block-start edge of our border-box, which
2397 // is the same as our padding-box here.
2401 }
2403 // XXX Currently, overflow areas are stored as physical rects, so we have
2404 // to handle writing modes explicitly here. If we change overflow rects
2405 // to be stored logically, this can be simplified again.
2411 // Layout containment should force all overflow to be ink (visual)
2412 // overflow, so if we're layout-contained, we only add our children's
2413 // block-end edge to the ink (visual) overflow -- not to the
2414 // scrollable overflow.
2417 }
2418 }
2427 }
2428 }
2429 }
2435 }
2436 }
2437 }
2438 }
2441 nscoord aBEndEdgeOfChildren,
2443 // XXX_perf: This can be done incrementally. It is currently one of
2444 // the things that makes incremental reflow O(N^2).
2450 }
2452 // We rely here on our caller having called SetOverflowAreasToDesiredBounds().
2457 // If we have layout containment, we should only consider our child's
2458 // ink overflow, leaving the scrollable regions of the parent
2459 // unaffected.
2460 // Note: scrollable overflow is a subset of ink overflow,
2461 // so this has the same affect as unioning the child's visual and
2462 // scrollable overflow with its parent's ink overflow.
2468 }
2469 }
2471 // Factor an outside ::marker in; normally the ::marker will be factored
2472 // into the line-box's overflow areas. However, if the line is a block
2473 // line then it won't; if there are no lines, it won't. So just
2474 // factor it in anyway (it can't hurt if it was already done).
2475 // XXXldb Can we just fix GetOverflowArea instead?
2478 }
2484 overflowClipMargin);
2485 }
2487 #ifdef NOISY_OVERFLOW_AREAS
2491 #endif
2492 }
2495 // We need to update the overflow areas of lines manually, as they
2496 // get cached and re-used otherwise. Lines aren't exposed as normal
2497 // frame children, so calling UnionChildOverflow alone will end up
2498 // using the old cached values.
2507 }
2509 // Consider the overflow areas of the floats attached to the line as well
2513 }
2514 }
2518 }
2520 // Union with child frames, skipping the principal and float lists
2521 // since we already handled those using the line boxes.
2525 }
2529 nscoord blockEndEdgeOfChildren =
2534 }
2536 // Line cursor invariants depend on the overflow areas of the lines, so
2537 // we must clear the line cursor since those areas may have changed.
2540 }
2550 // NOTE: MarkLineDirty does more than just marking the line dirty.
2553 }
2554 }
2555 }
2557 }
2558 }
2562 // Mark aLine dirty
2565 #ifdef DEBUG
2570 }
2571 #endif
2573 // Mark previous line dirty if it's an inline line so that it can
2574 // maybe pullup something from the line just affected.
2575 // XXX We don't need to do this if aPrevLine ends in a break-after...
2580 #ifdef DEBUG
2586 }
2587 #endif
2588 }
2589 }
2591 /**
2592 * Test whether lines are certain to be aligned left so that we can make
2593 * resizing optimizations
2594 */
2596 StyleDirection aDirection,
2597 StyleUnicodeBidi aUnicodeBidi,
2605 }
2608 // See if we can try and avoid marking all the lines as dirty
2609 // FIXME(emilio): This should be writing-mode aware, I guess.
2611 // The left content-edge must be a constant distance from the left
2612 // border-edge.
2615 #ifdef DEBUG
2618 }
2625 }
2626 }
2627 #endif
2631 nscoord newAvailISize =
2635 #ifdef DEBUG
2640 }
2641 #endif
2645 // We let child blocks make their own decisions the same
2646 // way we are here.
2654 }
2656 #ifdef REALLY_NOISY_REFLOW
2660 }
2661 #endif
2662 #ifdef DEBUG
2666 "skipped: line=%p next=%p %s %s%s%s clearTypeBefore/After=%s/%s "
2678 }
2679 #endif
2680 }
2682 // Mark everything dirty
2685 }
2686 }
2687 }
2689 //----------------------------------------
2691 /**
2692 * Propagate reflow "damage" from from earlier lines to the current
2693 * line. The reflow damage comes from the following sources:
2694 * 1. The regions of float damage remembered during reflow.
2695 * 2. The combination of nonzero |aDeltaBCoord| and any impact by a
2696 * float, either the previous reflow or now.
2697 *
2698 * When entering this function, |aLine| is still at its old position and
2699 * |aDeltaBCoord| indicates how much it will later be slid (assuming it
2700 * doesn't get marked dirty and reflowed entirely).
2701 */
2704 nscoord aDeltaBCoord) {
2712 // Check to see if there are any floats; if there aren't, there can't
2713 // be any float damage
2716 }
2718 // Check the damage region recorded in the float damage.
2720 // Need to check mBounds *and* mCombinedArea to find intersections
2721 // with aLine's floats
2724 // Scrollable overflow should be sufficient for things that affect
2725 // layout.
2728 LogicalRect overflow =
2731 nscoord lineBCoordCombinedAfter =
2737 lineBCoordCombinedAfter);
2741 }
2742 }
2744 // Check if the line is moving relative to the float manager
2747 // Unconditionally reflow sliding blocks; we only really need to reflow
2748 // if there's a float impacting this block, but the current float manager
2749 // makes it difficult to check that. Therefore, we let the child block
2750 // decide what it needs to reflow.
2754 nsFlowAreaRect floatAvailableSpace =
2758 #ifdef REALLY_NOISY_REFLOW
2761 #endif
2763 // Mark the line dirty if it was or is affected by a float
2764 // We actually only really need to reflow if the amount of impact
2765 // changes, but that's not straightforward to check
2768 }
2769 }
2770 }
2771 }
2777 NS_BLOCK_HAS_CLEAR_CHILDREN) ||
2780 }
2782 /**
2783 * Reparent a whole list of floats from aOldParent to this block. The
2784 * floats might be taken from aOldParent's overflow list. They will be
2785 * removed from the list. They end up appended to our mFloats list.
2786 */
2790 nsFrameList list;
2797 }
2799 }
2800 }
2804 #ifdef DEBUG
2810 "line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} "
2811 "oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} "
2818 }
2819 #endif
2820 }
2826 }
2827 }
2829 }
2837 #ifdef DEBUG
2843 }
2845 #endif
2851 // Reflow our last line if our availableBSize has increased
2852 // so that we (and our last child) pull up content as necessary
2861 }
2862 }
2863 // the amount by which we will slide the current line if it is not
2864 // dirty
2867 // whether we did NOT reflow the previous line and thus we need to
2868 // recompute the carried out margin before the line if we want to
2869 // reflow it or if its previous margin is dirty
2871 // Float continuations were reflowed in ReflowPushedFloats
2876 // We save up information about BR-clearance here
2881 // Determine if children of this frame could have breaks between them for
2882 // page names.
2883 //
2884 // We need to check for paginated layout, the named-page pref, and if the
2885 // available block-size is constrained.
2886 //
2887 // Note that we need to check for paginated layout as named-pages are only
2888 // used during paginated reflow. We need to additionally check for
2889 // unconstrained block-size to avoid introducing fragmentation breaks during
2890 // "measuring" reflows within an overall paginated reflow, and to avoid
2891 // fragmentation in monolithic containers like 'inline-block'.
2892 //
2893 // Because we can only break for named pages using Class A breakpoints, we
2894 // also need to check that the block flow direction of the containing frame
2895 // of these items (which is this block) is parallel to that of this page.
2896 // See: https://www.w3.org/TR/css-break-3/#btw-blocks
2904 // ReflowInput.mFlags.mCanHaveClassABreakpoints should respect the named
2905 // pages pref and presCtx->IsPaginated, so we did not explicitly check these
2906 // above when setting canBreakForPageNames.
2909 "canBreakForPageNames should not be set during non-paginated "
2911 }
2913 // Reflow the lines that are already ours
2916 #ifdef DEBUG
2918 #endif
2922 }
2924 // This really sucks, but we have to look inside any blocks that have clear
2925 // elements inside them.
2926 // XXX what can we do smarter here?
2930 }
2936 }
2938 // We have to reflow the line if it's a block whose clearance
2939 // might have changed, so detect that.
2943 // See where we would be after applying any clearance due to
2944 // BRs.
2948 }
2954 // Reflow the line if it might not have clearance anymore.
2956 // aState.mBCoord is the clearance point which should be the
2957 // block-start border-edge of the block frame. If sliding the
2958 // block by deltaBCoord isn't going to put it in the predicted
2959 // position, then we'd better reflow the line.
2962 }
2964 // Reflow the line if the line might have clearance now.
2967 }
2968 }
2969 }
2971 // We might have to reflow a line that is after a clearing BR.
2976 // SlideLine is not going to put the line where the clearance
2977 // put it. Reflow the line to be sure.
2979 }
2981 }
2985 // If the previous margin is dirty, reflow the current line
2994 // Lines that aren't dirty but get slid past our available block-size
2995 // constraint must be reflowed.
2997 }
2998 }
3002 // Last column can be reflowed unconstrained during column balancing.
3003 // Hence the additional NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR bit check
3004 // as a fail-safe fallback.
3007 // Table can also be reflowed unconstrained during printing.
3010 // We are in a paginated context, i.e. in columns or pages.
3014 // The following if-else conditions check whether this line -- which
3015 // might have floats in its subtree, or has floats as direct children,
3016 // or had floats pushed -- needs to be reflowed.
3018 // The distance to the block-end edge might have changed. Reflow the
3019 // line both because the breakpoints within its floats may have
3020 // changed and because we might have to push/pull the floats in
3021 // their entirety.
3024 // We had pushed floats which haven't been drained by our
3025 // next-in-flow, which means our parent is currently reflowing us
3026 // again due to clearance without creating a next-in-flow for us.
3027 // Reflow the line to redo the floats split logic to correctly set
3028 // our reflow status.
3031 // Reflow the line (that may containing a float's placeholder frame)
3032 // if our parent tells us to do so.
3035 // Our parent's line containing us moved to a different fragment.
3036 // Reflow the line because the decision about whether the float fits
3037 // may be different in a different fragment.
3039 }
3040 }
3041 }
3042 }
3045 // See if there's any reflow damage that requires that we mark the
3046 // line dirty.
3048 }
3050 // If the container size has changed, reset mContainerSize. If the
3051 // line's writing mode is not ltr, or if the line is not left-aligned, also
3052 // mark the line dirty.
3063 }
3064 }
3066 // Check for a page break caused by CSS named pages.
3067 //
3068 // We should break for named pages when two frames meet at a class A
3069 // breakpoint, where the first frame has a different end page value to the
3070 // second frame's start page value. canBreakForPageNames is true iff
3071 // children of this frame can form class A breakpoints, and that we are not
3072 // in a measurement reflow or in a monolithic container such as
3073 // 'inline-block'.
3074 //
3075 // We specifically do not want to cause a page-break for named pages when
3076 // we are at the top of a page. This would otherwise happen when the
3077 // previous sibling is an nsPageBreakFrame, or all previous siblings on the
3078 // current page are zero-height. The latter may not be per-spec, but is
3079 // compatible with Chrome's implementation of named pages.
3087 // Walk back to the last frame that isn't a placeholder.
3091 }
3095 }
3096 }
3097 }
3100 // We need to reconstruct the block-end margin only if we didn't
3101 // reflow the previous line and we do need to reflow (or repair
3102 // the block-start position of) the next line.
3104 }
3110 // Update aState.mPrevChild as if we had reflowed all of the frames in
3111 // this line.
3117 }
3118 }
3120 // Now repair the line and update |aState.mBCoord| by calling
3121 // |ReflowLine| or |SlideLine|.
3122 // If we're going to reflow everything again, then no need to reflow
3123 // the dirty line ... unless the line has floats, in which case we'd
3124 // better reflow it now to refresh its float cache, which may contain
3125 // dangling frame pointers! Ugh! This reflow of the line may be
3126 // incorrect because we skipped reflowing previous lines (e.g., floats
3127 // may be placed incorrectly), but that's OK because we'll mark the
3128 // line dirty below under "if (aState.mReflowInput.mDiscoveredClearance..."
3136 // Compute the dirty lines "before" BEnd, after factoring in
3137 // the running deltaBCoord value - the running value is implicit in
3138 // aState.mBCoord.
3143 "Don't reflow blocks while willReflowAgain is true, reflow "
3147 // Immediately fragment for page-name. It is possible we could break
3148 // out of the loop right here, but this should make it more similar to
3149 // what happens when reflow causes fragmentation.
3154 // Reflow the dirty line. If it's an incremental reflow, then force
3155 // it to invalidate the dirty area if necessary
3157 }
3162 // Note that once we've entered this state, every line that gets here
3163 // (e.g. because it has floats) gets marked dirty and reflowed again.
3164 // in the next pass. This is important, see above.
3165 }
3169 }
3175 }
3177 }
3179 // Test to see whether the margin that should be carried out
3180 // to the next line (NL) might have changed. In ReflowBlockFrame
3181 // we call nextLine->MarkPreviousMarginDirty if the block's
3182 // actual carried-out block-end margin changed. So here we only
3183 // need to worry about the following effects:
3184 // 1) the line was just created, and it might now be blocking
3185 // a carried-out block-end margin from previous lines that
3186 // used to reach NL from reaching NL
3187 // 2) the line used to be empty, and is now not empty,
3188 // thus blocking a carried-out block-end margin from previous lines
3189 // that used to reach NL from reaching NL
3190 // 3) the line wasn't empty, but now is, so a carried-out
3191 // block-end margin from previous lines that didn't used to reach NL
3192 // now does
3193 // 4) the line might have changed in a way that affects NL's
3194 // ShouldApplyBStartMargin decision. The three things that matter
3195 // are the line's emptiness, its adjacency to the block-start edge of the
3196 // block, and whether it has clearance (the latter only matters if the
3197 // block was and is adjacent to the block-start and empty).
3198 //
3199 // If the line is empty now, we can't reliably tell if the line was empty
3200 // before, so we just assume it was and do
3201 // nextLine->MarkPreviousMarginDirty. This means the checks in 4) are
3202 // redundant; if the line is empty now we don't need to check 4), but if
3203 // the line is not empty now and we're sure it wasn't empty before, any
3204 // adjacency and clearance changes are irrelevant to the result of
3205 // nextLine->ShouldApplyBStartMargin.
3212 // since it's marked dirty, nobody will care about |deltaBCoord|
3213 }
3214 }
3216 // If the line was just reflowed for the first time, then its
3217 // old mBounds cannot be trusted so this deltaBCoord computation is
3218 // bogus. But that's OK because we just did
3219 // MarkPreviousMarginDirty on the next line which will force it
3220 // to be reflowed, so this computation of deltaBCoord will not be
3221 // used.
3224 // Now do an interrupt check. We want to do this only in the case when we
3225 // actually reflow the line, so that if we get back in here we'll get
3226 // further on the reflow before interrupting.
3230 // Nop except for blocks (we don't create overflow container
3231 // continuations for any inlines atm), so only checking mFirstChild
3232 // is enough
3240 }
3245 // If we're going to reflow everything again, and this line is a block,
3246 // then there is no need to recover float state. The line may contain
3247 // other lines with floats, but in that case RecoverStateFrom would only
3248 // add floats to the float manager. We don't need to do that because
3249 // everything's going to get reflowed again "for real". Calling
3250 // RecoverStateFrom in this situation could be lethal because the
3251 // block's descendant lines may have float caches containing dangling
3252 // frame pointers. Ugh!
3253 // If this line is inline, then we need to recover its state now
3254 // to make sure that we don't forget to move its floats by deltaBCoord.
3256 // XXX EVIL O(N^2) EVIL
3258 }
3260 // Keep mBCoord up to date in case we're propagating reflow damage
3261 // and also because our final height may depend on it. If the
3262 // line is inlines, then only update mBCoord if the line is not
3263 // empty, because that's what PlaceLine does. (Empty blocks may
3264 // want to update mBCoord, e.g. if they have clearance.)
3267 }
3273 // Need to make sure to pull overflows from any prev-in-flows
3277 }
3278 }
3279 }
3281 // Record if we need to clear floats before reflowing the next
3282 // line. Note that inlineFloatClearType will be handled and
3283 // cleared before the next line is processed, so there is no
3284 // need to combine break types here.
3287 }
3291 }
3297 // Another option here might be to leave |line| clean if
3298 // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
3299 // that case the line really did reflow as it should have. Not sure
3300 // whether that would be safe, so doing this for now instead. Also not
3301 // sure whether we really want to mark all lines dirty after an
3302 // interrupt, but until we get better at propagating float damage we
3303 // really do need to do it this way; see comments inside MarkLineDirty.
3305 }
3306 }
3308 // Handle BR-clearance from the last line of the block
3312 }
3315 // Is this expensive?
3318 // Update aState.mPrevChild as if we had reflowed all of the frames in
3319 // the last line.
3325 }
3327 // Should we really have to do this?
3330 }
3332 // We can skip trying to pull up the next line if our height is constrained
3333 // (so we can report being incomplete) and there is no next in flow or we
3334 // were told not to or we know it will be futile, i.e.,
3335 // -- the next in flow is not changing
3336 // -- and we cannot have added more space for its first line to be
3337 // pulled up into,
3338 // -- it's an incremental reflow of a descendant
3339 // -- and we didn't reflow any floats (so the available space
3340 // didn't change)
3341 // -- my chain of next-in-flows either has no first line, or its first
3342 // line isn't dirty.
3349 // We'll place lineIter at the last line of this block, so that
3350 // nsBlockInFlowLineIterator::Next() will take us to the first
3351 // line of my next-in-flow-chain. (But first, check that I
3352 // have any lines -- if I don't, just bail out of this
3353 // optimization.)
3359 // Check for next-in-flow-chain's first line.
3360 // (First, see if there is such a line, and second, see if it's clean)
3363 }
3364 }
3365 }
3373 }
3374 }
3377 // Pull data from a next-in-flow if there's still room for more
3378 // content here.
3380 // Grab first line from our next-in-flow
3383 nsFrameList pulledFrames;
3388 // Grab an overflow line if there are any
3394 }
3400 }
3401 }
3404 // The line is empty. Try the next one.
3410 }
3415 }
3418 }
3419 }
3430 // Shift pulledLine's frames into our mFrames list.
3433 // Add line to our line list, and set its last child as our new prev-child
3437 // Reparent floats whose placeholders are in the line.
3441 #ifdef DEBUG
3443 #endif
3448 // Now reflow it and any lines that it makes during it's reflow
3449 // (we have to loop here because reflowing the line may cause a new
3450 // line to be created; see SplitLine's callers for examples of
3451 // when this happens).
3460 }
3466 }
3468 }
3472 }
3477 }
3479 // If this is an inline frame then its time to stop
3482 }
3483 }
3484 }
3489 }
3491 // Handle an odd-ball case: a list-item with no lines
3503 // There are no lines so we have to fake up some y motion so that
3504 // we end up with *some* height.
3505 // (Note: if we're layout-contained, we have to be sure to leave our
3506 // ReflowOutput's BlockStartAscent() (i.e. the baseline) untouched,
3507 // because layout-contained frames have no baseline.)
3510 nscoord ascent;
3516 }
3517 }
3533 }
3534 }
3535 }
3539 }
3545 }
3547 #ifdef DEBUG
3555 }
3556 #endif
3557 }
3562 // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
3563 // marked the lines that need to be marked dirty based on our
3564 // vertical resize stuff. So we'll definitely reflow all those kids;
3565 // the only question is how they should behave.
3567 // Mark all our child frames dirty so we make sure to reflow them
3568 // later.
3573 }
3574 // And mark all the floats whose reflows we might be skipping dirty too.
3578 }
3579 }
3581 // Dirty all the descendant lines of block kids to handle float damage,
3582 // since our nsFloatManager will go away by the next time we're reflowing.
3583 // XXXbz Can we do something more like what PropagateFloatDamage does?
3584 // Would need to sort out the exact business with mBlockDelta for that....
3585 // This marks way too much dirty. If we ever make this better, revisit
3586 // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
3590 }
3591 }
3592 }
3600 "using function more generally than designed, "
3605 // Mark the previous margin of the next line dirty since we need to
3606 // recompute its top position.
3609 }
3610 }
3611 }
3613 /**
3614 * Reflow a line. The line will either contain a single block frame
3615 * or contain 1 or more inline frames. aKeepReflowGoing indicates
3616 * whether or not the caller should continue to reflow more lines.
3617 */
3622 // Setup the line-layout for the new line
3628 // If this line contains a single block that is hidden by `content-visibility`
3629 // don't reflow the line. If this line contains inlines and the first one is
3630 // hidden by `content-visibility`, all of them are, so avoid reflow in that
3631 // case as well.
3632 // For frames that own anonymous children, even the first child is hidden by
3633 // `content-visibility`, there could be some anonymous children need reflow,
3634 // so we don't skip reflow this line.
3639 }
3641 // Now that we know what kind of line we have, reflow it
3648 // Store the line's float edges for overflow marker analysis if needed.
3660 // This line is overlapping a float - store the edges marking the area
3661 // between the floats for text-overflow analysis.
3663 }
3664 }
3665 }
3666 }
3669 }
3672 LineIterator aLine) {
3673 // First check our remaining lines.
3676 }
3682 // Try each next-in-flow.
3687 }
3690 }
3693 }
3696 }
3712 // If our line is not empty and the child in aFromLine is a block
3713 // then we cannot pull up the frame into this line. In this case
3714 // we stop pulling.
3716 }
3717 // Take frame from fromLine
3722 // The frame is being pulled from a next-in-flow; therefore we need to add
3723 // it to our sibling list.
3729 // When pushing and pulling frames we need to check for whether any
3730 // views need to be reparented.
3734 // The frame might have (or contain) floats that need to be brought
3735 // over too. (pass 'false' since there are no siblings to check)
3739 }
3745 // Mark line dirty now that we pulled a child
3749 // Free up the fromLine now that it's empty.
3750 // Its bounds might need to be redrawn, though.
3753 }
3755 // aFromLine is now invalid
3757 }
3759 #ifdef DEBUG
3762 #endif
3765 }
3768 nscoord aDeltaBCoord) {
3771 // Adjust line state
3774 // Adjust the frames in the line
3776 }
3782 }
3784 // Adjust line state
3787 // Changing container width only matters if writing mode is vertical-rl
3790 }
3791 }
3794 nscoord aDeltaBCoord) {
3795 // Adjust the frames in the line
3799 }
3807 }
3809 // Make sure the frame's view and any child views are updated
3812 // Adjust the block-dir coordinate of the frames in the line.
3813 // Note: we need to re-position views even if aDeltaBCoord is 0, because
3814 // one of our parent frames may have moved and so the view's position
3815 // relative to its parent may have changed.
3820 }
3821 // Make sure the frame's view and any child views are updated
3824 }
3825 }
3826 }
3829 // The "extremum length" values (see ExtremumLength) were originally aimed at
3830 // inline-size (or width, as it was before logicalization). For now, let them
3831 // return false here, so we treat them like 'auto' pending a real
3832 // implementation. (See bug 1126420.)
3833 //
3834 // FIXME (bug 567039, bug 527285) This isn't correct for the 'fill' value,
3835 // which should more likely (but not necessarily, depending on the available
3836 // space) be returning true.
3839 }
3841 // If we evaluate the length/percent/calc at a percentage basis of
3842 // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
3843 // length, percent, or combination thereof. Test > 0 so we clamp
3844 // negative calc() results to 0.
3847 }
3849 /* virtual */
3853 }
3855 // Blocks which are margin-roots (including inline-blocks) cannot be treated
3856 // as empty for margin-collapsing and other purposes. They're more like
3857 // replaced elements.
3860 }
3868 }
3870 // FIXME: Bug 1646100 - Take intrinsic size into account.
3871 // FIXME: Handle the case that both inline and block sizes are auto.
3872 // https://github.com/w3c/csswg-drafts/issues/5060.
3873 // Note: block-size could be zero or auto/intrinsic keywords here.
3877 }
3888 }
3892 }
3895 }
3900 }
3904 }
3905 }
3907 }
3912 }
3915 }
3920 // A page break frame consumes margins adjacent to it.
3921 // https://drafts.csswg.org/css-break/#break-margins
3923 }
3926 // Apply short-circuit check to avoid searching the line list
3928 }
3931 // If we aren't at the start block-coordinate then something of non-zero
3932 // height must have been placed. Therefore the childs block-start margin
3933 // applies.
3936 }
3938 // Determine if this line is "essentially" the first line
3942 }
3945 // A line which precedes aLine is non-empty, or has clearance,
3946 // so therefore the block-start margin applies.
3949 }
3950 // No need to apply the block-start margin if the line has floats. We
3951 // should collapse anyway (bug 44419)
3955 }
3957 // The line being reflowed is "essentially" the first line in the
3958 // block. Therefore its block-start margin will be collapsed by the
3959 // generational collapsing logic with its parent (us).
3961 }
3964 LineIterator aLine,
3972 }
3974 // If the previous frame was a page-break-frame, then preemptively push this
3975 // frame to the next page.
3976 // This is primarily important for the placeholders for abspos frames, which
3977 // measure as zero height and then would be placed on this page.
3983 }
3984 }
3986 // Prepare the block reflow engine
3994 }
3996 // Clear past floats before the block if the clear style is not none
4000 }
4002 // See if we should apply the block-start margin. If the block frame being
4003 // reflowed is a continuation, then we don't apply its block-start margin
4004 // because it's not significant. Otherwise, dig deeper.
4008 // The HasClearance setting is only valid if ShouldApplyBStartMargin
4009 // returned false (in which case the block-start margin-root set our
4010 // clearance flag). Otherwise clear it now. We'll set it later on
4011 // ourselves if necessary.
4013 }
4021 }
4023 // If our block-start margin was counted as part of some parent's block-start
4024 // margin collapse, and we are being speculatively reflowed assuming this
4025 // frame DID NOT need clearance, then we need to check that
4026 // assumption.
4035 // Only record the first frame that requires clearance
4038 }
4040 // Exactly what we do now is flexible since we'll definitely be
4041 // reflowed.
4043 }
4044 }
4047 }
4052 nscoord clearance;
4053 // Save the original position of the frame so that we can reposition
4054 // its view as needed.
4063 // Precompute the blocks block-start margin value so that we can get the
4064 // correct available space (there might be a float that's
4065 // already been placed below the aState.mPrevBEndMargin
4067 // Setup a reflowInput to get the style computed block-start margin
4068 // value. We'll use a reason of `resize' so that we don't fudge
4069 // any incremental reflow input.
4071 // The availSpace here is irrelevant to our needs - all we want
4072 // out if this setup is the block-start margin value which doesn't depend
4073 // on the childs available space.
4074 // XXX building a complete ReflowInput just to get the block-start
4075 // margin seems like a waste. And we do this for almost every block!
4079 availSpace);
4084 }
4086 // Now compute the collapsed margin-block-start value into
4087 // aState.mPrevBEndMargin, assuming that all child margins
4088 // collapse down to clearanceFrame.
4092 // XXX optimization; we could check the collapsing children to see if they
4093 // are sure to require clearance, and so avoid retrying them
4096 // Don't allow retries on the second pass. The clearance decisions for
4097 // the blocks whose block-start margins collapse with ours are now
4098 // fixed.
4100 }
4103 // We don't know if we need clearance and this is the first,
4104 // optimistic pass. So determine whether *this block* needs
4105 // clearance. Note that we do not allow the decision for whether
4106 // this block has clearance to change on the second pass; that
4107 // decision is only allowed to be made under the optimistic
4108 // first pass.
4115 // Looks like we need clearance and we didn't know about it already.
4116 // So recompute collapsed margin
4118 // Remember this decision, needed for incremental reflow
4121 // Apply incoming margins
4125 // Compute the collapsed margin again, ignoring the incoming margin
4126 // this time
4130 }
4131 }
4133 // Temporarily advance the running block-direction value so that the
4134 // GetFloatAvailableSpace method will return the right available space.
4135 // This undone as soon as the horizontal margins are computed.
4140 // advance mBCoord to the clear position.
4146 clearedPushedOrSplitFloat =
4149 // Compute clearance. It's the amount we need to add to the block-start
4150 // border-edge of the frame, after applying collapsed margins
4151 // from the frame and its children, to get it to line up with
4152 // the block-end of the floats. The former is
4153 // currentBCoord + bStartMargin, the latter is the current
4154 // aState.mBCoord.
4155 // Note that negative clearance is possible
4158 // Add clearance to our block-start margin while we compute available
4159 // space for the frame
4162 // Note that aState.mBCoord should stay where it is: at the block-start
4163 // border-edge of the frame
4165 // Advance aState.mBCoord to the block-start border-edge of the frame.
4167 }
4168 }
4172 // Here aState.mBCoord is the block-start border-edge of the block.
4173 // Compute the available space for the block
4179 // The check for
4180 // (!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats)
4181 // is to some degree out of paranoia: if we reliably eat up block-start
4182 // margins at the top of the page as we ought to, it wouldn't be
4183 // needed.
4186 // We know already that this child block won't fit on this
4187 // page/column due to the block-start margin or the clearance. So we
4188 // need to get out of here now. (If we don't, most blocks will handle
4189 // things fine, and report break-before, but zero-height blocks
4190 // won't, and will thus make their parent overly-large and force
4191 // *it* to be pushed in its entirety.)
4198 }
4200 }
4202 // Now put the block-dir coordinate back to the start of the
4203 // block-start-margin + clearance.
4208 }
4210 // Construct the reflow input for the block.
4216 // Calculate the multicol containing block's block size so that the
4217 // children with percentage block size get correct percentage basis.
4223 // Use column-width as the containing block's inline-size, i.e. the column
4224 // content's computed inline-size.
4229 // If a ColumnSetWrapper is in a balancing column content, it may be
4230 // pushed or pulled back and forth between column contents. Always add
4231 // NS_FRAME_HAS_DIRTY_CHILDREN bit to it so that its ColumnSet children
4232 // can have a chance to reflow under current block size constraint.
4236 }
4238 // If we are reflowing our ColumnSet children, we want to apply our block
4239 // size constraint to the available block size when constructing reflow
4240 // input for ColumnSet so that ColumnSet can use it to compute its max
4241 // column block size.
4245 contentBSize =
4247 }
4249 // To get the remaining content block-size, subtract the content
4250 // block-size consumed by our previous continuations.
4253 // ColumnSet is not the outermost frame in the column container, so it
4254 // cannot have any margin. We don't need to consider any margin that
4255 // can be generated by "box-decoration-break: clone" as we do in
4256 // BlockReflowState::ComputeBlockAvailSpace().
4262 }
4263 }
4264 }
4265 }
4269 cbSize);
4272 columnSetWrapperHasNoBSizeLeft;
4275 // We only need to set this the first reflow, since if we reflow
4276 // again (and replace childReflowInput) we'll be reflowing it
4277 // again in the same fragment as the previous time.
4279 }
4282 nsReflowStatus frameReflowStatus;
4285 // Set if floatAvailableSpace.HasFloats() is true for any
4286 // iteration of the loop.
4288 }
4290 // We might need to store into mDiscoveredClearance later if it's
4291 // currently null; we want to overwrite any writes that
4292 // brc.ReflowBlock() below does, so we need to remember now
4293 // whether it's empty.
4298 // Reflow the block into the available space
4301 }
4308 }
4316 // No need to retry this loop if there is a break opportunity before the
4317 // child block.
4319 }
4321 // Now the block has a height. Using that height, get the
4322 // available space again and call ComputeBlockAvailSpace again.
4323 // If ComputeBlockAvailSpace gives a different result, we need to
4324 // reflow again.
4327 }
4336 // Restore the height to the position of the next band.
4339 // Determine whether the available space shrunk on either side,
4340 // because (the first time round) we now know the block's height,
4341 // and it may intersect additional floats, or (on later
4342 // iterations) because narrowing the width relative to the
4343 // previous time may cause the block to become taller. Note that
4344 // since we're reflowing the block, narrowing the width might also
4345 // make it shorter, so we must pass aCanGrow as true.
4348 // The size and position we chose before are fine (i.e., they
4349 // don't cause intersecting with floats that requires a change
4350 // in size or position), so we're done.
4352 }
4356 floatAvailableSpace)) {
4357 // Advance to the next band.
4361 }
4362 // ClearFloats might be able to advance us further once we're there.
4366 // Start over with a new available space rect at the new height.
4369 }
4377 }
4379 // We need another reflow.
4384 // We set shouldStoreClearance above to record only the first
4385 // frame that requires clearance.
4388 }
4390 // Exactly what we do now is flexible since we'll definitely be
4391 // reflowed.
4393 }
4396 // We're pushing down the border-box, so we don't apply margin anymore.
4397 // This should never cause us to move up since the call to
4398 // GetFloatAvailableSpaceForBSize above included the margin.
4403 }
4412 // Found a clearance frame, so we need to reflow |frame| a second time.
4413 // Restore the states and start over again.
4418 }
4423 // If an ancestor of ours is going to reflow for clearance, we
4424 // need to avoid calling PlaceBlock, because it unsets dirty bits
4425 // on the child block (both itself, and through its call to
4426 // nsIFrame::DidReflow), and those dirty bits imply dirtiness for
4427 // all of the child block, including the lines it didn't reflow.
4431 }
4433 #if defined(REFLOW_STATUS_COVERAGE)
4435 #endif
4438 // None of the child block fits.
4443 }
4445 // Note: line-break-after a block is a nop
4447 // Try to place the child block.
4448 // Don't force the block to fit if we have positive clearance, because
4449 // pushing it to the next page would give it more room.
4450 // Don't force the block to fit if it's impacted by a float. If it is,
4451 // then pushing it to the next page would give it more room. Note that
4452 // isImpacted doesn't include impact from the block's own floats.
4455 nsCollapsingMargin collapsedBEndMargin;
4456 OverflowAreas overflowAreas;
4464 }
4471 }
4472 }
4476 // Some of the child block fit
4478 // Advance to new Y position
4482 // Continue the block frame now if it didn't completely fit in
4483 // the available space.
4492 // If nextFrame used to be an overflow container, make it a normal
4493 // block
4502 }
4507 }
4509 // Push continuation to a new line, but only if we actually made
4510 // one.
4514 }
4518 // If we need to reflow the continuation of the block child,
4519 // then we'd better reflow our continuation
4522 // We also need to make that continuation's line dirty so
4523 // it gets reflowed when we reflow our next in flow. The
4524 // nif's line must always be either a line of the nif's
4525 // parent block (only if we didn't make a continuation) or
4526 // else one of our own overflow lines. In the latter case
4527 // the line is already marked dirty, so just handle the
4528 // first case.
4532 nifBlock,
4538 }
4539 }
4540 }
4541 }
4543 // The block-end margin for a block is only applied on the last
4544 // flow block. Since we just continued the child block frame,
4545 // we know that line->mFirstChild is not the last flow block
4546 // therefore zero out the running margin value.
4547 #ifdef NOISY_BLOCK_DIR_MARGINS
4553 #endif
4556 // Disconnect the next-in-flow and put it in our overflow tracker
4559 // It already exists, but as a normal next-in-flow, so we need
4560 // to dig it out of the child lists.
4564 }
4566 // Put it in our overflow list
4570 #ifdef NOISY_BLOCK_DIR_MARGINS
4576 #endif
4578 }
4580 #ifdef NOISY_BLOCK_DIR_MARGINS
4586 #endif
4588 }
4589 #ifdef NOISY_BLOCK_DIR_MARGINS
4596 #endif
4599 // The frame reported an incomplete status, but then it also didn't
4600 // fit. This means we need to reflow it again so that it can
4601 // (again) report the incomplete status.
4603 }
4607 // If it's our very first line *or* we're not at the top of the page
4608 // and we have page-break-inside:avoid, then we need to be pushed to
4609 // our parent's next-in-flow.
4612 // Push the line that didn't fit and any lines that follow it
4613 // to our next-in-flow.
4615 }
4616 }
4617 }
4619 }
4621 // Now that we've got its final position all figured out, position any child
4622 // views it may have. Note that the case when frame has a view got handled
4623 // by FinishReflowChild, but that function didn't have the coordinates needed
4624 // to correctly decide whether to reposition child views.
4627 }
4629 #ifdef DEBUG
4631 #endif
4632 }
4635 LineIterator aLine,
4641 // Setup initial coordinate system for reflowing the inline frames
4642 // into. Apply a previous block frame's block-end margin first.
4645 }
4648 LineReflowStatus lineReflowStatus;
4661 // Once upon a time we allocated the first 30 nsLineLayout objects
4662 // on the stack, and then we switched to the heap. At that time
4663 // these objects were large (1100 bytes on a 32 bit system).
4664 // Then the nsLineLayout object was shrunk to 156 bytes by
4665 // removing some internal buffers. Given that it is so much
4666 // smaller, the complexity of 2 different ways of allocating
4667 // no longer makes sense. Now we always allocate on the stack.
4673 }
4685 // If there is no saved break position, then this will set
4686 // set forceBreakInFrame to null and we won't back up, which is
4687 // correct.
4692 }
4693 // restore the float manager state
4695 // Clear out float lists
4699 }
4701 // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
4706 }
4709 LineIterator aLine,
4712 // Reflow the line again when we reflow at our new position.
4715 }
4718 LineIterator aLine,
4723 }
4730 // Forget all of the floats on the line
4734 // We need to set this flag on the line if any of our reflow passes
4735 // are impacted by floats.
4738 }
4739 #ifdef REALLY_NOISY_REFLOW
4742 #endif
4751 nscoord availBSize;
4755 /* XXX get the height right! */
4757 }
4759 // Make sure to enable resize optimization before we call BeginLineReflow
4760 // because it might get disabled there
4770 // XXX Unfortunately we need to know this before reflowing the first
4771 // inline frame in the line. FIX ME.
4774 NS_BLOCK_HAS_FIRST_LETTER_STYLE)) {
4776 }
4781 // Reflow the frames that are already on the line first
4787 // There is a soft break opportunity at the start of the line, because
4788 // we can always move this line down below float(s).
4792 }
4793 }
4795 // need to repeatedly call GetChildCount here, because the child
4796 // count can change during the loop!
4802 // It is possible that one or more of next lines are empty
4803 // (because of DeleteNextInFlowChild). If so, delete them now
4804 // in case we are finished.
4807 // XXX Is this still necessary now that DeleteNextInFlowChild
4808 // uses DoRemoveFrame?
4813 }
4817 "ReflowInlineFrame should never determine that a line "
4819 }
4820 }
4822 // Don't pull up new frames into lines with continuation placeholders
4824 // Pull frames and reflow them until we can't
4829 }
4835 // We just created a continuation for aFrame AND its going
4836 // to end up on this line (e.g. :first-letter
4837 // situation). Therefore we have to loop here before trying
4838 // to pull another frame.
4842 }
4843 }
4844 }
4845 }
4849 // We only need to backup if the line isn't going to be reflowed again anyway
4855 "We shouldn't be backing up more than once! "
4856 "Someone must have set a break opportunity beyond the available width, "
4859 }
4861 // We need to try backing up to before a text run
4862 // XXX It's possible, in fact not unusual, for the break opportunity to
4863 // already be the end of the line. We should detect that and optimize to not
4864 // re-do the line.
4866 // We can back up!
4868 }
4870 // In case we reflow this line again, remember that we don't
4871 // need to force any breaking
4873 }
4876 // This happens only when we have a line that is impacted by
4877 // floats and the first element in the line doesn't fit with
4878 // the floats.
4879 //
4880 // If there's block space available, we either try to reflow the line
4881 // past the current band (if it's non-zero and the band definitely won't
4882 // widen around a shape-outside), otherwise we try one pixel down. If
4883 // there's no block space available, we push the line to the next
4884 // page/column.
4889 // See the analogous code for blocks in BlockReflowState::ClearFloats.
4895 // We should never hit this case if we've placed floats on the
4896 // line; if we have, then the GetFloatAvailableSpace call is wrong
4897 // and needs to happen after the caller pops the float manager
4898 // state.
4902 // Move it down far enough to clear the current band.
4905 // Move it down by one dev pixel.
4907 }
4911 // There's nowhere to retry placing the line, so we want to push
4912 // it to the next page/column where its contents can fit not
4913 // next to a float.
4916 }
4918 // XXX: a small optimization can be done here when paginating:
4919 // if the new Y coordinate is past the end of the block then
4920 // push the line and return now instead of later on after we are
4921 // past the float.
4924 // If we are propagating out a break-before status then there is
4925 // no point in placing the line.
4929 aKeepReflowGoing)) {
4931 // PlaceLine already called GetFloatAvailableSpaceForBSize or its
4932 // variant for us.
4933 }
4934 }
4935 }
4936 #ifdef DEBUG
4940 }
4941 #endif
4944 // aLine may have been pushed to the overflow lines.
4946 // We can't just compare iterators front() to aLine here, since they may be
4947 // in different lists.
4951 // aLine is stale, it's associated with the main line list but it should
4952 // be associated with the overflow line list now
4954 }
4960 }
4961 }
4962 }
4965 }
4967 /**
4968 * Reflow an inline frame. The reflow status is mapped from the frames
4969 * reflow status to the lines reflow status (not to our reflow status).
4970 * The line reflow status is simple: true means keep placing frames
4971 * on the line; false means don't (the line is done). If the line
4972 * has some sort of breaking affect then aLine's break-type will be set
4973 * to something other than StyleClear::None.
4974 */
4982 #ifdef NOISY_FIRST_LETTER
4988 #endif
4993 }
4995 // Reflow the inline frame
4996 nsReflowStatus frameReflowStatus;
5002 }
5004 #ifdef REALLY_NOISY_REFLOW
5007 #endif
5009 #if defined(REFLOW_STATUS_COVERAGE)
5011 #endif
5013 // Send post-reflow notification
5016 /* XXX
5017 This is where we need to add logic to handle some odd behavior.
5018 For one thing, we should usually place at least one thing next
5019 to a left float, even when that float takes up all the width on a line.
5020 see bug 22496
5021 */
5023 // Process the child frames reflow status. There are 5 cases:
5024 // complete, not-complete, break-before, break-after-complete,
5025 // break-after-not-complete. There are two situations: we are a
5026 // block or we are an inline. This makes a total of 10 cases
5027 // (fortunately, there is some overlap).
5031 // Always abort the line reflow (because a line break is the
5032 // minimal amount of break we do).
5035 // XXX what should aLine's break-type be set to in all these cases?
5037 // Break-before cases.
5039 // If we break before the first frame on the line then we must
5040 // be trying to place content where there's no room (e.g. on a
5041 // line with wide floats). Inform the caller to reflow the
5042 // line after skipping past a float.
5045 // It's not the first child on this line so go ahead and split
5046 // the line. We will see the frame again on the next-line.
5049 // If we're splitting the line because the frame didn't fit and it
5050 // was pushed, then mark the line as having word wrapped. We need to
5051 // know that if we're shrink wrapping our width
5054 }
5055 }
5061 // If a float split and its prev-in-flow was followed by a <BR>, then
5062 // combine the <BR>'s float clear type with the inline's float clear type
5063 // (the inline will be the very next frame after the split float).
5069 }
5070 // Break-after cases
5073 }
5075 // Split line, but after the frame just reflowed
5077 aLineReflowStatus);
5082 }
5083 }
5084 }
5085 }
5088 // Create a continuation for the incomplete frame. Note that the
5089 // frame may already have a continuation.
5092 // Remember that the line has wrapped
5095 }
5097 // If we just ended a first-letter frame or reflowed a placeholder then
5098 // don't split the line and don't stop the line reflow...
5099 // But if we are going to stop anyways we'd better split the line.
5103 // Split line after the current frame
5106 aLineReflowStatus);
5107 }
5108 }
5109 }
5116 newFrame =
5123 }
5124 }
5125 #ifdef DEBUG
5127 #endif
5129 }
5143 }
5146 }
5148 nextInFlow =
5150 }
5153 }
5161 }
5169 }
5170 }
5176 }
5185 }
5186 }
5189 }
5201 #ifdef DEBUG
5210 }
5214 }
5215 }
5216 #endif
5221 #ifdef DEBUG
5222 {
5228 }
5230 }
5231 #endif
5233 // Put frames being split out into their own line
5236 #ifdef DEBUG
5239 }
5240 #endif
5242 // Let line layout know that some frames are no longer part of its
5243 // state.
5246 // If floats have been placed whose placeholders have been pushed to the new
5247 // line, we need to reflow the old line again. We don't want to look at the
5248 // frames in the new line, because as a large paragraph is laid out the
5249 // we'd get O(N^2) performance. So instead we just check that the last
5250 // float and the last below-current-line float are still in aLine.
5258 }
5260 #ifdef DEBUG
5262 #endif
5263 }
5264 }
5268 // There is another line
5270 // If the next line is a block line then this line is the last in a
5271 // group of inline lines.
5273 }
5274 // The next line is empty, try the next one
5275 }
5277 // Try our next-in-flows lines to answer the question
5283 }
5284 }
5286 }
5288 // This is the last line - so don't allow justification
5290 }
5298 // Try to position the floats in a nowrap context.
5301 // Trim extra white-space from the line before placing the frames
5304 // Vertically align the frames on this line.
5305 //
5306 // According to the CSS2 spec, section 12.6.1, the "marker" box
5307 // participates in the height calculation of the list-item box's
5308 // first line box.
5309 //
5310 // There are exactly two places a ::marker can be placed: near the
5311 // first or second line. It's only placed on the second line in a
5312 // rare case: when the first line is empty.
5327 }
5330 // We want to consider the floats in the current line when determining
5331 // whether the float available space is shrunk. If mLineBSize doesn't
5332 // exist, we are in the first pass trying to place the line. Calling
5333 // GetFloatAvailableSpace() like we did in BlockReflowState::AddFloat()
5334 // for UpdateBand().
5336 // floatAvailableSpaceWithOldLineBSize is the float available space with
5337 // the old BSize, but including the floats that were added in this line.
5338 LogicalRect floatAvailableSpaceWithOldLineBSize =
5341 : aState
5346 // As we redo for floats, we can't reduce the amount of BSize we're
5347 // checking.
5349 LogicalRect floatAvailableSpaceWithLineBSize =
5350 aState
5355 // If the available space between the floats is smaller now that we
5356 // know the BSize, return false (and cause another pass with
5357 // LineReflowStatus::RedoMoreFloats). We ensure aAvailableSpaceBSize
5358 // never decreases, which means that we can't reduce the set of floats
5359 // we intersect, which means that the available space cannot grow.
5362 // Prepare data for redoing the line.
5365 // Since we want to redo the line, we update aFlowArea by using the
5366 // aFloatStateBeforeLine, which is the float manager's state before the
5367 // line is placed.
5375 // Restore the BSize to the position of the next band.
5378 // Enforce both IStart() and IEnd() never move outwards to prevent
5379 // infinite grow-shrink loops.
5387 }
5390 }
5393 }
5395 #ifdef DEBUG
5405 }
5408 }
5409 }
5410 #endif
5412 // Only block frames horizontally align their children because
5413 // inline frames "shrink-wrap" around their children (therefore
5414 // there is no extra horizontal space).
5417 /**
5418 * We don't care checking for IsLastLine properly if we don't care (if it
5419 * can't change the used text-align value for the line).
5420 *
5421 * In other words, isLastLine really means isLastLineAndWeCare.
5422 */
5430 // From here on, pfd->mBounds rectangles are incorrect because bidi
5431 // might have moved frames around!
5432 OverflowAreas overflowAreas;
5437 }
5439 // Inline lines do not have margins themselves; however they are
5440 // impacted by prior block margins. If this line ends up having some
5441 // height then we zero out the previous block-end margin value that was
5442 // already applied to the line's starting Y coordinate. Otherwise we
5443 // leave it be so that the previous blocks block-end margin can be
5444 // collapsed with a block that follows.
5445 nscoord newBCoord;
5448 // This line has some height. Therefore the application of the
5449 // previous-bottom-margin should stick.
5453 // Don't let the previous-bottom-margin value affect the newBCoord
5454 // coordinate (it was applied in ReflowInlineFrames speculatively)
5455 // since the line is empty.
5456 // We already called |ShouldApplyBStartMargin|, and if we applied it
5457 // then mShouldApplyBStartMargin is set.
5462 }
5469 }
5471 // See if the line fit (our first line always does).
5477 // All our content doesn't fit, start on the next page.
5480 // Push aLine and all of its children and anything else that
5481 // follows to our next-in-flow.
5483 }
5485 }
5487 // Note that any early return before this update of aState.mBCoord
5488 // must either (a) return false or (b) set aKeepReflowGoing to false.
5489 // Otherwise we'll keep reflowing later lines at an incorrect
5490 // position, and we might not come back and clean up the damage later.
5493 // Add the already placed current-line floats to the line
5496 // Any below current line floats to place?
5498 // Reflow the below-current-line floats, which places on the line's
5499 // float list.
5501 }
5503 // When a line has floats, factor them into the overflow areas computations.
5505 // Union the float overflow areas (stored in aState) and the value computed
5506 // by the line layout code.
5511 #ifdef NOISY_OVERFLOW_AREAS
5516 #endif
5517 }
5519 // Apply break-after clearing if necessary
5520 // This must stay in sync with |ReflowDirtyLines|.
5524 }
5526 }
5530 // NOTE: aLineBefore is always a normal line, not an overflow line.
5531 // The following expression will assert otherwise.
5536 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
5540 // Remove floats in the lines from mFloats
5541 nsFrameList floats;
5545 #ifdef DEBUG
5549 }
5550 #endif
5551 // Push the floats onto the front of the overflow out-of-flows list
5554 }
5556 // overflow lines can already exist in some cases, in particular,
5557 // when shrinkwrapping and we discover that the shrinkwap causes
5558 // the height of some child block to grow which creates additional
5559 // overflowing content. In such cases we must prepend the new
5560 // overflow to the existing overflow.
5563 // XXXldb use presshell arena!
5565 }
5575 }
5583 // this takes ownership but it won't delete it immediately so we
5584 // can keep using it.
5587 // Mark all the overflow lines dirty so that they get reflowed when
5588 // they are pulled up by our next-in-flow.
5590 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
5600 }
5601 }
5602 }
5603 }
5605 #ifdef DEBUG
5607 #endif
5608 }
5610 // The overflowLines property is stored as a pointer to a line list,
5611 // which must be deleted. However, the following functions all maintain
5612 // the invariant that the property is never set if the list is empty.
5615 #ifdef DEBUG
5617 #endif
5619 // Steal the prev-in-flow's overflow lines and prepend them.
5626 // Make all the frames on the overflow line list mine.
5629 // Collect overflow containers from our OverflowContainers list that are
5630 // continuations from the frames we picked up from our prev-in-flow, then
5631 // prepend those to ExcessOverflowContainers to ensure the continuations
5632 // are ordered.
5634 nsFrameList ocContinuations;
5646 }
5648 }
5651 }
5652 }
5658 }
5659 }
5660 }
5662 // Make the overflow out-of-flow frames mine too.
5665 // In case we own any next-in-flows of any of the drained frames, then
5666 // move those to the PushedFloat list.
5667 nsFrameList pushedFloats;
5674 }
5675 }
5681 }
5682 }
5685 // Remember to recompute the margins on the first line. This will
5686 // also recompute the correct deltaBCoord if necessary.
5688 }
5689 // The overflow lines have already been marked dirty and their previous
5690 // margins marked dirty also.
5692 // Prepend the overflow frames/lines to our principal list.
5698 }
5699 }
5701 // Now append our own overflow lines.
5703 }
5709 }
5711 // No need to reparent frames in our own overflow lines/oofs, because they're
5712 // already ours. But we should put overflow floats back in mFloats.
5713 // (explicit scope to remove the OOF list before VerifyOverflowSituation)
5714 {
5717 #ifdef DEBUG
5721 }
5722 #endif
5723 // The overflow floats go after our regular floats.
5725 }
5726 }
5730 }
5732 #ifdef DEBUG
5734 #endif
5736 }
5738 /**
5739 * Pushed floats are floats whose placeholders are in a previous
5740 * continuation. They might themselves be next-continuations of a float
5741 * that partially fit in an earlier continuation, or they might be the
5742 * first continuation of a float that couldn't be placed at all.
5743 *
5744 * Pushed floats live permanently at the beginning of a block's float
5745 * list, where they must live *before* any floats whose placeholders are
5746 * in that block.
5747 *
5748 * Temporarily, during reflow, they also live on the pushed floats list,
5749 * which only holds them between (a) when one continuation pushes them to
5750 * its pushed floats list because they don't fit and (b) when the next
5751 * continuation pulls them onto the beginning of its float list.
5752 *
5753 * DrainPushedFloats sets up pushed floats the way we need them at the
5754 * start of reflow; they are then reflowed by ReflowPushedFloats (which
5755 * might push some of them on). Floats with placeholders in this block
5756 * are reflowed by (BlockReflowState/nsLineLayout)::AddFloat, which
5757 * also maintains these invariants.
5758 *
5759 * DrainSelfPushedFloats moves any pushed floats from this block's own
5760 * PushedFloats list back into mFloats. DrainPushedFloats additionally
5761 * moves frames from its prev-in-flow's PushedFloats list into mFloats.
5762 */
5764 // If we're getting reflowed multiple times without our
5765 // next-continuation being reflowed, we might need to pull back floats
5766 // that we just put in the list to be pushed to our next-in-flow.
5767 // We don't want to pull back any next-in-flows of floats on our own
5768 // float list, and we only need to pull back first-in-flows whose
5769 // placeholders were in earlier blocks (since first-in-flows whose
5770 // placeholders are in this block will get pulled appropriately by
5771 // AddFloat, and will then be more likely to be in the correct order).
5775 // When we pull back floats, we want to put them with the pushed
5776 // floats, which must live at the start of our float list, but we
5777 // want them at the end of those pushed floats.
5778 // FIXME: This isn't quite right! What if they're all pushed floats?
5784 }
5794 // This is a first continuation that was pushed from one of our
5795 // previous continuations. Take it out of the pushed floats
5796 // list and put it in our floats list, before any of our
5797 // floats, but after other pushed floats.
5800 }
5803 }
5807 }
5808 }
5809 }
5814 // After our prev-in-flow has completed reflow, it may have a pushed
5815 // floats list, containing floats that we need to own. Take these.
5821 }
5822 }
5823 }
5828 }
5837 }
5842 }
5852 }
5861 }
5863 // This takes ownership of aOverflowLines.
5864 // XXX We should allocate overflowLines from presShell arena!
5874 // Verify that we won't overwrite an existing overflow list
5878 }
5883 }
5887 }
5898 }
5912 }
5913 }
5918 }
5923 }
5928 }
5933 }
5938 }
5943 }
5947 }
5953 }
5960 }
5965 }
5970 }
5972 //////////////////////////////////////////////////////////////////////
5973 // Frame list manipulation routines
5978 }
5984 }
5987 }
5989 // Find the proper last-child for where the append should go
5995 #ifdef NOISY_REFLOW_REASON
6000 }
6004 }
6006 #endif
6011 // Workaround for bug 1399425 in case this bit has been removed from the
6012 // SVGTextFrame just before the parser adds more descendant nodes.
6014 }
6021 }
6022 }
6035 }
6038 }
6040 #ifdef NOISY_REFLOW_REASON
6045 }
6049 }
6051 #endif
6058 }
6059 }
6063 #ifdef NOISY_REFLOW_REASON
6068 #endif
6075 }
6077 // Make sure to mark affected lines dirty for the float frame
6078 // we are removing; this way is a bit messy, but so is the rest of the code.
6079 // See bug 390762.
6087 }
6090 // Skip the call to |FrameNeedsReflow| below by returning now.
6095 }
6100 }
6106 }
6107 // XXX the TEXT_OFFSETS_NEED_FIXING check is a wallpaper for bug 822910.
6111 }
6113 }
6117 // Clear our line cursor, since our lines may change.
6122 }
6124 // Attempt to find the line that contains the previous sibling
6138 // We need to find out which list it's actually in. Assume that
6139 // *if* we have overflow lines, that our primary lines aren't
6140 // huge, but our overflow lines might be.
6145 }
6147 }
6149 // By elimination, the line must be in our overflow lines.
6152 }
6153 }
6166 // XXX_perf This is technically O(N^2) in some cases, but by using
6167 // RFind instead of Find, we make it O(N) in the most common case,
6168 // which is appending content.
6170 // Find the line that contains the previous sibling
6174 // Not in mLines - try overflow lines.
6183 }
6188 // Note: defensive code! RFindLineContaining must not return
6189 // false in this case, so if it does...
6193 }
6194 }
6195 }
6196 }
6198 // Find the frame following aPrevSibling so that we can join up the
6199 // two lists of frames.
6201 // Split line containing aPrevSibling in two if the insertion
6202 // point is somewhere in the middle of the line.
6205 // Split the line in two where the frame(s) are being inserted.
6209 // Mark prevSibLine dirty and as needing textrun invalidation, since
6210 // we may be breaking up text in the line. Its previous line may also
6211 // need to be invalidated because it may be able to pull some text up.
6213 // The new line will also need its textruns recomputed because of the
6214 // frame changes.
6217 }
6221 }
6225 // Walk through the new frames being added and update the line data
6226 // structures to fit.
6237 // If the frame is a block frame, or if there is no previous line or if the
6238 // previous line is a block line we need to make a new line. We also make
6239 // a new line, as an optimization, in the two cases we know we'll need it:
6240 // if the previous line ended with a <br>, or if it has significant
6241 // whitespace and ended in a newline.
6244 // Create a new line for the frame and add its line to the line
6245 // list.
6248 // Append new line after prevSibLine
6252 // New line is going before the other lines
6255 }
6258 // We're adding inline content to prevSibLine, so we need to mark it
6259 // dirty, ensure its textruns are recomputed, and possibly do the same
6260 // to its previous line since that line may be able to pull content up.
6262 }
6265 }
6267 #ifdef DEBUG
6270 #endif
6271 }
6279 }
6281 }
6284 // 'display:block ruby' use the inner (Ruby) frame for insertions.
6287 }
6289 }
6295 }
6296 }
6299 // Find which line contains the float, so we can update
6300 // the float cache.
6304 }
6305 }
6306 }
6309 #ifdef DEBUG
6310 // Floats live in mFloats, or in the PushedFloat or OverflowOutOfFlows
6311 // frame list properties.
6318 }
6319 #endif
6323 }
6327 #if 0
6328 // XXXmats not yet - need to investigate BlockReflowState::mPushedFloats
6329 // first so we don't leave it pointing to a deleted list.
6332 }
6333 #endif
6335 }
6337 {
6341 }
6342 }
6343 }
6347 // The containing block is always the parent of aFrame.
6350 // Remove aFrame from the appropriate list.
6352 // This also deletes the next-in-flows
6356 // First remove aFrame's next-in-flows.
6359 }
6360 // Now remove aFrame from its child list and Destroy it.
6364 }
6365 }
6367 /**
6368 * This helps us iterate over the list of all normal + overflow lines
6369 */
6377 // Try the overflow lines
6385 }
6386 }
6387 }
6388 }
6391 LineIterator aLine)
6393 // This will assert if aLine isn't in mLines of aFrame:
6395 }
6398 LineIterator aLine,
6410 }
6416 }
6418 // Figure out what the right style parent is. This needs to match
6419 // nsCSSFrameConstructor::CreateLetterFrame.
6423 }
6430 parentStyle);
6431 // Note that we don't need to worry about changehints for the continuation
6432 // styles: those will be handled by the styleParent already.
6435 parentStyle);
6439 // We also want to update the style on the textframe inside the first-letter.
6440 // We don't need to compute a changehint for this, though, since any changes
6441 // to it are handled by the first-letter anyway.
6445 firstLetterStyle);
6448 // We don't need to update style for textFrame's continuations: it's already
6449 // set up to inherit from parentStyle, which is what we want.
6450 }
6462 }
6467 }
6470 }
6472 }
6475 }
6486 }
6492 // The block has a single line - that must be it!
6495 }
6497 // Try to use the cursor if it exists, otherwise fall back to the first line
6500 // Perform a simultaneous forward and reverse search starting from the
6501 // line cursor.
6505 // rline is positioned on the line containing 'cursor', so it's not
6506 // rline_end. So we can safely increment it (i.e. move it to one line
6507 // earlier) to start searching there.
6514 }
6516 }
6521 }
6523 }
6524 }
6529 }
6531 }
6537 }
6538 }
6539 }
6540 // Didn't find the line
6543 // If we reach here, it means that we have not been able to find the
6544 // desired frame in our in-flow lines. So we should start looking at
6545 // our overflow lines. In order to do that, we set mLine to the end
6546 // iterator so that FindValidLine starts to look at overflow lines,
6547 // if any.
6551 }
6557 }
6559 }
6563 }
6568 }
6573 }
6580 }
6589 }
6594 }
6602 }
6603 }
6605 }
6606 }
6612 }
6619 }
6624 }
6632 }
6633 }
6635 }
6636 }
6638 // This function removes aDeletedFrame and all its continuations. It
6639 // is optimized for deleting a whole series of frames. The easy
6640 // implementation would invoke itself recursively on
6641 // aDeletedFrame->GetNextContinuation, then locate the line containing
6642 // aDeletedFrame and remove aDeletedFrame from that line. But here we
6643 // start by locating aDeletedFrame and then scanning from that point
6644 // on looking for continuations.
6647 // Clear our line cursor, since our lines may change.
6651 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6657 // FIXME(emilio): aContext is lost here, maybe it's not a big deal?
6660 }
6662 }
6664 // Find the line that contains deletedFrame
6669 // Make sure we look in the overflow lines even if the normal line
6670 // list is empty
6676 }
6680 }
6685 }
6694 }
6695 }
6704 }
6706 // If the frame being deleted is the last one on the line then
6707 // optimize away the line->Contains(next-in-flow) call below.
6712 next != line_end
6719 }
6721 // Remove aDeletedFrame from the line
6723 // We should be setting this to null if aDeletedFrame
6724 // is the only frame on the line. HOWEVER in that case
6725 // we will be removing the line anyway, see below.
6727 }
6729 // Hmm, this won't do anything if we're removing a frame in the first
6730 // overflow line... Hopefully doesn't matter
6733 // Since we just removed a frame that follows some inline
6734 // frames, we need to reflow the previous line.
6736 }
6739 // Take aDeletedFrame out of the sibling list. Note that
6740 // prevSibling will only be nullptr when we are deleting the very
6741 // first frame in the main or overflow list.
6746 }
6748 // Update the child count of the line to be accurate
6751 // Destroy frame; capture its next continuation first in case we need
6752 // to destroy that too.
6757 #ifdef NOISY_REMOVE_FRAME
6763 #endif
6765 // If next-in-flow is an overflow container, must remove it first.
6766 // FIXME: Can we do this unconditionally?
6768 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6772 }
6778 // If line is empty, remove it now.
6780 #ifdef NOISY_REMOVE_FRAME
6783 #endif
6787 // Invalidate the space taken up by the line.
6788 // XXX We need to do this if we're removing a frame as a result of
6789 // a call to RemoveFrame(), but we may not need to do this in all
6790 // cases...
6791 #ifdef NOISY_BLOCK_INVALIDATE
6795 #endif
6801 // We just invalidated our iterators. Since we were in
6802 // the overflow lines list, which is now empty, set them
6803 // so we're at the end of the regular line list.
6807 }
6808 }
6811 // If we're removing a line, ReflowDirtyLines isn't going to
6812 // know that it needs to slide lines unless something is marked
6813 // dirty. So mark the previous margin of the next line dirty if
6814 // there is one.
6817 }
6820 // Make the line that just lost a frame dirty, and advance to
6821 // the next line.
6827 }
6828 }
6831 // See if we should keep looking in the current flow's line list.
6833 // The deceased frames continuation is not a child of the
6834 // current block. So break out of the loop so that we advance
6835 // to the next parent.
6836 //
6837 // If we have a continuation in a different block then all bets are
6838 // off regarding whether we are deleting frames without actual content,
6839 // so don't propagate FRAMES_ARE_EMPTY any further.
6842 }
6844 // If we advanced to the next line then check if we should switch to the
6845 // overflow line list.
6849 // We have advanced to the next *normal* line but the next-in-flow
6850 // is not there - force a switch to the overflow line list.
6852 }
6856 #ifdef NOISY_REMOVE_FRAME
6859 #endif
6860 }
6861 }
6862 }
6867 }
6869 #ifdef DEBUG
6872 #endif
6874 // Advance to next flow block if the frame has more continuations.
6877 }
6882 }
6894 }
6895 }
6897 }
6907 // Optimize by comparing the line's last child first.
6914 }
6915 }
6916 }
6918 }
6926 }
6934 }
6938 }
6956 }
6957 }
6958 }
6967 }
6972 // The line became empty - destroy it.
6977 }
6979 }
6980 }
6988 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6990 aDeletingEmptyFrames);
6992 #ifdef DEBUG
6995 }
6996 #endif
6999 }
7000 }
7003 // Return the pointer to an unmodified style text
7005 }
7017 // Setup a block reflow context to reflow the float.
7022 nsCollapsingMargin margin;
7025 // Only first in flow gets a block-start margin.
7032 // We don't need to push the float manager state because the the block
7033 // has its own float manager that will be destroyed and recreated
7034 }
7035 }
7037 // When reflowing a float, aSpace argument doesn't matter because we pass
7038 // nullptr to aLine and we don't call nsBlockReflowContext::PlaceBlock()
7039 // later.
7045 // We never split floating first letters; an incomplete status for such
7046 // frames simply means that there is more content to be reflowed on the
7047 // line.
7050 }
7051 }
7055 "The status can only be incomplete or overflow-incomplete if "
7060 }
7064 // Set the rect, make sure the view is properly sized and positioned,
7065 // and tell the frame we're done reflowing it
7066 // XXXldb This seems like the wrong place to be doing this -- shouldn't
7067 // we be doing this in BlockReflowState::FlowAndPlaceFloat after
7068 // we've positioned the float, and shouldn't we be doing the equivalent
7069 // of |PlaceFrameView| here?
7076 }
7078 }
7086 }
7087 }
7089 }
7093 // Pushed floats live at the start of our float list; see comment
7094 // above nsBlockFrame::DrainPushedFloats.
7099 // When we push a first-continuation float in a non-initial reflow,
7100 // it's possible that we end up with two continuations with the same
7101 // parent. This happens if, on the previous reflow of the block or
7102 // a previous reflow of the line containing the block, the float was
7103 // split between continuations A and B of the parent, but on the
7104 // current reflow, none of the float can fit in A.
7105 //
7106 // When this happens, we might even have the two continuations
7107 // out-of-order due to the management of the pushed floats. In
7108 // particular, if the float's placeholder was in a pushed line that
7109 // we reflowed before it was pushed, and we split the float during
7110 // that reflow, we might have the continuation of the float before
7111 // the float itself. (In the general case, however, it's correct
7112 // for floats in the pushed floats list to come before floats
7113 // anchored in pushed lines; however, in this case it's wrong. We
7114 // should probably find a way to fix it somehow, since it leads to
7115 // incorrect layout in some cases.)
7116 //
7117 // When we have these out-of-order continuations, we might hit the
7118 // next-continuation before the previous-continuation. When that
7119 // happens, just push it. When we reflow the next continuation,
7120 // we'll either pull all of its content back and destroy it (by
7121 // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
7122 // pull it out of its current position and push it again (and
7123 // potentially repeat this cycle for the next continuation, although
7124 // hopefully then they'll be in the right order).
7125 //
7126 // We should also need this code for the in-order case if the first
7127 // continuation of a float gets moved across more than one
7128 // continuation of the containing block. In this case we'd manage
7129 // to push the second continuation without this check, but not the
7130 // third and later.
7137 }
7139 // Always call FlowAndPlaceFloat; we might need to place this float if it
7140 // didn't belong to this block the last time it was reflowed. Note that if
7141 // the float doesn't get placed, we don't consider its overflow areas.
7142 // (Not-getting-placed means it didn't fit and we pushed it instead of
7143 // placing it, and its position could be stale.)
7147 }
7151 // We didn't push |f| so its next-sibling is next.
7156 }
7158 // If there are pushed or split floats, then we may need to continue BR
7159 // clearance
7165 }
7166 }
7167 }
7171 // Recover our own floats
7173 // belong to our next-in-flow
7180 }
7181 }
7183 // Recurse into our overflow container children
7188 }
7190 // Recurse into our normal children
7194 }
7195 }
7196 }
7200 WritingMode aWM,
7204 // Only blocks have floats
7206 // Don't recover any state inside a block that has its own float manager
7207 // (we don't currently have any blocks like this, though, thanks to our
7208 // use of extra frames for 'overflow')
7210 // If the element is relatively positioned, then adjust x and y
7211 // accordingly so that we consider relatively positioned frames
7212 // at their original position.
7220 }
7221 }
7225 // If we have pushed floats, then they should be at the beginning of our
7226 // float list.
7229 }
7230 }
7232 #ifdef DEBUG
7233 // Double-check the above assertion that pushed floats should be at the
7234 // beginning of our floats list.
7238 }
7239 #endif
7241 // We may have a pending push of pushed floats too:
7243 // XXX we can return 'true' here once we make HasPushedFloats
7244 // not lie. (see nsBlockFrame::RemoveFloat)
7247 }
7249 }
7251 //////////////////////////////////////////////////////////////////////
7252 // Painting, event handling
7254 #ifdef DEBUG
7260 // Compute min and max x/y values for the reflowed frame's
7261 // combined areas
7269 }
7272 }
7275 }
7278 }
7279 }
7285 }
7286 #endif
7288 #ifdef DEBUG
7297 }
7298 }
7299 #endif
7307 #ifdef DEBUG
7309 aDrawnLines++;
7310 }
7314 #endif
7316 // Collect our line's display items in a temporary nsDisplayListCollection,
7317 // so that we can apply any "text-overflow" clipping to the entire collection
7318 // without affecting previous lines.
7321 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
7322 // Inline-level child backgrounds go on the regular child content list.
7324 collection,
7328 aLineInLine
7337 }
7341 aLineNumberForTextOverflow);
7342 }
7345 }
7351 #ifdef DEBUG
7355 nsRect ca;
7362 }
7367 }
7368 #endif
7370 // TODO(heycam): Should we boost the load priority of any shape-outside
7371 // images using CATEGORY_DISPLAY, now that this block is being displayed?
7372 // We don't have a float manager here.
7381 }
7382 }
7383 }
7388 // Display outside ::marker manually.
7390 }
7392 // Prepare for text-overflow processing.
7401 // TODO(miko): Unfortunately |descendAlways| cannot be cached, because with
7402 // some frame trees, building display list for child lines can change it.
7403 // See bug 1552789.
7411 };
7415 // We'll try to draw an accessibility backplate behind text (to ensure it's
7416 // readable over any possible background-images), if all of the following
7417 // hold:
7418 // (A) the backplate feature is preffed on
7419 // (B) we are not honoring the document colors
7420 // (C) the force color adjust property is set to auto
7425 }
7427 // Don't use the line cursor if we might have a descendant placeholder ...
7428 // it might skip lines that contain placeholders but don't themselves
7429 // intersect with the dirty area.
7430 // In particular, we really want to check ShouldDescendIntoFrame()
7431 // on all our child frames, but that might be expensive. So we
7432 // approximate it by checking it on |this|; if it's true for any
7433 // frame in our child list, it's also true for |this|.
7434 // Also skip the cursor if we're creating text overflow markers,
7435 // since we need to know what line number we're up to in order
7436 // to generate unique display item keys.
7437 // Lastly, the cursor should be skipped if we're drawing
7438 // backplates behind text. When backplating we consider consecutive
7439 // runs of text as a whole, which requires we iterate through all lines
7440 // to find our backplate size.
7453 // Because we have a cursor, the combinedArea.ys are non-decreasing.
7454 // Once we've passed aDirtyRect.YMost(), we can never see it again.
7457 }
7463 }
7464 }
7465 }
7472 // A frame's display list cannot contain more than one copy of a
7473 // given display item unless the items are uniquely identifiable.
7474 // Because backplate occasionally requires multiple
7475 // SolidColor items, we use an index (backplateIndex) to maintain
7476 // uniqueness among them. Note this is a mapping of index to
7477 // item, and the mapping is stable even if the dirty rect changes.
7479 nsRect curBackplateArea;
7485 };
7494 }
7497 // If we have encountered a non-inline line but were previously
7498 // forming a backplate, we should add the backplate to the display
7499 // list as-is and render future backplates disjointly.
7501 "if this master switch is off, curBackplateArea "
7504 backplateIndex++;
7506 }
7511 }
7521 }
7522 }
7523 }
7524 lineCount++;
7525 }
7529 }
7533 }
7534 }
7537 // Put any text-overflow:ellipsis markers on top of the non-positioned
7538 // content of the block's lines. (If we ever start sorting the Content()
7539 // list this will end up in the wrong place.)
7541 }
7543 #ifdef DEBUG
7550 }
7564 }
7565 #endif
7566 }
7568 #ifdef ACCESSIBILITY
7572 }
7574 // block frame may be for <hr>
7577 }
7580 // XXXsmaug What if we're in the shadow dom?
7582 // Don't create accessible objects for the root content node, they are
7583 // redundant with the nsDocAccessible object created with the document
7584 // node
7586 }
7589 // Don't create accessible objects for the body, they are redundant with
7590 // the nsDocAccessible object created with the document node
7592 }
7594 // Not a list item with a ::marker, treat as normal HTML container.
7596 }
7598 // Create special list item accessible since we have a ::marker.
7600 }
7601 #endif
7606 }
7610 }
7615 }
7619 }
7622 // Although this looks like a "querying" method, it is used by the
7623 // display-list building code, so uses the Display cursor.
7627 }
7635 }
7640 }
7644 }
7647 }
7649 /* virtual */
7651 // See if the child is absolutely positioned
7653 // do nothing
7655 // The ::marker lives in the first line, unless the first line has
7656 // height 0 and there is a second line, in which case it lives
7657 // in the second line.
7662 }
7666 }
7667 // otherwise we have an empty line list, and ReflowDirtyLines
7668 // will handle reflowing the ::marker.
7670 // Note that we should go through our children to mark lines dirty
7671 // before the next reflow. Doing it now could make things O(N^2)
7672 // since finding the right line is O(N).
7673 // We don't need to worry about marking lines on the overflow list
7674 // as dirty; we're guaranteed to reflow them if we take them off the
7675 // overflow list.
7676 // However, we might have gotten a float, in which case we need to
7677 // reflow the line containing its placeholder. So find the
7678 // ancestor-or-self of the placeholder that's a child of the block,
7679 // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
7680 // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7681 // We need to take some care to handle the case where a float is in
7682 // a different continuation than its placeholder, including marking
7683 // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7690 // SVG code sometimes sends FrameNeedsReflow notifications during
7691 // frame destruction, leading to null placeholders, but we're safe
7692 // ignoring those.
7700 }
7702 }
7704 }
7705 }
7706 }
7709 }
7713 // These are all the block specific frame bits, they are copied from
7714 // the prev-in-flow to a newly created next-in-flow, except for the
7715 // NS_BLOCK_FLAGS_NON_INHERITED_MASK bits below.
7717 NS_BLOCK_FORMATTING_CONTEXT_STATE_BITS |
7720 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7722 // This is the subset of NS_BLOCK_FLAGS_MASK that is NOT inherited
7723 // by default. They should only be set on the first-in-flow.
7726 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7729 // Copy over the inherited block frame bits from the prev-in-flow.
7733 }
7740 }
7742 // A display:flow-root box establishes a block formatting context.
7743 //
7744 // If a box has a different writing-mode value than its containing block:
7745 // ...
7746 // If the box is a block container, then it establishes a new block
7747 // formatting context.
7748 // (https://drafts.csswg.org/css-writing-modes/#block-flow)
7749 //
7750 // If the box has contain: paint or contain:layout (or contain:strict),
7751 // then it should also establish a formatting context.
7752 //
7753 // Per spec, a column-span always establishes a new block formatting context.
7763 }
7767 }
7768 }
7775 #ifdef DEBUG
7776 // The only times a block that is an anonymous box is allowed to have a
7777 // first-letter frame are when it's the block inside a non-anonymous cell,
7778 // the block inside a fieldset, button or column set, or a scrolled content
7779 // block, except for <select>. Note that this means that blocks which are
7780 // the anonymous block in {ib} splits do NOT get first-letter frames.
7781 // Note that NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations
7782 // of the block.
7800 #endif
7805 }
7806 }
7811 NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER),
7819 // An outside ::marker needs to be an independent formatting context
7820 // to avoid being influenced by the float manager etc.
7822 }
7826 }
7827 }
7838 }
7843 nscoord aLineTop) {
7848 // Make up an inline-size since it doesn't really matter (XXX).
7854 nsReflowStatus status;
7857 // Get the float available space using our saved state from before we
7858 // started reflowing the block, so that we ignore any floats inside
7859 // the block.
7860 // FIXME: aLineTop isn't actually set correctly by some callers, since
7861 // they reposition the line.
7862 LogicalRect floatAvailSpace =
7863 aState
7867 // FIXME (bug 25888): need to check the entire region that the first
7868 // line overlaps, not just the top pixel.
7870 // Place the ::marker now. We want to place the ::marker relative to the
7871 // border-box of the associated block (using the right/left margin of
7872 // the ::marker frame as separation). However, if a line box would be
7873 // displaced by floats that are *outside* the associated block, we
7874 // want to displace it by the same amount. That is, we act as though
7875 // the edge of the floats is the content-edge of the block, and place
7876 // the ::marker at a position offset from there by the block's padding,
7877 // the block's border, and the ::marker frame's margin.
7879 // IStart from floatAvailSpace gives us the content/float start edge
7880 // in the current writing mode. Then we subtract out the start
7881 // border/padding and the ::marker's width and margin to offset the position.
7883 // Get the ::marker's margin, converted to our writing mode so that we can
7884 // combine it with other logical values here.
7890 // Approximate the ::marker's position; vertical alignment will provide
7891 // the final vertical location. We pass our writing-mode here, because
7892 // it may be different from the ::marker frame's mode.
7895 wm,
7899 }
7901 // This is used to scan frames for any float placeholders, add their
7902 // floats to the list represented by aList, and remove the
7903 // floats from whatever list they might be in. We don't search descendants
7904 // that are float containing blocks. Floats that or not children of 'this'
7905 // are ignored (they are not added to aList).
7909 // Don't descend into float containing blocks.
7917 // Remove the IS_PUSHED_FLOAT bit, in case |outOfFlowFrame| came from
7918 // the PushedFloats list.
7922 // FIXME: By not pulling floats whose parent is one of our
7923 // later siblings, are we risking the pushed floats getting
7924 // out-of-order?
7925 // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
7926 }
7932 }
7935 }
7937 }
7938 }
7941 #ifdef DEBUG
7942 // If any line is still dirty, that must mean we're going to reflow this
7943 // block again soon (e.g. because we bailed out after noticing that
7944 // clearance was imposed), so don't worry if the floats are out of sync.
7947 // Check that the float list is what we would have built
7952 }
7955 }
7956 }
7965 }
7966 // There are chances that the float children won't be added to lines,
7967 // because in nsBlockFrame::ReflowLine, it skips reflow line if the first
7968 // child of the line is IsHiddenByContentVisibilityOfInFlowParentForLayout.
7969 // There are also chances that the floats in line are out of date, for
7970 // instance, lines could reflow if
7971 // PresShell::IsForcingLayoutForHiddenContent, and after forcingLayout is
7972 // off, the reflow of lines could be skipped, but the floats are still in
7973 // there. Here we can't know whether the floats hidden by c-v are included
7974 // in the lines or not. So we use hasHiddenFloats to skip the float length
7975 // checking.
7979 }
7983 }
7985 }
7990 "nsBlockFrame::CheckFloats: Explicit float list is out of sync with "
7992 # if defined(DEBUG_roc)
7996 }
7999 }
8000 # endif
8001 }
8002 #endif
8006 // Floats that were pushed should be removed from our float
8007 // manager. Otherwise the float manager's YMost or XMost might
8008 // be larger than necessary, causing this block to get an
8009 // incorrect desired height (or width). Some of these floats
8010 // may not actually have been added to the float manager because
8011 // they weren't reflowed before being pushed; that's OK,
8012 // RemoveRegions will ignore them. It is safe to do this here
8013 // because we know from here on the float manager will only be
8014 // used for its XMost and YMost, not to place new floats and
8015 // lines.
8017 }
8018 }
8028 }
8029 }
8032 // The first column is a start margin root and the last column is an end
8033 // margin root. (If the column-set is split by a column-span:all box then
8034 // the first and last column in each column-set fragment are margin roots.)
8038 }
8042 }
8044 /* static */
8052 }
8054 /* static */
8058 }
8060 // Note that this width can vary based on the vertical position.
8061 // However, the cases where it varies are the cases where the width fits
8062 // in the available space given, which means that variation shouldn't
8063 // matter.
8064 /* static */
8071 FloatAvoidingISizeToClear result;
8074 nscoord availISize =
8077 // We actually don't want the min width here; see bug 427782; we only
8078 // want to displace if the width won't compute to a value small enough
8079 // to fit.
8080 // All we really need here is the result of ComputeSize, and we
8081 // could *almost* get that from an SizeComputationInput, except for the
8082 // last argument.
8084 LogicalSize availSpace =
8091 // Use the margins from sizingInput rather than reflowInput so that
8092 // they aren't reduced by ignoring margins in overconstrained cases.
8101 // If we get here, floatAvoidingBlock has a negative amount of inline-axis
8102 // margin and an 'auto' (or ~equivalently, -moz-available) inline
8103 // size. Under these circumstances, we use the margin to establish a
8104 // (positive) minimum size for the border-box, in order to satisfy the
8105 // equation in CSS2 10.3.3. That equation essentially simplifies to the
8106 // following:
8107 //
8108 // iSize of margins + iSize of borderBox = iSize of containingBlock
8109 //
8110 // ...where "iSize of borderBox" is the sum of floatAvoidingBlock's
8111 // inline-axis components of border, padding, and {width,height}.
8112 //
8113 // Right now, in the above equation, "iSize of margins" is the only term
8114 // that we know for sure. (And we also know that it's negative, since we
8115 // got here.) The other terms are as-yet unresolved, since the frame has an
8116 // 'auto' iSize, and since we aren't yet sure if we'll clear this frame
8117 // beyond floats or place it alongside them.
8118 //
8119 // However: we *do* know that the equation's "iSize of containingBlock"
8120 // term *must* be non-negative, since boxes' widths and heights generally
8121 // can't be negative in CSS. To satisfy that requirement, we can then
8122 // infer that the equation's "iSize of borderBox" term *must* be large
8123 // enough to cancel out the (known-to-be-negative) "iSize of margins"
8124 // term. Therefore, marginISize value (negated to make it positive)
8125 // establishes a lower-bound for how much inline-axis space our border-box
8126 // will really require in order to fit alongside any floats.
8127 //
8128 // XXXdholbert This explanation is admittedly a bit hand-wavy and may not
8129 // precisely match what any particular spec requires. It's the best
8130 // reasoning I could come up with to explain engines' behavior. Also, our
8131 // behavior with -moz-available doesn't seem particularly correct here, per
8132 // bug 1767217, though that's probably due to a bug elsewhere in our float
8133 // handling code...
8135 }
8139 }
8141 /* static */
8147 // yay, candidate is a block!
8149 }
8150 // Not a block. Check its parent next.
8152 }
8155 }
8158 nscoord aBEndEdgeOfChildren) {
8169 "An overflow container's effective content-box block-size, block-start "
8181 // If a block is split by any column-spans, we calculate the final
8182 // block-size by shrinkwrapping our children's block-size for all the
8183 // fragments except for those after the final column-span, but we should
8184 // take no more than our effective border-box block-size. If there's any
8185 // leftover block-size, our next continuations will take up rest.
8186 //
8187 // We don't need to adjust aBri.mReflowStatus because our children's status
8188 // is the same as ours.
8190 }
8195 }
8197 // Save our children's reflow status.
8204 }
8210 // The maximum value our content-box block-size can take within the given
8211 // available block-size.
8214 // The block-end edge of our content-box (relative to this frame's origin) if
8215 // we consumed the maximum block-size available to us (maxContentBoxBSize).
8218 // These variables are uninitialized intentionally so that the compiler can
8219 // check they are assigned in every if-else branch below.
8220 nscoord finalContentBoxBSizeWithBStartBP;
8224 // Our effective border-box block-size can fit in the available block-size,
8225 // so we are complete.
8229 // Note: The following assertion should generally hold because, for
8230 // box-decoration-break:clone, this "else if" branch is mathematically
8231 // equivalent to the initial "if".
8233 "This else-if branch is handling a situation that's specific "
8234 "to box-decoration-break:slice, i.e. a case when we can skip "
8237 // Our effective content-box block-size plus the block-start border and
8238 // padding can fit in the available block-size, but it cannot fit after
8239 // adding the block-end border and padding. Thus, we need a continuation
8240 // (unless we already weren't asking for any block-size, in which case we
8241 // stay complete to avoid looping forever).
8245 // We aren't going to be able to fit our content-box in the space available
8246 // to it, which means we'll probably call ourselves incomplete to request a
8247 // continuation. But before making that decision, we check for certain
8248 // conditions which would force us to overflow beyond the available space --
8249 // these might result in us actually being complete if we're forced to
8250 // overflow far enough.
8254 // In this rare case, we are at the top of page/column, we have
8255 // box-decoration-break:clone and zero available block-size for our
8256 // content-box (e.g. our own block-start border and padding already exceed
8257 // the available block-size), and we didn't lay out any child to consume
8258 // our content-box block-size. To ensure we make progress (avoid looping
8259 // forever), use 1px as our content-box block-size regardless of our
8260 // effective content-box block-size, in the spirit of
8261 // https://drafts.csswg.org/css-break/#breaking-rules.
8265 // We have a unbreakable child whose block-end edge exceeds the available
8266 // block-size for children.
8268 // The unbreakable child's block-end edge forces us to consume all of
8269 // our effective content-box block-size.
8272 // Even though we've consumed all of our effective content-box
8273 // block-size, we may still need to report an incomplete status in order
8274 // to get another continuation, which will be responsible for laying out
8275 // & drawing our block-end border & padding. But if we have no such
8276 // border & padding, or if we're forced to apply that border & padding
8277 // on this frame due to box-decoration-break:clone, then we don't need
8278 // to bother with that additional continuation.
8281 // The unbreakable child's block-end edge doesn't force us to consume
8282 // all of our effective content-box block-size.
8285 }
8287 // The children's block-end edge can fit in the content-box space that we
8288 // have available for it. Consume all the space that is available so that
8289 // our inline-start/inline-end borders extend all the way to the block-end
8290 // edge of column/page.
8293 }
8294 }
8300 // We want to use children's reflow status as ours, which can be overflow
8301 // incomplete. Suppress the urge to call aBri.mReflowStatus.Reset() here.
8304 }
8307 "An overflow container should always be complete because of "
8310 finalBorderBoxBSize =
8312 }
8316 }
8317 }
8320 }
8327 }
8330 // first-letter needs to be updated before first-line, because first-line can
8331 // change the style of the first-letter.
8334 }
8344 parentStyle);
8346 // FIXME(bz): Can we make first-line continuations be non-inheriting anon
8347 // boxes?
8355 // We also want to update the styles of the first-line's descendants. We
8356 // don't need to compute a changehint for this, though, since any changes to
8357 // them are handled by the first-line anyway.
8361 }
8362 }
8363 }
8367 // Certainly no first-letter frame.
8369 }
8372 }
8378 }
8381 }
8383 #ifdef DEBUG
8387 }
8390 }
8394 // Add up the counts on each line. Also validate that IsFirstLine is
8395 // set properly.
8400 }
8405 }
8406 }
8408 }
8410 // Then count the frames
8414 frameCount++;
8416 }
8419 // Next: test that each line has right number of frames on it
8426 }
8430 }
8431 }
8442 }
8443 }
8444 }
8445 }
8447 }
8450 // Overflow out-of-flows must not have a next-in-flow in mFloats or mFrames.
8457 }
8458 }
8460 // Pushed floats must not have a next-in-flow in mFloats or mFrames.
8467 }
8468 }
8470 // A child float next-in-flow's parent must be |this| or a next-in-flow of
8471 // |this|. Later next-in-flows must have the same or later parents.
8486 }
8487 }
8489 found,
8491 }
8492 }
8493 }
8506 }
8510 }
8514 ;
8519 ;
8520 }
8522 };
8528 }
8529 }
8536 depth++;
8537 }
8539 }
8545 }
8546 #endif