| blob | 0cf30859e3ed2a1f63af043f73a805e182e34aa5 |
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 */
49 #include <algorithm>
64 #include <inttypes.h>
82 }
83 }
85 }
86 }
94 }
96 }
98 // Mark every line at and below the line where the float was
99 // dirty, and mark their lines dirty too. We could probably do
100 // something more efficient --- e.g., just dirty the lines that intersect
101 // the float vertically.
103 }
105 /**
106 * Returns true if aFrame is a block that has one or more float children.
107 */
112 }
115 }
120 }
121 }
123 }
125 // Determines whether the given frame is visible text or has visible text that
126 // participate in the same line. Frames that are not line participants do not
127 // have their children checked.
132 }
137 }
141 }
142 }
144 }
146 // Determines whether any of the frames from the given line have visible text.
153 }
155 }
157 }
159 /**
160 * Iterates through the frame's in-flow children and
161 * unions the ink overflow of all text frames which
162 * participate in the line aFrame belongs to.
163 * If a child of aFrame is not a text frame,
164 * we recurse with the child as the aFrame argument.
165 * If aFrame isn't a line participant, we skip it entirely
166 * and return an empty rect.
167 * The resulting nsRect is offset relative to the parent of aFrame.
168 */
171 nsRect textArea;
175 }
180 }
181 }
182 // add aFrame's position to keep textArea relative to aFrame's parent
184 }
186 /**
187 * Iterates through the line's children and
188 * unions the ink overflow of all text frames.
189 * GetFrameTextArea unions and returns the ink overflow
190 * from all line-participating text frames within the given child.
191 * The nsRect returned from GetLineTextArea is offset
192 * relative to the given line.
193 */
196 nsRect textArea;
203 }
206 }
208 /**
209 * Starting with aFrame, iterates upward through parent frames and checks for
210 * non-transparent background colors. If one is found, we use that as our
211 * backplate color. Otheriwse, we use the default background color from
212 * our high contrast theme.
213 */
218 // NOTE(emilio): We assume themed frames (frame->IsThemed()) have correct
219 // background-color information so as to compute the right backplate color.
220 //
221 // This holds because HTML widgets with author-specified backgrounds or
222 // borders disable theming. So as long as the UA-specified background colors
223 // match the actual theme (which they should because we always use system
224 // colors with the non-native theme, and native system colors should also
225 // match the native theme), then we're alright and we should compute an
226 // appropriate backplate color.
230 }
236 }
238 // Even if there's a background image, if there's no background color we
239 // keep going up the frame tree, see bug 1723938.
241 }
243 // Try to avoid somewhat expensive math in the common case.
246 currentBackgroundColor =
248 }
250 // If fully opaque, we're done, otherwise keep going up blending with our
251 // background.
253 }
254 }
258 }
260 }
262 #ifdef DEBUG
281 };
293 };
294 # define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
302 }
305 }
318 }
330 }
331 }
334 }
338 }
341 }
344 }
345 }
346 }
347 }
349 #endif
351 //----------------------------------------------------------------------
353 // Debugging support code
355 #ifdef DEBUG
358 };
375 }
377 }
379 #endif
381 #ifdef REFLOW_STATUS_COVERAGE
386 // 0: child-is-block
387 // 1: child-is-inline
391 }
393 // Compute new status
402 }
407 }
409 // Log updates to the status that yield different values
413 }
414 }
415 #endif
426 //----------------------------------------------------------------------
430 }
440 // Add the size of any nsLineBox::mFrames hashtables we might have:
443 }
450 }
451 }
452 }
462 }
468 }
470 // destroy overflow lines now
476 }
482 }
487 }
490 }
492 /* virtual */
500 }
502 }
508 #ifdef DEBUG_FRAME_DUMP
511 nsCString str;
519 // Output the lines
524 }
525 }
527 // Output the overflow lines.
538 }
540 }
542 // skip the principal list - we printed the lines above
543 // skip the overflow list - we printed the overflow lines above
548 }
552 }
553 #endif
562 }
564 }
574 }
576 aRebuildDisplayItems);
577 }
582 }
587 BaselineSharingGroup aBaselineGroup,
596 // XXX Is this the right test? We have some bogus empty lines
597 // floating around, but IsEmpty is perhaps too weak.
602 }
604 }
606 }
610 }
613 // `<table>` in inline-block context does not export any baseline.
615 }
624 }
628 }
629 // Ignore relative positioning for baseline calculations.
634 }
636 }
638 }
645 }
649 aExportContext);
650 }
653 aExportContext);
654 }
665 }
667 }
668 }
679 }
681 /////////////////////////////////////////////////////////////////////////////
682 // Child frame enumeration
691 }
695 }
699 }
703 }
707 }
710 }
711 }
718 }
721 }
724 }
727 }
730 }
731 }
733 /* virtual */
736 /**
737 * Remove the first line from aFromLines and adjust the associated frame list
738 * aFromFrames accordingly. The removed line is assigned to *aOutLine and
739 * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
740 * that were extracted from the head of aFromFrames.
741 * aFromLines must contain at least one line, the line may be empty.
742 * @return true if aFromLines becomes empty
743 */
753 }
755 //////////////////////////////////////////////////////////////////////
756 // Reflow methods
758 /* virtual */
767 }
768 }
771 }
777 }
783 }
784 }
786 // Whether this line is indented by the text-indent amount.
792 // If not the first line of the block, but 'each-line' is in effect,
793 // check if the previous line was not wrapped.
795 }
797 // There's a prev-in-flow, so this only counts as a first-line if
798 // 'each-line' and the prev-in-flow's last line was not wrapped.
802 }
804 }();
806 // The 'hanging' option inverts which lines are/aren't indented.
808 }
811 IntrinsicISizeType aType) {
815 }
822 }
824 }
828 }
830 }
832 /* virtual */
836 }
838 #ifdef DEBUG
843 }
845 #endif
850 }
855 }
858 InlineMinISizeData data;
864 #ifdef DEBUG
869 }
871 #endif
884 }
895 }
896 }
897 }
898 #ifdef DEBUG
903 }
904 #endif
905 }
906 }
909 }
911 /* virtual */
915 }
917 #ifdef DEBUG
922 }
924 #endif
929 }
934 }
935 InlinePrefISizeData data;
941 #ifdef DEBUG
946 }
948 #endif
951 StyleClear clearType;
956 }
968 // XXXmats should the test below be indent > 0?
971 }
972 }
981 }
982 }
983 #ifdef DEBUG
988 }
989 #endif
990 }
991 }
994 }
997 // be conservative
1000 }
1002 }
1004 /* virtual */
1010 }
1015 nsresult rv;
1016 InlinePrefISizeData data;
1033 }
1037 // Per comment in nsIFrame::GetPrefWidthTightBounds(), the function is
1038 // only implemented for nsBlockFrame and nsTextFrame and is used to
1039 // determine the intrinsic inline sizes of MathML token elements. These
1040 // elements shouldn't have percentage block sizes that require a
1041 // percentage basis for resolution.
1052 }
1053 }
1054 }
1055 }
1059 }
1061 /**
1062 * Return whether aNewAvailableSpace is smaller *on either side*
1063 * (inline-start or inline-end) than aOldAvailableSpace, so that we know
1064 * if we need to redo layout on an line, replaced block, or block
1065 * formatting context, because its height (which we used to compute
1066 * aNewAvailableSpace) caused it to intersect additional floats.
1067 */
1073 // Positions are not significant if the inline size is zero.
1075 }
1080 "available space should not shrink on the start side and "
1085 "available space should not grow on the start side and "
1092 }
1093 // Have we shrunk on either side?
1096 }
1100 // The issue here is that for a 'height' of 'auto' the reflow input
1101 // code won't know how to calculate the containing block height
1102 // because it's calculated bottom up. So we use our own computed
1103 // size as the dimensions.
1107 // Containing block is relative to the padding edge
1115 }
1117 // We are a wrapped frame for the content (and the wrapper is not the
1118 // canvas frame, whose size is not meaningful here).
1119 // Use the container's dimensions, if they have been precomputed.
1120 // XXX This is a hack! We really should be waiting until the outermost
1121 // frame is fully reflowed and using the resulting dimensions, even
1122 // if they're intrinsic.
1123 // In fact we should be attaching absolute children to the outermost
1124 // frame and not always sticking them in block frames.
1126 // First, find the reflow input for the outermost frame for this content.
1134 }
1138 }
1140 // For scroll containers, we can just use cbSize (which is the padding-box
1141 // size of the scrolled-content frame).
1143 // Assert that we're not missing any frames between the abspos containing
1144 // block and the scroll container.
1145 // the parent.
1148 }
1150 // Same for fieldsets, where the inner anonymous frame has the correct padding
1151 // area with the legend taken into account.
1154 }
1156 // We found a reflow input for the outermost wrapping frame, so use
1157 // its computed metrics if available, converted to our writing mode
1163 }
1167 }
1170 }
1172 /**
1173 * Returns aFrame if it is a non-BFC block frame, and null otherwise.
1174 *
1175 * This is used to determine whether to recurse into aFrame when applying
1176 * -webkit-line-clamp.
1177 */
1182 }
1183 }
1185 }
1190 }
1195 }
1199 }
1204 }
1206 // For now, -webkit-box is the only thing allowed to be a line-clamp root.
1207 // Ideally we'd just make this work everywhere, but for now we're carrying
1208 // this forward as a limitation on the legacy -webkit-line-clamp feature,
1209 // since relaxing this limitation might create webcompat trouble.
1212 // If we're the anonymous block inside the scroll frame, we need to look
1213 // at the original display of our parent frame.
1218 ":-moz-scrolled-content should inherit -webkit-line-clamp, "
1221 }
1223 }();
1225 }
1230 }
1236 }
1239 }
1240 }
1242 }
1247 }
1250 }
1251 // For the OverflowOutOfFlowsProperty I think we do enforce that, but it's
1252 // a mix of out-of-flow frames, so that's why the method name has "Maybe".
1254 }
1256 /**
1257 * Iterator over all descendant inline line boxes, except for those that are
1258 * under an independent formatting context.
1259 */
1268 }
1269 }
1274 // Advances the iterator to the next line line.
1275 //
1276 // Next() shouldn't be called once the iterator is at the end, which can be
1277 // checked for by GetCurrentLine() or GetCurrentFrame() returning null.
1283 }
1289 // Reached the end of the current block. Pop the parent off the
1290 // stack; if there isn't one, then we've reached the end.
1294 }
1308 // Some kind of frame we shouldn't descend into.
1310 }
1314 }
1315 }
1316 }
1318 // The current line within the current block.
1319 //
1320 // When this is equal to mEnd, the iterator is at its end, and mCurrentFrame
1321 // is set to null.
1324 // The iterator end for the current block.
1327 // The current block.
1330 // Stack of mCurrentFrame and mEnd values that we push and pop as we enter and
1331 // exist blocks.
1333 };
1341 }
1342 }
1343 }
1345 }
1353 }
1354 }
1356 // We didn't find a line with the ellipsis; it must have been deleted already.
1358 }
1368 }
1374 #ifdef DEBUG
1381 }
1388 }
1389 #endif
1391 // ColumnSetWrapper's children depend on ColumnSetWrapper's block-size or
1392 // max-block-size because both affect the children's available block-size.
1395 }
1402 }
1403 });
1409 // If we have non-auto block size, we're clipping our kids and we fit,
1410 // make sure our kids fit too.
1415 LogicalMargin blockDirExtras =
1420 // Block-end margin never causes us to create continuations, so we
1421 // don't need to worry about whether it fits in its entirety.
1424 }
1431 }
1432 }
1436 }
1438 // OK, some lines may be reflowed. Blow away any saved line cursor
1439 // because we may invalidate the nondecreasing
1440 // overflowArea.InkOverflow().y/yMost invariant, and we may even
1441 // delete the line with the line cursor.
1444 // See comment below about oldSize. Use *only* for the
1445 // abs-pos-containing-block-size-change optimization!
1448 // Should we create a float manager?
1451 // XXXldb If we start storing the float manager in the frame rather
1452 // than keeping it around only during reflow then we should create it
1453 // only when there are actually floats to manage. Otherwise things
1454 // like tables will gain significant bloat.
1458 }
1463 }
1465 // Whether to apply text-wrap: balance behavior.
1470 // Struct used to hold the "target" number of lines or clamp position to
1471 // maintain when doing text-wrap: balance.
1473 // If line-clamp is in effect, mContent and mOffset indicate the starting
1474 // position of the first line after the clamp limit, and mBlockCoord is the
1475 // block-axis offset of its position.
1476 // If line-clamp is not in use, mContent is null, mOffset is the total
1477 // number of lines that the block must contain, and mBlockCoord is its end
1478 // edge in the block direction.
1486 }
1489 }
1490 };
1492 BalanceTarget balanceTarget;
1494 // Helpers for text-wrap: balance implementation:
1496 // Count the number of lines in the mLines list, but return -1 (to suppress
1497 // balancing) instead if the count is going to exceed aLimit, or if we
1498 // encounter a block.
1504 }
1505 }
1507 };
1509 // Return a BalanceTarget record representing the position at which line-clamp
1510 // will take effect for the current line list. Only to be used when there are
1511 // enough lines that the clamp will apply.
1517 }
1521 }
1525 }
1530 }
1532 };
1534 // "balancing" is implemented by shortening the effective inline-size of the
1535 // lines, so that content will tend to be pushed down to fill later lines of
1536 // the block. `balanceInset` is the current amount of "inset" to apply, and
1537 // `balanceStep` is the increment to adjust it by for the next iteration.
1540 // text-wrap: balance loop, executed only once if balancing is not required.
1541 nsReflowStatus reflowStatus;
1543 needFloatManager);
1545 // Save the initial floatManager state for repeated trial reflows.
1546 // We'll restore (and re-save) the initial state each time we repeat the
1547 // reflow.
1552 reflowStatus =
1555 // Do we need to start a `text-wrap: balance` iteration?
1558 // Don't try to balance an incomplete block, or if we had to use an
1559 // overflow-wrap break position in the initial reflow.
1562 }
1566 // If there are less than 2 lines, or the number exceeds the limit,
1567 // no balancing is needed; just break from the balance loop.
1569 }
1571 // Initialize the amount of inset to try, and the iteration step size.
1576 // If -webkit-line-clamp is in effect, then we need to maintain the
1577 // content location at which clamping occurs, rather than the total
1578 // number of lines in the block.
1586 }
1587 }
1588 }
1590 // Restore initial floatManager state for a new trial with updated inset.
1593 }
1595 // Helper to determine whether the current trial succeeded (i.e. was able
1596 // to fit the content into the expected number of lines).
1600 }
1604 }
1609 };
1611 // If we're in the process of a balance operation, check whether we've
1612 // inset by too much and either increase or reduce the inset for the next
1613 // iteration.
1619 }
1624 }
1626 // If we were attempting to balance, check whether the final iteration was
1627 // successful, and if not, back up by one step.
1631 }
1636 }
1638 // If we reach here, no balancing was required, so just exit; we don't
1639 // reset (pop) the floatManager state because this is the reflow we're
1640 // going to keep. So the saved state is just dropped.
1644 // If the block direction is right-to-left, we need to update the bounds of
1645 // lines that were placed relative to mContainerSize during reflow, as
1646 // we typically do not know the true container size until we've reflowed all
1647 // its children. So we use a dummy mContainerSize during reflow (see
1648 // BlockReflowState's constructor) and then fix up the positions of the
1649 // lines here, once the final block size is known.
1650 //
1651 // Note that writing-mode:vertical-rl is the only case where the block
1652 // logical direction progresses in a negative physical direction, and
1653 // therefore block-dir coordinate conversion depends on knowing the width
1654 // of the coordinate space in order to translate between the logical and
1655 // physical origins.
1660 // We compute our lines and markers' overflow areas later in
1661 // ComputeOverflowAreas(), so we don't need to adjust their overflow areas
1662 // here.
1666 }
1672 }
1673 }
1678 }
1679 }
1685 }
1686 }
1687 }
1688 }
1694 // Factor overflow container child bounds into the overflow area
1696 // Factor pushed float child bounds into the overflow area
1699 // Let the absolutely positioned container reflow any absolutely positioned
1700 // child frames that need to be reflowed, e.g., elements with a percentage
1701 // based width/height
1702 // We want to do this under either of two conditions:
1703 // 1. If we didn't do the incremental reflow above.
1704 // 2. If our size changed.
1705 // Even though it's the padding edge that's the containing block, we
1706 // can use our rect (the border edge) since if the border style
1707 // changed, the reflow would have been targeted at us so we'd satisfy
1708 // condition 1.
1709 // XXX checking oldSize is bogus, there are various reasons we might have
1710 // reflowed but our size might not have been changed to what we
1711 // asked for (e.g., we ended up being pushed to a new page)
1712 // When WillReflowAgainForClearance is true, we will reflow again without
1713 // resetting the size. Because of this, we must not reflow our abs-pos
1714 // children in that situation --- what we think is our "new size" will not be
1715 // our real new size. This also happens to be more efficient.
1721 // Make sure that when we reflow again we'll actually reflow all the abs
1722 // pos frames that might conceivably depend on our size (or all of them,
1723 // if we're dirty right now and interrupted; in that case we also need
1724 // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
1725 // better than that, because we don't really know what our size will be,
1726 // and it might in fact not change on the followup reflow!
1731 }
1733 // We're not going to reflow absolute frames; make sure to account for
1734 // their existing overflow areas, which is usually a side effect of this
1735 // reflow.
1736 //
1737 // TODO(emilio): nsAbsoluteContainingBlock::Reflow already checks for
1738 // interrupt, can we just rely on it and unconditionally take the else
1739 // branch below? That's a bit more subtle / risky, since I don't see
1740 // what would reflow them in that case if they depended on our size.
1744 }
1745 }
1747 LogicalSize containingBlockSize =
1751 // Mark frames that depend on changes we just made to this frame as dirty:
1752 // Now we can assume that the padding edge hasn't moved.
1753 // We need to reflow the absolutes if one of them depends on
1754 // its placeholder position, or the containing block size in a
1755 // direction in which the containing block size might have
1756 // changed.
1758 // XXX "width" and "height" in this block will become ISize and BSize
1759 // when nsAbsoluteContainingBlock is logicalized
1762 // If isRoot and we have auto height, then we are the initial
1763 // containing block and the containing block height is the
1764 // viewport height, which can't change during incremental
1765 // reflow.
1775 }
1778 }
1779 // Setup the line cursor here to optimize line searching for
1780 // calculating hypothetical position of absolutely-positioned
1781 // frames.
1786 }
1787 }
1793 #ifdef DEBUG
1794 // Between when we drain pushed floats and when we complete reflow,
1795 // we're allowed to have multiple continuations of the same float on
1796 // our floats list, since a first-in-flow might get pushed to a later
1797 // continuation of its containing block. But it's not permitted
1798 // outside that time.
1816 }
1818 }
1827 }
1840 }
1841 #endif
1842 }
1848 #ifdef DEBUG
1849 // Between when we drain pushed floats and when we complete reflow,
1850 // we're allowed to have multiple continuations of the same float on
1851 // our floats list, since a first-in-flow might get pushed to a later
1852 // continuation of its containing block. But it's not permitted
1853 // outside that time.
1856 #endif
1858 // ALWAYS drain overflow. We never want to leave the previnflow's
1859 // overflow lines hanging around; block reflow depends on the
1860 // overflow line lists being cleared out between reflow passes.
1872 // Handle paginated overflow (see nsContainerFrame.h)
1873 nsReflowStatus ocStatus;
1879 }
1881 // Now that we're done cleaning up our overflow container lists, we can
1882 // give |state| its nsOverflowContinuationTracker.
1886 // Drain & handle pushed floats
1890 // If we're not dirty (which means we'll mark everything dirty later)
1891 // and our inline-size has changed, mark the lines dirty that we need to
1892 // mark dirty for a resize reflow.
1895 }
1897 // The same for percentage text-indent, except conditioned on the
1898 // parent resizing.
1903 }
1905 // For text-wrap:balance trials, we need to reflow all the lines even if
1906 // they're not all "dirty".
1911 }
1913 // Now reflow...
1916 // If we have a next-in-flow, and that next-in-flow has pushed floats from
1917 // this frame from a previous iteration of reflow, then we should not return
1918 // a status with IsFullyComplete() equals to true, since we actually have
1919 // overflow, it's just already been handled.
1921 // NOTE: This really shouldn't happen, since we _should_ pull back our floats
1922 // and reflow them, but just in case it does, this is a safety precaution so
1923 // we don't end up with a placeholder pointing to frames that have already
1924 // been deleted as part of removing our next-in-flow.
1933 }
1935 }
1938 }
1939 }
1943 // If we end in a BR with clear and affected floats continue,
1944 // we need to continue, too.
1949 }
1954 }
1955 }
1957 // Place the ::marker's frame if it is placed next to a block child.
1958 //
1959 // According to the CSS2 spec, section 12.6.1, the ::marker's box
1960 // participates in the height calculation of the list-item box's
1961 // first line box.
1962 //
1963 // There are exactly two places a ::marker can be placed: near the
1964 // first or second line. It's only placed on the second line in a
1965 // rare case: an empty first line followed by a second line that
1966 // contains a block (example: <LI>\n<P>... ). This is where
1967 // the second case can happen.
1972 // Reflow the ::marker's frame.
1974 // XXX Use the entire line when we fix bug 25888.
1979 nscoord lineBStart =
1988 // We have some lines to align the ::marker with.
1990 // Doing the alignment using the baseline will also cater for
1991 // ::markers that are placed next to a child block (bug 92896)
1993 // Tall ::markers won't look particularly nice here...
1994 LogicalRect bbox =
2001 }
2004 });
2007 }
2008 // Otherwise just leave the ::marker where it is, up against our
2009 // block-start padding.
2010 }
2012 // Clear any existing -webkit-line-clamp ellipsis.
2015 }
2019 // Compute our final size (for this trial layout)
2024 // Align content
2028 }
2034 }
2037 }
2038 }
2040 }
2043 StyleLineClamp aLineNumber) {
2058 NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
2061 // Don't count a line that only has collapsible white space (as might exist
2062 // after calling e.g. getBoxQuads).
2066 }
2069 // We already previously found our target line, and now we have
2070 // confirmed that there is another line after it.
2073 }
2076 // This is our target line. Continue looping to confirm that we
2077 // have another line after us.
2080 }
2083 }
2088 }
2095 }
2099 nscoord aContentBlockEndEdge) {
2102 }
2107 // The number of lines did not exceed the -webkit-line-clamp value.
2109 }
2111 // Mark the line as having an ellipsis so that TextOverflow will render it.
2115 // Translate the b-end edge of the line up to aFrame's space.
2118 edge +=
2120 }
2123 }
2130 #ifdef NOISY_FINAL_SIZE
2136 #endif
2138 // Compute final inline size
2145 // Return block-end margin information
2146 // rbs says he hit this assertion occasionally (see bug 86947), so
2147 // just set the margin to zero and we'll figure out why later
2148 // NS_ASSERTION(aMetrics.mCarriedOutBEndMargin.IsZero(),
2149 // "someone else set the margin");
2152 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
2153 // line with clearance and a non-zero block-start margin and all
2154 // subsequent lines are empty, then we do not allow our children's
2155 // carried out block-end margin to be carried out of us and collapse
2156 // with our own block-end margin.
2158 // Convert the children's carried out margin to something that
2159 // we will include in our height
2162 }
2166 }
2169 // Shrink wrap our height around our contents.
2172 // When we are a block-end-margin root make sure that our last
2173 // child's block-end margin is fully applied. We also do this when
2174 // we have a computed height, since in that case the carried out
2175 // margin is not going to be applied anywhere, so we should note it
2176 // here to be included in the overflow area.
2177 // Apply the margin only if there's space for it.
2179 // Truncate block-end margin if it doesn't fit to our available BSize.
2180 blockEndEdgeOfChildren =
2183 }
2184 }
2186 // Include the float manager's state to properly account for the
2187 // block-end margin of any floated elements; e.g., inside a table cell.
2188 //
2189 // Note: The block coordinate returned by ClearFloats is always greater than
2190 // or equal to blockEndEdgeOfChildren.
2193 }
2195 // undo cached alignment shift for sizing purposes
2196 // (we used shifted positions because the float manager uses them)
2201 // Note: We don't use blockEndEdgeOfChildren because it includes the
2202 // previous margin.
2206 // We don't care about ApplyLineClamp's return value (the line-clamped
2207 // content BSize) in this explicit-BSize codepath, but we do still need to
2208 // call ApplyLineClamp for ellipsis markers to be placed as-needed.
2213 // If the content block-size is larger than the effective computed
2214 // block-size, we extend the block-size to contain all the content.
2215 // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
2217 // Note: finalSize.BSize(wm) is the border-box size, so we compare it with
2218 // the content's block-size plus our border and padding..
2223 // The size should be capped by its maximum block size.
2228 }
2229 }
2231 // Don't carry out a block-end margin when our BSize is fixed.
2232 //
2233 // Note: this also includes the case that aReflowInput.ComputedBSize() is
2234 // calculated from aspect-ratio. i.e. Don't carry out block margin-end if it
2235 // is replaced by the block size from aspect-ratio and inline size.
2238 // If we're size-containing in block axis and we don't have a specified
2239 // block size, then our final size should actually be computed from only
2240 // our border, padding and contain-intrinsic-block-size, ignoring the
2241 // actual contents. Hence this case is a simplified version of the case
2242 // below.
2244 nscoord autoBSize =
2250 // Our parent is expected to push this frame to the next page/column so
2251 // what size we set here doesn't really matter.
2265 // Our min-block-size, max-block-size, or -webkit-line-clamp value made
2266 // our bsize change. Don't carry out our kids' block-end margins.
2268 }
2273 // Applying `min-size` made us overflow our available size.
2274 // Clamp it and report that we're Incomplete, or BreakBefore if we have
2275 // 'break-inside: avoid' that is applicable.
2281 }
2282 }
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 }
2318 // Overflow containers can only be overflow complete.
2319 // Note that auto height overflow containers have no normal children
2323 }
2327 // Currently only used for grid items, but could be used in other contexts.
2328 // The FragStretchBSizeProperty is our expected non-fragmented block-size
2329 // we should stretch to (for align-self:stretch etc). In some fragmentation
2330 // cases though, the last fragment (this frame since we're complete), needs
2331 // to have extra size applied because earlier fragments consumed too much of
2332 // our computed size due to overflowing their containing block. (E.g. this
2333 // ensures we fill the last row when a multi-row grid item is fragmented).
2338 }
2339 }
2341 // Clamp the content size to fit within the margin-box clamp size, if any.
2355 // XXXmats deal with percentages better somehow?
2357 }
2358 }
2359 }
2361 // Screen out negative block sizes --- can happen due to integer overflows :-(
2368 }
2373 }
2377 nscoord aBEndEdgeOfChildren) {
2380 }
2385 // Short circuit
2393 // desired shift = 0, no cached shift to undo
2395 }
2397 // NOTE: ComputeFinalSize already called aState.UndoAlignContentShift(),
2398 // so metrics no longer include cached shift.
2399 // NOTE: Content is currently positioned at cached shift
2400 // NOTE: Content has been fragmented against 0-shift assumption.
2402 // Calculate shift
2411 // note: these measures all include start BP, so it subtracts out
2414 }
2417 }
2418 }
2419 // else: zero shift if start-aligned or if fragmented
2423 // Shift children
2427 }
2431 }
2435 }
2436 }
2439 // Cache shift
2443 }
2444 }
2451 // Factor in the block-end edge of the children. Child frames will be added
2452 // to the overflow area as we iterate through the lines, but their margins
2453 // won't, so we need to account for block-end margins here.
2454 // REVIEW: For now, we do this for both visual and scrollable area,
2455 // although when we make scrollable overflow area not be a subset of
2456 // visual, we can change this.
2459 // If we are a scrolled inner frame, add our block-end padding to our
2460 // children's block-end edge.
2461 //
2462 // Note: aBEndEdgeOfChildren already includes our own block-start padding
2463 // because it is relative to our block-start edge of our border-box, which
2464 // is the same as our padding-box here.
2468 }
2470 // XXX Currently, overflow areas are stored as physical rects, so we have
2471 // to handle writing modes explicitly here. If we change overflow rects
2472 // to be stored logically, this can be simplified again.
2478 // Layout containment should force all overflow to be ink (visual)
2479 // overflow, so if we're layout-contained, we only add our children's
2480 // block-end edge to the ink (visual) overflow -- not to the
2481 // scrollable overflow.
2484 }
2485 }
2494 }
2495 }
2496 }
2502 }
2503 }
2504 }
2505 }
2508 nscoord aBEndEdgeOfChildren,
2510 // XXX_perf: This can be done incrementally. It is currently one of
2511 // the things that makes incremental reflow O(N^2).
2516 }
2518 // We rely here on our caller having called SetOverflowAreasToDesiredBounds().
2523 // If we have layout containment, we should only consider our child's
2524 // ink overflow, leaving the scrollable regions of the parent
2525 // unaffected.
2526 // Note: scrollable overflow is a subset of ink overflow,
2527 // so this has the same affect as unioning the child's visual and
2528 // scrollable overflow with its parent's ink overflow.
2534 }
2535 }
2537 // Factor an outside ::marker in; normally the ::marker will be factored
2538 // into the line-box's overflow areas. However, if the line is a block
2539 // line then it won't; if there are no lines, it won't. So just
2540 // factor it in anyway (it can't hurt if it was already done).
2541 // XXXldb Can we just fix GetOverflowArea instead?
2544 }
2550 overflowClipMargin);
2551 }
2553 #ifdef NOISY_OVERFLOW_AREAS
2557 #endif
2558 }
2562 // We need to update the overflow areas of lines manually, as they
2563 // get cached and re-used otherwise. Lines aren't exposed as normal
2564 // frame children, so calling UnionChildOverflow alone will end up
2565 // using the old cached values.
2574 }
2576 // Consider the overflow areas of the floats attached to the line as well
2580 }
2581 }
2585 }
2587 // Union with child frames, skipping the principal and float lists
2588 // since we already handled those using the line boxes.
2592 }
2596 nscoord blockEndEdgeOfChildren =
2601 }
2603 // Line cursor invariants depend on the overflow areas of the lines, so
2604 // we must clear the line cursor since those areas may have changed.
2607 }
2617 // NOTE: MarkLineDirty does more than just marking the line dirty.
2620 }
2621 }
2622 }
2624 }
2625 }
2629 // Mark aLine dirty
2632 #ifdef DEBUG
2637 }
2638 #endif
2640 // Mark previous line dirty if it's an inline line so that it can
2641 // maybe pullup something from the line just affected.
2642 // XXX We don't need to do this if aPrevLine ends in a break-after...
2647 #ifdef DEBUG
2653 }
2654 #endif
2655 }
2656 }
2658 /**
2659 * Test whether lines are certain to be aligned left so that we can make
2660 * resizing optimizations
2661 */
2663 StyleDirection aDirection,
2664 StyleUnicodeBidi aUnicodeBidi,
2672 }
2675 // See if we can try and avoid marking all the lines as dirty
2676 // FIXME(emilio): This should be writing-mode aware, I guess.
2678 // The left content-edge must be a constant distance from the left
2679 // border-edge.
2682 #ifdef DEBUG
2685 }
2692 }
2693 }
2694 #endif
2698 nscoord newAvailISize =
2702 #ifdef DEBUG
2707 }
2708 #endif
2712 // We let child blocks make their own decisions the same
2713 // way we are here.
2721 }
2723 #ifdef REALLY_NOISY_REFLOW
2727 }
2728 #endif
2729 #ifdef DEBUG
2733 "skipped: line=%p next=%p %s %s%s%s clearTypeBefore/After=%s/%s "
2745 }
2746 #endif
2747 }
2749 // Mark everything dirty
2752 }
2753 }
2754 }
2756 //----------------------------------------
2758 /**
2759 * Propagate reflow "damage" from from earlier lines to the current
2760 * line. The reflow damage comes from the following sources:
2761 * 1. The regions of float damage remembered during reflow.
2762 * 2. The combination of nonzero |aDeltaBCoord| and any impact by a
2763 * float, either the previous reflow or now.
2764 *
2765 * When entering this function, |aLine| is still at its old position and
2766 * |aDeltaBCoord| indicates how much it will later be slid (assuming it
2767 * doesn't get marked dirty and reflowed entirely).
2768 */
2771 nscoord aDeltaBCoord) {
2779 // Check to see if there are any floats; if there aren't, there can't
2780 // be any float damage
2783 }
2785 // Check the damage region recorded in the float damage.
2787 // Need to check mBounds *and* mCombinedArea to find intersections
2788 // with aLine's floats
2791 // Scrollable overflow should be sufficient for things that affect
2792 // layout.
2795 LogicalRect overflow =
2798 nscoord lineBCoordCombinedAfter =
2804 lineBCoordCombinedAfter);
2808 }
2809 }
2811 // Check if the line is moving relative to the float manager
2814 // Unconditionally reflow sliding blocks; we only really need to reflow
2815 // if there's a float impacting this block, but the current float manager
2816 // makes it difficult to check that. Therefore, we let the child block
2817 // decide what it needs to reflow.
2821 nsFlowAreaRect floatAvailableSpace =
2825 #ifdef REALLY_NOISY_REFLOW
2828 #endif
2830 // Mark the line dirty if it was or is affected by a float
2831 // We actually only really need to reflow if the amount of impact
2832 // changes, but that's not straightforward to check
2835 }
2836 }
2837 }
2838 }
2844 NS_BLOCK_HAS_CLEAR_CHILDREN) ||
2847 }
2849 /**
2850 * Reparent a whole list of floats from aOldParent to this block. The
2851 * floats might be taken from aOldParent's overflow list. They will be
2852 * removed from the list. They end up appended to our floats list.
2853 */
2857 nsFrameList list;
2864 }
2866 }
2867 }
2871 #ifdef DEBUG
2877 "line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} "
2878 "oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} "
2885 }
2886 #endif
2887 }
2893 }
2894 }
2896 }
2905 #ifdef DEBUG
2911 }
2913 #endif
2919 // Reflow our last line if our availableBSize has increased
2920 // so that we (and our last child) pull up content as necessary
2929 }
2930 }
2931 // the amount by which we will slide the current line if it is not
2932 // dirty
2935 // whether we did NOT reflow the previous line and thus we need to
2936 // recompute the carried out margin before the line if we want to
2937 // reflow it or if its previous margin is dirty
2939 // Float continuations were reflowed in ReflowPushedFloats
2944 // We save up information about BR-clearance here
2949 // Determine if children of this frame could have breaks between them for
2950 // page names.
2951 //
2952 // We need to check for paginated layout, the named-page pref, and if the
2953 // available block-size is constrained.
2954 //
2955 // Note that we need to check for paginated layout as named-pages are only
2956 // used during paginated reflow. We need to additionally check for
2957 // unconstrained block-size to avoid introducing fragmentation breaks during
2958 // "measuring" reflows within an overall paginated reflow, and to avoid
2959 // fragmentation in monolithic containers like 'inline-block'.
2960 //
2961 // Because we can only break for named pages using Class A breakpoints, we
2962 // also need to check that the block flow direction of the containing frame
2963 // of these items (which is this block) is parallel to that of this page.
2964 // See: https://www.w3.org/TR/css-break-3/#btw-blocks
2972 // ReflowInput.mFlags.mCanHaveClassABreakpoints should respect the named
2973 // pages pref and presCtx->IsPaginated, so we did not explicitly check these
2974 // above when setting canBreakForPageNames.
2977 "canBreakForPageNames should not be set during non-paginated "
2979 }
2981 // Reflow the lines that are already ours
2984 #ifdef DEBUG
2986 #endif
2990 }
2992 // This really sucks, but we have to look inside any blocks that have clear
2993 // elements inside them.
2994 // XXX what can we do smarter here?
2999 }
3005 }
3007 // We have to reflow the line if it's a block whose clearance
3008 // might have changed, so detect that.
3012 // See where we would be after applying any clearance due to
3013 // BRs.
3017 }
3023 // Reflow the line if it might not have clearance anymore.
3025 // aState.mBCoord is the clearance point which should be the
3026 // block-start border-edge of the block frame. If sliding the
3027 // block by deltaBCoord isn't going to put it in the predicted
3028 // position, then we'd better reflow the line.
3031 }
3033 // Reflow the line if the line might have clearance now.
3036 }
3037 }
3038 }
3040 // We might have to reflow a line that is after a clearing BR.
3045 // SlideLine is not going to put the line where the clearance
3046 // put it. Reflow the line to be sure.
3048 }
3050 }
3054 // If the previous margin is dirty, reflow the current line
3063 // Lines that aren't dirty but get slid past our available block-size
3064 // constraint must be reflowed.
3066 }
3067 }
3071 // Last column can be reflowed unconstrained during column balancing.
3072 // Hence the additional NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR bit check
3073 // as a fail-safe fallback.
3076 // Table can also be reflowed unconstrained during printing.
3079 // We are in a paginated context, i.e. in columns or pages.
3083 // The following if-else conditions check whether this line -- which
3084 // might have floats in its subtree, or has floats as direct children,
3085 // or had floats pushed -- needs to be reflowed.
3087 // The distance to the block-end edge might have changed. Reflow the
3088 // line both because the breakpoints within its floats may have
3089 // changed and because we might have to push/pull the floats in
3090 // their entirety.
3093 // We had pushed floats which haven't been drained by our
3094 // next-in-flow, which means our parent is currently reflowing us
3095 // again due to clearance without creating a next-in-flow for us.
3096 // Reflow the line to redo the floats split logic to correctly set
3097 // our reflow status.
3100 // Reflow the line (that may containing a float's placeholder frame)
3101 // if our parent tells us to do so.
3104 // Our parent's line containing us moved to a different fragment.
3105 // Reflow the line because the decision about whether the float fits
3106 // may be different in a different fragment.
3108 }
3109 }
3110 }
3111 }
3114 // See if there's any reflow damage that requires that we mark the
3115 // line dirty.
3117 }
3119 // If the container size has changed, reset mContainerSize. If the
3120 // line's writing mode is not ltr, or if the line is not left-aligned, also
3121 // mark the line dirty.
3132 }
3133 }
3135 // Check for a page break caused by CSS named pages.
3136 //
3137 // We should break for named pages when two frames meet at a class A
3138 // breakpoint, where the first frame has a different end page value to the
3139 // second frame's start page value. canBreakForPageNames is true iff
3140 // children of this frame can form class A breakpoints, and that we are not
3141 // in a measurement reflow or in a monolithic container such as
3142 // 'inline-block'.
3143 //
3144 // We specifically do not want to cause a page-break for named pages when
3145 // we are at the top of a page. This would otherwise happen when the
3146 // previous sibling is an nsPageBreakFrame, or all previous siblings on the
3147 // current page are zero-height. The latter may not be per-spec, but is
3148 // compatible with Chrome's implementation of named pages.
3156 // Walk back to the last frame that isn't a placeholder.
3160 }
3164 }
3165 }
3166 }
3169 // We need to reconstruct the block-end margin only if we didn't
3170 // reflow the previous line and we do need to reflow (or repair
3171 // the block-start position of) the next line.
3173 }
3179 // Update aState.mPrevChild as if we had reflowed all of the frames in
3180 // this line.
3186 }
3187 }
3189 // Now repair the line and update |aState.mBCoord| by calling
3190 // |ReflowLine| or |SlideLine|.
3191 // If we're going to reflow everything again, then no need to reflow
3192 // the dirty line ... unless the line has floats, in which case we'd
3193 // better reflow it now to refresh its float cache, which may contain
3194 // dangling frame pointers! Ugh! This reflow of the line may be
3195 // incorrect because we skipped reflowing previous lines (e.g., floats
3196 // may be placed incorrectly), but that's OK because we'll mark the
3197 // line dirty below under "if (aState.mReflowInput.mDiscoveredClearance..."
3205 // Compute the dirty lines "before" BEnd, after factoring in
3206 // the running deltaBCoord value - the running value is implicit in
3207 // aState.mBCoord.
3212 "Don't reflow blocks while willReflowAgain is true, reflow "
3216 // Immediately fragment for page-name. It is possible we could break
3217 // out of the loop right here, but this should make it more similar to
3218 // what happens when reflow causes fragmentation.
3219 // Set the page name, so that PushTruncatedLine does not need to
3220 // recalculate the new page name.
3226 // Reflow the dirty line. If it's an incremental reflow, then force
3227 // it to invalidate the dirty area if necessary
3229 }
3234 // Note that once we've entered this state, every line that gets here
3235 // (e.g. because it has floats) gets marked dirty and reflowed again.
3236 // in the next pass. This is important, see above.
3237 }
3241 }
3247 }
3249 }
3251 // Test to see whether the margin that should be carried out
3252 // to the next line (NL) might have changed. In ReflowBlockFrame
3253 // we call nextLine->MarkPreviousMarginDirty if the block's
3254 // actual carried-out block-end margin changed. So here we only
3255 // need to worry about the following effects:
3256 // 1) the line was just created, and it might now be blocking
3257 // a carried-out block-end margin from previous lines that
3258 // used to reach NL from reaching NL
3259 // 2) the line used to be empty, and is now not empty,
3260 // thus blocking a carried-out block-end margin from previous lines
3261 // that used to reach NL from reaching NL
3262 // 3) the line wasn't empty, but now is, so a carried-out
3263 // block-end margin from previous lines that didn't used to reach NL
3264 // now does
3265 // 4) the line might have changed in a way that affects NL's
3266 // ShouldApplyBStartMargin decision. The three things that matter
3267 // are the line's emptiness, its adjacency to the block-start edge of the
3268 // block, and whether it has clearance (the latter only matters if the
3269 // block was and is adjacent to the block-start and empty).
3270 //
3271 // If the line is empty now, we can't reliably tell if the line was empty
3272 // before, so we just assume it was and do
3273 // nextLine->MarkPreviousMarginDirty. This means the checks in 4) are
3274 // redundant; if the line is empty now we don't need to check 4), but if
3275 // the line is not empty now and we're sure it wasn't empty before, any
3276 // adjacency and clearance changes are irrelevant to the result of
3277 // nextLine->ShouldApplyBStartMargin.
3284 // since it's marked dirty, nobody will care about |deltaBCoord|
3285 }
3286 }
3288 // If the line was just reflowed for the first time, then its
3289 // old mBounds cannot be trusted so this deltaBCoord computation is
3290 // bogus. But that's OK because we just did
3291 // MarkPreviousMarginDirty on the next line which will force it
3292 // to be reflowed, so this computation of deltaBCoord will not be
3293 // used.
3296 // Now do an interrupt check. We want to do this only in the case when we
3297 // actually reflow the line, so that if we get back in here we'll get
3298 // further on the reflow before interrupting.
3302 // Nop except for blocks (we don't create overflow container
3303 // continuations for any inlines atm), so only checking mFirstChild
3304 // is enough
3312 }
3317 // If we're going to reflow everything again, and this line is a block,
3318 // then there is no need to recover float state. The line may contain
3319 // other lines with floats, but in that case RecoverStateFrom would only
3320 // add floats to the float manager. We don't need to do that because
3321 // everything's going to get reflowed again "for real". Calling
3322 // RecoverStateFrom in this situation could be lethal because the
3323 // block's descendant lines may have float caches containing dangling
3324 // frame pointers. Ugh!
3325 // If this line is inline, then we need to recover its state now
3326 // to make sure that we don't forget to move its floats by deltaBCoord.
3328 // XXX EVIL O(N^2) EVIL
3330 }
3332 // Keep mBCoord up to date in case we're propagating reflow damage
3333 // and also because our final height may depend on it. If the
3334 // line is inlines, then only update mBCoord if the line is not
3335 // empty, because that's what PlaceLine does. (Empty blocks may
3336 // want to update mBCoord, e.g. if they have clearance.)
3339 }
3345 // Need to make sure to pull overflows from any prev-in-flows
3349 }
3350 }
3351 }
3353 // Record if we need to clear floats before reflowing the next
3354 // line. Note that inlineFloatClearType will be handled and
3355 // cleared before the next line is processed, so there is no
3356 // need to combine break types here.
3359 }
3363 }
3369 // Another option here might be to leave |line| clean if
3370 // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
3371 // that case the line really did reflow as it should have. Not sure
3372 // whether that would be safe, so doing this for now instead. Also not
3373 // sure whether we really want to mark all lines dirty after an
3374 // interrupt, but until we get better at propagating float damage we
3375 // really do need to do it this way; see comments inside MarkLineDirty.
3377 }
3378 }
3380 // Handle BR-clearance from the last line of the block
3384 }
3387 // Is this expensive?
3390 // Update aState.mPrevChild as if we had reflowed all of the frames in
3391 // the last line.
3397 }
3399 // Should we really have to do this?
3402 }
3404 // We can skip trying to pull up the next line if our height is constrained
3405 // (so we can report being incomplete) and there is no next in flow or we
3406 // were told not to or we know it will be futile, i.e.,
3407 // -- the next in flow is not changing
3408 // -- and we cannot have added more space for its first line to be
3409 // pulled up into,
3410 // -- it's an incremental reflow of a descendant
3411 // -- and we didn't reflow any floats (so the available space
3412 // didn't change)
3413 // -- my chain of next-in-flows either has no first line, or its first
3414 // line isn't dirty.
3421 // We'll place lineIter at the last line of this block, so that
3422 // nsBlockInFlowLineIterator::Next() will take us to the first
3423 // line of my next-in-flow-chain. (But first, check that I
3424 // have any lines -- if I don't, just bail out of this
3425 // optimization.)
3431 // Check for next-in-flow-chain's first line.
3432 // (First, see if there is such a line, and second, see if it's clean)
3435 }
3436 }
3437 }
3445 }
3446 }
3449 // Pull data from a next-in-flow if there's still room for more
3450 // content here.
3452 // Grab first line from our next-in-flow
3455 nsFrameList pulledFrames;
3461 // Grab an overflow line if there are any
3467 }
3473 }
3474 }
3477 // The line is empty. Try the next one.
3483 }
3488 }
3491 }
3492 }
3503 // Shift pulledLine's frames into our mFrames list.
3506 // Add line to our line list, and set its last child as our new prev-child
3510 // Reparent floats whose placeholders are in the line.
3514 #ifdef DEBUG
3516 #endif
3521 // Now reflow it and any lines that it makes during it's reflow
3522 // (we have to loop here because reflowing the line may cause a new
3523 // line to be created; see SplitLine's callers for examples of
3524 // when this happens).
3533 }
3539 }
3541 }
3545 }
3550 }
3552 // If this is an inline frame then its time to stop
3555 }
3556 }
3557 }
3562 }
3564 // Handle an odd-ball case: a list-item with no lines
3576 // There are no lines so we have to fake up some y motion so that
3577 // we end up with *some* height.
3578 // (Note: if we're layout-contained, we have to be sure to leave our
3579 // ReflowOutput's BlockStartAscent() (i.e. the baseline) untouched,
3580 // because layout-contained frames have no baseline.)
3583 nscoord ascent;
3589 }
3590 }
3606 }
3607 }
3608 }
3612 }
3618 }
3620 #ifdef DEBUG
3628 }
3629 #endif
3632 }
3637 // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
3638 // marked the lines that need to be marked dirty based on our
3639 // vertical resize stuff. So we'll definitely reflow all those kids;
3640 // the only question is how they should behave.
3642 // Mark all our child frames dirty so we make sure to reflow them
3643 // later.
3648 }
3649 // And mark all the floats whose reflows we might be skipping dirty too.
3653 }
3654 }
3656 // Dirty all the descendant lines of block kids to handle float damage,
3657 // since our nsFloatManager will go away by the next time we're reflowing.
3658 // XXXbz Can we do something more like what PropagateFloatDamage does?
3659 // Would need to sort out the exact business with mBlockDelta for that....
3660 // This marks way too much dirty. If we ever make this better, revisit
3661 // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
3665 }
3666 }
3667 }
3675 "using function more generally than designed, "
3681 // Mark the previous margin of the next line dirty since we need to
3682 // recompute its top position.
3685 }
3686 }
3687 }
3689 /**
3690 * Reflow a line. The line will either contain a single block frame
3691 * or contain 1 or more inline frames. aKeepReflowGoing indicates
3692 * whether or not the caller should continue to reflow more lines.
3693 * Returns true if the reflow used an overflow-wrap breakpoint.
3694 */
3699 // Setup the line-layout for the new line
3705 // If this line contains a single block that is hidden by `content-visibility`
3706 // don't reflow the line. If this line contains inlines and the first one is
3707 // hidden by `content-visibility`, all of them are, so avoid reflow in that
3708 // case as well.
3709 // For frames that own anonymous children, even the first child is hidden by
3710 // `content-visibility`, there could be some anonymous children need reflow,
3711 // so we don't skip reflow this line.
3716 }
3718 // Now that we know what kind of line we have, reflow it
3726 // Store the line's float edges for overflow marker analysis if needed.
3738 // This line is overlapping a float - store the edges marking the area
3739 // between the floats for text-overflow analysis.
3741 }
3742 }
3743 }
3744 }
3749 }
3752 LineIterator aLine) {
3753 // First check our remaining lines.
3756 }
3762 // Try each next-in-flow.
3767 }
3770 }
3773 }
3776 }
3792 // If our line is not empty and the child in aFromLine is a block
3793 // then we cannot pull up the frame into this line. In this case
3794 // we stop pulling.
3796 }
3797 // Take frame from fromLine
3802 // The frame is being pulled from a next-in-flow; therefore we need to add
3803 // it to our sibling list.
3809 // When pushing and pulling frames we need to check for whether any
3810 // views need to be reparented.
3814 // The frame might have (or contain) floats that need to be brought
3815 // over too. (pass 'false' since there are no siblings to check)
3819 }
3825 // Mark line dirty now that we pulled a child
3829 // Free up the fromLine now that it's empty.
3830 // Its bounds might need to be redrawn, though.
3833 }
3835 // aFromLine is now invalid
3837 }
3839 #ifdef DEBUG
3842 #endif
3845 }
3848 nscoord aDeltaBCoord) {
3851 // Adjust line state
3854 // Adjust the frames in the line
3856 }
3862 }
3864 // Adjust line state
3867 // Changing container width only matters if writing mode is vertical-rl
3870 }
3871 }
3874 nscoord aDeltaBCoord) {
3875 // Adjust the frames in the line
3879 }
3887 }
3889 // Make sure the frame's view and any child views are updated
3892 // Adjust the block-dir coordinate of the frames in the line.
3893 // Note: we need to re-position views even if aDeltaBCoord is 0, because
3894 // one of our parent frames may have moved and so the view's position
3895 // relative to its parent may have changed.
3900 }
3901 // Make sure the frame's view and any child views are updated
3904 }
3905 }
3906 }
3909 // The "extremum length" values (see ExtremumLength) were originally aimed at
3910 // inline-size (or width, as it was before logicalization). For now, let them
3911 // return false here, so we treat them like 'auto' pending a real
3912 // implementation. (See bug 1126420.)
3913 //
3914 // FIXME (bug 567039, bug 527285) This isn't correct for the 'fill' value,
3915 // which should more likely (but not necessarily, depending on the available
3916 // space) be returning true.
3919 }
3921 // If we evaluate the length/percent/calc at a percentage basis of
3922 // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
3923 // length, percent, or combination thereof. Test > 0 so we clamp
3924 // negative calc() results to 0.
3927 }
3929 /* virtual */
3933 }
3935 // Blocks which are margin-roots (including inline-blocks) cannot be treated
3936 // as empty for margin-collapsing and other purposes. They're more like
3937 // replaced elements.
3940 }
3948 }
3950 // FIXME: Bug 1646100 - Take intrinsic size into account.
3951 // FIXME: Handle the case that both inline and block sizes are auto.
3952 // https://github.com/w3c/csswg-drafts/issues/5060.
3953 // Note: block-size could be zero or auto/intrinsic keywords here.
3957 }
3968 }
3972 }
3975 }
3980 }
3984 }
3985 }
3987 }
3992 }
3995 }
4000 // A page break frame consumes margins adjacent to it.
4001 // https://drafts.csswg.org/css-break/#break-margins
4003 }
4006 // Apply short-circuit check to avoid searching the line list
4008 }
4011 // If we aren't at the start block-coordinate then something of non-zero
4012 // height must have been placed. Therefore the childs block-start margin
4013 // applies.
4016 }
4018 // Determine if this line is "essentially" the first line
4022 }
4025 // A line which precedes aLine is non-empty, or has clearance,
4026 // so therefore the block-start margin applies.
4029 }
4030 // No need to apply the block-start margin if the line has floats. We
4031 // should collapse anyway (bug 44419)
4035 }
4037 // The line being reflowed is "essentially" the first line in the
4038 // block. Therefore its block-start margin will be collapsed by the
4039 // generational collapsing logic with its parent (us).
4041 }
4044 LineIterator aLine,
4052 }
4054 // If the previous frame was a page-break-frame, then preemptively push this
4055 // frame to the next page.
4056 // This is primarily important for the placeholders for abspos frames, which
4057 // measure as zero height and then would be placed on this page.
4063 }
4064 }
4066 // Prepare the block reflow engine
4074 }
4076 // Clear past floats before the block if the clear style is not none
4080 }
4082 // See if we should apply the block-start margin. If the block frame being
4083 // reflowed is a continuation, then we don't apply its block-start margin
4084 // because it's not significant. Otherwise, dig deeper.
4088 // The HasClearance setting is only valid if ShouldApplyBStartMargin
4089 // returned false (in which case the block-start margin-root set our
4090 // clearance flag). Otherwise clear it now. We'll set it later on
4091 // ourselves if necessary.
4093 }
4101 }
4103 // If our block-start margin was counted as part of some parent's block-start
4104 // margin collapse, and we are being speculatively reflowed assuming this
4105 // frame DID NOT need clearance, then we need to check that
4106 // assumption.
4115 // Only record the first frame that requires clearance
4118 }
4120 // Exactly what we do now is flexible since we'll definitely be
4121 // reflowed.
4123 }
4124 }
4127 }
4132 nscoord clearance;
4133 // Save the original position of the frame so that we can reposition
4134 // its view as needed.
4143 // Precompute the blocks block-start margin value so that we can get the
4144 // correct available space (there might be a float that's
4145 // already been placed below the aState.mPrevBEndMargin
4147 // Setup a reflowInput to get the style computed block-start margin
4148 // value. We'll use a reason of `resize' so that we don't fudge
4149 // any incremental reflow input.
4151 // The availSpace here is irrelevant to our needs - all we want
4152 // out if this setup is the block-start margin value which doesn't depend
4153 // on the childs available space.
4154 // XXX building a complete ReflowInput just to get the block-start
4155 // margin seems like a waste. And we do this for almost every block!
4159 availSpace);
4164 }
4166 // Now compute the collapsed margin-block-start value into
4167 // aState.mPrevBEndMargin, assuming that all child margins
4168 // collapse down to clearanceFrame.
4172 // XXX optimization; we could check the collapsing children to see if they
4173 // are sure to require clearance, and so avoid retrying them
4176 // Don't allow retries on the second pass. The clearance decisions for
4177 // the blocks whose block-start margins collapse with ours are now
4178 // fixed.
4180 }
4183 // We don't know if we need clearance and this is the first,
4184 // optimistic pass. So determine whether *this block* needs
4185 // clearance. Note that we do not allow the decision for whether
4186 // this block has clearance to change on the second pass; that
4187 // decision is only allowed to be made under the optimistic
4188 // first pass.
4195 // Looks like we need clearance and we didn't know about it already.
4196 // So recompute collapsed margin
4198 // Remember this decision, needed for incremental reflow
4201 // Apply incoming margins
4205 // Compute the collapsed margin again, ignoring the incoming margin
4206 // this time
4210 }
4211 }
4213 // Temporarily advance the running block-direction value so that the
4214 // GetFloatAvailableSpace method will return the right available space.
4215 // This undone as soon as the horizontal margins are computed.
4220 // advance mBCoord to the clear position.
4226 clearedPushedOrSplitFloat =
4229 // Compute clearance. It's the amount we need to add to the block-start
4230 // border-edge of the frame, after applying collapsed margins
4231 // from the frame and its children, to get it to line up with
4232 // the block-end of the floats. The former is
4233 // currentBCoord + bStartMargin, the latter is the current
4234 // aState.mBCoord.
4235 // Note that negative clearance is possible
4238 // Add clearance to our block-start margin while we compute available
4239 // space for the frame
4242 // Note that aState.mBCoord should stay where it is: at the block-start
4243 // border-edge of the frame
4245 // Advance aState.mBCoord to the block-start border-edge of the frame.
4247 }
4248 }
4252 // Here aState.mBCoord is the block-start border-edge of the block.
4253 // Compute the available space for the block
4259 // The check for
4260 // (!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats)
4261 // is to some degree out of paranoia: if we reliably eat up block-start
4262 // margins at the top of the page as we ought to, it wouldn't be
4263 // needed.
4266 // We know already that this child block won't fit on this
4267 // page/column due to the block-start margin or the clearance. So we
4268 // need to get out of here now. (If we don't, most blocks will handle
4269 // things fine, and report break-before, but zero-height blocks
4270 // won't, and will thus make their parent overly-large and force
4271 // *it* to be pushed in its entirety.)
4278 }
4280 }
4282 // Now put the block-dir coordinate back to the start of the
4283 // block-start-margin + clearance.
4288 }
4290 // Construct the reflow input for the block.
4296 // Calculate the multicol containing block's block size so that the
4297 // children with percentage block size get correct percentage basis.
4303 // Use column-width as the containing block's inline-size, i.e. the column
4304 // content's computed inline-size.
4309 // If a ColumnSetWrapper is in a balancing column content, it may be
4310 // pushed or pulled back and forth between column contents. Always add
4311 // NS_FRAME_HAS_DIRTY_CHILDREN bit to it so that its ColumnSet children
4312 // can have a chance to reflow under current block size constraint.
4316 }
4318 // If we are reflowing our ColumnSet children, we want to apply our block
4319 // size constraint to the available block size when constructing reflow
4320 // input for ColumnSet so that ColumnSet can use it to compute its max
4321 // column block size.
4325 contentBSize =
4327 }
4329 // To get the remaining content block-size, subtract the content
4330 // block-size consumed by our previous continuations.
4333 // ColumnSet is not the outermost frame in the column container, so it
4334 // cannot have any margin. We don't need to consider any margin that
4335 // can be generated by "box-decoration-break: clone" as we do in
4336 // BlockReflowState::ComputeBlockAvailSpace().
4342 }
4343 }
4344 }
4345 }
4349 cbSize);
4352 columnSetWrapperHasNoBSizeLeft;
4355 // We only need to set this the first reflow, since if we reflow
4356 // again (and replace childReflowInput) we'll be reflowing it
4357 // again in the same fragment as the previous time.
4359 }
4362 nsReflowStatus frameReflowStatus;
4365 // Set if floatAvailableSpace.HasFloats() is true for any
4366 // iteration of the loop.
4368 }
4370 // We might need to store into mDiscoveredClearance later if it's
4371 // currently null; we want to overwrite any writes that
4372 // brc.ReflowBlock() below does, so we need to remember now
4373 // whether it's empty.
4378 // Reflow the block into the available space
4381 }
4388 }
4396 // No need to retry this loop if there is a break opportunity before the
4397 // child block.
4399 }
4401 // Now the block has a height. Using that height, get the
4402 // available space again and call ComputeBlockAvailSpace again.
4403 // If ComputeBlockAvailSpace gives a different result, we need to
4404 // reflow again.
4407 }
4416 // Restore the height to the position of the next band.
4419 // Determine whether the available space shrunk on either side,
4420 // because (the first time round) we now know the block's height,
4421 // and it may intersect additional floats, or (on later
4422 // iterations) because narrowing the width relative to the
4423 // previous time may cause the block to become taller. Note that
4424 // since we're reflowing the block, narrowing the width might also
4425 // make it shorter, so we must pass aCanGrow as true.
4428 // The size and position we chose before are fine (i.e., they
4429 // don't cause intersecting with floats that requires a change
4430 // in size or position), so we're done.
4432 }
4436 floatAvailableSpace)) {
4437 // Advance to the next band.
4441 }
4442 // ClearFloats might be able to advance us further once we're there.
4446 // Start over with a new available space rect at the new height.
4449 }
4457 }
4459 // We need another reflow.
4464 // We set shouldStoreClearance above to record only the first
4465 // frame that requires clearance.
4468 }
4470 // Exactly what we do now is flexible since we'll definitely be
4471 // reflowed.
4473 }
4476 // We're pushing down the border-box, so we don't apply margin anymore.
4477 // This should never cause us to move up since the call to
4478 // GetFloatAvailableSpaceForBSize above included the margin.
4483 }
4492 // Found a clearance frame, so we need to reflow |frame| a second time.
4493 // Restore the states and start over again.
4498 }
4503 // If an ancestor of ours is going to reflow for clearance, we
4504 // need to avoid calling PlaceBlock, because it unsets dirty bits
4505 // on the child block (both itself, and through its call to
4506 // nsIFrame::DidReflow), and those dirty bits imply dirtiness for
4507 // all of the child block, including the lines it didn't reflow.
4511 }
4513 #if defined(REFLOW_STATUS_COVERAGE)
4515 #endif
4518 // None of the child block fits.
4523 }
4525 // Note: line-break-after a block is a nop
4527 // Try to place the child block.
4528 // Don't force the block to fit if we have positive clearance, because
4529 // pushing it to the next page would give it more room.
4530 // Don't force the block to fit if it's impacted by a float. If it is,
4531 // then pushing it to the next page would give it more room. Note that
4532 // isImpacted doesn't include impact from the block's own floats.
4535 CollapsingMargin collapsedBEndMargin;
4536 OverflowAreas overflowAreas;
4544 }
4551 }
4552 }
4556 // Some of the child block fit
4558 // Advance to new Y position
4562 // Continue the block frame now if it didn't completely fit in
4563 // the available space.
4572 // If nextFrame used to be an overflow container, make it a normal
4573 // block
4582 }
4587 }
4589 // Push continuation to a new line, but only if we actually made
4590 // one.
4594 }
4598 // If we need to reflow the continuation of the block child,
4599 // then we'd better reflow our continuation
4602 // We also need to make that continuation's line dirty so
4603 // it gets reflowed when we reflow our next in flow. The
4604 // nif's line must always be either a line of the nif's
4605 // parent block (only if we didn't make a continuation) or
4606 // else one of our own overflow lines. In the latter case
4607 // the line is already marked dirty, so just handle the
4608 // first case.
4612 nifBlock,
4618 }
4619 }
4620 }
4621 }
4623 // The block-end margin for a block is only applied on the last
4624 // flow block. Since we just continued the child block frame,
4625 // we know that line->mFirstChild is not the last flow block
4626 // therefore zero out the running margin value.
4627 #ifdef NOISY_BLOCK_DIR_MARGINS
4633 #endif
4636 // Disconnect the next-in-flow and put it in our overflow tracker
4639 // It already exists, but as a normal next-in-flow, so we need
4640 // to dig it out of the child lists.
4644 }
4646 // Put it in our overflow list
4650 #ifdef NOISY_BLOCK_DIR_MARGINS
4656 #endif
4658 }
4660 #ifdef NOISY_BLOCK_DIR_MARGINS
4666 #endif
4668 }
4669 #ifdef NOISY_BLOCK_DIR_MARGINS
4676 #endif
4679 // The frame reported an incomplete status, but then it also didn't
4680 // fit. This means we need to reflow it again so that it can
4681 // (again) report the incomplete status.
4683 }
4687 // If it's our very first line *or* we're not at the top of the page
4688 // and we have page-break-inside:avoid, then we need to be pushed to
4689 // our parent's next-in-flow.
4692 // Push the line that didn't fit and any lines that follow it
4693 // to our next-in-flow.
4695 }
4696 }
4697 }
4699 }
4701 // Now that we've got its final position all figured out, position any child
4702 // views it may have. Note that the case when frame has a view got handled
4703 // by FinishReflowChild, but that function didn't have the coordinates needed
4704 // to correctly decide whether to reposition child views.
4707 }
4709 #ifdef DEBUG
4711 #endif
4712 }
4714 // Returns true if an overflow-wrap break was used.
4716 LineIterator aLine,
4723 // Setup initial coordinate system for reflowing the inline frames
4724 // into. Apply a previous block frame's block-end margin first.
4727 }
4730 LineReflowStatus lineReflowStatus;
4743 // Once upon a time we allocated the first 30 nsLineLayout objects
4744 // on the stack, and then we switched to the heap. At that time
4745 // these objects were large (1100 bytes on a 32 bit system).
4746 // Then the nsLineLayout object was shrunk to 156 bytes by
4747 // removing some internal buffers. Given that it is so much
4748 // smaller, the complexity of 2 different ways of allocating
4749 // no longer makes sense. Now we always allocate on the stack.
4755 }
4767 // If there is no saved break position, then this will set
4768 // set forceBreakInFrame to null and we won't back up, which is
4769 // correct.
4774 }
4775 // restore the float manager state
4777 // Clear out float lists
4781 }
4783 // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
4790 }
4793 LineIterator aLine,
4796 // Reflow the line again when we reflow at our new position.
4799 }
4803 ComputeNewPageNameIfNeeded aComputeNewPageName) {
4808 // mCanHaveClassABreakpoints can only be true during paginated reflow, and
4809 // we expect this function to only be called when the available bsize is
4810 // constrained.
4818 }
4819 }
4821 }
4828 // Forget all of the floats on the line
4832 // We need to set this flag on the line if any of our reflow passes
4833 // are impacted by floats.
4836 }
4837 #ifdef REALLY_NOISY_REFLOW
4840 #endif
4849 nscoord availBSize;
4853 /* XXX get the height right! */
4855 }
4857 // Make sure to enable resize optimization before we call BeginLineReflow
4858 // because it might get disabled there
4868 // XXX Unfortunately we need to know this before reflowing the first
4869 // inline frame in the line. FIX ME.
4872 NS_BLOCK_HAS_FIRST_LETTER_STYLE)) {
4874 }
4879 // Reflow the frames that are already on the line first
4885 // There is a soft break opportunity at the start of the line, because
4886 // we can always move this line down below float(s).
4890 }
4891 }
4893 // need to repeatedly call GetChildCount here, because the child
4894 // count can change during the loop!
4901 // It is possible that one or more of next lines are empty
4902 // (because of DeleteNextInFlowChild). If so, delete them now
4903 // in case we are finished.
4906 // XXX Is this still necessary now that DeleteNextInFlowChild
4907 // uses DoRemoveFrame?
4913 }
4917 "ReflowInlineFrame should never determine that a line "
4919 }
4920 }
4922 // Don't pull up new frames into lines with continuation placeholders
4924 // Pull frames and reflow them until we can't
4929 }
4936 // We just created a continuation for aFrame AND its going
4937 // to end up on this line (e.g. :first-letter
4938 // situation). Therefore we have to loop here before trying
4939 // to pull another frame.
4943 }
4944 }
4945 }
4946 }
4951 // We only need to backup if the line isn't going to be reflowed again anyway
4957 "We shouldn't be backing up more than once! "
4958 "Someone must have set a break opportunity beyond the available width, "
4961 }
4963 // We need to try backing up to before a text run
4964 // XXX It's possible, in fact not unusual, for the break opportunity to
4965 // already be the end of the line. We should detect that and optimize to not
4966 // re-do the line.
4968 // We can back up!
4970 }
4972 // In case we reflow this line again, remember that we don't
4973 // need to force any breaking
4975 }
4978 // This happens only when we have a line that is impacted by
4979 // floats and the first element in the line doesn't fit with
4980 // the floats.
4981 //
4982 // If there's block space available, we either try to reflow the line
4983 // past the current band (if it's non-zero and the band definitely won't
4984 // widen around a shape-outside), otherwise we try one pixel down. If
4985 // there's no block space available, we push the line to the next
4986 // page/column.
4991 // See the analogous code for blocks in BlockReflowState::ClearFloats.
4997 // We should never hit this case if we've placed floats on the
4998 // line; if we have, then the GetFloatAvailableSpace call is wrong
4999 // and needs to happen after the caller pops the float manager
5000 // state.
5004 // Move it down far enough to clear the current band.
5007 // Move it down by one dev pixel.
5009 }
5013 // There's nowhere to retry placing the line, so we want to push
5014 // it to the next page/column where its contents can fit not
5015 // next to a float.
5018 }
5020 // XXX: a small optimization can be done here when paginating:
5021 // if the new Y coordinate is past the end of the block then
5022 // push the line and return now instead of later on after we are
5023 // past the float.
5026 // If we are propagating out a break-before status then there is
5027 // no point in placing the line.
5031 aKeepReflowGoing)) {
5033 // PlaceLine already called GetFloatAvailableSpaceForBSize or its
5034 // variant for us.
5035 }
5036 }
5037 }
5038 #ifdef DEBUG
5042 }
5043 #endif
5046 // aLine may have been pushed to the overflow lines.
5048 // We can't just compare iterators front() to aLine here, since they may be
5049 // in different lists.
5053 // aLine is stale, it's associated with the main line list but it should
5054 // be associated with the overflow line list now
5056 }
5062 }
5063 }
5064 }
5067 }
5069 /**
5070 * Reflow an inline frame. The reflow status is mapped from the frames
5071 * reflow status to the lines reflow status (not to our reflow status).
5072 * The line reflow status is simple: true means keep placing frames
5073 * on the line; false means don't (the line is done). If the line
5074 * has some sort of breaking affect then aLine's break-type will be set
5075 * to something other than StyleClear::None.
5076 */
5084 #ifdef NOISY_FIRST_LETTER
5090 #endif
5095 }
5097 // Reflow the inline frame
5098 nsReflowStatus frameReflowStatus;
5104 }
5106 #ifdef REALLY_NOISY_REFLOW
5109 #endif
5111 #if defined(REFLOW_STATUS_COVERAGE)
5113 #endif
5115 // Send post-reflow notification
5118 /* XXX
5119 This is where we need to add logic to handle some odd behavior.
5120 For one thing, we should usually place at least one thing next
5121 to a left float, even when that float takes up all the width on a line.
5122 see bug 22496
5123 */
5125 // Process the child frames reflow status. There are 5 cases:
5126 // complete, not-complete, break-before, break-after-complete,
5127 // break-after-not-complete. There are two situations: we are a
5128 // block or we are an inline. This makes a total of 10 cases
5129 // (fortunately, there is some overlap).
5133 // Always abort the line reflow (because a line break is the
5134 // minimal amount of break we do).
5137 // XXX what should aLine's break-type be set to in all these cases?
5139 // Break-before cases.
5141 // If we break before the first frame on the line then we must
5142 // be trying to place content where there's no room (e.g. on a
5143 // line with wide floats). Inform the caller to reflow the
5144 // line after skipping past a float.
5147 // It's not the first child on this line so go ahead and split
5148 // the line. We will see the frame again on the next-line.
5151 // If we're splitting the line because the frame didn't fit and it
5152 // was pushed, then mark the line as having word wrapped. We need to
5153 // know that if we're shrink wrapping our width
5156 }
5157 }
5163 // If a float split and its prev-in-flow was followed by a <BR>, then
5164 // combine the <BR>'s float clear type with the inline's float clear type
5165 // (the inline will be the very next frame after the split float).
5171 }
5172 // Break-after cases
5175 }
5177 // Split line, but after the frame just reflowed
5179 aLineReflowStatus);
5184 }
5185 }
5186 }
5187 }
5190 // Create a continuation for the incomplete frame. Note that the
5191 // frame may already have a continuation.
5194 // Remember that the line has wrapped
5197 }
5199 // If we just ended a first-letter frame or reflowed a placeholder then
5200 // don't split the line and don't stop the line reflow...
5201 // But if we are going to stop anyways we'd better split the line.
5205 // Split line after the current frame
5208 aLineReflowStatus);
5209 }
5210 }
5211 }
5218 newFrame =
5225 }
5226 }
5227 #ifdef DEBUG
5229 #endif
5231 }
5245 }
5248 }
5250 nextInFlow =
5252 }
5255 }
5263 }
5271 }
5272 }
5278 }
5287 }
5288 }
5291 }
5303 #ifdef DEBUG
5312 }
5316 }
5317 }
5318 #endif
5323 #ifdef DEBUG
5324 {
5330 }
5332 }
5333 #endif
5335 // Put frames being split out into their own line
5338 #ifdef DEBUG
5341 }
5342 #endif
5344 // Let line layout know that some frames are no longer part of its
5345 // state.
5348 // If floats have been placed whose placeholders have been pushed to the new
5349 // line, we need to reflow the old line again. We don't want to look at the
5350 // frames in the new line, because as a large paragraph is laid out the
5351 // we'd get O(N^2) performance. So instead we just check that the last
5352 // float and the last below-current-line float are still in aLine.
5360 }
5362 #ifdef DEBUG
5364 #endif
5365 }
5366 }
5370 // There is another line
5372 // If the next line is a block line then this line is the last in a
5373 // group of inline lines.
5375 }
5376 // The next line is empty, try the next one
5377 }
5379 // Try our next-in-flows lines to answer the question
5385 }
5386 }
5388 }
5390 // This is the last line - so don't allow justification
5392 }
5400 // Try to position the floats in a nowrap context.
5403 // Trim extra white-space from the line before placing the frames
5406 // Vertically align the frames on this line.
5407 //
5408 // According to the CSS2 spec, section 12.6.1, the "marker" box
5409 // participates in the height calculation of the list-item box's
5410 // first line box.
5411 //
5412 // There are exactly two places a ::marker can be placed: near the
5413 // first or second line. It's only placed on the second line in a
5414 // rare case: when the first line is empty.
5429 }
5432 // We want to consider the floats in the current line when determining
5433 // whether the float available space is shrunk. If mLineBSize doesn't
5434 // exist, we are in the first pass trying to place the line. Calling
5435 // GetFloatAvailableSpace() like we did in BlockReflowState::AddFloat()
5436 // for UpdateBand().
5438 // floatAvailableSpaceWithOldLineBSize is the float available space with
5439 // the old BSize, but including the floats that were added in this line.
5440 LogicalRect floatAvailableSpaceWithOldLineBSize =
5443 : aState
5448 // As we redo for floats, we can't reduce the amount of BSize we're
5449 // checking.
5451 LogicalRect floatAvailableSpaceWithLineBSize =
5452 aState
5457 // If the available space between the floats is smaller now that we
5458 // know the BSize, return false (and cause another pass with
5459 // LineReflowStatus::RedoMoreFloats). We ensure aAvailableSpaceBSize
5460 // never decreases, which means that we can't reduce the set of floats
5461 // we intersect, which means that the available space cannot grow.
5464 // Prepare data for redoing the line.
5467 // Since we want to redo the line, we update aFlowArea by using the
5468 // aFloatStateBeforeLine, which is the float manager's state before the
5469 // line is placed.
5477 // Restore the BSize to the position of the next band.
5480 // Enforce both IStart() and IEnd() never move outwards to prevent
5481 // infinite grow-shrink loops.
5489 }
5492 }
5495 }
5497 #ifdef DEBUG
5507 }
5510 }
5511 }
5512 #endif
5514 // Only block frames horizontally align their children because
5515 // inline frames "shrink-wrap" around their children (therefore
5516 // there is no extra horizontal space).
5519 /**
5520 * We don't care checking for IsLastLine properly if we don't care (if it
5521 * can't change the used text-align value for the line).
5522 *
5523 * In other words, isLastLine really means isLastLineAndWeCare.
5524 */
5532 // From here on, pfd->mBounds rectangles are incorrect because bidi
5533 // might have moved frames around!
5534 OverflowAreas overflowAreas;
5539 }
5541 // Inline lines do not have margins themselves; however they are
5542 // impacted by prior block margins. If this line ends up having some
5543 // height then we zero out the previous block-end margin value that was
5544 // already applied to the line's starting Y coordinate. Otherwise we
5545 // leave it be so that the previous blocks block-end margin can be
5546 // collapsed with a block that follows.
5547 nscoord newBCoord;
5550 // This line has some height. Therefore the application of the
5551 // previous-bottom-margin should stick.
5555 // Don't let the previous-bottom-margin value affect the newBCoord
5556 // coordinate (it was applied in ReflowInlineFrames speculatively)
5557 // since the line is empty.
5558 // We already called |ShouldApplyBStartMargin|, and if we applied it
5559 // then mShouldApplyBStartMargin is set.
5564 }
5571 }
5573 // See if the line fit (our first line always does).
5579 // All our content doesn't fit, start on the next page.
5582 // Push aLine and all of its children and anything else that
5583 // follows to our next-in-flow.
5585 }
5587 }
5589 // Note that any early return before this update of aState.mBCoord
5590 // must either (a) return false or (b) set aKeepReflowGoing to false.
5591 // Otherwise we'll keep reflowing later lines at an incorrect
5592 // position, and we might not come back and clean up the damage later.
5595 // Add the already placed current-line floats to the line
5598 // Any below current line floats to place?
5600 // Reflow the below-current-line floats, which places on the line's
5601 // float list.
5603 }
5605 // When a line has floats, factor them into the overflow areas computations.
5607 // Union the float overflow areas (stored in aState) and the value computed
5608 // by the line layout code.
5613 #ifdef NOISY_OVERFLOW_AREAS
5618 #endif
5619 }
5621 // Apply break-after clearing if necessary
5622 // This must stay in sync with |ReflowDirtyLines|.
5626 }
5628 }
5632 // NOTE: aLineBefore is always a normal line, not an overflow line.
5633 // The following expression will assert otherwise.
5638 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
5642 // Remove floats in the lines from floats list.
5643 nsFrameList floats;
5647 #ifdef DEBUG
5651 }
5652 #endif
5653 // Push the floats onto the front of the overflow out-of-flows list
5656 }
5658 // overflow lines can already exist in some cases, in particular,
5659 // when shrinkwrapping and we discover that the shrinkwap causes
5660 // the height of some child block to grow which creates additional
5661 // overflowing content. In such cases we must prepend the new
5662 // overflow to the existing overflow.
5665 // XXXldb use presshell arena!
5667 }
5677 }
5685 // this takes ownership but it won't delete it immediately so we
5686 // can keep using it.
5689 // Mark all the overflow lines dirty so that they get reflowed when
5690 // they are pulled up by our next-in-flow.
5694 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
5700 }
5707 }
5708 }
5709 }
5710 }
5712 #ifdef DEBUG
5714 #endif
5715 }
5717 // The overflowLines property is stored as a pointer to a line list,
5718 // which must be deleted. However, the following functions all maintain
5719 // the invariant that the property is never set if the list is empty.
5722 #ifdef DEBUG
5724 #endif
5726 // Steal the prev-in-flow's overflow lines and prepend them.
5733 // Make all the frames on the overflow line list mine.
5736 // Collect overflow containers from our OverflowContainers list that are
5737 // continuations from the frames we picked up from our prev-in-flow, then
5738 // prepend those to ExcessOverflowContainers to ensure the continuations
5739 // are ordered.
5741 nsFrameList ocContinuations;
5753 }
5755 }
5758 }
5759 }
5765 }
5766 }
5767 }
5769 // Make the overflow out-of-flow frames mine too.
5772 // In case we own any next-in-flows of any of the drained frames, then
5773 // move those to the PushedFloat list.
5774 nsFrameList pushedFloats;
5781 }
5782 }
5788 }
5789 }
5792 // Remember to recompute the margins on the first line. This will
5793 // also recompute the correct deltaBCoord if necessary.
5795 }
5796 // The overflow lines have already been marked dirty and their previous
5797 // margins marked dirty also.
5799 // Prepend the overflow frames/lines to our principal list.
5805 }
5806 }
5808 // Now append our own overflow lines.
5810 }
5816 }
5818 // No need to reparent frames in our own overflow lines/oofs, because they're
5819 // already ours. But we should put overflow floats back in our floats list.
5820 // (explicit scope to remove the OOF list before VerifyOverflowSituation)
5821 {
5824 #ifdef DEBUG
5828 }
5829 #endif
5830 // The overflow floats go after our regular floats.
5832 }
5833 }
5837 }
5839 #ifdef DEBUG
5841 #endif
5843 }
5845 /**
5846 * Pushed floats are floats whose placeholders are in a previous
5847 * continuation. They might themselves be next-continuations of a float
5848 * that partially fit in an earlier continuation, or they might be the
5849 * first continuation of a float that couldn't be placed at all.
5850 *
5851 * Pushed floats live permanently at the beginning of a block's float
5852 * list, where they must live *before* any floats whose placeholders are
5853 * in that block.
5854 *
5855 * Temporarily, during reflow, they also live on the pushed floats list,
5856 * which only holds them between (a) when one continuation pushes them to
5857 * its pushed floats list because they don't fit and (b) when the next
5858 * continuation pulls them onto the beginning of its float list.
5859 *
5860 * DrainPushedFloats sets up pushed floats the way we need them at the
5861 * start of reflow; they are then reflowed by ReflowPushedFloats (which
5862 * might push some of them on). Floats with placeholders in this block
5863 * are reflowed by (BlockReflowState/nsLineLayout)::AddFloat, which
5864 * also maintains these invariants.
5865 *
5866 * DrainSelfPushedFloats moves any pushed floats from this block's own
5867 * pushed floats list back into floats list. DrainPushedFloats additionally
5868 * moves frames from its prev-in-flow's pushed floats list into floats list.
5869 */
5871 // If we're getting reflowed multiple times without our
5872 // next-continuation being reflowed, we might need to pull back floats
5873 // that we just put in the list to be pushed to our next-in-flow.
5874 // We don't want to pull back any next-in-flows of floats on our own
5875 // float list, and we only need to pull back first-in-flows whose
5876 // placeholders were in earlier blocks (since first-in-flows whose
5877 // placeholders are in this block will get pulled appropriately by
5878 // AddFloat, and will then be more likely to be in the correct order).
5884 // When we pull back floats, we want to put them with the pushed
5885 // floats, which must live at the start of our float list, but we
5886 // want them at the end of those pushed floats.
5887 // FIXME: This isn't quite right! What if they're all pushed floats?
5893 }
5903 // This is a first continuation that was pushed from one of our
5904 // previous continuations. Take it out of the pushed floats
5905 // list and put it in our floats list, before any of our
5906 // floats, but after other pushed floats.
5910 }
5912 }
5915 }
5919 }
5920 }
5921 }
5926 // After our prev-in-flow has completed reflow, it may have a pushed
5927 // floats list, containing floats that we need to own. Take these.
5933 }
5934 }
5935 }
5940 }
5949 }
5954 }
5964 }
5973 }
5975 // This takes ownership of aOverflowLines.
5976 // XXX We should allocate overflowLines from presShell arena!
5986 // Verify that we won't overwrite an existing overflow list
5990 }
5995 }
5999 }
6010 }
6024 }
6025 }
6030 }
6035 }
6040 }
6045 }
6050 }
6058 }
6063 }
6069 }
6075 }
6080 }
6085 }
6090 }
6098 }
6103 }
6109 }
6115 }
6122 }
6127 }
6132 }
6134 //////////////////////////////////////////////////////////////////////
6135 // Frame list manipulation routines
6140 }
6146 }
6149 }
6151 // Find the proper last-child for where the append should go
6157 #ifdef NOISY_REFLOW_REASON
6162 }
6166 }
6168 #endif
6173 // Workaround for bug 1399425 in case this bit has been removed from the
6174 // SVGTextFrame just before the parser adds more descendant nodes.
6176 }
6183 }
6184 }
6197 }
6200 }
6202 #ifdef NOISY_REFLOW_REASON
6207 }
6211 }
6213 #endif
6220 }
6221 }
6225 #ifdef NOISY_REFLOW_REASON
6230 #endif
6237 }
6239 // Make sure to mark affected lines dirty for the float frame
6240 // we are removing; this way is a bit messy, but so is the rest of the code.
6241 // See bug 390762.
6249 }
6252 // Skip the call to |FrameNeedsReflow| below by returning now.
6257 }
6262 }
6268 }
6269 // XXX the TEXT_OFFSETS_NEED_FIXING check is a wallpaper for bug 822910.
6273 }
6275 }
6279 // Clear our line cursor, since our lines may change.
6284 }
6286 // Attempt to find the line that contains the previous sibling
6300 // We need to find out which list it's actually in. Assume that
6301 // *if* we have overflow lines, that our primary lines aren't
6302 // huge, but our overflow lines might be.
6307 }
6309 }
6311 // By elimination, the line must be in our overflow lines.
6314 }
6315 }
6328 // XXX_perf This is technically O(N^2) in some cases, but by using
6329 // RFind instead of Find, we make it O(N) in the most common case,
6330 // which is appending content.
6332 // Find the line that contains the previous sibling
6336 // Not in mLines - try overflow lines.
6345 }
6350 // Note: defensive code! RFindLineContaining must not return
6351 // false in this case, so if it does...
6355 }
6356 }
6357 }
6358 }
6360 // Find the frame following aPrevSibling so that we can join up the
6361 // two lists of frames.
6363 // Split line containing aPrevSibling in two if the insertion
6364 // point is somewhere in the middle of the line.
6367 // Split the line in two where the frame(s) are being inserted.
6371 // Mark prevSibLine dirty and as needing textrun invalidation, since
6372 // we may be breaking up text in the line. Its previous line may also
6373 // need to be invalidated because it may be able to pull some text up.
6375 // The new line will also need its textruns recomputed because of the
6376 // frame changes.
6379 }
6383 }
6387 // Walk through the new frames being added and update the line data
6388 // structures to fit.
6399 // If the frame is a block frame, or if there is no previous line or if the
6400 // previous line is a block line we need to make a new line. We also make
6401 // a new line, as an optimization, in the two cases we know we'll need it:
6402 // if the previous line ended with a <br>, or if it has significant
6403 // whitespace and ended in a newline.
6406 // Create a new line for the frame and add its line to the line
6407 // list.
6410 // Append new line after prevSibLine
6414 // New line is going before the other lines
6417 }
6420 // We're adding inline content to prevSibLine, so we need to mark it
6421 // dirty, ensure its textruns are recomputed, and possibly do the same
6422 // to its previous line since that line may be able to pull content up.
6424 }
6427 }
6429 #ifdef DEBUG
6432 #endif
6433 }
6441 }
6443 }
6446 // 'display:block ruby' use the inner (Ruby) frame for insertions.
6449 }
6451 }
6457 }
6458 }
6461 // Find which line contains the float, so we can update
6462 // the float cache.
6466 }
6467 }
6468 }
6473 // Floats live in floats list, pushed floats list, or overflow out-of-flow
6474 // list.
6488 }
6490 }
6491 }
6500 }
6504 }
6506 }
6507 }
6509 {
6514 }
6515 }
6516 }
6520 // The containing block is always the parent of aFrame.
6523 // Remove aFrame from the appropriate list.
6525 // This also deletes the next-in-flows
6529 // First remove aFrame's next-in-flows.
6532 }
6533 // Now remove aFrame from its child list and Destroy it.
6537 }
6538 }
6540 /**
6541 * This helps us iterate over the list of all normal + overflow lines
6542 */
6550 // Try the overflow lines
6558 }
6559 }
6560 }
6561 }
6564 LineIterator aLine)
6566 // This will assert if aLine isn't in mLines of aFrame:
6568 }
6571 LineIterator aLine,
6583 }
6596 }
6597 }
6600 // paint/layout containment boxes and multi-column containers establish an
6601 // independent formatting context.
6602 // https://drafts.csswg.org/css-contain/#containment-paint
6603 // https://drafts.csswg.org/css-contain/#containment-layout
6604 // https://drafts.csswg.org/css-align/#distribution-block
6605 // https://drafts.csswg.org/css-multicol/#columns
6613 }
6618 }
6622 // A rendered legend always establishes a new formatting context, and so
6623 // does the fieldset content frame, so we can just return true here.
6624 // https://html.spec.whatwg.org/#rendered-legend
6626 }
6632 // If a box has a different writing-mode value than its containing block
6633 // [...] if the box is a block container, then it establishes a new block
6634 // formatting context.
6635 // https://drafts.csswg.org/css-writing-modes/#block-flow
6637 }
6638 }
6642 }
6646 }
6653 // An outside ::marker needs to be an independent formatting context
6654 // to avoid being influenced by the float manager etc.
6656 }
6657 }
6659 }
6665 }
6670 // If the frame contains floats, this update may change their float
6671 // manager. Be safe by dirtying all descendant lines of the nearest
6672 // ancestor's float manager.
6675 }
6677 }
6678 }
6684 }
6686 // Figure out what the right style parent is. This needs to match
6687 // nsCSSFrameConstructor::CreateLetterFrame.
6691 }
6698 parentStyle);
6699 // Note that we don't need to worry about changehints for the continuation
6700 // styles: those will be handled by the styleParent already.
6703 parentStyle);
6707 // We also want to update the style on the textframe inside the first-letter.
6708 // We don't need to compute a changehint for this, though, since any changes
6709 // to it are handled by the first-letter anyway.
6713 firstLetterStyle);
6716 // We don't need to update style for textFrame's continuations: it's already
6717 // set up to inherit from parentStyle, which is what we want.
6718 }
6730 }
6735 }
6738 }
6740 }
6743 }
6754 }
6760 // The block has a single line - that must be it!
6763 }
6765 // Try to use the cursor if it exists, otherwise fall back to the first line
6768 // Perform a simultaneous forward and reverse search starting from the
6769 // line cursor.
6773 // rline is positioned on the line containing 'cursor', so it's not
6774 // rline_end. So we can safely increment it (i.e. move it to one line
6775 // earlier) to start searching there.
6782 }
6784 }
6789 }
6791 }
6792 }
6797 }
6799 }
6805 }
6806 }
6807 }
6808 // Didn't find the line
6811 // If we reach here, it means that we have not been able to find the
6812 // desired frame in our in-flow lines. So we should start looking at
6813 // our overflow lines. In order to do that, we set mLine to the end
6814 // iterator so that FindValidLine starts to look at overflow lines,
6815 // if any.
6819 }
6825 }
6827 }
6831 }
6836 }
6841 }
6848 }
6857 }
6862 }
6870 }
6871 }
6873 }
6874 }
6880 }
6887 }
6892 }
6900 }
6901 }
6903 }
6904 }
6906 // This function removes aDeletedFrame and all its continuations. It
6907 // is optimized for deleting a whole series of frames. The easy
6908 // implementation would invoke itself recursively on
6909 // aDeletedFrame->GetNextContinuation, then locate the line containing
6910 // aDeletedFrame and remove aDeletedFrame from that line. But here we
6911 // start by locating aDeletedFrame and then scanning from that point
6912 // on looking for continuations.
6915 // We use the line cursor to attempt to optimize removal, but must ensure
6916 // it is cleared if lines change such that it may become invalid.
6919 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6925 // FIXME(emilio): aContext is lost here, maybe it's not a big deal?
6928 }
6930 }
6932 // Find the line that contains deletedFrame. Start from the line cursor
6933 // (if available) and search to the end of the normal line list, then
6934 // from the start to the line cursor, and last the overflow lines.
6944 }
6945 }
6947 // Setup for a shorter TryAllLines normal line search to avoid searching
6948 // the [cursor .. line_end] range again.
6951 }
6952 }
6957 // Make sure we look in the overflow lines even if the normal line
6958 // list is empty.
6964 }
6968 }
6970 // Restore line_end since we shortened the search to the cursor.
6972 // Clear our line cursors, since our normal line list may change.
6974 }
6975 }
6980 }
6989 }
6990 }
6999 }
7001 // If the frame being deleted is the last one on the line then
7002 // optimize away the line->Contains(next-in-flow) call below.
7007 next != line_end
7014 }
7016 // Remove aDeletedFrame from the line
7018 // We should be setting this to null if aDeletedFrame
7019 // is the only frame on the line. HOWEVER in that case
7020 // we will be removing the line anyway, see below.
7022 }
7024 // Hmm, this won't do anything if we're removing a frame in the first
7025 // overflow line... Hopefully doesn't matter
7028 // Since we just removed a frame that follows some inline
7029 // frames, we need to reflow the previous line.
7031 }
7034 // Take aDeletedFrame out of the sibling list. Note that
7035 // prevSibling will only be nullptr when we are deleting the very
7036 // first frame in the main or overflow list.
7041 }
7043 // Update the child count of the line to be accurate
7046 // Destroy frame; capture its next continuation first in case we need
7047 // to destroy that too.
7052 #ifdef NOISY_REMOVE_FRAME
7058 #endif
7060 // If next-in-flow is an overflow container, must remove it first.
7061 // FIXME: Can we do this unconditionally?
7063 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
7067 }
7073 // If line is empty, remove it now.
7075 #ifdef NOISY_REMOVE_FRAME
7078 #endif
7083 // Invalidate the space taken up by the line.
7084 // XXX We need to do this if we're removing a frame as a result of
7085 // a call to RemoveFrame(), but we may not need to do this in all
7086 // cases...
7087 #ifdef NOISY_BLOCK_INVALIDATE
7091 #endif
7097 // We just invalidated our iterators. Since we were in
7098 // the overflow lines list, which is now empty, set them
7099 // so we're at the end of the regular line list.
7103 }
7104 }
7107 // If we're removing a line, ReflowDirtyLines isn't going to
7108 // know that it needs to slide lines unless something is marked
7109 // dirty. So mark the previous margin of the next line dirty if
7110 // there is one.
7113 }
7116 // Make the line that just lost a frame dirty, and advance to
7117 // the next line.
7123 }
7124 }
7127 // See if we should keep looking in the current flow's line list.
7129 // The deceased frames continuation is not a child of the
7130 // current block. So break out of the loop so that we advance
7131 // to the next parent.
7132 //
7133 // If we have a continuation in a different block then all bets are
7134 // off regarding whether we are deleting frames without actual content,
7135 // so don't propagate FRAMES_ARE_EMPTY any further.
7138 }
7140 // If we advanced to the next line then check if we should switch to the
7141 // overflow line list.
7145 // We have advanced to the next *normal* line but the next-in-flow
7146 // is not there - force a switch to the overflow line list.
7148 }
7152 #ifdef NOISY_REMOVE_FRAME
7155 #endif
7156 }
7157 }
7158 }
7163 }
7165 #ifdef DEBUG
7168 #endif
7170 // Advance to next flow block if the frame has more continuations.
7173 }
7178 }
7190 }
7191 }
7193 }
7203 // Optimize by comparing the line's last child first.
7210 }
7211 }
7212 }
7214 }
7222 }
7230 }
7234 }
7252 }
7253 }
7254 }
7263 }
7268 // The line became empty - destroy it.
7273 }
7276 }
7277 }
7285 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
7287 aDeletingEmptyFrames);
7289 #ifdef DEBUG
7292 }
7293 #endif
7296 }
7297 }
7300 // Return the pointer to an unmodified style text
7302 }
7314 // Setup a block reflow context to reflow the float.
7319 CollapsingMargin margin;
7322 // Only first in flow gets a block-start margin.
7329 // We don't need to push the float manager state because the the block
7330 // has its own float manager that will be destroyed and recreated
7331 }
7332 }
7334 // When reflowing a float, aSpace argument doesn't matter because we pass
7335 // nullptr to aLine and we don't call nsBlockReflowContext::PlaceBlock()
7336 // later.
7342 // We never split floating first letters; an incomplete status for such
7343 // frames simply means that there is more content to be reflowed on the
7344 // line.
7347 }
7348 }
7352 "The status can only be incomplete or overflow-incomplete if "
7357 }
7361 // Set the rect, make sure the view is properly sized and positioned,
7362 // and tell the frame we're done reflowing it
7363 // XXXldb This seems like the wrong place to be doing this -- shouldn't
7364 // we be doing this in BlockReflowState::FlowAndPlaceFloat after
7365 // we've positioned the float, and shouldn't we be doing the equivalent
7366 // of |PlaceFrameView| here?
7373 }
7375 }
7383 }
7384 }
7386 }
7390 // Pushed floats live at the start of our float list; see comment
7391 // above nsBlockFrame::DrainPushedFloats.
7397 // When we push a first-continuation float in a non-initial reflow,
7398 // it's possible that we end up with two continuations with the same
7399 // parent. This happens if, on the previous reflow of the block or
7400 // a previous reflow of the line containing the block, the float was
7401 // split between continuations A and B of the parent, but on the
7402 // current reflow, none of the float can fit in A.
7403 //
7404 // When this happens, we might even have the two continuations
7405 // out-of-order due to the management of the pushed floats. In
7406 // particular, if the float's placeholder was in a pushed line that
7407 // we reflowed before it was pushed, and we split the float during
7408 // that reflow, we might have the continuation of the float before
7409 // the float itself. (In the general case, however, it's correct
7410 // for floats in the pushed floats list to come before floats
7411 // anchored in pushed lines; however, in this case it's wrong. We
7412 // should probably find a way to fix it somehow, since it leads to
7413 // incorrect layout in some cases.)
7414 //
7415 // When we have these out-of-order continuations, we might hit the
7416 // next-continuation before the previous-continuation. When that
7417 // happens, just push it. When we reflow the next continuation,
7418 // we'll either pull all of its content back and destroy it (by
7419 // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
7420 // pull it out of its current position and push it again (and
7421 // potentially repeat this cycle for the next continuation, although
7422 // hopefully then they'll be in the right order).
7423 //
7424 // We should also need this code for the in-order case if the first
7425 // continuation of a float gets moved across more than one
7426 // continuation of the containing block. In this case we'd manage
7427 // to push the second continuation without this check, but not the
7428 // third and later.
7435 }
7438 // The floats list becomes empty after removing |f|. Bail out.
7441 }
7442 // Even if we think |floats| is valid, AppendPushedFloatChain() can also
7443 // push |f|'s next-in-flows in our floats list to our pushed floats list.
7444 // If all the floats in the floats list are pushed, the floats list will
7445 // be deleted, and |floats| will be stale and poisoned. Therefore, we need
7446 // to get the floats list again to check its validity.
7451 }
7454 }
7456 // Always call FlowAndPlaceFloat; we might need to place this float if it
7457 // didn't belong to this block the last time it was reflowed. Note that if
7458 // the float doesn't get placed, we don't consider its overflow areas.
7459 // (Not-getting-placed means it didn't fit and we pushed it instead of
7460 // placing it, and its position could be stale.)
7464 }
7466 // If f is the only child in the floats list, pushing it to the pushed
7467 // floats list in FlowAndPlaceFloat() can result in the floats list being
7468 // deleted. Get the floats list again.
7473 }
7477 // We didn't push |f| so its next-sibling is next.
7482 }
7484 // If there are pushed or split floats, then we may need to continue BR
7485 // clearance
7491 }
7492 }
7493 }
7497 // Recover our own floats
7499 // belong to our next-in-flow
7507 }
7508 }
7510 // Recurse into our overflow container children
7515 }
7517 // Recurse into our normal children
7521 }
7522 }
7523 }
7527 WritingMode aWM,
7531 // Only blocks have floats
7533 // Don't recover any state inside a block that has its own float manager
7534 // (we don't currently have any blocks like this, though, thanks to our
7535 // use of extra frames for 'overflow')
7537 // If the element is relatively positioned, then adjust x and y
7538 // accordingly so that we consider relatively positioned frames
7539 // at their original position.
7547 }
7548 }
7552 // If we have pushed floats, then they should be at the beginning of our
7553 // float list.
7556 }
7557 #ifdef DEBUG
7558 // Double-check the above assertion that pushed floats should be at the
7559 // beginning of our floats list.
7563 }
7564 #endif
7565 }
7567 // We may have a pending push of pushed floats, too.
7569 }
7571 //////////////////////////////////////////////////////////////////////
7572 // Painting, event handling
7574 #ifdef DEBUG
7580 // Compute min and max x/y values for the reflowed frame's
7581 // combined areas
7589 }
7592 }
7595 }
7598 }
7599 }
7605 }
7606 #endif
7608 #ifdef DEBUG
7617 }
7618 }
7619 #endif
7627 #ifdef DEBUG
7629 aDrawnLines++;
7630 }
7634 #endif
7636 // Collect our line's display items in a temporary nsDisplayListCollection,
7637 // so that we can apply any "text-overflow" clipping to the entire collection
7638 // without affecting previous lines.
7641 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
7642 // Inline-level child backgrounds go on the regular child content list.
7644 collection,
7648 aLineInLine
7657 }
7661 aLineNumberForTextOverflow);
7662 }
7665 }
7671 #ifdef DEBUG
7675 nsRect ca;
7682 }
7687 }
7688 #endif
7690 // TODO(heycam): Should we boost the load priority of any shape-outside
7691 // images using CATEGORY_DISPLAY, now that this block is being displayed?
7692 // We don't have a float manager here.
7701 }
7702 }
7703 }
7709 // Display outside ::marker manually.
7711 }
7713 // Prepare for text-overflow processing.
7722 // TODO(miko): Unfortunately |descendAlways| cannot be cached, because with
7723 // some frame trees, building display list for child lines can change it.
7724 // See bug 1552789.
7732 };
7736 // We'll try to draw an accessibility backplate behind text (to ensure it's
7737 // readable over any possible background-images), if all of the following
7738 // hold:
7739 // (A) we are not honoring the document colors
7740 // (B) the backplate feature is preffed on
7741 // (C) the force color adjust property is set to auto
7746 }
7748 // Don't use the line cursor if we might have a descendant placeholder ...
7749 // it might skip lines that contain placeholders but don't themselves
7750 // intersect with the dirty area.
7751 // In particular, we really want to check ShouldDescendIntoFrame()
7752 // on all our child frames, but that might be expensive. So we
7753 // approximate it by checking it on |this|; if it's true for any
7754 // frame in our child list, it's also true for |this|.
7755 // Also skip the cursor if we're creating text overflow markers,
7756 // since we need to know what line number we're up to in order
7757 // to generate unique display item keys.
7758 // Lastly, the cursor should be skipped if we're drawing
7759 // backplates behind text. When backplating we consider consecutive
7760 // runs of text as a whole, which requires we iterate through all lines
7761 // to find our backplate size.
7774 // Because we have a cursor, the combinedArea.ys are non-decreasing.
7775 // Once we've passed aDirtyRect.YMost(), we can never see it again.
7778 }
7784 }
7785 }
7786 }
7793 // A frame's display list cannot contain more than one copy of a
7794 // given display item unless the items are uniquely identifiable.
7795 // Because backplate occasionally requires multiple
7796 // SolidColor items, we use an index (backplateIndex) to maintain
7797 // uniqueness among them. Note this is a mapping of index to
7798 // item, and the mapping is stable even if the dirty rect changes.
7800 nsRect curBackplateArea;
7806 };
7815 }
7818 // If we have encountered a non-inline line but were previously
7819 // forming a backplate, we should add the backplate to the display
7820 // list as-is and render future backplates disjointly.
7822 "if this master switch is off, curBackplateArea "
7825 backplateIndex++;
7827 }
7832 }
7842 }
7843 }
7844 }
7845 lineCount++;
7846 }
7850 }
7854 }
7855 }
7858 // Put any text-overflow:ellipsis markers on top of the non-positioned
7859 // content of the block's lines. (If we ever start sorting the Content()
7860 // list this will end up in the wrong place.)
7862 }
7864 #ifdef DEBUG
7871 }
7885 }
7886 #endif
7887 }
7889 #ifdef ACCESSIBILITY
7893 }
7895 // block frame may be for <hr>
7898 }
7901 // XXXsmaug What if we're in the shadow dom?
7903 // Don't create accessible objects for the root content node, they are
7904 // redundant with the nsDocAccessible object created with the document
7905 // node
7907 }
7910 // Don't create accessible objects for the body, they are redundant with
7911 // the nsDocAccessible object created with the document node
7913 }
7915 // Not a list item with a ::marker, treat as normal HTML container.
7917 }
7919 // Create special list item accessible since we have a ::marker.
7921 }
7922 #endif
7927 }
7931 }
7936 }
7940 }
7943 // Although this looks like a "querying" method, it is used by the
7944 // display-list building code, so uses the Display cursor.
7948 }
7956 }
7961 }
7965 }
7968 }
7970 /* virtual */
7972 // See if the child is absolutely positioned
7974 // do nothing
7976 // The ::marker lives in the first line, unless the first line has
7977 // height 0 and there is a second line, in which case it lives
7978 // in the second line.
7983 }
7987 }
7988 // otherwise we have an empty line list, and ReflowDirtyLines
7989 // will handle reflowing the ::marker.
7991 // Note that we should go through our children to mark lines dirty
7992 // before the next reflow. Doing it now could make things O(N^2)
7993 // since finding the right line is O(N).
7994 // We don't need to worry about marking lines on the overflow list
7995 // as dirty; we're guaranteed to reflow them if we take them off the
7996 // overflow list.
7997 // However, we might have gotten a float, in which case we need to
7998 // reflow the line containing its placeholder. So find the
7999 // ancestor-or-self of the placeholder that's a child of the block,
8000 // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
8001 // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
8002 // We need to take some care to handle the case where a float is in
8003 // a different continuation than its placeholder, including marking
8004 // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
8011 // SVG code sometimes sends FrameNeedsReflow notifications during
8012 // frame destruction, leading to null placeholders, but we're safe
8013 // ignoring those.
8021 }
8023 }
8025 }
8026 }
8027 }
8030 }
8034 // These are all the block specific frame bits, they are copied from
8035 // the prev-in-flow to a newly created next-in-flow, except for the
8036 // NS_BLOCK_FLAGS_NON_INHERITED_MASK bits below.
8040 NS_BLOCK_HAS_INSIDE_MARKER;
8042 // This is the subset of NS_BLOCK_FLAGS_MASK that is NOT inherited
8043 // by default. They should only be set on the first-in-flow.
8046 NS_BLOCK_HAS_INSIDE_MARKER;
8049 // Copy over the inherited block frame bits from the prev-in-flow.
8053 }
8060 }
8064 }
8069 }
8070 }
8078 #ifdef DEBUG
8079 // The only times a block that is an anonymous box is allowed to have a
8080 // first-letter frame are when it's the block inside a non-anonymous cell,
8081 // the block inside a fieldset, button or column set, or a scrolled content
8082 // block, except for <select>. Note that this means that blocks which are
8083 // the anonymous block in {ib} splits do NOT get first-letter frames.
8084 // Note that NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations
8085 // of the block.
8103 #endif
8108 }
8109 }
8122 }
8123 }
8134 }
8139 nscoord aLineTop) {
8144 // Make up an inline-size since it doesn't really matter (XXX).
8150 nsReflowStatus status;
8153 // Get the float available space using our saved state from before we
8154 // started reflowing the block, so that we ignore any floats inside
8155 // the block.
8156 // FIXME: aLineTop isn't actually set correctly by some callers, since
8157 // they reposition the line.
8158 LogicalRect floatAvailSpace =
8159 aState
8163 // FIXME (bug 25888): need to check the entire region that the first
8164 // line overlaps, not just the top pixel.
8166 // Place the ::marker now. We want to place the ::marker relative to the
8167 // border-box of the associated block (using the right/left margin of
8168 // the ::marker frame as separation). However, if a line box would be
8169 // displaced by floats that are *outside* the associated block, we
8170 // want to displace it by the same amount. That is, we act as though
8171 // the edge of the floats is the content-edge of the block, and place
8172 // the ::marker at a position offset from there by the block's padding,
8173 // the block's border, and the ::marker frame's margin.
8175 // IStart from floatAvailSpace gives us the content/float start edge
8176 // in the current writing mode. Then we subtract out the start
8177 // border/padding and the ::marker's width and margin to offset the position.
8179 // Get the ::marker's margin, converted to our writing mode so that we can
8180 // combine it with other logical values here.
8186 // Approximate the ::marker's position; vertical alignment will provide
8187 // the final vertical location. We pass our writing-mode here, because
8188 // it may be different from the ::marker frame's mode.
8191 wm,
8195 }
8197 // This is used to scan frames for any float placeholders, add their
8198 // floats to the list represented by aList, and remove the
8199 // floats from whatever list they might be in. We don't search descendants
8200 // that are float containing blocks. Floats that or not children of 'this'
8201 // are ignored (they are not added to aList).
8205 // Don't descend into float containing blocks.
8213 // Remove the IS_PUSHED_FLOAT bit, in case |outOfFlowFrame| came from
8214 // the PushedFloats list.
8218 // FIXME: By not pulling floats whose parent is one of our
8219 // later siblings, are we risking the pushed floats getting
8220 // out-of-order?
8221 // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
8222 }
8228 }
8231 }
8233 }
8234 }
8237 #ifdef DEBUG
8238 // If any line is still dirty, that must mean we're going to reflow this
8239 // block again soon (e.g. because we bailed out after noticing that
8240 // clearance was imposed), so don't worry if the floats are out of sync.
8243 // Check that the float list is what we would have built
8248 }
8251 }
8252 }
8261 }
8262 // There are chances that the float children won't be added to lines,
8263 // because in nsBlockFrame::ReflowLine, it skips reflow line if the first
8264 // child of the line is IsHiddenByContentVisibilityOfInFlowParentForLayout.
8265 // There are also chances that the floats in line are out of date, for
8266 // instance, lines could reflow if
8267 // PresShell::IsForcingLayoutForHiddenContent, and after forcingLayout is
8268 // off, the reflow of lines could be skipped, but the floats are still in
8269 // there. Here we can't know whether the floats hidden by c-v are included
8270 // in the lines or not. So we use hasHiddenFloats to skip the float length
8271 // checking.
8275 }
8279 }
8281 }
8286 "nsBlockFrame::CheckFloats: Explicit float list is out of sync with "
8288 }
8289 #endif
8293 // Floats that were pushed should be removed from our float
8294 // manager. Otherwise the float manager's YMost or XMost might
8295 // be larger than necessary, causing this block to get an
8296 // incorrect desired height (or width). Some of these floats
8297 // may not actually have been added to the float manager because
8298 // they weren't reflowed before being pushed; that's OK,
8299 // RemoveRegions will ignore them. It is safe to do this here
8300 // because we know from here on the float manager will only be
8301 // used for its XMost and YMost, not to place new floats and
8302 // lines.
8304 }
8305 }
8315 }
8316 }
8319 // The first column is a start margin root and the last column is an end
8320 // margin root. (If the column-set is split by a column-span:all box then
8321 // the first and last column in each column-set fragment are margin roots.)
8325 }
8329 }
8331 /* static */
8339 }
8341 /* static */
8345 }
8347 // Note that this width can vary based on the vertical position.
8348 // However, the cases where it varies are the cases where the width fits
8349 // in the available space given, which means that variation shouldn't
8350 // matter.
8351 /* static */
8358 FloatAvoidingISizeToClear result;
8361 nscoord availISize =
8364 // We actually don't want the min width here; see bug 427782; we only
8365 // want to displace if the width won't compute to a value small enough
8366 // to fit.
8367 // All we really need here is the result of ComputeSize, and we
8368 // could *almost* get that from an SizeComputationInput, except for the
8369 // last argument.
8371 LogicalSize availSpace =
8378 // Use the margins from sizingInput rather than reflowInput so that
8379 // they aren't reduced by ignoring margins in overconstrained cases.
8389 // If we get here, floatAvoidingBlock has a negative amount of inline-axis
8390 // margin and an 'auto' (or ~equivalently, -moz-available) inline
8391 // size. Under these circumstances, we use the margin to establish a
8392 // (positive) minimum size for the border-box, in order to satisfy the
8393 // equation in CSS2 10.3.3. That equation essentially simplifies to the
8394 // following:
8395 //
8396 // iSize of margins + iSize of borderBox = iSize of containingBlock
8397 //
8398 // ...where "iSize of borderBox" is the sum of floatAvoidingBlock's
8399 // inline-axis components of border, padding, and {width,height}.
8400 //
8401 // Right now, in the above equation, "iSize of margins" is the only term
8402 // that we know for sure. (And we also know that it's negative, since we
8403 // got here.) The other terms are as-yet unresolved, since the frame has an
8404 // 'auto' iSize, and since we aren't yet sure if we'll clear this frame
8405 // beyond floats or place it alongside them.
8406 //
8407 // However: we *do* know that the equation's "iSize of containingBlock"
8408 // term *must* be non-negative, since boxes' widths and heights generally
8409 // can't be negative in CSS. To satisfy that requirement, we can then
8410 // infer that the equation's "iSize of borderBox" term *must* be large
8411 // enough to cancel out the (known-to-be-negative) "iSize of margins"
8412 // term. Therefore, marginISize value (negated to make it positive)
8413 // establishes a lower-bound for how much inline-axis space our border-box
8414 // will really require in order to fit alongside any floats.
8415 //
8416 // XXXdholbert This explanation is admittedly a bit hand-wavy and may not
8417 // precisely match what any particular spec requires. It's the best
8418 // reasoning I could come up with to explain engines' behavior. Also, our
8419 // behavior with -moz-available doesn't seem particularly correct here, per
8420 // bug 1767217, though that's probably due to a bug elsewhere in our float
8421 // handling code...
8423 }
8427 }
8429 /* static */
8435 // yay, candidate is a block!
8437 }
8438 // Not a block. Check its parent next.
8440 }
8443 }
8446 nscoord aBEndEdgeOfChildren) {
8457 "An overflow container's effective content-box block-size, block-start "
8469 // If a block is split by any column-spans, we calculate the final
8470 // block-size by shrinkwrapping our children's block-size for all the
8471 // fragments except for those after the final column-span, but we should
8472 // take no more than our effective border-box block-size. If there's any
8473 // leftover block-size, our next continuations will take up rest.
8474 //
8475 // We don't need to adjust aBri.mReflowStatus because our children's status
8476 // is the same as ours.
8478 }
8483 }
8485 // Save our children's reflow status.
8492 }
8498 // The maximum value our content-box block-size can take within the given
8499 // available block-size.
8502 // The block-end edge of our content-box (relative to this frame's origin) if
8503 // we consumed the maximum block-size available to us (maxContentBoxBSize).
8506 // These variables are uninitialized intentionally so that the compiler can
8507 // check they are assigned in every if-else branch below.
8508 nscoord finalContentBoxBSizeWithBStartBP;
8512 // Our effective border-box block-size can fit in the available block-size,
8513 // so we are complete.
8517 // Note: The following assertion should generally hold because, for
8518 // box-decoration-break:clone, this "else if" branch is mathematically
8519 // equivalent to the initial "if".
8521 "This else-if branch is handling a situation that's specific "
8522 "to box-decoration-break:slice, i.e. a case when we can skip "
8525 // Our effective content-box block-size plus the block-start border and
8526 // padding can fit in the available block-size, but it cannot fit after
8527 // adding the block-end border and padding. Thus, we need a continuation
8528 // (unless we already weren't asking for any block-size, in which case we
8529 // stay complete to avoid looping forever).
8533 // We aren't going to be able to fit our content-box in the space available
8534 // to it, which means we'll probably call ourselves incomplete to request a
8535 // continuation. But before making that decision, we check for certain
8536 // conditions which would force us to overflow beyond the available space --
8537 // these might result in us actually being complete if we're forced to
8538 // overflow far enough.
8542 // In this rare case, we are at the top of page/column, we have
8543 // box-decoration-break:clone and zero available block-size for our
8544 // content-box (e.g. our own block-start border and padding already exceed
8545 // the available block-size), and we didn't lay out any child to consume
8546 // our content-box block-size. To ensure we make progress (avoid looping
8547 // forever), use 1px as our content-box block-size regardless of our
8548 // effective content-box block-size, in the spirit of
8549 // https://drafts.csswg.org/css-break/#breaking-rules.
8553 // We have a unbreakable child whose block-end edge exceeds the available
8554 // block-size for children.
8556 // The unbreakable child's block-end edge forces us to consume all of
8557 // our effective content-box block-size.
8560 // Even though we've consumed all of our effective content-box
8561 // block-size, we may still need to report an incomplete status in order
8562 // to get another continuation, which will be responsible for laying out
8563 // & drawing our block-end border & padding. But if we have no such
8564 // border & padding, or if we're forced to apply that border & padding
8565 // on this frame due to box-decoration-break:clone, then we don't need
8566 // to bother with that additional continuation.
8569 // The unbreakable child's block-end edge doesn't force us to consume
8570 // all of our effective content-box block-size.
8573 }
8575 // The children's block-end edge can fit in the content-box space that we
8576 // have available for it. Consume all the space that is available so that
8577 // our inline-start/inline-end borders extend all the way to the block-end
8578 // edge of column/page.
8581 }
8582 }
8588 // We want to use children's reflow status as ours, which can be overflow
8589 // incomplete. Suppress the urge to call aBri.mReflowStatus.Reset() here.
8592 }
8595 "An overflow container should always be complete because of "
8598 finalBorderBoxBSize =
8600 }
8604 }
8605 }
8608 }
8615 }
8618 // first-letter needs to be updated before first-line, because first-line can
8619 // change the style of the first-letter.
8622 }
8632 parentStyle);
8634 // FIXME(bz): Can we make first-line continuations be non-inheriting anon
8635 // boxes?
8643 // We also want to update the styles of the first-line's descendants. We
8644 // don't need to compute a changehint for this, though, since any changes to
8645 // them are handled by the first-line anyway.
8649 }
8650 }
8651 }
8655 // Certainly no first-letter frame.
8657 }
8660 }
8666 }
8669 }
8671 #ifdef DEBUG
8675 }
8678 }
8682 // Add up the counts on each line. Also validate that IsFirstLine is
8683 // set properly.
8688 }
8693 }
8694 }
8696 }
8698 // Then count the frames
8702 frameCount++;
8704 }
8707 // Next: test that each line has right number of frames on it
8714 }
8718 }
8719 }
8730 }
8731 }
8732 }
8733 }
8735 }
8738 // Overflow out-of-flows must not have a next-in-flow in floats list or
8739 // mFrames.
8747 }
8748 }
8750 // Pushed floats must not have a next-in-flow in floats list or mFrames.
8758 }
8759 }
8761 // A child float next-in-flow's parent must be |this| or a next-in-flow of
8762 // |this|. Later next-in-flows must have the same or later parents.
8777 }
8778 }
8780 found,
8782 }
8783 }
8784 }
8797 }
8801 }
8809 }
8811 };
8817 }
8818 }
8825 depth++;
8826 }
8828 }
8834 }
8835 #endif