| blob | f25638c54b6a3c03a79f7018fd7ed292edb24cd6 |
1 /* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 // vim:cindent:ts=2:et:sw=2:
3 /* ***** BEGIN LICENSE BLOCK *****
4 * Version: MPL 1.1/GPL 2.0/LGPL 2.1
5 *
6 * The contents of this file are subject to the Mozilla Public License Version
7 * 1.1 (the "License"); you may not use this file except in compliance with
8 * the License. You may obtain a copy of the License at
9 * http://www.mozilla.org/MPL/
10 *
11 * Software distributed under the License is distributed on an "AS IS" basis,
12 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the License
13 * for the specific language governing rights and limitations under the
14 * License.
15 *
16 * The Original Code is Mozilla Communicator client code.
17 *
18 * The Initial Developer of the Original Code is
19 * Netscape Communications Corporation.
20 * Portions created by the Initial Developer are Copyright (C) 1998
21 * the Initial Developer. All Rights Reserved.
22 *
23 * Contributor(s):
24 * Steve Clark <buster@netscape.com>
25 * Robert O'Callahan <roc+moz@cs.cmu.edu>
26 * L. David Baron <dbaron@dbaron.org>
27 * IBM Corporation
28 * Mats Palmgren <mats.palmgren@bredband.net>
29 *
30 * Alternatively, the contents of this file may be used under the terms of
31 * either of the GNU General Public License Version 2 or later (the "GPL"),
32 * or the GNU Lesser General Public License Version 2.1 or later (the "LGPL"),
33 * in which case the provisions of the GPL or the LGPL are applicable instead
34 * of those above. If you wish to allow use of your version of this file only
35 * under the terms of either the GPL or the LGPL, and not to allow others to
36 * use your version of this file under the terms of the MPL, indicate your
37 * decision by deleting the provisions above and replace them with the notice
38 * and other provisions required by the GPL or the LGPL. If you do not delete
39 * the provisions above, a recipient may use your version of this file under
40 * the terms of any one of the MPL, the GPL or the LGPL.
41 *
42 * ***** END LICENSE BLOCK ***** */
44 /*
45 * rendering object for CSS display:block and display:list-item objects,
46 * also used inside table cells
47 */
82 #ifdef ACCESSIBILITY
85 #endif
92 #ifdef IBMBIDI
101 #ifdef DEBUG
121 };
133 };
134 #define NUM_DEBUG_FLAGS (sizeof(gFlags) / sizeof(gFlags[0]))
136 static void
138 {
144 }
147 }
149 void
151 {
172 }
173 }
176 }
181 }
184 }
185 }
186 }
187 }
189 #endif
191 // add in a sanity check for absurdly deep frame trees. See bug 42138
192 // can't just use IsFrameTreeTooDeep() because that method has side effects we don't want
195 //----------------------------------------------------------------------
197 // Debugging support code
199 #ifdef DEBUG
206 };
207 #endif
209 #ifdef REALLY_NOISY_FIRST_LINE
210 static void
212 {
222 }
224 }
225 #endif
227 #ifdef REFLOW_STATUS_COVERAGE
228 static void
230 {
233 // 0: child-is-block
234 // 1: child-is-inline
238 // Compute new status
243 }
246 }
249 }
250 }
253 }
256 }
258 // Log updates to the status that yield different values
262 }
263 }
264 #endif
266 //----------------------------------------------------------------------
270 nsIFrame*
272 {
276 }
278 }
281 {
282 }
284 void
286 {
288 // Make sure all the content nodes for the generated content inside
289 // this frame know it's going away.
290 // This is duplicated in nsInlineFrame::Destroy
291 // See also nsCSSFrameConstructor::CreateGeneratedContentFrame which
292 // created this frame.
294 // XXXbz would this be better done via a global structure in
295 // nsCSSFrameConstructor that could key off of
296 // GeneratedContentFrameRemoved or something? The problem is that
297 // our kids are gone by the time that's called.
299 }
302 // Outside bullets are not in our child-list so check for them here
303 // and delete them when present.
307 }
315 // destroy overflow lines now
319 }
321 {
324 // oofs is now empty and will remove the frame list property
325 }
328 }
330 NS_IMETHODIMP
332 {
337 }
340 {
345 }
353 }
357 }
359 }
361 nsSplittableType
363 {
365 }
367 #ifdef DEBUG
368 NS_METHOD
370 {
373 #ifdef DEBUG_waterson
375 #endif
378 }
381 }
383 // Output the flow linkage
386 }
389 }
391 // Output the rect and state
395 }
401 }
408 {
410 numBlockLines++;
411 else
412 numInlineLines++;
413 }
414 }
419 nsAutoString atomString;
423 }
426 aIndent++;
428 // Output the lines
433 {
435 }
436 }
444 }
448 nsAutoString tmp;
452 }
459 }
461 }
464 }
465 }
467 aIndent--;
472 }
476 {
477 // We don't want to include our cursor flag in the bits the
478 // regression tester looks at
480 }
482 NS_IMETHODIMP
484 {
486 }
487 #endif
489 nsIAtom*
491 {
493 }
495 void
498 PRBool aImmediate)
499 {
500 // Optimize by suppressing invalidation of areas that are clipped out
501 // with CSS 'clip'.
503 nsRect absPosClipRect;
505 // Restrict the invalidated area to abs-pos clip rect
506 // abs-pos clipping clips everything in the frame
507 nsRect r;
510 }
512 }
515 }
517 nscoord
519 {
521 nscoord result;
525 }
527 /////////////////////////////////////////////////////////////////////////////
528 // Child frame enumeration
530 nsIFrame*
532 {
537 }
540 }
544 }
547 }
550 }
554 }
555 }
557 }
559 nsIAtom*
561 {
575 }
576 }
578 /* virtual */ PRBool
580 {
582 }
584 /* virtual */ PRBool
586 {
588 }
591 {
594 }
603 // When pushing and pulling frames we need to check for whether any
604 // views need to be reparented
607 }
609 //////////////////////////////////////////////////////////////////////
610 // Frame structure methods
612 //////////////////////////////////////////////////////////////////////
613 // Reflow methods
617 {
622 }
624 /* virtual */ nscoord
626 {
631 #ifdef DEBUG
636 }
638 #endif
640 #ifdef IBMBIDI
644 InlineMinWidthData data;
647 {
648 #ifdef DEBUG
654 }
656 #endif
667 }
668 // XXX Bug NNNNNN Should probably handle percentage text-indent.
674 }
675 }
676 #ifdef DEBUG
681 }
682 #endif
683 }
688 }
690 /* virtual */ nscoord
692 {
697 #ifdef DEBUG
702 }
704 #endif
706 #ifdef IBMBIDI
710 InlinePrefWidthData data;
713 {
714 #ifdef DEBUG
720 }
722 #endif
733 }
734 // XXX Bug NNNNNN Should probably handle percentage text-indent.
740 }
741 }
742 #ifdef DEBUG
747 }
748 #endif
749 }
754 }
756 static nsSize
758 nsSize aFrameSize)
759 {
760 // The issue here is that for a 'height' of 'auto' the reflow state
761 // code won't know how to calculate the containing block height
762 // because it's calculated bottom up. So we use our own computed
763 // size as the dimensions. We don't really want to do this for the
764 // initial containing block
768 }
771 // Containing block is relative to the padding edge
777 // We are a wrapped frame for the content. Use the container's
778 // dimensions, if they have been precomputed.
779 // XXX This is a hack! We really should be waiting until the outermost
780 // frame is fully reflowed and using the resulting dimensions, even
781 // if they're intrinsic.
782 // In fact we should be attaching absolute children to the outermost
783 // frame and not always sticking them in block frames.
785 // First, find the reflow state for the outermost frame for this
786 // content.
793 }
795 // The wrapper frame should be block-level. If it isn't, how the
796 // heck did it end up wrapping this block frame?
799 // Scrollbars need to be specifically excluded, if present, because they are outside the
800 // padding-edge. We need better APIs for getting the various boxes from a frame.
808 // XXX We should account for the horizontal scrollbar too --- but currently
809 // nsGfxScrollFrame assumes nothing depends on the presence (or absence) of
810 // a horizontal scrollbar, so accounting for it would create incremental
811 // reflow bugs.
812 //if (!lastButOneRS->mFlags.mAssumingHScrollbar) {
814 //}
817 }
818 }
819 // We found a reflow state for the outermost wrapping frame, so use
820 // its computed metrics if available
824 }
828 }
829 }
830 }
833 }
835 NS_IMETHODIMP
840 {
843 #ifdef DEBUG
850 }
857 }
858 #endif
862 // Should we create a space manager?
865 // XXXldb If we start storing the space manager in the frame rather
866 // than keeping it around only during reflow then we should create it
867 // only when there are actually floats to manage. Otherwise things
868 // like tables will gain significant bloat.
873 // OK, some lines may be reflowed. Blow away any saved line cursor because
874 // we may invalidate the nondecreasing combinedArea.y/yMost invariant,
875 // and we may even delete the line with the line cursor.
879 #ifdef DEBUG_kipp
880 {
886 }
887 #endif
890 }
896 #ifdef IBMBIDI
902 }
906 // ALWAYS drain overflow. We never want to leave the previnflow's
907 // overflow lines hanging around; block reflow depends on the
908 // overflow line lists being cleared out between reflow passes.
912 // If we're not dirty (which means we'll mark everything dirty later)
913 // and our width has changed, mark the lines dirty that we need to
914 // mark dirty for a resize reflow.
920 // Now reflow...
925 // If the block is complete, put continuted floats in the closest ancestor
926 // block that uses the same space manager and leave the block complete; this
927 // allows subsequent lines on the page to be impacted by floats. If the
928 // block is incomplete or there is no ancestor using the same space manager,
929 // put continued floats at the beginning of the first overflow line.
934 // find the nearest block ancestor that uses the same space manager
936 ancestorRS;
942 // Put the continued floats in ancestor since it uses the same space manager
945 // The ancestor should have this list, since it's being reflowed. But maybe
946 // it isn't because of reflow roots or something.
956 // Clear the next-sibling in case the frame wasn't in mFloats
958 // Do not put the float into any child frame list, because
959 // placeholders in the overflow-placeholder block-state list
960 // don't keep their out of flows in a child frame list.
961 }
965 }
966 }
967 }
968 }
978 // Need to put the overflow placeholders' floats into our
979 // overflow-out-of-flows list, since the overflow placeholders are
980 // going onto our overflow line list. Put them last, because that's
981 // where the placeholders are going.
982 nsFrameList floats;
989 // oof is not currently in any child list
992 }
994 // Put the new placeholders *last* in the overflow lines
995 // because they might have previnflows in the overflow lines.
998 // Create a new line as the last line and put the
999 // placeholders there
1004 }
1009 }
1011 }
1013 }
1014 }
1019 }
1023 }
1025 #ifdef DEBUG_kipp
1027 #endif
1028 }
1029 }
1033 // Place the "marker" (bullet) frame if it is placed next to a block
1034 // child.
1035 //
1036 // According to the CSS2 spec, section 12.6.1, the "marker" box
1037 // participates in the height calculation of the list-item box's
1038 // first line box.
1039 //
1040 // There are exactly two places a bullet can be placed: near the
1041 // first or second line. It's only placed on the second line in a
1042 // rare case: an empty first line followed by a second line that
1043 // contains a block (example: <LI>\n<P>... ). This is where
1044 // the second case can happen.
1049 // Reflow the bullet
1050 nsHTMLReflowMetrics metrics;
1053 nscoord baseline;
1056 }
1058 // Doing the alignment using the baseline will also cater for
1059 // bullets that are placed next to a child block (bug 92896)
1061 // Tall bullets won't look particularly nice here...
1065 }
1067 // Compute our final size
1072 // see if verifyReflow is enabled, and if so store off the space manager pointer
1073 #ifdef DEBUG
1076 {
1077 // this is a leak of the space manager, but it's only in debug if verify reflow is enabled, so not a big deal
1086 }
1087 }
1088 #endif
1090 // Let the absolutely positioned container reflow any absolutely positioned
1091 // child frames that need to be reflowed, e.g., elements with a percentage
1092 // based width/height
1093 // We want to do this under either of two conditions:
1094 // 1. If we didn't do the incremental reflow above.
1095 // 2. If our size changed.
1096 // Even though it's the padding edge that's the containing block, we
1097 // can use our rect (the border edge) since if the border style
1098 // changed, the reflow would have been targeted at us so we'd satisfy
1099 // condition 1.
1101 nsRect childBounds;
1102 nsSize containingBlockSize
1106 // Mark frames that depend on changes we just made to this frame as dirty:
1107 // Now we can assume that the padding edge hasn't moved.
1108 // We need to reflow the absolutes if one of them depends on
1109 // its placeholder position, or the containing block size in a
1110 // direction in which the containing block size might have
1111 // changed.
1114 // If isRoot and we have auto height, then we are the initial
1115 // containing block and the containing block height is the
1116 // viewport height, which can't change during incremental
1117 // reflow.
1118 PRBool cbHeightChanged =
1128 // Factor the absolutely positioned child bounds into the overflow area
1130 }
1132 // Determine if we need to repaint our border, background or outline
1137 // Clear the space manager pointer in the block reflow state so we
1138 // don't waste time translating the coordinate system back on a dead
1139 // space manager.
1145 #ifdef DEBUG
1159 }
1161 }
1180 }
1181 #endif
1185 }
1187 PRBool
1189 {
1196 }
1200 }
1203 }
1204 }
1205 // not reached
1206 }
1208 void
1212 {
1214 #ifdef NOISY_FINAL_SIZE
1220 #endif
1222 // Compute final width
1226 // Return bottom margin information
1227 // rbs says he hit this assertion occasionally (see bug 86947), so
1228 // just set the margin to zero and we'll figure out why later
1229 //NS_ASSERTION(aMetrics.mCarriedOutBottomMargin.IsZero(),
1230 // "someone else set the margin");
1233 // Apply rule from CSS 2.1 section 8.3.1. If we have some empty
1234 // line with clearance and a non-zero top margin and all
1235 // subsequent lines are empty, then we do not allow our children's
1236 // carried out bottom margin to be carried out of us and collapse
1237 // with our own bottom margin.
1239 // Convert the children's carried out margin to something that
1240 // we will include in our height
1243 }
1247 }
1249 // Compute final height
1251 // Figure out how much of the computed height should be
1252 // applied to this frame.
1255 // Reduce the height by the computed height of prev-in-flows.
1258 }
1259 // We just subtracted our top-border padding, since it was included in the
1260 // first frame's height. Add it back to get the content height.
1262 // We may have stretched the frame beyond its computed height. Oh well.
1264 }
1270 // We don't fit and we consumed some of the computed height,
1271 // so we should consume all the available height and then
1272 // break. If our bottom border/padding straddles the break
1273 // point, then this will increase our height and push the
1274 // border/padding to the next page/column.
1277 }
1278 }
1280 // Use the current height; continuations will take up the rest.
1281 // Do extend the height to at least consume the available
1282 // height, otherwise our left/right borders (for example) won't
1283 // extend all the way to the break.
1286 // ... but don't take up more height than is available
1289 // XXX It's pretty wrong that our bottom border still gets drawn on
1290 // on its own on the last-in-flow, even if we ran out of height
1291 // here. We need GetSkipSides to check whether we ran out of content
1292 // height in the current frame, not whether it's last-in-flow.
1293 }
1295 // Don't carry out a bottom margin when our height is fixed.
1297 }
1301 // Shrink wrap our height around our contents.
1303 // When we are a bottom-margin root make sure that our last
1304 // childs bottom margin is fully applied.
1305 // Apply the margin only if there's space for it.
1307 {
1308 // Truncate bottom margin if it doesn't fit to our available height.
1309 autoHeight = PR_MIN(autoHeight + aState.mPrevBottomMargin.get(), aState.mReflowState.availableHeight);
1310 }
1311 }
1314 // Include the space manager's state to properly account for the
1315 // bottom margin of any floated elements; e.g., inside a table cell.
1316 nscoord ymost;
1320 }
1322 // Apply min/max values
1327 // Our min-height or max-height made our height change. Don't carry out
1328 // our kids' bottom margins.
1330 }
1333 }
1335 #ifdef DEBUG_blocks
1339 }
1340 #endif
1341 }
1343 void
1346 {
1347 // Compute the combined area of our children
1348 // XXX_perf: This can be done incrementally. It is currently one of
1349 // the things that makes incremental reflow O(N^2).
1356 }
1358 // Factor the bullet in; normally the bullet will be factored into
1359 // the line-box's combined area. However, if the line is a block
1360 // line then it won't; if there are no lines, it won't. So just
1361 // factor it in anyway (it can't hurt if it was already done).
1362 // XXXldb Can we just fix GetCombinedArea instead?
1365 }
1366 }
1367 #ifdef NOISY_COMBINED_AREA
1370 #endif
1373 }
1375 nsresult
1377 {
1378 // Mark aLine dirty
1380 #ifdef DEBUG
1385 }
1386 #endif
1388 // Mark previous line dirty if it's an inline line so that it can
1389 // maybe pullup something from the line just affected.
1390 // XXX We don't need to do this if aPrevLine ends in a break-after...
1395 #ifdef DEBUG
1401 }
1402 #endif
1403 }
1406 }
1408 nsresult
1410 {
1411 // we need to calculate if any part of then block itself
1412 // is impacted by a float (bug 19579)
1416 // See if we can try and avoid marking all the lines as dirty
1417 PRBool tryAndSkipLines =
1418 // There must be no floats.
1420 // The text must be left-aligned.
1423 NS_STYLE_DIRECTION_LTR ==
1425 // The left content-edge must be a constant distance from the left
1426 // border-edge.
1429 #ifdef DEBUG
1432 }
1440 }
1441 }
1442 #endif
1451 #ifdef DEBUG
1456 }
1457 #endif
1462 {
1463 // We let child blocks make their own decisions the same
1464 // way we are here.
1472 }
1474 #ifdef REALLY_NOISY_REFLOW
1478 }
1479 #endif
1480 #ifdef DEBUG
1492 }
1493 #endif
1494 }
1495 }
1497 // Mark everything dirty
1501 {
1503 }
1504 }
1506 }
1508 //----------------------------------------
1512 {
1517 // If the target frame is in-flow, and this line contains the it,
1518 // then we've found our line.
1522 // If the target frame is floated, and this line contains the
1523 // float's placeholder, then we've found our line.
1530 }
1531 }
1532 }
1535 }
1537 /**
1538 * Propagate reflow "damage" from from earlier lines to the current
1539 * line. The reflow damage comes from the following sources:
1540 * 1. The regions of float damage remembered during reflow.
1541 * 2. The combination of nonzero |aDeltaY| and any impact by a float,
1542 * either the previous reflow or now.
1543 *
1544 * When entering this function, |aLine| is still at its old position and
1545 * |aDeltaY| indicates how much it will later be slid (assuming it
1546 * doesn't get marked dirty and reflowed entirely).
1547 */
1548 void
1551 nscoord aDeltaY)
1552 {
1555 // Check the damage region recorded in the float damage.
1563 }
1564 }
1567 // Cases we need to find:
1568 //
1569 // 1. the line was impacted by a float and now isn't
1570 // 2. the line wasn't impacted by a float and now is
1571 // 3. the line is impacted by a float both before and after and
1572 // the float has changed position relative to the line (or it's
1573 // a different float). (XXXPerf we don't currently
1574 // check whether the float changed size. We currently just
1575 // mark blocks dirty and ignore any possibility of damage to
1576 // inlines by it being a different float with a different
1577 // size.)
1578 //
1579 // XXXPerf: An optimization: if the line was and is completely
1580 // impacted by a float and the float hasn't changed size,
1581 // then we don't need to mark the line dirty.
1585 #ifdef REALLY_NOISY_REFLOW
1588 #endif
1589 // Mark the line dirty if:
1590 // 1. It used to be impacted by a float and now isn't, or vice
1591 // versa.
1592 // 2. It is impacted by a float and it is a block, which means
1593 // that more or less of the line could be impacted than was in
1594 // the past. (XXXPerf This could be optimized further, since
1595 // we're marking the whole line dirty.)
1599 }
1600 }
1601 }
1608 }
1611 /**
1612 * Reparent a whole list of floats from aOldParent to this block. The
1613 * floats might be taken from aOldParent's overflow list. They will be
1614 * removed from the list. They end up appended to our mFloats list.
1615 */
1616 void
1619 PRBool aReparentSiblings) {
1620 nsFrameList list;
1626 }
1628 }
1629 }
1633 #ifdef DEBUG
1637 printf("line=%p mY=%d dirty=%s oldBounds={%d,%d,%d,%d} oldCombinedArea={%d,%d,%d,%d} deltaY=%d mPrevBottomMargin=%d childCount=%d\n",
1644 }
1645 #endif
1646 }
1648 /**
1649 * Reflow the dirty lines
1650 */
1651 nsresult
1653 {
1659 #ifdef DEBUG
1665 }
1667 #endif
1673 // the amount by which we will slide the current line if it is not
1674 // dirty
1677 // whether we did NOT reflow the previous line and thus we need to
1678 // recompute the carried out margin before the line if we want to
1679 // reflow it or if its previous margin is dirty
1683 // We save up information about BR-clearance here
1688 // Reflow the lines that are already ours
1691 #ifdef DEBUG
1693 #endif
1698 // This really sucks, but we have to look inside any blocks that have clear
1699 // elements inside them.
1700 // XXX what can we do smarter here?
1704 }
1706 // We have to reflow the line if it's a block whose clearance
1707 // might have changed, so detect that.
1710 // See where we would be after applying any clearance due to
1711 // BRs.
1714 }
1719 // Reflow the line if it might not have clearance anymore.
1721 // aState.mY is the clearance point which should be the
1722 // top border-edge of the block frame. If sliding the
1723 // block by deltaY isn't going to put it in the predicted
1724 // position, then we'd better reflow the line.
1727 }
1729 // Reflow the line if the line might have clearance now.
1732 }
1733 }
1734 }
1736 // We might have to reflow a line that is after a clearing BR.
1740 // SlideLine is not going to put the line where the clearance
1741 // put it. Reflow the line to be sure.
1743 }
1745 }
1749 // If the previous margin is dirty, reflow the current line
1753 // Lines that aren't dirty but get slid past our height constraint must
1754 // be reflowed.
1756 }
1759 // See if there's any reflow damage that requires that we mark the
1760 // line dirty.
1762 }
1765 // We need to reconstruct the bottom margin only if we didn't
1766 // reflow the previous line and we do need to reflow (or repair
1767 // the top position of) the next line.
1769 }
1774 // Update aState.mPrevChild as if we had reflowed all of the frames in
1775 // this line. This is expensive in some cases, since it requires
1776 // walking |GetNextSibling|.
1779 }
1781 // Now repair the line and update |aState.mY| by calling
1782 // |ReflowLine| or |SlideLine|.
1786 PRBool maybeReflowingForFirstTime =
1790 // Compute the dirty lines "before" YMost, after factoring in
1791 // the running deltaY value - the running value is implicit in
1792 // aState.mY.
1796 // Reflow the dirty line. If it's an incremental reflow, then force
1797 // it to invalidate the dirty area if necessary
1803 }
1809 }
1811 }
1813 // Test to see whether the margin that should be carried out
1814 // to the next line (NL) might have changed. In ReflowBlockFrame
1815 // we call nextLine->MarkPreviousMarginDirty if the block's
1816 // actual carried-out bottom margin changed. So here we only
1817 // need to worry about the following effects:
1818 // 1) the line was just created, and it might now be blocking
1819 // a carried-out bottom margin from previous lines that
1820 // used to reach NL from reaching NL
1821 // 2) the line used to be empty, and is now not empty,
1822 // thus blocking a carried-out bottom margin from previous lines
1823 // that used to reach NL from reaching NL
1824 // 3) the line wasn't empty, but now is, so a carried-out
1825 // bottom margin from previous lines that didn't used to reach NL
1826 // now does
1827 // 4) the line might have changed in a way that affects NL's
1828 // ShouldApplyTopMargin decision. The three things that matter
1829 // are the line's emptiness, its adjacency to the top of the block,
1830 // and whether it has clearance (the latter only matters if the block
1831 // was and is adjacent to the top and empty).
1832 //
1833 // If the line is empty now, we can't reliably tell if the line was empty
1834 // before, so we just assume it was and do nextLine->MarkPreviousMarginDirty.
1835 // This means the checks in 4) are redundant; if the line is empty now
1836 // we don't need to check 4), but if the line is not empty now and we're sure
1837 // it wasn't empty before, any adjacency and clearance changes are irrelevant
1838 // to the result of nextLine->ShouldApplyTopMargin.
1845 // since it's marked dirty, nobody will care about |deltaY|
1846 }
1847 }
1849 // If the line was just reflowed for the first time, then its
1850 // old mBounds cannot be trusted so this deltaY computation is
1851 // bogus. But that's OK because we just did
1852 // MarkPreviousMarginDirty on the next line which will force it
1853 // to be reflowed, so this computation of deltaY will not be
1854 // used.
1861 else
1864 // XXX EVIL O(N^2) EVIL
1867 // Keep mY up to date in case we're propagating reflow damage
1868 // and also because our final height may depend on it. If the
1869 // line is inlines, then only update mY if the line is not
1870 // empty, because that's what PlaceLine does. (Empty blocks may
1871 // want to update mY, e.g. if they have clearance.)
1874 }
1877 }
1879 // Record if we need to clear floats before reflowing the next
1880 // line. Note that inlineFloatBreakType will be handled and
1881 // cleared before the next line is processed, so there is no
1882 // need to combine break types here.
1885 }
1889 }
1892 }
1894 // Handle BR-clearance from the last line of the block
1897 }
1900 // Is this expensive?
1903 // Update aState.mPrevChild as if we had reflowed all of the frames in
1904 // the last line. This is expensive in some cases, since it requires
1905 // walking |GetNextSibling|.
1907 }
1909 // Should we really have to do this?
1913 // We can skip trying to pull up the next line if there is no next
1914 // in flow or we were told not to or we know it will be futile, i.e.,
1915 // -- the next in flow is not changing
1916 // -- and we cannot have added more space for its first line to be
1917 // pulled up into,
1918 // -- it's an incremental reflow of a descendant
1919 // -- and we didn't reflow any floats (so the available space
1920 // didn't change)
1921 // XXXldb We should also check that the first line of the next-in-flow
1922 // isn't dirty.
1930 }
1932 // Pull data from a next-in-flow if there's still room for more
1933 // content here.
1935 // Grab first line from our next-in-flow
1939 PRBool collectOverflowFloats;
1942 // go around again in case the line was deleted
1944 }
1949 // Grab an overflow line if there are any
1953 // go around again in case the line was deleted
1955 }
1960 }
1968 // We need to this remove-and-put-back dance because we want
1969 // to avoid making the overflow line list empty while it's
1970 // stored in the property (because the property has the
1971 // invariant that the list is never empty).
1973 }
1975 }
1978 // The line is empty. Try the next one.
1982 }
1984 // XXX move to a subroutine: run-in, overflow, pullframe and this do this
1985 // Make the children in the line ours.
1993 }
1996 // Reparent floats whose placeholders are in the line.
1999 // Add line to our line list
2002 }
2007 #ifdef DEBUG
2009 #endif
2011 // Now reflow it and any lines that it makes during it's reflow
2012 // (we have to loop here because reflowing the line may case a new
2013 // line to be created; see SplitLine's callers for examples of
2014 // when this happens).
2022 }
2024 }
2028 }
2030 // If this is an inline frame then its time to stop
2033 }
2034 }
2038 }
2039 }
2041 // Handle an odd-ball case: a list-item with no lines
2043 nsHTMLReflowMetrics metrics;
2046 // There are no lines so we have to fake up some y motion so that
2047 // we end up with *some* height.
2049 }
2055 }
2057 #ifdef DEBUG
2063 }
2064 #endif
2067 }
2069 void
2073 {
2077 "using function more generally than designed, "
2082 // Mark the previous margin of the next line dirty since we need to
2083 // recompute its top position.
2086 }
2087 }
2089 /**
2090 * Takes two rectangles whose origins must be the same, and computes
2091 * the difference between their union and their intersection as two
2092 * rectangles. (This difference is a superset of the difference
2093 * between the two rectangles.)
2094 */
2109 }
2111 /**
2112 * Reflow a line. The line will either contain a single block frame
2113 * or contain 1 or more inline frames. aKeepReflowGoing indicates
2114 * whether or not the caller should continue to reflow more lines.
2115 */
2116 nsresult
2118 line_iterator aLine,
2120 {
2125 // Setup the line-layout for the new line
2130 // Now that we know what kind of line we have, reflow it
2137 // We expect blocks to damage any area inside their bounds that is
2138 // dirty; however, if the frame changes size or position then we
2139 // need to do some repainting.
2140 // XXX roc --- the above statement is ambiguous about whether 'bounds'
2141 // means the frame's bounds or overflowArea, and in fact this is a source
2142 // of much confusion and bugs. Thus the following hack considers *both*
2143 // overflowArea and bounds. This should be considered a temporary hack
2144 // until we decide how it's really supposed to work.
2148 // The block has moved, and so to be safe we need to repaint
2149 // XXX We need to improve on this...
2150 nsRect dirtyRect;
2152 #ifdef NOISY_BLOCK_INVALIDATE
2155 #endif
2165 #ifdef NOISY_BLOCK_INVALIDATE
2171 this, combinedAreaVStrip.x, combinedAreaVStrip.y, combinedAreaVStrip.width, combinedAreaVStrip.height);
2173 this, combinedAreaHStrip.x, combinedAreaHStrip.y, combinedAreaHStrip.width, combinedAreaHStrip.height);
2174 #endif
2175 // The first thing Invalidate does is check if the rect is empty, so
2176 // don't bother doing that here.
2181 }
2182 }
2189 // We don't really know what changed in the line, so use the union
2190 // of the old and new combined areas
2191 nsRect dirtyRect;
2193 #ifdef NOISY_BLOCK_INVALIDATE
2198 #endif
2200 }
2203 }
2205 /**
2206 * Pull frame from the next available location (one of our lines or
2207 * one of our next-in-flows lines).
2208 */
2209 nsresult
2211 line_iterator aLine,
2213 {
2216 // First check our remaining lines
2218 #ifdef DEBUG
2219 PRBool retry =
2220 #endif
2224 }
2229 // Try each next in flows
2232 // first normal lines, then overflow lines
2236 // try again with the same value of nextInFlow
2238 }
2240 }
2246 // try again with the same value of nextInFlow
2248 }
2250 }
2254 }
2257 }
2259 /**
2260 * Try to pull a frame out of a line pointed at by aFromLine. If
2261 * aUpdateGeometricParent is set then the pulled frames geometric parent
2262 * will be updated (e.g. when pulling from a next-in-flows line list).
2263 *
2264 * Note: pulling a frame from a line that is a place-holder frame
2265 * doesn't automatically remove the corresponding float from the
2266 * line's float array. This happens indirectly: either the line gets
2267 * emptied (and destroyed) or the line gets reflowed (because we mark
2268 * it dirty) and the code at the top of ReflowLine empties the
2269 * array. So eventually, it will be removed, just not right away.
2270 *
2271 * @return PR_TRUE to force retrying of the pull.
2272 */
2273 PRBool
2277 PRBool aFromOverflowLine,
2280 {
2286 NS_ASSERTION(fromLine->IsBlock() == fromLine->mFirstChild->GetStyleDisplay()->IsBlockOutside(),
2290 // If our line is not empty and the child in aFromLine is a block
2291 // then we cannot pull up the frame into this line. In this case
2292 // we stop pulling.
2294 }
2296 // Take frame from fromLine
2301 // we lost this one, retry
2303 }
2306 }
2307 // when aFromContainer is 'this', then aLine->LastChild()'s next sibling
2308 // is already set correctly.
2313 // Mark line dirty now that we pulled a child
2317 }
2319 // Free up the fromLine now that it's empty
2320 // Its bounds might need to be redrawn, though.
2321 // XXX WHY do we invalidate the bounds AND the combined area? doesn't
2322 // the combined area always enclose the bounds?
2332 // Note that aFromLine just got incremented, so don't use it again here!
2335 // Put any remaining overflow lines back.
2338 }
2339 }
2341 // Change geometric parents
2343 // When pushing and pulling frames we need to check for whether any
2344 // views need to be reparented
2349 // The frame is being pulled from a next-in-flow; therefore we
2350 // need to add it to our sibling list.
2354 }
2356 // The frame might have (or contain) floats that need to be
2357 // brought over too.
2359 }
2361 // Stop pulling because we found a frame to pull
2363 #ifdef DEBUG
2365 #endif
2366 }
2368 }
2370 static void
2372 {
2375 else
2377 }
2379 void
2382 {
2386 // Adjust line state
2390 // Adjust the frames in the line
2394 }
2401 }
2403 // Make sure the frame's view and any child views are updated
2405 }
2407 // Adjust the Y coordinate of the frames in the line.
2408 // Note: we need to re-position views even if aDY is 0, because
2409 // one of our parent frames may have moved and so the view's position
2410 // relative to its parent may have changed
2417 }
2418 // Make sure the frame's view and any child views are updated
2421 }
2422 }
2423 }
2425 NS_IMETHODIMP
2428 PRInt32 aModType)
2429 {
2435 }
2439 // XXX Not sure if this is necessary anymore
2443 NS_FRAME_HAS_DIRTY_CHILDREN);
2444 }
2445 }
2449 // Search for the closest ancestor that's a block frame. We
2450 // make the assumption that all related list items share a
2451 // common block parent.
2452 // XXXldb I think that's a bad assumption.
2455 // Tell the enclosing block frame to renumber list items within
2456 // itself
2459 // XXX Not sure if this is necessary anymore
2463 NS_FRAME_HAS_DIRTY_CHILDREN);
2464 }
2465 }
2466 }
2467 }
2470 }
2472 inline PRBool
2474 {
2477 }
2479 inline PRBool
2481 {
2485 }
2487 /* virtual */ PRBool
2489 {
2503 }
2518 }
2522 nsStyleCoord coord;
2530 }
2533 }
2535 PRBool
2537 {
2540 }
2545 {
2548 }
2551 }
2553 PRBool
2555 {
2558 }
2563 {
2566 }
2569 }
2571 PRBool
2574 {
2576 // Apply short-circuit check to avoid searching the line list
2578 }
2581 // If we aren't at the top Y coordinate then something of non-zero
2582 // height must have been placed. Therefore the childs top-margin
2583 // applies.
2586 }
2588 // Determine if this line is "essentially" the first line
2592 }
2595 // A line which precedes aLine is non-empty, or has clearance,
2596 // so therefore the top margin applies.
2599 }
2600 // No need to apply the top margin if the line has floats. We
2601 // should collapse anyway (bug 44419)
2605 }
2607 // The line being reflowed is "essentially" the first line in the
2608 // block. Therefore its top-margin will be collapsed by the
2609 // generational collapsing logic with its parent (us).
2611 }
2613 nsIFrame*
2615 {
2632 }
2634 // If placeholders/floats split during reflowing a line, but that line will
2635 // be put on the next page, then put the placeholders/floats back the way
2636 // they were before the line was reflowed.
2637 void
2640 {
2645 }
2649 }
2650 // remove the next in flows of the placeholders that need to be removed
2652 placeholder; ) {
2659 // XXX we probably should be doing something with oof here. But what?
2665 }
2666 }
2668 nsresult
2670 line_iterator aLine,
2672 {
2681 }
2683 // Prepare the block reflow engine
2688 // If a float split and its prev-in-flow was followed by a <BR>, then combine
2689 // the <BR>'s break type with the block's break type (the block will be the very
2690 // next frame after the split float).
2695 }
2697 // Clear past floats before the block if the clear style is not none
2700 // See if we should apply the top margin. If the block frame being
2701 // reflowed is a continuation (non-null prev-in-flow) then we don't
2702 // apply its top margin because it's not significant. Otherwise, dig
2703 // deeper.
2704 PRBool applyTopMargin =
2708 // The HasClearance setting is only valid if ShouldApplyTopMargin
2709 // returned PR_FALSE (in which case the top-margin-root set our
2710 // clearance flag). Otherwise clear it now. We'll set it later on
2711 // ourselves if necessary.
2713 }
2715 // If our top margin was counted as part of some parents top-margin
2716 // collapse and we are being speculatively reflowed assuming this
2717 // frame DID NOT need clearance, then we need to check that
2718 // assumption.
2724 // Looks like that assumption was invalid, we do need
2725 // clearance. Tell our ancestor so it can reflow again. It is
2726 // responsible for actually setting our clearance flag before
2727 // the next reflow.
2729 // Only record the first frame that requires clearance
2732 }
2733 // Exactly what we do now is flexible since we'll definitely be
2734 // reflowed.
2735 }
2736 }
2739 }
2744 nscoord clearance;
2745 // Save the original position of the frame so that we can reposition
2746 // its view as needed.
2749 // Save the frame's current position. We might need it later.
2756 // Precompute the blocks top margin value so that we can get the
2757 // correct available space (there might be a float that's
2758 // already been placed below the aState.mPrevBottomMargin
2760 // Setup a reflowState to get the style computed margin-top
2761 // value. We'll use a reason of `resize' so that we don't fudge
2762 // any incremental reflow state.
2764 // The availSpace here is irrelevant to our needs - all we want
2765 // out if this setup is the margin-top value which doesn't depend
2766 // on the childs available space.
2767 // XXX building a complete nsHTMLReflowState just to get the margin-top
2768 // seems like a waste. And we do this for almost every block!
2776 }
2778 // Now compute the collapsed margin-top value into aState.mPrevBottomMargin, assuming
2779 // that all child margins collapse down to clearanceFrame.
2783 // XXX optimization; we could check the collapsing children to see if they are sure
2784 // to require clearance, and so avoid retrying them
2787 // Don't allow retries on the second pass. The clearance decisions for the
2788 // blocks whose top-margins collapse with ours are now fixed.
2790 }
2793 // We don't know if we need clearance and this is the first,
2794 // optimistic pass. So determine whether *this block* needs
2795 // clearance. Note that we do not allow the decision for whether
2796 // this block has clearance to change on the second pass; that
2797 // decision is only allowed to be made under the optimistic
2798 // first pass.
2802 // Looks like we need clearance and we didn't know about it already. So
2803 // recompute collapsed margin
2805 // Remember this decision, needed for incremental reflow
2808 // Apply incoming margins
2812 // Compute the collapsed margin again, ignoring the incoming margin this time
2816 }
2817 }
2819 // Temporarily advance the running Y value so that the
2820 // GetAvailableSpace method will return the right available
2821 // space. This undone as soon as the horizontal margins are
2822 // computed.
2827 // advance mY to the clear position.
2830 // Compute clearance. It's the amount we need to add to the top
2831 // border-edge of the frame, after applying collapsed margins
2832 // from the frame and its children, to get it to line up with
2833 // the bottom of the floats. The former is currentY + topMargin,
2834 // the latter is the current aState.mY.
2835 // Note that negative clearance is possible
2838 // Add clearance to our top margin while we compute available
2839 // space for the frame
2842 // Note that aState.mY should stay where it is: at the top
2843 // border-edge of the frame
2845 // Advance aState.mY to the top border-edge of the frame.
2847 }
2848 }
2850 // Here aState.mY is the top border-edge of the block.
2851 // Compute the available space for the block
2853 #ifdef REALLY_NOISY_REFLOW
2854 printf("setting line %p isImpacted to %s\n", aLine.get(), aState.IsImpactedByFloat()?"true":"false");
2855 #endif
2858 nsRect availSpace;
2861 // Now put the Y coordinate back to the top of the top-margin +
2862 // clearance, and flow the block.
2867 }
2869 // keep track of the last overflow float in case we need to undo any new additions
2872 // Reflow the block into the available space
2873 nsMargin computedOffsets;
2874 // construct the html reflow state for the block. ReflowBlock
2875 // will initialize it
2886 }
2893 // If this was a second-pass reflow and the block's vertical position
2894 // changed, invalidates from the first pass might have happened in the
2895 // wrong places. Invalidate the entire overflow rect at the new position.
2899 }
2909 }
2913 #if defined(REFLOW_STATUS_COVERAGE)
2915 #endif
2918 // None of the child block fits.
2923 }
2925 // Note: line-break-after a block is a nop
2927 // Try to place the child block.
2928 // Don't force the block to fit if we have positive clearance, because
2929 // pushing it to the next page would give it more room.
2930 // Don't force the block to fit if it's impacted by a float. If it is,
2931 // then pushing it to the next page would give it more room. Note that
2932 // isImpacted doesn't include impact from the block's own floats.
2935 nsCollapsingMargin collapsedBottomMargin;
2945 }
2946 }
2950 // Some of the child block fit
2952 // Advance to new Y position
2956 // Continue the block frame now if it didn't completely fit in
2957 // the available space.
2959 PRBool madeContinuation;
2965 // Push continuation to a new line, but only if we actually made one.
2970 }
2972 // Advance to next line since some of the block fit. That way
2973 // only the following lines will be pushed.
2976 // If we need to reflow the continuation of the block child,
2977 // then we'd better reflow our continuation
2980 // We also need to make that continuation's line dirty so
2981 // it gets reflowed when we reflow our next in flow. The
2982 // nif's line must always be either a line of the nif's
2983 // parent block (only if we didn't make a continuation) or
2984 // else one of our own overflow lines. In the latter case
2985 // the line is already marked dirty, so just handle the
2986 // first case.
2997 }
2998 }
2999 }
3000 }
3003 // The bottom margin for a block is only applied on the last
3004 // flow block. Since we just continued the child block frame,
3005 // we know that line->mFirstChild is not the last flow block
3006 // therefore zero out the running margin value.
3007 #ifdef NOISY_VERTICAL_MARGINS
3013 #endif
3015 }
3017 #ifdef NOISY_VERTICAL_MARGINS
3023 #endif
3025 }
3026 #ifdef NOISY_VERTICAL_MARGINS
3033 #endif
3034 }
3036 // None of the block fits. Determine the correct reflow status.
3038 // If it's our very first line then we need to be pushed to
3039 // our parents next-in-flow. Therefore, return break-before
3040 // status for our reflow status.
3042 }
3044 // Push the line that didn't fit and any lines that follow it
3045 // to our next-in-flow.
3049 }
3050 }
3051 }
3053 }
3055 // Now that we've got its final position all figured out, position any child
3056 // views it may have. Note that the case when frame has a view got handled
3057 // by FinishReflowChild, but that function didn't have the coordinates needed
3058 // to correctly decide whether to reposition child views.
3061 }
3063 #ifdef DEBUG
3065 #endif
3067 }
3069 nsresult
3071 line_iterator aLine,
3073 {
3077 #ifdef DEBUG
3079 #endif
3090 // Once upon a time we allocated the first 30 nsLineLayout objects
3091 // on the stack, and then we switched to the heap. At that time
3092 // these objects were large (1100 bytes on a 32 bit system).
3093 // Then the nsLineLayout object was shrunk to 156 bytes by
3094 // removing some internal buffers. Given that it is so much
3095 // smaller, the complexity of 2 different ways of allocating
3096 // no longer makes sense. Now we always allocate on the stack
3103 }
3106 allowPullUp);
3113 // If there is no saved break position, then this will set
3114 // set forceBreakInContent to null and we won't back up, which is
3115 // correct.
3119 }
3120 // restore the space manager state
3122 // Clear out float lists
3125 }
3127 #ifdef DEBUG
3128 spins++;
3133 }
3134 #endif
3136 // Don't allow pullup on a subsequent LINE_REFLOW_REDO_NO_PULL pass
3142 }
3145 // If we did at least one REDO_FOR_FLOAT, then the line did not fit next to some float.
3146 // Mark it as impacted by a float, even if it no longer is next to a float.
3149 }
3152 }
3154 // If at least one float on the line was complete, not at the top of
3155 // page, but was truncated, then restore the overflow floats to what
3156 // they were before and push the line. The floats that will be removed
3157 // from the list aren't yet known by the block's next in flow.
3158 void
3160 line_iterator aLine,
3163 {
3171 }
3173 #ifdef DEBUG
3177 };
3178 #endif
3180 nsresult
3183 line_iterator aLine,
3186 PRBool aAllowPullUp)
3187 {
3188 // Forget all of the floats on the line
3192 // Setup initial coordinate system for reflowing the inline frames
3193 // into. Apply a previous block frame's bottom margin first.
3196 }
3200 #ifdef REALLY_NOISY_REFLOW
3203 #endif
3208 nscoord availHeight;
3211 }
3213 /* XXX get the height right! */
3215 }
3217 // Make sure to enable resize optimization before we call BeginLineReflow
3218 // because it might get disabled there
3223 impactedByFloats,
3226 // XXX Unfortunately we need to know this before reflowing the first
3227 // inline frame in the line. FIX ME.
3231 }
3233 // keep track of the last overflow float in case we need to undo any new additions
3236 // Reflow the frames that are already on the line first
3239 PRInt32 i;
3242 // Determine whether this is a line of placeholders for out-of-flow
3243 // continuations
3247 // There is a soft break opportunity at the start of the line, because
3248 // we can always move this line down below float(s).
3251 }
3252 }
3254 // need to repeatedly call GetChildCount here, because the child
3255 // count can change during the loop!
3260 }
3265 // It is possible that one or more of next lines are empty
3266 // (because of DeleteNextInFlowChild). If so, delete them now
3267 // in case we are finished.
3270 // XXX Is this still necessary now that DeleteNextInFlowChild
3271 // uses DoRemoveFrame?
3276 }
3280 // Push the line with the truncated float
3282 }
3283 }
3284 }
3286 // Don't pull up new frames into lines with continuation placeholders
3288 // Pull frames and reflow them until we can't
3294 }
3302 // We just created a continuation for aFrame AND its going
3303 // to end up on this line (e.g. :first-letter
3304 // situation). Therefore we have to loop here before trying
3305 // to pull another frame.
3307 }
3310 }
3311 }
3312 }
3313 }
3315 // We only need to backup if the line isn't going to be reflowed again anyway
3320 "Someone must have set a break opportunity beyond the available width, "
3323 }
3325 // We need to try backing up to before a text run
3326 PRInt32 offset;
3328 // XXX It's possible, in fact not unusual, for the break opportunity to already
3329 // be the end of the line. We should detect that and optimize to not
3330 // re-do the line.
3332 // We can back up!
3334 }
3336 // In case we reflow this line again, remember that we don't
3337 // need to force any breaking
3339 }
3342 // This happens only when we have a line that is impacted by
3343 // floats and the first element in the line doesn't fit with
3344 // the floats.
3345 //
3346 // What we do is to advance past the first float we find and
3347 // then reflow the line all over again.
3359 // just move it down a bit to try to get out of this mess
3362 // There's nowhere to retry placing the line. Just treat it as if
3363 // we placed the float but it was truncated so we need this line
3364 // to go to the next page/column.
3366 // Push the line that didn't fit
3369 }
3370 }
3372 // We don't want to advance by the bottom margin anymore (we did it
3373 // once at the beginning of this function, which will just be called
3374 // again), and we certainly don't want to go back if it's negative
3375 // (infinite loop, bug 153429).
3378 // XXX: a small optimization can be done here when paginating:
3379 // if the new Y coordinate is past the end of the block then
3380 // push the line and return now instead of later on after we are
3381 // past the float.
3382 }
3384 // We don't want to advance by the bottom margin anymore (we did it
3385 // once at the beginning of this function, which will just be called
3386 // again), and we certainly don't want to go back if it's negative
3387 // (infinite loop, bug 153429).
3389 }
3391 // If we are propagating out a break-before status then there is
3392 // no point in placing the line.
3396 }
3397 }
3398 }
3399 #ifdef DEBUG
3402 }
3403 #endif
3407 }
3409 /**
3410 * Reflow an inline frame. The reflow status is mapped from the frames
3411 * reflow status to the lines reflow status (not to our reflow status).
3412 * The line reflow status is simple: PR_TRUE means keep placing frames
3413 * on the line; PR_FALSE means don't (the line is done). If the line
3414 * has some sort of breaking affect then aLine's break-type will be set
3415 * to something other than NS_STYLE_CLEAR_NONE.
3416 */
3417 nsresult
3420 line_iterator aLine,
3423 {
3428 // If it's currently ok to be reflowing in first-letter style then
3429 // we must be about to reflow a frame that has first-letter style.
3431 #ifdef NOISY_FIRST_LETTER
3436 #endif
3438 // Reflow the inline frame
3439 nsReflowStatus frameReflowStatus;
3440 PRBool pushedFrame;
3446 // we need to ensure that the frame's nextinflow gets reflowed.
3453 }
3454 }
3455 }
3458 #ifdef REALLY_NOISY_REFLOW_CHILD
3461 #endif
3463 #if defined(REFLOW_STATUS_COVERAGE)
3465 #endif
3467 // Send post-reflow notification
3470 /* XXX
3471 This is where we need to add logic to handle some odd behavior.
3472 For one thing, we should usually place at least one thing next
3473 to a left float, even when that float takes up all the width on a line.
3474 see bug 22496
3475 */
3477 // Process the child frames reflow status. There are 5 cases:
3478 // complete, not-complete, break-before, break-after-complete,
3479 // break-after-not-complete. There are two situations: we are a
3480 // block or we are an inline. This makes a total of 10 cases
3481 // (fortunately, there is some overlap).
3485 // Always abort the line reflow (because a line break is the
3486 // minimal amount of break we do).
3489 // XXX what should aLine's break-type be set to in all these cases?
3496 // Break-before cases.
3498 // If we break before the first frame on the line then we must
3499 // be trying to place content where there's no room (e.g. on a
3500 // line with wide floats). Inform the caller to reflow the
3501 // line after skipping past a float.
3503 }
3505 // It's not the first child on this line so go ahead and split
3506 // the line. We will see the frame again on the next-line.
3510 // If we're splitting the line because the frame didn't fit and it
3511 // was pushed, then mark the line as having word wrapped. We need to
3512 // know that if we're shrink wrapping our width
3515 }
3516 }
3517 }
3519 // If a float split and its prev-in-flow was followed by a <BR>, then combine
3520 // the <BR>'s break type with the inline's break type (the inline will be the very
3521 // next frame after the split float).
3526 }
3527 // Break-after cases
3531 }
3532 }
3535 // Create a continuation for the incomplete frame. Note that the
3536 // frame may already have a continuation.
3537 PRBool madeContinuation;
3541 // Remember that the line has wrapped
3543 }
3544 }
3546 // Split line, but after the frame just reflowed
3553 // Mark next line dirty in case SplitLine didn't end up
3554 // pushing any frames.
3558 }
3559 }
3560 }
3561 }
3563 // Frame is not-complete, no special breaking status
3567 // Create a continuation for the incomplete frame. Note that the
3568 // frame may already have a continuation.
3569 PRBool madeContinuation;
3575 // Remember that the line has wrapped
3578 }
3580 // If we are reflowing the first letter frame or a placeholder then
3581 // don't split the line and don't stop the line reflow...
3588 }
3589 }
3592 // Split line after the current frame
3597 // Mark next line dirty in case SplitLine didn't end up
3598 // pushing any frames.
3602 }
3603 }
3604 }
3606 // if the frame is a placeholder and was complete but truncated (and not at the top
3607 // of page), the entire line will be pushed to give it another chance to not truncate.
3610 }
3611 }
3614 }
3616 /**
3617 * Create a continuation, if necessary, for aFrame. Place it in aLine
3618 * if aLine is not null. Set aMadeNewFrame to PR_TRUE if a new frame is created.
3619 */
3620 nsresult
3625 {
3627 nsresult rv;
3635 }
3636 }
3637 #ifdef DEBUG
3639 #endif
3641 }
3643 nsresult
3646 {
3652 // Next in flow was not created because it already exists.
3654 }
3656 // put the sibling list back to what it was before the continuation was created
3665 // The new out of flow frame does not get put anywhere; the out-of-flows
3666 // for placeholders in mOverflowPlaceholders are not kept in any child list
3669 }
3673 {
3677 }
3679 }
3681 static PRBool
3683 {
3689 }
3692 }
3694 nsresult
3697 line_iterator aLine,
3700 {
3706 #ifdef DEBUG
3713 }
3716 }
3720 }
3721 }
3722 #endif
3730 // Put frames being split out into their own line
3734 }
3737 #ifdef DEBUG
3740 }
3741 #endif
3743 // Let line layout know that some frames are no longer part of its
3744 // state.
3747 // If floats have been placed whose placeholders have been pushed to the new
3748 // line, we need to reflow the old line again. We don't want to look at the
3749 // frames in the new line, because as a large paragraph is laid out the
3750 // we'd get O(N^2) performance. So instead we just check that the last
3751 // float and the last below-current-line float are still in aLine.
3755 }
3757 #ifdef DEBUG
3759 #endif
3760 }
3762 }
3764 PRBool
3766 line_iterator aLine)
3767 {
3769 // There is another line
3771 // If the next line is a block line then we must not justify
3772 // this line because it means that this line is the last in a
3773 // group of inline lines.
3775 }
3776 // The next line is empty, try the next one
3777 }
3779 // XXX Not sure about this part
3780 // Try our next-in-flows lines to answer the question
3787 {
3790 }
3792 }
3794 // This is the last line - so don't allow justification
3796 }
3798 PRBool
3801 line_iterator aLine,
3803 {
3804 // Trim extra white-space from the line before placing the frames
3807 // Vertically align the frames on this line.
3808 //
3809 // According to the CSS2 spec, section 12.6.1, the "marker" box
3810 // participates in the height calculation of the list-item box's
3811 // first line box.
3812 //
3813 // There are exactly two places a bullet can be placed: near the
3814 // first or second line. It's only placed on the second line in a
3815 // rare case: an empty first line followed by a second line that
3816 // contains a block (example: <LI>\n<P>... ).
3817 //
3818 // For this code, only the first case is possible because this
3819 // method is used for placing a line of inline frames. If the rare
3820 // case is happening then the worst that will happen is that the
3821 // bullet frame will be reflowed twice.
3825 nsHTMLReflowMetrics metrics;
3829 }
3832 #ifdef DEBUG
3833 {
3842 }
3843 }
3846 }
3847 }
3848 #endif
3850 // Only block frames horizontally align their children because
3851 // inline frames "shrink-wrap" around their children (therefore
3852 // there is no extra horizontal space).
3858 // XXX: not only bidi: right alignment can be broken after
3859 // RelativePositionFrames!!!
3860 // XXXldb Is something here considering relatively positioned frames at
3861 // other than their original positions?
3862 #ifdef IBMBIDI
3863 // XXXldb Why don't we do this earlier?
3877 nsRect combinedArea;
3878 aLineLayout.RelativePositionFrames(combinedArea); // XXXldb This returned width as -15, 2001-06-12, Bugzilla
3882 }
3884 // Inline lines do not have margins themselves; however they are
3885 // impacted by prior block margins. If this line ends up having some
3886 // height then we zero out the previous bottom margin value that was
3887 // already applied to the line's starting Y coordinate. Otherwise we
3888 // leave it be so that the previous blocks bottom margin can be
3889 // collapsed with a block that follows.
3890 nscoord newY;
3893 // This line has some height. Therefore the application of the
3894 // previous-bottom-margin should stick.
3897 }
3899 // Don't let the previous-bottom-margin value affect the newY
3900 // coordinate (it was applied in ReflowInlineFrames speculatively)
3901 // since the line is empty.
3902 // We already called |ShouldApplyTopMargin|, and if we applied it
3903 // then BRS_APPLYTOPMARGIN is set.
3908 }
3910 // See if the line fit. If it doesn't we need to push it. Our first
3911 // line will always fit.
3915 // Push this line and all of its children and anything else that
3916 // follows to our next-in-flow
3920 // Stop reflow and whack the reflow status if reflow hasn't
3921 // already been stopped.
3925 }
3927 }
3929 // May be needed below
3934 // Add the already placed current-line floats to the line
3937 // Any below current line floats to place?
3939 // Reflow the below-current-line floats, then add them to the
3940 // lines float list if there aren't any truncated floats.
3942 wasAdjacentWIthTop)) {
3944 }
3946 // At least one float is truncated, so fix up any placeholders that got split and
3947 // push the line. XXX It may be better to put the float on the next line, but this
3948 // is not common enough to justify the complexity. Or maybe it is now...
3952 }
3953 }
3955 // When a line has floats, factor them into the combined-area
3956 // computations.
3958 // Combine the float combined area (stored in aState) and the
3959 // value computed by the line layout code.
3961 #ifdef NOISY_COMBINED_AREA
3969 #endif
3973 #ifdef NOISY_COMBINED_AREA
3977 #endif
3978 }
3980 // Apply break-after clearing if necessary
3981 // This must stay in sync with |ReflowDirtyLines|.
3984 }
3987 }
3989 void
3992 {
3995 // PushTruncatedPlaceholderLine sometimes pushes the first line. Ugh.
3999 // Remove floats in the lines from mFloats
4000 nsFrameList floats;
4005 // Push the floats onto the front of the overflow out-of-flows list
4009 }
4011 }
4013 // overflow lines can already exist in some cases, in particular,
4014 // when shrinkwrapping and we discover that the shrinkwap causes
4015 // the height of some child block to grow which creates additional
4016 // overflowing content. In such cases we must prepend the new
4017 // overflow to the existing overflow.
4020 // XXXldb use presshell arena!
4022 }
4026 }
4030 // this takes ownership but it won't delete it immediately so we
4031 // can keep using it.
4034 // Mark all the overflow lines dirty so that they get reflowed when
4035 // they are pulled up by our next-in-flow.
4037 // XXXldb Can this get called O(N) times making the whole thing O(N^2)?
4042 {
4048 }
4049 }
4050 }
4051 }
4053 // Break frame sibling list
4057 #ifdef DEBUG
4059 #endif
4060 }
4062 /**
4063 * Call this when a frame will be pulled from the block's
4064 * next-in-flow into this frame. If it's a continuation placeholder,
4065 * it should not be here so we push it into our overflow placeholders
4066 * list. To avoid creating holes (e.g., the following block doesn't
4067 * have a placeholder but the block after it does) we also need to
4068 * pull all the following placeholders and put them in our overflow
4069 * placeholders list too.
4070 *
4071 * If it's a first-in-flow placeholder, or it contains one, then we
4072 * need to do this to the continuation placeholders.
4073 *
4074 * We return PR_TRUE if we removed the frame and it cannot be used.
4075 * If we return PR_FALSE then the frame *must* be pulled immediately.
4076 */
4077 PRBool
4080 {
4082 // Descend into children that are not float containing blocks.
4083 // We should encounter only first-in-flow placeholders, so the
4084 // frame subtree rooted at aFrame should not change.
4087 #ifdef DEBUG
4088 PRBool changed =
4089 #endif
4092 }
4093 }
4095 }
4100 // First in flow frame. We only want to deal with its
4101 // next in flows, if there are any.
4106 }
4109 // Remove aFrame and all its next in flows from their parents, but
4110 // don't destroy the frames.
4111 #ifdef DEBUG
4112 nsresult rv =
4113 #endif
4125 // continuation placeholders are always direct children of a block
4130 #ifdef DEBUG
4131 PRBool found =
4132 #endif
4135 }
4139 // outOfFlow isn't inserted anywhere yet. Eventually the overflow
4140 // placeholders get put into the overflow lines, and at the same time we
4141 // insert the placeholders' out of flows into the overflow out-of-flows
4142 // list.
4146 }
4149 }
4151 /**
4152 * Call this when a line will be pulled from the block's
4153 * next-in-flow's line.
4154 *
4155 * @return PR_TRUE we consumed the entire line, delete it and try again
4156 */
4157 PRBool
4160 {
4161 // First, see if it's a line of continuation placeholders. If it
4162 // is, remove one and retry.
4164 PRBool taken =
4168 }
4170 // OK, it's a normal line. Scan it for floats with continuations that
4171 // need to be taken care of. We won't need to change the line.
4174 #ifdef DEBUG
4175 PRBool taken =
4176 #endif
4179 }
4182 }
4184 // The overflowLines property is stored as a pointer to a line list,
4185 // which must be deleted. However, the following functions all maintain
4186 // the invariant that the property is never set if the list is empty.
4188 PRBool
4190 {
4191 #ifdef DEBUG
4193 #endif
4197 // First grab the prev-in-flows overflow lines
4204 // Make all the frames on the overflow line list mine
4209 // Get the next frame
4211 }
4213 // make the overflow out-of-flow frames mine too
4218 }
4221 }
4222 }
4224 // The lines on the overflow list have already been marked dirty and their
4225 // previous margins marked dirty also.
4226 }
4228 // Don't need to reparent frames in our own overflow lines/oofs, because they're
4229 // already ours. But we should put overflow floats back in mFloats.
4234 // The overflow floats go after our regular floats
4237 }
4238 }
4241 // nothing to do; always the case for non-constrained-height reflows
4243 }
4248 // HANDLING CONTINUATION PLACEHOLDERS (floats only at the moment, because
4249 // abs-pos frames don't have continuations)
4250 //
4251 // All continuation placeholders need to be moved to the front of
4252 // our line list. We also need to maintain the invariant that at
4253 // most one frame for a given piece of content is in our normal
4254 // child list, by pushing all but the first placeholder to our
4255 // overflow placeholders list.
4256 //
4257 // One problem we have to deal with is that some of these
4258 // continuation placeholders may have been donated to us by a
4259 // descendant block that was complete. We need to push them down to
4260 // a lower block if possible.
4261 //
4262 // We keep the lists ordered so that prev in flows come before their
4263 // next in flows. We do not worry about properly ordering the
4264 // placeholders for different content relative to each other until
4265 // the end. Then we sort them.
4266 //
4267 // When we're shuffling placeholders we also need to shuffle their out of
4268 // flows to match. As we put placeholders into keepPlaceholders, we unhook
4269 // their floats from mFloats. Later we put the floats back based on the
4270 // order of the placeholders.
4272 nsFrameList keepPlaceholders;
4273 nsFrameList keepOutOfFlows;
4289 }
4292 }
4304 }
4309 // Take this out of mFloats for now. We may put it back later in
4310 // this function
4311 #ifdef DEBUG
4312 PRBool found =
4313 #endif
4319 // oops. we already have a prev-in-flow for this
4320 // placeholder. We have to move this frame out of here. We
4321 // can put it in our overflow placeholders.
4323 // Let oof dangle for now, because placeholders in
4324 // mOverflowPlaceholders do not keep their floats in any child list
4333 // Ok, now we're in the tough situation where some child
4334 // of prevBlock was complete and pushed its overflow
4335 // placeholders up to prevBlock's overflow. We might be
4336 // able to find a more appropriate parent for f somewhere
4337 // down in our descendants.
4340 // Find the first ancestor of f's prev-in-flow that has a next in flow
4341 // that can contain the float.
4342 // That next in flow should become f's parent.
4347 ;
4349 // We're still the best parent.
4355 // Just put it at the front of
4356 // fpAncestor->GetNextInFlow()'s lines.
4365 }
4371 }
4372 }
4373 }
4374 }
4375 }
4377 }
4378 }
4381 }
4382 }
4383 }
4385 // Now join the line lists into mLines
4388 // Join the line lists
4390 {
4391 // Remember to recompute the margins on the first line. This will
4392 // also recompute the correct deltaY if necessary.
4394 // Join the sibling lists together
4397 }
4398 // Place overflow lines at the front of our line list
4401 }
4403 }
4409 }
4410 // append the overflow to mLines
4412 }
4414 }
4416 // store the placeholders that we're keeping in our frame list
4424 }
4426 }
4428 // Put the placeholders' out of flows into the float list
4431 }
4434 }
4436 nsLineList*
4438 {
4441 }
4447 }
4449 nsLineList*
4451 {
4454 }
4461 }
4463 // Destructor function for the overflowLines frame property
4464 static void
4469 {
4475 }
4476 }
4478 // This takes ownership of aOverflowLines.
4479 // XXX We should allocate overflowLines from presShell arena!
4480 nsresult
4482 {
4492 // Verify that we didn't overwrite an existing overflow list
4496 }
4498 nsFrameList
4500 {
4503 }
4508 }
4510 // This takes ownership of the frames
4511 void
4513 {
4517 }
4526 }
4527 }
4529 nsFrameList*
4531 {
4534 }
4539 }
4541 //////////////////////////////////////////////////////////////////////
4542 // Frame list manipulation routines
4544 nsIFrame*
4546 {
4549 }
4551 }
4553 NS_IMETHODIMP
4556 {
4559 }
4563 }
4567 }
4571 }
4572 }
4574 // Find the proper last-child for where the append should go
4579 }
4581 // Add frames after the last child
4582 #ifdef NOISY_REFLOW_REASON
4589 }
4591 #endif
4597 }
4599 }
4601 NS_IMETHODIMP
4605 {
4612 aFrameList);
4613 }
4617 }
4618 #ifdef IBMBIDI
4624 }
4625 }
4627 #ifdef NOISY_REFLOW_REASON
4634 }
4636 #endif
4638 #ifdef IBMBIDI
4645 }
4647 }
4649 static PRBool
4651 {
4661 }
4663 nsresult
4666 {
4667 // Clear our line cursor, since our lines may change.
4672 }
4674 // If we're inserting at the beginning of our list and we have an
4675 // inside bullet, insert after that bullet.
4680 }
4684 // Attempt to find the line that contains the previous sibling
4688 // XXX_perf This is technically O(N^2) in some cases, but by using
4689 // RFind instead of Find, we make it O(N) in the most common case,
4690 // which is appending content.
4692 // Find the line that contains the previous sibling
4696 // Note: defensive code! RFindLineContaining must not return
4697 // false in this case, so if it does...
4701 }
4702 }
4704 // Find the frame following aPrevSibling so that we can join up the
4705 // two lists of frames.
4710 // Split line containing aPrevSibling in two if the insertion
4711 // point is somewhere in the middle of the line.
4714 // Split the line in two where the frame(s) are being inserted.
4718 }
4722 }
4724 // Now (partially) join the sibling lists together
4726 }
4729 }
4731 // Walk through the new frames being added and update the line data
4732 // structures to fit.
4737 // If the frame is a block frame, or if there is no previous line or if the
4738 // previous line is a block line we need to make a new line. We also make
4739 // a new line, as an optimization, in the three cases we know we'll need it:
4740 // if the previous line ended with a <br>, if it has significant whitespace and
4741 // ended in a newline, or if it contains continuation placeholders.
4744 // Create a new line for the frame and add its line to the line
4745 // list.
4749 }
4751 // Append new line after prevSibLine
4754 }
4756 // New line is going before the other lines
4759 }
4760 }
4764 }
4768 }
4770 // Connect the last new frame to the remainder of the sibling list
4772 }
4774 #ifdef DEBUG
4776 #endif
4778 }
4782 // Find which line contains the float, so we can update
4783 // the float cache.
4788 }
4789 }
4791 // Unlink the placeholder *after* we searched the lines, because
4792 // the line search uses the placeholder relationship.
4798 }
4800 // Try to destroy if it's in mFloats.
4803 }
4805 // Try our overflow list
4806 {
4810 }
4811 }
4813 // If this is during reflow, it could be the out-of-flow frame for a
4814 // placeholder in our block reflow state's mOverflowPlaceholders. But that's
4815 // OK; it's not part of any child list, so we can just go ahead and delete it.
4818 }
4821 {
4830 }
4831 }
4834 }
4835 }
4838 {
4845 }
4847 }
4849 // Mark every line at and below the line where the float was
4850 // dirty, and mark their lines dirty too. We could probably do
4851 // something more efficient --- e.g., just dirty the lines that intersect
4852 // the float vertically.
4854 }
4856 /**
4857 * Returns PR_TRUE if aFrame is a block that has one or more float children.
4858 */
4860 {
4874 }
4876 }
4878 NS_IMETHODIMP
4881 {
4884 #ifdef NOISY_REFLOW_REASON
4889 #endif
4896 }
4897 }
4900 }
4904 }
4905 #ifdef IBMBIDI
4907 // Skip the call to |FrameNeedsReflow| below by returning now.
4909 }
4914 }
4920 }
4922 }
4924 void
4926 {
4927 // First remove aFrame's next in flow
4931 }
4932 // Now remove aFrame
4935 // The containing block is always the parent of aFrame.
4937 // Remove aFrame from the appropriate list.
4941 aFrame);
4943 }
4945 // This also destroys the frame.
4947 }
4948 }
4950 /**
4951 * This helps us iterate over the list of all normal + overflow lines
4952 */
4953 void
4960 // Try the overflow lines
4965 }
4966 }
4967 }
4968 }
4971 {
4980 }
4982 // This function removes aDeletedFrame and all its continuations. It
4983 // is optimized for deleting a whole series of frames. The easy
4984 // implementation would invoke itself recursively on
4985 // aDeletedFrame->GetNextContinuation, then locate the line containing
4986 // aDeletedFrame and remove aDeletedFrame from that line. But here we
4987 // start by locating aDeletedFrame and then scanning from that point
4988 // on looking for continuations.
4989 nsresult
4991 PRBool aRemoveOnlyFluidContinuations)
4992 {
4993 // Clear our line cursor, since our lines may change.
5000 }
5014 }
5016 }
5017 }
5019 // Find the line and the previous sibling that contains
5020 // deletedFrame; we also find the pointer to the line.
5025 // Make sure we look in the overflow lines even if the normal line
5026 // list is empty
5034 }
5037 }
5040 }
5041 found_frame:;
5045 }
5048 // We must have found the first frame in the overflow line list. So
5049 // there is no prevSibling
5051 }
5052 NS_ASSERTION(!prevSibling || prevSibling->GetNextSibling() == aDeletedFrame, "bad prevSibling");
5058 // If the frame being deleted is the last one on the line then
5059 // optimize away the line->Contains(next-in-flow) call below.
5063 // Remove aDeletedFrame from the line
5066 // We should be setting this to null if aDeletedFrame
5067 // is the only frame on the line. HOWEVER in that case
5068 // we will be removing the line anyway, see below.
5070 }
5072 // Hmm, this won't do anything if we're removing a frame in the first
5073 // overflow line... Hopefully doesn't matter
5076 // Since we just removed a frame that follows some inline
5077 // frames, we need to reflow the previous line.
5079 }
5082 // Take aDeletedFrame out of the sibling list. Note that
5083 // prevSibling will only be nsnull when we are deleting the very
5084 // first frame in the main or overflow list.
5087 }
5089 // Update the child count of the line to be accurate
5091 lineChildCount--;
5094 // Destroy frame; capture its next continuation first in case we need
5095 // to destroy that too.
5098 #ifdef NOISY_REMOVE_FRAME
5103 #endif
5109 }
5113 // If line is empty, remove it now.
5115 #ifdef NOISY_REMOVE_FRAME
5118 #endif
5122 // Invalidate the space taken up by the line.
5123 // XXX We need to do this if we're removing a frame as a result of
5124 // a call to RemoveFrame(), but we may not need to do this in all
5125 // cases...
5127 #ifdef NOISY_BLOCK_INVALIDATE
5131 #endif
5138 }
5139 }
5142 // If we're removing a line, ReflowDirtyLines isn't going to
5143 // know that it needs to slide lines unless something is marked
5144 // dirty. So mark the previous margin of the next line dirty if
5145 // there is one.
5148 }
5151 // Make the line that just lost a frame dirty, and advance to
5152 // the next line.
5158 }
5159 }
5162 // Continuations for placeholder frames don't always appear in
5163 // consecutive lines. So for placeholders, just continue the slow easy way.
5166 }
5168 // See if we should keep looking in the current flow's line list.
5170 // The deceased frames continuation is not a child of the
5171 // current block. So break out of the loop so that we advance
5172 // to the next parent.
5174 }
5176 // If we advanced to the next line then check if we should switch to the
5177 // overflow line list.
5181 // We have advanced to the next *normal* line but the next-in-flow
5182 // is not there - force a switch to the overflow line list.
5184 }
5189 prevSibling)) {
5190 // We switched to the overflow line list and we have a prev sibling
5191 // (in the main list), in this case we don't want to pick up any
5192 // sibling list from the deceased frames (bug 344557).
5195 }
5196 #ifdef NOISY_REMOVE_FRAME
5199 prevSibling);
5200 #endif
5201 }
5202 }
5203 }
5205 #ifdef DEBUG
5207 #endif
5209 // Advance to next flow block if the frame has more continuations
5211 }
5213 void
5216 {
5222 }
5224 ////////////////////////////////////////////////////////////////////////
5225 // Float support
5227 nsresult
5232 {
5233 // Reflow the float.
5237 #ifdef NOISY_FLOAT
5242 );
5243 #endif
5245 // Compute the available width. By default, assume the width of the
5246 // containing block.
5247 nscoord availWidth;
5253 }
5255 // This quirk matches the one in nsBlockReflowState::FlowAndPlaceFloat
5256 // give tables only the available space
5257 // if they can shrink we may not be constrained to place
5258 // them in the next line
5260 // round down to twips per pixel so that we fit
5261 // needed when prev. float has procentage width
5262 // (maybe is a table flaw that makes table chose to round up
5263 // but I don't want to change that, too risky)
5266 }
5268 // aState.mY is relative to the border-top, make it relative to the content-top
5271 ? NS_UNCONSTRAINEDSIZE
5278 // construct the html reflow state for the float. ReflowBlock will
5279 // initialize it.
5281 floatFrame,
5284 // Setup a block reflow state to reflow the float.
5287 // Reflow the float
5291 nsresult rv;
5293 nsCollapsingMargin margin;
5296 // Only first in flow gets a top margin.
5303 // We don't need to push the space manager state because the the block has its own
5304 // space manager that will be destroyed and recreated
5305 }
5306 }
5309 // on a frame property anyawy
5313 aReflowStatus);
5316 // An incomplete reflow status means we should split the float
5317 // if the height is constrained (bug 145305).
5322 // Float is now complete, so delete the placeholder's next in
5323 // flows, if any; their floats (which are this float's continuations)
5324 // have already been deleted.
5325 // XXX won't this be done later in nsLineLayout::ReflowFrame anyway??
5330 // that takes care of all subsequent nextinflows too
5331 }
5332 }
5335 }
5338 // We never split floating first letters; an incomplete state for
5339 // such frames simply means that there is more content to be
5340 // reflowed on the line.
5343 }
5347 }
5349 // Capture the margin information for the caller
5353 // Only last in flows get a bottom margin
5356 }
5362 // Set the rect, make sure the view is properly sized and positioned,
5363 // and tell the frame we're done reflowing it
5364 // XXXldb This seems like the wrong place to be doing this -- shouldn't
5365 // we be doing this in nsBlockReflowState::FlowAndPlaceFloat after
5366 // we've positioned the float, and shouldn't we be doing the equivalent
5367 // of |::PlaceFrameView| here?
5373 NS_FRAME_NO_MOVE_VIEW);
5374 }
5375 // Pass floatRS so the frame hierarchy can be used (redoFloatRS has the same hierarchy)
5377 NS_FRAME_REFLOW_FINISHED);
5379 #ifdef NOISY_FLOAT
5382 #endif
5384 // If the placeholder was continued and its first-in-flow was followed by a
5385 // <BR>, then cache the <BR>'s break type in aState.mFloatBreakType so that
5386 // the next frame after the placeholder can combine that break type with its own
5389 // the break occurs only after the last continued placeholder
5395 }
5396 }
5398 // get the containing block of prevPlaceholder which is our prev-in-flow
5400 // get the break type of the last line in mPrevInFlow
5404 }
5405 }
5407 }
5408 }
5410 }
5412 //////////////////////////////////////////////////////////////////////
5413 // Painting, event handling
5415 PRIntn
5417 {
5421 }
5424 }
5426 }
5428 #ifdef DEBUG
5432 {
5437 // Compute min and max x/y values for the reflowed frame's
5438 // combined areas
5446 }
5449 }
5452 }
5455 }
5456 }
5462 }
5463 #endif
5465 PRBool
5467 {
5474 PRBool visible;
5477 }
5481 nsPoint aPt,
5483 nscolor aColor,
5484 nscoord aOffset,
5485 nscoord aAscent,
5486 nscoord aSize)
5487 {
5495 // Adjust for the text-indent. See similar code in
5496 // nsLineLayout::BeginLineReflow.
5503 // It's a percentage of the containing block width.
5509 }
5511 // Adjust the start position and the width of the decoration by the
5512 // value of the indent. Note that indent can be negative; that's OK.
5513 // It'll just increase the width (which can also happen to be
5514 // negative!).
5517 }
5519 // Only paint if we have a positive width
5524 }
5525 }
5527 #ifdef DEBUG
5539 }
5540 }
5541 #endif
5543 static nsresult
5548 // If the line's combined area (which includes child frames that
5549 // stick outside of the line's bounding box or our bounding box)
5550 // intersects the dirty rect then paint the line.
5552 #ifdef DEBUG
5554 aDrawnLines++;
5555 }
5557 #endif
5558 // The line might contain a placeholder for a visible out-of-flow, in which
5559 // case we need to descend into it. If there is such a placeholder, we will
5560 // have NS_FRAME_FORCE_DISPLAY_LIST_DESCEND_INTO set.
5565 nsresult rv;
5566 nsDisplayList aboveTextDecorations;
5569 // Display the text-decoration for the hypothetical anonymous inline box
5570 // that wraps these inlines
5574 }
5576 // Block-level child backgrounds go on the blockBorderBackgrounds list ...
5577 // Inline-level child backgrounds go on the regular child content list.
5587 }
5591 }
5593 NS_IMETHODIMP
5597 {
5600 #ifdef DEBUG
5603 nsRect ca;
5611 }
5616 }
5617 #endif
5624 // Don't use the line cursor if we might have a descendant placeholder ...
5625 // it might skip lines that contain placeholders but don't themselves
5626 // intersect with the dirty area.
5638 // Because we have a cursor, the combinedArea.ys are non-decreasing.
5639 // Once we've passed aDirtyRect.YMost(), we can never see it again.
5642 }
5647 }
5648 }
5666 }
5669 }
5670 lineCount++;
5671 }
5675 }
5676 }
5679 // Display outside bullets manually
5681 }
5683 #ifdef DEBUG
5701 }
5702 #endif
5705 }
5707 #ifdef ACCESSIBILITY
5709 {
5715 // block frame may be for <hr>
5718 }
5723 // Don't create accessible objects for the root content node, they are redundant with
5724 // the nsDocAccessible object created with the document node
5726 }
5734 // Don't create accessible objects for the body, they are redundant with
5735 // the nsDocAccessible object created with the document node
5737 }
5738 }
5740 // Not a bullet, treat as normal HTML container
5742 }
5744 // Create special list bullet accessible
5746 nsAutoString bulletText;
5751 }
5754 }
5758 bulletText,
5759 aAccessible);
5760 }
5761 #endif
5766 }
5770 }
5776 }
5781 }
5786 }
5797 }
5802 }
5807 }
5810 }
5814 {
5815 // See if the child is absolutely positioned
5818 // do nothing
5820 // The bullet lives in the first line, unless the first line has
5821 // height 0 and there is a second line, in which case it lives
5822 // in the second line.
5827 }
5831 }
5832 // otherwise we have an empty line list, and ReflowDirtyLines
5833 // will handle reflowing the bullet.
5835 // Mark the line containing the child frame dirty.
5839 }
5842 }
5844 //////////////////////////////////////////////////////////////////////
5845 // Start Debugging
5847 #ifdef NS_DEBUG
5848 static PRBool
5850 {
5859 }
5861 }
5862 }
5864 }
5866 static PRBool
5868 {
5874 }
5876 }
5877 }
5879 }
5881 PRBool
5883 {
5884 // Continued out-of-flows don't satisfy InLineList(), continued out-of-flows
5885 // and placeholders don't satisfy InSiblingList().
5894 }
5900 }
5901 }
5905 }
5909 }
5914 }
5916 }
5918 NS_IMETHODIMP
5920 {
5921 // XXX rewrite this
5923 }
5924 #endif
5926 // End Debugging
5927 //////////////////////////////////////////////////////////////////////
5929 NS_IMETHODIMP
5933 {
5935 // Copy over the block/area frame type flags
5940 }
5945 }
5947 NS_IMETHODIMP
5950 {
5955 }
5958 }
5962 #ifdef DEBUG
5963 // The only times a block that is an anonymous box is allowed to have a
5964 // first-letter frame are when it's the block inside a non-anonymous cell,
5965 // the block inside a fieldset, a scrolled content block, or a column
5966 // content block. Note that this means that blocks which are the anonymous
5967 // block in {ib} splits do NOT get first-letter frames. Also, a block that
5968 // has a previous continuation can't have a first letter frame.
5970 PRBool haveFirstLetterStyle =
5982 #endif
5987 }
5989 // Create list bullet if this is a list-item. Note that this is done
5990 // here so that RenumberLists will work (it needs the bullets to
5991 // store the bullet numbers).
5996 // Resolve style for the bullet frame
6008 }
6015 // Create bullet frame
6019 }
6022 // If the list bullet frame should be positioned inside then add
6023 // it to the flow now.
6028 }
6031 }
6034 }
6035 }
6038 }
6040 // static
6041 PRBool
6043 {
6053 }
6055 PRBool
6057 {
6059 // If this frame doesn't start a counter scope then we don't need
6060 // to renumber child list items.
6062 }
6064 // Setup initial list ordinal value
6065 // XXX Map html's start property to counter-reset style
6074 }
6075 }
6077 // Get to first-in-flow
6080 }
6082 PRBool
6086 PRInt32 aDepth)
6087 {
6091 // Examine each line in the block
6103 }
6105 }
6106 }
6108 // Advance to the next continuation
6110 }
6113 }
6115 PRBool
6119 PRInt32 aDepth)
6120 {
6123 // add in a sanity check for absurdly deep frame trees. See bug 42138
6129 // if the frame is a placeholder, then get the out of flow frame
6132 // drill down through any wrappers to the real frame
6135 // If the frame is a list-item and the frame implements our
6136 // block frame API then get its bullet and set the list item
6137 // ordinal.
6140 // Make certain that the frame is a block frame in case
6141 // something foreign has crept in.
6146 PRBool changed;
6152 // Invalidate the bullet content area since it may look different now
6155 }
6156 }
6158 // XXX temporary? if the list-item has child list-items they
6159 // should be numbered too; especially since the list-item is
6160 // itself (ASSUMED!) not to be a counter-resetter.
6164 }
6165 }
6166 }
6169 // Don't bother recursing into a block frame that is a new
6170 // counter scope. Any list-items in there will be handled by
6171 // it.
6172 }
6174 // If the display=block element is a block frame then go ahead
6175 // and recurse into it, as it might have child list-items.
6180 }
6181 }
6182 }
6184 }
6186 void
6189 {
6192 // Reflow the bullet now
6193 nsSize availSize;
6194 // Make up a width since it doesn't really matter (XXX).
6198 // Get the reason right.
6199 // XXXwaterson Should this look just like the logic in
6200 // nsBlockReflowContext::ReflowBlock and nsLineLayout::ReflowFrame?
6203 nsReflowStatus status;
6207 // Place the bullet now; use its right margin to distance it
6208 // from the rest of the frames in the line
6209 nscoord x =
6210 #ifdef IBMBIDI
6212 // According to the CSS2 spec, section 12.6.1, outside marker box
6213 // is distanced from the associated principal box's border edge.
6214 // |rs.availableWidth| reflects exactly a border edge: it includes
6215 // border, padding, and content area, without margins.
6218 #endif
6221 // Approximate the bullets position; vertical alignment will provide
6222 // the final vertical location.
6227 }
6229 // This is used to scan frames for any float placeholders, add their
6230 // floats to the list represented by aHead and aTail, and remove the
6231 // floats from whatever list they might be in. We don't search descendants
6232 // that are float containing blocks. The floats must be children of 'this'.
6236 // Don't descend into float containing blocks.
6240 // Make sure that its parent is us. Otherwise we don't want
6241 // to mess around with it because it belongs to someone
6242 // else. I think this could happen if the overflow lines
6243 // contain a block descendant which owns its own floats.
6251 }
6254 }
6257 PR_TRUE);
6258 }
6262 }
6263 }
6265 void
6267 {
6268 #ifdef DEBUG
6269 // Check that the float list is what we would have built
6270 nsAutoVoidArray lineFloats;
6279 }
6280 }
6281 }
6283 nsAutoVoidArray storedFloats;
6290 }
6292 }
6296 #if defined(DEBUG_roc)
6300 }
6303 }
6304 #endif
6305 }
6306 #endif
6310 // Floats that were pushed should be removed from our space
6311 // manager. Otherwise the space manager's YMost or XMost might
6312 // be larger than necessary, causing this block to get an
6313 // incorrect desired height (or width). Some of these floats
6314 // may not actually have been added to the space manager because
6315 // they weren't reflowed before being pushed; that's OK,
6316 // RemoveRegions will ignore them. It is safe to do this here
6317 // because we know from here on the space manager will only be
6318 // used for its XMost and YMost, not to place new floats and
6319 // lines.
6321 }
6322 }
6324 /* static */
6325 PRBool
6327 {
6329 #ifdef DEBUG
6333 #endif
6339 }
6341 /* static */
6342 PRBool
6344 {
6346 #ifdef DEBUG
6350 #endif
6355 }
6357 // XXX keep the text-run data in the first-in-flow of the block
6359 #ifdef IBMBIDI
6360 nsresult
6362 {
6366 }
6370 }
6379 }
6381 PRBool
6383 {
6384 // This check is only necessary on visual bidi pages, because most
6385 // visual pages use logical order for form controls so that they will
6386 // display correctly on native widgets in OSs with Bidi support.
6387 // So bail out if the page is not visual, or if the pref is
6388 // set to use visual order on forms in visual pages
6391 }
6396 }
6402 }
6403 }
6406 }
6407 #endif
6409 #ifdef DEBUG
6410 void
6412 {
6415 }
6418 }
6420 // Add up the counts on each line. Also validate that IsFirstLine is
6421 // set properly.
6432 }
6435 }
6436 }
6438 }
6440 // Then count the frames
6444 frameCount++;
6446 }
6449 // Next: test that each line has right number of frames on it
6452 ) {
6457 }
6461 }
6462 }
6463 }
6465 // Its possible that a frame can have some frames on an overflow
6466 // list. But its never possible for multiple frames to have overflow
6467 // lists. Check that this fact is actually true.
6468 void
6470 {
6477 }
6479 }
6480 }
6482 PRInt32
6484 {
6489 depth++;
6490 }
6492 }
6493 #endif