| blob | a24e37f961abdde74be19024301dbc73008088cb |
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>
72 #include <inttypes.h>
90 }
91 }
93 }
94 }
102 }
104 }
106 // Mark every line at and below the line where the float was
107 // dirty, and mark their lines dirty too. We could probably do
108 // something more efficient --- e.g., just dirty the lines that intersect
109 // the float vertically.
111 }
113 /**
114 * Returns true if aFrame is a block that has one or more float children.
115 */
120 }
123 }
128 }
129 }
131 }
133 /**
134 * Determines whether the given frame is visible or has
135 * visible children that participate in the same line. Frames
136 * that are not line participants do not have their
137 * children checked.
138 */
144 }
151 }
152 }
153 }
155 }
157 /**
158 * Determines whether any of the frames descended from the
159 * given line have inline content with 'visibility: visible'.
160 * This function calls FrameHasVisibleInlineContent to process
161 * each frame in the line's child list.
162 */
169 }
172 }
175 }
177 /**
178 * Iterates through the frame's in-flow children and
179 * unions the ink overflow of all text frames which
180 * participate in the line aFrame belongs to.
181 * If a child of aFrame is not a text frame,
182 * we recurse with the child as the aFrame argument.
183 * If aFrame isn't a line participant, we skip it entirely
184 * and return an empty rect.
185 * The resulting nsRect is offset relative to the parent of aFrame.
186 */
189 nsRect textArea;
193 }
198 }
199 }
200 // add aFrame's position to keep textArea relative to aFrame's parent
202 }
204 /**
205 * Iterates through the line's children and
206 * unions the ink overflow of all text frames.
207 * GetFrameTextArea unions and returns the ink overflow
208 * from all line-participating text frames within the given child.
209 * The nsRect returned from GetLineTextArea is offset
210 * relative to the given line.
211 */
214 nsRect textArea;
221 }
224 }
226 /**
227 * Starting with aFrame, iterates upward through parent frames and checks for
228 * non-transparent background colors. If one is found, we use that as our
229 * backplate color. Otheriwse, we use the default background color from
230 * our high contrast theme.
231 */
236 // NOTE(emilio): We assume themed frames (frame->IsThemed()) have correct
237 // background-color information so as to compute the right backplate color.
238 //
239 // This holds because HTML widgets with author-specified backgrounds or
240 // borders disable theming. So as long as the UA-specified background colors
241 // match the actual theme (which they should because we always use system
242 // colors with the non-native theme, and native system colors should also
243 // match the native theme), then we're alright and we should compute an
244 // appropriate backplate color.
248 }
254 }
256 // Even if there's a background image, if there's no background color we
257 // keep going up the frame tree, see bug 1723938.
259 }
261 // Try to avoid somewhat expensive math in the common case.
264 currentBackgroundColor =
266 }
268 // If fully opaque, we're done, otherwise keep going up blending with our
269 // background.
271 }
272 }
276 }
278 }
280 #ifdef DEBUG
299 };
311 };
312 # define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
320 }
323 }
336 }
348 }
349 }
352 }
356 }
359 }
362 }
363 }
364 }
365 }
367 #endif
369 //----------------------------------------------------------------------
371 // Debugging support code
373 #ifdef DEBUG
376 };
393 }
395 }
397 #endif
399 #ifdef REFLOW_STATUS_COVERAGE
404 // 0: child-is-block
405 // 1: child-is-inline
409 }
411 // Compute new status
420 }
425 }
427 // Log updates to the status that yield different values
431 }
432 }
433 #endif
443 //----------------------------------------------------------------------
447 }
454 }
464 // Add the size of any nsLineBox::mFrames hashtables we might have:
467 }
474 }
475 }
476 }
489 }
491 // destroy overflow lines now
497 }
503 }
508 }
511 }
513 /* virtual */
521 }
523 }
529 #ifdef DEBUG_FRAME_DUMP
532 nsCString str;
540 // Output the lines
545 }
546 }
548 // Output the overflow lines.
559 }
561 }
563 // skip the principal list - we printed the lines above
564 // skip the overflow list - we printed the overflow lines above
569 }
573 }
574 #endif
583 }
585 }
595 }
597 aRebuildDisplayItems);
598 }
603 }
608 BaselineSharingGroup aBaselineGroup,
617 // XXX Is this the right test? We have some bogus empty lines
618 // floating around, but IsEmpty is perhaps too weak.
623 }
625 }
627 }
631 }
634 // `<table>` in inline-block context does not export any baseline.
636 }
645 }
649 }
650 // Ignore relative positioning for baseline calculations.
655 }
657 }
659 }
666 }
670 aExportContext);
671 }
674 aExportContext);
675 }
686 }
688 }
689 }
700 }
702 /////////////////////////////////////////////////////////////////////////////
703 // Child frame enumeration
712 }
718 }
722 }
726 }
729 }
730 }
737 }
741 }
746 }
750 }
751 }
753 /* virtual */
756 /**
757 * Remove the first line from aFromLines and adjust the associated frame list
758 * aFromFrames accordingly. The removed line is assigned to *aOutLine and
759 * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
760 * that were extracted from the head of aFromFrames.
761 * aFromLines must contain at least one line, the line may be empty.
762 * @return true if aFromLines becomes empty
763 */
773 }
775 //////////////////////////////////////////////////////////////////////
776 // Reflow methods
778 /* virtual */
787 }
788 }
791 }
797 }
806 }
807 }
808 }
810 // Whether this line is indented by the text-indent amount.
816 // If not the first line of the block, but 'each-line' is in effect,
817 // check if the previous line was not wrapped.
819 }
821 // There's a prev-in-flow, so this only counts as a first-line if
822 // 'each-line' and the prev-in-flow's last line was not wrapped.
826 }
828 }();
830 // The 'hanging' option inverts which lines are/aren't indented.
832 }
834 /* virtual */
839 }
847 }
852 }
854 #ifdef DEBUG
859 }
861 #endif
866 }
871 }
874 InlineMinISizeData data;
880 #ifdef DEBUG
885 }
887 #endif
896 }
905 }
906 }
907 }
908 #ifdef DEBUG
913 }
914 #endif
915 }
916 }
921 }
923 /* virtual */
928 }
936 }
941 }
943 #ifdef DEBUG
948 }
950 #endif
955 }
960 }
961 InlinePrefISizeData data;
967 #ifdef DEBUG
972 }
974 #endif
976 StyleClear clearType;
981 }
991 // XXXmats should the test below be indent > 0?
994 }
995 }
1002 }
1003 }
1004 #ifdef DEBUG
1009 }
1010 #endif
1011 }
1012 }
1017 }
1020 // be conservative
1023 }
1025 }
1027 /* virtual */
1033 }
1038 nsresult rv;
1039 InlinePrefISizeData data;
1056 }
1068 }
1069 }
1070 }
1071 }
1075 }
1077 /**
1078 * Return whether aNewAvailableSpace is smaller *on either side*
1079 * (inline-start or inline-end) than aOldAvailableSpace, so that we know
1080 * if we need to redo layout on an line, replaced block, or block
1081 * formatting context, because its height (which we used to compute
1082 * aNewAvailableSpace) caused it to intersect additional floats.
1083 */
1089 // Positions are not significant if the inline size is zero.
1091 }
1096 "available space should not shrink on the start side and "
1101 "available space should not grow on the start side and "
1108 }
1109 // Have we shrunk on either side?
1112 }
1116 // The issue here is that for a 'height' of 'auto' the reflow input
1117 // code won't know how to calculate the containing block height
1118 // because it's calculated bottom up. So we use our own computed
1119 // size as the dimensions.
1123 // Containing block is relative to the padding edge
1131 }
1133 // We are a wrapped frame for the content (and the wrapper is not the
1134 // canvas frame, whose size is not meaningful here).
1135 // Use the container's dimensions, if they have been precomputed.
1136 // XXX This is a hack! We really should be waiting until the outermost
1137 // frame is fully reflowed and using the resulting dimensions, even
1138 // if they're intrinsic.
1139 // In fact we should be attaching absolute children to the outermost
1140 // frame and not always sticking them in block frames.
1142 // First, find the reflow input for the outermost frame for this content.
1150 }
1154 }
1156 // For scroll containers, we can just use cbSize (which is the padding-box
1157 // size of the scrolled-content frame).
1159 // Assert that we're not missing any frames between the abspos containing
1160 // block and the scroll container.
1161 // the parent.
1165 }
1167 // Same for fieldsets, where the inner anonymous frame has the correct padding
1168 // area with the legend taken into account.
1171 }
1173 // We found a reflow input for the outermost wrapping frame, so use
1174 // its computed metrics if available, converted to our writing mode
1180 }
1184 }
1187 }
1189 /**
1190 * Returns aFrame if it is a non-BFC block frame, and null otherwise.
1191 *
1192 * This is used to determine whether to recurse into aFrame when applying
1193 * -webkit-line-clamp.
1194 */
1199 }
1200 }
1202 }
1207 }
1212 }
1216 }
1220 }
1222 // For now, -webkit-box is the only thing allowed to be a line-clamp root.
1223 // Ideally we'd just make this work everywhere, but for now we're carrying
1224 // this forward as a limitation on the legacy -webkit-line-clamp feature,
1225 // since relaxing this limitation might create webcompat trouble.
1228 // If we're the anonymous block inside the scroll frame, we need to look
1229 // at the original display of our parent frame.
1234 ":-moz-scrolled-content should inherit -webkit-line-clamp, "
1237 }
1239 }();
1241 }
1246 }
1252 }
1255 }
1256 }
1258 }
1260 /**
1261 * Iterator over all descendant inline line boxes, except for those that are
1262 * under an independent formatting context.
1263 */
1272 }
1273 }
1278 // Advances the iterator to the next line line.
1279 //
1280 // Next() shouldn't be called once the iterator is at the end, which can be
1281 // checked for by GetCurrentLine() or GetCurrentFrame() returning null.
1287 }
1293 // Reached the end of the current block. Pop the parent off the
1294 // stack; if there isn't one, then we've reached the end.
1298 }
1312 // Some kind of frame we shouldn't descend into.
1314 }
1318 }
1319 }
1320 }
1322 // The current line within the current block.
1323 //
1324 // When this is equal to mEnd, the iterator is at its end, and mCurrentFrame
1325 // is set to null.
1328 // The iterator end for the current block.
1331 // The current block.
1334 // Stack of mCurrentFrame and mEnd values that we push and pop as we enter and
1335 // exist blocks.
1337 };
1345 }
1346 }
1347 }
1349 }
1357 }
1358 }
1360 // We didn't find a line with the ellipsis; it must have been deleted already.
1362 }
1372 }
1379 #ifdef DEBUG
1386 }
1393 }
1394 #endif
1396 // ColumnSetWrapper's children depend on ColumnSetWrapper's block-size or
1397 // max-block-size because both affect the children's available block-size.
1400 }
1407 }
1408 });
1414 // If we have non-auto block size, we're clipping our kids and we fit,
1415 // make sure our kids fit too.
1421 physicalBlockAxis)) {
1422 LogicalMargin blockDirExtras =
1427 // Block-end margin never causes us to create continuations, so we
1428 // don't need to worry about whether it fits in its entirety.
1431 }
1438 }
1439 }
1443 }
1445 // OK, some lines may be reflowed. Blow away any saved line cursor
1446 // because we may invalidate the nondecreasing
1447 // overflowArea.InkOverflow().y/yMost invariant, and we may even
1448 // delete the line with the line cursor.
1451 // See comment below about oldSize. Use *only* for the
1452 // abs-pos-containing-block-size-change optimization!
1455 // Should we create a float manager?
1458 // XXXldb If we start storing the float manager in the frame rather
1459 // than keeping it around only during reflow then we should create it
1460 // only when there are actually floats to manage. Otherwise things
1461 // like tables will gain significant bloat.
1465 }
1470 }
1472 // Whether to apply text-wrap: balance behavior.
1477 // Struct used to hold the "target" number of lines or clamp position to
1478 // maintain when doing text-wrap: balance.
1480 // If line-clamp is in effect, mContent and mOffset indicate the starting
1481 // position of the first line after the clamp limit. If line-clamp is not
1482 // in use, mContent is null and mOffset is the total number of lines that
1483 // the block must contain.
1489 }
1492 }
1493 };
1495 BalanceTarget balanceTarget;
1497 // Helpers for text-wrap: balance implementation:
1499 // Count the number of lines in the mLines list, but return -1 (to suppress
1500 // balancing) instead if the count is going to exceed aLimit, or if we
1501 // encounter a block.
1507 }
1508 }
1510 };
1512 // Return a BalanceTarget record representing the position at which line-clamp
1513 // will take effect for the current line list. Only to be used when there are
1514 // enough lines that the clamp will apply.
1520 }
1524 }
1528 }
1533 }
1535 };
1537 // "balancing" is implemented by shortening the effective inline-size of the
1538 // lines, so that content will tend to be pushed down to fill later lines of
1539 // the block. `balanceInset` is the current amount of "inset" to apply, and
1540 // `balanceStep` is the increment to adjust it by for the next iteration.
1543 // text-wrap: balance loop, executed only once if balancing is not required.
1544 nsReflowStatus reflowStatus;
1546 needFloatManager);
1548 // Save the initial floatManager state for repeated trial reflows.
1549 // We'll restore (and re-save) the initial state each time we repeat the
1550 // reflow.
1555 reflowStatus =
1558 // Do we need to start a `text-wrap: balance` iteration?
1561 // Don't try to balance an incomplete block, or if we had to use an
1562 // overflow-wrap break position in the initial reflow.
1565 }
1569 // If there are less than 2 lines, or the number exceeds the limit,
1570 // no balancing is needed; just break from the balance loop.
1572 }
1573 // Initialize the amount of inset to try, and the iteration step size.
1578 // If -webkit-line-clamp is in effect, then we need to maintain the
1579 // content location at which clamping occurs, rather than the total
1580 // number of lines in the block.
1588 }
1589 }
1590 }
1592 // Restore initial floatManager state for a new trial with updated inset.
1595 }
1597 // Helper to determine whether the current trial succeeded (i.e. was able
1598 // to fit the content into the expected number of lines).
1602 }
1606 }
1610 };
1612 // If we're in the process of a balance operation, check whether we've
1613 // inset by too much and either increase or reduce the inset for the next
1614 // iteration.
1620 }
1625 }
1627 // If we were attempting to balance, check whether the final iteration was
1628 // successful, and if not, back up by one step.
1632 }
1637 }
1639 // If we reach here, no balancing was required, so just exit; we don't
1640 // reset (pop) the floatManager state because this is the reflow we're
1641 // going to keep. So the saved state is just dropped.
1645 // If the block direction is right-to-left, we need to update the bounds of
1646 // lines that were placed relative to mContainerSize during reflow, as
1647 // we typically do not know the true container size until we've reflowed all
1648 // its children. So we use a dummy mContainerSize during reflow (see
1649 // BlockReflowState's constructor) and then fix up the positions of the
1650 // lines here, once the final block size is known.
1651 //
1652 // Note that writing-mode:vertical-rl is the only case where the block
1653 // logical direction progresses in a negative physical direction, and
1654 // therefore block-dir coordinate conversion depends on knowing the width
1655 // of the coordinate space in order to translate between the logical and
1656 // physical origins.
1661 // We compute our lines and markers' overflow areas later in
1662 // ComputeOverflowAreas(), so we don't need to adjust their overflow areas
1663 // here.
1667 }
1672 }
1677 }
1678 }
1684 }
1685 }
1686 }
1687 }
1693 // Factor overflow container child bounds into the overflow area
1695 // Factor pushed float child bounds into the overflow area
1698 // Let the absolutely positioned container reflow any absolutely positioned
1699 // child frames that need to be reflowed, e.g., elements with a percentage
1700 // based width/height
1701 // We want to do this under either of two conditions:
1702 // 1. If we didn't do the incremental reflow above.
1703 // 2. If our size changed.
1704 // Even though it's the padding edge that's the containing block, we
1705 // can use our rect (the border edge) since if the border style
1706 // changed, the reflow would have been targeted at us so we'd satisfy
1707 // condition 1.
1708 // XXX checking oldSize is bogus, there are various reasons we might have
1709 // reflowed but our size might not have been changed to what we
1710 // asked for (e.g., we ended up being pushed to a new page)
1711 // When WillReflowAgainForClearance is true, we will reflow again without
1712 // resetting the size. Because of this, we must not reflow our abs-pos
1713 // children in that situation --- what we think is our "new size" will not be
1714 // our real new size. This also happens to be more efficient.
1720 // Make sure that when we reflow again we'll actually reflow all the abs
1721 // pos frames that might conceivably depend on our size (or all of them,
1722 // if we're dirty right now and interrupted; in that case we also need
1723 // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
1724 // better than that, because we don't really know what our size will be,
1725 // and it might in fact not change on the followup reflow!
1730 }
1732 // We're not going to reflow absolute frames; make sure to account for
1733 // their existing overflow areas, which is usually a side effect of this
1734 // reflow.
1735 //
1736 // TODO(emilio): nsAbsoluteContainingBlock::Reflow already checks for
1737 // interrupt, can we just rely on it and unconditionally take the else
1738 // branch below? That's a bit more subtle / risky, since I don't see
1739 // what would reflow them in that case if they depended on our size.
1743 }
1744 }
1746 LogicalSize containingBlockSize =
1750 // Mark frames that depend on changes we just made to this frame as dirty:
1751 // Now we can assume that the padding edge hasn't moved.
1752 // We need to reflow the absolutes if one of them depends on
1753 // its placeholder position, or the containing block size in a
1754 // direction in which the containing block size might have
1755 // changed.
1757 // XXX "width" and "height" in this block will become ISize and BSize
1758 // when nsAbsoluteContainingBlock is logicalized
1761 // If isRoot and we have auto height, then we are the initial
1762 // containing block and the containing block height is the
1763 // viewport height, which can't change during incremental
1764 // reflow.
1774 }
1777 }
1778 // Setup the line cursor here to optimize line searching for
1779 // calculating hypothetical position of absolutely-positioned
1780 // frames.
1785 }
1786 }
1792 #ifdef DEBUG
1793 // Between when we drain pushed floats and when we complete reflow,
1794 // we're allowed to have multiple continuations of the same float on
1795 // our floats list, since a first-in-flow might get pushed to a later
1796 // continuation of its containing block. But it's not permitted
1797 // outside that time.
1814 }
1816 }
1825 }
1838 }
1839 #endif
1840 }
1846 #ifdef DEBUG
1847 // Between when we drain pushed floats and when we complete reflow,
1848 // we're allowed to have multiple continuations of the same float on
1849 // our floats list, since a first-in-flow might get pushed to a later
1850 // continuation of its containing block. But it's not permitted
1851 // outside that time.
1853 #endif
1855 // ALWAYS drain overflow. We never want to leave the previnflow's
1856 // overflow lines hanging around; block reflow depends on the
1857 // overflow line lists being cleared out between reflow passes.
1869 // Handle paginated overflow (see nsContainerFrame.h)
1870 nsReflowStatus ocStatus;
1876 }
1878 // Now that we're done cleaning up our overflow container lists, we can
1879 // give |state| its nsOverflowContinuationTracker.
1883 // Drain & handle pushed floats
1887 // If we're not dirty (which means we'll mark everything dirty later)
1888 // and our inline-size has changed, mark the lines dirty that we need to
1889 // mark dirty for a resize reflow.
1892 }
1894 // The same for percentage text-indent, except conditioned on the
1895 // parent resizing.
1900 }
1902 // For text-wrap:balance trials, we need to reflow all the lines even if
1903 // they're not all "dirty".
1908 }
1910 // Now reflow...
1913 // If we have a next-in-flow, and that next-in-flow has pushed floats from
1914 // this frame from a previous iteration of reflow, then we should not return
1915 // a status with IsFullyComplete() equals to true, since we actually have
1916 // overflow, it's just already been handled.
1918 // NOTE: This really shouldn't happen, since we _should_ pull back our floats
1919 // and reflow them, but just in case it does, this is a safety precaution so
1920 // we don't end up with a placeholder pointing to frames that have already
1921 // been deleted as part of removing our next-in-flow.
1930 }
1932 }
1935 }
1936 }
1940 // If we end in a BR with clear and affected floats continue,
1941 // we need to continue, too.
1946 }
1951 }
1953 #ifdef DEBUG_kipp
1956 #endif
1957 }
1959 // Place the ::marker's frame if it is placed next to a block child.
1960 //
1961 // According to the CSS2 spec, section 12.6.1, the ::marker's box
1962 // participates in the height calculation of the list-item box's
1963 // first line box.
1964 //
1965 // There are exactly two places a ::marker can be placed: near the
1966 // first or second line. It's only placed on the second line in a
1967 // rare case: an empty first line followed by a second line that
1968 // contains a block (example: <LI>\n<P>... ). This is where
1969 // the second case can happen.
1974 // Reflow the ::marker's frame.
1976 // XXX Use the entire line when we fix bug 25888.
1981 nscoord lineBStart =
1990 // We have some lines to align the ::marker with.
1992 // Doing the alignment using the baseline will also cater for
1993 // ::markers that are placed next to a child block (bug 92896)
1995 // Tall ::markers won't look particularly nice here...
1996 LogicalRect bbox =
2003 }
2006 });
2009 }
2010 // Otherwise just leave the ::marker where it is, up against our
2011 // block-start padding.
2012 }
2014 // Clear any existing -webkit-line-clamp ellipsis.
2017 }
2021 // Compute our final size (for this trial layout)
2027 }
2033 }
2036 }
2037 }
2039 }
2042 StyleLineClamp aLineNumber) {
2057 NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
2060 // Don't count a line that only has collapsible white space (as might exist
2061 // after calling e.g. getBoxQuads).
2065 }
2068 // We already previously found our target line, and now we have
2069 // confirmed that there is another line after it.
2072 }
2075 // This is our target line. Continue looping to confirm that we
2076 // have another line after us.
2079 }
2082 }
2087 }
2094 }
2098 nscoord aContentBlockEndEdge) {
2101 }
2106 // The number of lines did not exceed the -webkit-line-clamp value.
2108 }
2110 // Mark the line as having an ellipsis so that TextOverflow will render it.
2114 // Translate the b-end edge of the line up to aFrame's space.
2117 edge +=
2119 }
2122 }
2129 #ifdef NOISY_FINAL_SIZE
2135 #endif
2137 // Compute final inline size
2144 // Return block-end margin information
2145 // rbs says he hit this assertion occasionally (see bug 86947), so
2146 // just set the margin to zero and we'll figure out why later
2147 // NS_ASSERTION(aMetrics.mCarriedOutBEndMargin.IsZero(),
2148 // "someone else set the margin");
2151 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
2152 // line with clearance and a non-zero block-start margin and all
2153 // subsequent lines are empty, then we do not allow our children's
2154 // carried out block-end margin to be carried out of us and collapse
2155 // with our own block-end margin.
2157 // Convert the children's carried out margin to something that
2158 // we will include in our height
2161 }
2165 }
2168 // Shrink wrap our height around our contents.
2171 // When we are a block-end-margin root make sure that our last
2172 // child's block-end margin is fully applied. We also do this when
2173 // we have a computed height, since in that case the carried out
2174 // margin is not going to be applied anywhere, so we should note it
2175 // here to be included in the overflow area.
2176 // Apply the margin only if there's space for it.
2178 // Truncate block-end margin if it doesn't fit to our available BSize.
2179 blockEndEdgeOfChildren =
2182 }
2183 }
2185 // Include the float manager's state to properly account for the
2186 // block-end margin of any floated elements; e.g., inside a table cell.
2187 //
2188 // Note: The block coordinate returned by ClearFloats is always greater than
2189 // or equal to blockEndEdgeOfChildren.
2192 }
2195 // Note: We don't use blockEndEdgeOfChildren because it includes the
2196 // previous margin.
2200 // We don't care about ApplyLineClamp's return value (the line-clamped
2201 // content BSize) in this explicit-BSize codepath, but we do still need to
2202 // call ApplyLineClamp for ellipsis markers to be placed as-needed.
2207 // If the content block-size is larger than the effective computed
2208 // block-size, we extend the block-size to contain all the content.
2209 // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
2211 // Note: finalSize.BSize(wm) is the border-box size, so we compare it with
2212 // the content's block-size plus our border and padding..
2216 }
2218 // Don't carry out a block-end margin when our BSize is fixed.
2219 //
2220 // Note: this also includes the case that aReflowInput.ComputedBSize() is
2221 // calculated from aspect-ratio. i.e. Don't carry out block margin-end if it
2222 // is replaced by the block size from aspect-ratio and inline size.
2228 // If we're size-containing in block axis and we don't have a specified
2229 // block size, then our final size should actually be computed from only
2230 // our border, padding and contain-intrinsic-block-size, ignoring the
2231 // actual contents. Hence this case is a simplified version of the case
2232 // below.
2233 //
2234 // NOTE: We exempt the nsComboboxControlFrame subclass from taking this
2235 // special case when it has 'contain-intrinsic-block-size: none', because
2236 // comboboxes implicitly honors the size-containment behavior on its
2237 // nsComboboxDisplayFrame child (which it shrinkwraps) rather than on the
2238 // nsComboboxControlFrame. (Moreover, the DisplayFrame child doesn't even
2239 // need any special content-size-ignoring behavior in its reflow method,
2240 // because that method just resolves "auto" BSize values to one
2241 // line-height rather than by measuring its contents' BSize.)
2243 nscoord autoBSize =
2249 // Our parent is expected to push this frame to the next page/column so
2250 // what size we set here doesn't really matter.
2264 // Our min-block-size, max-block-size, or -webkit-line-clamp value made
2265 // our bsize change. Don't carry out our kids' block-end margins.
2267 }
2272 // Applying `min-size` made us overflow our available size.
2273 // Clamp it and report that we're Incomplete, or BreakBefore if we have
2274 // 'break-inside: avoid' that is applicable.
2280 }
2281 }
2289 // This should never happen, but it does. See bug 414255
2291 }
2295 // Compute this fragment's block-size, with the max-block-size
2296 // constraint taken into consideration.
2303 // We actually fit after applying `max-size` so we should be
2304 // Overflow-Incomplete instead.
2308 // We cannot fit after applying `max-size` with our block-end BP, so
2309 // we should draw it in our next continuation.
2311 }
2312 }
2314 }
2315 }
2319 // Overflow containers can only be overflow complete.
2320 // Note that auto height overflow containers have no normal children
2324 }
2328 // Currently only used for grid items, but could be used in other contexts.
2329 // The FragStretchBSizeProperty is our expected non-fragmented block-size
2330 // we should stretch to (for align-self:stretch etc). In some fragmentation
2331 // cases though, the last fragment (this frame since we're complete), needs
2332 // to have extra size applied because earlier fragments consumed too much of
2333 // our computed size due to overflowing their containing block. (E.g. this
2334 // ensures we fill the last row when a multi-row grid item is fragmented).
2339 }
2340 }
2342 // Clamp the content size to fit within the margin-box clamp size, if any.
2356 // XXXmats deal with percentages better somehow?
2358 }
2359 }
2360 }
2362 // Screen out negative block sizes --- can happen due to integer overflows :-(
2369 }
2373 #ifdef DEBUG_blocks
2378 }
2379 #endif
2382 }
2389 // Factor in the block-end edge of the children. Child frames will be added
2390 // to the overflow area as we iterate through the lines, but their margins
2391 // won't, so we need to account for block-end margins here.
2392 // REVIEW: For now, we do this for both visual and scrollable area,
2393 // although when we make scrollable overflow area not be a subset of
2394 // visual, we can change this.
2397 // If we are a scrolled inner frame, add our block-end padding to our
2398 // children's block-end edge.
2399 //
2400 // Note: aBEndEdgeOfChildren already includes our own block-start padding
2401 // because it is relative to our block-start edge of our border-box, which
2402 // is the same as our padding-box here.
2406 }
2408 // XXX Currently, overflow areas are stored as physical rects, so we have
2409 // to handle writing modes explicitly here. If we change overflow rects
2410 // to be stored logically, this can be simplified again.
2416 // Layout containment should force all overflow to be ink (visual)
2417 // overflow, so if we're layout-contained, we only add our children's
2418 // block-end edge to the ink (visual) overflow -- not to the
2419 // scrollable overflow.
2422 }
2423 }
2432 }
2433 }
2434 }
2440 }
2441 }
2442 }
2443 }
2446 nscoord aBEndEdgeOfChildren,
2448 // XXX_perf: This can be done incrementally. It is currently one of
2449 // the things that makes incremental reflow O(N^2).
2455 }
2457 // We rely here on our caller having called SetOverflowAreasToDesiredBounds().
2462 // If we have layout containment, we should only consider our child's
2463 // ink overflow, leaving the scrollable regions of the parent
2464 // unaffected.
2465 // Note: scrollable overflow is a subset of ink overflow,
2466 // so this has the same affect as unioning the child's visual and
2467 // scrollable overflow with its parent's ink overflow.
2473 }
2474 }
2476 // Factor an outside ::marker in; normally the ::marker will be factored
2477 // into the line-box's overflow areas. However, if the line is a block
2478 // line then it won't; if there are no lines, it won't. So just
2479 // factor it in anyway (it can't hurt if it was already done).
2480 // XXXldb Can we just fix GetOverflowArea instead?
2483 }
2489 overflowClipMargin);
2490 }
2492 #ifdef NOISY_OVERFLOW_AREAS
2496 #endif
2497 }
2500 // We need to update the overflow areas of lines manually, as they
2501 // get cached and re-used otherwise. Lines aren't exposed as normal
2502 // frame children, so calling UnionChildOverflow alone will end up
2503 // using the old cached values.
2512 }
2514 // Consider the overflow areas of the floats attached to the line as well
2518 }
2519 }
2523 }
2525 // Union with child frames, skipping the principal and float lists
2526 // since we already handled those using the line boxes.
2530 }
2534 nscoord blockEndEdgeOfChildren =
2539 }
2541 // Line cursor invariants depend on the overflow areas of the lines, so
2542 // we must clear the line cursor since those areas may have changed.
2545 }
2555 // NOTE: MarkLineDirty does more than just marking the line dirty.
2558 }
2559 }
2560 }
2562 }
2563 }
2567 // Mark aLine dirty
2570 #ifdef DEBUG
2575 }
2576 #endif
2578 // Mark previous line dirty if it's an inline line so that it can
2579 // maybe pullup something from the line just affected.
2580 // XXX We don't need to do this if aPrevLine ends in a break-after...
2585 #ifdef DEBUG
2591 }
2592 #endif
2593 }
2594 }
2596 /**
2597 * Test whether lines are certain to be aligned left so that we can make
2598 * resizing optimizations
2599 */
2601 StyleDirection aDirection,
2602 StyleUnicodeBidi aUnicodeBidi,
2610 }
2613 // See if we can try and avoid marking all the lines as dirty
2614 // FIXME(emilio): This should be writing-mode aware, I guess.
2616 // The left content-edge must be a constant distance from the left
2617 // border-edge.
2620 #ifdef DEBUG
2623 }
2630 }
2631 }
2632 #endif
2636 nscoord newAvailISize =
2640 #ifdef DEBUG
2645 }
2646 #endif
2650 // We let child blocks make their own decisions the same
2651 // way we are here.
2659 }
2661 #ifdef REALLY_NOISY_REFLOW
2665 }
2666 #endif
2667 #ifdef DEBUG
2671 "skipped: line=%p next=%p %s %s%s%s clearTypeBefore/After=%s/%s "
2683 }
2684 #endif
2685 }
2687 // Mark everything dirty
2690 }
2691 }
2692 }
2694 //----------------------------------------
2696 /**
2697 * Propagate reflow "damage" from from earlier lines to the current
2698 * line. The reflow damage comes from the following sources:
2699 * 1. The regions of float damage remembered during reflow.
2700 * 2. The combination of nonzero |aDeltaBCoord| and any impact by a
2701 * float, either the previous reflow or now.
2702 *
2703 * When entering this function, |aLine| is still at its old position and
2704 * |aDeltaBCoord| indicates how much it will later be slid (assuming it
2705 * doesn't get marked dirty and reflowed entirely).
2706 */
2709 nscoord aDeltaBCoord) {
2717 // Check to see if there are any floats; if there aren't, there can't
2718 // be any float damage
2721 }
2723 // Check the damage region recorded in the float damage.
2725 // Need to check mBounds *and* mCombinedArea to find intersections
2726 // with aLine's floats
2729 // Scrollable overflow should be sufficient for things that affect
2730 // layout.
2733 LogicalRect overflow =
2736 nscoord lineBCoordCombinedAfter =
2742 lineBCoordCombinedAfter);
2746 }
2747 }
2749 // Check if the line is moving relative to the float manager
2752 // Unconditionally reflow sliding blocks; we only really need to reflow
2753 // if there's a float impacting this block, but the current float manager
2754 // makes it difficult to check that. Therefore, we let the child block
2755 // decide what it needs to reflow.
2759 nsFlowAreaRect floatAvailableSpace =
2763 #ifdef REALLY_NOISY_REFLOW
2766 #endif
2768 // Mark the line dirty if it was or is affected by a float
2769 // We actually only really need to reflow if the amount of impact
2770 // changes, but that's not straightforward to check
2773 }
2774 }
2775 }
2776 }
2782 NS_BLOCK_HAS_CLEAR_CHILDREN) ||
2785 }
2787 /**
2788 * Reparent a whole list of floats from aOldParent to this block. The
2789 * floats might be taken from aOldParent's overflow list. They will be
2790 * removed from the list. They end up appended to our mFloats list.
2791 */
2795 nsFrameList list;
2802 }
2804 }
2805 }
2809 #ifdef DEBUG
2815 "line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} "
2816 "oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} "
2823 }
2824 #endif
2825 }
2831 }
2832 }
2834 }
2843 #ifdef DEBUG
2849 }
2851 #endif
2857 // Reflow our last line if our availableBSize has increased
2858 // so that we (and our last child) pull up content as necessary
2867 }
2868 }
2869 // the amount by which we will slide the current line if it is not
2870 // dirty
2873 // whether we did NOT reflow the previous line and thus we need to
2874 // recompute the carried out margin before the line if we want to
2875 // reflow it or if its previous margin is dirty
2877 // Float continuations were reflowed in ReflowPushedFloats
2882 // We save up information about BR-clearance here
2887 // Determine if children of this frame could have breaks between them for
2888 // page names.
2889 //
2890 // We need to check for paginated layout, the named-page pref, and if the
2891 // available block-size is constrained.
2892 //
2893 // Note that we need to check for paginated layout as named-pages are only
2894 // used during paginated reflow. We need to additionally check for
2895 // unconstrained block-size to avoid introducing fragmentation breaks during
2896 // "measuring" reflows within an overall paginated reflow, and to avoid
2897 // fragmentation in monolithic containers like 'inline-block'.
2898 //
2899 // Because we can only break for named pages using Class A breakpoints, we
2900 // also need to check that the block flow direction of the containing frame
2901 // of these items (which is this block) is parallel to that of this page.
2902 // See: https://www.w3.org/TR/css-break-3/#btw-blocks
2910 // ReflowInput.mFlags.mCanHaveClassABreakpoints should respect the named
2911 // pages pref and presCtx->IsPaginated, so we did not explicitly check these
2912 // above when setting canBreakForPageNames.
2915 "canBreakForPageNames should not be set during non-paginated "
2917 }
2919 // Reflow the lines that are already ours
2922 #ifdef DEBUG
2924 #endif
2928 }
2930 // This really sucks, but we have to look inside any blocks that have clear
2931 // elements inside them.
2932 // XXX what can we do smarter here?
2936 }
2942 }
2944 // We have to reflow the line if it's a block whose clearance
2945 // might have changed, so detect that.
2949 // See where we would be after applying any clearance due to
2950 // BRs.
2954 }
2960 // Reflow the line if it might not have clearance anymore.
2962 // aState.mBCoord is the clearance point which should be the
2963 // block-start border-edge of the block frame. If sliding the
2964 // block by deltaBCoord isn't going to put it in the predicted
2965 // position, then we'd better reflow the line.
2968 }
2970 // Reflow the line if the line might have clearance now.
2973 }
2974 }
2975 }
2977 // We might have to reflow a line that is after a clearing BR.
2982 // SlideLine is not going to put the line where the clearance
2983 // put it. Reflow the line to be sure.
2985 }
2987 }
2991 // If the previous margin is dirty, reflow the current line
3000 // Lines that aren't dirty but get slid past our available block-size
3001 // constraint must be reflowed.
3003 }
3004 }
3008 // Last column can be reflowed unconstrained during column balancing.
3009 // Hence the additional NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR bit check
3010 // as a fail-safe fallback.
3013 // Table can also be reflowed unconstrained during printing.
3016 // We are in a paginated context, i.e. in columns or pages.
3020 // The following if-else conditions check whether this line -- which
3021 // might have floats in its subtree, or has floats as direct children,
3022 // or had floats pushed -- needs to be reflowed.
3024 // The distance to the block-end edge might have changed. Reflow the
3025 // line both because the breakpoints within its floats may have
3026 // changed and because we might have to push/pull the floats in
3027 // their entirety.
3030 // We had pushed floats which haven't been drained by our
3031 // next-in-flow, which means our parent is currently reflowing us
3032 // again due to clearance without creating a next-in-flow for us.
3033 // Reflow the line to redo the floats split logic to correctly set
3034 // our reflow status.
3037 // Reflow the line (that may containing a float's placeholder frame)
3038 // if our parent tells us to do so.
3041 // Our parent's line containing us moved to a different fragment.
3042 // Reflow the line because the decision about whether the float fits
3043 // may be different in a different fragment.
3045 }
3046 }
3047 }
3048 }
3051 // See if there's any reflow damage that requires that we mark the
3052 // line dirty.
3054 }
3056 // If the container size has changed, reset mContainerSize. If the
3057 // line's writing mode is not ltr, or if the line is not left-aligned, also
3058 // mark the line dirty.
3069 }
3070 }
3072 // Check for a page break caused by CSS named pages.
3073 //
3074 // We should break for named pages when two frames meet at a class A
3075 // breakpoint, where the first frame has a different end page value to the
3076 // second frame's start page value. canBreakForPageNames is true iff
3077 // children of this frame can form class A breakpoints, and that we are not
3078 // in a measurement reflow or in a monolithic container such as
3079 // 'inline-block'.
3080 //
3081 // We specifically do not want to cause a page-break for named pages when
3082 // we are at the top of a page. This would otherwise happen when the
3083 // previous sibling is an nsPageBreakFrame, or all previous siblings on the
3084 // current page are zero-height. The latter may not be per-spec, but is
3085 // compatible with Chrome's implementation of named pages.
3093 // Walk back to the last frame that isn't a placeholder.
3097 }
3101 }
3102 }
3103 }
3106 // We need to reconstruct the block-end margin only if we didn't
3107 // reflow the previous line and we do need to reflow (or repair
3108 // the block-start position of) the next line.
3110 }
3116 // Update aState.mPrevChild as if we had reflowed all of the frames in
3117 // this line.
3123 }
3124 }
3126 // Now repair the line and update |aState.mBCoord| by calling
3127 // |ReflowLine| or |SlideLine|.
3128 // If we're going to reflow everything again, then no need to reflow
3129 // the dirty line ... unless the line has floats, in which case we'd
3130 // better reflow it now to refresh its float cache, which may contain
3131 // dangling frame pointers! Ugh! This reflow of the line may be
3132 // incorrect because we skipped reflowing previous lines (e.g., floats
3133 // may be placed incorrectly), but that's OK because we'll mark the
3134 // line dirty below under "if (aState.mReflowInput.mDiscoveredClearance..."
3142 // Compute the dirty lines "before" BEnd, after factoring in
3143 // the running deltaBCoord value - the running value is implicit in
3144 // aState.mBCoord.
3149 "Don't reflow blocks while willReflowAgain is true, reflow "
3153 // Immediately fragment for page-name. It is possible we could break
3154 // out of the loop right here, but this should make it more similar to
3155 // what happens when reflow causes fragmentation.
3156 // Set the page name, so that PushTruncatedLine does not need to
3157 // recalculate the new page name.
3163 // Reflow the dirty line. If it's an incremental reflow, then force
3164 // it to invalidate the dirty area if necessary
3166 }
3171 // Note that once we've entered this state, every line that gets here
3172 // (e.g. because it has floats) gets marked dirty and reflowed again.
3173 // in the next pass. This is important, see above.
3174 }
3178 }
3184 }
3186 }
3188 // Test to see whether the margin that should be carried out
3189 // to the next line (NL) might have changed. In ReflowBlockFrame
3190 // we call nextLine->MarkPreviousMarginDirty if the block's
3191 // actual carried-out block-end margin changed. So here we only
3192 // need to worry about the following effects:
3193 // 1) the line was just created, and it might now be blocking
3194 // a carried-out block-end margin from previous lines that
3195 // used to reach NL from reaching NL
3196 // 2) the line used to be empty, and is now not empty,
3197 // thus blocking a carried-out block-end margin from previous lines
3198 // that used to reach NL from reaching NL
3199 // 3) the line wasn't empty, but now is, so a carried-out
3200 // block-end margin from previous lines that didn't used to reach NL
3201 // now does
3202 // 4) the line might have changed in a way that affects NL's
3203 // ShouldApplyBStartMargin decision. The three things that matter
3204 // are the line's emptiness, its adjacency to the block-start edge of the
3205 // block, and whether it has clearance (the latter only matters if the
3206 // block was and is adjacent to the block-start and empty).
3207 //
3208 // If the line is empty now, we can't reliably tell if the line was empty
3209 // before, so we just assume it was and do
3210 // nextLine->MarkPreviousMarginDirty. This means the checks in 4) are
3211 // redundant; if the line is empty now we don't need to check 4), but if
3212 // the line is not empty now and we're sure it wasn't empty before, any
3213 // adjacency and clearance changes are irrelevant to the result of
3214 // nextLine->ShouldApplyBStartMargin.
3221 // since it's marked dirty, nobody will care about |deltaBCoord|
3222 }
3223 }
3225 // If the line was just reflowed for the first time, then its
3226 // old mBounds cannot be trusted so this deltaBCoord computation is
3227 // bogus. But that's OK because we just did
3228 // MarkPreviousMarginDirty on the next line which will force it
3229 // to be reflowed, so this computation of deltaBCoord will not be
3230 // used.
3233 // Now do an interrupt check. We want to do this only in the case when we
3234 // actually reflow the line, so that if we get back in here we'll get
3235 // further on the reflow before interrupting.
3239 // Nop except for blocks (we don't create overflow container
3240 // continuations for any inlines atm), so only checking mFirstChild
3241 // is enough
3249 }
3254 // If we're going to reflow everything again, and this line is a block,
3255 // then there is no need to recover float state. The line may contain
3256 // other lines with floats, but in that case RecoverStateFrom would only
3257 // add floats to the float manager. We don't need to do that because
3258 // everything's going to get reflowed again "for real". Calling
3259 // RecoverStateFrom in this situation could be lethal because the
3260 // block's descendant lines may have float caches containing dangling
3261 // frame pointers. Ugh!
3262 // If this line is inline, then we need to recover its state now
3263 // to make sure that we don't forget to move its floats by deltaBCoord.
3265 // XXX EVIL O(N^2) EVIL
3267 }
3269 // Keep mBCoord up to date in case we're propagating reflow damage
3270 // and also because our final height may depend on it. If the
3271 // line is inlines, then only update mBCoord if the line is not
3272 // empty, because that's what PlaceLine does. (Empty blocks may
3273 // want to update mBCoord, e.g. if they have clearance.)
3276 }
3282 // Need to make sure to pull overflows from any prev-in-flows
3286 }
3287 }
3288 }
3290 // Record if we need to clear floats before reflowing the next
3291 // line. Note that inlineFloatClearType will be handled and
3292 // cleared before the next line is processed, so there is no
3293 // need to combine break types here.
3296 }
3300 }
3306 // Another option here might be to leave |line| clean if
3307 // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
3308 // that case the line really did reflow as it should have. Not sure
3309 // whether that would be safe, so doing this for now instead. Also not
3310 // sure whether we really want to mark all lines dirty after an
3311 // interrupt, but until we get better at propagating float damage we
3312 // really do need to do it this way; see comments inside MarkLineDirty.
3314 }
3315 }
3317 // Handle BR-clearance from the last line of the block
3321 }
3324 // Is this expensive?
3327 // Update aState.mPrevChild as if we had reflowed all of the frames in
3328 // the last line.
3334 }
3336 // Should we really have to do this?
3339 }
3341 // We can skip trying to pull up the next line if our height is constrained
3342 // (so we can report being incomplete) and there is no next in flow or we
3343 // were told not to or we know it will be futile, i.e.,
3344 // -- the next in flow is not changing
3345 // -- and we cannot have added more space for its first line to be
3346 // pulled up into,
3347 // -- it's an incremental reflow of a descendant
3348 // -- and we didn't reflow any floats (so the available space
3349 // didn't change)
3350 // -- my chain of next-in-flows either has no first line, or its first
3351 // line isn't dirty.
3358 // We'll place lineIter at the last line of this block, so that
3359 // nsBlockInFlowLineIterator::Next() will take us to the first
3360 // line of my next-in-flow-chain. (But first, check that I
3361 // have any lines -- if I don't, just bail out of this
3362 // optimization.)
3368 // Check for next-in-flow-chain's first line.
3369 // (First, see if there is such a line, and second, see if it's clean)
3372 }
3373 }
3374 }
3382 }
3383 }
3386 // Pull data from a next-in-flow if there's still room for more
3387 // content here.
3389 // Grab first line from our next-in-flow
3392 nsFrameList pulledFrames;
3397 // Grab an overflow line if there are any
3403 }
3409 }
3410 }
3413 // The line is empty. Try the next one.
3419 }
3424 }
3427 }
3428 }
3439 // Shift pulledLine's frames into our mFrames list.
3442 // Add line to our line list, and set its last child as our new prev-child
3446 // Reparent floats whose placeholders are in the line.
3450 #ifdef DEBUG
3452 #endif
3457 // Now reflow it and any lines that it makes during it's reflow
3458 // (we have to loop here because reflowing the line may cause a new
3459 // line to be created; see SplitLine's callers for examples of
3460 // when this happens).
3469 }
3475 }
3477 }
3481 }
3486 }
3488 // If this is an inline frame then its time to stop
3491 }
3492 }
3493 }
3498 }
3500 // Handle an odd-ball case: a list-item with no lines
3512 // There are no lines so we have to fake up some y motion so that
3513 // we end up with *some* height.
3514 // (Note: if we're layout-contained, we have to be sure to leave our
3515 // ReflowOutput's BlockStartAscent() (i.e. the baseline) untouched,
3516 // because layout-contained frames have no baseline.)
3519 nscoord ascent;
3525 }
3526 }
3542 }
3543 }
3544 }
3548 }
3554 }
3556 #ifdef DEBUG
3564 }
3565 #endif
3568 }
3573 // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
3574 // marked the lines that need to be marked dirty based on our
3575 // vertical resize stuff. So we'll definitely reflow all those kids;
3576 // the only question is how they should behave.
3578 // Mark all our child frames dirty so we make sure to reflow them
3579 // later.
3584 }
3585 // And mark all the floats whose reflows we might be skipping dirty too.
3589 }
3590 }
3592 // Dirty all the descendant lines of block kids to handle float damage,
3593 // since our nsFloatManager will go away by the next time we're reflowing.
3594 // XXXbz Can we do something more like what PropagateFloatDamage does?
3595 // Would need to sort out the exact business with mBlockDelta for that....
3596 // This marks way too much dirty. If we ever make this better, revisit
3597 // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
3601 }
3602 }
3603 }
3611 "using function more generally than designed, "
3616 // Mark the previous margin of the next line dirty since we need to
3617 // recompute its top position.
3620 }
3621 }
3622 }
3624 /**
3625 * Reflow a line. The line will either contain a single block frame
3626 * or contain 1 or more inline frames. aKeepReflowGoing indicates
3627 * whether or not the caller should continue to reflow more lines.
3628 * Returns true if the reflow used an overflow-wrap breakpoint.
3629 */
3634 // Setup the line-layout for the new line
3640 // If this line contains a single block that is hidden by `content-visibility`
3641 // don't reflow the line. If this line contains inlines and the first one is
3642 // hidden by `content-visibility`, all of them are, so avoid reflow in that
3643 // case as well.
3644 // For frames that own anonymous children, even the first child is hidden by
3645 // `content-visibility`, there could be some anonymous children need reflow,
3646 // so we don't skip reflow this line.
3651 }
3653 // Now that we know what kind of line we have, reflow it
3661 // Store the line's float edges for overflow marker analysis if needed.
3673 // This line is overlapping a float - store the edges marking the area
3674 // between the floats for text-overflow analysis.
3676 }
3677 }
3678 }
3679 }
3684 }
3687 LineIterator aLine) {
3688 // First check our remaining lines.
3691 }
3697 // Try each next-in-flow.
3702 }
3705 }
3708 }
3711 }
3727 // If our line is not empty and the child in aFromLine is a block
3728 // then we cannot pull up the frame into this line. In this case
3729 // we stop pulling.
3731 }
3732 // Take frame from fromLine
3737 // The frame is being pulled from a next-in-flow; therefore we need to add
3738 // it to our sibling list.
3744 // When pushing and pulling frames we need to check for whether any
3745 // views need to be reparented.
3749 // The frame might have (or contain) floats that need to be brought
3750 // over too. (pass 'false' since there are no siblings to check)
3754 }
3760 // Mark line dirty now that we pulled a child
3764 // Free up the fromLine now that it's empty.
3765 // Its bounds might need to be redrawn, though.
3768 }
3770 // aFromLine is now invalid
3772 }
3774 #ifdef DEBUG
3777 #endif
3780 }
3783 nscoord aDeltaBCoord) {
3786 // Adjust line state
3789 // Adjust the frames in the line
3791 }
3797 }
3799 // Adjust line state
3802 // Changing container width only matters if writing mode is vertical-rl
3805 }
3806 }
3809 nscoord aDeltaBCoord) {
3810 // Adjust the frames in the line
3814 }
3822 }
3824 // Make sure the frame's view and any child views are updated
3827 // Adjust the block-dir coordinate of the frames in the line.
3828 // Note: we need to re-position views even if aDeltaBCoord is 0, because
3829 // one of our parent frames may have moved and so the view's position
3830 // relative to its parent may have changed.
3835 }
3836 // Make sure the frame's view and any child views are updated
3839 }
3840 }
3841 }
3844 // The "extremum length" values (see ExtremumLength) were originally aimed at
3845 // inline-size (or width, as it was before logicalization). For now, let them
3846 // return false here, so we treat them like 'auto' pending a real
3847 // implementation. (See bug 1126420.)
3848 //
3849 // FIXME (bug 567039, bug 527285) This isn't correct for the 'fill' value,
3850 // which should more likely (but not necessarily, depending on the available
3851 // space) be returning true.
3854 }
3856 // If we evaluate the length/percent/calc at a percentage basis of
3857 // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
3858 // length, percent, or combination thereof. Test > 0 so we clamp
3859 // negative calc() results to 0.
3862 }
3864 /* virtual */
3868 }
3870 // Blocks which are margin-roots (including inline-blocks) cannot be treated
3871 // as empty for margin-collapsing and other purposes. They're more like
3872 // replaced elements.
3875 }
3883 }
3885 // FIXME: Bug 1646100 - Take intrinsic size into account.
3886 // FIXME: Handle the case that both inline and block sizes are auto.
3887 // https://github.com/w3c/csswg-drafts/issues/5060.
3888 // Note: block-size could be zero or auto/intrinsic keywords here.
3892 }
3903 }
3907 }
3910 }
3915 }
3919 }
3920 }
3922 }
3927 }
3930 }
3935 // A page break frame consumes margins adjacent to it.
3936 // https://drafts.csswg.org/css-break/#break-margins
3938 }
3941 // Apply short-circuit check to avoid searching the line list
3943 }
3946 // If we aren't at the start block-coordinate then something of non-zero
3947 // height must have been placed. Therefore the childs block-start margin
3948 // applies.
3951 }
3953 // Determine if this line is "essentially" the first line
3957 }
3960 // A line which precedes aLine is non-empty, or has clearance,
3961 // so therefore the block-start margin applies.
3964 }
3965 // No need to apply the block-start margin if the line has floats. We
3966 // should collapse anyway (bug 44419)
3970 }
3972 // The line being reflowed is "essentially" the first line in the
3973 // block. Therefore its block-start margin will be collapsed by the
3974 // generational collapsing logic with its parent (us).
3976 }
3979 LineIterator aLine,
3987 }
3989 // If the previous frame was a page-break-frame, then preemptively push this
3990 // frame to the next page.
3991 // This is primarily important for the placeholders for abspos frames, which
3992 // measure as zero height and then would be placed on this page.
3998 }
3999 }
4001 // Prepare the block reflow engine
4009 }
4011 // Clear past floats before the block if the clear style is not none
4015 }
4017 // See if we should apply the block-start margin. If the block frame being
4018 // reflowed is a continuation, then we don't apply its block-start margin
4019 // because it's not significant. Otherwise, dig deeper.
4023 // The HasClearance setting is only valid if ShouldApplyBStartMargin
4024 // returned false (in which case the block-start margin-root set our
4025 // clearance flag). Otherwise clear it now. We'll set it later on
4026 // ourselves if necessary.
4028 }
4036 }
4038 // If our block-start margin was counted as part of some parent's block-start
4039 // margin collapse, and we are being speculatively reflowed assuming this
4040 // frame DID NOT need clearance, then we need to check that
4041 // assumption.
4050 // Only record the first frame that requires clearance
4053 }
4055 // Exactly what we do now is flexible since we'll definitely be
4056 // reflowed.
4058 }
4059 }
4062 }
4067 nscoord clearance;
4068 // Save the original position of the frame so that we can reposition
4069 // its view as needed.
4078 // Precompute the blocks block-start margin value so that we can get the
4079 // correct available space (there might be a float that's
4080 // already been placed below the aState.mPrevBEndMargin
4082 // Setup a reflowInput to get the style computed block-start margin
4083 // value. We'll use a reason of `resize' so that we don't fudge
4084 // any incremental reflow input.
4086 // The availSpace here is irrelevant to our needs - all we want
4087 // out if this setup is the block-start margin value which doesn't depend
4088 // on the childs available space.
4089 // XXX building a complete ReflowInput just to get the block-start
4090 // margin seems like a waste. And we do this for almost every block!
4094 availSpace);
4099 }
4101 // Now compute the collapsed margin-block-start value into
4102 // aState.mPrevBEndMargin, assuming that all child margins
4103 // collapse down to clearanceFrame.
4107 // XXX optimization; we could check the collapsing children to see if they
4108 // are sure to require clearance, and so avoid retrying them
4111 // Don't allow retries on the second pass. The clearance decisions for
4112 // the blocks whose block-start margins collapse with ours are now
4113 // fixed.
4115 }
4118 // We don't know if we need clearance and this is the first,
4119 // optimistic pass. So determine whether *this block* needs
4120 // clearance. Note that we do not allow the decision for whether
4121 // this block has clearance to change on the second pass; that
4122 // decision is only allowed to be made under the optimistic
4123 // first pass.
4130 // Looks like we need clearance and we didn't know about it already.
4131 // So recompute collapsed margin
4133 // Remember this decision, needed for incremental reflow
4136 // Apply incoming margins
4140 // Compute the collapsed margin again, ignoring the incoming margin
4141 // this time
4145 }
4146 }
4148 // Temporarily advance the running block-direction value so that the
4149 // GetFloatAvailableSpace method will return the right available space.
4150 // This undone as soon as the horizontal margins are computed.
4155 // advance mBCoord to the clear position.
4161 clearedPushedOrSplitFloat =
4164 // Compute clearance. It's the amount we need to add to the block-start
4165 // border-edge of the frame, after applying collapsed margins
4166 // from the frame and its children, to get it to line up with
4167 // the block-end of the floats. The former is
4168 // currentBCoord + bStartMargin, the latter is the current
4169 // aState.mBCoord.
4170 // Note that negative clearance is possible
4173 // Add clearance to our block-start margin while we compute available
4174 // space for the frame
4177 // Note that aState.mBCoord should stay where it is: at the block-start
4178 // border-edge of the frame
4180 // Advance aState.mBCoord to the block-start border-edge of the frame.
4182 }
4183 }
4187 // Here aState.mBCoord is the block-start border-edge of the block.
4188 // Compute the available space for the block
4194 // The check for
4195 // (!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats)
4196 // is to some degree out of paranoia: if we reliably eat up block-start
4197 // margins at the top of the page as we ought to, it wouldn't be
4198 // needed.
4201 // We know already that this child block won't fit on this
4202 // page/column due to the block-start margin or the clearance. So we
4203 // need to get out of here now. (If we don't, most blocks will handle
4204 // things fine, and report break-before, but zero-height blocks
4205 // won't, and will thus make their parent overly-large and force
4206 // *it* to be pushed in its entirety.)
4213 }
4215 }
4217 // Now put the block-dir coordinate back to the start of the
4218 // block-start-margin + clearance.
4223 }
4225 // Construct the reflow input for the block.
4231 // Calculate the multicol containing block's block size so that the
4232 // children with percentage block size get correct percentage basis.
4238 // Use column-width as the containing block's inline-size, i.e. the column
4239 // content's computed inline-size.
4244 // If a ColumnSetWrapper is in a balancing column content, it may be
4245 // pushed or pulled back and forth between column contents. Always add
4246 // NS_FRAME_HAS_DIRTY_CHILDREN bit to it so that its ColumnSet children
4247 // can have a chance to reflow under current block size constraint.
4251 }
4253 // If we are reflowing our ColumnSet children, we want to apply our block
4254 // size constraint to the available block size when constructing reflow
4255 // input for ColumnSet so that ColumnSet can use it to compute its max
4256 // column block size.
4260 contentBSize =
4262 }
4264 // To get the remaining content block-size, subtract the content
4265 // block-size consumed by our previous continuations.
4268 // ColumnSet is not the outermost frame in the column container, so it
4269 // cannot have any margin. We don't need to consider any margin that
4270 // can be generated by "box-decoration-break: clone" as we do in
4271 // BlockReflowState::ComputeBlockAvailSpace().
4277 }
4278 }
4279 }
4280 }
4284 cbSize);
4287 columnSetWrapperHasNoBSizeLeft;
4290 // We only need to set this the first reflow, since if we reflow
4291 // again (and replace childReflowInput) we'll be reflowing it
4292 // again in the same fragment as the previous time.
4294 }
4297 nsReflowStatus frameReflowStatus;
4300 // Set if floatAvailableSpace.HasFloats() is true for any
4301 // iteration of the loop.
4303 }
4305 // We might need to store into mDiscoveredClearance later if it's
4306 // currently null; we want to overwrite any writes that
4307 // brc.ReflowBlock() below does, so we need to remember now
4308 // whether it's empty.
4313 // Reflow the block into the available space
4316 }
4323 }
4331 // No need to retry this loop if there is a break opportunity before the
4332 // child block.
4334 }
4336 // Now the block has a height. Using that height, get the
4337 // available space again and call ComputeBlockAvailSpace again.
4338 // If ComputeBlockAvailSpace gives a different result, we need to
4339 // reflow again.
4342 }
4351 // Restore the height to the position of the next band.
4354 // Determine whether the available space shrunk on either side,
4355 // because (the first time round) we now know the block's height,
4356 // and it may intersect additional floats, or (on later
4357 // iterations) because narrowing the width relative to the
4358 // previous time may cause the block to become taller. Note that
4359 // since we're reflowing the block, narrowing the width might also
4360 // make it shorter, so we must pass aCanGrow as true.
4363 // The size and position we chose before are fine (i.e., they
4364 // don't cause intersecting with floats that requires a change
4365 // in size or position), so we're done.
4367 }
4371 floatAvailableSpace)) {
4372 // Advance to the next band.
4376 }
4377 // ClearFloats might be able to advance us further once we're there.
4381 // Start over with a new available space rect at the new height.
4384 }
4392 }
4394 // We need another reflow.
4399 // We set shouldStoreClearance above to record only the first
4400 // frame that requires clearance.
4403 }
4405 // Exactly what we do now is flexible since we'll definitely be
4406 // reflowed.
4408 }
4411 // We're pushing down the border-box, so we don't apply margin anymore.
4412 // This should never cause us to move up since the call to
4413 // GetFloatAvailableSpaceForBSize above included the margin.
4418 }
4427 // Found a clearance frame, so we need to reflow |frame| a second time.
4428 // Restore the states and start over again.
4433 }
4438 // If an ancestor of ours is going to reflow for clearance, we
4439 // need to avoid calling PlaceBlock, because it unsets dirty bits
4440 // on the child block (both itself, and through its call to
4441 // nsIFrame::DidReflow), and those dirty bits imply dirtiness for
4442 // all of the child block, including the lines it didn't reflow.
4446 }
4448 #if defined(REFLOW_STATUS_COVERAGE)
4450 #endif
4453 // None of the child block fits.
4458 }
4460 // Note: line-break-after a block is a nop
4462 // Try to place the child block.
4463 // Don't force the block to fit if we have positive clearance, because
4464 // pushing it to the next page would give it more room.
4465 // Don't force the block to fit if it's impacted by a float. If it is,
4466 // then pushing it to the next page would give it more room. Note that
4467 // isImpacted doesn't include impact from the block's own floats.
4470 nsCollapsingMargin collapsedBEndMargin;
4471 OverflowAreas overflowAreas;
4479 }
4486 }
4487 }
4491 // Some of the child block fit
4493 // Advance to new Y position
4497 // Continue the block frame now if it didn't completely fit in
4498 // the available space.
4507 // If nextFrame used to be an overflow container, make it a normal
4508 // block
4517 }
4522 }
4524 // Push continuation to a new line, but only if we actually made
4525 // one.
4529 }
4533 // If we need to reflow the continuation of the block child,
4534 // then we'd better reflow our continuation
4537 // We also need to make that continuation's line dirty so
4538 // it gets reflowed when we reflow our next in flow. The
4539 // nif's line must always be either a line of the nif's
4540 // parent block (only if we didn't make a continuation) or
4541 // else one of our own overflow lines. In the latter case
4542 // the line is already marked dirty, so just handle the
4543 // first case.
4547 nifBlock,
4553 }
4554 }
4555 }
4556 }
4558 // The block-end margin for a block is only applied on the last
4559 // flow block. Since we just continued the child block frame,
4560 // we know that line->mFirstChild is not the last flow block
4561 // therefore zero out the running margin value.
4562 #ifdef NOISY_BLOCK_DIR_MARGINS
4568 #endif
4571 // Disconnect the next-in-flow and put it in our overflow tracker
4574 // It already exists, but as a normal next-in-flow, so we need
4575 // to dig it out of the child lists.
4579 }
4581 // Put it in our overflow list
4585 #ifdef NOISY_BLOCK_DIR_MARGINS
4591 #endif
4593 }
4595 #ifdef NOISY_BLOCK_DIR_MARGINS
4601 #endif
4603 }
4604 #ifdef NOISY_BLOCK_DIR_MARGINS
4611 #endif
4614 // The frame reported an incomplete status, but then it also didn't
4615 // fit. This means we need to reflow it again so that it can
4616 // (again) report the incomplete status.
4618 }
4622 // If it's our very first line *or* we're not at the top of the page
4623 // and we have page-break-inside:avoid, then we need to be pushed to
4624 // our parent's next-in-flow.
4627 // Push the line that didn't fit and any lines that follow it
4628 // to our next-in-flow.
4630 }
4631 }
4632 }
4634 }
4636 // Now that we've got its final position all figured out, position any child
4637 // views it may have. Note that the case when frame has a view got handled
4638 // by FinishReflowChild, but that function didn't have the coordinates needed
4639 // to correctly decide whether to reposition child views.
4642 }
4644 #ifdef DEBUG
4646 #endif
4647 }
4649 // Returns true if an overflow-wrap break was used.
4651 LineIterator aLine,
4658 // Setup initial coordinate system for reflowing the inline frames
4659 // into. Apply a previous block frame's block-end margin first.
4662 }
4665 LineReflowStatus lineReflowStatus;
4678 // Once upon a time we allocated the first 30 nsLineLayout objects
4679 // on the stack, and then we switched to the heap. At that time
4680 // these objects were large (1100 bytes on a 32 bit system).
4681 // Then the nsLineLayout object was shrunk to 156 bytes by
4682 // removing some internal buffers. Given that it is so much
4683 // smaller, the complexity of 2 different ways of allocating
4684 // no longer makes sense. Now we always allocate on the stack.
4690 }
4702 // If there is no saved break position, then this will set
4703 // set forceBreakInFrame to null and we won't back up, which is
4704 // correct.
4709 }
4710 // restore the float manager state
4712 // Clear out float lists
4716 }
4718 // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
4725 }
4728 LineIterator aLine,
4731 // Reflow the line again when we reflow at our new position.
4734 }
4738 ComputeNewPageNameIfNeeded aComputeNewPageName) {
4743 // mCanHaveClassABreakpoints can only be true during paginated reflow, and
4744 // we expect this function to only be called when the available bsize is
4745 // constrained.
4753 }
4754 }
4756 }
4763 // Forget all of the floats on the line
4767 // We need to set this flag on the line if any of our reflow passes
4768 // are impacted by floats.
4771 }
4772 #ifdef REALLY_NOISY_REFLOW
4775 #endif
4784 nscoord availBSize;
4788 /* XXX get the height right! */
4790 }
4792 // Make sure to enable resize optimization before we call BeginLineReflow
4793 // because it might get disabled there
4803 // XXX Unfortunately we need to know this before reflowing the first
4804 // inline frame in the line. FIX ME.
4807 NS_BLOCK_HAS_FIRST_LETTER_STYLE)) {
4809 }
4814 // Reflow the frames that are already on the line first
4820 // There is a soft break opportunity at the start of the line, because
4821 // we can always move this line down below float(s).
4825 }
4826 }
4828 // need to repeatedly call GetChildCount here, because the child
4829 // count can change during the loop!
4835 // It is possible that one or more of next lines are empty
4836 // (because of DeleteNextInFlowChild). If so, delete them now
4837 // in case we are finished.
4840 // XXX Is this still necessary now that DeleteNextInFlowChild
4841 // uses DoRemoveFrame?
4846 }
4850 "ReflowInlineFrame should never determine that a line "
4852 }
4853 }
4855 // Don't pull up new frames into lines with continuation placeholders
4857 // Pull frames and reflow them until we can't
4862 }
4868 // We just created a continuation for aFrame AND its going
4869 // to end up on this line (e.g. :first-letter
4870 // situation). Therefore we have to loop here before trying
4871 // to pull another frame.
4875 }
4876 }
4877 }
4878 }
4882 // We only need to backup if the line isn't going to be reflowed again anyway
4888 "We shouldn't be backing up more than once! "
4889 "Someone must have set a break opportunity beyond the available width, "
4892 }
4894 // We need to try backing up to before a text run
4895 // XXX It's possible, in fact not unusual, for the break opportunity to
4896 // already be the end of the line. We should detect that and optimize to not
4897 // re-do the line.
4899 // We can back up!
4901 }
4903 // In case we reflow this line again, remember that we don't
4904 // need to force any breaking
4906 }
4909 // This happens only when we have a line that is impacted by
4910 // floats and the first element in the line doesn't fit with
4911 // the floats.
4912 //
4913 // If there's block space available, we either try to reflow the line
4914 // past the current band (if it's non-zero and the band definitely won't
4915 // widen around a shape-outside), otherwise we try one pixel down. If
4916 // there's no block space available, we push the line to the next
4917 // page/column.
4922 // See the analogous code for blocks in BlockReflowState::ClearFloats.
4928 // We should never hit this case if we've placed floats on the
4929 // line; if we have, then the GetFloatAvailableSpace call is wrong
4930 // and needs to happen after the caller pops the float manager
4931 // state.
4935 // Move it down far enough to clear the current band.
4938 // Move it down by one dev pixel.
4940 }
4944 // There's nowhere to retry placing the line, so we want to push
4945 // it to the next page/column where its contents can fit not
4946 // next to a float.
4949 }
4951 // XXX: a small optimization can be done here when paginating:
4952 // if the new Y coordinate is past the end of the block then
4953 // push the line and return now instead of later on after we are
4954 // past the float.
4957 // If we are propagating out a break-before status then there is
4958 // no point in placing the line.
4962 aKeepReflowGoing)) {
4964 // PlaceLine already called GetFloatAvailableSpaceForBSize or its
4965 // variant for us.
4966 }
4967 }
4968 }
4969 #ifdef DEBUG
4973 }
4974 #endif
4977 // aLine may have been pushed to the overflow lines.
4979 // We can't just compare iterators front() to aLine here, since they may be
4980 // in different lists.
4984 // aLine is stale, it's associated with the main line list but it should
4985 // be associated with the overflow line list now
4987 }
4993 }
4994 }
4995 }
4998 }
5000 /**
5001 * Reflow an inline frame. The reflow status is mapped from the frames
5002 * reflow status to the lines reflow status (not to our reflow status).
5003 * The line reflow status is simple: true means keep placing frames
5004 * on the line; false means don't (the line is done). If the line
5005 * has some sort of breaking affect then aLine's break-type will be set
5006 * to something other than StyleClear::None.
5007 */
5015 #ifdef NOISY_FIRST_LETTER
5021 #endif
5026 }
5028 // Reflow the inline frame
5029 nsReflowStatus frameReflowStatus;
5035 }
5037 #ifdef REALLY_NOISY_REFLOW
5040 #endif
5042 #if defined(REFLOW_STATUS_COVERAGE)
5044 #endif
5046 // Send post-reflow notification
5049 /* XXX
5050 This is where we need to add logic to handle some odd behavior.
5051 For one thing, we should usually place at least one thing next
5052 to a left float, even when that float takes up all the width on a line.
5053 see bug 22496
5054 */
5056 // Process the child frames reflow status. There are 5 cases:
5057 // complete, not-complete, break-before, break-after-complete,
5058 // break-after-not-complete. There are two situations: we are a
5059 // block or we are an inline. This makes a total of 10 cases
5060 // (fortunately, there is some overlap).
5064 // Always abort the line reflow (because a line break is the
5065 // minimal amount of break we do).
5068 // XXX what should aLine's break-type be set to in all these cases?
5070 // Break-before cases.
5072 // If we break before the first frame on the line then we must
5073 // be trying to place content where there's no room (e.g. on a
5074 // line with wide floats). Inform the caller to reflow the
5075 // line after skipping past a float.
5078 // It's not the first child on this line so go ahead and split
5079 // the line. We will see the frame again on the next-line.
5082 // If we're splitting the line because the frame didn't fit and it
5083 // was pushed, then mark the line as having word wrapped. We need to
5084 // know that if we're shrink wrapping our width
5087 }
5088 }
5094 // If a float split and its prev-in-flow was followed by a <BR>, then
5095 // combine the <BR>'s float clear type with the inline's float clear type
5096 // (the inline will be the very next frame after the split float).
5102 }
5103 // Break-after cases
5106 }
5108 // Split line, but after the frame just reflowed
5110 aLineReflowStatus);
5115 }
5116 }
5117 }
5118 }
5121 // Create a continuation for the incomplete frame. Note that the
5122 // frame may already have a continuation.
5125 // Remember that the line has wrapped
5128 }
5130 // If we just ended a first-letter frame or reflowed a placeholder then
5131 // don't split the line and don't stop the line reflow...
5132 // But if we are going to stop anyways we'd better split the line.
5136 // Split line after the current frame
5139 aLineReflowStatus);
5140 }
5141 }
5142 }
5149 newFrame =
5156 }
5157 }
5158 #ifdef DEBUG
5160 #endif
5162 }
5176 }
5179 }
5181 nextInFlow =
5183 }
5186 }
5194 }
5202 }
5203 }
5209 }
5218 }
5219 }
5222 }
5234 #ifdef DEBUG
5243 }
5247 }
5248 }
5249 #endif
5254 #ifdef DEBUG
5255 {
5261 }
5263 }
5264 #endif
5266 // Put frames being split out into their own line
5269 #ifdef DEBUG
5272 }
5273 #endif
5275 // Let line layout know that some frames are no longer part of its
5276 // state.
5279 // If floats have been placed whose placeholders have been pushed to the new
5280 // line, we need to reflow the old line again. We don't want to look at the
5281 // frames in the new line, because as a large paragraph is laid out the
5282 // we'd get O(N^2) performance. So instead we just check that the last
5283 // float and the last below-current-line float are still in aLine.
5291 }
5293 #ifdef DEBUG
5295 #endif
5296 }
5297 }
5301 // There is another line
5303 // If the next line is a block line then this line is the last in a
5304 // group of inline lines.
5306 }
5307 // The next line is empty, try the next one
5308 }
5310 // Try our next-in-flows lines to answer the question
5316 }
5317 }
5319 }
5321 // This is the last line - so don't allow justification
5323 }
5331 // Try to position the floats in a nowrap context.
5334 // Trim extra white-space from the line before placing the frames
5337 // Vertically align the frames on this line.
5338 //
5339 // According to the CSS2 spec, section 12.6.1, the "marker" box
5340 // participates in the height calculation of the list-item box's
5341 // first line box.
5342 //
5343 // There are exactly two places a ::marker can be placed: near the
5344 // first or second line. It's only placed on the second line in a
5345 // rare case: when the first line is empty.
5360 }
5363 // We want to consider the floats in the current line when determining
5364 // whether the float available space is shrunk. If mLineBSize doesn't
5365 // exist, we are in the first pass trying to place the line. Calling
5366 // GetFloatAvailableSpace() like we did in BlockReflowState::AddFloat()
5367 // for UpdateBand().
5369 // floatAvailableSpaceWithOldLineBSize is the float available space with
5370 // the old BSize, but including the floats that were added in this line.
5371 LogicalRect floatAvailableSpaceWithOldLineBSize =
5374 : aState
5379 // As we redo for floats, we can't reduce the amount of BSize we're
5380 // checking.
5382 LogicalRect floatAvailableSpaceWithLineBSize =
5383 aState
5388 // If the available space between the floats is smaller now that we
5389 // know the BSize, return false (and cause another pass with
5390 // LineReflowStatus::RedoMoreFloats). We ensure aAvailableSpaceBSize
5391 // never decreases, which means that we can't reduce the set of floats
5392 // we intersect, which means that the available space cannot grow.
5395 // Prepare data for redoing the line.
5398 // Since we want to redo the line, we update aFlowArea by using the
5399 // aFloatStateBeforeLine, which is the float manager's state before the
5400 // line is placed.
5408 // Restore the BSize to the position of the next band.
5411 // Enforce both IStart() and IEnd() never move outwards to prevent
5412 // infinite grow-shrink loops.
5420 }
5423 }
5426 }
5428 #ifdef DEBUG
5438 }
5441 }
5442 }
5443 #endif
5445 // Only block frames horizontally align their children because
5446 // inline frames "shrink-wrap" around their children (therefore
5447 // there is no extra horizontal space).
5450 /**
5451 * We don't care checking for IsLastLine properly if we don't care (if it
5452 * can't change the used text-align value for the line).
5453 *
5454 * In other words, isLastLine really means isLastLineAndWeCare.
5455 */
5463 // From here on, pfd->mBounds rectangles are incorrect because bidi
5464 // might have moved frames around!
5465 OverflowAreas overflowAreas;
5470 }
5472 // Inline lines do not have margins themselves; however they are
5473 // impacted by prior block margins. If this line ends up having some
5474 // height then we zero out the previous block-end margin value that was
5475 // already applied to the line's starting Y coordinate. Otherwise we
5476 // leave it be so that the previous blocks block-end margin can be
5477 // collapsed with a block that follows.
5478 nscoord newBCoord;
5481 // This line has some height. Therefore the application of the
5482 // previous-bottom-margin should stick.
5486 // Don't let the previous-bottom-margin value affect the newBCoord
5487 // coordinate (it was applied in ReflowInlineFrames speculatively)
5488 // since the line is empty.
5489 // We already called |ShouldApplyBStartMargin|, and if we applied it
5490 // then mShouldApplyBStartMargin is set.
5495 }
5502 }
5504 // See if the line fit (our first line always does).
5510 // All our content doesn't fit, start on the next page.
5513 // Push aLine and all of its children and anything else that
5514 // follows to our next-in-flow.
5516 }
5518 }
5520 // Note that any early return before this update of aState.mBCoord
5521 // must either (a) return false or (b) set aKeepReflowGoing to false.
5522 // Otherwise we'll keep reflowing later lines at an incorrect
5523 // position, and we might not come back and clean up the damage later.
5526 // Add the already placed current-line floats to the line
5529 // Any below current line floats to place?
5531 // Reflow the below-current-line floats, which places on the line's
5532 // float list.
5534 }
5536 // When a line has floats, factor them into the overflow areas computations.
5538 // Union the float overflow areas (stored in aState) and the value computed
5539 // by the line layout code.
5544 #ifdef NOISY_OVERFLOW_AREAS
5549 #endif
5550 }
5552 // Apply break-after clearing if necessary
5553 // This must stay in sync with |ReflowDirtyLines|.
5557 }
5559 }
5563 // NOTE: aLineBefore is always a normal line, not an overflow line.
5564 // The following expression will assert otherwise.
5569 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
5573 // Remove floats in the lines from mFloats
5574 nsFrameList floats;
5578 #ifdef DEBUG
5582 }
5583 #endif
5584 // Push the floats onto the front of the overflow out-of-flows list
5587 }
5589 // overflow lines can already exist in some cases, in particular,
5590 // when shrinkwrapping and we discover that the shrinkwap causes
5591 // the height of some child block to grow which creates additional
5592 // overflowing content. In such cases we must prepend the new
5593 // overflow to the existing overflow.
5596 // XXXldb use presshell arena!
5598 }
5608 }
5616 // this takes ownership but it won't delete it immediately so we
5617 // can keep using it.
5620 // Mark all the overflow lines dirty so that they get reflowed when
5621 // they are pulled up by our next-in-flow.
5623 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
5633 }
5634 }
5635 }
5636 }
5638 #ifdef DEBUG
5640 #endif
5641 }
5643 // The overflowLines property is stored as a pointer to a line list,
5644 // which must be deleted. However, the following functions all maintain
5645 // the invariant that the property is never set if the list is empty.
5648 #ifdef DEBUG
5650 #endif
5652 // Steal the prev-in-flow's overflow lines and prepend them.
5659 // Make all the frames on the overflow line list mine.
5662 // Collect overflow containers from our OverflowContainers list that are
5663 // continuations from the frames we picked up from our prev-in-flow, then
5664 // prepend those to ExcessOverflowContainers to ensure the continuations
5665 // are ordered.
5667 nsFrameList ocContinuations;
5679 }
5681 }
5684 }
5685 }
5691 }
5692 }
5693 }
5695 // Make the overflow out-of-flow frames mine too.
5698 // In case we own any next-in-flows of any of the drained frames, then
5699 // move those to the PushedFloat list.
5700 nsFrameList pushedFloats;
5707 }
5708 }
5714 }
5715 }
5718 // Remember to recompute the margins on the first line. This will
5719 // also recompute the correct deltaBCoord if necessary.
5721 }
5722 // The overflow lines have already been marked dirty and their previous
5723 // margins marked dirty also.
5725 // Prepend the overflow frames/lines to our principal list.
5731 }
5732 }
5734 // Now append our own overflow lines.
5736 }
5742 }
5744 // No need to reparent frames in our own overflow lines/oofs, because they're
5745 // already ours. But we should put overflow floats back in mFloats.
5746 // (explicit scope to remove the OOF list before VerifyOverflowSituation)
5747 {
5750 #ifdef DEBUG
5754 }
5755 #endif
5756 // The overflow floats go after our regular floats.
5758 }
5759 }
5763 }
5765 #ifdef DEBUG
5767 #endif
5769 }
5771 /**
5772 * Pushed floats are floats whose placeholders are in a previous
5773 * continuation. They might themselves be next-continuations of a float
5774 * that partially fit in an earlier continuation, or they might be the
5775 * first continuation of a float that couldn't be placed at all.
5776 *
5777 * Pushed floats live permanently at the beginning of a block's float
5778 * list, where they must live *before* any floats whose placeholders are
5779 * in that block.
5780 *
5781 * Temporarily, during reflow, they also live on the pushed floats list,
5782 * which only holds them between (a) when one continuation pushes them to
5783 * its pushed floats list because they don't fit and (b) when the next
5784 * continuation pulls them onto the beginning of its float list.
5785 *
5786 * DrainPushedFloats sets up pushed floats the way we need them at the
5787 * start of reflow; they are then reflowed by ReflowPushedFloats (which
5788 * might push some of them on). Floats with placeholders in this block
5789 * are reflowed by (BlockReflowState/nsLineLayout)::AddFloat, which
5790 * also maintains these invariants.
5791 *
5792 * DrainSelfPushedFloats moves any pushed floats from this block's own
5793 * PushedFloats list back into mFloats. DrainPushedFloats additionally
5794 * moves frames from its prev-in-flow's PushedFloats list into mFloats.
5795 */
5797 // If we're getting reflowed multiple times without our
5798 // next-continuation being reflowed, we might need to pull back floats
5799 // that we just put in the list to be pushed to our next-in-flow.
5800 // We don't want to pull back any next-in-flows of floats on our own
5801 // float list, and we only need to pull back first-in-flows whose
5802 // placeholders were in earlier blocks (since first-in-flows whose
5803 // placeholders are in this block will get pulled appropriately by
5804 // AddFloat, and will then be more likely to be in the correct order).
5808 // When we pull back floats, we want to put them with the pushed
5809 // floats, which must live at the start of our float list, but we
5810 // want them at the end of those pushed floats.
5811 // FIXME: This isn't quite right! What if they're all pushed floats?
5817 }
5827 // This is a first continuation that was pushed from one of our
5828 // previous continuations. Take it out of the pushed floats
5829 // list and put it in our floats list, before any of our
5830 // floats, but after other pushed floats.
5833 }
5836 }
5840 }
5841 }
5842 }
5847 // After our prev-in-flow has completed reflow, it may have a pushed
5848 // floats list, containing floats that we need to own. Take these.
5854 }
5855 }
5856 }
5861 }
5870 }
5875 }
5885 }
5894 }
5896 // This takes ownership of aOverflowLines.
5897 // XXX We should allocate overflowLines from presShell arena!
5907 // Verify that we won't overwrite an existing overflow list
5911 }
5916 }
5920 }
5931 }
5945 }
5946 }
5951 }
5956 }
5961 }
5966 }
5971 }
5976 }
5980 }
5986 }
5993 }
5998 }
6003 }
6005 //////////////////////////////////////////////////////////////////////
6006 // Frame list manipulation routines
6011 }
6017 }
6020 }
6022 // Find the proper last-child for where the append should go
6028 #ifdef NOISY_REFLOW_REASON
6033 }
6037 }
6039 #endif
6044 // Workaround for bug 1399425 in case this bit has been removed from the
6045 // SVGTextFrame just before the parser adds more descendant nodes.
6047 }
6054 }
6055 }
6068 }
6071 }
6073 #ifdef NOISY_REFLOW_REASON
6078 }
6082 }
6084 #endif
6091 }
6092 }
6096 #ifdef NOISY_REFLOW_REASON
6101 #endif
6108 }
6110 // Make sure to mark affected lines dirty for the float frame
6111 // we are removing; this way is a bit messy, but so is the rest of the code.
6112 // See bug 390762.
6120 }
6123 // Skip the call to |FrameNeedsReflow| below by returning now.
6128 }
6133 }
6139 }
6140 // XXX the TEXT_OFFSETS_NEED_FIXING check is a wallpaper for bug 822910.
6144 }
6146 }
6150 // Clear our line cursor, since our lines may change.
6155 }
6157 // Attempt to find the line that contains the previous sibling
6171 // We need to find out which list it's actually in. Assume that
6172 // *if* we have overflow lines, that our primary lines aren't
6173 // huge, but our overflow lines might be.
6178 }
6180 }
6182 // By elimination, the line must be in our overflow lines.
6185 }
6186 }
6199 // XXX_perf This is technically O(N^2) in some cases, but by using
6200 // RFind instead of Find, we make it O(N) in the most common case,
6201 // which is appending content.
6203 // Find the line that contains the previous sibling
6207 // Not in mLines - try overflow lines.
6216 }
6221 // Note: defensive code! RFindLineContaining must not return
6222 // false in this case, so if it does...
6226 }
6227 }
6228 }
6229 }
6231 // Find the frame following aPrevSibling so that we can join up the
6232 // two lists of frames.
6234 // Split line containing aPrevSibling in two if the insertion
6235 // point is somewhere in the middle of the line.
6238 // Split the line in two where the frame(s) are being inserted.
6242 // Mark prevSibLine dirty and as needing textrun invalidation, since
6243 // we may be breaking up text in the line. Its previous line may also
6244 // need to be invalidated because it may be able to pull some text up.
6246 // The new line will also need its textruns recomputed because of the
6247 // frame changes.
6250 }
6254 }
6258 // Walk through the new frames being added and update the line data
6259 // structures to fit.
6270 // If the frame is a block frame, or if there is no previous line or if the
6271 // previous line is a block line we need to make a new line. We also make
6272 // a new line, as an optimization, in the two cases we know we'll need it:
6273 // if the previous line ended with a <br>, or if it has significant
6274 // whitespace and ended in a newline.
6277 // Create a new line for the frame and add its line to the line
6278 // list.
6281 // Append new line after prevSibLine
6285 // New line is going before the other lines
6288 }
6291 // We're adding inline content to prevSibLine, so we need to mark it
6292 // dirty, ensure its textruns are recomputed, and possibly do the same
6293 // to its previous line since that line may be able to pull content up.
6295 }
6298 }
6300 #ifdef DEBUG
6303 #endif
6304 }
6312 }
6314 }
6317 // 'display:block ruby' use the inner (Ruby) frame for insertions.
6320 }
6322 }
6328 }
6329 }
6332 // Find which line contains the float, so we can update
6333 // the float cache.
6337 }
6338 }
6339 }
6342 #ifdef DEBUG
6343 // Floats live in mFloats, or in the PushedFloat or OverflowOutOfFlows
6344 // frame list properties.
6351 }
6352 #endif
6356 }
6360 #if 0
6361 // XXXmats not yet - need to investigate BlockReflowState::mPushedFloats
6362 // first so we don't leave it pointing to a deleted list.
6365 }
6366 #endif
6368 }
6370 {
6374 }
6375 }
6376 }
6380 // The containing block is always the parent of aFrame.
6383 // Remove aFrame from the appropriate list.
6385 // This also deletes the next-in-flows
6389 // First remove aFrame's next-in-flows.
6392 }
6393 // Now remove aFrame from its child list and Destroy it.
6397 }
6398 }
6400 /**
6401 * This helps us iterate over the list of all normal + overflow lines
6402 */
6410 // Try the overflow lines
6418 }
6419 }
6420 }
6421 }
6424 LineIterator aLine)
6426 // This will assert if aLine isn't in mLines of aFrame:
6428 }
6431 LineIterator aLine,
6443 }
6446 // paint/layout containment boxes and multi-column containers establish an
6447 // independent formatting context.
6448 // https://drafts.csswg.org/css-contain/#containment-paint
6449 // https://drafts.csswg.org/css-contain/#containment-layout
6450 // https://drafts.csswg.org/css-multicol/#columns
6454 }
6460 }
6462 // If NS_BLOCK_STATIC_BFC flag was set when the frame was initialized, it
6463 // remains set during the lifetime of the frame and always forces it to be
6464 // treated as a BFC, independently of the value of NS_BLOCK_DYNAMIC_BFC.
6465 // Consequently, we don't bother invalidating or updating that latter flag.
6468 }
6473 // If the frame contains floats, this update may change their float
6474 // manager. Be safe by dirtying all descendant lines of the nearest
6475 // ancestor's float manager.
6478 }
6480 }
6481 }
6487 }
6489 // Figure out what the right style parent is. This needs to match
6490 // nsCSSFrameConstructor::CreateLetterFrame.
6494 }
6501 parentStyle);
6502 // Note that we don't need to worry about changehints for the continuation
6503 // styles: those will be handled by the styleParent already.
6506 parentStyle);
6510 // We also want to update the style on the textframe inside the first-letter.
6511 // We don't need to compute a changehint for this, though, since any changes
6512 // to it are handled by the first-letter anyway.
6516 firstLetterStyle);
6519 // We don't need to update style for textFrame's continuations: it's already
6520 // set up to inherit from parentStyle, which is what we want.
6521 }
6533 }
6538 }
6541 }
6543 }
6546 }
6557 }
6563 // The block has a single line - that must be it!
6566 }
6568 // Try to use the cursor if it exists, otherwise fall back to the first line
6571 // Perform a simultaneous forward and reverse search starting from the
6572 // line cursor.
6576 // rline is positioned on the line containing 'cursor', so it's not
6577 // rline_end. So we can safely increment it (i.e. move it to one line
6578 // earlier) to start searching there.
6585 }
6587 }
6592 }
6594 }
6595 }
6600 }
6602 }
6608 }
6609 }
6610 }
6611 // Didn't find the line
6614 // If we reach here, it means that we have not been able to find the
6615 // desired frame in our in-flow lines. So we should start looking at
6616 // our overflow lines. In order to do that, we set mLine to the end
6617 // iterator so that FindValidLine starts to look at overflow lines,
6618 // if any.
6622 }
6628 }
6630 }
6634 }
6639 }
6644 }
6651 }
6660 }
6665 }
6673 }
6674 }
6676 }
6677 }
6683 }
6690 }
6695 }
6703 }
6704 }
6706 }
6707 }
6709 // This function removes aDeletedFrame and all its continuations. It
6710 // is optimized for deleting a whole series of frames. The easy
6711 // implementation would invoke itself recursively on
6712 // aDeletedFrame->GetNextContinuation, then locate the line containing
6713 // aDeletedFrame and remove aDeletedFrame from that line. But here we
6714 // start by locating aDeletedFrame and then scanning from that point
6715 // on looking for continuations.
6718 // Clear our line cursor, since our lines may change.
6722 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6728 // FIXME(emilio): aContext is lost here, maybe it's not a big deal?
6731 }
6733 }
6735 // Find the line that contains deletedFrame
6740 // Make sure we look in the overflow lines even if the normal line
6741 // list is empty
6747 }
6751 }
6756 }
6765 }
6766 }
6775 }
6777 // If the frame being deleted is the last one on the line then
6778 // optimize away the line->Contains(next-in-flow) call below.
6783 next != line_end
6790 }
6792 // Remove aDeletedFrame from the line
6794 // We should be setting this to null if aDeletedFrame
6795 // is the only frame on the line. HOWEVER in that case
6796 // we will be removing the line anyway, see below.
6798 }
6800 // Hmm, this won't do anything if we're removing a frame in the first
6801 // overflow line... Hopefully doesn't matter
6804 // Since we just removed a frame that follows some inline
6805 // frames, we need to reflow the previous line.
6807 }
6810 // Take aDeletedFrame out of the sibling list. Note that
6811 // prevSibling will only be nullptr when we are deleting the very
6812 // first frame in the main or overflow list.
6817 }
6819 // Update the child count of the line to be accurate
6822 // Destroy frame; capture its next continuation first in case we need
6823 // to destroy that too.
6828 #ifdef NOISY_REMOVE_FRAME
6834 #endif
6836 // If next-in-flow is an overflow container, must remove it first.
6837 // FIXME: Can we do this unconditionally?
6839 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6843 }
6849 // If line is empty, remove it now.
6851 #ifdef NOISY_REMOVE_FRAME
6854 #endif
6858 // Invalidate the space taken up by the line.
6859 // XXX We need to do this if we're removing a frame as a result of
6860 // a call to RemoveFrame(), but we may not need to do this in all
6861 // cases...
6862 #ifdef NOISY_BLOCK_INVALIDATE
6866 #endif
6872 // We just invalidated our iterators. Since we were in
6873 // the overflow lines list, which is now empty, set them
6874 // so we're at the end of the regular line list.
6878 }
6879 }
6882 // If we're removing a line, ReflowDirtyLines isn't going to
6883 // know that it needs to slide lines unless something is marked
6884 // dirty. So mark the previous margin of the next line dirty if
6885 // there is one.
6888 }
6891 // Make the line that just lost a frame dirty, and advance to
6892 // the next line.
6898 }
6899 }
6902 // See if we should keep looking in the current flow's line list.
6904 // The deceased frames continuation is not a child of the
6905 // current block. So break out of the loop so that we advance
6906 // to the next parent.
6907 //
6908 // If we have a continuation in a different block then all bets are
6909 // off regarding whether we are deleting frames without actual content,
6910 // so don't propagate FRAMES_ARE_EMPTY any further.
6913 }
6915 // If we advanced to the next line then check if we should switch to the
6916 // overflow line list.
6920 // We have advanced to the next *normal* line but the next-in-flow
6921 // is not there - force a switch to the overflow line list.
6923 }
6927 #ifdef NOISY_REMOVE_FRAME
6930 #endif
6931 }
6932 }
6933 }
6938 }
6940 #ifdef DEBUG
6943 #endif
6945 // Advance to next flow block if the frame has more continuations.
6948 }
6953 }
6965 }
6966 }
6968 }
6978 // Optimize by comparing the line's last child first.
6985 }
6986 }
6987 }
6989 }
6997 }
7005 }
7009 }
7027 }
7028 }
7029 }
7038 }
7043 // The line became empty - destroy it.
7048 }
7050 }
7051 }
7059 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
7061 aDeletingEmptyFrames);
7063 #ifdef DEBUG
7066 }
7067 #endif
7070 }
7071 }
7074 // Return the pointer to an unmodified style text
7076 }
7088 // Setup a block reflow context to reflow the float.
7093 nsCollapsingMargin margin;
7096 // Only first in flow gets a block-start margin.
7103 // We don't need to push the float manager state because the the block
7104 // has its own float manager that will be destroyed and recreated
7105 }
7106 }
7108 // When reflowing a float, aSpace argument doesn't matter because we pass
7109 // nullptr to aLine and we don't call nsBlockReflowContext::PlaceBlock()
7110 // later.
7116 // We never split floating first letters; an incomplete status for such
7117 // frames simply means that there is more content to be reflowed on the
7118 // line.
7121 }
7122 }
7126 "The status can only be incomplete or overflow-incomplete if "
7131 }
7135 // Set the rect, make sure the view is properly sized and positioned,
7136 // and tell the frame we're done reflowing it
7137 // XXXldb This seems like the wrong place to be doing this -- shouldn't
7138 // we be doing this in BlockReflowState::FlowAndPlaceFloat after
7139 // we've positioned the float, and shouldn't we be doing the equivalent
7140 // of |PlaceFrameView| here?
7147 }
7149 }
7157 }
7158 }
7160 }
7164 // Pushed floats live at the start of our float list; see comment
7165 // above nsBlockFrame::DrainPushedFloats.
7170 // When we push a first-continuation float in a non-initial reflow,
7171 // it's possible that we end up with two continuations with the same
7172 // parent. This happens if, on the previous reflow of the block or
7173 // a previous reflow of the line containing the block, the float was
7174 // split between continuations A and B of the parent, but on the
7175 // current reflow, none of the float can fit in A.
7176 //
7177 // When this happens, we might even have the two continuations
7178 // out-of-order due to the management of the pushed floats. In
7179 // particular, if the float's placeholder was in a pushed line that
7180 // we reflowed before it was pushed, and we split the float during
7181 // that reflow, we might have the continuation of the float before
7182 // the float itself. (In the general case, however, it's correct
7183 // for floats in the pushed floats list to come before floats
7184 // anchored in pushed lines; however, in this case it's wrong. We
7185 // should probably find a way to fix it somehow, since it leads to
7186 // incorrect layout in some cases.)
7187 //
7188 // When we have these out-of-order continuations, we might hit the
7189 // next-continuation before the previous-continuation. When that
7190 // happens, just push it. When we reflow the next continuation,
7191 // we'll either pull all of its content back and destroy it (by
7192 // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
7193 // pull it out of its current position and push it again (and
7194 // potentially repeat this cycle for the next continuation, although
7195 // hopefully then they'll be in the right order).
7196 //
7197 // We should also need this code for the in-order case if the first
7198 // continuation of a float gets moved across more than one
7199 // continuation of the containing block. In this case we'd manage
7200 // to push the second continuation without this check, but not the
7201 // third and later.
7208 }
7210 // Always call FlowAndPlaceFloat; we might need to place this float if it
7211 // didn't belong to this block the last time it was reflowed. Note that if
7212 // the float doesn't get placed, we don't consider its overflow areas.
7213 // (Not-getting-placed means it didn't fit and we pushed it instead of
7214 // placing it, and its position could be stale.)
7218 }
7222 // We didn't push |f| so its next-sibling is next.
7227 }
7229 // If there are pushed or split floats, then we may need to continue BR
7230 // clearance
7236 }
7237 }
7238 }
7242 // Recover our own floats
7244 // belong to our next-in-flow
7251 }
7252 }
7254 // Recurse into our overflow container children
7259 }
7261 // Recurse into our normal children
7265 }
7266 }
7267 }
7271 WritingMode aWM,
7275 // Only blocks have floats
7277 // Don't recover any state inside a block that has its own float manager
7278 // (we don't currently have any blocks like this, though, thanks to our
7279 // use of extra frames for 'overflow')
7281 // If the element is relatively positioned, then adjust x and y
7282 // accordingly so that we consider relatively positioned frames
7283 // at their original position.
7291 }
7292 }
7296 // If we have pushed floats, then they should be at the beginning of our
7297 // float list.
7300 }
7301 }
7303 #ifdef DEBUG
7304 // Double-check the above assertion that pushed floats should be at the
7305 // beginning of our floats list.
7309 }
7310 #endif
7312 // We may have a pending push of pushed floats too:
7314 // XXX we can return 'true' here once we make HasPushedFloats
7315 // not lie. (see nsBlockFrame::RemoveFloat)
7318 }
7320 }
7322 //////////////////////////////////////////////////////////////////////
7323 // Painting, event handling
7325 #ifdef DEBUG
7331 // Compute min and max x/y values for the reflowed frame's
7332 // combined areas
7340 }
7343 }
7346 }
7349 }
7350 }
7356 }
7357 #endif
7359 #ifdef DEBUG
7368 }
7369 }
7370 #endif
7378 #ifdef DEBUG
7380 aDrawnLines++;
7381 }
7385 #endif
7387 // Collect our line's display items in a temporary nsDisplayListCollection,
7388 // so that we can apply any "text-overflow" clipping to the entire collection
7389 // without affecting previous lines.
7392 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
7393 // Inline-level child backgrounds go on the regular child content list.
7395 collection,
7399 aLineInLine
7408 }
7412 aLineNumberForTextOverflow);
7413 }
7416 }
7422 #ifdef DEBUG
7426 nsRect ca;
7433 }
7438 }
7439 #endif
7441 // TODO(heycam): Should we boost the load priority of any shape-outside
7442 // images using CATEGORY_DISPLAY, now that this block is being displayed?
7443 // We don't have a float manager here.
7452 }
7453 }
7454 }
7459 // Display outside ::marker manually.
7461 }
7463 // Prepare for text-overflow processing.
7472 // TODO(miko): Unfortunately |descendAlways| cannot be cached, because with
7473 // some frame trees, building display list for child lines can change it.
7474 // See bug 1552789.
7482 };
7486 // We'll try to draw an accessibility backplate behind text (to ensure it's
7487 // readable over any possible background-images), if all of the following
7488 // hold:
7489 // (A) the backplate feature is preffed on
7490 // (B) we are not honoring the document colors
7491 // (C) the force color adjust property is set to auto
7496 }
7498 // Don't use the line cursor if we might have a descendant placeholder ...
7499 // it might skip lines that contain placeholders but don't themselves
7500 // intersect with the dirty area.
7501 // In particular, we really want to check ShouldDescendIntoFrame()
7502 // on all our child frames, but that might be expensive. So we
7503 // approximate it by checking it on |this|; if it's true for any
7504 // frame in our child list, it's also true for |this|.
7505 // Also skip the cursor if we're creating text overflow markers,
7506 // since we need to know what line number we're up to in order
7507 // to generate unique display item keys.
7508 // Lastly, the cursor should be skipped if we're drawing
7509 // backplates behind text. When backplating we consider consecutive
7510 // runs of text as a whole, which requires we iterate through all lines
7511 // to find our backplate size.
7524 // Because we have a cursor, the combinedArea.ys are non-decreasing.
7525 // Once we've passed aDirtyRect.YMost(), we can never see it again.
7528 }
7534 }
7535 }
7536 }
7543 // A frame's display list cannot contain more than one copy of a
7544 // given display item unless the items are uniquely identifiable.
7545 // Because backplate occasionally requires multiple
7546 // SolidColor items, we use an index (backplateIndex) to maintain
7547 // uniqueness among them. Note this is a mapping of index to
7548 // item, and the mapping is stable even if the dirty rect changes.
7550 nsRect curBackplateArea;
7556 };
7565 }
7568 // If we have encountered a non-inline line but were previously
7569 // forming a backplate, we should add the backplate to the display
7570 // list as-is and render future backplates disjointly.
7572 "if this master switch is off, curBackplateArea "
7575 backplateIndex++;
7577 }
7582 }
7592 }
7593 }
7594 }
7595 lineCount++;
7596 }
7600 }
7604 }
7605 }
7608 // Put any text-overflow:ellipsis markers on top of the non-positioned
7609 // content of the block's lines. (If we ever start sorting the Content()
7610 // list this will end up in the wrong place.)
7612 }
7614 #ifdef DEBUG
7621 }
7635 }
7636 #endif
7637 }
7639 #ifdef ACCESSIBILITY
7643 }
7645 // block frame may be for <hr>
7648 }
7651 // XXXsmaug What if we're in the shadow dom?
7653 // Don't create accessible objects for the root content node, they are
7654 // redundant with the nsDocAccessible object created with the document
7655 // node
7657 }
7660 // Don't create accessible objects for the body, they are redundant with
7661 // the nsDocAccessible object created with the document node
7663 }
7665 // Not a list item with a ::marker, treat as normal HTML container.
7667 }
7669 // Create special list item accessible since we have a ::marker.
7671 }
7672 #endif
7677 }
7681 }
7686 }
7690 }
7693 // Although this looks like a "querying" method, it is used by the
7694 // display-list building code, so uses the Display cursor.
7698 }
7706 }
7711 }
7715 }
7718 }
7720 /* virtual */
7722 // See if the child is absolutely positioned
7724 // do nothing
7726 // The ::marker lives in the first line, unless the first line has
7727 // height 0 and there is a second line, in which case it lives
7728 // in the second line.
7733 }
7737 }
7738 // otherwise we have an empty line list, and ReflowDirtyLines
7739 // will handle reflowing the ::marker.
7741 // Note that we should go through our children to mark lines dirty
7742 // before the next reflow. Doing it now could make things O(N^2)
7743 // since finding the right line is O(N).
7744 // We don't need to worry about marking lines on the overflow list
7745 // as dirty; we're guaranteed to reflow them if we take them off the
7746 // overflow list.
7747 // However, we might have gotten a float, in which case we need to
7748 // reflow the line containing its placeholder. So find the
7749 // ancestor-or-self of the placeholder that's a child of the block,
7750 // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
7751 // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7752 // We need to take some care to handle the case where a float is in
7753 // a different continuation than its placeholder, including marking
7754 // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7761 // SVG code sometimes sends FrameNeedsReflow notifications during
7762 // frame destruction, leading to null placeholders, but we're safe
7763 // ignoring those.
7771 }
7773 }
7775 }
7776 }
7777 }
7780 }
7785 // CSS Multi-column level 1 section 2: A multi-column container
7786 // establishes a new block formatting context, as per CSS 2.1 section
7787 // 9.4.1.
7792 // Ensure that the options inside the select aren't expanded by
7793 // right floats outside the select.
7795 // See bug 1373767 and bug 353894.
7799 }
7800 }
7804 // These are all the block specific frame bits, they are copied from
7805 // the prev-in-flow to a newly created next-in-flow, except for the
7806 // NS_BLOCK_FLAGS_NON_INHERITED_MASK bits below.
7812 // This is the subset of NS_BLOCK_FLAGS_MASK that is NOT inherited
7813 // by default. They should only be set on the first-in-flow.
7816 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7819 // Copy over the inherited block frame bits from the prev-in-flow.
7823 }
7830 }
7832 // A display:flow-root box establishes a block formatting context.
7833 //
7834 // If a box has a different writing-mode value than its containing block:
7835 // ...
7836 // If the box is a block container, then it establishes a new block
7837 // formatting context.
7838 // (https://drafts.csswg.org/css-writing-modes/#block-flow)
7839 //
7840 // If the box has contain: paint or contain:layout (or contain:strict),
7841 // then it should also establish a formatting context.
7842 //
7843 // Per spec, a column-span always establishes a new block formatting context.
7844 //
7845 // Other more specific frame types also always establish a BFC.
7846 //
7855 }
7859 }
7864 }
7865 }
7872 #ifdef DEBUG
7873 // The only times a block that is an anonymous box is allowed to have a
7874 // first-letter frame are when it's the block inside a non-anonymous cell,
7875 // the block inside a fieldset, button or column set, or a scrolled content
7876 // block, except for <select>. Note that this means that blocks which are
7877 // the anonymous block in {ib} splits do NOT get first-letter frames.
7878 // Note that NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations
7879 // of the block.
7897 #endif
7902 }
7903 }
7908 NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER),
7916 // An outside ::marker needs to be an independent formatting context
7917 // to avoid being influenced by the float manager etc.
7919 }
7923 }
7924 }
7935 }
7940 nscoord aLineTop) {
7945 // Make up an inline-size since it doesn't really matter (XXX).
7951 nsReflowStatus status;
7954 // Get the float available space using our saved state from before we
7955 // started reflowing the block, so that we ignore any floats inside
7956 // the block.
7957 // FIXME: aLineTop isn't actually set correctly by some callers, since
7958 // they reposition the line.
7959 LogicalRect floatAvailSpace =
7960 aState
7964 // FIXME (bug 25888): need to check the entire region that the first
7965 // line overlaps, not just the top pixel.
7967 // Place the ::marker now. We want to place the ::marker relative to the
7968 // border-box of the associated block (using the right/left margin of
7969 // the ::marker frame as separation). However, if a line box would be
7970 // displaced by floats that are *outside* the associated block, we
7971 // want to displace it by the same amount. That is, we act as though
7972 // the edge of the floats is the content-edge of the block, and place
7973 // the ::marker at a position offset from there by the block's padding,
7974 // the block's border, and the ::marker frame's margin.
7976 // IStart from floatAvailSpace gives us the content/float start edge
7977 // in the current writing mode. Then we subtract out the start
7978 // border/padding and the ::marker's width and margin to offset the position.
7980 // Get the ::marker's margin, converted to our writing mode so that we can
7981 // combine it with other logical values here.
7987 // Approximate the ::marker's position; vertical alignment will provide
7988 // the final vertical location. We pass our writing-mode here, because
7989 // it may be different from the ::marker frame's mode.
7992 wm,
7996 }
7998 // This is used to scan frames for any float placeholders, add their
7999 // floats to the list represented by aList, and remove the
8000 // floats from whatever list they might be in. We don't search descendants
8001 // that are float containing blocks. Floats that or not children of 'this'
8002 // are ignored (they are not added to aList).
8006 // Don't descend into float containing blocks.
8014 // Remove the IS_PUSHED_FLOAT bit, in case |outOfFlowFrame| came from
8015 // the PushedFloats list.
8019 // FIXME: By not pulling floats whose parent is one of our
8020 // later siblings, are we risking the pushed floats getting
8021 // out-of-order?
8022 // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
8023 }
8029 }
8032 }
8034 }
8035 }
8038 #ifdef DEBUG
8039 // If any line is still dirty, that must mean we're going to reflow this
8040 // block again soon (e.g. because we bailed out after noticing that
8041 // clearance was imposed), so don't worry if the floats are out of sync.
8044 // Check that the float list is what we would have built
8049 }
8052 }
8053 }
8062 }
8063 // There are chances that the float children won't be added to lines,
8064 // because in nsBlockFrame::ReflowLine, it skips reflow line if the first
8065 // child of the line is IsHiddenByContentVisibilityOfInFlowParentForLayout.
8066 // There are also chances that the floats in line are out of date, for
8067 // instance, lines could reflow if
8068 // PresShell::IsForcingLayoutForHiddenContent, and after forcingLayout is
8069 // off, the reflow of lines could be skipped, but the floats are still in
8070 // there. Here we can't know whether the floats hidden by c-v are included
8071 // in the lines or not. So we use hasHiddenFloats to skip the float length
8072 // checking.
8076 }
8080 }
8082 }
8087 "nsBlockFrame::CheckFloats: Explicit float list is out of sync with "
8089 # if defined(DEBUG_roc)
8093 }
8096 }
8097 # endif
8098 }
8099 #endif
8103 // Floats that were pushed should be removed from our float
8104 // manager. Otherwise the float manager's YMost or XMost might
8105 // be larger than necessary, causing this block to get an
8106 // incorrect desired height (or width). Some of these floats
8107 // may not actually have been added to the float manager because
8108 // they weren't reflowed before being pushed; that's OK,
8109 // RemoveRegions will ignore them. It is safe to do this here
8110 // because we know from here on the float manager will only be
8111 // used for its XMost and YMost, not to place new floats and
8112 // lines.
8114 }
8115 }
8125 }
8126 }
8129 // The first column is a start margin root and the last column is an end
8130 // margin root. (If the column-set is split by a column-span:all box then
8131 // the first and last column in each column-set fragment are margin roots.)
8135 }
8139 }
8141 /* static */
8149 }
8151 /* static */
8155 }
8157 // Note that this width can vary based on the vertical position.
8158 // However, the cases where it varies are the cases where the width fits
8159 // in the available space given, which means that variation shouldn't
8160 // matter.
8161 /* static */
8168 FloatAvoidingISizeToClear result;
8171 nscoord availISize =
8174 // We actually don't want the min width here; see bug 427782; we only
8175 // want to displace if the width won't compute to a value small enough
8176 // to fit.
8177 // All we really need here is the result of ComputeSize, and we
8178 // could *almost* get that from an SizeComputationInput, except for the
8179 // last argument.
8181 LogicalSize availSpace =
8188 // Use the margins from sizingInput rather than reflowInput so that
8189 // they aren't reduced by ignoring margins in overconstrained cases.
8198 // If we get here, floatAvoidingBlock has a negative amount of inline-axis
8199 // margin and an 'auto' (or ~equivalently, -moz-available) inline
8200 // size. Under these circumstances, we use the margin to establish a
8201 // (positive) minimum size for the border-box, in order to satisfy the
8202 // equation in CSS2 10.3.3. That equation essentially simplifies to the
8203 // following:
8204 //
8205 // iSize of margins + iSize of borderBox = iSize of containingBlock
8206 //
8207 // ...where "iSize of borderBox" is the sum of floatAvoidingBlock's
8208 // inline-axis components of border, padding, and {width,height}.
8209 //
8210 // Right now, in the above equation, "iSize of margins" is the only term
8211 // that we know for sure. (And we also know that it's negative, since we
8212 // got here.) The other terms are as-yet unresolved, since the frame has an
8213 // 'auto' iSize, and since we aren't yet sure if we'll clear this frame
8214 // beyond floats or place it alongside them.
8215 //
8216 // However: we *do* know that the equation's "iSize of containingBlock"
8217 // term *must* be non-negative, since boxes' widths and heights generally
8218 // can't be negative in CSS. To satisfy that requirement, we can then
8219 // infer that the equation's "iSize of borderBox" term *must* be large
8220 // enough to cancel out the (known-to-be-negative) "iSize of margins"
8221 // term. Therefore, marginISize value (negated to make it positive)
8222 // establishes a lower-bound for how much inline-axis space our border-box
8223 // will really require in order to fit alongside any floats.
8224 //
8225 // XXXdholbert This explanation is admittedly a bit hand-wavy and may not
8226 // precisely match what any particular spec requires. It's the best
8227 // reasoning I could come up with to explain engines' behavior. Also, our
8228 // behavior with -moz-available doesn't seem particularly correct here, per
8229 // bug 1767217, though that's probably due to a bug elsewhere in our float
8230 // handling code...
8232 }
8236 }
8238 /* static */
8244 // yay, candidate is a block!
8246 }
8247 // Not a block. Check its parent next.
8249 }
8252 }
8255 nscoord aBEndEdgeOfChildren) {
8266 "An overflow container's effective content-box block-size, block-start "
8278 // If a block is split by any column-spans, we calculate the final
8279 // block-size by shrinkwrapping our children's block-size for all the
8280 // fragments except for those after the final column-span, but we should
8281 // take no more than our effective border-box block-size. If there's any
8282 // leftover block-size, our next continuations will take up rest.
8283 //
8284 // We don't need to adjust aBri.mReflowStatus because our children's status
8285 // is the same as ours.
8287 }
8292 }
8294 // Save our children's reflow status.
8301 }
8307 // The maximum value our content-box block-size can take within the given
8308 // available block-size.
8311 // The block-end edge of our content-box (relative to this frame's origin) if
8312 // we consumed the maximum block-size available to us (maxContentBoxBSize).
8315 // These variables are uninitialized intentionally so that the compiler can
8316 // check they are assigned in every if-else branch below.
8317 nscoord finalContentBoxBSizeWithBStartBP;
8321 // Our effective border-box block-size can fit in the available block-size,
8322 // so we are complete.
8326 // Note: The following assertion should generally hold because, for
8327 // box-decoration-break:clone, this "else if" branch is mathematically
8328 // equivalent to the initial "if".
8330 "This else-if branch is handling a situation that's specific "
8331 "to box-decoration-break:slice, i.e. a case when we can skip "
8334 // Our effective content-box block-size plus the block-start border and
8335 // padding can fit in the available block-size, but it cannot fit after
8336 // adding the block-end border and padding. Thus, we need a continuation
8337 // (unless we already weren't asking for any block-size, in which case we
8338 // stay complete to avoid looping forever).
8342 // We aren't going to be able to fit our content-box in the space available
8343 // to it, which means we'll probably call ourselves incomplete to request a
8344 // continuation. But before making that decision, we check for certain
8345 // conditions which would force us to overflow beyond the available space --
8346 // these might result in us actually being complete if we're forced to
8347 // overflow far enough.
8351 // In this rare case, we are at the top of page/column, we have
8352 // box-decoration-break:clone and zero available block-size for our
8353 // content-box (e.g. our own block-start border and padding already exceed
8354 // the available block-size), and we didn't lay out any child to consume
8355 // our content-box block-size. To ensure we make progress (avoid looping
8356 // forever), use 1px as our content-box block-size regardless of our
8357 // effective content-box block-size, in the spirit of
8358 // https://drafts.csswg.org/css-break/#breaking-rules.
8362 // We have a unbreakable child whose block-end edge exceeds the available
8363 // block-size for children.
8365 // The unbreakable child's block-end edge forces us to consume all of
8366 // our effective content-box block-size.
8369 // Even though we've consumed all of our effective content-box
8370 // block-size, we may still need to report an incomplete status in order
8371 // to get another continuation, which will be responsible for laying out
8372 // & drawing our block-end border & padding. But if we have no such
8373 // border & padding, or if we're forced to apply that border & padding
8374 // on this frame due to box-decoration-break:clone, then we don't need
8375 // to bother with that additional continuation.
8378 // The unbreakable child's block-end edge doesn't force us to consume
8379 // all of our effective content-box block-size.
8382 }
8384 // The children's block-end edge can fit in the content-box space that we
8385 // have available for it. Consume all the space that is available so that
8386 // our inline-start/inline-end borders extend all the way to the block-end
8387 // edge of column/page.
8390 }
8391 }
8397 // We want to use children's reflow status as ours, which can be overflow
8398 // incomplete. Suppress the urge to call aBri.mReflowStatus.Reset() here.
8401 }
8404 "An overflow container should always be complete because of "
8407 finalBorderBoxBSize =
8409 }
8413 }
8414 }
8417 }
8424 }
8427 // first-letter needs to be updated before first-line, because first-line can
8428 // change the style of the first-letter.
8431 }
8441 parentStyle);
8443 // FIXME(bz): Can we make first-line continuations be non-inheriting anon
8444 // boxes?
8452 // We also want to update the styles of the first-line's descendants. We
8453 // don't need to compute a changehint for this, though, since any changes to
8454 // them are handled by the first-line anyway.
8458 }
8459 }
8460 }
8464 // Certainly no first-letter frame.
8466 }
8469 }
8475 }
8478 }
8480 #ifdef DEBUG
8484 }
8487 }
8491 // Add up the counts on each line. Also validate that IsFirstLine is
8492 // set properly.
8497 }
8502 }
8503 }
8505 }
8507 // Then count the frames
8511 frameCount++;
8513 }
8516 // Next: test that each line has right number of frames on it
8523 }
8527 }
8528 }
8539 }
8540 }
8541 }
8542 }
8544 }
8547 // Overflow out-of-flows must not have a next-in-flow in mFloats or mFrames.
8554 }
8555 }
8557 // Pushed floats must not have a next-in-flow in mFloats or mFrames.
8564 }
8565 }
8567 // A child float next-in-flow's parent must be |this| or a next-in-flow of
8568 // |this|. Later next-in-flows must have the same or later parents.
8583 }
8584 }
8586 found,
8588 }
8589 }
8590 }
8603 }
8607 }
8611 ;
8616 ;
8617 }
8619 };
8625 }
8626 }
8633 depth++;
8634 }
8636 }
8642 }
8643 #endif