| blob | 2e5e1af5d3605cc959f663b2700599d13d2308f0 |
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 }
483 aPostDestroyData);
489 }
491 // destroy overflow lines now
497 }
503 }
509 }
512 }
514 /* virtual */
522 }
524 }
530 #ifdef DEBUG_FRAME_DUMP
533 nsCString str;
541 // Output the lines
546 }
547 }
549 // Output the overflow lines.
560 }
562 }
564 // skip the principal list - we printed the lines above
565 // skip the overflow list - we printed the overflow lines above
570 }
574 }
575 #endif
584 }
586 }
596 }
598 aRebuildDisplayItems);
599 }
605 }
612 }
616 }
621 nscoord offset;
625 // Ignore relative positioning for baseline calculations.
630 }
632 // XXX Is this the right test? We have some bogus empty lines
633 // floating around, but IsEmpty is perhaps too weak.
637 }
638 }
639 }
641 }
652 }
654 }
655 }
666 }
668 /////////////////////////////////////////////////////////////////////////////
669 // Child frame enumeration
678 }
684 }
688 }
692 }
695 }
696 }
703 }
707 }
712 }
716 }
717 }
719 /* virtual */
722 /**
723 * Remove the first line from aFromLines and adjust the associated frame list
724 * aFromFrames accordingly. The removed line is assigned to *aOutLine and
725 * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
726 * that were extracted from the head of aFromFrames.
727 * aFromLines must contain at least one line, the line may be empty.
728 * @return true if aFromLines becomes empty
729 */
739 }
741 //////////////////////////////////////////////////////////////////////
742 // Reflow methods
744 /* virtual */
753 }
754 }
757 }
763 }
772 }
773 }
774 }
776 /* virtual */
781 }
789 }
794 }
796 #ifdef DEBUG
801 }
803 #endif
808 }
813 }
816 InlineMinISizeData data;
822 #ifdef DEBUG
827 }
829 #endif
839 }
848 }
849 }
850 }
851 #ifdef DEBUG
856 }
857 #endif
858 }
859 }
864 }
866 /* virtual */
871 }
879 }
884 }
886 #ifdef DEBUG
891 }
893 #endif
898 }
903 }
904 InlinePrefISizeData data;
910 #ifdef DEBUG
915 }
917 #endif
919 StyleClear clearType;
924 }
935 // XXXmats should the test below be indent > 0?
938 }
939 }
946 }
947 }
948 #ifdef DEBUG
953 }
954 #endif
955 }
956 }
961 }
964 // be conservative
967 }
969 }
971 /* virtual */
977 }
982 nsresult rv;
983 InlinePrefISizeData data;
1001 }
1013 }
1014 }
1015 }
1016 }
1020 }
1022 /**
1023 * Return whether aNewAvailableSpace is smaller *on either side*
1024 * (inline-start or inline-end) than aOldAvailableSpace, so that we know
1025 * if we need to redo layout on an line, replaced block, or block
1026 * formatting context, because its height (which we used to compute
1027 * aNewAvailableSpace) caused it to intersect additional floats.
1028 */
1034 // Positions are not significant if the inline size is zero.
1036 }
1041 "available space should not shrink on the start side and "
1046 "available space should not grow on the start side and "
1053 }
1054 // Have we shrunk on either side?
1057 }
1061 // The issue here is that for a 'height' of 'auto' the reflow input
1062 // code won't know how to calculate the containing block height
1063 // because it's calculated bottom up. So we use our own computed
1064 // size as the dimensions.
1068 // Containing block is relative to the padding edge
1076 }
1078 // We are a wrapped frame for the content (and the wrapper is not the
1079 // canvas frame, whose size is not meaningful here).
1080 // Use the container's dimensions, if they have been precomputed.
1081 // XXX This is a hack! We really should be waiting until the outermost
1082 // frame is fully reflowed and using the resulting dimensions, even
1083 // if they're intrinsic.
1084 // In fact we should be attaching absolute children to the outermost
1085 // frame and not always sticking them in block frames.
1087 // First, find the reflow input for the outermost frame for this content.
1095 }
1099 }
1101 // For scroll containers, we can just use cbSize (which is the padding-box
1102 // size of the scrolled-content frame).
1104 // Assert that we're not missing any frames between the abspos containing
1105 // block and the scroll container.
1106 // the parent.
1110 }
1112 // Same for fieldsets, where the inner anonymous frame has the correct padding
1113 // area with the legend taken into account.
1116 }
1118 // We found a reflow input for the outermost wrapping frame, so use
1119 // its computed metrics if available, converted to our writing mode
1125 }
1129 }
1132 }
1134 /**
1135 * Returns aFrame if it is a non-BFC block frame, and null otherwise.
1136 *
1137 * This is used to determine whether to recurse into aFrame when applying
1138 * -webkit-line-clamp.
1139 */
1144 }
1145 }
1147 }
1152 }
1157 }
1161 }
1165 }
1167 // For now, -webkit-box is the only thing allowed to be a line-clamp root.
1168 // Ideally we'd just make this work everywhere, but for now we're carrying
1169 // this forward as a limitation on the legacy -webkit-line-clamp feature,
1170 // since relaxing this limitation might create webcompat trouble.
1173 // If we're the anonymous block inside the scroll frame, we need to look
1174 // at the original display of our parent frame.
1179 ":-moz-scrolled-content should inherit -webkit-line-clamp, "
1182 }
1184 }();
1187 }
1192 }
1198 }
1201 }
1202 }
1204 }
1206 /**
1207 * Iterator over all descendant inline line boxes, except for those that are
1208 * under an independent formatting context.
1209 */
1218 }
1219 }
1224 // Advances the iterator to the next line line.
1225 //
1226 // Next() shouldn't be called once the iterator is at the end, which can be
1227 // checked for by GetCurrentLine() or GetCurrentFrame() returning null.
1233 }
1239 // Reached the end of the current block. Pop the parent off the
1240 // stack; if there isn't one, then we've reached the end.
1244 }
1258 // Some kind of frame we shouldn't descend into.
1260 }
1264 }
1265 }
1266 }
1268 // The current line within the current block.
1269 //
1270 // When this is equal to mEnd, the iterator is at its end, and mCurrentFrame
1271 // is set to null.
1274 // The iterator end for the current block.
1277 // The current block.
1280 // Stack of mCurrentFrame and mEnd values that we push and pop as we enter and
1281 // exist blocks.
1283 };
1291 }
1292 }
1293 }
1295 }
1303 }
1304 }
1306 // We didn't find a line with the ellipsis; it must have been deleted already.
1308 }
1318 }
1325 #ifdef DEBUG
1332 }
1339 }
1340 #endif
1342 // ColumnSetWrapper's children depend on ColumnSetWrapper's block-size or
1343 // max-block-size because both affect the children's available block-size.
1346 }
1354 // If we have non-auto block size, we're clipping our kids and we fit,
1355 // make sure our kids fit too.
1361 physicalBlockAxis)) {
1362 LogicalMargin blockDirExtras =
1367 // Block-end margin never causes us to create continuations, so we
1368 // don't need to worry about whether it fits in its entirety.
1371 }
1378 }
1379 }
1381 // See comment below about oldSize. Use *only* for the
1382 // abs-pos-containing-block-size-change optimization!
1385 // Should we create a float manager?
1388 // XXXldb If we start storing the float manager in the frame rather
1389 // than keeping it around only during reflow then we should create it
1390 // only when there are actually floats to manage. Otherwise things
1391 // like tables will gain significant bloat.
1395 }
1397 // OK, some lines may be reflowed. Blow away any saved line cursor
1398 // because we may invalidate the nondecreasing
1399 // overflowArea.InkOverflow().y/yMost invariant, and we may even
1400 // delete the line with the line cursor.
1405 }
1407 #ifdef DEBUG
1408 // Between when we drain pushed floats and when we complete reflow,
1409 // we're allowed to have multiple continuations of the same float on
1410 // our floats list, since a first-in-flow might get pushed to a later
1411 // continuation of its containing block. But it's not permitted
1412 // outside that time.
1414 #endif
1416 // ALWAYS drain overflow. We never want to leave the previnflow's
1417 // overflow lines hanging around; block reflow depends on the
1418 // overflow line lists being cleared out between reflow passes.
1426 effectiveContentBoxBSize);
1431 }
1433 // Handle paginated overflow (see nsContainerFrame.h)
1434 OverflowAreas ocBounds;
1435 nsReflowStatus ocStatus;
1440 }
1442 // Now that we're done cleaning up our overflow container lists, we can
1443 // give |state| its nsOverflowContinuationTracker.
1447 // Drain & handle pushed floats
1449 OverflowAreas fcBounds;
1452 // If we're not dirty (which means we'll mark everything dirty later)
1453 // and our inline-size has changed, mark the lines dirty that we need to
1454 // mark dirty for a resize reflow.
1457 }
1459 // The same for percentage text-indent, except conditioned on the
1460 // parent resizing.
1465 }
1469 // Now reflow...
1472 // If we have a next-in-flow, and that next-in-flow has pushed floats from
1473 // this frame from a previous iteration of reflow, then we should not return
1474 // a status with IsFullyComplete() equals to true, since we actually have
1475 // overflow, it's just already been handled.
1477 // NOTE: This really shouldn't happen, since we _should_ pull back our floats
1478 // and reflow them, but just in case it does, this is a safety precaution so
1479 // we don't end up with a placeholder pointing to frames that have already
1480 // been deleted as part of removing our next-in-flow.
1489 }
1491 }
1494 }
1495 }
1499 // If we end in a BR with clear and affected floats continue,
1500 // we need to continue, too.
1505 }
1510 }
1512 #ifdef DEBUG_kipp
1515 #endif
1516 }
1518 // Place the ::marker's frame if it is placed next to a block child.
1519 //
1520 // According to the CSS2 spec, section 12.6.1, the ::marker's box
1521 // participates in the height calculation of the list-item box's
1522 // first line box.
1523 //
1524 // There are exactly two places a ::marker can be placed: near the
1525 // first or second line. It's only placed on the second line in a
1526 // rare case: an empty first line followed by a second line that
1527 // contains a block (example: <LI>\n<P>... ). This is where
1528 // the second case can happen.
1533 // Reflow the ::marker's frame.
1535 // XXX Use the entire line when we fix bug 25888.
1540 nscoord lineBStart =
1549 // We have some lines to align the ::marker with.
1551 // Doing the alignment using the baseline will also cater for
1552 // ::markers that are placed next to a child block (bug 92896)
1554 // Tall ::markers won't look particularly nice here...
1555 LogicalRect bbox =
1558 nscoord markerBaseline;
1562 // ::marker has no baseline in this axis: align with its margin-box end.
1563 markerBaseline =
1565 }
1568 }
1569 // Otherwise just leave the ::marker where it is, up against our
1570 // block-start padding.
1571 }
1573 // Clear any existing -webkit-line-clamp ellipsis.
1576 }
1580 // Compute our final size
1581 nscoord blockEndEdgeOfChildren;
1584 // If the block direction is right-to-left, we need to update the bounds of
1585 // lines that were placed relative to mContainerSize during reflow, as
1586 // we typically do not know the true container size until we've reflowed all
1587 // its children. So we use a dummy mContainerSize during reflow (see
1588 // BlockReflowState's constructor) and then fix up the positions of the
1589 // lines here, once the final block size is known.
1590 //
1591 // Note that writing-mode:vertical-rl is the only case where the block
1592 // logical direction progresses in a negative physical direction, and
1593 // therefore block-dir coordinate conversion depends on knowing the width
1594 // of the coordinate space in order to translate between the logical and
1595 // physical origins.
1600 // We compute our lines and markers' overflow areas later in
1601 // ComputeOverflowAreas(), so we don't need to adjust their overflow areas
1602 // here.
1606 }
1611 }
1616 }
1617 }
1623 }
1624 }
1625 }
1626 }
1631 // Factor overflow container child bounds into the overflow area
1633 // Factor pushed float child bounds into the overflow area
1636 // Let the absolutely positioned container reflow any absolutely positioned
1637 // child frames that need to be reflowed, e.g., elements with a percentage
1638 // based width/height
1639 // We want to do this under either of two conditions:
1640 // 1. If we didn't do the incremental reflow above.
1641 // 2. If our size changed.
1642 // Even though it's the padding edge that's the containing block, we
1643 // can use our rect (the border edge) since if the border style
1644 // changed, the reflow would have been targeted at us so we'd satisfy
1645 // condition 1.
1646 // XXX checking oldSize is bogus, there are various reasons we might have
1647 // reflowed but our size might not have been changed to what we
1648 // asked for (e.g., we ended up being pushed to a new page)
1649 // When WillReflowAgainForClearance is true, we will reflow again without
1650 // resetting the size. Because of this, we must not reflow our abs-pos
1651 // children in that situation --- what we think is our "new size" will not be
1652 // our real new size. This also happens to be more efficient.
1658 // Make sure that when we reflow again we'll actually reflow all the abs
1659 // pos frames that might conceivably depend on our size (or all of them,
1660 // if we're dirty right now and interrupted; in that case we also need
1661 // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
1662 // better than that, because we don't really know what our size will be,
1663 // and it might in fact not change on the followup reflow!
1668 }
1670 // We're not going to reflow absolute frames; make sure to account for
1671 // their existing overflow areas, which is usually a side effect of this
1672 // reflow.
1673 //
1674 // TODO(emilio): nsAbsoluteContainingBlock::Reflow already checks for
1675 // interrupt, can we just rely on it and unconditionally take the else
1676 // branch below? That's a bit more subtle / risky, since I don't see
1677 // what would reflow them in that case if they depended on our size.
1681 }
1682 }
1684 LogicalSize containingBlockSize =
1688 // Mark frames that depend on changes we just made to this frame as dirty:
1689 // Now we can assume that the padding edge hasn't moved.
1690 // We need to reflow the absolutes if one of them depends on
1691 // its placeholder position, or the containing block size in a
1692 // direction in which the containing block size might have
1693 // changed.
1695 // XXX "width" and "height" in this block will become ISize and BSize
1696 // when nsAbsoluteContainingBlock is logicalized
1699 // If isRoot and we have auto height, then we are the initial
1700 // containing block and the containing block height is the
1701 // viewport height, which can't change during incremental
1702 // reflow.
1712 }
1715 }
1716 // Setup the line cursor here to optimize line searching for
1717 // calculating hypothetical position of absolutely-positioned
1718 // frames.
1723 }
1724 }
1730 #ifdef DEBUG
1731 // Between when we drain pushed floats and when we complete reflow,
1732 // we're allowed to have multiple continuations of the same float on
1733 // our floats list, since a first-in-flow might get pushed to a later
1734 // continuation of its containing block. But it's not permitted
1735 // outside that time.
1752 }
1754 }
1763 }
1776 }
1777 #endif
1778 }
1784 }
1787 }
1788 }
1790 }
1793 StyleLineClamp aLineNumber) {
1808 NS_BLOCK_HAS_LINE_CLAMP_ELLIPSIS),
1811 // Don't count a line that only has collapsible white space (as might exist
1812 // after calling e.g. getBoxQuads).
1816 }
1819 // We already previously found our target line, and now we have
1820 // confirmed that there is another line after it.
1823 }
1826 // This is our target line. Continue looping to confirm that we
1827 // have another line after us.
1830 }
1833 }
1838 }
1845 }
1849 nscoord aContentBlockEndEdge) {
1852 }
1857 // The number of lines did not exceed the -webkit-line-clamp value.
1859 }
1861 // Mark the line as having an ellipsis so that TextOverflow will render it.
1865 // Translate the b-end edge of the line up to aFrame's space.
1868 edge +=
1870 }
1873 }
1881 #ifdef NOISY_FINAL_SIZE
1887 #endif
1889 // Compute final inline size
1896 // Return block-end margin information
1897 // rbs says he hit this assertion occasionally (see bug 86947), so
1898 // just set the margin to zero and we'll figure out why later
1899 // NS_ASSERTION(aMetrics.mCarriedOutBEndMargin.IsZero(),
1900 // "someone else set the margin");
1903 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
1904 // line with clearance and a non-zero block-start margin and all
1905 // subsequent lines are empty, then we do not allow our children's
1906 // carried out block-end margin to be carried out of us and collapse
1907 // with our own block-end margin.
1909 // Convert the children's carried out margin to something that
1910 // we will include in our height
1913 }
1917 }
1920 // Shrink wrap our height around our contents.
1923 // When we are a block-end-margin root make sure that our last
1924 // child's block-end margin is fully applied. We also do this when
1925 // we have a computed height, since in that case the carried out
1926 // margin is not going to be applied anywhere, so we should note it
1927 // here to be included in the overflow area.
1928 // Apply the margin only if there's space for it.
1930 // Truncate block-end margin if it doesn't fit to our available BSize.
1931 blockEndEdgeOfChildren =
1934 }
1935 }
1937 // Include the float manager's state to properly account for the
1938 // block-end margin of any floated elements; e.g., inside a table cell.
1939 //
1940 // Note: The block coordinate returned by ClearFloats is always greater than
1941 // or equal to blockEndEdgeOfChildren.
1944 }
1947 // Note: We don't use blockEndEdgeOfChildren because it includes the
1948 // previous margin.
1952 // We don't care about ApplyLineClamp's return value (the line-clamped
1953 // content BSize) in this explicit-BSize codepath, but we do still need to
1954 // call ApplyLineClamp for ellipsis markers to be placed as-needed.
1959 // If the content block-size is larger than the effective computed
1960 // block-size, we extend the block-size to contain all the content.
1961 // https://drafts.csswg.org/css-sizing-4/#aspect-ratio-minimum
1963 // Note: finalSize.BSize(wm) is the border-box size, so we compare it with
1964 // the content's block-size plus our border and padding..
1968 }
1970 // Don't carry out a block-end margin when our BSize is fixed.
1971 //
1972 // Note: this also includes the case that aReflowInput.ComputedBSize() is
1973 // calculated from aspect-ratio. i.e. Don't carry out block margin-end if it
1974 // is replaced by the block size from aspect-ratio and inline size.
1980 // If we're size-containing in block axis and we don't have a specified
1981 // block size, then our final size should actually be computed from only
1982 // our border, padding and contain-intrinsic-block-size, ignoring the
1983 // actual contents. Hence this case is a simplified version of the case
1984 // below.
1985 //
1986 // NOTE: We exempt the nsComboboxControlFrame subclass from taking this
1987 // special case when it has 'contain-intrinsic-block-size: none', because
1988 // comboboxes implicitly honors the size-containment behavior on its
1989 // nsComboboxDisplayFrame child (which it shrinkwraps) rather than on the
1990 // nsComboboxControlFrame. (Moreover, the DisplayFrame child doesn't even
1991 // need any special content-size-ignoring behavior in its reflow method,
1992 // because that method just resolves "auto" BSize values to one
1993 // line-height rather than by measuring its contents' BSize.)
1995 nscoord autoBSize =
2001 // Our parent is expected to push this frame to the next page/column so
2002 // what size we set here doesn't really matter.
2016 // Our min-block-size, max-block-size, or -webkit-line-clamp value made
2017 // our bsize change. Don't carry out our kids' block-end margins.
2019 }
2024 // Applying `min-size` made us overflow our available size.
2025 // Clamp it and report that we're Incomplete, or BreakBefore if we have
2026 // 'break-inside: avoid' that is applicable.
2032 }
2033 }
2041 // This should never happen, but it does. See bug 414255
2043 }
2049 // Note that |borderPadding| has GetSkipSides applied, so we ask
2050 // aReflowInput for the actual value we'd use on a last fragment here:
2053 // We actually fit after applying `max-size` so we should be
2054 // Overflow-Incomplete instead.
2057 }
2058 }
2060 }
2061 }
2065 // Overflow containers can only be overflow complete.
2066 // Note that auto height overflow containers have no normal children
2070 }
2074 // Currently only used for grid items, but could be used in other contexts.
2075 // The FragStretchBSizeProperty is our expected non-fragmented block-size
2076 // we should stretch to (for align-self:stretch etc). In some fragmentation
2077 // cases though, the last fragment (this frame since we're complete), needs
2078 // to have extra size applied because earlier fragments consumed too much of
2079 // our computed size due to overflowing their containing block. (E.g. this
2080 // ensures we fill the last row when a multi-row grid item is fragmented).
2085 }
2086 }
2088 // Clamp the content size to fit within the margin-box clamp size, if any.
2102 // XXXmats deal with percentages better somehow?
2104 }
2105 }
2106 }
2108 // Screen out negative block sizes --- can happen due to integer overflows :-(
2116 }
2120 #ifdef DEBUG_blocks
2125 }
2126 #endif
2127 }
2134 // Factor in the block-end edge of the children. Child frames will be added
2135 // to the overflow area as we iterate through the lines, but their margins
2136 // won't, so we need to account for block-end margins here.
2137 // REVIEW: For now, we do this for both visual and scrollable area,
2138 // although when we make scrollable overflow area not be a subset of
2139 // visual, we can change this.
2142 // If we are a scrolled inner frame, add our block-end padding to our
2143 // children's block-end edge.
2144 //
2145 // Note: aBEndEdgeOfChildren already includes our own block-start padding
2146 // because it is relative to our block-start edge of our border-box, which
2147 // is the same as our padding-box here.
2151 }
2153 // XXX Currently, overflow areas are stored as physical rects, so we have
2154 // to handle writing modes explicitly here. If we change overflow rects
2155 // to be stored logically, this can be simplified again.
2161 // Layout containment should force all overflow to be ink (visual)
2162 // overflow, so if we're layout-contained, we only add our children's
2163 // block-end edge to the ink (visual) overflow -- not to the
2164 // scrollable overflow.
2167 }
2168 }
2177 }
2178 }
2179 }
2185 }
2186 }
2187 }
2188 }
2191 nscoord aBEndEdgeOfChildren,
2193 // XXX_perf: This can be done incrementally. It is currently one of
2194 // the things that makes incremental reflow O(N^2).
2200 }
2202 // We rely here on our caller having called SetOverflowAreasToDesiredBounds().
2207 // If we have layout containment, we should only consider our child's
2208 // ink overflow, leaving the scrollable regions of the parent
2209 // unaffected.
2210 // Note: scrollable overflow is a subset of ink overflow,
2211 // so this has the same affect as unioning the child's visual and
2212 // scrollable overflow with its parent's ink overflow.
2218 }
2219 }
2221 // Factor an outside ::marker in; normally the ::marker will be factored
2222 // into the line-box's overflow areas. However, if the line is a block
2223 // line then it won't; if there are no lines, it won't. So just
2224 // factor it in anyway (it can't hurt if it was already done).
2225 // XXXldb Can we just fix GetOverflowArea instead?
2228 }
2234 overflowClipMargin);
2235 }
2237 #ifdef NOISY_OVERFLOW_AREAS
2241 #endif
2242 }
2245 // We need to update the overflow areas of lines manually, as they
2246 // get cached and re-used otherwise. Lines aren't exposed as normal
2247 // frame children, so calling UnionChildOverflow alone will end up
2248 // using the old cached values.
2257 }
2259 // Consider the overflow areas of the floats attached to the line as well
2263 }
2264 }
2268 }
2270 // Union with child frames, skipping the principal and float lists
2271 // since we already handled those using the line boxes.
2275 }
2279 nscoord blockEndEdgeOfChildren =
2284 }
2286 // Line cursor invariants depend on the overflow areas of the lines, so
2287 // we must clear the line cursor since those areas may have changed.
2290 }
2300 // NOTE: MarkLineDirty does more than just marking the line dirty.
2303 }
2304 }
2305 }
2307 }
2308 }
2312 // Mark aLine dirty
2315 #ifdef DEBUG
2320 }
2321 #endif
2323 // Mark previous line dirty if it's an inline line so that it can
2324 // maybe pullup something from the line just affected.
2325 // XXX We don't need to do this if aPrevLine ends in a break-after...
2330 #ifdef DEBUG
2336 }
2337 #endif
2338 }
2339 }
2341 /**
2342 * Test whether lines are certain to be aligned left so that we can make
2343 * resizing optimizations
2344 */
2346 StyleDirection aDirection,
2355 }
2358 // See if we can try and avoid marking all the lines as dirty
2359 // FIXME(emilio): This should be writing-mode aware, I guess.
2361 // The left content-edge must be a constant distance from the left
2362 // border-edge.
2365 #ifdef DEBUG
2368 }
2375 }
2376 }
2377 #endif
2381 nscoord newAvailISize =
2385 #ifdef DEBUG
2390 }
2391 #endif
2395 // We let child blocks make their own decisions the same
2396 // way we are here.
2404 }
2406 #ifdef REALLY_NOISY_REFLOW
2410 }
2411 #endif
2412 #ifdef DEBUG
2416 "skipped: line=%p next=%p %s %s%s%s clearTypeBefore/After=%s/%s "
2428 }
2429 #endif
2430 }
2432 // Mark everything dirty
2435 }
2436 }
2437 }
2439 //----------------------------------------
2441 /**
2442 * Propagate reflow "damage" from from earlier lines to the current
2443 * line. The reflow damage comes from the following sources:
2444 * 1. The regions of float damage remembered during reflow.
2445 * 2. The combination of nonzero |aDeltaBCoord| and any impact by a
2446 * float, either the previous reflow or now.
2447 *
2448 * When entering this function, |aLine| is still at its old position and
2449 * |aDeltaBCoord| indicates how much it will later be slid (assuming it
2450 * doesn't get marked dirty and reflowed entirely).
2451 */
2454 nscoord aDeltaBCoord) {
2462 // Check to see if there are any floats; if there aren't, there can't
2463 // be any float damage
2466 }
2468 // Check the damage region recorded in the float damage.
2470 // Need to check mBounds *and* mCombinedArea to find intersections
2471 // with aLine's floats
2474 // Scrollable overflow should be sufficient for things that affect
2475 // layout.
2478 LogicalRect overflow =
2481 nscoord lineBCoordCombinedAfter =
2487 lineBCoordCombinedAfter);
2491 }
2492 }
2494 // Check if the line is moving relative to the float manager
2497 // Unconditionally reflow sliding blocks; we only really need to reflow
2498 // if there's a float impacting this block, but the current float manager
2499 // makes it difficult to check that. Therefore, we let the child block
2500 // decide what it needs to reflow.
2504 nsFlowAreaRect floatAvailableSpace =
2508 #ifdef REALLY_NOISY_REFLOW
2511 #endif
2513 // Mark the line dirty if it was or is affected by a float
2514 // We actually only really need to reflow if the amount of impact
2515 // changes, but that's not straightforward to check
2518 }
2519 }
2520 }
2521 }
2527 NS_BLOCK_HAS_CLEAR_CHILDREN) ||
2530 }
2532 /**
2533 * Reparent a whole list of floats from aOldParent to this block. The
2534 * floats might be taken from aOldParent's overflow list. They will be
2535 * removed from the list. They end up appended to our mFloats list.
2536 */
2540 nsFrameList list;
2547 }
2549 }
2550 }
2554 #ifdef DEBUG
2560 "line=%p mBCoord=%d dirty=%s oldBounds={%d,%d,%d,%d} "
2561 "oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} "
2568 }
2569 #endif
2570 }
2576 }
2577 }
2579 }
2587 #ifdef DEBUG
2593 }
2595 #endif
2601 // Reflow our last line if our availableBSize has increased
2602 // so that we (and our last child) pull up content as necessary
2611 }
2612 }
2613 // the amount by which we will slide the current line if it is not
2614 // dirty
2617 // whether we did NOT reflow the previous line and thus we need to
2618 // recompute the carried out margin before the line if we want to
2619 // reflow it or if its previous margin is dirty
2621 // Float continuations were reflowed in ReflowPushedFloats
2626 // We save up information about BR-clearance here
2631 // Determine if children of this frame could have breaks between them for
2632 // page names.
2633 //
2634 // We need to check for paginated layout, the named-page pref, and if the
2635 // available block-size is constrained.
2636 //
2637 // Note that we need to check for paginated layout as named-pages are only
2638 // used during paginated reflow. We need to additionally check for
2639 // unconstrained block-size to avoid introducing fragmentation breaks during
2640 // "measuring" reflows within an overall paginated reflow, and to avoid
2641 // fragmentation in monolithic containers like 'inline-block'.
2642 //
2643 // Because we can only break for named pages using Class A breakpoints, we
2644 // also need to check that the block flow direction of the containing frame
2645 // of these items (which is this block) is parallel to that of this page.
2646 // See: https://www.w3.org/TR/css-break-3/#btw-blocks
2654 // Reflow the lines that are already ours
2657 #ifdef DEBUG
2659 #endif
2663 }
2665 // This really sucks, but we have to look inside any blocks that have clear
2666 // elements inside them.
2667 // XXX what can we do smarter here?
2671 }
2677 }
2679 // We have to reflow the line if it's a block whose clearance
2680 // might have changed, so detect that.
2684 // See where we would be after applying any clearance due to
2685 // BRs.
2689 }
2695 // Reflow the line if it might not have clearance anymore.
2697 // aState.mBCoord is the clearance point which should be the
2698 // block-start border-edge of the block frame. If sliding the
2699 // block by deltaBCoord isn't going to put it in the predicted
2700 // position, then we'd better reflow the line.
2703 }
2705 // Reflow the line if the line might have clearance now.
2708 }
2709 }
2710 }
2712 // We might have to reflow a line that is after a clearing BR.
2717 // SlideLine is not going to put the line where the clearance
2718 // put it. Reflow the line to be sure.
2720 }
2722 }
2726 // If the previous margin is dirty, reflow the current line
2735 // Lines that aren't dirty but get slid past our available block-size
2736 // constraint must be reflowed.
2738 }
2739 }
2743 // Last column can be reflowed unconstrained during column balancing.
2744 // Hence the additional NS_FRAME_HAS_MULTI_COLUMN_ANCESTOR bit check
2745 // as a fail-safe fallback.
2748 // Table can also be reflowed unconstrained during printing.
2751 // We are in a paginated context, i.e. in columns or pages.
2755 // The following if-else conditions check whether this line -- which
2756 // might have floats in its subtree, or has floats as direct children,
2757 // or had floats pushed -- needs to be reflowed.
2759 // The distance to the block-end edge might have changed. Reflow the
2760 // line both because the breakpoints within its floats may have
2761 // changed and because we might have to push/pull the floats in
2762 // their entirety.
2765 // We had pushed floats which haven't been drained by our
2766 // next-in-flow, which means our parent is currently reflowing us
2767 // again due to clearance without creating a next-in-flow for us.
2768 // Reflow the line to redo the floats split logic to correctly set
2769 // our reflow status.
2772 // Reflow the line (that may containing a float's placeholder frame)
2773 // if our parent tells us to do so.
2776 // Our parent's line containing us moved to a different fragment.
2777 // Reflow the line because the decision about whether the float fits
2778 // may be different in a different fragment.
2780 }
2781 }
2782 }
2783 }
2786 // See if there's any reflow damage that requires that we mark the
2787 // line dirty.
2789 }
2791 // If the container size has changed, reset mContainerSize. If the
2792 // line's writing mode is not ltr, or if the line is not left-aligned, also
2793 // mark the line dirty.
2804 }
2805 }
2807 // Check for a page break caused by CSS named pages.
2808 //
2809 // We should break for named pages when two frames meet at a class A
2810 // breakpoint, where the first frame has a different end page value to the
2811 // second frame's start page value. canBreakForPageNames is true iff
2812 // children of this frame can form class A breakpoints, and that we are not
2813 // in a measurement reflow or in a monolithic container such as
2814 // 'inline-block'.
2815 //
2816 // We specifically do not want to cause a page-break for named pages when
2817 // we are at the top of a page. This would otherwise happen when the
2818 // previous sibling is an nsPageBreakFrame, or all previous siblings on the
2819 // current page are zero-height. The latter may not be per-spec, but is
2820 // compatible with Chrome's implementation of named pages.
2832 }
2833 }
2834 }
2835 }
2838 // We need to reconstruct the block-end margin only if we didn't
2839 // reflow the previous line and we do need to reflow (or repair
2840 // the block-start position of) the next line.
2842 }
2848 // Update aState.mPrevChild as if we had reflowed all of the frames in
2849 // this line.
2855 }
2856 }
2858 // Now repair the line and update |aState.mBCoord| by calling
2859 // |ReflowLine| or |SlideLine|.
2860 // If we're going to reflow everything again, then no need to reflow
2861 // the dirty line ... unless the line has floats, in which case we'd
2862 // better reflow it now to refresh its float cache, which may contain
2863 // dangling frame pointers! Ugh! This reflow of the line may be
2864 // incorrect because we skipped reflowing previous lines (e.g., floats
2865 // may be placed incorrectly), but that's OK because we'll mark the
2866 // line dirty below under "if (aState.mReflowInput.mDiscoveredClearance..."
2874 // Compute the dirty lines "before" BEnd, after factoring in
2875 // the running deltaBCoord value - the running value is implicit in
2876 // aState.mBCoord.
2881 "Don't reflow blocks while willReflowAgain is true, reflow "
2885 // Immediately fragment for page-name. It is possible we could break
2886 // out of the loop right here, but this should make it more similar to
2887 // what happens when reflow causes fragmentation.
2892 // Reflow the dirty line. If it's an incremental reflow, then force
2893 // it to invalidate the dirty area if necessary
2895 }
2900 // Note that once we've entered this state, every line that gets here
2901 // (e.g. because it has floats) gets marked dirty and reflowed again.
2902 // in the next pass. This is important, see above.
2903 }
2907 }
2913 }
2915 }
2917 // Test to see whether the margin that should be carried out
2918 // to the next line (NL) might have changed. In ReflowBlockFrame
2919 // we call nextLine->MarkPreviousMarginDirty if the block's
2920 // actual carried-out block-end margin changed. So here we only
2921 // need to worry about the following effects:
2922 // 1) the line was just created, and it might now be blocking
2923 // a carried-out block-end margin from previous lines that
2924 // used to reach NL from reaching NL
2925 // 2) the line used to be empty, and is now not empty,
2926 // thus blocking a carried-out block-end margin from previous lines
2927 // that used to reach NL from reaching NL
2928 // 3) the line wasn't empty, but now is, so a carried-out
2929 // block-end margin from previous lines that didn't used to reach NL
2930 // now does
2931 // 4) the line might have changed in a way that affects NL's
2932 // ShouldApplyBStartMargin decision. The three things that matter
2933 // are the line's emptiness, its adjacency to the block-start edge of the
2934 // block, and whether it has clearance (the latter only matters if the
2935 // block was and is adjacent to the block-start and empty).
2936 //
2937 // If the line is empty now, we can't reliably tell if the line was empty
2938 // before, so we just assume it was and do
2939 // nextLine->MarkPreviousMarginDirty. This means the checks in 4) are
2940 // redundant; if the line is empty now we don't need to check 4), but if
2941 // the line is not empty now and we're sure it wasn't empty before, any
2942 // adjacency and clearance changes are irrelevant to the result of
2943 // nextLine->ShouldApplyBStartMargin.
2950 // since it's marked dirty, nobody will care about |deltaBCoord|
2951 }
2952 }
2954 // If the line was just reflowed for the first time, then its
2955 // old mBounds cannot be trusted so this deltaBCoord computation is
2956 // bogus. But that's OK because we just did
2957 // MarkPreviousMarginDirty on the next line which will force it
2958 // to be reflowed, so this computation of deltaBCoord will not be
2959 // used.
2962 // Now do an interrupt check. We want to do this only in the case when we
2963 // actually reflow the line, so that if we get back in here we'll get
2964 // further on the reflow before interrupting.
2968 // Nop except for blocks (we don't create overflow container
2969 // continuations for any inlines atm), so only checking mFirstChild
2970 // is enough
2978 }
2983 // If we're going to reflow everything again, and this line is a block,
2984 // then there is no need to recover float state. The line may contain
2985 // other lines with floats, but in that case RecoverStateFrom would only
2986 // add floats to the float manager. We don't need to do that because
2987 // everything's going to get reflowed again "for real". Calling
2988 // RecoverStateFrom in this situation could be lethal because the
2989 // block's descendant lines may have float caches containing dangling
2990 // frame pointers. Ugh!
2991 // If this line is inline, then we need to recover its state now
2992 // to make sure that we don't forget to move its floats by deltaBCoord.
2994 // XXX EVIL O(N^2) EVIL
2996 }
2998 // Keep mBCoord up to date in case we're propagating reflow damage
2999 // and also because our final height may depend on it. If the
3000 // line is inlines, then only update mBCoord if the line is not
3001 // empty, because that's what PlaceLine does. (Empty blocks may
3002 // want to update mBCoord, e.g. if they have clearance.)
3005 }
3011 // Need to make sure to pull overflows from any prev-in-flows
3015 }
3016 }
3017 }
3019 // Record if we need to clear floats before reflowing the next
3020 // line. Note that inlineFloatClearType will be handled and
3021 // cleared before the next line is processed, so there is no
3022 // need to combine break types here.
3025 }
3029 }
3035 // Another option here might be to leave |line| clean if
3036 // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
3037 // that case the line really did reflow as it should have. Not sure
3038 // whether that would be safe, so doing this for now instead. Also not
3039 // sure whether we really want to mark all lines dirty after an
3040 // interrupt, but until we get better at propagating float damage we
3041 // really do need to do it this way; see comments inside MarkLineDirty.
3043 }
3044 }
3046 // Handle BR-clearance from the last line of the block
3050 }
3053 // Is this expensive?
3056 // Update aState.mPrevChild as if we had reflowed all of the frames in
3057 // the last line.
3063 }
3065 // Should we really have to do this?
3068 }
3070 // We can skip trying to pull up the next line if our height is constrained
3071 // (so we can report being incomplete) and there is no next in flow or we
3072 // were told not to or we know it will be futile, i.e.,
3073 // -- the next in flow is not changing
3074 // -- and we cannot have added more space for its first line to be
3075 // pulled up into,
3076 // -- it's an incremental reflow of a descendant
3077 // -- and we didn't reflow any floats (so the available space
3078 // didn't change)
3079 // -- my chain of next-in-flows either has no first line, or its first
3080 // line isn't dirty.
3087 // We'll place lineIter at the last line of this block, so that
3088 // nsBlockInFlowLineIterator::Next() will take us to the first
3089 // line of my next-in-flow-chain. (But first, check that I
3090 // have any lines -- if I don't, just bail out of this
3091 // optimization.)
3097 // Check for next-in-flow-chain's first line.
3098 // (First, see if there is such a line, and second, see if it's clean)
3101 }
3102 }
3103 }
3111 }
3112 }
3115 // Pull data from a next-in-flow if there's still room for more
3116 // content here.
3118 // Grab first line from our next-in-flow
3121 nsFrameList pulledFrames;
3126 // Grab an overflow line if there are any
3132 }
3138 }
3139 }
3142 // The line is empty. Try the next one.
3148 }
3153 }
3156 }
3157 }
3168 // Shift pulledLine's frames into our mFrames list.
3171 // Add line to our line list, and set its last child as our new prev-child
3175 // Reparent floats whose placeholders are in the line.
3179 #ifdef DEBUG
3181 #endif
3186 // Now reflow it and any lines that it makes during it's reflow
3187 // (we have to loop here because reflowing the line may cause a new
3188 // line to be created; see SplitLine's callers for examples of
3189 // when this happens).
3198 }
3204 }
3206 }
3210 }
3215 }
3217 // If this is an inline frame then its time to stop
3220 }
3221 }
3222 }
3227 }
3229 // Handle an odd-ball case: a list-item with no lines
3241 // There are no lines so we have to fake up some y motion so that
3242 // we end up with *some* height.
3243 // (Note: if we're layout-contained, we have to be sure to leave our
3244 // ReflowOutput's BlockStartAscent() (i.e. the baseline) untouched,
3245 // because layout-contained frames have no baseline.)
3248 nscoord ascent;
3254 }
3255 }
3271 }
3272 }
3273 }
3277 }
3283 }
3285 #ifdef DEBUG
3293 }
3294 #endif
3295 }
3300 // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
3301 // marked the lines that need to be marked dirty based on our
3302 // vertical resize stuff. So we'll definitely reflow all those kids;
3303 // the only question is how they should behave.
3305 // Mark all our child frames dirty so we make sure to reflow them
3306 // later.
3311 }
3312 // And mark all the floats whose reflows we might be skipping dirty too.
3316 }
3317 }
3319 // Dirty all the descendant lines of block kids to handle float damage,
3320 // since our nsFloatManager will go away by the next time we're reflowing.
3321 // XXXbz Can we do something more like what PropagateFloatDamage does?
3322 // Would need to sort out the exact business with mBlockDelta for that....
3323 // This marks way too much dirty. If we ever make this better, revisit
3324 // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
3328 }
3329 }
3330 }
3338 "using function more generally than designed, "
3343 // Mark the previous margin of the next line dirty since we need to
3344 // recompute its top position.
3347 }
3348 }
3349 }
3351 /**
3352 * Reflow a line. The line will either contain a single block frame
3353 * or contain 1 or more inline frames. aKeepReflowGoing indicates
3354 * whether or not the caller should continue to reflow more lines.
3355 */
3360 // Setup the line-layout for the new line
3366 // If this line contains a single block that is hidden by `content-visibility`
3367 // don't reflow the line. If this line contains inlines and the first one is
3368 // hidden by `content-visibility`, all of them are, so avoid reflow in that
3369 // case as well.
3373 }
3375 // Now that we know what kind of line we have, reflow it
3382 // Store the line's float edges for overflow marker analysis if needed.
3394 // This line is overlapping a float - store the edges marking the area
3395 // between the floats for text-overflow analysis.
3397 }
3398 }
3399 }
3400 }
3403 }
3406 LineIterator aLine) {
3407 // First check our remaining lines.
3410 }
3416 // Try each next-in-flow.
3421 }
3424 }
3427 }
3430 }
3444 // If our line is not empty and the child in aFromLine is a block
3445 // then we cannot pull up the frame into this line. In this case
3446 // we stop pulling.
3448 }
3449 // Take frame from fromLine
3454 // The frame is being pulled from a next-in-flow; therefore we
3455 // need to add it to our sibling list.
3461 // When pushing and pulling frames we need to check for whether any
3462 // views need to be reparented.
3466 // The frame might have (or contain) floats that need to be brought
3467 // over too. (pass 'false' since there are no siblings to check)
3471 }
3477 // Mark line dirty now that we pulled a child
3481 // Free up the fromLine now that it's empty.
3482 // Its bounds might need to be redrawn, though.
3485 }
3487 // aFromLine is now invalid
3489 }
3491 #ifdef DEBUG
3494 #endif
3497 }
3500 nscoord aDeltaBCoord) {
3503 // Adjust line state
3506 // Adjust the frames in the line
3508 }
3514 }
3516 // Adjust line state
3519 // Changing container width only matters if writing mode is vertical-rl
3522 }
3523 }
3526 nscoord aDeltaBCoord) {
3527 // Adjust the frames in the line
3531 }
3539 }
3541 // Make sure the frame's view and any child views are updated
3544 // Adjust the block-dir coordinate of the frames in the line.
3545 // Note: we need to re-position views even if aDeltaBCoord is 0, because
3546 // one of our parent frames may have moved and so the view's position
3547 // relative to its parent may have changed.
3552 }
3553 // Make sure the frame's view and any child views are updated
3556 }
3557 }
3558 }
3561 // The "extremum length" values (see ExtremumLength) were originally aimed at
3562 // inline-size (or width, as it was before logicalization). For now, let them
3563 // return false here, so we treat them like 'auto' pending a real
3564 // implementation. (See bug 1126420.)
3565 //
3566 // FIXME (bug 567039, bug 527285) This isn't correct for the 'fill' value,
3567 // which should more likely (but not necessarily, depending on the available
3568 // space) be returning true.
3571 }
3573 // If we evaluate the length/percent/calc at a percentage basis of
3574 // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
3575 // length, percent, or combination thereof. Test > 0 so we clamp
3576 // negative calc() results to 0.
3579 }
3581 /* virtual */
3585 }
3587 // Blocks which are margin-roots (including inline-blocks) cannot be treated
3588 // as empty for margin-collapsing and other purposes. They're more like
3589 // replaced elements.
3592 }
3600 }
3602 // FIXME: Bug 1646100 - Take intrinsic size into account.
3603 // FIXME: Handle the case that both inline and block sizes are auto.
3604 // https://github.com/w3c/csswg-drafts/issues/5060.
3605 // Note: block-size could be zero or auto/intrinsic keywords here.
3609 }
3620 }
3624 }
3627 }
3632 }
3636 }
3637 }
3639 }
3644 }
3647 }
3652 // A page break frame consumes margins adjacent to it.
3653 // https://drafts.csswg.org/css-break/#break-margins
3655 }
3658 // Apply short-circuit check to avoid searching the line list
3660 }
3663 // If we aren't at the start block-coordinate then something of non-zero
3664 // height must have been placed. Therefore the childs block-start margin
3665 // applies.
3668 }
3670 // Determine if this line is "essentially" the first line
3674 }
3677 // A line which precedes aLine is non-empty, or has clearance,
3678 // so therefore the block-start margin applies.
3681 }
3682 // No need to apply the block-start margin if the line has floats. We
3683 // should collapse anyway (bug 44419)
3687 }
3689 // The line being reflowed is "essentially" the first line in the
3690 // block. Therefore its block-start margin will be collapsed by the
3691 // generational collapsing logic with its parent (us).
3693 }
3696 LineIterator aLine,
3704 }
3706 // Prepare the block reflow engine
3714 }
3716 // Clear past floats before the block if the clear style is not none
3720 }
3722 // See if we should apply the block-start margin. If the block frame being
3723 // reflowed is a continuation, then we don't apply its block-start margin
3724 // because it's not significant. Otherwise, dig deeper.
3728 // The HasClearance setting is only valid if ShouldApplyBStartMargin
3729 // returned false (in which case the block-start margin-root set our
3730 // clearance flag). Otherwise clear it now. We'll set it later on
3731 // ourselves if necessary.
3733 }
3741 }
3743 // If our block-start margin was counted as part of some parent's block-start
3744 // margin collapse, and we are being speculatively reflowed assuming this
3745 // frame DID NOT need clearance, then we need to check that
3746 // assumption.
3755 // Only record the first frame that requires clearance
3758 }
3760 // Exactly what we do now is flexible since we'll definitely be
3761 // reflowed.
3763 }
3764 }
3767 }
3772 nscoord clearance;
3773 // Save the original position of the frame so that we can reposition
3774 // its view as needed.
3783 // Precompute the blocks block-start margin value so that we can get the
3784 // correct available space (there might be a float that's
3785 // already been placed below the aState.mPrevBEndMargin
3787 // Setup a reflowInput to get the style computed block-start margin
3788 // value. We'll use a reason of `resize' so that we don't fudge
3789 // any incremental reflow input.
3791 // The availSpace here is irrelevant to our needs - all we want
3792 // out if this setup is the block-start margin value which doesn't depend
3793 // on the childs available space.
3794 // XXX building a complete ReflowInput just to get the block-start
3795 // margin seems like a waste. And we do this for almost every block!
3799 availSpace);
3804 }
3806 // Now compute the collapsed margin-block-start value into
3807 // aState.mPrevBEndMargin, assuming that all child margins
3808 // collapse down to clearanceFrame.
3812 // XXX optimization; we could check the collapsing children to see if they
3813 // are sure to require clearance, and so avoid retrying them
3816 // Don't allow retries on the second pass. The clearance decisions for
3817 // the blocks whose block-start margins collapse with ours are now
3818 // fixed.
3820 }
3823 // We don't know if we need clearance and this is the first,
3824 // optimistic pass. So determine whether *this block* needs
3825 // clearance. Note that we do not allow the decision for whether
3826 // this block has clearance to change on the second pass; that
3827 // decision is only allowed to be made under the optimistic
3828 // first pass.
3835 // Looks like we need clearance and we didn't know about it already.
3836 // So recompute collapsed margin
3838 // Remember this decision, needed for incremental reflow
3841 // Apply incoming margins
3845 // Compute the collapsed margin again, ignoring the incoming margin
3846 // this time
3850 }
3851 }
3853 // Temporarily advance the running block-direction value so that the
3854 // GetFloatAvailableSpace method will return the right available space.
3855 // This undone as soon as the horizontal margins are computed.
3860 // advance mBCoord to the clear position.
3866 clearedPushedOrSplitFloat =
3869 // Compute clearance. It's the amount we need to add to the block-start
3870 // border-edge of the frame, after applying collapsed margins
3871 // from the frame and its children, to get it to line up with
3872 // the block-end of the floats. The former is
3873 // currentBCoord + bStartMargin, the latter is the current
3874 // aState.mBCoord.
3875 // Note that negative clearance is possible
3878 // Add clearance to our block-start margin while we compute available
3879 // space for the frame
3882 // Note that aState.mBCoord should stay where it is: at the block-start
3883 // border-edge of the frame
3885 // Advance aState.mBCoord to the block-start border-edge of the frame.
3887 }
3888 }
3892 // Here aState.mBCoord is the block-start border-edge of the block.
3893 // Compute the available space for the block
3899 // The check for
3900 // (!aState.mReflowInput.mFlags.mIsTopOfPage || clearedFloats)
3901 // is to some degree out of paranoia: if we reliably eat up block-start
3902 // margins at the top of the page as we ought to, it wouldn't be
3903 // needed.
3906 // We know already that this child block won't fit on this
3907 // page/column due to the block-start margin or the clearance. So we
3908 // need to get out of here now. (If we don't, most blocks will handle
3909 // things fine, and report break-before, but zero-height blocks
3910 // won't, and will thus make their parent overly-large and force
3911 // *it* to be pushed in its entirety.)
3918 }
3920 }
3922 // Now put the block-dir coordinate back to the start of the
3923 // block-start-margin + clearance.
3928 }
3930 // Construct the reflow input for the block.
3936 // Calculate the multicol containing block's block size so that the
3937 // children with percentage block size get correct percentage basis.
3943 // Use column-width as the containing block's inline-size, i.e. the column
3944 // content's computed inline-size.
3949 // If a ColumnSetWrapper is in a balancing column content, it may be
3950 // pushed or pulled back and forth between column contents. Always add
3951 // NS_FRAME_HAS_DIRTY_CHILDREN bit to it so that its ColumnSet children
3952 // can have a chance to reflow under current block size constraint.
3956 }
3958 // If we are reflowing our ColumnSet children, we want to apply our block
3959 // size constraint to the available block size when constructing reflow
3960 // input for ColumnSet so that ColumnSet can use it to compute its max
3961 // column block size.
3965 contentBSize =
3967 }
3969 // To get the remaining content block-size, subtract the content
3970 // block-size consumed by our previous continuations.
3973 // ColumnSet is not the outermost frame in the column container, so it
3974 // cannot have any margin. We don't need to consider any margin that
3975 // can be generated by "box-decoration-break: clone" as we do in
3976 // BlockReflowState::ComputeBlockAvailSpace().
3982 }
3983 }
3984 }
3985 }
3989 cbSize);
3992 columnSetWrapperHasNoBSizeLeft;
3995 // We only need to set this the first reflow, since if we reflow
3996 // again (and replace childReflowInput) we'll be reflowing it
3997 // again in the same fragment as the previous time.
3999 }
4002 nsReflowStatus frameReflowStatus;
4005 // Set if floatAvailableSpace.HasFloats() is true for any
4006 // iteration of the loop.
4008 }
4010 // We might need to store into mDiscoveredClearance later if it's
4011 // currently null; we want to overwrite any writes that
4012 // brc.ReflowBlock() below does, so we need to remember now
4013 // whether it's empty.
4018 // Reflow the block into the available space
4021 }
4028 }
4036 // No need to retry this loop if there is a break opportunity before the
4037 // child block.
4039 }
4041 // Now the block has a height. Using that height, get the
4042 // available space again and call ComputeBlockAvailSpace again.
4043 // If ComputeBlockAvailSpace gives a different result, we need to
4044 // reflow again.
4047 }
4056 // Restore the height to the position of the next band.
4059 // Determine whether the available space shrunk on either side,
4060 // because (the first time round) we now know the block's height,
4061 // and it may intersect additional floats, or (on later
4062 // iterations) because narrowing the width relative to the
4063 // previous time may cause the block to become taller. Note that
4064 // since we're reflowing the block, narrowing the width might also
4065 // make it shorter, so we must pass aCanGrow as true.
4068 // The size and position we chose before are fine (i.e., they
4069 // don't cause intersecting with floats that requires a change
4070 // in size or position), so we're done.
4072 }
4076 floatAvailableSpace)) {
4077 // Advance to the next band.
4081 }
4082 // ClearFloats might be able to advance us further once we're there.
4086 // Start over with a new available space rect at the new height.
4089 }
4097 }
4099 // We need another reflow.
4104 // We set shouldStoreClearance above to record only the first
4105 // frame that requires clearance.
4108 }
4110 // Exactly what we do now is flexible since we'll definitely be
4111 // reflowed.
4113 }
4116 // We're pushing down the border-box, so we don't apply margin anymore.
4117 // This should never cause us to move up since the call to
4118 // GetFloatAvailableSpaceForBSize above included the margin.
4123 }
4132 // Found a clearance frame, so we need to reflow |frame| a second time.
4133 // Restore the states and start over again.
4138 }
4143 // If an ancestor of ours is going to reflow for clearance, we
4144 // need to avoid calling PlaceBlock, because it unsets dirty bits
4145 // on the child block (both itself, and through its call to
4146 // nsIFrame::DidReflow), and those dirty bits imply dirtiness for
4147 // all of the child block, including the lines it didn't reflow.
4151 }
4153 #if defined(REFLOW_STATUS_COVERAGE)
4155 #endif
4158 // None of the child block fits.
4163 }
4165 // Note: line-break-after a block is a nop
4167 // Try to place the child block.
4168 // Don't force the block to fit if we have positive clearance, because
4169 // pushing it to the next page would give it more room.
4170 // Don't force the block to fit if it's impacted by a float. If it is,
4171 // then pushing it to the next page would give it more room. Note that
4172 // isImpacted doesn't include impact from the block's own floats.
4175 nsCollapsingMargin collapsedBEndMargin;
4176 OverflowAreas overflowAreas;
4184 }
4191 }
4192 }
4196 // Some of the child block fit
4198 // Advance to new Y position
4202 // Continue the block frame now if it didn't completely fit in
4203 // the available space.
4212 // If nextFrame used to be an overflow container, make it a normal
4213 // block
4222 }
4227 }
4229 // Push continuation to a new line, but only if we actually made
4230 // one.
4234 }
4238 // If we need to reflow the continuation of the block child,
4239 // then we'd better reflow our continuation
4242 // We also need to make that continuation's line dirty so
4243 // it gets reflowed when we reflow our next in flow. The
4244 // nif's line must always be either a line of the nif's
4245 // parent block (only if we didn't make a continuation) or
4246 // else one of our own overflow lines. In the latter case
4247 // the line is already marked dirty, so just handle the
4248 // first case.
4252 nifBlock,
4258 }
4259 }
4260 }
4261 }
4263 // The block-end margin for a block is only applied on the last
4264 // flow block. Since we just continued the child block frame,
4265 // we know that line->mFirstChild is not the last flow block
4266 // therefore zero out the running margin value.
4267 #ifdef NOISY_BLOCK_DIR_MARGINS
4273 #endif
4276 // Disconnect the next-in-flow and put it in our overflow tracker
4279 // It already exists, but as a normal next-in-flow, so we need
4280 // to dig it out of the child lists.
4284 }
4286 // Put it in our overflow list
4290 #ifdef NOISY_BLOCK_DIR_MARGINS
4296 #endif
4298 }
4300 #ifdef NOISY_BLOCK_DIR_MARGINS
4306 #endif
4308 }
4309 #ifdef NOISY_BLOCK_DIR_MARGINS
4316 #endif
4319 // The frame reported an incomplete status, but then it also didn't
4320 // fit. This means we need to reflow it again so that it can
4321 // (again) report the incomplete status.
4323 }
4327 // If it's our very first line *or* we're not at the top of the page
4328 // and we have page-break-inside:avoid, then we need to be pushed to
4329 // our parent's next-in-flow.
4332 // Push the line that didn't fit and any lines that follow it
4333 // to our next-in-flow.
4335 }
4336 }
4337 }
4339 }
4341 // Now that we've got its final position all figured out, position any child
4342 // views it may have. Note that the case when frame has a view got handled
4343 // by FinishReflowChild, but that function didn't have the coordinates needed
4344 // to correctly decide whether to reposition child views.
4347 }
4349 #ifdef DEBUG
4351 #endif
4352 }
4355 LineIterator aLine,
4361 // Setup initial coordinate system for reflowing the inline frames
4362 // into. Apply a previous block frame's block-end margin first.
4365 }
4368 LineReflowStatus lineReflowStatus;
4381 // Once upon a time we allocated the first 30 nsLineLayout objects
4382 // on the stack, and then we switched to the heap. At that time
4383 // these objects were large (1100 bytes on a 32 bit system).
4384 // Then the nsLineLayout object was shrunk to 156 bytes by
4385 // removing some internal buffers. Given that it is so much
4386 // smaller, the complexity of 2 different ways of allocating
4387 // no longer makes sense. Now we always allocate on the stack.
4393 }
4405 // If there is no saved break position, then this will set
4406 // set forceBreakInFrame to null and we won't back up, which is
4407 // correct.
4412 }
4413 // restore the float manager state
4415 // Clear out float lists
4419 }
4421 // Don't allow pullup on a subsequent LineReflowStatus::RedoNoPull pass
4426 }
4429 LineIterator aLine,
4432 // Reflow the line again when we reflow at our new position.
4435 }
4438 LineIterator aLine,
4443 }
4450 // Forget all of the floats on the line
4454 // We need to set this flag on the line if any of our reflow passes
4455 // are impacted by floats.
4458 }
4459 #ifdef REALLY_NOISY_REFLOW
4462 #endif
4471 nscoord availBSize;
4475 /* XXX get the height right! */
4477 }
4479 // Make sure to enable resize optimization before we call BeginLineReflow
4480 // because it might get disabled there
4490 // XXX Unfortunately we need to know this before reflowing the first
4491 // inline frame in the line. FIX ME.
4496 }
4501 // Reflow the frames that are already on the line first
4507 // There is a soft break opportunity at the start of the line, because
4508 // we can always move this line down below float(s).
4512 }
4513 }
4515 // need to repeatedly call GetChildCount here, because the child
4516 // count can change during the loop!
4522 // It is possible that one or more of next lines are empty
4523 // (because of DeleteNextInFlowChild). If so, delete them now
4524 // in case we are finished.
4527 // XXX Is this still necessary now that DeleteNextInFlowChild
4528 // uses DoRemoveFrame?
4533 }
4537 "ReflowInlineFrame should never determine that a line "
4539 }
4540 }
4542 // Don't pull up new frames into lines with continuation placeholders
4544 // Pull frames and reflow them until we can't
4549 }
4555 // We just created a continuation for aFrame AND its going
4556 // to end up on this line (e.g. :first-letter
4557 // situation). Therefore we have to loop here before trying
4558 // to pull another frame.
4562 }
4563 }
4564 }
4565 }
4569 // We only need to backup if the line isn't going to be reflowed again anyway
4575 "We shouldn't be backing up more than once! "
4576 "Someone must have set a break opportunity beyond the available width, "
4579 }
4581 // We need to try backing up to before a text run
4582 // XXX It's possible, in fact not unusual, for the break opportunity to
4583 // already be the end of the line. We should detect that and optimize to not
4584 // re-do the line.
4586 // We can back up!
4588 }
4590 // In case we reflow this line again, remember that we don't
4591 // need to force any breaking
4593 }
4596 // This happens only when we have a line that is impacted by
4597 // floats and the first element in the line doesn't fit with
4598 // the floats.
4599 //
4600 // If there's block space available, we either try to reflow the line
4601 // past the current band (if it's non-zero and the band definitely won't
4602 // widen around a shape-outside), otherwise we try one pixel down. If
4603 // there's no block space available, we push the line to the next
4604 // page/column.
4609 // See the analogous code for blocks in BlockReflowState::ClearFloats.
4615 // We should never hit this case if we've placed floats on the
4616 // line; if we have, then the GetFloatAvailableSpace call is wrong
4617 // and needs to happen after the caller pops the float manager
4618 // state.
4622 // Move it down far enough to clear the current band.
4625 // Move it down by one dev pixel.
4627 }
4631 // There's nowhere to retry placing the line, so we want to push
4632 // it to the next page/column where its contents can fit not
4633 // next to a float.
4636 }
4638 // XXX: a small optimization can be done here when paginating:
4639 // if the new Y coordinate is past the end of the block then
4640 // push the line and return now instead of later on after we are
4641 // past the float.
4644 // If we are propagating out a break-before status then there is
4645 // no point in placing the line.
4649 aKeepReflowGoing)) {
4651 // PlaceLine already called GetFloatAvailableSpaceForBSize or its
4652 // variant for us.
4653 }
4654 }
4655 }
4656 #ifdef DEBUG
4660 }
4661 #endif
4664 // aLine may have been pushed to the overflow lines.
4666 // We can't just compare iterators front() to aLine here, since they may be
4667 // in different lists.
4671 // aLine is stale, it's associated with the main line list but it should
4672 // be associated with the overflow line list now
4674 }
4680 }
4681 }
4682 }
4685 }
4687 /**
4688 * Reflow an inline frame. The reflow status is mapped from the frames
4689 * reflow status to the lines reflow status (not to our reflow status).
4690 * The line reflow status is simple: true means keep placing frames
4691 * on the line; false means don't (the line is done). If the line
4692 * has some sort of breaking affect then aLine's break-type will be set
4693 * to something other than StyleClear::None.
4694 */
4702 #ifdef NOISY_FIRST_LETTER
4708 #endif
4713 }
4715 // Reflow the inline frame
4716 nsReflowStatus frameReflowStatus;
4722 }
4724 #ifdef REALLY_NOISY_REFLOW
4727 #endif
4729 #if defined(REFLOW_STATUS_COVERAGE)
4731 #endif
4733 // Send post-reflow notification
4736 /* XXX
4737 This is where we need to add logic to handle some odd behavior.
4738 For one thing, we should usually place at least one thing next
4739 to a left float, even when that float takes up all the width on a line.
4740 see bug 22496
4741 */
4743 // Process the child frames reflow status. There are 5 cases:
4744 // complete, not-complete, break-before, break-after-complete,
4745 // break-after-not-complete. There are two situations: we are a
4746 // block or we are an inline. This makes a total of 10 cases
4747 // (fortunately, there is some overlap).
4751 // Always abort the line reflow (because a line break is the
4752 // minimal amount of break we do).
4755 // XXX what should aLine's break-type be set to in all these cases?
4757 // Break-before cases.
4759 // If we break before the first frame on the line then we must
4760 // be trying to place content where there's no room (e.g. on a
4761 // line with wide floats). Inform the caller to reflow the
4762 // line after skipping past a float.
4765 // It's not the first child on this line so go ahead and split
4766 // the line. We will see the frame again on the next-line.
4769 // If we're splitting the line because the frame didn't fit and it
4770 // was pushed, then mark the line as having word wrapped. We need to
4771 // know that if we're shrink wrapping our width
4774 }
4775 }
4781 // If a float split and its prev-in-flow was followed by a <BR>, then
4782 // combine the <BR>'s float clear type with the inline's float clear type
4783 // (the inline will be the very next frame after the split float).
4789 }
4790 // Break-after cases
4793 }
4795 // Split line, but after the frame just reflowed
4797 aLineReflowStatus);
4802 }
4803 }
4804 }
4805 }
4808 // Create a continuation for the incomplete frame. Note that the
4809 // frame may already have a continuation.
4812 // Remember that the line has wrapped
4815 }
4817 // If we just ended a first-letter frame or reflowed a placeholder then
4818 // don't split the line and don't stop the line reflow...
4819 // But if we are going to stop anyways we'd better split the line.
4823 // Split line after the current frame
4826 aLineReflowStatus);
4827 }
4828 }
4829 }
4836 newFrame =
4843 }
4844 }
4845 #ifdef DEBUG
4847 #endif
4849 }
4863 }
4866 }
4868 nextInFlow =
4870 }
4873 }
4881 }
4889 }
4890 }
4896 }
4905 }
4906 }
4909 }
4921 #ifdef DEBUG
4930 }
4934 }
4935 }
4936 #endif
4941 #ifdef DEBUG
4942 {
4948 }
4950 }
4951 #endif
4953 // Put frames being split out into their own line
4956 #ifdef DEBUG
4959 }
4960 #endif
4962 // Let line layout know that some frames are no longer part of its
4963 // state.
4966 // If floats have been placed whose placeholders have been pushed to the new
4967 // line, we need to reflow the old line again. We don't want to look at the
4968 // frames in the new line, because as a large paragraph is laid out the
4969 // we'd get O(N^2) performance. So instead we just check that the last
4970 // float and the last below-current-line float are still in aLine.
4978 }
4980 #ifdef DEBUG
4982 #endif
4983 }
4984 }
4988 // There is another line
4990 // If the next line is a block line then this line is the last in a
4991 // group of inline lines.
4993 }
4994 // The next line is empty, try the next one
4995 }
4997 // XXX Not sure about this part
4998 // Try our next-in-flows lines to answer the question
5004 }
5005 }
5007 }
5009 // This is the last line - so don't allow justification
5011 }
5019 // Try to position the floats in a nowrap context.
5022 // Trim extra white-space from the line before placing the frames
5025 // Vertically align the frames on this line.
5026 //
5027 // According to the CSS2 spec, section 12.6.1, the "marker" box
5028 // participates in the height calculation of the list-item box's
5029 // first line box.
5030 //
5031 // There are exactly two places a ::marker can be placed: near the
5032 // first or second line. It's only placed on the second line in a
5033 // rare case: when the first line is empty.
5048 }
5051 // We want to consider the floats in the current line when determining
5052 // whether the float available space is shrunk. If mLineBSize doesn't
5053 // exist, we are in the first pass trying to place the line. Calling
5054 // GetFloatAvailableSpace() like we did in BlockReflowState::AddFloat()
5055 // for UpdateBand().
5057 // floatAvailableSpaceWithOldLineBSize is the float available space with
5058 // the old BSize, but including the floats that were added in this line.
5059 LogicalRect floatAvailableSpaceWithOldLineBSize =
5062 : aState
5067 // As we redo for floats, we can't reduce the amount of BSize we're
5068 // checking.
5070 LogicalRect floatAvailableSpaceWithLineBSize =
5071 aState
5076 // If the available space between the floats is smaller now that we
5077 // know the BSize, return false (and cause another pass with
5078 // LineReflowStatus::RedoMoreFloats). We ensure aAvailableSpaceBSize
5079 // never decreases, which means that we can't reduce the set of floats
5080 // we intersect, which means that the available space cannot grow.
5083 // Prepare data for redoing the line.
5086 // Since we want to redo the line, we update aFlowArea by using the
5087 // aFloatStateBeforeLine, which is the float manager's state before the
5088 // line is placed.
5096 // Restore the BSize to the position of the next band.
5099 // Enforce both IStart() and IEnd() never move outwards to prevent
5100 // infinite grow-shrink loops.
5108 }
5111 }
5114 }
5116 #ifdef DEBUG
5126 }
5129 }
5130 }
5131 #endif
5133 // Only block frames horizontally align their children because
5134 // inline frames "shrink-wrap" around their children (therefore
5135 // there is no extra horizontal space).
5138 /**
5139 * We don't care checking for IsLastLine properly if we don't care (if it
5140 * can't change the used text-align value for the line).
5141 *
5142 * In other words, isLastLine really means isLastLineAndWeCare.
5143 */
5151 // From here on, pfd->mBounds rectangles are incorrect because bidi
5152 // might have moved frames around!
5153 OverflowAreas overflowAreas;
5158 }
5160 // Inline lines do not have margins themselves; however they are
5161 // impacted by prior block margins. If this line ends up having some
5162 // height then we zero out the previous block-end margin value that was
5163 // already applied to the line's starting Y coordinate. Otherwise we
5164 // leave it be so that the previous blocks block-end margin can be
5165 // collapsed with a block that follows.
5166 nscoord newBCoord;
5169 // This line has some height. Therefore the application of the
5170 // previous-bottom-margin should stick.
5174 // Don't let the previous-bottom-margin value affect the newBCoord
5175 // coordinate (it was applied in ReflowInlineFrames speculatively)
5176 // since the line is empty.
5177 // We already called |ShouldApplyBStartMargin|, and if we applied it
5178 // then mShouldApplyBStartMargin is set.
5183 }
5190 }
5192 // See if the line fit (our first line always does).
5198 // All our content doesn't fit, start on the next page.
5201 // Push aLine and all of its children and anything else that
5202 // follows to our next-in-flow.
5204 }
5206 }
5208 // Note that any early return before this update of aState.mBCoord
5209 // must either (a) return false or (b) set aKeepReflowGoing to false.
5210 // Otherwise we'll keep reflowing later lines at an incorrect
5211 // position, and we might not come back and clean up the damage later.
5214 // Add the already placed current-line floats to the line
5217 // Any below current line floats to place?
5219 // Reflow the below-current-line floats, which places on the line's
5220 // float list.
5222 }
5224 // When a line has floats, factor them into the overflow areas computations.
5226 // Union the float overflow areas (stored in aState) and the value computed
5227 // by the line layout code.
5232 #ifdef NOISY_OVERFLOW_AREAS
5237 #endif
5238 }
5240 // Apply break-after clearing if necessary
5241 // This must stay in sync with |ReflowDirtyLines|.
5245 }
5247 }
5251 // NOTE: aLineBefore is always a normal line, not an overflow line.
5252 // The following expression will assert otherwise.
5257 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
5261 // Remove floats in the lines from mFloats
5262 nsFrameList floats;
5266 #ifdef DEBUG
5270 }
5271 #endif
5272 // Push the floats onto the front of the overflow out-of-flows list
5275 }
5277 // overflow lines can already exist in some cases, in particular,
5278 // when shrinkwrapping and we discover that the shrinkwap causes
5279 // the height of some child block to grow which creates additional
5280 // overflowing content. In such cases we must prepend the new
5281 // overflow to the existing overflow.
5284 // XXXldb use presshell arena!
5286 }
5296 }
5304 // this takes ownership but it won't delete it immediately so we
5305 // can keep using it.
5308 // Mark all the overflow lines dirty so that they get reflowed when
5309 // they are pulled up by our next-in-flow.
5311 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
5321 }
5322 }
5323 }
5324 }
5326 #ifdef DEBUG
5328 #endif
5329 }
5331 // The overflowLines property is stored as a pointer to a line list,
5332 // which must be deleted. However, the following functions all maintain
5333 // the invariant that the property is never set if the list is empty.
5336 #ifdef DEBUG
5338 #endif
5340 // Steal the prev-in-flow's overflow lines and prepend them.
5347 // Make all the frames on the overflow line list mine.
5350 // Collect overflow containers from our OverflowContainers list that are
5351 // continuations from the frames we picked up from our prev-in-flow, then
5352 // prepend those to ExcessOverflowContainers to ensure the continuations
5353 // are ordered.
5355 nsFrameList ocContinuations;
5367 }
5369 }
5372 }
5373 }
5379 }
5380 }
5381 }
5383 // Make the overflow out-of-flow frames mine too.
5386 // In case we own any next-in-flows of any of the drained frames, then
5387 // move those to the PushedFloat list.
5388 nsFrameList pushedFloats;
5395 }
5396 }
5402 }
5403 }
5406 // Remember to recompute the margins on the first line. This will
5407 // also recompute the correct deltaBCoord if necessary.
5409 }
5410 // The overflow lines have already been marked dirty and their previous
5411 // margins marked dirty also.
5413 // Prepend the overflow frames/lines to our principal list.
5419 }
5420 }
5422 // Now append our own overflow lines.
5424 }
5430 }
5432 // No need to reparent frames in our own overflow lines/oofs, because they're
5433 // already ours. But we should put overflow floats back in mFloats.
5434 // (explicit scope to remove the OOF list before VerifyOverflowSituation)
5435 {
5438 #ifdef DEBUG
5442 }
5443 #endif
5444 // The overflow floats go after our regular floats.
5446 }
5447 }
5451 }
5453 #ifdef DEBUG
5455 #endif
5457 }
5459 /**
5460 * Pushed floats are floats whose placeholders are in a previous
5461 * continuation. They might themselves be next-continuations of a float
5462 * that partially fit in an earlier continuation, or they might be the
5463 * first continuation of a float that couldn't be placed at all.
5464 *
5465 * Pushed floats live permanently at the beginning of a block's float
5466 * list, where they must live *before* any floats whose placeholders are
5467 * in that block.
5468 *
5469 * Temporarily, during reflow, they also live on the pushed floats list,
5470 * which only holds them between (a) when one continuation pushes them to
5471 * its pushed floats list because they don't fit and (b) when the next
5472 * continuation pulls them onto the beginning of its float list.
5473 *
5474 * DrainPushedFloats sets up pushed floats the way we need them at the
5475 * start of reflow; they are then reflowed by ReflowPushedFloats (which
5476 * might push some of them on). Floats with placeholders in this block
5477 * are reflowed by (BlockReflowState/nsLineLayout)::AddFloat, which
5478 * also maintains these invariants.
5479 *
5480 * DrainSelfPushedFloats moves any pushed floats from this block's own
5481 * PushedFloats list back into mFloats. DrainPushedFloats additionally
5482 * moves frames from its prev-in-flow's PushedFloats list into mFloats.
5483 */
5485 // If we're getting reflowed multiple times without our
5486 // next-continuation being reflowed, we might need to pull back floats
5487 // that we just put in the list to be pushed to our next-in-flow.
5488 // We don't want to pull back any next-in-flows of floats on our own
5489 // float list, and we only need to pull back first-in-flows whose
5490 // placeholders were in earlier blocks (since first-in-flows whose
5491 // placeholders are in this block will get pulled appropriately by
5492 // AddFloat, and will then be more likely to be in the correct order).
5493 // FIXME: What if there's a continuation in our pushed floats list
5494 // whose prev-in-flow is in a previous continuation of this block
5495 // rather than this block? Might we need to pull it back so we don't
5496 // report ourselves complete?
5497 // FIXME: Maybe we should just pull all of them back?
5501 // When we pull back floats, we want to put them with the pushed
5502 // floats, which must live at the start of our float list, but we
5503 // want them at the end of those pushed floats.
5504 // FIXME: This isn't quite right! What if they're all pushed floats?
5510 }
5516 // FIXME
5524 // This is a first continuation that was pushed from one of our
5525 // previous continuations. Take it out of the pushed floats
5526 // list and put it in our floats list, before any of our
5527 // floats, but after other pushed floats.
5530 }
5531 }
5532 }
5536 }
5537 }
5538 }
5543 // After our prev-in-flow has completed reflow, it may have a pushed
5544 // floats list, containing floats that we need to own. Take these.
5550 }
5551 }
5552 }
5557 }
5566 }
5571 }
5581 }
5590 }
5592 // This takes ownership of aOverflowLines.
5593 // XXX We should allocate overflowLines from presShell arena!
5603 // Verify that we won't overwrite an existing overflow list
5607 }
5612 }
5616 }
5627 }
5641 }
5642 }
5647 }
5652 }
5657 }
5662 }
5667 }
5672 }
5676 }
5682 }
5689 }
5694 }
5699 }
5701 //////////////////////////////////////////////////////////////////////
5702 // Frame list manipulation routines
5707 }
5713 }
5716 }
5718 // Find the proper last-child for where the append should go
5724 #ifdef NOISY_REFLOW_REASON
5729 }
5733 }
5735 #endif
5740 // Workaround for bug 1399425 in case this bit has been removed from the
5741 // SVGTextFrame just before the parser adds more descendant nodes.
5743 }
5750 }
5751 }
5764 }
5767 }
5769 #ifdef NOISY_REFLOW_REASON
5774 }
5778 }
5780 #endif
5787 }
5788 }
5791 #ifdef NOISY_REFLOW_REASON
5796 #endif
5803 }
5805 // Make sure to mark affected lines dirty for the float frame
5806 // we are removing; this way is a bit messy, but so is the rest of the code.
5807 // See bug 390762.
5815 }
5818 // Skip the call to |FrameNeedsReflow| below by returning now.
5823 }
5828 }
5834 }
5835 // XXX the TEXT_OFFSETS_NEED_FIXING check is a wallpaper for bug 822910.
5839 }
5841 }
5845 // Clear our line cursor, since our lines may change.
5850 }
5852 // Attempt to find the line that contains the previous sibling
5866 // We need to find out which list it's actually in. Assume that
5867 // *if* we have overflow lines, that our primary lines aren't
5868 // huge, but our overflow lines might be.
5873 }
5875 }
5877 // By elimination, the line must be in our overflow lines.
5880 }
5881 }
5894 // XXX_perf This is technically O(N^2) in some cases, but by using
5895 // RFind instead of Find, we make it O(N) in the most common case,
5896 // which is appending content.
5898 // Find the line that contains the previous sibling
5902 // Not in mLines - try overflow lines.
5911 }
5916 // Note: defensive code! RFindLineContaining must not return
5917 // false in this case, so if it does...
5921 }
5922 }
5923 }
5924 }
5926 // Find the frame following aPrevSibling so that we can join up the
5927 // two lists of frames.
5929 // Split line containing aPrevSibling in two if the insertion
5930 // point is somewhere in the middle of the line.
5933 // Split the line in two where the frame(s) are being inserted.
5937 // Mark prevSibLine dirty and as needing textrun invalidation, since
5938 // we may be breaking up text in the line. Its previous line may also
5939 // need to be invalidated because it may be able to pull some text up.
5941 // The new line will also need its textruns recomputed because of the
5942 // frame changes.
5945 }
5949 }
5953 // Walk through the new frames being added and update the line data
5954 // structures to fit.
5965 // If the frame is a block frame, or if there is no previous line or if the
5966 // previous line is a block line we need to make a new line. We also make
5967 // a new line, as an optimization, in the two cases we know we'll need it:
5968 // if the previous line ended with a <br>, or if it has significant
5969 // whitespace and ended in a newline.
5972 // Create a new line for the frame and add its line to the line
5973 // list.
5976 // Append new line after prevSibLine
5980 // New line is going before the other lines
5983 }
5986 // We're adding inline content to prevSibLine, so we need to mark it
5987 // dirty, ensure its textruns are recomputed, and possibly do the same
5988 // to its previous line since that line may be able to pull content up.
5990 }
5993 }
5995 #ifdef DEBUG
5998 #endif
5999 }
6007 }
6009 }
6012 // 'display:block ruby' use the inner (Ruby) frame for insertions.
6015 }
6017 }
6023 }
6024 }
6027 // Find which line contains the float, so we can update
6028 // the float cache.
6032 }
6033 }
6034 }
6037 #ifdef DEBUG
6038 // Floats live in mFloats, or in the PushedFloat or OverflowOutOfFlows
6039 // frame list properties.
6046 }
6047 #endif
6051 }
6055 #if 0
6056 // XXXmats not yet - need to investigate BlockReflowState::mPushedFloats
6057 // first so we don't leave it pointing to a deleted list.
6060 }
6061 #endif
6063 }
6065 {
6069 }
6070 }
6071 }
6074 // The containing block is always the parent of aFrame.
6077 // Remove aFrame from the appropriate list.
6079 // This also deletes the next-in-flows
6083 // First remove aFrame's next-in-flows.
6087 }
6088 // Now remove aFrame from its child list and Destroy it.
6092 }
6093 }
6095 /**
6096 * This helps us iterate over the list of all normal + overflow lines
6097 */
6105 // Try the overflow lines
6113 }
6114 }
6115 }
6116 }
6119 LineIterator aLine)
6121 // This will assert if aLine isn't in mLines of aFrame:
6123 }
6126 LineIterator aLine,
6138 }
6144 }
6146 // Figure out what the right style parent is. This needs to match
6147 // nsCSSFrameConstructor::CreateLetterFrame.
6151 }
6158 // Note that we don't need to worry about changehints for the continuation
6159 // styles: those will be handled by the styleParent already.
6162 parentStyle);
6166 // We also want to update the style on the textframe inside the first-letter.
6167 // We don't need to compute a changehint for this, though, since any changes
6168 // to it are handled by the first-letter anyway.
6172 firstLetterStyle);
6175 // We don't need to update style for textFrame's continuations: it's already
6176 // set up to inherit from parentStyle, which is what we want.
6177 }
6189 }
6194 }
6197 }
6199 }
6202 }
6213 }
6219 // The block has a single line - that must be it!
6222 }
6224 // Try to use the cursor if it exists, otherwise fall back to the first line
6227 // Perform a simultaneous forward and reverse search starting from the
6228 // line cursor.
6232 // rline is positioned on the line containing 'cursor', so it's not
6233 // rline_end. So we can safely increment it (i.e. move it to one line
6234 // earlier) to start searching there.
6241 }
6243 }
6248 }
6250 }
6251 }
6256 }
6258 }
6264 }
6265 }
6266 }
6267 // Didn't find the line
6270 // If we reach here, it means that we have not been able to find the
6271 // desired frame in our in-flow lines. So we should start looking at
6272 // our overflow lines. In order to do that, we set mLine to the end
6273 // iterator so that FindValidLine starts to look at overflow lines,
6274 // if any.
6278 }
6284 }
6286 }
6290 }
6295 }
6300 }
6307 }
6316 }
6321 }
6329 }
6330 }
6332 }
6333 }
6339 }
6346 }
6351 }
6359 }
6360 }
6362 }
6363 }
6365 // This function removes aDeletedFrame and all its continuations. It
6366 // is optimized for deleting a whole series of frames. The easy
6367 // implementation would invoke itself recursively on
6368 // aDeletedFrame->GetNextContinuation, then locate the line containing
6369 // aDeletedFrame and remove aDeletedFrame from that line. But here we
6370 // start by locating aDeletedFrame and then scanning from that point
6371 // on looking for continuations.
6375 // Clear our line cursor, since our lines may change.
6379 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6387 }
6389 }
6391 // Find the line that contains deletedFrame
6396 // Make sure we look in the overflow lines even if the normal line
6397 // list is empty
6403 }
6407 }
6412 }
6421 }
6422 }
6431 }
6433 // If the frame being deleted is the last one on the line then
6434 // optimize away the line->Contains(next-in-flow) call below.
6439 next != line_end
6446 }
6448 // Remove aDeletedFrame from the line
6450 // We should be setting this to null if aDeletedFrame
6451 // is the only frame on the line. HOWEVER in that case
6452 // we will be removing the line anyway, see below.
6454 }
6456 // Hmm, this won't do anything if we're removing a frame in the first
6457 // overflow line... Hopefully doesn't matter
6460 // Since we just removed a frame that follows some inline
6461 // frames, we need to reflow the previous line.
6463 }
6466 // Take aDeletedFrame out of the sibling list. Note that
6467 // prevSibling will only be nullptr when we are deleting the very
6468 // first frame in the main or overflow list.
6473 }
6475 // Update the child count of the line to be accurate
6478 // Destroy frame; capture its next continuation first in case we need
6479 // to destroy that too.
6484 #ifdef NOISY_REMOVE_FRAME
6490 #endif
6492 // If next-in-flow is an overflow container, must remove it first.
6494 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6498 }
6504 // If line is empty, remove it now.
6506 #ifdef NOISY_REMOVE_FRAME
6509 #endif
6513 // Invalidate the space taken up by the line.
6514 // XXX We need to do this if we're removing a frame as a result of
6515 // a call to RemoveFrame(), but we may not need to do this in all
6516 // cases...
6517 #ifdef NOISY_BLOCK_INVALIDATE
6521 #endif
6527 // We just invalidated our iterators. Since we were in
6528 // the overflow lines list, which is now empty, set them
6529 // so we're at the end of the regular line list.
6533 }
6534 }
6537 // If we're removing a line, ReflowDirtyLines isn't going to
6538 // know that it needs to slide lines unless something is marked
6539 // dirty. So mark the previous margin of the next line dirty if
6540 // there is one.
6543 }
6546 // Make the line that just lost a frame dirty, and advance to
6547 // the next line.
6553 }
6554 }
6557 // See if we should keep looking in the current flow's line list.
6559 // The deceased frames continuation is not a child of the
6560 // current block. So break out of the loop so that we advance
6561 // to the next parent.
6562 //
6563 // If we have a continuation in a different block then all bets are
6564 // off regarding whether we are deleting frames without actual content,
6565 // so don't propagate FRAMES_ARE_EMPTY any further.
6568 }
6570 // If we advanced to the next line then check if we should switch to the
6571 // overflow line list.
6575 // We have advanced to the next *normal* line but the next-in-flow
6576 // is not there - force a switch to the overflow line list.
6578 }
6582 #ifdef NOISY_REMOVE_FRAME
6585 #endif
6586 }
6587 }
6588 }
6593 }
6595 #ifdef DEBUG
6598 #endif
6600 // Advance to next flow block if the frame has more continuations.
6603 }
6608 }
6620 }
6621 }
6623 }
6633 // Optimize by comparing the line's last child first.
6640 }
6641 }
6642 }
6644 }
6652 }
6660 }
6664 }
6682 }
6683 }
6684 }
6693 }
6698 // The line became empty - destroy it.
6703 }
6705 }
6706 }
6713 NS_FRAME_IS_OVERFLOW_CONTAINER)) {
6716 #ifdef DEBUG
6719 }
6720 #endif
6722 }
6723 }
6726 // Return the pointer to an unmodified style text
6728 }
6740 // Setup a block reflow context to reflow the float.
6745 nsCollapsingMargin margin;
6748 // Only first in flow gets a block-start margin.
6755 // We don't need to push the float manager state because the the block
6756 // has its own float manager that will be destroyed and recreated
6757 }
6758 }
6760 // When reflowing a float, aSpace argument doesn't matter because we pass
6761 // nullptr to aLine and we don't call nsBlockReflowContext::PlaceBlock()
6762 // later.
6768 // We never split floating first letters; an incomplete status for such
6769 // frames simply means that there is more content to be reflowed on the
6770 // line.
6773 }
6774 }
6778 "The status can only be incomplete or overflow-incomplete if "
6783 }
6787 // Set the rect, make sure the view is properly sized and positioned,
6788 // and tell the frame we're done reflowing it
6789 // XXXldb This seems like the wrong place to be doing this -- shouldn't
6790 // we be doing this in BlockReflowState::FlowAndPlaceFloat after
6791 // we've positioned the float, and shouldn't we be doing the equivalent
6792 // of |PlaceFrameView| here?
6799 }
6801 }
6809 }
6810 }
6812 }
6816 // Pushed floats live at the start of our float list; see comment
6817 // above nsBlockFrame::DrainPushedFloats.
6822 // When we push a first-continuation float in a non-initial reflow,
6823 // it's possible that we end up with two continuations with the same
6824 // parent. This happens if, on the previous reflow of the block or
6825 // a previous reflow of the line containing the block, the float was
6826 // split between continuations A and B of the parent, but on the
6827 // current reflow, none of the float can fit in A.
6828 //
6829 // When this happens, we might even have the two continuations
6830 // out-of-order due to the management of the pushed floats. In
6831 // particular, if the float's placeholder was in a pushed line that
6832 // we reflowed before it was pushed, and we split the float during
6833 // that reflow, we might have the continuation of the float before
6834 // the float itself. (In the general case, however, it's correct
6835 // for floats in the pushed floats list to come before floats
6836 // anchored in pushed lines; however, in this case it's wrong. We
6837 // should probably find a way to fix it somehow, since it leads to
6838 // incorrect layout in some cases.)
6839 //
6840 // When we have these out-of-order continuations, we might hit the
6841 // next-continuation before the previous-continuation. When that
6842 // happens, just push it. When we reflow the next continuation,
6843 // we'll either pull all of its content back and destroy it (by
6844 // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
6845 // pull it out of its current position and push it again (and
6846 // potentially repeat this cycle for the next continuation, although
6847 // hopefully then they'll be in the right order).
6848 //
6849 // We should also need this code for the in-order case if the first
6850 // continuation of a float gets moved across more than one
6851 // continuation of the containing block. In this case we'd manage
6852 // to push the second continuation without this check, but not the
6853 // third and later.
6860 }
6862 // Always call FlowAndPlaceFloat; we might need to place this float if it
6863 // didn't belong to this block the last time it was reflowed. Note that if
6864 // the float doesn't get placed, we don't consider its overflow areas.
6865 // (Not-getting-placed means it didn't fit and we pushed it instead of
6866 // placing it, and its position could be stale.)
6870 }
6874 // We didn't push |f| so its next-sibling is next.
6879 }
6881 // If there are pushed or split floats, then we may need to continue BR
6882 // clearance
6888 }
6889 }
6890 }
6894 // Recover our own floats
6896 // belong to our next-in-flow
6903 }
6904 }
6906 // Recurse into our overflow container children
6911 }
6913 // Recurse into our normal children
6917 }
6918 }
6919 }
6923 WritingMode aWM,
6927 // Only blocks have floats
6929 // Don't recover any state inside a block that has its own float manager
6930 // (we don't currently have any blocks like this, though, thanks to our
6931 // use of extra frames for 'overflow')
6933 // If the element is relatively positioned, then adjust x and y
6934 // accordingly so that we consider relatively positioned frames
6935 // at their original position.
6943 }
6944 }
6948 // If we have pushed floats, then they should be at the beginning of our
6949 // float list.
6952 }
6953 }
6955 #ifdef DEBUG
6956 // Double-check the above assertion that pushed floats should be at the
6957 // beginning of our floats list.
6961 }
6962 #endif
6964 // We may have a pending push of pushed floats too:
6966 // XXX we can return 'true' here once we make HasPushedFloats
6967 // not lie. (see nsBlockFrame::RemoveFloat)
6970 }
6972 }
6974 //////////////////////////////////////////////////////////////////////
6975 // Painting, event handling
6977 #ifdef DEBUG
6983 // Compute min and max x/y values for the reflowed frame's
6984 // combined areas
6992 }
6995 }
6998 }
7001 }
7002 }
7008 }
7009 #endif
7011 #ifdef DEBUG
7020 }
7021 }
7022 #endif
7030 #ifdef DEBUG
7032 aDrawnLines++;
7033 }
7037 #endif
7039 // Collect our line's display items in a temporary nsDisplayListCollection,
7040 // so that we can apply any "text-overflow" clipping to the entire collection
7041 // without affecting previous lines.
7044 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
7045 // Inline-level child backgrounds go on the regular child content list.
7047 collection,
7051 aLineInLine
7060 }
7064 aLineNumberForTextOverflow);
7065 }
7068 }
7074 #ifdef DEBUG
7078 nsRect ca;
7085 }
7090 }
7091 #endif
7093 // TODO(heycam): Should we boost the load priority of any shape-outside
7094 // images using CATEGORY_DISPLAY, now that this block is being displayed?
7095 // We don't have a float manager here.
7104 }
7105 }
7106 }
7111 // Display outside ::marker manually.
7113 }
7115 // Prepare for text-overflow processing.
7124 // TODO(miko): Unfortunately |descendAlways| cannot be cached, because with
7125 // some frame trees, building display list for child lines can change it.
7126 // See bug 1552789.
7134 };
7138 // We'll try to draw an accessibility backplate behind text (to ensure it's
7139 // readable over any possible background-images), if all of the following
7140 // hold:
7141 // (A) the backplate feature is preffed on
7142 // (B) we are not honoring the document colors
7146 }
7148 // Don't use the line cursor if we might have a descendant placeholder ...
7149 // it might skip lines that contain placeholders but don't themselves
7150 // intersect with the dirty area.
7151 // In particular, we really want to check ShouldDescendIntoFrame()
7152 // on all our child frames, but that might be expensive. So we
7153 // approximate it by checking it on |this|; if it's true for any
7154 // frame in our child list, it's also true for |this|.
7155 // Also skip the cursor if we're creating text overflow markers,
7156 // since we need to know what line number we're up to in order
7157 // to generate unique display item keys.
7158 // Lastly, the cursor should be skipped if we're drawing
7159 // backplates behind text. When backplating we consider consecutive
7160 // runs of text as a whole, which requires we iterate through all lines
7161 // to find our backplate size.
7174 // Because we have a cursor, the combinedArea.ys are non-decreasing.
7175 // Once we've passed aDirtyRect.YMost(), we can never see it again.
7178 }
7184 }
7185 }
7186 }
7193 // A frame's display list cannot contain more than one copy of a
7194 // given display item unless the items are uniquely identifiable.
7195 // Because backplate occasionally requires multiple
7196 // SolidColor items, we use an index (backplateIndex) to maintain
7197 // uniqueness among them. Note this is a mapping of index to
7198 // item, and the mapping is stable even if the dirty rect changes.
7200 nsRect curBackplateArea;
7206 };
7215 }
7218 // If we have encountered a non-inline line but were previously
7219 // forming a backplate, we should add the backplate to the display
7220 // list as-is and render future backplates disjointly.
7222 "if this master switch is off, curBackplateArea "
7225 backplateIndex++;
7227 }
7232 }
7242 }
7243 }
7244 }
7245 lineCount++;
7246 }
7250 }
7254 }
7255 }
7258 // Put any text-overflow:ellipsis markers on top of the non-positioned
7259 // content of the block's lines. (If we ever start sorting the Content()
7260 // list this will end up in the wrong place.)
7262 }
7264 #ifdef DEBUG
7271 }
7285 }
7286 #endif
7287 }
7289 #ifdef ACCESSIBILITY
7293 }
7295 // block frame may be for <hr>
7298 }
7301 // XXXsmaug What if we're in the shadow dom?
7303 // Don't create accessible objects for the root content node, they are
7304 // redundant with the nsDocAccessible object created with the document
7305 // node
7307 }
7310 // Don't create accessible objects for the body, they are redundant with
7311 // the nsDocAccessible object created with the document node
7313 }
7315 // Not a list item with a ::marker, treat as normal HTML container.
7317 }
7319 // Create special list item accessible since we have a ::marker.
7321 }
7322 #endif
7327 }
7331 }
7336 }
7340 }
7343 // Although this looks like a "querying" method, it is used by the
7344 // display-list building code, so uses the Display cursor.
7348 }
7356 }
7361 }
7365 }
7368 }
7370 /* virtual */
7372 // See if the child is absolutely positioned
7374 // do nothing
7376 // The ::marker lives in the first line, unless the first line has
7377 // height 0 and there is a second line, in which case it lives
7378 // in the second line.
7383 }
7387 }
7388 // otherwise we have an empty line list, and ReflowDirtyLines
7389 // will handle reflowing the ::marker.
7391 // Note that we should go through our children to mark lines dirty
7392 // before the next reflow. Doing it now could make things O(N^2)
7393 // since finding the right line is O(N).
7394 // We don't need to worry about marking lines on the overflow list
7395 // as dirty; we're guaranteed to reflow them if we take them off the
7396 // overflow list.
7397 // However, we might have gotten a float, in which case we need to
7398 // reflow the line containing its placeholder. So find the
7399 // ancestor-or-self of the placeholder that's a child of the block,
7400 // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
7401 // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7402 // We need to take some care to handle the case where a float is in
7403 // a different continuation than its placeholder, including marking
7404 // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
7411 // SVG code sometimes sends FrameNeedsReflow notifications during
7412 // frame destruction, leading to null placeholders, but we're safe
7413 // ignoring those.
7421 }
7423 }
7425 }
7426 }
7427 }
7430 }
7434 // These are all the block specific frame bits, they are copied from
7435 // the prev-in-flow to a newly created next-in-flow, except for the
7436 // NS_BLOCK_FLAGS_NON_INHERITED_MASK bits below.
7438 NS_BLOCK_FORMATTING_CONTEXT_STATE_BITS |
7441 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7443 // This is the subset of NS_BLOCK_FLAGS_MASK that is NOT inherited
7444 // by default. They should only be set on the first-in-flow.
7447 NS_BLOCK_FRAME_HAS_INSIDE_MARKER;
7450 // Copy over the inherited block frame bits from the prev-in-flow.
7454 }
7461 }
7463 // A display:flow-root box establishes a block formatting context.
7464 //
7465 // If a box has a different writing-mode value than its containing block:
7466 // ...
7467 // If the box is a block container, then it establishes a new block
7468 // formatting context.
7469 // (https://drafts.csswg.org/css-writing-modes/#block-flow)
7470 //
7471 // If the box has contain: paint or contain:layout (or contain:strict),
7472 // then it should also establish a formatting context.
7473 //
7474 // Per spec, a column-span always establishes a new block formatting context.
7484 }
7488 }
7489 }
7496 #ifdef DEBUG
7497 // The only times a block that is an anonymous box is allowed to have a
7498 // first-letter frame are when it's the block inside a non-anonymous cell,
7499 // the block inside a fieldset, button or column set, or a scrolled content
7500 // block, except for <select>. Note that this means that blocks which are
7501 // the anonymous block in {ib} splits do NOT get first-letter frames.
7502 // Note that NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations
7503 // of the block.
7521 #endif
7526 }
7527 }
7532 NS_BLOCK_FRAME_HAS_OUTSIDE_MARKER),
7540 // An outside ::marker needs to be an independent formatting context
7541 // to avoid being influenced by the float manager etc.
7543 }
7547 }
7548 }
7559 }
7564 nscoord aLineTop) {
7569 // Make up an inline-size since it doesn't really matter (XXX).
7575 nsReflowStatus status;
7578 // Get the float available space using our saved state from before we
7579 // started reflowing the block, so that we ignore any floats inside
7580 // the block.
7581 // FIXME: aLineTop isn't actually set correctly by some callers, since
7582 // they reposition the line.
7583 LogicalRect floatAvailSpace =
7584 aState
7588 // FIXME (bug 25888): need to check the entire region that the first
7589 // line overlaps, not just the top pixel.
7591 // Place the ::marker now. We want to place the ::marker relative to the
7592 // border-box of the associated block (using the right/left margin of
7593 // the ::marker frame as separation). However, if a line box would be
7594 // displaced by floats that are *outside* the associated block, we
7595 // want to displace it by the same amount. That is, we act as though
7596 // the edge of the floats is the content-edge of the block, and place
7597 // the ::marker at a position offset from there by the block's padding,
7598 // the block's border, and the ::marker frame's margin.
7600 // IStart from floatAvailSpace gives us the content/float start edge
7601 // in the current writing mode. Then we subtract out the start
7602 // border/padding and the ::marker's width and margin to offset the position.
7604 // Get the ::marker's margin, converted to our writing mode so that we can
7605 // combine it with other logical values here.
7611 // Approximate the ::marker's position; vertical alignment will provide
7612 // the final vertical location. We pass our writing-mode here, because
7613 // it may be different from the ::marker frame's mode.
7616 wm,
7620 }
7622 // This is used to scan frames for any float placeholders, add their
7623 // floats to the list represented by aList, and remove the
7624 // floats from whatever list they might be in. We don't search descendants
7625 // that are float containing blocks. Floats that or not children of 'this'
7626 // are ignored (they are not added to aList).
7630 // Don't descend into float containing blocks.
7638 // Remove the IS_PUSHED_FLOAT bit, in case |outOfFlowFrame| came from
7639 // the PushedFloats list.
7643 // FIXME: By not pulling floats whose parent is one of our
7644 // later siblings, are we risking the pushed floats getting
7645 // out-of-order?
7646 // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
7647 }
7653 }
7656 }
7658 }
7659 }
7662 #ifdef DEBUG
7663 // If any line is still dirty, that must mean we're going to reflow this
7664 // block again soon (e.g. because we bailed out after noticing that
7665 // clearance was imposed), so don't worry if the floats are out of sync.
7668 // Check that the float list is what we would have built
7673 }
7676 }
7677 }
7685 }
7689 }
7691 }
7696 "nsBlockFrame::CheckFloats: Explicit float list is out of sync with "
7698 # if defined(DEBUG_roc)
7702 }
7705 }
7706 # endif
7707 }
7708 #endif
7712 // Floats that were pushed should be removed from our float
7713 // manager. Otherwise the float manager's YMost or XMost might
7714 // be larger than necessary, causing this block to get an
7715 // incorrect desired height (or width). Some of these floats
7716 // may not actually have been added to the float manager because
7717 // they weren't reflowed before being pushed; that's OK,
7718 // RemoveRegions will ignore them. It is safe to do this here
7719 // because we know from here on the float manager will only be
7720 // used for its XMost and YMost, not to place new floats and
7721 // lines.
7723 }
7724 }
7734 }
7735 }
7738 // The first column is a start margin root and the last column is an end
7739 // margin root. (If the column-set is split by a column-span:all box then
7740 // the first and last column in each column-set fragment are margin roots.)
7744 }
7748 }
7750 /* static */
7758 }
7760 /* static */
7765 }
7767 // Note that this width can vary based on the vertical position.
7768 // However, the cases where it varies are the cases where the width fits
7769 // in the available space given, which means that variation shouldn't
7770 // matter.
7771 /* static */
7778 FloatAvoidingISizeToClear result;
7781 nscoord availISize =
7784 // We actually don't want the min width here; see bug 427782; we only
7785 // want to displace if the width won't compute to a value small enough
7786 // to fit.
7787 // All we really need here is the result of ComputeSize, and we
7788 // could *almost* get that from an SizeComputationInput, except for the
7789 // last argument.
7791 LogicalSize availSpace =
7798 // Use the margins from sizingInput rather than reflowInput so that
7799 // they aren't reduced by ignoring margins in overconstrained cases.
7808 // If we get here, floatAvoidingBlock has a negative amount of inline-axis
7809 // margin and an 'auto' (or ~equivalently, -moz-available) inline
7810 // size. Under these circumstances, we use the margin to establish a
7811 // (positive) minimum size for the border-box, in order to satisfy the
7812 // equation in CSS2 10.3.3. That equation essentially simplifies to the
7813 // following:
7814 //
7815 // iSize of margins + iSize of borderBox = iSize of containingBlock
7816 //
7817 // ...where "iSize of borderBox" is the sum of floatAvoidingBlock's
7818 // inline-axis components of border, padding, and {width,height}.
7819 //
7820 // Right now, in the above equation, "iSize of margins" is the only term
7821 // that we know for sure. (And we also know that it's negative, since we
7822 // got here.) The other terms are as-yet unresolved, since the frame has an
7823 // 'auto' iSize, and since we aren't yet sure if we'll clear this frame
7824 // beyond floats or place it alongside them.
7825 //
7826 // However: we *do* know that the equation's "iSize of containingBlock"
7827 // term *must* be non-negative, since boxes' widths and heights generally
7828 // can't be negative in CSS. To satisfy that requirement, we can then
7829 // infer that the equation's "iSize of borderBox" term *must* be large
7830 // enough to cancel out the (known-to-be-negative) "iSize of margins"
7831 // term. Therefore, marginISize value (negated to make it positive)
7832 // establishes a lower-bound for how much inline-axis space our border-box
7833 // will really require in order to fit alongside any floats.
7834 //
7835 // XXXdholbert This explanation is admittedly a bit hand-wavy and may not
7836 // precisely match what any particular spec requires. It's the best
7837 // reasoning I could come up with to explain engines' behavior. Also, our
7838 // behavior with -moz-available doesn't seem particularly correct here, per
7839 // bug 1767217, though that's probably due to a bug elsewhere in our float
7840 // handling code...
7842 }
7846 }
7848 /* static */
7854 // yay, candidate is a block!
7856 }
7857 // Not a block. Check its parent next.
7859 }
7862 }
7865 nscoord aBEndEdgeOfChildren) {
7876 "An overflow container's effective content-box block-size, block-start "
7888 // If a block is split by any column-spans, we calculate the final
7889 // block-size by shrinkwrapping our children's block-size for all the
7890 // fragments except for those after the final column-span, but we should
7891 // take no more than our effective border-box block-size. If there's any
7892 // leftover block-size, our next continuations will take up rest.
7893 //
7894 // We don't need to adjust aBri.mReflowStatus because our children's status
7895 // is the same as ours.
7897 }
7902 }
7904 // Save our children's reflow status.
7911 }
7917 // The maximum value our content-box block-size can take within the given
7918 // available block-size.
7921 // The block-end edge of our content-box (relative to this frame's origin) if
7922 // we consumed the maximum block-size available to us (maxContentBoxBSize).
7925 // These variables are uninitialized intentionally so that the compiler can
7926 // check they are assigned in every if-else branch below.
7927 nscoord finalContentBoxBSizeWithBStartBP;
7931 // Our effective border-box block-size can fit in the available block-size,
7932 // so we are complete.
7936 // Note: The following assertion should generally hold because, for
7937 // box-decoration-break:clone, this "else if" branch is mathematically
7938 // equivalent to the initial "if".
7940 "This else-if branch is handling a situation that's specific "
7941 "to box-decoration-break:slice, i.e. a case when we can skip "
7944 // Our effective content-box block-size plus the block-start border and
7945 // padding can fit in the available block-size, but it cannot fit after
7946 // adding the block-end border and padding. Thus, we need a continuation
7947 // (unless we already weren't asking for any block-size, in which case we
7948 // stay complete to avoid looping forever).
7952 // We aren't going to be able to fit our content-box in the space available
7953 // to it, which means we'll probably call ourselves incomplete to request a
7954 // continuation. But before making that decision, we check for certain
7955 // conditions which would force us to overflow beyond the available space --
7956 // these might result in us actually being complete if we're forced to
7957 // overflow far enough.
7961 // In this rare case, we are at the top of page/column, we have
7962 // box-decoration-break:clone and zero available block-size for our
7963 // content-box (e.g. our own block-start border and padding already exceed
7964 // the available block-size), and we didn't lay out any child to consume
7965 // our content-box block-size. To ensure we make progress (avoid looping
7966 // forever), use 1px as our content-box block-size regardless of our
7967 // effective content-box block-size, in the spirit of
7968 // https://drafts.csswg.org/css-break/#breaking-rules.
7972 // We have a unbreakable child whose block-end edge exceeds the available
7973 // block-size for children.
7975 // The unbreakable child's block-end edge forces us to consume all of
7976 // our effective content-box block-size.
7979 // Even though we've consumed all of our effective content-box
7980 // block-size, we may still need to report an incomplete status in order
7981 // to get another continuation, which will be responsible for laying out
7982 // & drawing our block-end border & padding. But if we have no such
7983 // border & padding, or if we're forced to apply that border & padding
7984 // on this frame due to box-decoration-break:clone, then we don't need
7985 // to bother with that additional continuation.
7988 // The unbreakable child's block-end edge doesn't force us to consume
7989 // all of our effective content-box block-size.
7992 }
7994 // The children's block-end edge can fit in the content-box space that we
7995 // have available for it. Consume all the space that is available so that
7996 // our inline-start/inline-end borders extend all the way to the block-end
7997 // edge of column/page.
8000 }
8001 }
8007 // We want to use children's reflow status as ours, which can be overflow
8008 // incomplete. Suppress the urge to call aBri.mReflowStatus.Reset() here.
8011 }
8014 "An overflow container should always be complete because of "
8017 finalBorderBoxBSize =
8019 }
8023 }
8024 }
8027 }
8034 }
8037 // first-letter needs to be updated before first-line, because first-line can
8038 // change the style of the first-letter.
8041 }
8052 // FIXME(bz): Can we make first-line continuations be non-inheriting anon
8053 // boxes?
8061 // We also want to update the styles of the first-line's descendants. We
8062 // don't need to compute a changehint for this, though, since any changes to
8063 // them are handled by the first-line anyway.
8067 }
8068 }
8069 }
8073 // Certainly no first-letter frame.
8075 }
8078 }
8084 }
8087 }
8089 #ifdef DEBUG
8093 }
8096 }
8100 // Add up the counts on each line. Also validate that IsFirstLine is
8101 // set properly.
8106 }
8111 }
8112 }
8114 }
8116 // Then count the frames
8120 frameCount++;
8122 }
8125 // Next: test that each line has right number of frames on it
8132 }
8136 }
8137 }
8148 }
8149 }
8150 }
8151 }
8153 }
8156 // Overflow out-of-flows must not have a next-in-flow in mFloats or mFrames.
8163 }
8164 }
8166 // Pushed floats must not have a next-in-flow in mFloats or mFrames.
8173 }
8174 }
8176 // A child float next-in-flow's parent must be |this| or a next-in-flow of
8177 // |this|. Later next-in-flows must have the same or later parents.
8192 }
8193 }
8195 found,
8197 }
8198 }
8199 }
8212 }
8216 }
8220 ;
8225 ;
8226 }
8228 };
8234 }
8235 }
8242 depth++;
8243 }
8245 }
8251 }
8252 #endif