| blob | 14d38974ed6022797baeb38272b7a7cd12ac3218 |
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 // vim:cindent:ts=2:et:sw=2:
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 */
41 #include <algorithm>
42 #ifdef ACCESSIBILITY
44 #endif
53 #ifdef IBMBIDI
63 #define DISABLE_FLOAT_BREAKING_IN_COLUMNS
69 #ifdef DEBUG
88 };
100 };
101 #define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
103 static void
105 {
111 }
114 }
116 void
118 {
139 }
140 }
143 }
148 }
151 }
152 }
153 }
154 }
156 #endif
158 // add in a sanity check for absurdly deep frame trees. See bug 42138
159 // can't just use IsFrameTreeTooDeep() because that method has side effects we don't want
162 //----------------------------------------------------------------------
164 // Debugging support code
166 #ifdef DEBUG
173 };
174 #endif
176 #ifdef REALLY_NOISY_FIRST_LINE
177 static void
179 {
189 }
191 }
192 #endif
194 #ifdef REFLOW_STATUS_COVERAGE
195 static void
197 {
200 // 0: child-is-block
201 // 1: child-is-inline
205 // Compute new status
210 }
213 }
216 }
217 }
220 }
223 }
225 // Log updates to the status that yield different values
229 }
230 }
231 #endif
233 // Destructor function for the overflowLines frame property
234 static void
236 {
238 }
246 //----------------------------------------------------------------------
248 nsIFrame*
250 {
254 }
259 {
260 }
262 void
264 {
279 }
281 // destroy overflow lines now
287 }
293 }
299 }
302 }
306 {
316 }
318 }
324 nsSplittableType
326 {
328 }
330 #ifdef DEBUG
331 void
333 {
338 aIndent++;
340 // Output the lines
345 }
346 }
348 // Output the overflow lines.
357 }
360 }
362 // skip the principal list - we printed the lines above
363 // skip the overflow list - we printed the overflow lines above
369 }
377 }
380 }
382 aIndent--;
385 }
389 {
390 // We don't want to include our cursor flag in the bits the
391 // regression tester looks at
393 }
395 NS_IMETHODIMP
397 {
399 }
400 #endif
402 nsIAtom*
404 {
406 }
408 void
410 {
416 }
418 }
420 void
422 {
428 }
430 }
432 nscoord
434 {
435 nscoord result;
439 }
441 nscoord
443 {
452 }
453 }
460 }
462 /////////////////////////////////////////////////////////////////////////////
463 // Child frame enumeration
467 {
474 }
480 }
484 }
488 }
491 }
492 }
494 void
496 {
501 }
505 }
510 }
514 }
515 }
519 {
521 }
523 static void
525 {
531 // When pushing and pulling frames we need to check for whether any
532 // views need to be reparented
535 }
537 static void
540 {
543 }
544 }
546 /**
547 * Remove the first line from aFromLines and adjust the associated frame list
548 * aFromFrames accordingly. The removed line is assigned to *aOutLine and
549 * a frame list with its frames is assigned to *aOutFrames, i.e. the frames
550 * that were extracted from the head of aFromFrames.
551 * aFromLines must contain at least one line, the line may be empty.
552 * @return true if aFromLines becomes empty
553 */
554 static bool
557 {
567 }
569 //////////////////////////////////////////////////////////////////////
570 // Reflow methods
574 {
582 }
583 }
586 }
588 void
590 {
594 }
605 }
606 }
607 }
609 /* virtual */ nscoord
611 {
623 #ifdef DEBUG
628 }
630 #endif
635 }
639 InlineMinWidthData data;
644 {
645 #ifdef DEBUG
651 }
653 #endif
662 // Only add text-indent if it has no percentages; using a
663 // percentage basis of 0 unconditionally would give strange
664 // behavior for calc(10%-3px).
668 }
669 // XXX Bug NNNNNN Should probably handle percentage text-indent.
677 }
678 }
679 #ifdef DEBUG
684 }
685 #endif
686 }
687 }
692 }
694 /* virtual */ nscoord
696 {
708 #ifdef DEBUG
713 }
715 #endif
720 }
724 InlinePrefWidthData data;
729 {
730 #ifdef DEBUG
736 }
738 #endif
747 // Only add text-indent if it has no percentages; using a
748 // percentage basis of 0 unconditionally would give strange
749 // behavior for calc(10%-3px).
753 }
754 // XXX Bug NNNNNN Should probably handle percentage text-indent.
762 }
763 }
764 #ifdef DEBUG
769 }
770 #endif
771 }
772 }
777 }
779 nsRect
781 {
782 // be conservative
785 }
787 }
789 static bool
792 {
794 // Positions are not significant if the width is zero.
796 }
801 }
803 static nsSize
805 nsSize aFrameSize)
806 {
807 // The issue here is that for a 'height' of 'auto' the reflow state
808 // code won't know how to calculate the containing block height
809 // because it's calculated bottom up. So we use our own computed
810 // size as the dimensions.
814 // Containing block is relative to the padding edge
822 // We are a wrapped frame for the content (and the wrapper is not the
823 // canvas frame, whose size is not meaningful here).
824 // Use the container's dimensions, if they have been precomputed.
825 // XXX This is a hack! We really should be waiting until the outermost
826 // frame is fully reflowed and using the resulting dimensions, even
827 // if they're intrinsic.
828 // In fact we should be attaching absolute children to the outermost
829 // frame and not always sticking them in block frames.
831 // First, find the reflow state for the outermost frame for this
832 // content.
839 }
841 // Scrollbars need to be specifically excluded, if present, because they are outside the
842 // padding-edge. We need better APIs for getting the various boxes from a frame.
846 scrollbars =
851 }
854 }
855 }
856 // We found a reflow state for the outermost wrapping frame, so use
857 // its computed metrics if available
861 }
865 }
866 }
867 }
870 }
872 NS_IMETHODIMP
877 {
880 #ifdef DEBUG
887 }
894 }
895 #endif
900 consumedHeight);
902 // If we have non-auto height, we're clipping our kids and we fit,
903 // make sure our kids fit too.
911 // Bottom margin never causes us to create continuations, so we
912 // don't need to worry about whether it fits in its entirety.
914 }
921 }
922 }
924 // See comment below about oldSize. Use *only* for the
925 // abs-pos-containing-block-size-change optimization!
928 // Should we create a float manager?
931 // XXXldb If we start storing the float manager in the frame rather
932 // than keeping it around only during reflow then we should create it
933 // only when there are actually floats to manage. Otherwise things
934 // like tables will gain significant bloat.
939 // OK, some lines may be reflowed. Blow away any saved line cursor
940 // because we may invalidate the nondecreasing
941 // overflowArea.VisualOverflow().y/yMost invariant, and we may even
942 // delete the line with the line cursor.
947 }
952 // Cache the consumed height in the block reflow state so that we don't have
953 // to continually recompute it.
956 consumedHeight);
958 #ifdef IBMBIDI
965 }
969 // ALWAYS drain overflow. We never want to leave the previnflow's
970 // overflow lines hanging around; block reflow depends on the
971 // overflow line lists being cleared out between reflow passes.
974 // Handle paginated overflow (see nsContainerFrame.h)
975 nsOverflowAreas ocBounds;
979 ocStatus);
980 }
982 // Now that we're done cleaning up our overflow container lists, we can
983 // give |state| its nsOverflowContinuationTracker.
987 // Drain & handle pushed floats
989 nsOverflowAreas fcBounds;
993 // If we're not dirty (which means we'll mark everything dirty later)
994 // and our width has changed, mark the lines dirty that we need to
995 // mark dirty for a resize reflow.
998 }
1004 // Now reflow...
1007 // If we have a next-in-flow, and that next-in-flow has pushed floats from
1008 // this frame from a previous iteration of reflow, then we should not return
1009 // a status of NS_FRAME_COMPLETE, since we actually have overflow, it's just
1010 // already been handled.
1012 // NOTE: This really shouldn't happen, since we _should_ pull back our floats
1013 // and reflow them, but just in case it does, this is a safety precaution so
1014 // we don't end up with a placeholder pointing to frames that have already
1015 // been deleted as part of removing our next-in-flow.
1021 }
1024 }
1025 }
1033 // If we end in a BR with clear and affected floats continue,
1034 // we need to continue, too.
1039 }
1044 }
1046 #ifdef DEBUG_kipp
1048 #endif
1049 }
1051 // Place the "marker" (bullet) frame if it is placed next to a block
1052 // child.
1053 //
1054 // According to the CSS2 spec, section 12.6.1, the "marker" box
1055 // participates in the height calculation of the list-item box's
1056 // first line box.
1057 //
1058 // There are exactly two places a bullet can be placed: near the
1059 // first or second line. It's only placed on the second line in a
1060 // rare case: an empty first line followed by a second line that
1061 // contains a block (example: <LI>\n<P>... ). This is where
1062 // the second case can happen.
1068 // Reflow the bullet
1069 nsHTMLReflowMetrics metrics;
1070 // XXX Use the entire line when we fix bug 25888.
1081 // We have some lines to align the bullet with.
1083 // Doing the alignment using the baseline will also cater for
1084 // bullets that are placed next to a child block (bug 92896)
1086 // Tall bullets won't look particularly nice here...
1090 }
1091 // Otherwise just leave the bullet where it is, up against our top padding.
1092 }
1096 // Compute our final size
1097 nscoord bottomEdgeOfChildren;
1102 // Factor overflow container child bounds into the overflow area
1104 // Factor pushed float child bounds into the overflow area
1107 // Let the absolutely positioned container reflow any absolutely positioned
1108 // child frames that need to be reflowed, e.g., elements with a percentage
1109 // based width/height
1110 // We want to do this under either of two conditions:
1111 // 1. If we didn't do the incremental reflow above.
1112 // 2. If our size changed.
1113 // Even though it's the padding edge that's the containing block, we
1114 // can use our rect (the border edge) since if the border style
1115 // changed, the reflow would have been targeted at us so we'd satisfy
1116 // condition 1.
1117 // XXX checking oldSize is bogus, there are various reasons we might have
1118 // reflowed but our size might not have been changed to what we
1119 // asked for (e.g., we ended up being pushed to a new page)
1120 // When WillReflowAgainForClearance is true, we will reflow again without
1121 // resetting the size. Because of this, we must not reflow our abs-pos children
1122 // in that situation --- what we think is our "new size"
1123 // will not be our real new size. This also happens to be more efficient.
1128 haveInterrupt) {
1129 // Make sure that when we reflow again we'll actually reflow all the abs
1130 // pos frames that might conceivably depend on our size (or all of them,
1131 // if we're dirty right now and interrupted; in that case we also need
1132 // to mark them all with NS_FRAME_IS_DIRTY). Sadly, we can't do much
1133 // better than that, because we don't really know what our size will be,
1134 // and it might in fact not change on the followup reflow!
1139 }
1141 nsSize containingBlockSize =
1146 // Mark frames that depend on changes we just made to this frame as dirty:
1147 // Now we can assume that the padding edge hasn't moved.
1148 // We need to reflow the absolutes if one of them depends on
1149 // its placeholder position, or the containing block size in a
1150 // direction in which the containing block size might have
1151 // changed.
1154 // If isRoot and we have auto height, then we are the initial
1155 // containing block and the containing block height is the
1156 // viewport height, which can't change during incremental
1157 // reflow.
1169 //XXXfr Why isn't this rv (and others in this file) checked/returned?
1170 }
1171 }
1175 // Clear the float manager pointer in the block reflow state so we
1176 // don't waste time translating the coordinate system back on a dead
1177 // float manager.
1183 #ifdef DEBUG
1184 // Between when we drain pushed floats and when we complete reflow,
1185 // we're allowed to have multiple continuations of the same float on
1186 // our floats list, since a first-in-flow might get pushed to a later
1187 // continuation of its containing block. But it's not permitted
1188 // outside that time.
1209 }
1211 }
1230 }
1231 #endif
1235 }
1237 bool
1239 {
1246 }
1250 }
1253 }
1254 }
1255 // not reached
1256 }
1258 void
1263 {
1265 #ifdef NOISY_FINAL_SIZE
1271 #endif
1273 // Compute final width
1279 // Return bottom margin information
1280 // rbs says he hit this assertion occasionally (see bug 86947), so
1281 // just set the margin to zero and we'll figure out why later
1282 //NS_ASSERTION(aMetrics.mCarriedOutBottomMargin.IsZero(),
1283 // "someone else set the margin");
1286 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
1287 // line with clearance and a non-zero top margin and all
1288 // subsequent lines are empty, then we do not allow our children's
1289 // carried out bottom margin to be carried out of us and collapse
1290 // with our own bottom margin.
1292 // Convert the children's carried out margin to something that
1293 // we will include in our height
1296 }
1300 }
1303 // Shrink wrap our height around our contents.
1306 // When we are a bottom-margin root make sure that our last
1307 // childs bottom margin is fully applied. We also do this when
1308 // we have a computed height, since in that case the carried out
1309 // margin is not going to be applied anywhere, so we should note it
1310 // here to be included in the overflow area.
1311 // Apply the margin only if there's space for it.
1313 {
1314 // Truncate bottom margin if it doesn't fit to our available height.
1315 bottomEdgeOfChildren =
1318 }
1319 }
1321 // Include the float manager's state to properly account for the
1322 // bottom margin of any floated elements; e.g., inside a table cell.
1323 nscoord floatHeight =
1327 }
1336 // Use the current height; continuations will take up the rest.
1337 // Do extend the height to at least consume the available
1338 // height, otherwise our left/right borders (for example) won't
1339 // extend all the way to the break.
1342 // ... but don't take up more height than is available
1343 nscoord effectiveComputedHeight =
1347 // XXX It's pretty wrong that our bottom border still gets drawn on
1348 // on its own on the last-in-flow, even if we ran out of height
1349 // here. We need GetSkipSides to check whether we ran out of content
1350 // height in the current frame, not whether it's last-in-flow.
1351 }
1353 // Don't carry out a bottom margin when our height is fixed.
1355 }
1360 // Our min-height or max-height made our height change. Don't carry out
1361 // our kids' bottom margins.
1363 }
1366 }
1372 // This should never happen, but it does. See bug 414255
1374 }
1378 // Overflow containers can only be overflow complete.
1379 // Note that auto height overflow containers have no normal children
1382 }
1384 // Screen out negative heights --- can happen due to integer overflows :-(
1388 #ifdef DEBUG_blocks
1392 }
1393 #endif
1394 }
1396 void
1399 nscoord aBottomEdgeOfChildren,
1401 {
1402 // Compute the overflow areas of our children
1403 // XXX_perf: This can be done incrementally. It is currently one of
1404 // the things that makes incremental reflow O(N^2).
1411 }
1413 // Factor an outside bullet in; normally the bullet will be factored into
1414 // the line-box's overflow areas. However, if the line is a block
1415 // line then it won't; if there are no lines, it won't. So just
1416 // factor it in anyway (it can't hurt if it was already done).
1417 // XXXldb Can we just fix GetOverflowArea instead?
1421 }
1423 // Factor in the bottom edge of the children. Child frames will be added
1424 // to the overflow area as we iterate through the lines, but their margins
1425 // won't, so we need to account for bottom margins here.
1426 // REVIEW: For now, we do this for both visual and scrollable area,
1427 // although when we make scrollable overflow area not be a subset of
1428 // visual, we can change this.
1432 }
1433 }
1434 #ifdef NOISY_COMBINED_AREA
1437 #endif
1440 }
1442 bool
1444 {
1445 // We need to update the overflow areas of lines manually, as they
1446 // get cached and re-used otherwise. Lines aren't exposed as normal
1447 // frame children, so calling UnionChildOverflow alone will end up
1448 // using the old cached values.
1452 nsOverflowAreas lineAreas;
1458 }
1460 // Consider the overflow areas of the floats attached to the line as well
1464 }
1465 }
1468 }
1470 // Line cursor invariants depend on the overflow areas of the lines, so
1471 // we must clear the line cursor since those areas may have changed.
1475 }
1477 void
1479 {
1487 // NOTE: MarkLineDirty does more than just marking the line dirty.
1490 }
1491 }
1492 }
1494 }
1495 }
1497 void
1499 {
1500 // Mark aLine dirty
1503 #ifdef DEBUG
1508 }
1509 #endif
1511 // Mark previous line dirty if it's an inline line so that it can
1512 // maybe pullup something from the line just affected.
1513 // XXX We don't need to do this if aPrevLine ends in a break-after...
1518 #ifdef DEBUG
1524 }
1525 #endif
1526 }
1527 }
1529 /**
1530 * Test whether lines are certain to be aligned left so that we can make
1531 * resizing optimizations
1532 */
1538 {
1546 }
1548 void
1550 {
1553 // See if we can try and avoid marking all the lines as dirty
1555 // The block must be LTR (bug 806284)
1557 // The text must be left-aligned.
1562 // The left content-edge must be a constant distance from the left
1563 // border-edge.
1566 #ifdef DEBUG
1569 }
1577 }
1578 }
1579 #endif
1588 #ifdef DEBUG
1593 }
1594 #endif
1596 // The last line might not be aligned left even if the rest of the block is
1606 {
1607 // We let child blocks make their own decisions the same
1608 // way we are here.
1618 }
1620 #ifdef REALLY_NOISY_REFLOW
1624 }
1625 #endif
1626 #ifdef DEBUG
1639 }
1640 #endif
1641 }
1642 }
1644 // Mark everything dirty
1648 {
1650 }
1651 }
1652 }
1654 //----------------------------------------
1656 /**
1657 * Propagate reflow "damage" from from earlier lines to the current
1658 * line. The reflow damage comes from the following sources:
1659 * 1. The regions of float damage remembered during reflow.
1660 * 2. The combination of nonzero |aDeltaY| and any impact by a float,
1661 * either the previous reflow or now.
1662 *
1663 * When entering this function, |aLine| is still at its old position and
1664 * |aDeltaY| indicates how much it will later be slid (assuming it
1665 * doesn't get marked dirty and reflowed entirely).
1666 */
1667 void
1670 nscoord aDeltaY)
1671 {
1677 // Check to see if there are any floats; if there aren't, there can't
1678 // be any float damage
1682 // Check the damage region recorded in the float damage.
1684 // Need to check mBounds *and* mCombinedArea to find intersections
1685 // with aLine's floats
1688 // Scrollable overflow should be sufficient for things that affect
1689 // layout.
1697 }
1698 }
1700 // Check if the line is moving relative to the float manager
1703 // Unconditionally reflow sliding blocks; we only really need to reflow
1704 // if there's a float impacting this block, but the current float manager
1705 // makes it difficult to check that. Therefore, we let the child block
1706 // decide what it needs to reflow.
1710 nsFlowAreaRect floatAvailableSpace =
1715 #ifdef REALLY_NOISY_REFLOW
1718 #endif
1720 // Mark the line dirty if it was or is affected by a float
1721 // We actually only really need to reflow if the amount of impact
1722 // changes, but that's not straightforward to check
1725 }
1726 }
1727 }
1728 }
1736 }
1739 /**
1740 * Reparent a whole list of floats from aOldParent to this block. The
1741 * floats might be taken from aOldParent's overflow list. They will be
1742 * removed from the list. They end up appended to our mFloats list.
1743 */
1744 void
1747 nsFrameList list;
1752 }
1754 }
1755 }
1759 #ifdef DEBUG
1764 printf("line=%p mY=%d dirty=%s oldBounds={%d,%d,%d,%d} oldoverflow-vis={%d,%d,%d,%d} oldoverflow-scr={%d,%d,%d,%d} deltaY=%d mPrevBottomMargin=%d childCount=%d\n",
1772 }
1773 #endif
1774 }
1776 /**
1777 * Reflow the dirty lines
1778 */
1779 nsresult
1781 {
1788 #ifdef DEBUG
1794 }
1796 #endif
1802 // Reflow our last line if our availableHeight has increased
1803 // so that we (and our last child) pull up content as necessary
1810 }
1811 }
1812 // the amount by which we will slide the current line if it is not
1813 // dirty
1816 // whether we did NOT reflow the previous line and thus we need to
1817 // recompute the carried out margin before the line if we want to
1818 // reflow it or if its previous margin is dirty
1820 // Float continuations were reflowed in ReflowPushedFloats
1824 // We save up information about BR-clearance here
1829 // Reflow the lines that are already ours
1832 #ifdef DEBUG
1834 #endif
1839 // This really sucks, but we have to look inside any blocks that have clear
1840 // elements inside them.
1841 // XXX what can we do smarter here?
1845 }
1851 }
1853 // We have to reflow the line if it's a block whose clearance
1854 // might have changed, so detect that.
1857 replacedBlock)) {
1859 // See where we would be after applying any clearance due to
1860 // BRs.
1863 }
1865 nscoord newY =
1869 // Reflow the line if it might not have clearance anymore.
1871 // aState.mY is the clearance point which should be the
1872 // top border-edge of the block frame. If sliding the
1873 // block by deltaY isn't going to put it in the predicted
1874 // position, then we'd better reflow the line.
1877 }
1879 // Reflow the line if the line might have clearance now.
1882 }
1883 }
1884 }
1886 // We might have to reflow a line that is after a clearing BR.
1890 // SlideLine is not going to put the line where the clearance
1891 // put it. Reflow the line to be sure.
1893 }
1895 }
1899 // If the previous margin is dirty, reflow the current line
1903 // Lines that aren't dirty but get slid past our height constraint must
1904 // be reflowed.
1906 }
1908 // If we have a constrained height (i.e., breaking columns/pages),
1909 // and the distance to the bottom might have changed, then we need
1910 // to reflow any line that might have floats in it, both because the
1911 // breakpoints within those floats may have changed and because we
1912 // might have to push/pull the floats in their entirety.
1913 // FIXME: What about a deltaY or height change that forces us to
1914 // push lines? Why does that work?
1921 }
1924 // See if there's any reflow damage that requires that we mark the
1925 // line dirty.
1927 }
1930 // We need to reconstruct the bottom margin only if we didn't
1931 // reflow the previous line and we do need to reflow (or repair
1932 // the top position of) the next line.
1934 }
1940 // Update aState.mPrevChild as if we had reflowed all of the frames in
1941 // this line.
1946 }
1948 // Now repair the line and update |aState.mY| by calling
1949 // |ReflowLine| or |SlideLine|.
1950 // If we're going to reflow everything again, then no need to reflow
1951 // the dirty line ... unless the line has floats, in which case we'd
1952 // better reflow it now to refresh its float cache, which may contain
1953 // dangling frame pointers! Ugh! This reflow of the line may be
1954 // incorrect because we skipped reflowing previous lines (e.g., floats
1955 // may be placed incorrectly), but that's OK because we'll mark the
1956 // line dirty below under "if (aState.mReflowState.mDiscoveredClearance..."
1964 // Compute the dirty lines "before" YMost, after factoring in
1965 // the running deltaY value - the running value is implicit in
1966 // aState.mY.
1971 "Don't reflow blocks while willReflowAgain is true, reflow of block abs-pos children depends on this");
1973 // Reflow the dirty line. If it's an incremental reflow, then force
1974 // it to invalidate the dirty area if necessary
1981 // Note that once we've entered this state, every line that gets here
1982 // (e.g. because it has floats) gets marked dirty and reflowed again.
1983 // in the next pass. This is important, see above.
1984 }
1988 }
1994 }
1996 }
1998 // Test to see whether the margin that should be carried out
1999 // to the next line (NL) might have changed. In ReflowBlockFrame
2000 // we call nextLine->MarkPreviousMarginDirty if the block's
2001 // actual carried-out bottom margin changed. So here we only
2002 // need to worry about the following effects:
2003 // 1) the line was just created, and it might now be blocking
2004 // a carried-out bottom margin from previous lines that
2005 // used to reach NL from reaching NL
2006 // 2) the line used to be empty, and is now not empty,
2007 // thus blocking a carried-out bottom margin from previous lines
2008 // that used to reach NL from reaching NL
2009 // 3) the line wasn't empty, but now is, so a carried-out
2010 // bottom margin from previous lines that didn't used to reach NL
2011 // now does
2012 // 4) the line might have changed in a way that affects NL's
2013 // ShouldApplyTopMargin decision. The three things that matter
2014 // are the line's emptiness, its adjacency to the top of the block,
2015 // and whether it has clearance (the latter only matters if the block
2016 // was and is adjacent to the top and empty).
2017 //
2018 // If the line is empty now, we can't reliably tell if the line was empty
2019 // before, so we just assume it was and do nextLine->MarkPreviousMarginDirty.
2020 // This means the checks in 4) are redundant; if the line is empty now
2021 // we don't need to check 4), but if the line is not empty now and we're sure
2022 // it wasn't empty before, any adjacency and clearance changes are irrelevant
2023 // to the result of nextLine->ShouldApplyTopMargin.
2030 // since it's marked dirty, nobody will care about |deltaY|
2031 }
2032 }
2034 // If the line was just reflowed for the first time, then its
2035 // old mBounds cannot be trusted so this deltaY computation is
2036 // bogus. But that's OK because we just did
2037 // MarkPreviousMarginDirty on the next line which will force it
2038 // to be reflowed, so this computation of deltaY will not be
2039 // used.
2042 // Now do an interrupt check. We want to do this only in the case when we
2043 // actually reflow the line, so that if we get back in here we'll get
2044 // further on the reflow before interrupting.
2048 // Nop except for blocks (we don't create overflow container
2049 // continuations for any inlines atm), so only checking mFirstChild
2050 // is enough
2056 else
2062 // If we're going to reflow everything again, and this line is a block,
2063 // then there is no need to recover float state. The line may contain
2064 // other lines with floats, but in that case RecoverStateFrom would only
2065 // add floats to the float manager. We don't need to do that because
2066 // everything's going to get reflowed again "for real". Calling
2067 // RecoverStateFrom in this situation could be lethal because the
2068 // block's descendant lines may have float caches containing dangling
2069 // frame pointers. Ugh!
2070 // If this line is inline, then we need to recover its state now
2071 // to make sure that we don't forget to move its floats by deltaY.
2073 // XXX EVIL O(N^2) EVIL
2075 }
2077 // Keep mY up to date in case we're propagating reflow damage
2078 // and also because our final height may depend on it. If the
2079 // line is inlines, then only update mY if the line is not
2080 // empty, because that's what PlaceLine does. (Empty blocks may
2081 // want to update mY, e.g. if they have clearance.)
2084 }
2090 // Need to make sure to pull overflows from any prev-in-flows
2094 }
2095 }
2096 }
2098 // Record if we need to clear floats before reflowing the next
2099 // line. Note that inlineFloatBreakType will be handled and
2100 // cleared before the next line is processed, so there is no
2101 // need to combine break types here.
2104 }
2108 }
2114 // Another option here might be to leave |line| clean if
2115 // !HasPendingInterrupt() before the CheckForInterrupt() call, since in
2116 // that case the line really did reflow as it should have. Not sure
2117 // whether that would be safe, so doing this for now instead. Also not
2118 // sure whether we really want to mark all lines dirty after an
2119 // interrupt, but until we get better at propagating float damage we
2120 // really do need to do it this way; see comments inside MarkLineDirty.
2122 }
2123 }
2125 // Handle BR-clearance from the last line of the block
2128 }
2131 // Is this expensive?
2134 // Update aState.mPrevChild as if we had reflowed all of the frames in
2135 // the last line.
2140 }
2142 // Should we really have to do this?
2146 // We can skip trying to pull up the next line if our height is constrained
2147 // (so we can report being incomplete) and there is no next in flow or we
2148 // were told not to or we know it will be futile, i.e.,
2149 // -- the next in flow is not changing
2150 // -- and we cannot have added more space for its first line to be
2151 // pulled up into,
2152 // -- it's an incremental reflow of a descendant
2153 // -- and we didn't reflow any floats (so the available space
2154 // didn't change)
2155 // -- my chain of next-in-flows either has no first line, or its first
2156 // line isn't dirty.
2165 // We'll place lineIter at the last line of this block, so that
2166 // nsBlockInFlowLineIterator::Next() will take us to the first
2167 // line of my next-in-flow-chain. (But first, check that I
2168 // have any lines -- if I don't, just bail out of this
2169 // optimization.)
2175 // Check for next-in-flow-chain's first line.
2176 // (First, see if there is such a line, and second, see if it's clean)
2180 }
2181 }
2182 }
2188 else
2190 }
2193 // Pull data from a next-in-flow if there's still room for more
2194 // content here.
2196 // Grab first line from our next-in-flow
2199 nsFrameList pulledFrames;
2204 // Grab an overflow line if there are any
2210 }
2216 }
2217 }
2220 // The line is empty. Try the next one.
2225 }
2229 }
2238 // Shift pulledLine's frames into our mFrames list.
2241 // Add line to our line list, and set its last child as our new prev-child
2245 // Reparent floats whose placeholders are in the line.
2249 #ifdef DEBUG
2251 #endif
2256 // Now reflow it and any lines that it makes during it's reflow
2257 // (we have to loop here because reflowing the line may cause a new
2258 // line to be created; see SplitLine's callers for examples of
2259 // when this happens).
2269 }
2275 }
2277 }
2281 }
2286 }
2288 // If this is an inline frame then its time to stop
2291 }
2292 }
2293 }
2298 }
2300 // Handle an odd-ball case: a list-item with no lines
2302 nsHTMLReflowMetrics metrics;
2310 // There are no lines so we have to fake up some y motion so that
2311 // we end up with *some* height.
2316 }
2323 nscoord minAscent =
2333 }
2334 }
2335 }
2341 }
2343 #ifdef DEBUG
2351 }
2352 #endif
2355 }
2358 {
2367 }
2368 }
2371 }
2372 }
2374 void
2376 {
2379 // Just checking NS_FRAME_IS_DIRTY is ok, because we've already
2380 // marked the lines that need to be marked dirty based on our
2381 // vertical resize stuff. So we'll definitely reflow all those kids;
2382 // the only question is how they should behave.
2384 // Mark all our child frames dirty so we make sure to reflow them
2385 // later.
2390 }
2391 // And mark all the floats whose reflows we might be skipping dirty too.
2395 }
2396 }
2398 // Dirty all the descendant lines of block kids to handle float damage,
2399 // since our nsFloatManager will go away by the next time we're reflowing.
2400 // XXXbz Can we do something more like what PropagateFloatDamage does?
2401 // Would need to sort out the exact business with mBlockDelta for that....
2402 // This marks way too much dirty. If we ever make this better, revisit
2403 // which lines we mark dirty in the interrupt case in ReflowDirtyLines.
2407 }
2408 }
2409 }
2411 void
2415 {
2419 "using function more generally than designed, "
2424 // Mark the previous margin of the next line dirty since we need to
2425 // recompute its top position.
2428 }
2429 }
2431 /**
2432 * Reflow a line. The line will either contain a single block frame
2433 * or contain 1 or more inline frames. aKeepReflowGoing indicates
2434 * whether or not the caller should continue to reflow more lines.
2435 */
2436 nsresult
2438 line_iterator aLine,
2440 {
2445 // Setup the line-layout for the new line
2451 // Now that we know what kind of line we have, reflow it
2457 }
2460 }
2462 nsIFrame*
2464 line_iterator aLine)
2465 {
2466 // First check our remaining lines.
2469 }
2474 // Try each next-in-flow.
2479 }
2482 }
2485 }
2488 }
2490 nsIFrame*
2494 {
2504 // If our line is not empty and the child in aFromLine is a block
2505 // then we cannot pull up the frame into this line. In this case
2506 // we stop pulling.
2508 }
2509 // Take frame from fromLine
2514 // The frame is being pulled from a next-in-flow; therefore we
2515 // need to add it to our sibling list.
2521 // When pushing and pulling frames we need to check for whether any
2522 // views need to be reparented.
2526 // The frame might have (or contain) floats that need to be brought
2527 // over too. (pass 'false' since there are no siblings to check)
2531 }
2537 // Mark line dirty now that we pulled a child
2541 // Free up the fromLine now that it's empty.
2542 // Its bounds might need to be redrawn, though.
2545 }
2547 // aFromLine is now invalid
2549 }
2551 #ifdef DEBUG
2554 #endif
2557 }
2559 void
2562 {
2565 // Adjust line state
2568 // Adjust the frames in the line
2572 }
2577 }
2579 // Make sure the frame's view and any child views are updated
2581 }
2583 // Adjust the Y coordinate of the frames in the line.
2584 // Note: we need to re-position views even if aDY is 0, because
2585 // one of our parent frames may have moved and so the view's position
2586 // relative to its parent may have changed
2591 }
2592 // Make sure the frame's view and any child views are updated
2595 }
2596 }
2597 }
2599 NS_IMETHODIMP
2603 {
2609 }
2614 // XXX Not sure if this is necessary anymore
2618 NS_FRAME_HAS_DIRTY_CHILDREN);
2619 }
2620 }
2624 // Search for the closest ancestor that's a block frame. We
2625 // make the assumption that all related list items share a
2626 // common block parent.
2627 // XXXldb I think that's a bad assumption.
2630 // Tell the enclosing block frame to renumber list items within
2631 // itself
2634 // XXX Not sure if this is necessary anymore
2638 NS_FRAME_HAS_DIRTY_CHILDREN);
2639 }
2640 }
2641 }
2642 }
2645 }
2649 {
2653 // If we evaluate the length/percent/calc at a percentage basis of
2654 // both nscoord_MAX and 0, and it's zero both ways, then it's a zero
2655 // length, percent, or combination thereof. Test > 0 so we clamp
2656 // negative calc() results to 0.
2659 }
2662 }
2666 {
2667 // Blocks which are margin-roots (including inline-blocks) cannot be treated
2668 // as empty for margin-collapsing and other purposes. They're more like
2669 // replaced elements.
2686 }
2690 }
2693 }
2695 bool
2697 {
2700 }
2705 {
2708 }
2711 }
2713 bool
2715 {
2718 }
2723 {
2726 }
2729 }
2731 bool
2734 {
2736 // Apply short-circuit check to avoid searching the line list
2738 }
2741 // If we aren't at the top Y coordinate then something of non-zero
2742 // height must have been placed. Therefore the childs top-margin
2743 // applies.
2746 }
2748 // Determine if this line is "essentially" the first line
2752 }
2755 // A line which precedes aLine is non-empty, or has clearance,
2756 // so therefore the top margin applies.
2759 }
2760 // No need to apply the top margin if the line has floats. We
2761 // should collapse anyway (bug 44419)
2765 }
2767 // The line being reflowed is "essentially" the first line in the
2768 // block. Therefore its top-margin will be collapsed by the
2769 // generational collapsing logic with its parent (us).
2771 }
2773 nsresult
2775 line_iterator aLine,
2777 {
2786 }
2788 // Prepare the block reflow engine
2797 }
2799 // Clear past floats before the block if the clear style is not none
2802 // See if we should apply the top margin. If the block frame being
2803 // reflowed is a continuation (non-null prev-in-flow) then we don't
2804 // apply its top margin because it's not significant. Otherwise, dig
2805 // deeper.
2810 // The HasClearance setting is only valid if ShouldApplyTopMargin
2811 // returned false (in which case the top-margin-root set our
2812 // clearance flag). Otherwise clear it now. We'll set it later on
2813 // ourselves if necessary.
2815 }
2823 }
2825 // If our top margin was counted as part of some parents top-margin
2826 // collapse and we are being speculatively reflowed assuming this
2827 // frame DID NOT need clearance, then we need to check that
2828 // assumption.
2834 // Looks like that assumption was invalid, we do need
2835 // clearance. Tell our ancestor so it can reflow again. It is
2836 // responsible for actually setting our clearance flag before
2837 // the next reflow.
2839 // Only record the first frame that requires clearance
2842 }
2844 // Exactly what we do now is flexible since we'll definitely be
2845 // reflowed.
2847 }
2848 }
2851 }
2856 nscoord clearance;
2857 // Save the original position of the frame so that we can reposition
2858 // its view as needed.
2866 // Precompute the blocks top margin value so that we can get the
2867 // correct available space (there might be a float that's
2868 // already been placed below the aState.mPrevBottomMargin
2870 // Setup a reflowState to get the style computed margin-top
2871 // value. We'll use a reason of `resize' so that we don't fudge
2872 // any incremental reflow state.
2874 // The availSpace here is irrelevant to our needs - all we want
2875 // out if this setup is the margin-top value which doesn't depend
2876 // on the childs available space.
2877 // XXX building a complete nsHTMLReflowState just to get the margin-top
2878 // seems like a waste. And we do this for almost every block!
2886 }
2888 // Now compute the collapsed margin-top value into aState.mPrevBottomMargin, assuming
2889 // that all child margins collapse down to clearanceFrame.
2893 // XXX optimization; we could check the collapsing children to see if they are sure
2894 // to require clearance, and so avoid retrying them
2897 // Don't allow retries on the second pass. The clearance decisions for the
2898 // blocks whose top-margins collapse with ours are now fixed.
2900 }
2903 // We don't know if we need clearance and this is the first,
2904 // optimistic pass. So determine whether *this block* needs
2905 // clearance. Note that we do not allow the decision for whether
2906 // this block has clearance to change on the second pass; that
2907 // decision is only allowed to be made under the optimistic
2908 // first pass.
2912 // Looks like we need clearance and we didn't know about it already. So
2913 // recompute collapsed margin
2915 // Remember this decision, needed for incremental reflow
2918 // Apply incoming margins
2922 // Compute the collapsed margin again, ignoring the incoming margin this time
2926 }
2927 }
2929 // Temporarily advance the running Y value so that the
2930 // GetAvailableSpace method will return the right available
2931 // space. This undone as soon as the horizontal margins are
2932 // computed.
2937 // advance mY to the clear position.
2942 // Compute clearance. It's the amount we need to add to the top
2943 // border-edge of the frame, after applying collapsed margins
2944 // from the frame and its children, to get it to line up with
2945 // the bottom of the floats. The former is currentY + topMargin,
2946 // the latter is the current aState.mY.
2947 // Note that negative clearance is possible
2950 // Add clearance to our top margin while we compute available
2951 // space for the frame
2954 // Note that aState.mY should stay where it is: at the top
2955 // border-edge of the frame
2957 // Advance aState.mY to the top border-edge of the frame.
2959 }
2960 }
2962 // Here aState.mY is the top border-edge of the block.
2963 // Compute the available space for the block
2965 #ifdef REALLY_NOISY_REFLOW
2968 #endif
2970 nsRect availSpace;
2974 // The check for
2975 // (!aState.mReflowState.mFlags.mIsTopOfPage || clearedFloats)
2976 // is to some degree out of paranoia: if we reliably eat up top
2977 // margins at the top of the page as we ought to, it wouldn't be
2978 // needed.
2981 // We know already that this child block won't fit on this
2982 // page/column due to the top margin or the clearance. So we need
2983 // to get out of here now. (If we don't, most blocks will handle
2984 // things fine, and report break-before, but zero-height blocks
2985 // won't, and will thus make their parent overly-large and force
2986 // *it* to be pushed in its entirety.)
2987 // Doing this means that we also don't need to worry about the
2988 // |availSpace.height += topMargin| below interacting with pushed
2989 // floats (which force nscoord_MAX clearance) to cause a
2990 // constrained height to turn into an unconstrained one.
2999 }
3001 }
3003 // Now put the Y coordinate back to the top of the top-margin +
3004 // clearance, and flow the block.
3009 }
3011 // Reflow the block into the available space
3012 // construct the html reflow state for the block. ReflowBlock
3013 // will initialize it
3024 }
3038 }
3043 // If an ancestor of ours is going to reflow for clearance, we
3044 // need to avoid calling PlaceBlock, because it unsets dirty bits
3045 // on the child block (both itself, and through its call to
3046 // nsFrame::DidReflow), and those dirty bits imply dirtiness for
3047 // all of the child block, including the lines it didn't reflow.
3051 }
3053 #if defined(REFLOW_STATUS_COVERAGE)
3055 #endif
3058 // None of the child block fits.
3065 }
3066 }
3068 // Note: line-break-after a block is a nop
3070 // Try to place the child block.
3071 // Don't force the block to fit if we have positive clearance, because
3072 // pushing it to the next page would give it more room.
3073 // Don't force the block to fit if it's impacted by a float. If it is,
3074 // then pushing it to the next page would give it more room. Note that
3075 // isImpacted doesn't include impact from the block's own floats.
3078 nsCollapsingMargin collapsedBottomMargin;
3079 nsOverflowAreas overflowAreas;
3081 collapsedBottomMargin,
3083 frameReflowStatus);
3087 }
3094 }
3095 }
3099 // Some of the child block fit
3101 // Advance to new Y position
3105 // Continue the block frame now if it didn't completely fit in
3106 // the available space.
3115 // If nextFrame used to be an overflow container, make it a normal block
3129 }
3131 // Push continuation to a new line, but only if we actually made one.
3135 }
3140 // If we need to reflow the continuation of the block child,
3141 // then we'd better reflow our continuation
3144 // We also need to make that continuation's line dirty so
3145 // it gets reflowed when we reflow our next in flow. The
3146 // nif's line must always be either a line of the nif's
3147 // parent block (only if we didn't make a continuation) or
3148 // else one of our own overflow lines. In the latter case
3149 // the line is already marked dirty, so just handle the
3150 // first case.
3161 }
3162 }
3163 }
3164 }
3167 // The bottom margin for a block is only applied on the last
3168 // flow block. Since we just continued the child block frame,
3169 // we know that line->mFirstChild is not the last flow block
3170 // therefore zero out the running margin value.
3171 #ifdef NOISY_VERTICAL_MARGINS
3177 #endif
3179 }
3181 // Disconnect the next-in-flow and put it in our overflow tracker
3184 // It already exists, but as a normal next-in-flow, so we need
3185 // to dig it out of the child lists.
3190 }
3193 }
3195 // Put it in our overflow list
3199 #ifdef NOISY_VERTICAL_MARGINS
3205 #endif
3207 }
3208 }
3210 #ifdef NOISY_VERTICAL_MARGINS
3216 #endif
3218 }
3219 #ifdef NOISY_VERTICAL_MARGINS
3226 #endif
3230 // If it's our very first line *or* we're not at the top of the page
3231 // and we have page-break-inside:avoid, then we need to be pushed to
3232 // our parent's next-in-flow.
3235 // Push the line that didn't fit and any lines that follow it
3236 // to our next-in-flow.
3239 }
3240 }
3241 }
3243 }
3245 // Now that we've got its final position all figured out, position any child
3246 // views it may have. Note that the case when frame has a view got handled
3247 // by FinishReflowChild, but that function didn't have the coordinates needed
3248 // to correctly decide whether to reposition child views.
3251 }
3253 #ifdef DEBUG
3255 #endif
3257 }
3259 nsresult
3261 line_iterator aLine,
3263 {
3269 // Setup initial coordinate system for reflowing the inline frames
3270 // into. Apply a previous block frame's bottom margin first.
3273 }
3276 LineReflowStatus lineReflowStatus;
3288 // Once upon a time we allocated the first 30 nsLineLayout objects
3289 // on the stack, and then we switched to the heap. At that time
3290 // these objects were large (1100 bytes on a 32 bit system).
3291 // Then the nsLineLayout object was shrunk to 156 bytes by
3292 // removing some internal buffers. Given that it is so much
3293 // smaller, the complexity of 2 different ways of allocating
3294 // no longer makes sense. Now we always allocate on the stack.
3301 }
3310 }
3317 // If there is no saved break position, then this will set
3318 // set forceBreakInContent to null and we won't back up, which is
3319 // correct.
3320 forceBreakInContent = lineLayout.GetLastOptionalBreakPosition(&forceBreakOffset, &forceBreakPriority);
3323 }
3324 // restore the float manager state
3326 // Clear out float lists
3329 }
3331 // Don't allow pullup on a subsequent LINE_REFLOW_REDO_NO_PULL pass
3338 }
3340 void
3342 line_iterator aLine,
3344 {
3348 }
3350 #ifdef DEBUG
3355 };
3356 #endif
3358 nsresult
3361 line_iterator aLine,
3365 aFloatStateBeforeLine,
3369 {
3370 // Forget all of the floats on the line
3374 // We need to set this flag on the line if any of our reflow passes
3375 // are impacted by floats.
3378 #ifdef REALLY_NOISY_REFLOW
3381 #endif
3385 nscoord availHeight;
3388 }
3390 /* XXX get the height right! */
3392 }
3394 // Make sure to enable resize optimization before we call BeginLineReflow
3395 // because it might get disabled there
3398 // For unicode-bidi: plaintext, we need to get the direction of the line from
3399 // the resolved paragraph level of the first frame on the line, not the block
3400 // frame, because the block frame could be split by hard line breaks into
3401 // multiple paragraphs with different base direction
3411 direction);
3415 // XXX Unfortunately we need to know this before reflowing the first
3416 // inline frame in the line. FIX ME.
3421 }
3426 // Reflow the frames that are already on the line first
3433 // There is a soft break opportunity at the start of the line, because
3434 // we can always move this line down below float(s).
3437 }
3438 }
3440 // need to repeatedly call GetChildCount here, because the child
3441 // count can change during the loop!
3448 // It is possible that one or more of next lines are empty
3449 // (because of DeleteNextInFlowChild). If so, delete them now
3450 // in case we are finished.
3453 // XXX Is this still necessary now that DeleteNextInFlowChild
3454 // uses DoRemoveFrame?
3459 }
3463 "ReflowInlineFrame should never determine that a line "
3465 }
3466 }
3468 // Don't pull up new frames into lines with continuation placeholders
3470 // Pull frames and reflow them until we can't
3475 }
3483 // We just created a continuation for aFrame AND its going
3484 // to end up on this line (e.g. :first-letter
3485 // situation). Therefore we have to loop here before trying
3486 // to pull another frame.
3488 }
3491 }
3492 }
3493 }
3494 }
3498 // We only need to backup if the line isn't going to be reflowed again anyway
3503 "Someone must have set a break opportunity beyond the available width, "
3506 }
3508 // We need to try backing up to before a text run
3510 gfxBreakPriority breakPriority;
3512 // XXX It's possible, in fact not unusual, for the break opportunity to already
3513 // be the end of the line. We should detect that and optimize to not
3514 // re-do the line.
3516 // We can back up!
3518 }
3520 // In case we reflow this line again, remember that we don't
3521 // need to force any breaking
3523 }
3526 // This happens only when we have a line that is impacted by
3527 // floats and the first element in the line doesn't fit with
3528 // the floats.
3529 //
3530 // What we do is to advance past the first float we find and
3531 // then reflow the line all over again.
3535 // See the analogous code for blocks in nsBlockReflowState::ClearFloats.
3539 // We should never hit this case if we've placed floats on the
3540 // line; if we have, then the GetFloatAvailableSpace call is wrong
3541 // and needs to happen after the caller pops the space manager
3542 // state.
3550 // just move it down a bit to try to get out of this mess
3552 // We should never hit this case if we've placed floats on the
3553 // line; if we have, then the GetFloatAvailableSpace call is wrong
3554 // and needs to happen after the caller pops the space manager
3555 // state.
3559 // There's nowhere to retry placing the line, so we want to push
3560 // it to the next page/column where its contents can fit not
3561 // next to a float.
3564 }
3565 }
3567 // XXX: a small optimization can be done here when paginating:
3568 // if the new Y coordinate is past the end of the block then
3569 // push the line and return now instead of later on after we are
3570 // past the float.
3571 }
3574 // If we are propagating out a break-before status then there is
3575 // no point in placing the line.
3579 aKeepReflowGoing)) {
3581 // PlaceLine already called GetAvailableSpaceForHeight for us.
3582 }
3583 }
3584 }
3585 #ifdef DEBUG
3588 }
3589 #endif
3592 // aLine may have been pushed to the overflow lines.
3594 // We can't just compare iterators front() to aLine here, since they may be in
3595 // different lists.
3599 // aLine is stale, it's associated with the main line list but it should
3600 // be associated with the overflow line list now
3602 }
3608 }
3609 }
3610 }
3615 }
3617 /**
3618 * Reflow an inline frame. The reflow status is mapped from the frames
3619 * reflow status to the lines reflow status (not to our reflow status).
3620 * The line reflow status is simple: true means keep placing frames
3621 * on the line; false means don't (the line is done). If the line
3622 * has some sort of breaking affect then aLine's break-type will be set
3623 * to something other than NS_STYLE_CLEAR_NONE.
3624 */
3625 nsresult
3628 line_iterator aLine,
3631 {
3636 #ifdef NOISY_FIRST_LETTER
3642 #endif
3644 // Reflow the inline frame
3645 nsReflowStatus frameReflowStatus;
3653 }
3656 #ifdef REALLY_NOISY_REFLOW_CHILD
3659 #endif
3661 #if defined(REFLOW_STATUS_COVERAGE)
3663 #endif
3665 // Send post-reflow notification
3668 /* XXX
3669 This is where we need to add logic to handle some odd behavior.
3670 For one thing, we should usually place at least one thing next
3671 to a left float, even when that float takes up all the width on a line.
3672 see bug 22496
3673 */
3675 // Process the child frames reflow status. There are 5 cases:
3676 // complete, not-complete, break-before, break-after-complete,
3677 // break-after-not-complete. There are two situations: we are a
3678 // block or we are an inline. This makes a total of 10 cases
3679 // (fortunately, there is some overlap).
3683 // Always abort the line reflow (because a line break is the
3684 // minimal amount of break we do).
3687 // XXX what should aLine's break-type be set to in all these cases?
3694 // Break-before cases.
3696 // If we break before the first frame on the line then we must
3697 // be trying to place content where there's no room (e.g. on a
3698 // line with wide floats). Inform the caller to reflow the
3699 // line after skipping past a float.
3701 }
3703 // It's not the first child on this line so go ahead and split
3704 // the line. We will see the frame again on the next-line.
3707 // If we're splitting the line because the frame didn't fit and it
3708 // was pushed, then mark the line as having word wrapped. We need to
3709 // know that if we're shrink wrapping our width
3712 }
3713 }
3714 }
3716 // If a float split and its prev-in-flow was followed by a <BR>, then combine
3717 // the <BR>'s break type with the inline's break type (the inline will be the very
3718 // next frame after the split float).
3723 }
3724 // Break-after cases
3728 }
3729 }
3732 // Split line, but after the frame just reflowed
3738 }
3739 }
3740 }
3741 }
3744 // Create a continuation for the incomplete frame. Note that the
3745 // frame may already have a continuation.
3748 // Remember that the line has wrapped
3751 }
3753 // If we just ended a first-letter frame or reflowed a placeholder then
3754 // don't split the line and don't stop the line reflow...
3755 // But if we are going to stop anyways we'd better split the line.
3759 // Split line after the current frame
3762 }
3763 }
3766 }
3768 bool
3772 {
3783 }
3784 }
3785 #ifdef DEBUG
3787 #endif
3789 }
3791 nsresult
3794 nsReflowStatus aFloatStatus)
3795 {
3804 }
3808 }
3812 // The containing block is now overflow-incomplete.
3821 }
3825 }
3829 {
3833 }
3835 }
3837 static bool
3839 {
3851 }
3854 }
3856 void
3859 line_iterator aLine,
3862 {
3868 #ifdef DEBUG
3875 }
3878 }
3882 }
3883 }
3884 #endif
3889 #ifdef DEBUG
3890 {
3896 }
3898 }
3899 #endif
3901 // Put frames being split out into their own line
3904 #ifdef DEBUG
3907 }
3908 #endif
3910 // Let line layout know that some frames are no longer part of its
3911 // state.
3914 // If floats have been placed whose placeholders have been pushed to the new
3915 // line, we need to reflow the old line again. We don't want to look at the
3916 // frames in the new line, because as a large paragraph is laid out the
3917 // we'd get O(N^2) performance. So instead we just check that the last
3918 // float and the last below-current-line float are still in aLine.
3922 }
3924 #ifdef DEBUG
3926 #endif
3927 }
3928 }
3930 bool
3932 line_iterator aLine)
3933 {
3935 // There is another line
3937 // If the next line is a block line then this line is the last in a
3938 // group of inline lines.
3940 }
3941 // The next line is empty, try the next one
3942 }
3944 // XXX Not sure about this part
3945 // Try our next-in-flows lines to answer the question
3952 {
3955 }
3957 }
3959 // This is the last line - so don't allow justification
3961 }
3963 bool
3966 line_iterator aLine,
3971 {
3972 // Trim extra white-space from the line before placing the frames
3975 // Vertically align the frames on this line.
3976 //
3977 // According to the CSS2 spec, section 12.6.1, the "marker" box
3978 // participates in the height calculation of the list-item box's
3979 // first line box.
3980 //
3981 // There are exactly two places a bullet can be placed: near the
3982 // first or second line. It's only placed on the second line in a
3983 // rare case: when the first line is empty.
3991 nsHTMLReflowMetrics metrics;
3998 }
4001 // We want to compare to the available space that we would have had in
4002 // the line's height *before* we placed any floats in the line itself.
4003 // Floats that are in the line are handled during line reflow (and may
4004 // result in floats being pushed to below the line or (I HOPE???) in a
4005 // reflow with a forced break position).
4007 // As we redo for floats, we can't reduce the amount of height we're
4008 // checking.
4010 aFloatAvailableSpace =
4012 aAvailableSpaceHeight,
4015 // Restore the height to the position of the next band.
4017 // If the available space between the floats is smaller now that we
4018 // know the height, return false (and cause another pass with
4019 // LINE_REFLOW_REDO_MORE_FLOATS).
4022 }
4024 #ifdef DEBUG
4025 {
4034 }
4035 }
4038 }
4039 }
4040 #endif
4042 // Only block frames horizontally align their children because
4043 // inline frames "shrink-wrap" around their children (therefore
4044 // there is no extra horizontal space).
4047 /**
4048 * text-align-last defaults to the same value as text-align when
4049 * text-align-last is set to auto (except when text-align is set to justify),
4050 * so in that case we don't need to set isLastLine.
4051 *
4052 * In other words, isLastLine really means isLastLineAndWeCare.
4053 */
4061 // XXX: not only bidi: right alignment can be broken after
4062 // RelativePositionFrames!!!
4063 // XXXldb Is something here considering relatively positioned frames at
4064 // other than their original positions?
4065 #ifdef IBMBIDI
4066 // XXXldb Why don't we do this earlier?
4075 // From here on, pfd->mBounds rectangles are incorrect because bidi
4076 // might have moved frames around!
4077 nsOverflowAreas overflowAreas;
4082 }
4084 // Inline lines do not have margins themselves; however they are
4085 // impacted by prior block margins. If this line ends up having some
4086 // height then we zero out the previous bottom margin value that was
4087 // already applied to the line's starting Y coordinate. Otherwise we
4088 // leave it be so that the previous blocks bottom margin can be
4089 // collapsed with a block that follows.
4090 nscoord newY;
4093 // This line has some height. Therefore the application of the
4094 // previous-bottom-margin should stick.
4097 }
4099 // Don't let the previous-bottom-margin value affect the newY
4100 // coordinate (it was applied in ReflowInlineFrames speculatively)
4101 // since the line is empty.
4102 // We already called |ShouldApplyTopMargin|, and if we applied it
4103 // then BRS_APPLYTOPMARGIN is set.
4107 }
4114 }
4116 // See if the line fit (our first line always does).
4122 // All our content doesn't fit, start on the next page.
4125 // Push aLine and all of its children and anything else that
4126 // follows to our next-in-flow.
4128 }
4130 }
4134 // Add the already placed current-line floats to the line
4137 // Any below current line floats to place?
4139 // Reflow the below-current-line floats, which places on the line's
4140 // float list.
4143 }
4145 // When a line has floats, factor them into the combined-area
4146 // computations.
4148 // Combine the float combined area (stored in aState) and the
4149 // value computed by the line layout code.
4150 nsOverflowAreas lineOverflowAreas;
4154 #ifdef NOISY_COMBINED_AREA
4157 otype,
4163 #endif
4166 #ifdef NOISY_COMBINED_AREA
4169 #endif
4170 }
4172 }
4174 // Apply break-after clearing if necessary
4175 // This must stay in sync with |ReflowDirtyLines|.
4178 }
4180 }
4182 void
4185 {
4186 // NOTE: aLineBefore is always a normal line, not an overflow line.
4187 // The following expression will assert otherwise.
4192 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
4196 // Remove floats in the lines from mFloats
4197 nsFrameList floats;
4201 // Push the floats onto the front of the overflow out-of-flows list
4204 }
4206 // overflow lines can already exist in some cases, in particular,
4207 // when shrinkwrapping and we discover that the shrinkwap causes
4208 // the height of some child block to grow which creates additional
4209 // overflowing content. In such cases we must prepend the new
4210 // overflow to the existing overflow.
4213 // XXXldb use presshell arena!
4215 }
4225 }
4232 // this takes ownership but it won't delete it immediately so we
4233 // can keep using it.
4236 // Mark all the overflow lines dirty so that they get reflowed when
4237 // they are pulled up by our next-in-flow.
4239 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
4244 {
4250 }
4251 }
4252 }
4253 }
4255 #ifdef DEBUG
4257 #endif
4258 }
4260 // The overflowLines property is stored as a pointer to a line list,
4261 // which must be deleted. However, the following functions all maintain
4262 // the invariant that the property is never set if the list is empty.
4264 bool
4266 {
4267 #ifdef DEBUG
4269 #endif
4271 // Steal the prev-in-flow's overflow lines and prepend them.
4278 // Make all the frames on the overflow line list mine.
4281 // Make the overflow out-of-flow frames mine too.
4286 }
4289 // Remember to recompute the margins on the first line. This will
4290 // also recompute the correct deltaY if necessary.
4292 }
4293 // The overflow lines have already been marked dirty and their previous
4294 // margins marked dirty also.
4296 // Prepend the overflow frames/lines to our principal list.
4302 }
4303 }
4305 // Now append our own overflow lines.
4307 }
4309 bool
4311 {
4315 }
4317 // No need to reparent frames in our own overflow lines/oofs, because they're
4318 // already ours. But we should put overflow floats back in mFloats.
4321 // The overflow floats go after our regular floats.
4323 }
4328 }
4330 }
4332 /**
4333 * Pushed floats are floats whose placeholders are in a previous
4334 * continuation. They might themselves be next-continuations of a float
4335 * that partially fit in an earlier continuation, or they might be the
4336 * first continuation of a float that couldn't be placed at all.
4337 *
4338 * Pushed floats live permanently at the beginning of a block's float
4339 * list, where they must live *before* any floats whose placeholders are
4340 * in that block.
4341 *
4342 * Temporarily, during reflow, they also live on the pushed floats list,
4343 * which only holds them between (a) when one continuation pushes them to
4344 * its pushed floats list because they don't fit and (b) when the next
4345 * continuation pulls them onto the beginning of its float list.
4346 *
4347 * DrainPushedFloats sets up pushed floats the way we need them at the
4348 * start of reflow; they are then reflowed by ReflowPushedFloats (which
4349 * might push some of them on). Floats with placeholders in this block
4350 * are reflowed by (nsBlockReflowState/nsLineLayout)::AddFloat, which
4351 * also maintains these invariants.
4352 */
4353 void
4355 {
4356 #ifdef DEBUG
4357 // Between when we drain pushed floats and when we complete reflow,
4358 // we're allowed to have multiple continuations of the same float on
4359 // our floats list, since a first-in-flow might get pushed to a later
4360 // continuation of its containing block. But it's not permitted
4361 // outside that time.
4363 #endif
4365 // If we're getting reflowed multiple times without our
4366 // next-continuation being reflowed, we might need to pull back floats
4367 // that we just put in the list to be pushed to our next-in-flow.
4368 // We don't want to pull back any next-in-flows of floats on our own
4369 // float list, and we only need to pull back first-in-flows whose
4370 // placeholders were in earlier blocks (since first-in-flows whose
4371 // placeholders are in this block will get pulled appropriately by
4372 // AddFloat, and will then be more likely to be in the correct order).
4373 // FIXME: What if there's a continuation in our pushed floats list
4374 // whose prev-in-flow is in a previous continuation of this block
4375 // rather than this block? Might we need to pull it back so we don't
4376 // report ourselves complete?
4377 // FIXME: Maybe we should just pull all of them back?
4381 // When we pull back floats, we want to put them with the pushed
4382 // floats, which must live at the start of our float list, but we
4383 // want them at the end of those pushed floats.
4384 // FIXME: This isn't quite right! What if they're all pushed floats?
4390 }
4396 // FIXME
4403 // This is a first continuation that was pushed from one of our
4404 // previous continuations. Take it out of the pushed floats
4405 // list and put it in our floats list, before any of our
4406 // floats, but after other pushed floats.
4409 }
4410 }
4411 }
4415 }
4416 }
4418 // After our prev-in-flow has completed reflow, it may have a pushed
4419 // floats list, containing floats that we need to own. Take these.
4425 }
4426 }
4427 }
4431 {
4434 }
4442 }
4446 {
4449 }
4458 }
4460 void
4462 {
4470 }
4472 // This takes ownership of aOverflowLines.
4473 // XXX We should allocate overflowLines from presShell arena!
4474 void
4476 {
4486 // Verify that we won't overwrite an existing overflow list
4490 }
4492 nsFrameList*
4494 {
4497 }
4502 }
4504 // This takes ownership of the frames
4505 void
4508 {
4515 }
4522 }
4528 }
4534 }
4535 }
4537 nsBulletFrame*
4539 {
4542 }
4549 }
4551 nsBulletFrame*
4553 {
4557 }
4559 nsFrameList*
4561 {
4564 }
4572 }
4574 nsFrameList*
4576 {
4579 }
4584 }
4586 nsFrameList*
4588 {
4598 }
4600 nsFrameList*
4602 {
4605 }
4611 }
4613 //////////////////////////////////////////////////////////////////////
4614 // Frame list manipulation routines
4616 NS_IMETHODIMP
4619 {
4622 }
4626 }
4630 }
4634 }
4635 }
4637 // Find the proper last-child for where the append should go
4642 // Add frames after the last child
4643 #ifdef NOISY_REFLOW_REASON
4650 }
4652 #endif
4659 }
4661 NS_IMETHODIMP
4665 {
4672 }
4676 }
4677 #ifdef IBMBIDI
4683 }
4684 }
4686 #ifdef NOISY_REFLOW_REASON
4693 }
4695 #endif
4699 #ifdef IBMBIDI
4706 }
4708 static bool
4710 {
4714 }
4715 // XXX the IS_DIRTY check is a wallpaper for bug 822910.
4720 }
4722 }
4724 void
4726 {
4727 // Clear our line cursor, since our lines may change.
4732 }
4734 // If we're inserting at the beginning of our list and we have an
4735 // inside bullet, insert after that bullet.
4738 }
4740 // Attempt to find the line that contains the previous sibling
4746 // XXX_perf This is technically O(N^2) in some cases, but by using
4747 // RFind instead of Find, we make it O(N) in the most common case,
4748 // which is appending content.
4750 // Find the line that contains the previous sibling
4754 // Not in mLines - try overflow lines.
4761 prevSibLine,
4765 }
4766 }
4768 // Note: defensive code! RFindLineContaining must not return
4769 // false in this case, so if it does...
4774 }
4775 }
4776 }
4778 // Find the frame following aPrevSibling so that we can join up the
4779 // two lists of frames.
4781 // Split line containing aPrevSibling in two if the insertion
4782 // point is somewhere in the middle of the line.
4785 // Split the line in two where the frame(s) are being inserted.
4788 // Mark prevSibLine dirty and as needing textrun invalidation, since
4789 // we may be breaking up text in the line. Its previous line may also
4790 // need to be invalidated because it may be able to pull some text up.
4792 // The new line will also need its textruns recomputed because of the
4793 // frame changes.
4796 }
4797 }
4801 }
4806 // Walk through the new frames being added and update the line data
4807 // structures to fit.
4819 // If the frame is a block frame, or if there is no previous line or if the
4820 // previous line is a block line we need to make a new line. We also make
4821 // a new line, as an optimization, in the two cases we know we'll need it:
4822 // if the previous line ended with a <br>, or if it has significant whitespace
4823 // and ended in a newline.
4826 // Create a new line for the frame and add its line to the line
4827 // list.
4830 // Append new line after prevSibLine
4833 }
4835 // New line is going before the other lines
4838 }
4839 }
4842 // We're adding inline content to prevSibLine, so we need to mark it
4843 // dirty, ensure its textruns are recomputed, and possibly do the same
4844 // to its previous line since that line may be able to pull content up.
4846 }
4849 }
4851 #ifdef DEBUG
4854 #endif
4855 }
4857 void
4859 {
4860 // Find which line contains the float, so we can update
4861 // the float cache.
4866 }
4867 }
4868 }
4870 void
4872 {
4873 #ifdef DEBUG
4874 // Floats live in mFloats, or in the PushedFloat or OverflowOutOfFlows
4875 // frame list properties.
4882 }
4883 #endif
4887 }
4891 #if 0
4892 // XXXmats not yet - need to investigate nsBlockReflowState::mPushedFloats
4893 // first so we don't leave it pointing to a deleted list.
4896 }
4897 #endif
4899 }
4901 {
4905 }
4906 }
4907 }
4910 {
4916 }
4918 }
4920 // Mark every line at and below the line where the float was
4921 // dirty, and mark their lines dirty too. We could probably do
4922 // something more efficient --- e.g., just dirty the lines that intersect
4923 // the float vertically.
4925 }
4927 /**
4928 * Returns true if aFrame is a block that has one or more float children.
4929 */
4931 {
4944 }
4946 }
4948 NS_IMETHODIMP
4951 {
4954 #ifdef NOISY_REFLOW_REASON
4959 #endif
4966 }
4967 }
4971 }
4973 // Make sure to mark affected lines dirty for the float frame
4974 // we are removing; this way is a bit messy, but so is the rest of the code.
4975 // See bug 390762.
4982 }
4984 }
4985 #ifdef IBMBIDI
4987 // Skip the call to |FrameNeedsReflow| below by returning now.
4989 }
4994 }
5000 }
5002 }
5004 void
5006 {
5007 // The containing block is always the parent of aFrame.
5010 // Remove aFrame from the appropriate list.
5012 // This also deletes the next-in-flows
5014 kAbsoluteList,
5015 aFrame);
5016 }
5018 // First remove aFrame's next-in-flows.
5023 }
5024 // Now remove aFrame from its child list and Destroy it.
5028 }
5029 }
5031 /**
5032 * This helps us iterate over the list of all normal + overflow lines
5033 */
5034 void
5040 {
5043 // Try the overflow lines
5051 }
5052 }
5053 }
5054 }
5057 line_iterator aLine)
5059 {
5060 // This will assert if aLine isn't in mLines of aFrame:
5062 }
5069 {
5070 }
5075 {
5078 }
5082 {
5098 }
5101 }
5106 {
5113 // Try to use the cursor if it exists, otherwise fall back to the first line
5119 }
5120 }
5123 // Perform a simultaneous forward and reverse search starting from the
5124 // line cursor.
5129 // rline is positioned on the line containing 'cursor', so it's not
5130 // rline_end. So we can safely increment it (i.e. move it to one line
5131 // earlier) to start searching there.
5139 }
5141 }
5147 }
5149 }
5150 }
5151 // Didn't find the line
5152 }
5154 // If we reach here, it means that we have not been able to find the
5155 // desired frame in our in-flow lines. So we should start looking at
5156 // our overflow lines. In order to do that, we set mLine to the end
5157 // iterator so that FindValidLine starts to look at overflow lines,
5158 // if any.
5169 }
5171 }
5175 {
5177 }
5179 bool
5181 {
5184 }
5186 bool
5188 {
5191 }
5193 bool
5195 {
5200 }
5209 }
5221 }
5222 }
5224 }
5225 }
5227 bool
5229 {
5250 }
5251 }
5253 }
5254 }
5258 {
5267 }
5269 // This function removes aDeletedFrame and all its continuations. It
5270 // is optimized for deleting a whole series of frames. The easy
5271 // implementation would invoke itself recursively on
5272 // aDeletedFrame->GetNextContinuation, then locate the line containing
5273 // aDeletedFrame and remove aDeletedFrame from that line. But here we
5274 // start by locating aDeletedFrame and then scanning from that point
5275 // on looking for continuations.
5276 nsresult
5278 {
5279 // Clear our line cursor, since our lines may change.
5289 }
5293 }
5295 }
5297 // Find the line that contains deletedFrame
5303 // Make sure we look in the overflow lines even if the normal line
5304 // list is empty
5310 }
5314 }
5319 }
5325 }
5329 }
5330 }
5339 }
5341 // If the frame being deleted is the last one on the line then
5342 // optimize away the line->Contains(next-in-flow) call below.
5353 }
5355 // Remove aDeletedFrame from the line
5357 // We should be setting this to null if aDeletedFrame
5358 // is the only frame on the line. HOWEVER in that case
5359 // we will be removing the line anyway, see below.
5361 }
5363 // Hmm, this won't do anything if we're removing a frame in the first
5364 // overflow line... Hopefully doesn't matter
5367 // Since we just removed a frame that follows some inline
5368 // frames, we need to reflow the previous line.
5370 }
5373 // Take aDeletedFrame out of the sibling list. Note that
5374 // prevSibling will only be nullptr when we are deleting the very
5375 // first frame in the main or overflow list.
5380 }
5382 // Update the child count of the line to be accurate
5385 // Destroy frame; capture its next continuation first in case we need
5386 // to destroy that too.
5389 #ifdef NOISY_REMOVE_FRAME
5395 #endif
5397 // If next-in-flow is an overflow container, must remove it first.
5403 }
5409 // If line is empty, remove it now.
5411 #ifdef NOISY_REMOVE_FRAME
5414 #endif
5418 // Invalidate the space taken up by the line.
5419 // XXX We need to do this if we're removing a frame as a result of
5420 // a call to RemoveFrame(), but we may not need to do this in all
5421 // cases...
5422 #ifdef NOISY_BLOCK_INVALIDATE
5427 #endif
5433 // We just invalidated our iterators. Since we were in
5434 // the overflow lines list, which is now empty, set them
5435 // so we're at the end of the regular line list.
5439 }
5440 }
5443 // If we're removing a line, ReflowDirtyLines isn't going to
5444 // know that it needs to slide lines unless something is marked
5445 // dirty. So mark the previous margin of the next line dirty if
5446 // there is one.
5449 }
5452 // Make the line that just lost a frame dirty, and advance to
5453 // the next line.
5459 }
5460 }
5463 // See if we should keep looking in the current flow's line list.
5465 // The deceased frames continuation is not a child of the
5466 // current block. So break out of the loop so that we advance
5467 // to the next parent.
5468 //
5469 // If we have a continuation in a different block then all bets are
5470 // off regarding whether we are deleting frames without actual content,
5471 // so don't propagate FRAMES_ARE_EMPTY any further.
5474 }
5476 // If we advanced to the next line then check if we should switch to the
5477 // overflow line list.
5481 // We have advanced to the next *normal* line but the next-in-flow
5482 // is not there - force a switch to the overflow line list.
5484 }
5488 #ifdef NOISY_REMOVE_FRAME
5491 #endif
5492 }
5493 }
5494 }
5499 }
5501 #ifdef DEBUG
5504 #endif
5506 // Advance to next flow block if the frame has more continuations
5508 }
5510 static bool
5515 {
5523 }
5524 }
5526 }
5528 static bool
5534 {
5539 // Optimize by comparing the line's last child first.
5546 }
5547 }
5548 }
5550 }
5552 static bool
5558 {
5562 }
5564 nsresult
5568 {
5575 }
5580 }
5598 }
5599 }
5602 }
5604 void
5607 {
5611 }
5616 // The line became empty - destroy it.
5621 }
5623 }
5624 }
5626 void
5630 {
5637 }
5639 #ifdef DEBUG
5642 }
5643 #endif
5646 }
5647 }
5649 ////////////////////////////////////////////////////////////////////////
5650 // Float support
5652 nsRect
5656 {
5657 // Compute the available width. By default, assume the width of the
5658 // containing block.
5659 nscoord availWidth;
5665 }
5667 // This quirk matches the one in nsBlockReflowState::FlowAndPlaceFloat
5668 // give tables only the available space
5669 // if they can shrink we may not be constrained to place
5670 // them in the next line
5672 }
5675 ? NS_UNCONSTRAINEDSIZE
5678 #ifdef DISABLE_FLOAT_BREAKING_IN_COLUMNS
5681 // Tell the float it has unrestricted height, so it won't break.
5682 // If the float doesn't actually fit in the column it will fail to be
5683 // placed, and either move to the top of the next column or just
5684 // overflow.
5686 }
5687 #endif
5692 }
5694 nscoord
5698 {
5701 // Reflow the float.
5703 aFloat);
5709 }
5711 nsresult
5719 {
5722 // Reflow the float.
5725 #ifdef NOISY_FLOAT
5730 );
5731 #endif
5737 // Normally the mIsTopOfPage state is copied from the parent reflow
5738 // state. However, when reflowing a float, if we've placed other
5739 // floats that force this float *down* or *narrower*, we should unset
5740 // the mIsTopOfPage state.
5741 // FIXME: This is somewhat redundant with the |isAdjacentWithTop|
5742 // variable below, which has the exact same effect. Perhaps it should
5743 // be merged into that, except that the test for narrowing here is not
5744 // about adjacency with the top, so it seems misleading.
5749 }
5751 // Setup a block reflow context to reflow the float.
5754 // Reflow the float
5758 nsresult rv;
5760 nsCollapsingMargin margin;
5763 // Only first in flow gets a top margin.
5770 // We don't need to push the float manager state because the the block has its own
5771 // float manager that will be destroyed and recreated
5772 }
5773 }
5786 // An incomplete reflow status means we should split the float
5787 // if the height is constrained (bug 145305).
5789 }
5793 }
5796 // We never split floating first letters; an incomplete state for
5797 // such frames simply means that there is more content to be
5798 // reflowed on the line.
5801 }
5805 }
5807 // Capture the margin and offsets information for the caller
5813 // Set the rect, make sure the view is properly sized and positioned,
5814 // and tell the frame we're done reflowing it
5815 // XXXldb This seems like the wrong place to be doing this -- shouldn't
5816 // we be doing this in nsBlockReflowState::FlowAndPlaceFloat after
5817 // we've positioned the float, and shouldn't we be doing the equivalent
5818 // of |PlaceFrameView| here?
5824 NS_FRAME_NO_MOVE_VIEW);
5825 }
5826 // Pass floatRS so the frame hierarchy can be used (redoFloatRS has the same hierarchy)
5830 #ifdef NOISY_FLOAT
5833 #endif
5836 }
5838 uint8_t
5840 {
5841 // find the break type of the last line
5848 }
5849 }
5851 }
5853 void
5857 {
5858 // Pushed floats live at the start of our float list; see comment
5859 // above nsBlockFrame::DrainPushedFloats.
5863 // save next sibling now, since reflowing could push the entire
5864 // float, changing its siblings
5867 // When we push a first-continuation float in a non-initial reflow,
5868 // it's possible that we end up with two continuations with the same
5869 // parent. This happens if, on the previous reflow of the block or
5870 // a previous reflow of the line containing the block, the float was
5871 // split between continuations A and B of the parent, but on the
5872 // current reflow, none of the float can fit in A.
5873 //
5874 // When this happens, we might even have the two continuations
5875 // out-of-order due to the management of the pushed floats. In
5876 // particular, if the float's placeholder was in a pushed line that
5877 // we reflowed before it was pushed, and we split the float during
5878 // that reflow, we might have the continuation of the float before
5879 // the float itself. (In the general case, however, it's correct
5880 // for floats in the pushed floats list to come before floats
5881 // anchored in pushed lines; however, in this case it's wrong. We
5882 // should probably find a way to fix it somehow, since it leads to
5883 // incorrect layout in some cases.)
5884 //
5885 // When we have these out-of-order continuations, we might hit the
5886 // next-continuation before the previous-continuation. When that
5887 // happens, just push it. When we reflow the next continuation,
5888 // we'll either pull all of its content back and destroy it (by
5889 // calling DeleteNextInFlowChild), or nsBlockFrame::SplitFloat will
5890 // pull it out of its current position and push it again (and
5891 // potentially repeat this cycle for the next continuation, although
5892 // hopefully then they'll be in the right order).
5893 //
5894 // We should also need this code for the in-order case if the first
5895 // continuation of a float gets moved across more than one
5896 // continuation of the containing block. In this case we'd manage
5897 // to push the second continuation without this check, but not the
5898 // third and later.
5904 }
5906 // Always call FlowAndPlaceFloat; we might need to place this float
5907 // if didn't belong to this block the last time it was reflowed.
5911 }
5913 // If there are continued floats, then we may need to continue BR clearance
5917 }
5918 }
5920 void
5922 {
5923 // Recover our own floats
5925 // belong to our next-in-flow
5931 }
5933 // Recurse into our overflow container children
5937 }
5939 // Recurse into our normal children
5943 }
5944 }
5945 }
5947 void
5950 {
5952 // Only blocks have floats
5954 // Don't recover any state inside a block that has its own space manager
5955 // (we don't currently have any blocks like this, though, thanks to our
5956 // use of extra frames for 'overflow')
5958 // If the element is relatively positioned, then adjust x and y
5959 // accordingly so that we consider relatively positioned frames
5960 // at their original position.
5965 }
5966 }
5968 //////////////////////////////////////////////////////////////////////
5969 // Painting, event handling
5971 #ifdef DEBUG
5975 {
5980 // Compute min and max x/y values for the reflowed frame's
5981 // combined areas
5989 }
5992 }
5995 }
5998 }
5999 }
6005 }
6006 #endif
6008 bool
6010 {
6019 }
6021 #ifdef DEBUG
6033 }
6034 }
6035 #endif
6037 static void
6042 // If the line's combined area (which includes child frames that
6043 // stick outside of the line's bounding box or our bounding box)
6044 // intersects the dirty rect then paint the line.
6046 #ifdef DEBUG
6048 aDrawnLines++;
6049 }
6051 #endif
6052 // The line might contain a placeholder for a visible out-of-flow, in which
6053 // case we need to descend into it. If there is such a placeholder, we will
6054 // have NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO set.
6055 // In particular, we really want to check ShouldDescendIntoFrame()
6056 // on all the frames on the line, but that might be expensive. So
6057 // we approximate it by checking it on aFrame; if it's true for any
6058 // frame in the line, it's also true for aFrame.
6065 // Collect our line's display items in a temporary nsDisplayListCollection,
6066 // so that we can apply any "text-overflow" clipping to the entire collection
6067 // without affecting previous lines.
6068 nsDisplayListCollection collection;
6070 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
6071 // Inline-level child backgrounds go on the regular child content list.
6083 }
6087 }
6090 }
6092 void
6096 {
6099 #ifdef DEBUG
6102 nsRect ca;
6110 }
6115 }
6116 #endif
6125 }
6126 }
6130 // Prepare for text-overflow processing.
6134 // We'll collect our lines' display items here, & then append this to aLists.
6135 nsDisplayListCollection linesDisplayListCollection;
6137 // Don't use the line cursor if we might have a descendant placeholder ...
6138 // it might skip lines that contain placeholders but don't themselves
6139 // intersect with the dirty area.
6140 // In particular, we really want to check ShouldDescendIntoFrame()
6141 // on all our child frames, but that might be expensive. So we
6142 // approximate it by checking it on |this|; if it's true for any
6143 // frame in our child list, it's also true for |this|.
6154 // Because we have a cursor, the combinedArea.ys are non-decreasing.
6155 // Once we've passed aDirtyRect.YMost(), we can never see it again.
6158 }
6161 }
6162 }
6178 }
6181 }
6182 lineCount++;
6183 }
6187 }
6188 }
6190 // Pick up the resulting text-overflow markers. We append them to
6191 // PositionedDescendants just before we append the lines' display items,
6192 // so that our text-overflow markers will appear on top of this block's
6193 // normal content but below any of its its' positioned children.
6196 }
6200 // Display outside bullets manually
6203 }
6205 #ifdef DEBUG
6223 }
6224 #endif
6225 }
6227 #ifdef ACCESSIBILITY
6230 {
6231 // block frame may be for <hr>
6234 }
6238 // Don't create accessible objects for the root content node, they are redundant with
6239 // the nsDocAccessible object created with the document node
6241 }
6249 // Don't create accessible objects for the body, they are redundant with
6250 // the nsDocAccessible object created with the document node
6252 }
6253 }
6255 // Not a bullet, treat as normal HTML container
6257 }
6259 // Create special list bullet accessible
6261 }
6262 #endif
6265 {
6268 }
6272 }
6275 {
6279 }
6283 }
6286 {
6289 }
6302 }
6307 }
6311 }
6314 }
6318 {
6319 // See if the child is absolutely positioned
6322 // do nothing
6324 // The bullet lives in the first line, unless the first line has
6325 // height 0 and there is a second line, in which case it lives
6326 // in the second line.
6331 }
6335 }
6336 // otherwise we have an empty line list, and ReflowDirtyLines
6337 // will handle reflowing the bullet.
6339 // Note that we should go through our children to mark lines dirty
6340 // before the next reflow. Doing it now could make things O(N^2)
6341 // since finding the right line is O(N).
6342 // We don't need to worry about marking lines on the overflow list
6343 // as dirty; we're guaranteed to reflow them if we take them off the
6344 // overflow list.
6345 // However, we might have gotten a float, in which case we need to
6346 // reflow the line containing its placeholder. So find the
6347 // ancestor-or-self of the placeholder that's a child of the block,
6348 // and mark it as NS_FRAME_HAS_DIRTY_CHILDREN too, so that we mark
6349 // its line dirty when we handle NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
6350 // We need to take some care to handle the case where a float is in
6351 // a different continuation than its placeholder, including marking
6352 // an extra block with NS_BLOCK_LOOK_FOR_DIRTY_FRAMES.
6360 // SVG code sometimes sends FrameNeedsReflow notifications during
6361 // frame destruction, leading to null placeholders, but we're safe
6362 // ignoring those.
6370 }
6372 }
6374 }
6375 }
6376 }
6379 }
6381 void
6385 {
6387 // Copy over the inherited block frame bits from the prev-in-flow.
6390 }
6402 }
6403 }
6405 NS_IMETHODIMP
6408 {
6416 }
6419 }
6423 #ifdef DEBUG
6424 // The only times a block that is an anonymous box is allowed to have a
6425 // first-letter frame are when it's the block inside a non-anonymous cell,
6426 // the block inside a fieldset, a scrolled content block, or a column
6427 // content block. Note that this means that blocks which are the anonymous
6428 // block in {ib} splits do NOT get first-letter frames. Note that
6429 // NS_BLOCK_HAS_FIRST_LETTER_STYLE gets set on all continuations of the
6430 // block.
6445 #endif
6449 // Create a list bullet if this is a list-item. Note that this is
6450 // done here so that RenumberLists will work (it needs the bullets
6451 // to store the bullet numbers). Also note that due to various
6452 // wrapper frames (scrollframes, columns) we want to use the
6453 // outermost (primary, ideally, but it's not set yet when we get
6454 // here) frame of our content for the display check. On the other
6455 // hand, we look at ourselves for the GetPrevInFlow() check, since
6456 // for a columnset we don't want a bullet per column. Note that
6457 // the outermost frame for the content is the primary frame in
6458 // most cases; the ones when it's not (like tables) can't be
6459 // NS_STYLE_DISPLAY_LIST_ITEM).
6465 }
6467 }
6471 // Resolve style for the bullet frame
6483 }
6492 parentStyle);
6494 // Create bullet frame
6498 // If the list bullet frame should be positioned inside then add
6499 // it to the flow now.
6510 }
6511 }
6512 }
6515 }
6517 bool
6519 {
6526 }
6528 void
6530 {
6537 }
6540 }
6543 }
6547 nsAutoString text;
6550 }
6551 }
6552 }
6554 // static
6555 bool
6557 {
6567 }
6569 bool
6571 {
6573 // If this frame doesn't start a counter scope then we don't need
6574 // to renumber child list items.
6576 }
6581 // Setup initial list ordinal value
6582 // XXX Map html's start property to counter-reset style
6590 }
6593 // Must be non-null, since FrameStartsCounterScope only returns true
6594 // for HTML elements.
6600 // <ol reversed> case, or some other case with a negative increment: count
6601 // up the child list
6606 // FIXME: This isn't right in terms of what CSS says to do for
6607 // overflow of counters (but it only matters when this node has
6608 // more than numeric_limits<int32_t>::max() children).
6610 }
6611 }
6612 }
6614 // Get to first-in-flow
6617 }
6619 bool
6625 {
6626 // Examine each line in the block
6645 }
6647 }
6650 // We need to set NS_FRAME_HAS_DIRTY_CHILDREN bits up the tree between
6651 // the bullet and the caller of RenumberLists. But the caller itself
6652 // has to be responsible for setting the bit itself, since that caller
6653 // might be making a FrameNeedsReflow call, which requires that the
6654 // bit not be set yet.
6657 }
6660 }
6662 bool
6668 {
6671 // add in a sanity check for absurdly deep frame trees. See bug 42138
6675 // if the frame is a placeholder, then get the out of flow frame
6679 // drill down through any wrappers to the real frame
6682 // possible there is no content insertion frame
6688 // If the frame is a list-item and the frame implements our
6689 // block frame API then get its bullet and set the list item
6690 // ordinal.
6692 // Make certain that the frame is a block frame in case
6693 // something foreign has crept in.
6703 // The ordinal changed - mark the bullet frame, and any
6704 // intermediate frames between it and the block (are there
6705 // ever any?), dirty.
6706 // The calling code will make the necessary FrameNeedsReflow
6707 // call for the list ancestor.
6715 }
6716 }
6718 // XXX temporary? if the list-item has child list-items they
6719 // should be numbered too; especially since the list-item is
6720 // itself (ASSUMED!) not to be a counter-resetter.
6725 }
6726 }
6727 }
6730 // Don't bother recursing into a block frame that is a new
6731 // counter scope. Any list-items in there will be handled by
6732 // it.
6733 }
6735 // If the display=block element is a block frame then go ahead
6736 // and recurse into it, as it might have child list-items.
6741 aIncrement);
6742 }
6743 }
6744 }
6746 }
6748 void
6752 nscoord aLineTop)
6753 {
6756 // Reflow the bullet now
6757 nsSize availSize;
6758 // Make up a width since it doesn't really matter (XXX).
6762 // Get the reason right.
6763 // XXXwaterson Should this look just like the logic in
6764 // nsBlockReflowContext::ReflowBlock and nsLineLayout::ReflowFrame?
6767 nsReflowStatus status;
6771 // Get the float available space using our saved state from before we
6772 // started reflowing the block, so that we ignore any floats inside
6773 // the block.
6774 // FIXME: aLineTop isn't actually set correctly by some callers, since
6775 // they reposition the line.
6776 nsRect floatAvailSpace =
6780 // FIXME (bug 25888): need to check the entire region that the first
6781 // line overlaps, not just the top pixel.
6783 // Place the bullet now. We want to place the bullet relative to the
6784 // border-box of the associated block (using the right/left margin of
6785 // the bullet frame as separation). However, if a line box would be
6786 // displaced by floats that are *outside* the associated block, we
6787 // want to displace it by the same amount. That is, we act as though
6788 // the edge of the floats is the content-edge of the block, and place
6789 // the bullet at a position offset from there by the block's padding,
6790 // the block's border, and the bullet frame's margin.
6791 nscoord x;
6793 // The floatAvailSpace.x gives us the content/float edge. Then we
6794 // subtract out the left border/padding and the bullet's width and
6795 // margin to offset the position.
6799 // The XMost() of the available space give us offsets from the left
6800 // border edge. Then we add the right border/padding and the
6801 // bullet's margin to offset the position.
6804 }
6806 // Approximate the bullets position; vertical alignment will provide
6807 // the final vertical location.
6812 }
6814 // This is used to scan frames for any float placeholders, add their
6815 // floats to the list represented by aList, and remove the
6816 // floats from whatever list they might be in. We don't search descendants
6817 // that are float containing blocks. Floats that or not children of 'this'
6818 // are ignored (they are not added to aList).
6819 void
6822 {
6824 // Don't descend into float containing blocks.
6832 // FIXME: By not pulling floats whose parent is one of our
6833 // later siblings, are we risking the pushed floats getting
6834 // out-of-order?
6835 // XXXmats nsInlineFrame's lazy reparenting depends on NOT doing that.
6836 }
6840 }
6844 }
6845 }
6847 void
6849 {
6850 #ifdef DEBUG
6851 // If any line is still dirty, that must mean we're going to reflow this
6852 // block again soon (e.g. because we bailed out after noticing that
6853 // clearance was imposed), so don't worry if the floats are out of sync.
6856 // Check that the float list is what we would have built
6865 }
6866 }
6869 }
6870 }
6881 }
6883 }
6887 #if defined(DEBUG_roc)
6891 }
6894 }
6895 #endif
6896 }
6897 #endif
6901 // Floats that were pushed should be removed from our float
6902 // manager. Otherwise the float manager's YMost or XMost might
6903 // be larger than necessary, causing this block to get an
6904 // incorrect desired height (or width). Some of these floats
6905 // may not actually have been added to the float manager because
6906 // they weren't reflowed before being pushed; that's OK,
6907 // RemoveRegions will ignore them. It is safe to do this here
6908 // because we know from here on the float manager will only be
6909 // used for its XMost and YMost, not to place new floats and
6910 // lines.
6912 }
6913 }
6915 void
6917 {
6924 }
6929 }
6930 }
6934 }
6936 /* static */
6937 bool
6939 {
6946 }
6948 /* static */
6949 bool
6951 {
6955 }
6957 // Note that this width can vary based on the vertical position.
6958 // However, the cases where it varies are the cases where the width fits
6959 // in the available space given, which means that variation shouldn't
6960 // matter.
6961 /* static */
6966 {
6971 ReplacedElementWidthToClear result;
6976 // We actually don't want the min width here; see bug 427782; we only
6977 // want to displace if the width won't compute to a value small enough
6978 // to fit.
6979 // All we really need here is the result of ComputeSize, and we
6980 // could *almost* get that from an nsCSSOffsetState, except for the
6981 // last argument.
6987 // Use the margins from offsetState rather than reflowState so that
6988 // they aren't reduced by ignoring margins in overconstrained cases.
6992 }
6994 /* static */
6995 nsBlockFrame*
6997 {
7002 // yay, candidate is a block!
7004 }
7005 // Not a block. Check its parent next.
7007 }
7010 }
7012 void
7015 nscoord aContentHeight,
7018 nscoord aConsumed)
7019 {
7021 // Figure out how much of the computed height should be
7022 // applied to this frame.
7024 aConsumed);
7031 computedHeightLeftOver),
7036 // We ran out of height on this page but we're incomplete
7037 // Set status to complete except for overflow
7039 }
7048 }
7049 // We don't fit and we consumed some of the computed height,
7050 // so we should consume all the available height and then
7051 // break. If our bottom border/padding straddles the break
7052 // point, then this will increase our height and push the
7053 // border/padding to the next page/column.
7055 aContentHeight);
7059 }
7060 }
7061 }
7063 #ifdef IBMBIDI
7064 nsresult
7066 {
7073 }
7076 }
7077 #endif
7079 #ifdef DEBUG
7080 void
7082 {
7085 }
7088 }
7092 // Add up the counts on each line. Also validate that IsFirstLine is
7093 // set properly.
7101 }
7106 }
7107 }
7109 }
7111 // Then count the frames
7115 frameCount++;
7117 }
7120 // Next: test that each line has right number of frames on it
7123 ) {
7128 }
7132 }
7133 }
7144 }
7145 }
7146 }
7147 }
7149 }
7151 void
7153 {
7165 }
7171 ;
7176 ;
7177 }
7179 }
7181 }
7182 }
7184 int32_t
7186 {
7191 depth++;
7192 }
7194 }
7195 #endif