| blob | 5ad0f713e2ba72f8f0ac64cad4d70a45e0b5c8f3 |
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 /*
8 * rendering object for CSS display:block, inline-block, and list-item
9 * boxes, also used for various anonymous boxes
10 */
50 #include <algorithm>
69 #include <inttypes.h>
87 }
88 }
90 }
91 }
99 }
101 }
103 // Mark every line at and below the line where the float was
104 // dirty, and mark their lines dirty too. We could probably do
105 // something more efficient --- e.g., just dirty the lines that intersect
106 // the float vertically.
108 }
110 /**
111 * Returns true if aFrame is a block that has one or more float children.
112 */
117 }
120 }
125 }
126 }
128 }
130 /**
131 * Determines whether the given frame is visible or has
132 * visible children that participate in the same line. Frames
133 * that are not line participants do not have their
134 * children checked.
135 */
141 }
148 }
149 }
150 }
152 }
154 /**
155 * Determines whether any of the frames descended from the
156 * given line have inline content with 'visibility: visible'.
157 * This function calls FrameHasVisibleInlineContent to process
158 * each frame in the line's child list.
159 */
166 }
169 }
172 }
174 /**
175 * Iterates through the frame's in-flow children and
176 * unions the ink overflow of all text frames which
177 * participate in the line aFrame belongs to.
178 * If a child of aFrame is not a text frame,
179 * we recurse with the child as the aFrame argument.
180 * If aFrame isn't a line participant, we skip it entirely
181 * and return an empty rect.
182 * The resulting nsRect is offset relative to the parent of aFrame.
183 */
186 nsRect textArea;
190 }
195 }
196 }
197 // add aFrame's position to keep textArea relative to aFrame's parent
199 }
201 /**
202 * Iterates through the line's children and
203 * unions the ink overflow of all text frames.
204 * GetFrameTextArea unions and returns the ink overflow
205 * from all line-participating text frames within the given child.
206 * The nsRect returned from GetLineTextArea is offset
207 * relative to the given line.
208 */
211 nsRect textArea;
218 }
221 }
223 /**
224 * Starting with aFrame, iterates upward through parent frames and checks for
225 * non-transparent background colors. If one is found, we use that as our
226 * backplate color. Otheriwse, we use the default background color from
227 * our high contrast theme.
228 */
233 // NOTE(emilio): We assume themed frames (frame->IsThemed()) have correct
234 // background-color information so as to compute the right backplate color.
235 //
236 // This holds because HTML widgets with author-specified backgrounds or
237 // borders disable theming. So as long as the UA-specified background colors
238 // match the actual theme (which they should because we always use system
239 // colors with the non-native theme, and native system colors should also
240 // match the native theme), then we're alright and we should compute an
241 // appropriate backplate color.
245 }
251 }
253 // Even if there's a background image, if there's no background color we
254 // keep going up the frame tree, see bug 1723938.
256 }
258 // Try to avoid somewhat expensive math in the common case.
261 currentBackgroundColor =
263 }
265 // If fully opaque, we're done, otherwise keep going up blending with our
266 // background.
268 }
269 }
273 }
275 }
277 #ifdef DEBUG
296 };
308 };
309 # define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
317 }
320 }
333 }
345 }
346 }
349 }
353 }
356 }
359 }
360 }
361 }
362 }
364 #endif
366 //----------------------------------------------------------------------
368 // Debugging support code
370 #ifdef DEBUG
373 };
390 }
392 }
394 #endif
396 #ifdef REFLOW_STATUS_COVERAGE
401 // 0: child-is-block
402 // 1: child-is-inline
406 }
408 // Compute new status
417 }
422 }
424 // Log updates to the status that yield different values
428 }
429 }
430 #endif
440 //----------------------------------------------------------------------
444 }
451 }
461 // Add the size of any nsLineBox::mFrames hashtables we might have:
464 }
471 }
472 }
473 }
486 }
488 // destroy overflow lines now
494 }
500 }
505 }
508 }
510 /* virtual */
518 }
520 }
526 #ifdef DEBUG_FRAME_DUMP
529 nsCString str;
537 // Output the lines
542 }
543 }
545 // Output the overflow lines.
556 }
558 }
560 // skip the principal list - we printed the lines above
561 // skip the overflow list - we printed the overflow lines above
566 }
570 }
571 #endif
580 }
582 }
592 }
594 aRebuildDisplayItems);
595 }
600 }
605 BaselineSharingGroup aBaselineGroup,
614 // XXX Is this the right test? We have some bogus empty lines
615 // floating around, but IsEmpty is perhaps too weak.
620 }
622 }
624 }
628 }
631 // `<table>` in inline-block context does not export any baseline.
633 }
642 }
646 }
647 // Ignore relative positioning for baseline calculations.
652 }
654 }
656 }
663 }
667 aExportContext);
668 }
671 aExportContext);
672 }
683 }
685 }
686 }
697 }
699 /////////////////////////////////////////////////////////////////////////////
700 // Child frame enumeration
709 }
715 }
719 }
723 }
726 }
727 }
734 }
738 }
743 }
747 }
748 }
750 /* virtual */
753 /**
754 * Remove the first line from aFromLines and adjust the associated frame list
755 * aFromFrames accordingly. The removed line is assigned to *aOutLine and
756 * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
757 * that were extracted from the head of aFromFrames.
758 * aFromLines must contain at least one line, the line may be empty.
759 * @return true if aFromLines becomes empty
760 */
770 }
772 //////////////////////////////////////////////////////////////////////
773 // Reflow methods
775 /* virtual */
784 }
785 }
788 }
794 }
803 }
804 }
805 }
807 /* virtual */
812 }
820 }
825 }
827 #ifdef DEBUG
832 }
834 #endif
839 }
844 }
847 InlineMinISizeData data;
853 #ifdef DEBUG
858 }
860 #endif
870 }
879 }
880 }
881 }
882 #ifdef DEBUG
887 }
888 #endif
889 }
890 }
895 }
897 /* virtual */
902 }
910 }
915 }
917 #ifdef DEBUG
922 }
924 #endif
929 }
934 }
935 InlinePrefISizeData data;
941 #ifdef DEBUG
946 }
948 #endif
950 StyleClear clearType;
955 }
966 // XXXmats should the test below be indent > 0?
969 }
970 }
977 }
978 }
979 #ifdef DEBUG
984 }
985 #endif
986 }
987 }
992 }
995 // be conservative
998 }
1000 }
1002 /* virtual */
1008 }
1013 nsresult rv;
1014 InlinePrefISizeData data;
1032 }
1044 }
1045 }
1046 }
1047 }
1051 }
1053 /**
1054 * Return whether aNewAvailableSpace is smaller *on either side*
1055 * (inline-start or inline-end) than aOldAvailableSpace, so that we know
1056 * if we need to redo layout on an line, replaced block, or block
1057 * formatting context, because its height (which we used to compute
1058 * aNewAvailableSpace) caused it to intersect additional floats.
1059 */
1065 // Positions are not significant if the inline size is zero.
1067 }
1072 "available space should not shrink on the start side and "
1077 "available space should not grow on the start side and "
1084 }
1085 // Have we shrunk on either side?
1088 }
1092 // The issue here is that for a 'height' of 'auto' the reflow input
1093 // code won't know how to calculate the containing block height
1094 // because it's calculated bottom up. So we use our own computed
1095 // size as the dimensions.
1099 // Containing block is relative to the padding edge
1107 }
1109 // We are a wrapped frame for the content (and the wrapper is not the
1110 // canvas frame, whose size is not meaningful here).
1111 // Use the container's dimensions, if they have been precomputed.
1112 // XXX This is a hack! We really should be waiting until the outermost
1113 // frame is fully reflowed and using the resulting dimensions, even
1114 // if they're intrinsic.
1115 // In fact we should be attaching absolute children to the outermost
1116 // frame and not always sticking them in block frames.
1118 // First, find the reflow input for the outermost frame for this content.
1126 }
1130 }
1132 // For scroll containers, we can just use cbSize (which is the padding-box
1133 // size of the scrolled-content frame).
1135 // Assert that we're not missing any frames between the abspos containing
1136 // block and the scroll container.
1137 // the parent.
1141 }
1143 // Same for fieldsets, where the inner anonymous frame has the correct padding
1144 // area with the legend taken into account.
1147 }
1149 // We found a reflow input for the outermost wrapping frame, so use
1150 // its computed metrics if available, converted to our writing mode
1156 }
1160 }
1163 }
1165 /**
1166 * Returns aFrame if it is a non-BFC block frame, and null otherwise.
1167 *
1168 * This is used to determine whether to recurse into aFrame when applying
1169 * -webkit-line-clamp.
1170 */
1175 }
1176 }
1178 }
1183 }
1188 }
1192 }
1196 }
1198 // For now, -webkit-box is the only thing allowed to be a line-clamp root.
1199 // Ideally we'd just make this work everywhere, but for now we're carrying
1200 // this forward as a limitation on the legacy -webkit-line-clamp feature,
1201 // since relaxing this limitation might create webcompat trouble.
1204 // If we're the anonymous block inside the scroll frame, we need to look
1205 // at the original display of our parent frame.
1210 ":-moz-scrolled-content should inherit -webkit-line-clamp, "
1213 }
1215 }();
1217 }
1222 }
1228 }
1231 }
1232 }
1234 }
1236 /**
1237 * Iterator over all descendant inline line boxes, except for those that are
1238 * under an independent formatting context.
1239 */
1248 }
1249 }
1254 // Advances the iterator to the next line line.
1255 //
1256 // Next() shouldn't be called once the iterator is at the end, which can be
1257 // checked for by GetCurrentLine() or GetCurrentFrame() returning null.
1263 }
1269 // Reached the end of the current block. Pop the parent off the
1270 // stack; if there isn't one, then we've reached the end.
1274 }
1288 // Some kind of frame we shouldn't descend into.
1290 }
1294 }
1295 }
1296 }
1298 // The current line within the current block.
1299 //
1300 // When this is equal to mEnd, the iterator is at its end, and mCurrentFrame
1301 // is set to null.
1304 // The iterator end for the current block.
1307 // The current block.
1310 // Stack of mCurrentFrame and mEnd values that we push and pop as we enter and
1311 // exist blocks.
1313 };
1321 }
1322 }
1323 }
1325 }
1333 }
1334 }
1336 // We didn't find a line with the ellipsis; it must have been deleted already.
1338 }
1348 }
1355 #ifdef DEBUG
1362 }
1369 }
1370 #endif
1372 // ColumnSetWrapper's children depend on ColumnSetWrapper's block-size or
1373 // max-block-size because both affect the children's available block-size.
1376 }
1383 }
1384 });
1390 // If we have non-auto block size, we're clipping our kids and we fit,
1391 // make sure our kids fit too.
1397 physicalBlockAxis)) {
1398 LogicalMargin blockDirExtras =
1403 // Block-end margin never causes us to create continuations, so we
1404 // don't need to worry about whether it fits in its entirety.
1407 }
1414 }
1415 }
1419 }
1421 // OK, some lines may be reflowed. Blow away any saved line cursor
1422 // because we may invalidate the nondecreasing
1423 // overflowArea.InkOverflow().y/yMost invariant, and we may even
1424 // delete the line with the line cursor.
1427 // See comment below about oldSize. Use *only* for the
1428 // abs-pos-containing-block-size-change optimization!
1431 // Should we create a float manager?
1434 // XXXldb If we start storing the float manager in the frame rather
1435 // than keeping it around only during reflow then we should create it
1436 // only when there are actually floats to manage. Otherwise things
1437 // like tables will gain significant bloat.
1441 }
1446 }
1448 // Whether to apply text-wrap: balance behavior.
1452 // Struct used to hold the "target" number of lines or clamp position to
1453 // maintain when doing text-wrap: balance.
1455 // If line-clamp is in effect, mContent and mOffset indicate the starting
1456 // position of the first line after the clamp limit. If line-clamp is not
1457 // in use, mContent is null and mOffset is the total number of lines that
1458 // the block must contain.
1464 }
1467 }
1468 };
1470 BalanceTarget balanceTarget;
1472 // Helpers for text-wrap: balance implementation:
1474 // Count the number of lines in the mLines list, but return -1 instead if the
1475 // count is going to exceed aLimit.
1481 }
1482 }
1484 };
1486 // Return a BalanceTarget record representing the position at which line-clamp
1487 // will take effect for the current line list. Only to be used when there are
1488 // enough lines that the clamp will apply.
1494 }
1498 }
1502 }
1507 }
1509 };
1511 // "balancing" is implemented by shortening the effective inline-size of the
1512 // lines, so that content will tend to be pushed down to fill later lines of
1513 // the block. `balanceInset` is the current amount of "inset" to apply, and
1514 // `balanceStep` is the increment to adjust it by for the next iteration.
1517 // text-wrap: balance loop, executed only once if balancing is not required.
1518 nsReflowStatus reflowStatus;
1520 needFloatManager);
1522 // Save the initial floatManager state for repeated trial reflows.
1523 // We'll restore (and re-save) the initial state each time we repeat the
1524 // reflow.
1529 reflowStatus =
1532 // Do we need to start a `text-wrap: balance` iteration?
1535 // Don't try to balance an incomplete block.
1538 }
1542 // If there are less than 2 lines, or the number exceeds the limit,
1543 // no balancing is needed; just break from the balance loop.
1545 }
1546 // Initialize the amount of inset to try, and the iteration step size.
1551 // If -webkit-line-clamp is in effect, then we need to maintain the
1552 // content location at which clamping occurs, rather than the total
1553 // number of lines in the block.
1561 }
1562 }
1563 }
1565 // Restore initial floatManager state for a new trial with updated inset.
1568 }
1570 // Helper to determine whether the current trial succeeded (i.e. was able
1571 // to fit the content into the expected number of lines).
1575 }
1579 }
1583 };
1585 // If we're in the process of a balance operation, check whether we've
1586 // inset by too much and either increase or reduce the inset for the next
1587 // iteration.
1593 }
1598 }
1600 // If we were attempting to balance, check whether the final iteration was
1601 // successful, and if not, back up by one step.
1605 }
1610 }
1612 // If we reach here, no balancing was required, so just exit; we don't
1613 // reset (pop) the floatManager state because this is the reflow we're
1614 // going to keep. So the saved state is just dropped.
1618 // If the block direction is right-to-left, we need to update the bounds of
1619 // lines that were placed relative to mContainerSize during reflow, as
1620 // we typically do not know the true container size until we've reflowed all
1621 // its children. So we use a dummy mContainerSize during reflow (see
1622 // BlockReflowState's constructor) and then fix up the positions of the
1623 // lines here, once the final block size is known.
1624 //
1625 // Note that writing-mode:vertical-rl is the only case where the block
1626 // logical direction progresses in a negative physical direction, and
1627 // therefore block-dir coordinate conversion depends on knowing the width
1628 // of the coordinate space in order to translate between the logical and
1629 // physical origins.
1634 // We compute our lines and markers' overflow areas later in
1635 // ComputeOverflowAreas(), so we don't need to adjust their overflow areas
1636 // here.
1640 }
1645 }
1650 }
1651 }
1657 }
1658 }
1659 }
1660 }
1666 // Factor overflow container child bounds into the overflow area
1668 // Factor pushed float child bounds into the overflow area
1671 // Let the absolutely positioned container reflow any absolutely positioned
1672 // child frames that need to be reflowed, e.g., elements with a percentage
1673 // based width/height
1674 // We want to do this under either of two conditions:
1675 // 1. If we didn't do the incremental reflow above.
1676 // 2. If our size changed.
1677 // Even though it's the padding edge that's the containing block, we
1678 // can use our rect (the border edge) since if the border style
1679 // changed, the reflow would have been targeted at us so we'd satisfy
1680 // condition 1.
1681 // XXX checking oldSize is bogus, there are various reasons we might have
1682 // reflowed but our size might not have been changed to what we
1683 // asked for (e.g., we ended up being pushed to a new page)
1684 // When WillReflowAgainForClearance is true, we will reflow again without
1685 // resetting the size. Because of this, we must not reflow our abs-pos
1686 // children in that situation --- what we think is our "new size" will not be
1687 // our real new size. This also happens to be more efficient.
1693 // Make sure that when we reflow again we'll actually reflow all the abs
1694 // pos frames that might conceivably depend on our size (or all of them,
1695 // if we're dirty right now and interrupted; in that case we also need
1696 // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
1697 // better than that, because we don't really know what our size will be,
1698 // and it might in fact not change on the followup reflow!
1703 }
1705 // We're not going to reflow absolute frames; make sure to account for
1706 // their existing overflow areas, which is usually a side effect of this
1707 // reflow.
1708 //
1709 // TODO(emilio): nsAbsoluteContainingBlock::Reflow already checks for
1710 // interrupt, can we just rely on it and unconditionally take the else
1711 // branch below? That's a bit more subtle / risky, since I don't see
1712 // what would reflow them in that case if they depended on our size.
1716 }
1717 }
1719 LogicalSize containingBlockSize =
1723 // Mark frames that depend on changes we just made to this frame as dirty:
1724 // Now we can assume that the padding edge hasn't moved.
1725 // We need to reflow the absolutes if one of them depends on
1726 // its placeholder position, or the containing block size in a
1727 // direction in which the containing block size might have
1728 // changed.
1730 // XXX "width" and "height" in this block will become ISize and BSize
1731 // when nsAbsoluteContainingBlock is logicalized
1734 // If isRoot and we have auto height, then we are the initial
1735 // containing block and the containing block height is the
1736 // viewport height, which can't change during incremental
1737 // reflow.
1747 }
1750 }
1751 // Setup the line cursor here to optimize line searching for
1752 // calculating hypothetical position of absolutely-positioned
1753 // frames.
1758 }
1759 }
1765 #ifdef DEBUG
1766 // Between when we drain pushed floats and when we complete reflow,
1767 // we're allowed to have multiple continuations of the same float on
1768 // our floats list, since a first-in-flow might get pushed to a later
1769 // continuation of its containing block. But it's not permitted
1770 // outside that time.
1787 }
1789 }
1798 }
1811 }
1812 #endif
1813 }
1819 #ifdef DEBUG
1820 // Between when we drain pushed floats and when we complete reflow,
1821 // we're allowed to have multiple continuations of the same float on
1822 // our floats list, since a first-in-flow might get pushed to a later
1823 // continuation of its containing block. But it's not permitted
1824 // outside that time.
1826 #endif
1828 // ALWAYS drain overflow. We never want to leave the previnflow's
1829 // overflow lines hanging around; block reflow depends on the
1830 // overflow line lists being cleared out between reflow passes.
1842 // Handle paginated overflow (see nsContainerFrame.h)
1843 nsReflowStatus ocStatus;
1849 }
1851 // Now that we're done cleaning up our overflow container lists, we can
1852 // give |state| its nsOverflowContinuationTracker.
1856 // Drain & handle pushed floats
1860 // If we're not dirty (which means we'll mark everything dirty later)
1861 // and our inline-size has changed, mark the lines dirty that we need to
1862 // mark dirty for a resize reflow.
1865 }
1867 // The same for percentage text-indent, except conditioned on the
1868 // parent resizing.
1873 }
1875 // For text-wrap:balance trials, we need to reflow all the lines even if
1876 // they're not all "dirty".
1881 }
1883 // Now reflow...
1886 // If we have a next-in-flow, and that next-in-flow has pushed floats from
1887 // this frame from a previous iteration of reflow, then we should not return
1888 // a status with IsFullyComplete() equals to true, since we actually have
1889 // overflow, it's just already been handled.
1891 // NOTE: This really shouldn't happen, since we _should_ pull back our floats
1892 // and reflow them, but just in case it does, this is a safety precaution so
1893 // we don't end up with a placeholder pointing to frames that have already
1894 // been deleted as part of removing our next-in-flow.
1903 }
1905 }
1908 }
1909 }
1913 // If we end in a BR with clear and affected floats continue,
1914 // we need to continue, too.
1919 }
1924 }
1926 #ifdef DEBUG_kipp
1929 #endif
1930 }
1932 // Place the ::marker's frame if it is placed next to a block child.
1933 //
1934 // According to the CSS2 spec, section 12.6.1, the ::marker's box
1935 // participates in the height calculation of the list-item box's
1936 // first line box.
1937 //
1938 // There are exactly two places a ::marker can be placed: near the
1939 // first or second line. It's only placed on the second line in a
1940 // rare case: an empty first line followed by a second line that
1941 // contains a block (example: <LI>\n<P>... ). This is where
1942 // the second case can happen.
1947 // Reflow the ::marker's frame.
1949 // XXX Use the entire line when we fix bug 25888.
1954 nscoord lineBStart =
1963 // We have some lines to align the ::marker with.
1965 // Doing the alignment using the baseline will also cater for
1966 // ::markers that are placed next to a child block (bug 92896)
1968 // Tall ::markers won't look particularly nice here...
1969 LogicalRect bbox =
1976 }
1979 });
1982 }
1983 // Otherwise just leave the ::marker where it is, up against our
1984 // block-start padding.
1985 }
1987 // Clear any existing -webkit-line-clamp ellipsis.
1990 }
1994 // Compute our final size (for this trial layout)
2000 }
2006 }
2009 }
2010 }
2012 }
2015 StyleLineClamp aLineNumber) {
2030 NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
2033 // Don't count a line that only has collapsible white space (as might exist
2034 // after calling e.g. getBoxQuads).
2038 }
2041 // We already previously found our target line, and now we have
2042 // confirmed that there is another line after it.
2045 }
2048 // This is our target line. Continue looping to confirm that we
2049 // have another line after us.
2052 }
2055 }
2060 }
2067 }
2071 nscoord aContentBlockEndEdge) {
2074 }
2079 // The number of lines did not exceed the -webkit-line-clamp value.
2081 }
2083 // Mark the line as having an ellipsis so that TextOverflow will render it.
2087 // Translate the b-end edge of the line up to aFrame's space.
2090 edge +=
2092 }
2095 }
2102 #ifdef NOISY_FINAL_SIZE
2108 #endif
2110 // Compute final inline size
2117 // Return block-end margin information
2118 // rbs says he hit this assertion occasionally (see bug 86947), so
2119 // just set the margin to zero and we'll figure out why later
2120 // NS_ASSERTION(aMetrics.mCarriedOutBEndMargin.IsZero(),
2121 // "someone else set the margin");
2124 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
2125 // line with clearance and a non-zero block-start margin and all
2126 // subsequent lines are empty, then we do not allow our children's
2127 // carried out block-end margin to be carried out of us and collapse
2128 // with our own block-end margin.
2130 // Convert the children's carried out margin to something that
2131 // we will include in our height
2134 }
2138 }
2141 // Shrink wrap our height around our contents.
2144 // When we are a block-end-margin root make sure that our last
2145 // child's block-end margin is fully applied. We also do this when
2146 // we have a computed height, since in that case the carried out
2147 // margin is not going to be applied anywhere, so we should note it
2148 // here to be included in the overflow area.
2149 // Apply the margin only if there's space for it.
2151 // Truncate block-end margin if it doesn't fit to our available BSize.
2152 blockEndEdgeOfChildren =
2155 }
2156 }
2158 // Include the float manager's state to properly account for the
2159 // block-end margin of any floated elements; e.g., inside a table cell.
2160 //
2161 // Note: The block coordinate returned by ClearFloats is always greater than
2162 // or equal to blockEndEdgeOfChildren.
2165 }
2168 // Note: We don't use blockEndEdgeOfChildren because it includes the
2169 // previous margin.
2173 // We don't care about ApplyLineClamp's return value (the line-clamped
2174 // content BSize) in this explicit-BSize codepath, but we do still need to
2175 // call ApplyLineClamp for ellipsis markers to be placed as-needed.
2180 // If the content block-size is larger than the effective computed
2181 // block-size, we extend the block-size to contain all the content.
2182 // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
2184 // Note: finalSize.BSize(wm) is the border-box size, so we compare it with
2185 // the content's block-size plus our border and padding..
2189 }
2191 // Don't carry out a block-end margin when our BSize is fixed.
2192 //
2193 // Note: this also includes the case that aReflowInput.ComputedBSize() is
2194 // calculated from aspect-ratio. i.e. Don't carry out block margin-end if it
2195 // is replaced by the block size from aspect-ratio and inline size.
2201 // If we're size-containing in block axis and we don't have a specified
2202 // block size, then our final size should actually be computed from only
2203 // our border, padding and contain-intrinsic-block-size, ignoring the
2204 // actual contents. Hence this case is a simplified version of the case
2205 // below.
2206 //
2207 // NOTE: We exempt the nsComboboxControlFrame subclass from taking this
2208 // special case when it has 'contain-intrinsic-block-size: none', because
2209 // comboboxes implicitly honors the size-containment behavior on its
2210 // nsComboboxDisplayFrame child (which it shrinkwraps) rather than on the
2211 // nsComboboxControlFrame. (Moreover, the DisplayFrame child doesn't even
2212 // need any special content-size-ignoring behavior in its reflow method,
2213 // because that method just resolves "auto" BSize values to one
2214 // line-height rather than by measuring its contents' BSize.)
2216 nscoord autoBSize =
2222 // Our parent is expected to push this frame to the next page/column so
2223 // what size we set here doesn't really matter.
2237 // Our min-block-size, max-block-size, or -webkit-line-clamp value made
2238 // our bsize change. Don't carry out our kids' block-end margins.
2240 }
2245 // Applying `min-size` made us overflow our available size.
2246 // Clamp it and report that we're Incomplete, or BreakBefore if we have
2247 // 'break-inside: avoid' that is applicable.
2253 }
2254 }
2262 // This should never happen, but it does. See bug 414255
2264 }
2268 // Compute this fragment's block-size, with the max-block-size
2269 // constraint taken into consideration.
2276 // We actually fit after applying `max-size` so we should be
2277 // Overflow-Incomplete instead.
2281 // We cannot fit after applying `max-size` with our block-end BP, so
2282 // we should draw it in our next continuation.
2284 }
2285 }
2287 }
2288 }
2292 // Overflow containers can only be overflow complete.
2293 // Note that auto height overflow containers have no normal children
2297 }
2301 // Currently only used for grid items, but could be used in other contexts.
2302 // The FragStretchBSizeProperty is our expected non-fragmented block-size
2303 // we should stretch to (for align-self:stretch etc). In some fragmentation
2304 // cases though, the last fragment (this frame since we're complete), needs
2305 // to have extra size applied because earlier fragments consumed too much of
2306 // our computed size due to overflowing their containing block. (E.g. this
2307 // ensures we fill the last row when a multi-row grid item is fragmented).
2312 }
2313 }
2315 // Clamp the content size to fit within the margin-box clamp size, if any.
2329 // XXXmats deal with percentages better somehow?
2331 }
2332 }
2333 }
2335 // Screen out negative block sizes --- can happen due to integer overflows :-(
2342 }
2346 #ifdef DEBUG_blocks
2351 }
2352 #endif
2355 }
2362 // Factor in the block-end edge of the children. Child frames will be added
2363 // to the overflow area as we iterate through the lines, but their margins
2364 // won't, so we need to account for block-end margins here.
2365 // REVIEW: For now, we do this for both visual and scrollable area,
2366 // although when we make scrollable overflow area not be a subset of
2367 // visual, we can change this.
2370 // If we are a scrolled inner frame, add our block-end padding to our
2371 // children's block-end edge.
2372 //
2373 // Note: aBEndEdgeOfChildren already includes our own block-start padding
2374 // because it is relative to our block-start edge of our border-box, which
2375 // is the same as our padding-box here.
2379 }
2381 // XXX Currently, overflow areas are stored as physical rects, so we have
2382 // to handle writing modes explicitly here. If we change overflow rects
2383 // to be stored logically, this can be simplified again.
2389 // Layout containment should force all overflow to be ink (visual)
2390 // overflow, so if we're layout-contained, we only add our children's
2391 // block-end edge to the ink (visual) overflow -- not to the
2392 // scrollable overflow.
2395 }
2396 }
2405 }
2406 }
2407 }
2413 }
2414 }
2415 }
2416 }
2419 nscoord aBEndEdgeOfChildren,
2421 // XXX_perf: This can be done incrementally. It is currently one of
2422 // the things that makes incremental reflow O(N^2).
2428 }
2430 // We rely here on our caller having called SetOverflowAreasToDesiredBounds().
2435 // If we have layout containment, we should only consider our child's
2436 // ink overflow, leaving the scrollable regions of the parent
2437 // unaffected.
2438 // Note: scrollable overflow is a subset of ink overflow,
2439 // so this has the same affect as unioning the child's visual and
2440 // scrollable overflow with its parent's ink overflow.
2446 }
2447 }
2449 // Factor an outside ::marker in; normally the ::marker will be factored
2450 // into the line-box's overflow areas. However, if the line is a block
2451 // line then it won't; if there are no lines, it won't. So just
2452 // factor it in anyway (it can't hurt if it was already done).
2453 // XXXldb Can we just fix GetOverflowArea instead?
2456 }
2462 overflowClipMargin);
2463 }
2465 #ifdef NOISY_OVERFLOW_AREAS
2469 #endif
2470 }
2473 // We need to update the overflow areas of lines manually, as they
2474 // get cached and re-used otherwise. Lines aren't exposed as normal
2475 // frame children, so calling UnionChildOverflow alone will end up
2476 // using the old cached values.
2485 }
2487 // Consider the overflow areas of the floats attached to the line as well
2491 }
2492 }
2496 }
2498 // Union with child frames, skipping the principal and float lists
2499 // since we already handled those using the line boxes.
2503 }
2507 nscoord blockEndEdgeOfChildren =
2512 }
2514 // Line cursor invariants depend on the overflow areas of the lines, so
2515 // we must clear the line cursor since those areas may have changed.
2518 }
2528 // NOTE: MarkLineDirty does more than just marking the line dirty.
2531 }
2532 }
2533 }
2535 }
2536 }
2540 // Mark aLine dirty
2543 #ifdef DEBUG
2548 }
2549 #endif
2551 // Mark previous line dirty if it's an inline line so that it can
2552 // maybe pullup something from the line just affected.
2553 // XXX We don't need to do this if aPrevLine ends in a break-after...
2558 #ifdef DEBUG
2564 }
2565 #endif
2566 }
2567 }
2569 /**
2570 * Test whether lines are certain to be aligned left so that we can make
2571 * resizing optimizations
2572 */
2574 StyleDirection aDirection,
2575 StyleUnicodeBidi aUnicodeBidi,
2583 }
2586 // See if we can try and avoid marking all the lines as dirty
2587 // FIXME(emilio): This should be writing-mode aware, I guess.
2589 // The left content-edge must be a constant distance from the left
2590 // border-edge.
2593 #ifdef DEBUG
2596 }
2603 }
2604 }
2605 #endif
2609 nscoord newAvailISize =
2613 #ifdef DEBUG
2618 }
2619 #endif
2623 // We let child blocks make their own decisions the same
2624 // way we are here.
2632 }
2634 #ifdef REALLY_NOISY_REFLOW
2638 }
2639 #endif
2640 #ifdef DEBUG
2644 "skipped: line=%p next=%p %s %s%s%s clearTypeBefore/After=%s/%s "
2656 }
2657 #endif
2658 }
2660 // Mark everything dirty
2663 }
2664 }
2665 }
2667 //----------------------------------------
2669 /**
2670 * Propagate reflow "damage" from from earlier lines to the current
2671 * line. The reflow damage comes from the following sources:
2672 * 1. The regions of float damage remembered during reflow.
2673 * 2. The combination of nonzero |aDeltaBCoord| and any impact by a
2674 * float, either the previous reflow or now.
2675 *
2676 * When entering this function, |aLine| is still at its old position and
2677 * |aDeltaBCoord| indicates how much it will later be slid (assuming it
2678 * doesn't get marked dirty and reflowed entirely).
2679 */
2682 nscoord aDeltaBCoord) {
2690 // Check to see if there are any floats; if there aren't, there can't
2691 // be any float damage
2694 }
2696 // Check the damage region recorded in the float damage.
2698 // Need to check mBounds *and* mCombinedArea to find intersections
2699 // with aLine's floats
2702 // Scrollable overflow should be sufficient for things that affect
2703 // layout.
2706 LogicalRect overflow =
2709 nscoord lineBCoordCombinedAfter =
2715 lineBCoordCombinedAfter);
2719 }
2720 }
2722 // Check if the line is moving relative to the float manager
2725 // Unconditionally reflow sliding blocks; we only really need to reflow
2726 // if there's a float impacting this block, but the current float manager
2727 // makes it difficult to check that. Therefore, we let the child block
2728 // decide what it needs to reflow.
2732 nsFlowAreaRect floatAvailableSpace =
2736 #ifdef REALLY_NOISY_REFLOW
2739 #endif
2741 // Mark the line dirty if it was or is affected by a float
2742 // We actually only really need to reflow if the amount of impact
2743 // changes, but that's not straightforward to check
2746 }
2747 }
2748 }
2749 }
2755 NS_BLOCK_HAS_CLEAR_CHILDREN) ||
2758 }
2760 /**
2761 * Reparent a whole list of floats from aOldParent to this block. The
2762 * floats might be taken from aOldParent's overflow list. They will be
2763 * removed from the list. They end up appended to our mFloats list.
2764 */
2768 nsFrameList list;
2775 }
2777 }
2778 }
2782 #ifdef DEBUG
2788 "line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} "
2789 "oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} "
2796 }
2797 #endif
2798 }
2804 }
2805 }
2807 }
2815 #ifdef DEBUG
2821 }
2823 #endif
2829 // Reflow our last line if our availableBSize has increased
2830 // so that we (and our last child) pull up content as necessary
2839 }
2840 }
2841 // the amount by which we will slide the current line if it is not
2842 // dirty
2845 // whether we did NOT reflow the previous line and thus we need to
2846 // recompute the carried out margin before the line if we want to
2847 // reflow it or if its previous margin is dirty
2849 // Float continuations were reflowed in ReflowPushedFloats
2854 // We save up information about BR-clearance here
2859 // Determine if children of this frame could have breaks between them for
2860 // page names.
2861 //
2862 // We need to check for paginated layout, the named-page pref, and if the
2863 // available block-size is constrained.
2864 //
2865 // Note that we need to check for paginated layout as named-pages are only
2866 // used during paginated reflow. We need to additionally check for
2867 // unconstrained block-size to avoid introducing fragmentation breaks during
2868 // "measuring" reflows within an overall paginated reflow, and to avoid
2869 // fragmentation in monolithic containers like 'inline-block'.
2870 //
2871 // Because we can only break for named pages using Class A breakpoints, we
2872 // also need to check that the block flow direction of the containing frame
2873 // of these items (which is this block) is parallel to that of this page.
2874 // See: https://www.w3.org/TR/css-break-3/#btw-blocks
2882 // ReflowInput.mFlags.mCanHaveClassABreakpoints should respect the named
2883 // pages pref and presCtx->IsPaginated, so we did not explicitly check these
2884 // above when setting canBreakForPageNames.
2887 "canBreakForPageNames should not be set during non-paginated "
2889 }
2891 // Reflow the lines that are already ours
2894 #ifdef DEBUG
2896 #endif
2900 }
2902 // This really sucks, but we have to look inside any blocks that have clear
2903 // elements inside them.
2904 // XXX what can we do smarter here?
2908 }
2914 }
2916 // We have to reflow the line if it's a block whose clearance
2917 // might have changed, so detect that.
2921 // See where we would be after applying any clearance due to
2922 // BRs.
2926 }
2932 // Reflow the line if it might not have clearance anymore.
2934 // aState.mBCoord is the clearance point which should be the
2935 // block-start border-edge of the block frame. If sliding the
2936 // block by deltaBCoord isn't going to put it in the predicted
2937 // position, then we'd better reflow the line.
2940 }
2942 // Reflow the line if the line might have clearance now.
2945 }
2946 }
2947 }
2949 // We might have to reflow a line that is after a clearing BR.
2954 // SlideLine is not going to put the line where the clearance
2955 // put it. Reflow the line to be sure.
2957 }
2959 }
2963 // If the previous margin is dirty, reflow the current line
2972 // Lines that aren't dirty but get slid past our available block-size
2973 // constraint must be reflowed.
2975 }
2976 }
2980 // Last column can be reflowed unconstrained during column balancing.
2981 // Hence the additional NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR bit check
2982 // as a fail-safe fallback.
2985 // Table can also be reflowed unconstrained during printing.
2988 // We are in a paginated context, i.e. in columns or pages.
2992 // The following if-else conditions check whether this line -- which
2993 // might have floats in its subtree, or has floats as direct children,
2994 // or had floats pushed -- needs to be reflowed.
2996 // The distance to the block-end edge might have changed. Reflow the
2997 // line both because the breakpoints within its floats may have
2998 // changed and because we might have to push/pull the floats in
2999 // their entirety.
3002 // We had pushed floats which haven't been drained by our
3003 // next-in-flow, which means our parent is currently reflowing us
3004 // again due to clearance without creating a next-in-flow for us.
3005 // Reflow the line to redo the floats split logic to correctly set
3006 // our reflow status.
3009 // Reflow the line (that may containing a float's placeholder frame)
3010 // if our parent tells us to do so.
3013 // Our parent's line containing us moved to a different fragment.
3014 // Reflow the line because the decision about whether the float fits
3015 // may be different in a different fragment.
3017 }
3018 }
3019 }
3020 }
3023 // See if there's any reflow damage that requires that we mark the
3024 // line dirty.
3026 }
3028 // If the container size has changed, reset mContainerSize. If the
3029 // line's writing mode is not ltr, or if the line is not left-aligned, also
3030 // mark the line dirty.
3041 }
3042 }
3044 // Check for a page break caused by CSS named pages.
3045 //
3046 // We should break for named pages when two frames meet at a class A
3047 // breakpoint, where the first frame has a different end page value to the
3048 // second frame's start page value. canBreakForPageNames is true iff
3049 // children of this frame can form class A breakpoints, and that we are not
3050 // in a measurement reflow or in a monolithic container such as
3051 // 'inline-block'.
3052 //
3053 // We specifically do not want to cause a page-break for named pages when
3054 // we are at the top of a page. This would otherwise happen when the
3055 // previous sibling is an nsPageBreakFrame, or all previous siblings on the
3056 // current page are zero-height. The latter may not be per-spec, but is
3057 // compatible with Chrome's implementation of named pages.
3065 // Walk back to the last frame that isn't a placeholder.
3069 }
3073 }
3074 }
3075 }
3078 // We need to reconstruct the block-end margin only if we didn't
3079 // reflow the previous line and we do need to reflow (or repair
3080 // the block-start position of) the next line.
3082 }
3088 // Update aState.mPrevChild as if we had reflowed all of the frames in
3089 // this line.
3095 }
3096 }
3098 // Now repair the line and update |aState.mBCoord| by calling
3099 // |ReflowLine| or |SlideLine|.
3100 // If we're going to reflow everything again, then no need to reflow
3101 // the dirty line ... unless the line has floats, in which case we'd
3102 // better reflow it now to refresh its float cache, which may contain
3103 // dangling frame pointers! Ugh! This reflow of the line may be
3104 // incorrect because we skipped reflowing previous lines (e.g., floats
3105 // may be placed incorrectly), but that's OK because we'll mark the
3106 // line dirty below under "if (aState.mReflowInput.mDiscoveredClearance..."
3114 // Compute the dirty lines "before" BEnd, after factoring in
3115 // the running deltaBCoord value - the running value is implicit in
3116 // aState.mBCoord.
3121 "Don't reflow blocks while willReflowAgain is true, reflow "
3125 // Immediately fragment for page-name. It is possible we could break
3126 // out of the loop right here, but this should make it more similar to
3127 // what happens when reflow causes fragmentation.
3132 // Reflow the dirty line. If it's an incremental reflow, then force
3133 // it to invalidate the dirty area if necessary
3135 }
3140 // Note that once we've entered this state, every line that gets here
3141 // (e.g. because it has floats) gets marked dirty and reflowed again.
3142 // in the next pass. This is important, see above.
3143 }
3147 }
3153 }
3155 }
3157 // Test to see whether the margin that should be carried out
3158 // to the next line (NL) might have changed. In ReflowBlockFrame
3159 // we call nextLine->MarkPreviousMarginDirty if the block's
3160 // actual carried-out block-end margin changed. So here we only
3161 // need to worry about the following effects:
3162 // 1) the line was just created, and it might now be blocking
3163 // a carried-out block-end margin from previous lines that
3164 // used to reach NL from reaching NL
3165 // 2) the line used to be empty, and is now not empty,
3166 // thus blocking a carried-out block-end margin from previous lines
3167 // that used to reach NL from reaching NL
3168 // 3) the line wasn't empty, but now is, so a carried-out
3169 // block-end margin from previous lines that didn't used to reach NL
3170 // now does
3171 // 4) the line might have changed in a way that affects NL's
3172 // ShouldApplyBStartMargin decision. The three things that matter
3173 // are the line's emptiness, its adjacency to the block-start edge of the
3174 // block, and whether it has clearance (the latter only matters if the
3175 // block was and is adjacent to the block-start and empty).
3176 //
3177 // If the line is empty now, we can't reliably tell if the line was empty
3178 // before, so we just assume it was and do
3179 // nextLine->MarkPreviousMarginDirty. This means the checks in 4) are
3180 // redundant; if the line is empty now we don't need to check 4), but if
3181 // the line is not empty now and we're sure it wasn't empty before, any
3182 // adjacency and clearance changes are irrelevant to the result of
3183 // nextLine->ShouldApplyBStartMargin.
3190 // since it's marked dirty, nobody will care about |deltaBCoord|
3191 }
3192 }
3194 // If the line was just reflowed for the first time, then its
3195 // old mBounds cannot be trusted so this deltaBCoord computation is
3196 // bogus. But that's OK because we just did
3197 // MarkPreviousMarginDirty on the next line which will force it
3198 // to be reflowed, so this computation of deltaBCoord will not be
3199 // used.
3202 // Now do an interrupt check. We want to do this only in the case when we
3203 // actually reflow the line, so that if we get back in here we'll get
3204 // further on the reflow before interrupting.
3208 // Nop except for blocks (we don't create overflow container
3209 // continuations for any inlines atm), so only checking mFirstChild
3210 // is enough
3218 }
3223 // If we're going to reflow everything again, and this line is a block,
3224 // then there is no need to recover float state. The line may contain
3225 // other lines with floats, but in that case RecoverStateFrom would only
3226 // add floats to the float manager. We don't need to do that because
3227 // everything's going to get reflowed again "for real". Calling
3228 // RecoverStateFrom in this situation could be lethal because the
3229 // block's descendant lines may have float caches containing dangling
3230 // frame pointers. Ugh!
3231 // If this line is inline, then we need to recover its state now
3232 // to make sure that we don't forget to move its floats by deltaBCoord.
3234 // XXX EVIL O(N^2) EVIL
3236 }
3238 // Keep mBCoord up to date in case we're propagating reflow damage
3239 // and also because our final height may depend on it. If the
3240 // line is inlines, then only update mBCoord if the line is not
3241 // empty, because that's what PlaceLine does. (Empty blocks may
3242 // want to update mBCoord, e.g. if they have clearance.)
3245 }
3251 // Need to make sure to pull overflows from any prev-in-flows
3255 }
3256 }
3257 }
3259 // Record if we need to clear floats before reflowing the next
3260 // line. Note that inlineFloatClearType will be handled and
3261 // cleared before the next line is processed, so there is no
3262 // need to combine break types here.
3265 }
3269 }
3275 // Another option here might be to leave |line| clean if
3276 // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
3277 // that case the line really did reflow as it should have. Not sure
3278 // whether that would be safe, so doing this for now instead. Also not
3279 // sure whether we really want to mark all lines dirty after an
3280 // interrupt, but until we get better at propagating float damage we
3281 // really do need to do it this way; see comments inside MarkLineDirty.
3283 }
3284 }
3286 // Handle BR-clearance from the last line of the block
3290 }
3293 // Is this expensive?
3296 // Update aState.mPrevChild as if we had reflowed all of the frames in
3297 // the last line.
3303 }
3305 // Should we really have to do this?
3308 }
3310 // We can skip trying to pull up the next line if our height is constrained
3311 // (so we can report being incomplete) and there is no next in flow or we
3312 // were told not to or we know it will be futile, i.e.,
3313 // -- the next in flow is not changing
3314 // -- and we cannot have added more space for its first line to be
3315 // pulled up into,
3316 // -- it's an incremental reflow of a descendant
3317 // -- and we didn't reflow any floats (so the available space
3318 // didn't change)
3319 // -- my chain of next-in-flows either has no first line, or its first
3320 // line isn't dirty.
3327 // We'll place lineIter at the last line of this block, so that
3328 // nsBlockInFlowLineIterator::Next() will take us to the first
3329 // line of my next-in-flow-chain. (But first, check that I
3330 // have any lines -- if I don't, just bail out of this
3331 // optimization.)
3337 // Check for next-in-flow-chain's first line.
3338 // (First, see if there is such a line, and second, see if it's clean)
3341 }
3342 }
3343 }
3351 }
3352 }
3355 // Pull data from a next-in-flow if there's still room for more
3356 // content here.
3358 // Grab first line from our next-in-flow
3361 nsFrameList pulledFrames;
3366 // Grab an overflow line if there are any
3372 }
3378 }
3379 }
3382 // The line is empty. Try the next one.
3388 }
3393 }
3396 }
3397 }
3408 // Shift pulledLine's frames into our mFrames list.
3411 // Add line to our line list, and set its last child as our new prev-child
3415 // Reparent floats whose placeholders are in the line.
3419 #ifdef DEBUG
3421 #endif
3426 // Now reflow it and any lines that it makes during it's reflow
3427 // (we have to loop here because reflowing the line may cause a new
3428 // line to be created; see SplitLine's callers for examples of
3429 // when this happens).
3438 }
3444 }
3446 }
3450 }
3455 }
3457 // If this is an inline frame then its time to stop
3460 }
3461 }
3462 }
3467 }
3469 // Handle an odd-ball case: a list-item with no lines
3481 // There are no lines so we have to fake up some y motion so that
3482 // we end up with *some* height.
3483 // (Note: if we're layout-contained, we have to be sure to leave our
3484 // ReflowOutput's BlockStartAscent() (i.e. the baseline) untouched,
3485 // because layout-contained frames have no baseline.)
3488 nscoord ascent;
3494 }
3495 }
3511 }
3512 }
3513 }
3517 }
3523 }
3525 #ifdef DEBUG
3533 }
3534 #endif
3535 }
3540 // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
3541 // marked the lines that need to be marked dirty based on our
3542 // vertical resize stuff. So we'll definitely reflow all those kids;
3543 // the only question is how they should behave.
3545 // Mark all our child frames dirty so we make sure to reflow them
3546 // later.
3551 }
3552 // And mark all the floats whose reflows we might be skipping dirty too.
3556 }
3557 }
3559 // Dirty all the descendant lines of block kids to handle float damage,
3560 // since our nsFloatManager will go away by the next time we're reflowing.
3561 // XXXbz Can we do something more like what PropagateFloatDamage does?
3562 // Would need to sort out the exact business with mBlockDelta for that....
3563 // This marks way too much dirty. If we ever make this better, revisit
3564 // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
3568 }
3569 }
3570 }
3578 "using function more generally than designed, "
3583 // Mark the previous margin of the next line dirty since we need to
3584 // recompute its top position.
3587 }
3588 }
3589 }
3591 /**
3592 * Reflow a line. The line will either contain a single block frame
3593 * or contain 1 or more inline frames. aKeepReflowGoing indicates
3594 * whether or not the caller should continue to reflow more lines.
3595 */
3600 // Setup the line-layout for the new line
3606 // If this line contains a single block that is hidden by `content-visibility`
3607 // don't reflow the line. If this line contains inlines and the first one is
3608 // hidden by `content-visibility`, all of them are, so avoid reflow in that
3609 // case as well.
3610 // For frames that own anonymous children, even the first child is hidden by
3611 // `content-visibility`, there could be some anonymous children need reflow,
3612 // so we don't skip reflow this line.
3617 }
3619 // Now that we know what kind of line we have, reflow it
3626 // Store the line's float edges for overflow marker analysis if needed.
3638 // This line is overlapping a float - store the edges marking the area
3639 // between the floats for text-overflow analysis.
3641 }
3642 }
3643 }
3644 }
3647 }
3650 LineIterator aLine) {
3651 // First check our remaining lines.
3654 }
3660 // Try each next-in-flow.
3665 }
3668 }
3671 }
3674 }
3690 // If our line is not empty and the child in aFromLine is a block
3691 // then we cannot pull up the frame into this line. In this case
3692 // we stop pulling.
3694 }
3695 // Take frame from fromLine
3700 // The frame is being pulled from a next-in-flow; therefore we need to add
3701 // it to our sibling list.
3707 // When pushing and pulling frames we need to check for whether any
3708 // views need to be reparented.
3712 // The frame might have (or contain) floats that need to be brought
3713 // over too. (pass 'false' since there are no siblings to check)
3717 }
3723 // Mark line dirty now that we pulled a child
3727 // Free up the fromLine now that it's empty.
3728 // Its bounds might need to be redrawn, though.
3731 }
3733 // aFromLine is now invalid
3735 }
3737 #ifdef DEBUG
3740 #endif
3743 }
3746 nscoord aDeltaBCoord) {
3749 // Adjust line state
3752 // Adjust the frames in the line
3754 }
3760 }
3762 // Adjust line state
3765 // Changing container width only matters if writing mode is vertical-rl
3768 }
3769 }
3772 nscoord aDeltaBCoord) {
3773 // Adjust the frames in the line
3777 }
3785 }
3787 // Make sure the frame's view and any child views are updated
3790 // Adjust the block-dir coordinate of the frames in the line.
3791 // Note: we need to re-position views even if aDeltaBCoord is 0, because
3792 // one of our parent frames may have moved and so the view's position
3793 // relative to its parent may have changed.
3798 }
3799 // Make sure the frame's view and any child views are updated
3802 }
3803 }
3804 }
3807 // The "extremum length" values (see ExtremumLength) were originally aimed at
3808 // inline-size (or width, as it was before logicalization). For now, let them
3809 // return false here, so we treat them like 'auto' pending a real
3810 // implementation. (See bug 1126420.)
3811 //
3812 // FIXME (bug 567039, bug 527285) This isn't correct for the 'fill' value,
3813 // which should more likely (but not necessarily, depending on the available
3814 // space) be returning true.
3817 }
3819 // If we evaluate the length/percent/calc at a percentage basis of
3820 // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
3821 // length, percent, or combination thereof. Test > 0 so we clamp
3822 // negative calc() results to 0.
3825 }
3827 /* virtual */
3831 }
3833 // Blocks which are margin-roots (including inline-blocks) cannot be treated
3834 // as empty for margin-collapsing and other purposes. They're more like
3835 // replaced elements.
3838 }
3846 }
3848 // FIXME: Bug 1646100 - Take intrinsic size into account.
3849 // FIXME: Handle the case that both inline and block sizes are auto.
3850 // https://github.com/w3c/csswg-drafts/issues/5060.
3851 // Note: block-size could be zero or auto/intrinsic keywords here.
3855 }
3866 }
3870 }
3873 }
3878 }
3882 }
3883 }
3885 }
3890 }
3893 }
3898 // A page break frame consumes margins adjacent to it.
3899 // https://drafts.csswg.org/css-break/#break-margins
3901 }
3904 // Apply short-circuit check to avoid searching the line list
3906 }
3909 // If we aren't at the start block-coordinate then something of non-zero
3910 // height must have been placed. Therefore the childs block-start margin
3911 // applies.
3914 }
3916 // Determine if this line is "essentially" the first line
3920 }
3923 // A line which precedes aLine is non-empty, or has clearance,
3924 // so therefore the block-start margin applies.
3927 }
3928 // No need to apply the block-start margin if the line has floats. We
3929 // should collapse anyway (bug 44419)
3933 }
3935 // The line being reflowed is "essentially" the first line in the
3936 // block. Therefore its block-start margin will be collapsed by the
3937 // generational collapsing logic with its parent (us).
3939 }
3942 LineIterator aLine,
3950 }
3952 // If the previous frame was a page-break-frame, then preemptively push this
3953 // frame to the next page.
3954 // This is primarily important for the placeholders for abspos frames, which
3955 // measure as zero height and then would be placed on this page.
3961 }
3962 }
3964 // Prepare the block reflow engine
3972 }
3974 // Clear past floats before the block if the clear style is not none
3978 }
3980 // See if we should apply the block-start margin. If the block frame being
3981 // reflowed is a continuation, then we don't apply its block-start margin
3982 // because it's not significant. Otherwise, dig deeper.
3986 // The HasClearance setting is only valid if ShouldApplyBStartMargin
3987 // returned false (in which case the block-start margin-root set our
3988 // clearance flag). Otherwise clear it now. We'll set it later on
3989 // ourselves if necessary.
3991 }
3999 }
4001 // If our block-start margin was counted as part of some parent's block-start
4002 // margin collapse, and we are being speculatively reflowed assuming this
4003 // frame DID NOT need clearance, then we need to check that
4004 // assumption.
4013 // Only record the first frame that requires clearance
4016 }
4018 // Exactly what we do now is flexible since we'll definitely be
4019 // reflowed.
4021 }
4022 }
4025 }
4030 nscoord clearance;
4031 // Save the original position of the frame so that we can reposition
4032 // its view as needed.
4041 // Precompute the blocks block-start margin value so that we can get the
4042 // correct available space (there might be a float that's
4043 // already been placed below the aState.mPrevBEndMargin
4045 // Setup a reflowInput to get the style computed block-start margin
4046 // value. We'll use a reason of `resize' so that we don't fudge
4047 // any incremental reflow input.
4049 // The availSpace here is irrelevant to our needs - all we want
4050 // out if this setup is the block-start margin value which doesn't depend
4051 // on the childs available space.
4052 // XXX building a complete ReflowInput just to get the block-start
4053 // margin seems like a waste. And we do this for almost every block!
4057 availSpace);
4062 }
4064 // Now compute the collapsed margin-block-start value into
4065 // aState.mPrevBEndMargin, assuming that all child margins
4066 // collapse down to clearanceFrame.
4070 // XXX optimization; we could check the collapsing children to see if they
4071 // are sure to require clearance, and so avoid retrying them
4074 // Don't allow retries on the second pass. The clearance decisions for
4075 // the blocks whose block-start margins collapse with ours are now
4076 // fixed.
4078 }
4081 // We don't know if we need clearance and this is the first,
4082 // optimistic pass. So determine whether *this block* needs
4083 // clearance. Note that we do not allow the decision for whether
4084 // this block has clearance to change on the second pass; that
4085 // decision is only allowed to be made under the optimistic
4086 // first pass.
4093 // Looks like we need clearance and we didn't know about it already.
4094 // So recompute collapsed margin
4096 // Remember this decision, needed for incremental reflow
4099 // Apply incoming margins
4103 // Compute the collapsed margin again, ignoring the incoming margin
4104 // this time
4108 }
4109 }
4111 // Temporarily advance the running block-direction value so that the
4112 // GetFloatAvailableSpace method will return the right available space.
4113 // This undone as soon as the horizontal margins are computed.
4118 // advance mBCoord to the clear position.
4124 clearedPushedOrSplitFloat =
4127 // Compute clearance. It's the amount we need to add to the block-start
4128 // border-edge of the frame, after applying collapsed margins
4129 // from the frame and its children, to get it to line up with
4130 // the block-end of the floats. The former is
4131 // currentBCoord + bStartMargin, the latter is the current
4132 // aState.mBCoord.
4133 // Note that negative clearance is possible
4136 // Add clearance to our block-start margin while we compute available
4137 // space for the frame
4140 // Note that aState.mBCoord should stay where it is: at the block-start
4141 // border-edge of the frame
4143 // Advance aState.mBCoord to the block-start border-edge of the frame.
4145 }
4146 }
4150 // Here aState.mBCoord is the block-start border-edge of the block.
4151 // Compute the available space for the block
4157 // The check for
4158 // (!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats)
4159 // is to some degree out of paranoia: if we reliably eat up block-start
4160 // margins at the top of the page as we ought to, it wouldn't be
4161 // needed.
4164 // We know already that this child block won't fit on this
4165 // page/column due to the block-start margin or the clearance. So we
4166 // need to get out of here now. (If we don't, most blocks will handle
4167 // things fine, and report break-before, but zero-height blocks
4168 // won't, and will thus make their parent overly-large and force
4169 // *it* to be pushed in its entirety.)
4176 }
4178 }
4180 // Now put the block-dir coordinate back to the start of the
4181 // block-start-margin + clearance.
4186 }
4188 // Construct the reflow input for the block.
4194 // Calculate the multicol containing block's block size so that the
4195 // children with percentage block size get correct percentage basis.
4201 // Use column-width as the containing block's inline-size, i.e. the column
4202 // content's computed inline-size.
4207 // If a ColumnSetWrapper is in a balancing column content, it may be
4208 // pushed or pulled back and forth between column contents. Always add
4209 // NS_FRAME_HAS_DIRTY_CHILDREN bit to it so that its ColumnSet children
4210 // can have a chance to reflow under current block size constraint.
4214 }
4216 // If we are reflowing our ColumnSet children, we want to apply our block
4217 // size constraint to the available block size when constructing reflow
4218 // input for ColumnSet so that ColumnSet can use it to compute its max
4219 // column block size.
4223 contentBSize =
4225 }
4227 // To get the remaining content block-size, subtract the content
4228 // block-size consumed by our previous continuations.
4231 // ColumnSet is not the outermost frame in the column container, so it
4232 // cannot have any margin. We don't need to consider any margin that
4233 // can be generated by "box-decoration-break: clone" as we do in
4234 // BlockReflowState::ComputeBlockAvailSpace().
4240 }
4241 }
4242 }
4243 }
4247 cbSize);
4250 columnSetWrapperHasNoBSizeLeft;
4253 // We only need to set this the first reflow, since if we reflow
4254 // again (and replace childReflowInput) we'll be reflowing it
4255 // again in the same fragment as the previous time.
4257 }
4260 nsReflowStatus frameReflowStatus;
4263 // Set if floatAvailableSpace.HasFloats() is true for any
4264 // iteration of the loop.
4266 }
4268 // We might need to store into mDiscoveredClearance later if it's
4269 // currently null; we want to overwrite any writes that
4270 // brc.ReflowBlock() below does, so we need to remember now
4271 // whether it's empty.
4276 // Reflow the block into the available space
4279 }
4286 }
4294 // No need to retry this loop if there is a break opportunity before the
4295 // child block.
4297 }
4299 // Now the block has a height. Using that height, get the
4300 // available space again and call ComputeBlockAvailSpace again.
4301 // If ComputeBlockAvailSpace gives a different result, we need to
4302 // reflow again.
4305 }
4314 // Restore the height to the position of the next band.
4317 // Determine whether the available space shrunk on either side,
4318 // because (the first time round) we now know the block's height,
4319 // and it may intersect additional floats, or (on later
4320 // iterations) because narrowing the width relative to the
4321 // previous time may cause the block to become taller. Note that
4322 // since we're reflowing the block, narrowing the width might also
4323 // make it shorter, so we must pass aCanGrow as true.
4326 // The size and position we chose before are fine (i.e., they
4327 // don't cause intersecting with floats that requires a change
4328 // in size or position), so we're done.
4330 }
4334 floatAvailableSpace)) {
4335 // Advance to the next band.
4339 }
4340 // ClearFloats might be able to advance us further once we're there.
4344 // Start over with a new available space rect at the new height.
4347 }
4355 }
4357 // We need another reflow.
4362 // We set shouldStoreClearance above to record only the first
4363 // frame that requires clearance.
4366 }
4368 // Exactly what we do now is flexible since we'll definitely be
4369 // reflowed.
4371 }
4374 // We're pushing down the border-box, so we don't apply margin anymore.
4375 // This should never cause us to move up since the call to
4376 // GetFloatAvailableSpaceForBSize above included the margin.
4381 }
4390 // Found a clearance frame, so we need to reflow |frame| a second time.
4391 // Restore the states and start over again.
4396 }
4401 // If an ancestor of ours is going to reflow for clearance, we
4402 // need to avoid calling PlaceBlock, because it unsets dirty bits
4403 // on the child block (both itself, and through its call to
4404 // nsIFrame::DidReflow), and those dirty bits imply dirtiness for
4405 // all of the child block, including the lines it didn't reflow.
4409 }
4411 #if defined(REFLOW_STATUS_COVERAGE)
4413 #endif
4416 // None of the child block fits.
4421 }
4423 // Note: line-break-after a block is a nop
4425 // Try to place the child block.
4426 // Don't force the block to fit if we have positive clearance, because
4427 // pushing it to the next page would give it more room.
4428 // Don't force the block to fit if it's impacted by a float. If it is,
4429 // then pushing it to the next page would give it more room. Note that
4430 // isImpacted doesn't include impact from the block's own floats.
4433 nsCollapsingMargin collapsedBEndMargin;
4434 OverflowAreas overflowAreas;
4442 }
4449 }
4450 }
4454 // Some of the child block fit
4456 // Advance to new Y position
4460 // Continue the block frame now if it didn't completely fit in
4461 // the available space.
4470 // If nextFrame used to be an overflow container, make it a normal
4471 // block
4480 }
4485 }
4487 // Push continuation to a new line, but only if we actually made
4488 // one.
4492 }
4496 // If we need to reflow the continuation of the block child,
4497 // then we'd better reflow our continuation
4500 // We also need to make that continuation's line dirty so
4501 // it gets reflowed when we reflow our next in flow. The
4502 // nif's line must always be either a line of the nif's
4503 // parent block (only if we didn't make a continuation) or
4504 // else one of our own overflow lines. In the latter case
4505 // the line is already marked dirty, so just handle the
4506 // first case.
4510 nifBlock,
4516 }
4517 }
4518 }
4519 }
4521 // The block-end margin for a block is only applied on the last
4522 // flow block. Since we just continued the child block frame,
4523 // we know that line->mFirstChild is not the last flow block
4524 // therefore zero out the running margin value.
4525 #ifdef NOISY_BLOCK_DIR_MARGINS
4531 #endif
4534 // Disconnect the next-in-flow and put it in our overflow tracker
4537 // It already exists, but as a normal next-in-flow, so we need
4538 // to dig it out of the child lists.
4542 }
4544 // Put it in our overflow list
4548 #ifdef NOISY_BLOCK_DIR_MARGINS
4554 #endif
4556 }
4558 #ifdef NOISY_BLOCK_DIR_MARGINS
4564 #endif
4566 }
4567 #ifdef NOISY_BLOCK_DIR_MARGINS
4574 #endif
4577 // The frame reported an incomplete status, but then it also didn't
4578 // fit. This means we need to reflow it again so that it can
4579 // (again) report the incomplete status.
4581 }
4585 // If it's our very first line *or* we're not at the top of the page
4586 // and we have page-break-inside:avoid, then we need to be pushed to
4587 // our parent's next-in-flow.
4590 // Push the line that didn't fit and any lines that follow it
4591 // to our next-in-flow.
4593 }
4594 }
4595 }
4597 }
4599 // Now that we've got its final position all figured out, position any child
4600 // views it may have. Note that the case when frame has a view got handled
4601 // by FinishReflowChild, but that function didn't have the coordinates needed
4602 // to correctly decide whether to reposition child views.
4605 }
4607 #ifdef DEBUG
4609 #endif
4610 }
4613 LineIterator aLine,
4619 // Setup initial coordinate system for reflowing the inline frames
4620 // into. Apply a previous block frame's block-end margin first.
4623 }
4626 LineReflowStatus lineReflowStatus;
4639 // Once upon a time we allocated the first 30 nsLineLayout objects
4640 // on the stack, and then we switched to the heap. At that time
4641 // these objects were large (1100 bytes on a 32 bit system).
4642 // Then the nsLineLayout object was shrunk to 156 bytes by
4643 // removing some internal buffers. Given that it is so much
4644 // smaller, the complexity of 2 different ways of allocating
4645 // no longer makes sense. Now we always allocate on the stack.
4651 }
4663 // If there is no saved break position, then this will set
4664 // set forceBreakInFrame to null and we won't back up, which is
4665 // correct.
4670 }
4671 // restore the float manager state
4673 // Clear out float lists
4677 }
4679 // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
4684 }
4687 LineIterator aLine,
4690 // Reflow the line again when we reflow at our new position.
4693 }
4696 LineIterator aLine,
4701 }
4708 // Forget all of the floats on the line
4712 // We need to set this flag on the line if any of our reflow passes
4713 // are impacted by floats.
4716 }
4717 #ifdef REALLY_NOISY_REFLOW
4720 #endif
4729 nscoord availBSize;
4733 /* XXX get the height right! */
4735 }
4737 // Make sure to enable resize optimization before we call BeginLineReflow
4738 // because it might get disabled there
4748 // XXX Unfortunately we need to know this before reflowing the first
4749 // inline frame in the line. FIX ME.
4752 NS_BLOCK_HAS_FIRST_LETTER_STYLE)) {
4754 }
4759 // Reflow the frames that are already on the line first
4765 // There is a soft break opportunity at the start of the line, because
4766 // we can always move this line down below float(s).
4770 }
4771 }
4773 // need to repeatedly call GetChildCount here, because the child
4774 // count can change during the loop!
4780 // It is possible that one or more of next lines are empty
4781 // (because of DeleteNextInFlowChild). If so, delete them now
4782 // in case we are finished.
4785 // XXX Is this still necessary now that DeleteNextInFlowChild
4786 // uses DoRemoveFrame?
4791 }
4795 "ReflowInlineFrame should never determine that a line "
4797 }
4798 }
4800 // Don't pull up new frames into lines with continuation placeholders
4802 // Pull frames and reflow them until we can't
4807 }
4813 // We just created a continuation for aFrame AND its going
4814 // to end up on this line (e.g. :first-letter
4815 // situation). Therefore we have to loop here before trying
4816 // to pull another frame.
4820 }
4821 }
4822 }
4823 }
4827 // We only need to backup if the line isn't going to be reflowed again anyway
4833 "We shouldn't be backing up more than once! "
4834 "Someone must have set a break opportunity beyond the available width, "
4837 }
4839 // We need to try backing up to before a text run
4840 // XXX It's possible, in fact not unusual, for the break opportunity to
4841 // already be the end of the line. We should detect that and optimize to not
4842 // re-do the line.
4844 // We can back up!
4846 }
4848 // In case we reflow this line again, remember that we don't
4849 // need to force any breaking
4851 }
4854 // This happens only when we have a line that is impacted by
4855 // floats and the first element in the line doesn't fit with
4856 // the floats.
4857 //
4858 // If there's block space available, we either try to reflow the line
4859 // past the current band (if it's non-zero and the band definitely won't
4860 // widen around a shape-outside), otherwise we try one pixel down. If
4861 // there's no block space available, we push the line to the next
4862 // page/column.
4867 // See the analogous code for blocks in BlockReflowState::ClearFloats.
4873 // We should never hit this case if we've placed floats on the
4874 // line; if we have, then the GetFloatAvailableSpace call is wrong
4875 // and needs to happen after the caller pops the float manager
4876 // state.
4880 // Move it down far enough to clear the current band.
4883 // Move it down by one dev pixel.
4885 }
4889 // There's nowhere to retry placing the line, so we want to push
4890 // it to the next page/column where its contents can fit not
4891 // next to a float.
4894 }
4896 // XXX: a small optimization can be done here when paginating:
4897 // if the new Y coordinate is past the end of the block then
4898 // push the line and return now instead of later on after we are
4899 // past the float.
4902 // If we are propagating out a break-before status then there is
4903 // no point in placing the line.
4907 aKeepReflowGoing)) {
4909 // PlaceLine already called GetFloatAvailableSpaceForBSize or its
4910 // variant for us.
4911 }
4912 }
4913 }
4914 #ifdef DEBUG
4918 }
4919 #endif
4922 // aLine may have been pushed to the overflow lines.
4924 // We can't just compare iterators front() to aLine here, since they may be
4925 // in different lists.
4929 // aLine is stale, it's associated with the main line list but it should
4930 // be associated with the overflow line list now
4932 }
4938 }
4939 }
4940 }
4943 }
4945 /**
4946 * Reflow an inline frame. The reflow status is mapped from the frames
4947 * reflow status to the lines reflow status (not to our reflow status).
4948 * The line reflow status is simple: true means keep placing frames
4949 * on the line; false means don't (the line is done). If the line
4950 * has some sort of breaking affect then aLine's break-type will be set
4951 * to something other than StyleClear::None.
4952 */
4960 #ifdef NOISY_FIRST_LETTER
4966 #endif
4971 }
4973 // Reflow the inline frame
4974 nsReflowStatus frameReflowStatus;
4980 }
4982 #ifdef REALLY_NOISY_REFLOW
4985 #endif
4987 #if defined(REFLOW_STATUS_COVERAGE)
4989 #endif
4991 // Send post-reflow notification
4994 /* XXX
4995 This is where we need to add logic to handle some odd behavior.
4996 For one thing, we should usually place at least one thing next
4997 to a left float, even when that float takes up all the width on a line.
4998 see bug 22496
4999 */
5001 // Process the child frames reflow status. There are 5 cases:
5002 // complete, not-complete, break-before, break-after-complete,
5003 // break-after-not-complete. There are two situations: we are a
5004 // block or we are an inline. This makes a total of 10 cases
5005 // (fortunately, there is some overlap).
5009 // Always abort the line reflow (because a line break is the
5010 // minimal amount of break we do).
5013 // XXX what should aLine's break-type be set to in all these cases?
5015 // Break-before cases.
5017 // If we break before the first frame on the line then we must
5018 // be trying to place content where there's no room (e.g. on a
5019 // line with wide floats). Inform the caller to reflow the
5020 // line after skipping past a float.
5023 // It's not the first child on this line so go ahead and split
5024 // the line. We will see the frame again on the next-line.
5027 // If we're splitting the line because the frame didn't fit and it
5028 // was pushed, then mark the line as having word wrapped. We need to
5029 // know that if we're shrink wrapping our width
5032 }
5033 }
5039 // If a float split and its prev-in-flow was followed by a <BR>, then
5040 // combine the <BR>'s float clear type with the inline's float clear type
5041 // (the inline will be the very next frame after the split float).
5047 }
5048 // Break-after cases
5051 }
5053 // Split line, but after the frame just reflowed
5055 aLineReflowStatus);
5060 }
5061 }
5062 }
5063 }
5066 // Create a continuation for the incomplete frame. Note that the
5067 // frame may already have a continuation.
5070 // Remember that the line has wrapped
5073 }
5075 // If we just ended a first-letter frame or reflowed a placeholder then
5076 // don't split the line and don't stop the line reflow...
5077 // But if we are going to stop anyways we'd better split the line.
5081 // Split line after the current frame
5084 aLineReflowStatus);
5085 }
5086 }
5087 }
5094 newFrame =
5101 }
5102 }
5103 #ifdef DEBUG
5105 #endif
5107 }
5121 }
5124 }
5126 nextInFlow =
5128 }
5131 }
5139 }
5147 }
5148 }
5154 }
5163 }
5164 }
5167 }
5179 #ifdef DEBUG
5188 }
5192 }
5193 }
5194 #endif
5199 #ifdef DEBUG
5200 {
5206 }
5208 }
5209 #endif
5211 // Put frames being split out into their own line
5214 #ifdef DEBUG
5217 }
5218 #endif
5220 // Let line layout know that some frames are no longer part of its
5221 // state.
5224 // If floats have been placed whose placeholders have been pushed to the new
5225 // line, we need to reflow the old line again. We don't want to look at the
5226 // frames in the new line, because as a large paragraph is laid out the
5227 // we'd get O(N^2) performance. So instead we just check that the last
5228 // float and the last below-current-line float are still in aLine.
5236 }
5238 #ifdef DEBUG
5240 #endif
5241 }
5242 }
5246 // There is another line
5248 // If the next line is a block line then this line is the last in a
5249 // group of inline lines.
5251 }
5252 // The next line is empty, try the next one
5253 }
5255 // Try our next-in-flows lines to answer the question
5261 }
5262 }
5264 }
5266 // This is the last line - so don't allow justification
5268 }
5276 // Try to position the floats in a nowrap context.
5279 // Trim extra white-space from the line before placing the frames
5282 // Vertically align the frames on this line.
5283 //
5284 // According to the CSS2 spec, section 12.6.1, the "marker" box
5285 // participates in the height calculation of the list-item box's
5286 // first line box.
5287 //
5288 // There are exactly two places a ::marker can be placed: near the
5289 // first or second line. It's only placed on the second line in a
5290 // rare case: when the first line is empty.
5305 }
5308 // We want to consider the floats in the current line when determining
5309 // whether the float available space is shrunk. If mLineBSize doesn't
5310 // exist, we are in the first pass trying to place the line. Calling
5311 // GetFloatAvailableSpace() like we did in BlockReflowState::AddFloat()
5312 // for UpdateBand().
5314 // floatAvailableSpaceWithOldLineBSize is the float available space with
5315 // the old BSize, but including the floats that were added in this line.
5316 LogicalRect floatAvailableSpaceWithOldLineBSize =
5319 : aState
5324 // As we redo for floats, we can't reduce the amount of BSize we're
5325 // checking.
5327 LogicalRect floatAvailableSpaceWithLineBSize =
5328 aState
5333 // If the available space between the floats is smaller now that we
5334 // know the BSize, return false (and cause another pass with
5335 // LineReflowStatus::RedoMoreFloats). We ensure aAvailableSpaceBSize
5336 // never decreases, which means that we can't reduce the set of floats
5337 // we intersect, which means that the available space cannot grow.
5340 // Prepare data for redoing the line.
5343 // Since we want to redo the line, we update aFlowArea by using the
5344 // aFloatStateBeforeLine, which is the float manager's state before the
5345 // line is placed.
5353 // Restore the BSize to the position of the next band.
5356 // Enforce both IStart() and IEnd() never move outwards to prevent
5357 // infinite grow-shrink loops.
5365 }
5368 }
5371 }
5373 #ifdef DEBUG
5383 }
5386 }
5387 }
5388 #endif
5390 // Only block frames horizontally align their children because
5391 // inline frames "shrink-wrap" around their children (therefore
5392 // there is no extra horizontal space).
5395 /**
5396 * We don't care checking for IsLastLine properly if we don't care (if it
5397 * can't change the used text-align value for the line).
5398 *
5399 * In other words, isLastLine really means isLastLineAndWeCare.
5400 */
5408 // From here on, pfd->mBounds rectangles are incorrect because bidi
5409 // might have moved frames around!
5410 OverflowAreas overflowAreas;
5415 }
5417 // Inline lines do not have margins themselves; however they are
5418 // impacted by prior block margins. If this line ends up having some
5419 // height then we zero out the previous block-end margin value that was
5420 // already applied to the line's starting Y coordinate. Otherwise we
5421 // leave it be so that the previous blocks block-end margin can be
5422 // collapsed with a block that follows.
5423 nscoord newBCoord;
5426 // This line has some height. Therefore the application of the
5427 // previous-bottom-margin should stick.
5431 // Don't let the previous-bottom-margin value affect the newBCoord
5432 // coordinate (it was applied in ReflowInlineFrames speculatively)
5433 // since the line is empty.
5434 // We already called |ShouldApplyBStartMargin|, and if we applied it
5435 // then mShouldApplyBStartMargin is set.
5440 }
5447 }
5449 // See if the line fit (our first line always does).
5455 // All our content doesn't fit, start on the next page.
5458 // Push aLine and all of its children and anything else that
5459 // follows to our next-in-flow.
5461 }
5463 }
5465 // Note that any early return before this update of aState.mBCoord
5466 // must either (a) return false or (b) set aKeepReflowGoing to false.
5467 // Otherwise we'll keep reflowing later lines at an incorrect
5468 // position, and we might not come back and clean up the damage later.
5471 // Add the already placed current-line floats to the line
5474 // Any below current line floats to place?
5476 // Reflow the below-current-line floats, which places on the line's
5477 // float list.
5479 }
5481 // When a line has floats, factor them into the overflow areas computations.
5483 // Union the float overflow areas (stored in aState) and the value computed
5484 // by the line layout code.
5489 #ifdef NOISY_OVERFLOW_AREAS
5494 #endif
5495 }
5497 // Apply break-after clearing if necessary
5498 // This must stay in sync with |ReflowDirtyLines|.
5502 }
5504 }
5508 // NOTE: aLineBefore is always a normal line, not an overflow line.
5509 // The following expression will assert otherwise.
5514 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
5518 // Remove floats in the lines from mFloats
5519 nsFrameList floats;
5523 #ifdef DEBUG
5527 }
5528 #endif
5529 // Push the floats onto the front of the overflow out-of-flows list
5532 }
5534 // overflow lines can already exist in some cases, in particular,
5535 // when shrinkwrapping and we discover that the shrinkwap causes
5536 // the height of some child block to grow which creates additional
5537 // overflowing content. In such cases we must prepend the new
5538 // overflow to the existing overflow.
5541 // XXXldb use presshell arena!
5543 }
5553 }
5561 // this takes ownership but it won't delete it immediately so we
5562 // can keep using it.
5565 // Mark all the overflow lines dirty so that they get reflowed when
5566 // they are pulled up by our next-in-flow.
5568 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
5578 }
5579 }
5580 }
5581 }
5583 #ifdef DEBUG
5585 #endif
5586 }
5588 // The overflowLines property is stored as a pointer to a line list,
5589 // which must be deleted. However, the following functions all maintain
5590 // the invariant that the property is never set if the list is empty.
5593 #ifdef DEBUG
5595 #endif
5597 // Steal the prev-in-flow's overflow lines and prepend them.
5604 // Make all the frames on the overflow line list mine.
5607 // Collect overflow containers from our OverflowContainers list that are
5608 // continuations from the frames we picked up from our prev-in-flow, then
5609 // prepend those to ExcessOverflowContainers to ensure the continuations
5610 // are ordered.
5612 nsFrameList ocContinuations;
5624 }
5626 }
5629 }
5630 }
5636 }
5637 }
5638 }
5640 // Make the overflow out-of-flow frames mine too.
5643 // In case we own any next-in-flows of any of the drained frames, then
5644 // move those to the PushedFloat list.
5645 nsFrameList pushedFloats;
5652 }
5653 }
5659 }
5660 }
5663 // Remember to recompute the margins on the first line. This will
5664 // also recompute the correct deltaBCoord if necessary.
5666 }
5667 // The overflow lines have already been marked dirty and their previous
5668 // margins marked dirty also.
5670 // Prepend the overflow frames/lines to our principal list.
5676 }
5677 }
5679 // Now append our own overflow lines.
5681 }
5687 }
5689 // No need to reparent frames in our own overflow lines/oofs, because they're
5690 // already ours. But we should put overflow floats back in mFloats.
5691 // (explicit scope to remove the OOF list before VerifyOverflowSituation)
5692 {
5695 #ifdef DEBUG
5699 }
5700 #endif
5701 // The overflow floats go after our regular floats.
5703 }
5704 }
5708 }
5710 #ifdef DEBUG
5712 #endif
5714 }
5716 /**
5717 * Pushed floats are floats whose placeholders are in a previous
5718 * continuation. They might themselves be next-continuations of a float
5719 * that partially fit in an earlier continuation, or they might be the
5720 * first continuation of a float that couldn't be placed at all.
5721 *
5722 * Pushed floats live permanently at the beginning of a block's float
5723 * list, where they must live *before* any floats whose placeholders are
5724 * in that block.
5725 *
5726 * Temporarily, during reflow, they also live on the pushed floats list,
5727 * which only holds them between (a) when one continuation pushes them to
5728 * its pushed floats list because they don't fit and (b) when the next
5729 * continuation pulls them onto the beginning of its float list.
5730 *
5731 * DrainPushedFloats sets up pushed floats the way we need them at the
5732 * start of reflow; they are then reflowed by ReflowPushedFloats (which
5733 * might push some of them on). Floats with placeholders in this block
5734 * are reflowed by (BlockReflowState/nsLineLayout)::AddFloat, which
5735 * also maintains these invariants.
5736 *
5737 * DrainSelfPushedFloats moves any pushed floats from this block's own
5738 * PushedFloats list back into mFloats. DrainPushedFloats additionally
5739 * moves frames from its prev-in-flow's PushedFloats list into mFloats.
5740 */
5742 // If we're getting reflowed multiple times without our
5743 // next-continuation being reflowed, we might need to pull back floats
5744 // that we just put in the list to be pushed to our next-in-flow.
5745 // We don't want to pull back any next-in-flows of floats on our own
5746 // float list, and we only need to pull back first-in-flows whose
5747 // placeholders were in earlier blocks (since first-in-flows whose
5748 // placeholders are in this block will get pulled appropriately by
5749 // AddFloat, and will then be more likely to be in the correct order).
5753 // When we pull back floats, we want to put them with the pushed
5754 // floats, which must live at the start of our float list, but we
5755 // want them at the end of those pushed floats.
5756 // FIXME: This isn't quite right! What if they're all pushed floats?
5762 }
5772 // This is a first continuation that was pushed from one of our
5773 // previous continuations. Take it out of the pushed floats
5774 // list and put it in our floats list, before any of our
5775 // floats, but after other pushed floats.
5778 }
5781 }
5785 }
5786 }
5787 }
5792 // After our prev-in-flow has completed reflow, it may have a pushed
5793 // floats list, containing floats that we need to own. Take these.
5799 }
5800 }
5801 }
5806 }
5815 }
5820 }
5830 }
5839 }
5841 // This takes ownership of aOverflowLines.
5842 // XXX We should allocate overflowLines from presShell arena!
5852 // Verify that we won't overwrite an existing overflow list
5856 }
5861 }
5865 }
5876 }
5890 }
5891 }
5896 }
5901 }
5906 }
5911 }
5916 }
5921 }
5925 }
5931 }
5938 }
5943 }
5948 }
5950 //////////////////////////////////////////////////////////////////////
5951 // Frame list manipulation routines
5956 }
5962 }
5965 }
5967 // Find the proper last-child for where the append should go
5973 #ifdef NOISY_REFLOW_REASON
5978 }
5982 }
5984 #endif
5989 // Workaround for bug 1399425 in case this bit has been removed from the
5990 // SVGTextFrame just before the parser adds more descendant nodes.
5992 }
5999 }
6000 }
6013 }
6016 }
6018 #ifdef NOISY_REFLOW_REASON
6023 }
6027 }
6029 #endif
6036 }
6037 }
6041 #ifdef NOISY_REFLOW_REASON
6046 #endif
6053 }
6055 // Make sure to mark affected lines dirty for the float frame
6056 // we are removing; this way is a bit messy, but so is the rest of the code.
6057 // See bug 390762.
6065 }
6068 // Skip the call to |FrameNeedsReflow| below by returning now.
6073 }
6078 }
6084 }
6085 // XXX the TEXT_OFFSETS_NEED_FIXING check is a wallpaper for bug 822910.
6089 }
6091 }
6095 // Clear our line cursor, since our lines may change.
6100 }
6102 // Attempt to find the line that contains the previous sibling
6116 // We need to find out which list it's actually in. Assume that
6117 // *if* we have overflow lines, that our primary lines aren't
6118 // huge, but our overflow lines might be.
6123 }
6125 }
6127 // By elimination, the line must be in our overflow lines.
6130 }
6131 }
6144 // XXX_perf This is technically O(N^2) in some cases, but by using
6145 // RFind instead of Find, we make it O(N) in the most common case,
6146 // which is appending content.
6148 // Find the line that contains the previous sibling
6152 // Not in mLines - try overflow lines.
6161 }
6166 // Note: defensive code! RFindLineContaining must not return
6167 // false in this case, so if it does...
6171 }
6172 }
6173 }
6174 }
6176 // Find the frame following aPrevSibling so that we can join up the
6177 // two lists of frames.
6179 // Split line containing aPrevSibling in two if the insertion
6180 // point is somewhere in the middle of the line.
6183 // Split the line in two where the frame(s) are being inserted.
6187 // Mark prevSibLine dirty and as needing textrun invalidation, since
6188 // we may be breaking up text in the line. Its previous line may also
6189 // need to be invalidated because it may be able to pull some text up.
6191 // The new line will also need its textruns recomputed because of the
6192 // frame changes.
6195 }
6199 }
6203 // Walk through the new frames being added and update the line data
6204 // structures to fit.
6215 // If the frame is a block frame, or if there is no previous line or if the
6216 // previous line is a block line we need to make a new line. We also make
6217 // a new line, as an optimization, in the two cases we know we'll need it:
6218 // if the previous line ended with a <br>, or if it has significant
6219 // whitespace and ended in a newline.
6222 // Create a new line for the frame and add its line to the line
6223 // list.
6226 // Append new line after prevSibLine
6230 // New line is going before the other lines
6233 }
6236 // We're adding inline content to prevSibLine, so we need to mark it
6237 // dirty, ensure its textruns are recomputed, and possibly do the same
6238 // to its previous line since that line may be able to pull content up.
6240 }
6243 }
6245 #ifdef DEBUG
6248 #endif
6249 }
6257 }
6259 }
6262 // 'display:block ruby' use the inner (Ruby) frame for insertions.
6265 }
6267 }
6273 }
6274 }
6277 // Find which line contains the float, so we can update
6278 // the float cache.
6282 }
6283 }
6284 }
6287 #ifdef DEBUG
6288 // Floats live in mFloats, or in the PushedFloat or OverflowOutOfFlows
6289 // frame list properties.
6296 }
6297 #endif
6301 }
6305 #if 0
6306 // XXXmats not yet - need to investigate BlockReflowState::mPushedFloats
6307 // first so we don't leave it pointing to a deleted list.
6310 }
6311 #endif
6313 }
6315 {
6319 }
6320 }
6321 }
6325 // The containing block is always the parent of aFrame.
6328 // Remove aFrame from the appropriate list.
6330 // This also deletes the next-in-flows
6334 // First remove aFrame's next-in-flows.
6337 }
6338 // Now remove aFrame from its child list and Destroy it.
6342 }
6343 }
6345 /**
6346 * This helps us iterate over the list of all normal + overflow lines
6347 */
6355 // Try the overflow lines
6363 }
6364 }
6365 }
6366 }
6369 LineIterator aLine)
6371 // This will assert if aLine isn't in mLines of aFrame:
6373 }
6376 LineIterator aLine,
6388 }
6394 }
6396 // Figure out what the right style parent is. This needs to match
6397 // nsCSSFrameConstructor::CreateLetterFrame.
6401 }
6408 parentStyle);
6409 // Note that we don't need to worry about changehints for the continuation
6410 // styles: those will be handled by the styleParent already.
6413 parentStyle);
6417 // We also want to update the style on the textframe inside the first-letter.
6418 // We don't need to compute a changehint for this, though, since any changes
6419 // to it are handled by the first-letter anyway.
6423 firstLetterStyle);
6426 // We don't need to update style for textFrame's continuations: it's already
6427 // set up to inherit from parentStyle, which is what we want.
6428 }
6440 }
6445 }
6448 }
6450 }
6453 }
6464 }
6470 // The block has a single line - that must be it!
6473 }
6475 // Try to use the cursor if it exists, otherwise fall back to the first line
6478 // Perform a simultaneous forward and reverse search starting from the
6479 // line cursor.
6483 // rline is positioned on the line containing 'cursor', so it's not
6484 // rline_end. So we can safely increment it (i.e. move it to one line
6485 // earlier) to start searching there.
6492 }
6494 }
6499 }
6501 }
6502 }
6507 }
6509 }
6515 }
6516 }
6517 }
6518 // Didn't find the line
6521 // If we reach here, it means that we have not been able to find the
6522 // desired frame in our in-flow lines. So we should start looking at
6523 // our overflow lines. In order to do that, we set mLine to the end
6524 // iterator so that FindValidLine starts to look at overflow lines,
6525 // if any.
6529 }
6535 }
6537 }
6541 }
6546 }
6551 }
6558 }
6567 }
6572 }
6580 }
6581 }
6583 }
6584 }
6590 }
6597 }
6602 }
6610 }
6611 }
6613 }
6614 }
6616 // This function removes aDeletedFrame and all its continuations. It
6617 // is optimized for deleting a whole series of frames. The easy
6618 // implementation would invoke itself recursively on
6619 // aDeletedFrame->GetNextContinuation, then locate the line containing
6620 // aDeletedFrame and remove aDeletedFrame from that line. But here we
6621 // start by locating aDeletedFrame and then scanning from that point
6622 // on looking for continuations.
6625 // Clear our line cursor, since our lines may change.
6629 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6635 // FIXME(emilio): aContext is lost here, maybe it's not a big deal?
6638 }
6640 }
6642 // Find the line that contains deletedFrame
6647 // Make sure we look in the overflow lines even if the normal line
6648 // list is empty
6654 }
6658 }
6663 }
6672 }
6673 }
6682 }
6684 // If the frame being deleted is the last one on the line then
6685 // optimize away the line->Contains(next-in-flow) call below.
6690 next != line_end
6697 }
6699 // Remove aDeletedFrame from the line
6701 // We should be setting this to null if aDeletedFrame
6702 // is the only frame on the line. HOWEVER in that case
6703 // we will be removing the line anyway, see below.
6705 }
6707 // Hmm, this won't do anything if we're removing a frame in the first
6708 // overflow line... Hopefully doesn't matter
6711 // Since we just removed a frame that follows some inline
6712 // frames, we need to reflow the previous line.
6714 }
6717 // Take aDeletedFrame out of the sibling list. Note that
6718 // prevSibling will only be nullptr when we are deleting the very
6719 // first frame in the main or overflow list.
6724 }
6726 // Update the child count of the line to be accurate
6729 // Destroy frame; capture its next continuation first in case we need
6730 // to destroy that too.
6735 #ifdef NOISY_REMOVE_FRAME
6741 #endif
6743 // If next-in-flow is an overflow container, must remove it first.
6744 // FIXME: Can we do this unconditionally?
6746 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6750 }
6756 // If line is empty, remove it now.
6758 #ifdef NOISY_REMOVE_FRAME
6761 #endif
6765 // Invalidate the space taken up by the line.
6766 // XXX We need to do this if we're removing a frame as a result of
6767 // a call to RemoveFrame(), but we may not need to do this in all
6768 // cases...
6769 #ifdef NOISY_BLOCK_INVALIDATE
6773 #endif
6779 // We just invalidated our iterators. Since we were in
6780 // the overflow lines list, which is now empty, set them
6781 // so we're at the end of the regular line list.
6785 }
6786 }
6789 // If we're removing a line, ReflowDirtyLines isn't going to
6790 // know that it needs to slide lines unless something is marked
6791 // dirty. So mark the previous margin of the next line dirty if
6792 // there is one.
6795 }
6798 // Make the line that just lost a frame dirty, and advance to
6799 // the next line.
6805 }
6806 }
6809 // See if we should keep looking in the current flow's line list.
6811 // The deceased frames continuation is not a child of the
6812 // current block. So break out of the loop so that we advance
6813 // to the next parent.
6814 //
6815 // If we have a continuation in a different block then all bets are
6816 // off regarding whether we are deleting frames without actual content,
6817 // so don't propagate FRAMES_ARE_EMPTY any further.
6820 }
6822 // If we advanced to the next line then check if we should switch to the
6823 // overflow line list.
6827 // We have advanced to the next *normal* line but the next-in-flow
6828 // is not there - force a switch to the overflow line list.
6830 }
6834 #ifdef NOISY_REMOVE_FRAME
6837 #endif
6838 }
6839 }
6840 }
6845 }
6847 #ifdef DEBUG
6850 #endif
6852 // Advance to next flow block if the frame has more continuations.
6855 }
6860 }
6872 }
6873 }
6875 }
6885 // Optimize by comparing the line's last child first.
6892 }
6893 }
6894 }
6896 }
6904 }
6912 }
6916 }
6934 }
6935 }
6936 }
6945 }
6950 // The line became empty - destroy it.
6955 }
6957 }
6958 }
6966 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6968 aDeletingEmptyFrames);
6970 #ifdef DEBUG
6973 }
6974 #endif
6977 }
6978 }
6981 // Return the pointer to an unmodified style text
6983 }
6995 // Setup a block reflow context to reflow the float.
7000 nsCollapsingMargin margin;
7003 // Only first in flow gets a block-start margin.
7010 // We don't need to push the float manager state because the the block
7011 // has its own float manager that will be destroyed and recreated
7012 }
7013 }
7015 // When reflowing a float, aSpace argument doesn't matter because we pass
7016 // nullptr to aLine and we don't call nsBlockReflowContext::PlaceBlock()
7017 // later.
7023 // We never split floating first letters; an incomplete status for such
7024 // frames simply means that there is more content to be reflowed on the
7025 // line.
7028 }
7029 }
7033 "The status can only be incomplete or overflow-incomplete if "
7038 }
7042 // Set the rect, make sure the view is properly sized and positioned,
7043 // and tell the frame we're done reflowing it
7044 // XXXldb This seems like the wrong place to be doing this -- shouldn't
7045 // we be doing this in BlockReflowState::FlowAndPlaceFloat after
7046 // we've positioned the float, and shouldn't we be doing the equivalent
7047 // of |PlaceFrameView| here?
7054 }
7056 }
7064 }
7065 }
7067 }
7071 // Pushed floats live at the start of our float list; see comment
7072 // above nsBlockFrame::DrainPushedFloats.
7077 // When we push a first-continuation float in a non-initial reflow,
7078 // it's possible that we end up with two continuations with the same
7079 // parent. This happens if, on the previous reflow of the block or
7080 // a previous reflow of the line containing the block, the float was
7081 // split between continuations A and B of the parent, but on the
7082 // current reflow, none of the float can fit in A.
7083 //
7084 // When this happens, we might even have the two continuations
7085 // out-of-order due to the management of the pushed floats. In
7086 // particular, if the float's placeholder was in a pushed line that
7087 // we reflowed before it was pushed, and we split the float during
7088 // that reflow, we might have the continuation of the float before
7089 // the float itself. (In the general case, however, it's correct
7090 // for floats in the pushed floats list to come before floats
7091 // anchored in pushed lines; however, in this case it's wrong. We
7092 // should probably find a way to fix it somehow, since it leads to
7093 // incorrect layout in some cases.)
7094 //
7095 // When we have these out-of-order continuations, we might hit the
7096 // next-continuation before the previous-continuation. When that
7097 // happens, just push it. When we reflow the next continuation,
7098 // we'll either pull all of its content back and destroy it (by
7099 // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
7100 // pull it out of its current position and push it again (and
7101 // potentially repeat this cycle for the next continuation, although
7102 // hopefully then they'll be in the right order).
7103 //
7104 // We should also need this code for the in-order case if the first
7105 // continuation of a float gets moved across more than one
7106 // continuation of the containing block. In this case we'd manage
7107 // to push the second continuation without this check, but not the
7108 // third and later.
7115 }
7117 // Always call FlowAndPlaceFloat; we might need to place this float if it
7118 // didn't belong to this block the last time it was reflowed. Note that if
7119 // the float doesn't get placed, we don't consider its overflow areas.
7120 // (Not-getting-placed means it didn't fit and we pushed it instead of
7121 // placing it, and its position could be stale.)
7125 }
7129 // We didn't push |f| so its next-sibling is next.
7134 }
7136 // If there are pushed or split floats, then we may need to continue BR
7137 // clearance
7143 }
7144 }
7145 }
7149 // Recover our own floats
7151 // belong to our next-in-flow
7158 }
7159 }
7161 // Recurse into our overflow container children
7166 }
7168 // Recurse into our normal children
7172 }
7173 }
7174 }
7178 WritingMode aWM,
7182 // Only blocks have floats
7184 // Don't recover any state inside a block that has its own float manager
7185 // (we don't currently have any blocks like this, though, thanks to our
7186 // use of extra frames for 'overflow')
7188 // If the element is relatively positioned, then adjust x and y
7189 // accordingly so that we consider relatively positioned frames
7190 // at their original position.
7198 }
7199 }
7203 // If we have pushed floats, then they should be at the beginning of our
7204 // float list.
7207 }
7208 }
7210 #ifdef DEBUG
7211 // Double-check the above assertion that pushed floats should be at the
7212 // beginning of our floats list.
7216 }
7217 #endif
7219 // We may have a pending push of pushed floats too:
7221 // XXX we can return 'true' here once we make HasPushedFloats
7222 // not lie. (see nsBlockFrame::RemoveFloat)
7225 }
7227 }
7229 //////////////////////////////////////////////////////////////////////
7230 // Painting, event handling
7232 #ifdef DEBUG
7238 // Compute min and max x/y values for the reflowed frame's
7239 // combined areas
7247 }
7250 }
7253 }
7256 }
7257 }
7263 }
7264 #endif
7266 #ifdef DEBUG
7275 }
7276 }
7277 #endif
7285 #ifdef DEBUG
7287 aDrawnLines++;
7288 }
7292 #endif
7294 // Collect our line's display items in a temporary nsDisplayListCollection,
7295 // so that we can apply any "text-overflow" clipping to the entire collection
7296 // without affecting previous lines.
7299 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
7300 // Inline-level child backgrounds go on the regular child content list.
7302 collection,
7306 aLineInLine
7315 }
7319 aLineNumberForTextOverflow);
7320 }
7323 }
7329 #ifdef DEBUG
7333 nsRect ca;
7340 }
7345 }
7346 #endif
7348 // TODO(heycam): Should we boost the load priority of any shape-outside
7349 // images using CATEGORY_DISPLAY, now that this block is being displayed?
7350 // We don't have a float manager here.
7359 }
7360 }
7361 }
7366 // Display outside ::marker manually.
7368 }
7370 // Prepare for text-overflow processing.
7379 // TODO(miko): Unfortunately |descendAlways| cannot be cached, because with
7380 // some frame trees, building display list for child lines can change it.
7381 // See bug 1552789.
7389 };
7393 // We'll try to draw an accessibility backplate behind text (to ensure it's
7394 // readable over any possible background-images), if all of the following
7395 // hold:
7396 // (A) the backplate feature is preffed on
7397 // (B) we are not honoring the document colors
7398 // (C) the force color adjust property is set to auto
7403 }
7405 // Don't use the line cursor if we might have a descendant placeholder ...
7406 // it might skip lines that contain placeholders but don't themselves
7407 // intersect with the dirty area.
7408 // In particular, we really want to check ShouldDescendIntoFrame()
7409 // on all our child frames, but that might be expensive. So we
7410 // approximate it by checking it on |this|; if it's true for any
7411 // frame in our child list, it's also true for |this|.
7412 // Also skip the cursor if we're creating text overflow markers,
7413 // since we need to know what line number we're up to in order
7414 // to generate unique display item keys.
7415 // Lastly, the cursor should be skipped if we're drawing
7416 // backplates behind text. When backplating we consider consecutive
7417 // runs of text as a whole, which requires we iterate through all lines
7418 // to find our backplate size.
7431 // Because we have a cursor, the combinedArea.ys are non-decreasing.
7432 // Once we've passed aDirtyRect.YMost(), we can never see it again.
7435 }
7441 }
7442 }
7443 }
7450 // A frame's display list cannot contain more than one copy of a
7451 // given display item unless the items are uniquely identifiable.
7452 // Because backplate occasionally requires multiple
7453 // SolidColor items, we use an index (backplateIndex) to maintain
7454 // uniqueness among them. Note this is a mapping of index to
7455 // item, and the mapping is stable even if the dirty rect changes.
7457 nsRect curBackplateArea;
7463 };
7472 }
7475 // If we have encountered a non-inline line but were previously
7476 // forming a backplate, we should add the backplate to the display
7477 // list as-is and render future backplates disjointly.
7479 "if this master switch is off, curBackplateArea "
7482 backplateIndex++;
7484 }
7489 }
7499 }
7500 }
7501 }
7502 lineCount++;
7503 }
7507 }
7511 }
7512 }
7515 // Put any text-overflow:ellipsis markers on top of the non-positioned
7516 // content of the block's lines. (If we ever start sorting the Content()
7517 // list this will end up in the wrong place.)
7519 }
7521 #ifdef DEBUG
7528 }
7542 }
7543 #endif
7544 }
7546 #ifdef ACCESSIBILITY
7550 }
7552 // block frame may be for <hr>
7555 }
7558 // XXXsmaug What if we're in the shadow dom?
7560 // Don't create accessible objects for the root content node, they are
7561 // redundant with the nsDocAccessible object created with the document
7562 // node
7564 }
7567 // Don't create accessible objects for the body, they are redundant with
7568 // the nsDocAccessible object created with the document node
7570 }
7572 // Not a list item with a ::marker, treat as normal HTML container.
7574 }
7576 // Create special list item accessible since we have a ::marker.
7578 }
7579 #endif
7584 }
7588 }
7593 }
7597 }
7600 // Although this looks like a "querying" method, it is used by the
7601 // display-list building code, so uses the Display cursor.
7605 }
7613 }
7618 }
7622 }
7625 }
7627 /* virtual */
7629 // See if the child is absolutely positioned
7631 // do nothing
7633 // The ::marker lives in the first line, unless the first line has
7634 // height 0 and there is a second line, in which case it lives
7635 // in the second line.
7640 }
7644 }
7645 // otherwise we have an empty line list, and ReflowDirtyLines
7646 // will handle reflowing the ::marker.
7648 // Note that we should go through our children to mark lines dirty
7649 // before the next reflow. Doing it now could make things O(N^2)
7650 // since finding the right line is O(N).
7651 // We don't need to worry about marking lines on the overflow list
7652 // as dirty; we're guaranteed to reflow them if we take them off the
7653 // overflow list.
7654 // However, we might have gotten a float, in which case we need to
7655 // reflow the line containing its placeholder. So find the
7656 // ancestor-or-self of the placeholder that's a child of the block,
7657 // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
7658 // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7659 // We need to take some care to handle the case where a float is in
7660 // a different continuation than its placeholder, including marking
7661 // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7668 // SVG code sometimes sends FrameNeedsReflow notifications during
7669 // frame destruction, leading to null placeholders, but we're safe
7670 // ignoring those.
7678 }
7680 }
7682 }
7683 }
7684 }
7687 }
7691 // These are all the block specific frame bits, they are copied from
7692 // the prev-in-flow to a newly created next-in-flow, except for the
7693 // NS_BLOCK_FLAGS_NON_INHERITED_MASK bits below.
7695 NS_BLOCK_FORMATTING_CONTEXT_STATE_BITS |
7698 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7700 // This is the subset of NS_BLOCK_FLAGS_MASK that is NOT inherited
7701 // by default. They should only be set on the first-in-flow.
7704 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7707 // Copy over the inherited block frame bits from the prev-in-flow.
7711 }
7718 }
7720 // A display:flow-root box establishes a block formatting context.
7721 //
7722 // If a box has a different writing-mode value than its containing block:
7723 // ...
7724 // If the box is a block container, then it establishes a new block
7725 // formatting context.
7726 // (https://drafts.csswg.org/css-writing-modes/#block-flow)
7727 //
7728 // If the box has contain: paint or contain:layout (or contain:strict),
7729 // then it should also establish a formatting context.
7730 //
7731 // Per spec, a column-span always establishes a new block formatting context.
7741 }
7745 }
7746 }
7753 #ifdef DEBUG
7754 // The only times a block that is an anonymous box is allowed to have a
7755 // first-letter frame are when it's the block inside a non-anonymous cell,
7756 // the block inside a fieldset, button or column set, or a scrolled content
7757 // block, except for <select>. Note that this means that blocks which are
7758 // the anonymous block in {ib} splits do NOT get first-letter frames.
7759 // Note that NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations
7760 // of the block.
7778 #endif
7783 }
7784 }
7789 NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER),
7797 // An outside ::marker needs to be an independent formatting context
7798 // to avoid being influenced by the float manager etc.
7800 }
7804 }
7805 }
7816 }
7821 nscoord aLineTop) {
7826 // Make up an inline-size since it doesn't really matter (XXX).
7832 nsReflowStatus status;
7835 // Get the float available space using our saved state from before we
7836 // started reflowing the block, so that we ignore any floats inside
7837 // the block.
7838 // FIXME: aLineTop isn't actually set correctly by some callers, since
7839 // they reposition the line.
7840 LogicalRect floatAvailSpace =
7841 aState
7845 // FIXME (bug 25888): need to check the entire region that the first
7846 // line overlaps, not just the top pixel.
7848 // Place the ::marker now. We want to place the ::marker relative to the
7849 // border-box of the associated block (using the right/left margin of
7850 // the ::marker frame as separation). However, if a line box would be
7851 // displaced by floats that are *outside* the associated block, we
7852 // want to displace it by the same amount. That is, we act as though
7853 // the edge of the floats is the content-edge of the block, and place
7854 // the ::marker at a position offset from there by the block's padding,
7855 // the block's border, and the ::marker frame's margin.
7857 // IStart from floatAvailSpace gives us the content/float start edge
7858 // in the current writing mode. Then we subtract out the start
7859 // border/padding and the ::marker's width and margin to offset the position.
7861 // Get the ::marker's margin, converted to our writing mode so that we can
7862 // combine it with other logical values here.
7868 // Approximate the ::marker's position; vertical alignment will provide
7869 // the final vertical location. We pass our writing-mode here, because
7870 // it may be different from the ::marker frame's mode.
7873 wm,
7877 }
7879 // This is used to scan frames for any float placeholders, add their
7880 // floats to the list represented by aList, and remove the
7881 // floats from whatever list they might be in. We don't search descendants
7882 // that are float containing blocks. Floats that or not children of 'this'
7883 // are ignored (they are not added to aList).
7887 // Don't descend into float containing blocks.
7895 // Remove the IS_PUSHED_FLOAT bit, in case |outOfFlowFrame| came from
7896 // the PushedFloats list.
7900 // FIXME: By not pulling floats whose parent is one of our
7901 // later siblings, are we risking the pushed floats getting
7902 // out-of-order?
7903 // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
7904 }
7910 }
7913 }
7915 }
7916 }
7919 #ifdef DEBUG
7920 // If any line is still dirty, that must mean we're going to reflow this
7921 // block again soon (e.g. because we bailed out after noticing that
7922 // clearance was imposed), so don't worry if the floats are out of sync.
7925 // Check that the float list is what we would have built
7930 }
7933 }
7934 }
7943 }
7944 // There are chances that the float children won't be added to lines,
7945 // because in nsBlockFrame::ReflowLine, it skips reflow line if the first
7946 // child of the line is IsHiddenByContentVisibilityOfInFlowParentForLayout.
7947 // There are also chances that the floats in line are out of date, for
7948 // instance, lines could reflow if
7949 // PresShell::IsForcingLayoutForHiddenContent, and after forcingLayout is
7950 // off, the reflow of lines could be skipped, but the floats are still in
7951 // there. Here we can't know whether the floats hidden by c-v are included
7952 // in the lines or not. So we use hasHiddenFloats to skip the float length
7953 // checking.
7957 }
7961 }
7963 }
7968 "nsBlockFrame::CheckFloats: Explicit float list is out of sync with "
7970 # if defined(DEBUG_roc)
7974 }
7977 }
7978 # endif
7979 }
7980 #endif
7984 // Floats that were pushed should be removed from our float
7985 // manager. Otherwise the float manager's YMost or XMost might
7986 // be larger than necessary, causing this block to get an
7987 // incorrect desired height (or width). Some of these floats
7988 // may not actually have been added to the float manager because
7989 // they weren't reflowed before being pushed; that's OK,
7990 // RemoveRegions will ignore them. It is safe to do this here
7991 // because we know from here on the float manager will only be
7992 // used for its XMost and YMost, not to place new floats and
7993 // lines.
7995 }
7996 }
8006 }
8007 }
8010 // The first column is a start margin root and the last column is an end
8011 // margin root. (If the column-set is split by a column-span:all box then
8012 // the first and last column in each column-set fragment are margin roots.)
8016 }
8020 }
8022 /* static */
8030 }
8032 /* static */
8037 }
8039 // Note that this width can vary based on the vertical position.
8040 // However, the cases where it varies are the cases where the width fits
8041 // in the available space given, which means that variation shouldn't
8042 // matter.
8043 /* static */
8050 FloatAvoidingISizeToClear result;
8053 nscoord availISize =
8056 // We actually don't want the min width here; see bug 427782; we only
8057 // want to displace if the width won't compute to a value small enough
8058 // to fit.
8059 // All we really need here is the result of ComputeSize, and we
8060 // could *almost* get that from an SizeComputationInput, except for the
8061 // last argument.
8063 LogicalSize availSpace =
8070 // Use the margins from sizingInput rather than reflowInput so that
8071 // they aren't reduced by ignoring margins in overconstrained cases.
8080 // If we get here, floatAvoidingBlock has a negative amount of inline-axis
8081 // margin and an 'auto' (or ~equivalently, -moz-available) inline
8082 // size. Under these circumstances, we use the margin to establish a
8083 // (positive) minimum size for the border-box, in order to satisfy the
8084 // equation in CSS2 10.3.3. That equation essentially simplifies to the
8085 // following:
8086 //
8087 // iSize of margins + iSize of borderBox = iSize of containingBlock
8088 //
8089 // ...where "iSize of borderBox" is the sum of floatAvoidingBlock's
8090 // inline-axis components of border, padding, and {width,height}.
8091 //
8092 // Right now, in the above equation, "iSize of margins" is the only term
8093 // that we know for sure. (And we also know that it's negative, since we
8094 // got here.) The other terms are as-yet unresolved, since the frame has an
8095 // 'auto' iSize, and since we aren't yet sure if we'll clear this frame
8096 // beyond floats or place it alongside them.
8097 //
8098 // However: we *do* know that the equation's "iSize of containingBlock"
8099 // term *must* be non-negative, since boxes' widths and heights generally
8100 // can't be negative in CSS. To satisfy that requirement, we can then
8101 // infer that the equation's "iSize of borderBox" term *must* be large
8102 // enough to cancel out the (known-to-be-negative) "iSize of margins"
8103 // term. Therefore, marginISize value (negated to make it positive)
8104 // establishes a lower-bound for how much inline-axis space our border-box
8105 // will really require in order to fit alongside any floats.
8106 //
8107 // XXXdholbert This explanation is admittedly a bit hand-wavy and may not
8108 // precisely match what any particular spec requires. It's the best
8109 // reasoning I could come up with to explain engines' behavior. Also, our
8110 // behavior with -moz-available doesn't seem particularly correct here, per
8111 // bug 1767217, though that's probably due to a bug elsewhere in our float
8112 // handling code...
8114 }
8118 }
8120 /* static */
8126 // yay, candidate is a block!
8128 }
8129 // Not a block. Check its parent next.
8131 }
8134 }
8137 nscoord aBEndEdgeOfChildren) {
8148 "An overflow container's effective content-box block-size, block-start "
8160 // If a block is split by any column-spans, we calculate the final
8161 // block-size by shrinkwrapping our children's block-size for all the
8162 // fragments except for those after the final column-span, but we should
8163 // take no more than our effective border-box block-size. If there's any
8164 // leftover block-size, our next continuations will take up rest.
8165 //
8166 // We don't need to adjust aBri.mReflowStatus because our children's status
8167 // is the same as ours.
8169 }
8174 }
8176 // Save our children's reflow status.
8183 }
8189 // The maximum value our content-box block-size can take within the given
8190 // available block-size.
8193 // The block-end edge of our content-box (relative to this frame's origin) if
8194 // we consumed the maximum block-size available to us (maxContentBoxBSize).
8197 // These variables are uninitialized intentionally so that the compiler can
8198 // check they are assigned in every if-else branch below.
8199 nscoord finalContentBoxBSizeWithBStartBP;
8203 // Our effective border-box block-size can fit in the available block-size,
8204 // so we are complete.
8208 // Note: The following assertion should generally hold because, for
8209 // box-decoration-break:clone, this "else if" branch is mathematically
8210 // equivalent to the initial "if".
8212 "This else-if branch is handling a situation that's specific "
8213 "to box-decoration-break:slice, i.e. a case when we can skip "
8216 // Our effective content-box block-size plus the block-start border and
8217 // padding can fit in the available block-size, but it cannot fit after
8218 // adding the block-end border and padding. Thus, we need a continuation
8219 // (unless we already weren't asking for any block-size, in which case we
8220 // stay complete to avoid looping forever).
8224 // We aren't going to be able to fit our content-box in the space available
8225 // to it, which means we'll probably call ourselves incomplete to request a
8226 // continuation. But before making that decision, we check for certain
8227 // conditions which would force us to overflow beyond the available space --
8228 // these might result in us actually being complete if we're forced to
8229 // overflow far enough.
8233 // In this rare case, we are at the top of page/column, we have
8234 // box-decoration-break:clone and zero available block-size for our
8235 // content-box (e.g. our own block-start border and padding already exceed
8236 // the available block-size), and we didn't lay out any child to consume
8237 // our content-box block-size. To ensure we make progress (avoid looping
8238 // forever), use 1px as our content-box block-size regardless of our
8239 // effective content-box block-size, in the spirit of
8240 // https://drafts.csswg.org/css-break/#breaking-rules.
8244 // We have a unbreakable child whose block-end edge exceeds the available
8245 // block-size for children.
8247 // The unbreakable child's block-end edge forces us to consume all of
8248 // our effective content-box block-size.
8251 // Even though we've consumed all of our effective content-box
8252 // block-size, we may still need to report an incomplete status in order
8253 // to get another continuation, which will be responsible for laying out
8254 // & drawing our block-end border & padding. But if we have no such
8255 // border & padding, or if we're forced to apply that border & padding
8256 // on this frame due to box-decoration-break:clone, then we don't need
8257 // to bother with that additional continuation.
8260 // The unbreakable child's block-end edge doesn't force us to consume
8261 // all of our effective content-box block-size.
8264 }
8266 // The children's block-end edge can fit in the content-box space that we
8267 // have available for it. Consume all the space that is available so that
8268 // our inline-start/inline-end borders extend all the way to the block-end
8269 // edge of column/page.
8272 }
8273 }
8279 // We want to use children's reflow status as ours, which can be overflow
8280 // incomplete. Suppress the urge to call aBri.mReflowStatus.Reset() here.
8283 }
8286 "An overflow container should always be complete because of "
8289 finalBorderBoxBSize =
8291 }
8295 }
8296 }
8299 }
8306 }
8309 // first-letter needs to be updated before first-line, because first-line can
8310 // change the style of the first-letter.
8313 }
8323 parentStyle);
8325 // FIXME(bz): Can we make first-line continuations be non-inheriting anon
8326 // boxes?
8334 // We also want to update the styles of the first-line's descendants. We
8335 // don't need to compute a changehint for this, though, since any changes to
8336 // them are handled by the first-line anyway.
8340 }
8341 }
8342 }
8346 // Certainly no first-letter frame.
8348 }
8351 }
8357 }
8360 }
8362 #ifdef DEBUG
8366 }
8369 }
8373 // Add up the counts on each line. Also validate that IsFirstLine is
8374 // set properly.
8379 }
8384 }
8385 }
8387 }
8389 // Then count the frames
8393 frameCount++;
8395 }
8398 // Next: test that each line has right number of frames on it
8405 }
8409 }
8410 }
8421 }
8422 }
8423 }
8424 }
8426 }
8429 // Overflow out-of-flows must not have a next-in-flow in mFloats or mFrames.
8436 }
8437 }
8439 // Pushed floats must not have a next-in-flow in mFloats or mFrames.
8446 }
8447 }
8449 // A child float next-in-flow's parent must be |this| or a next-in-flow of
8450 // |this|. Later next-in-flows must have the same or later parents.
8465 }
8466 }
8468 found,
8470 }
8471 }
8472 }
8485 }
8489 }
8493 ;
8498 ;
8499 }
8501 };
8507 }
8508 }
8515 depth++;
8516 }
8518 }
8524 }
8525 #endif