| blob | ab6924faa4d35b35dd904215dab5279b7f24de0f |
1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
2 /* vim: set ts=8 sts=2 et sw=2 tw=80: */
3 /* This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
7 /* state and methods used while laying out a single line of a block frame */
30 #include <algorithm>
32 #ifdef DEBUG
33 # undef NOISY_INLINEDIR_ALIGN
34 # undef NOISY_BLOCKDIR_ALIGN
35 # undef NOISY_REFLOW
36 # undef REALLY_NOISY_REFLOW
37 # undef NOISY_PUSHING
38 # undef REALLY_NOISY_PUSHING
39 # undef NOISY_CAN_PLACE_FRAME
40 # undef NOISY_TRIM
41 # undef REALLY_NOISY_TRIM
42 #endif
46 //----------------------------------------------------------------------
83 #ifdef DEBUG
84 ,
89 #endif
90 {
98 // Stash away some style data that we need
108 mInflationMinFontSize =
111 // Instead of always pre-initializing the free-lists for frames and
112 // spans, we do it on demand so that situations that only use a few
113 // frames and spans won't waste a lot of time in unneeded
114 // initialization.
124 }
125 }
131 }
133 // Find out if the frame has a non-null prev-in-flow, i.e., whether it
134 // is a continuation.
138 }
143 WritingMode aWritingMode,
145 nscoord aInset) {
148 "have unconstrained width; this should only result from "
149 "very large sizes, not attempts at intrinsic width "
151 #ifdef DEBUG
156 }
161 }
162 #endif
163 #ifdef NOISY_REFLOW
168 #endif
169 #ifdef DEBUG
171 #endif
183 }
190 }
198 // Set up inset to be used for text-wrap:balance implementation, but only if
199 // the available size is greater than inset.
208 // Determine if this is the first line of the block (or first after a hard
209 // line-break, if `each-line` is in effect).
216 }
222 }
224 }();
226 // Resolve and apply the text-indent value if this line requires it.
227 // The `hanging` option inverts which lines are to be indented.
232 }
233 }
240 // Ruby text container won't be reflowed via ReflowFrame, hence the
241 // relative positioning information should be recorded here.
247 "mLineContainerRI.frame == frame, "
251 }
252 }
253 }
256 #ifdef NOISY_REFLOW
260 #endif
274 #if 0
280 }
284 }
285 #endif
288 }
290 // XXX swtich to a single mAvailLineWidth that we adjust as each frame
291 // on the line is placed. Each span can still have a per-span mICoord that
292 // tracks where a child frame is going in its span; they don't need a
293 // per-span mIStart?
299 // need to convert to our writing mode, because we might have a different
300 // mode from the caller due to dir: auto
301 LogicalRect availSpace =
303 #ifdef REALLY_NOISY_REFLOW
305 "nsLL::UpdateBand %d, %d, %d, %d, (converted to %d, %d, %d, %d); "
311 #endif
312 #ifdef DEBUG
319 }
326 }
327 #endif
329 // Compute the difference between last times width and the new width
333 "have unconstrained inline size; this should only result from very large "
335 // The root span's mIStart moves to aICoord
337 // The inline size of all spans changes by this much (the root span's
338 // mIEnd moves to aICoord + aISize, its new inline size is aISize)
339 nscoord deltaISize =
341 #ifdef NOISY_REFLOW
346 deltaICoord);
347 #endif
349 // Update the root span position
354 // Now update the right edges of the open spans to account for any
355 // change in available space width
359 #ifdef NOISY_REFLOW
362 #endif
363 }
369 // Update frame bounds
370 // Note: Only adjust the outermost frames (the ones that are direct
371 // children of the block), not the ones in the child spans. The reason
372 // is simple: the frames in the spans have coordinates local to their
373 // parent therefore they are moved when their parent span is moved.
377 }
378 }
384 }
394 }
402 #ifdef DEBUG
404 #endif
406 }
414 #ifdef NOISY_REFLOW
418 #endif
421 // Link up span frame's pfd to point to its child span data
426 // Init new span
441 // Switch to new span
443 mSpanDepth++;
444 }
448 #ifdef NOISY_REFLOW
452 #endif
458 }
462 mSpanDepth--;
466 }
476 #ifdef DEBUG
483 #endif
488 }
495 count++;
497 }
499 }
504 #ifdef REALLY_NOISY_PUSHING
508 #endif
513 // Truncate list at pfd (we keep pfd, but anything following is freed)
518 // Now unlink all of the frames following pfd
521 }
523 }
524 #ifdef NOISY_PUSHING
528 #endif
529 }
535 #ifdef REALLY_NOISY_PUSHING
539 #endif
541 // Take the last frame off of the span's frame list
544 // We are pushing away the only frame...empty the list
551 }
553 // Now unlink the frame
556 #ifdef NOISY_PUSHING
560 #endif
561 }
567 // This frame is linked to a ruby base, and should not be freed
568 // now. Just unlink it from the span. It will be freed when its
569 // base frame gets unlinked.
573 }
575 // It is a ruby base frame. If there are any annotations
576 // linked to this frame, free them first.
585 }
589 }
590 }
595 }
599 #ifdef DEBUG
601 #endif
602 }
605 // Unlink its frames
609 // Now put the span on the free list since it's free too
612 #ifdef DEBUG
614 #endif
615 }
623 }
625 }
627 }
637 }
644 // all flags default to false
668 #ifdef DEBUG
671 #endif
673 }
676 // XXX mTotalPlacedFrames should go away and we should just use
677 // mLineIsEmpty here instead
680 }
682 }
684 // Checks all four sides for percentage units. This means it should
685 // only be used for things (margin, padding) where percentages on top
686 // and bottom depend on the *width* just like percentages on left and
687 // right.
691 }
698 // None of these things can ever be true for text frames.
700 }
702 // Some of these things don't apply to non-replaced inline frames
703 // (that is, fType == LayoutFrameType::Inline), but we won't bother making
704 // things unnecessarily complicated, since they'll probably be set
705 // quite rarely.
710 }
715 }
717 // Note that borders can't be aware of percentages
727 }
730 // We need to check for frames that shrink-wrap when they're auto
731 // width.
740 }
742 // Per CSS 2.1, section 10.3.2:
743 // If 'height' and 'width' both have computed values of 'auto' and
744 // the element has an intrinsic ratio but no intrinsic height or
745 // width and the containing block's width does not itself depend
746 // on the replaced element's width, then the used value of 'width'
747 // is calculated from the constraint equation used for
748 // block-level, non-replaced elements in normal flow.
751 // Some percents are treated like 'auto', so check != coord
756 }
757 }
758 }
761 }
765 // Initialize OUT parameter
772 #ifdef REALLY_NOISY_REFLOW
777 #endif
782 #ifdef DEBUG
787 #endif
788 }
792 // Stash copies of some of the computed state away for later
793 // (block-direction alignment, for example)
797 // NOTE: While the inline direction coordinate remains relative to the
798 // parent span, the block direction coordinate is fixed at the top
799 // edge for the line. During VerticalAlignFrames we will repair this
800 // so that the block direction coordinate is properly set and relative
801 // to the appropriate span.
805 // We want to guarantee that we always make progress when
806 // formatting. Therefore, if the object being placed on the line is
807 // too big for the line, but it is the only thing on the line and is not
808 // impacted by a float, then we go ahead and place it anyway. (If the line
809 // is impacted by one or more floats, then it is safe to break because
810 // we can move the line down below float(s).)
811 //
812 // Capture this state *before* we reflow the frame in case it clears
813 // the state out. We need to know how to treat the current frame
814 // when breaking.
817 // Figure out whether we're talking about a textframe here
821 // Inline-ish and text-ish things don't compute their width;
822 // everything else does. We need to give them an available width that
823 // reflects the space left on the line.
825 "have unconstrained width; this should only result from "
826 "very large sizes, not attempts at intrinsic width "
830 // Setup reflow input for reflowing the frame
833 // Compute the available size for the frame. This available width
834 // includes room for the side margins.
835 // For now, set the available block-size to unconstrained always.
839 availSize);
845 }
852 }
854 // Calculate whether the the frame should have a start margin and
855 // subtract the margin from the available width if necessary.
856 // The margin will be applied to the starting inline coordinates of
857 // the frame in CanPlaceFrame() after reflowing the frame.
859 }
860 // if isText(), no need to propagate NS_FRAME_IS_DIRTY from the parent,
861 // because reflow doesn't look at the dirty bits on the frame being reflowed.
863 // See if this frame depends on the inline-size of its containing block.
864 // If so, disable resize reflow optimizations for the line. (Note that,
865 // to be conservative, we do this if we *try* to fit a frame on a
866 // line, even if we don't succeed.) (Note also that we can only make
867 // this IsPercentageAware check *after* we've constructed our
868 // ReflowInput, because that construction may be what forces aFrame
869 // to lazily initialize its (possibly-percent-valued) intrinsic size.)
872 }
874 // Note that we don't bother positioning the frame yet, because we're probably
875 // going to end up moving it when we do the block-direction alignment.
877 // Adjust float manager coordinate system for the frame.
879 #ifdef DEBUG
882 #endif
888 gfxBreakPriority savedOptionalBreakPriority;
894 aReflowStatus);
899 aReflowStatus);
900 }
905 // See if the frame is a placeholderFrame and if it is process
906 // the float. At the same time, check if the frame has any non-collapsed-away
907 // content.
919 // We can always place floats in an empty line.
921 // We always place floating letter frames. This kinda sucks. They'd
922 // usually fall into the LineIsEmpty() check anyway, except when
923 // there's something like a ::marker before or what not. We actually
924 // need to place them now, because they're pretty nasty and they
925 // create continuations that are in flow and not a kid of the
926 // previous continuation's parent. We don't want the deferred reflow
927 // of the letter frame to kill a continuation after we've stored it
928 // in the line layout data structures. See bug 1490281 to fix the
929 // underlying issue. When that's fixed this check should be removed.
932 // We'll do this at the next break opportunity.
936 }
937 }
939 // Note non-empty text-frames for inline frame compatibility hackery
947 }
954 }
959 }
960 }
969 }
972 }
974 #ifdef DEBUG
975 // Note: break-before means ignore the reflow metrics since the
976 // frame will be reflowed another time.
984 }
991 }
992 }
993 #endif
995 // Unlike with non-inline reflow, the overflow area here does *not*
996 // include the accumulation of the frame's bounds and its inline
997 // descendants' bounds. Nor does it include the outline area; it's
998 // just the union of the bounds of any absolute children. That is
999 // added in later by nsLineLayout::ReflowInlineFrames.
1005 // Size the frame, but |RelativePositionFrames| will size the view.
1008 // Tell the frame that we're done reflowing it
1013 }
1016 // If frame is complete and has a next-in-flow, we need to delete
1017 // them now. Do not do this when a break-before is signaled because
1018 // the frame is going to get reflowed again (and may end up wanting
1019 // a next-in-flow where it ends up).
1022 // Remove all of the childs next-in-flows. Make sure that we ask
1023 // the right parent to do the removal (it's possible that the
1024 // parent is not this because we are executing pullup code)
1028 }
1029 }
1031 // Check whether this frame breaks up text runs. All frames break up text
1032 // runs (hence return false here) except for text frames and inline
1033 // containers.
1036 // Clear any residual mTrimmableISize if this isn't a text frame
1039 }
1041 // See if we can place the frame. If we can't fit it, then we
1042 // return now.
1046 "How'd we get a floated inline frame? "
1055 // nonempty leaf content has been placed
1057 }
1061 }
1062 }
1064 // Place the frame, updating aBounds with the final size and
1065 // location. Then apply the bottom+right margins (as
1066 // appropriate) to the frame.
1070 // The frame we just finished reflowing is an inline
1071 // container. It needs its child frames aligned in the block direction,
1072 // so do most of it now.
1074 }
1078 // record soft break opportunity after this content that can't be
1079 // part of a text run. This is not a text frame so we know
1080 // that offset INT32_MAX means "after the content".
1083 optionalBreakAfterFits,
1085 // If this returns true then we are being told to actually break
1086 // here.
1088 }
1089 }
1090 }
1094 // Undo any saved break positions that the frame might have told us about,
1095 // since we didn't end up placing it
1097 savedOptionalBreakOffset,
1098 savedOptionalBreakPriority);
1099 }
1103 }
1105 #ifdef REALLY_NOISY_REFLOW
1110 #endif
1111 }
1116 "How'd we get a floated inline frame? "
1121 // Only apply start-margin on the first-in flow for inline frames,
1122 // and make sure to not apply it to any inline other than the first
1123 // in an ib split. Note that the ib sibling (block-in-inline
1124 // sibling) annotations only live on the first continuation, but we
1125 // don't want to apply the start margin for later continuations
1126 // anyway. For box-decoration-break:clone we apply the start-margin
1127 // on all continuations.
1132 // Zero this out so that when we compute the max-element-width of
1133 // the frame we will properly avoid adding in the starting margin.
1138 "have unconstrained inline-size; this should only result from very "
1140 // For inline-ish and text-ish things (which don't compute widths
1141 // in the reflow input), adjust available inline-size to account
1142 // for the start margin. The end margin will be accounted for when
1143 // we finish flowing the frame.
1148 }
1149 }
1156 }
1158 }
1160 /**
1161 * This method syncs bounds of ruby annotations and ruby annotation
1162 * containers from their rect. It is necessary because:
1163 * Containers are not part of the line in their levels, which means
1164 * their bounds are not set properly before.
1165 * Ruby annotations' position may have been changed when reflowing
1166 * their containers.
1167 */
1178 // Inter-character case: don't attempt to sync annotation bounds.
1180 }
1181 // When the annotation container is reflowed, the width of the
1182 // ruby container is unknown so we use a dummy container size;
1183 // in the case of RTL block direction, the final position will be
1184 // fixed up later.
1194 }
1195 }
1196 }
1197 }
1199 /**
1200 * See if the frame can be placed now that we know it's desired size.
1201 * We can always place the frame if the line is empty. Note that we
1202 * know that the reflow-status is not a break-before because if it was
1203 * ReflowFrame above would have returned false, preventing this method
1204 * from being called. The logic in this method assumes that.
1205 *
1206 * Note that there is no check against the Y coordinate because we
1207 * assume that the caller will take care of that.
1208 */
1220 /*
1221 * We want to only apply the end margin if we're the last continuation and
1222 * either not in an {ib} split or the last inline in it. In all other
1223 * cases we want to zero it out. That means zeroing it out if any of these
1224 * conditions hold:
1225 * 1) The frame is not complete (in this case it will get a next-in-flow)
1226 * 2) The frame is complete but has a non-fluid continuation on its
1227 * continuation chain. Note that if it has a fluid continuation, that
1228 * continuation will get destroyed later, so we don't want to drop the
1229 * end-margin in that case.
1230 * 3) The frame is in an {ib} split and is not the last part.
1231 *
1232 * However, none of that applies if this is a letter frame (XXXbz why?)
1233 *
1234 * For box-decoration-break:clone we apply the end margin on all
1235 * continuations (that are not letter frames).
1236 */
1244 }
1246 // Apply the start margin to the frame bounds.
1254 // When wrapping is off, everything fits.
1256 }
1258 #ifdef NOISY_CAN_PLACE_FRAME
1261 }
1266 endMargin);
1267 #endif
1269 // Set outside to true if the result of the reflow leads to the
1270 // frame sticking outside of our available area.
1274 // If it fits, it fits
1275 #ifdef NOISY_CAN_PLACE_FRAME
1277 #endif
1279 }
1282 // When it doesn't fit, check for a few special conditions where we
1283 // allow it to fit anyway.
1285 // Empty frames always fit right where they are
1286 #ifdef NOISY_CAN_PLACE_FRAME
1288 #endif
1290 }
1292 // another special case: always place a BR
1294 #ifdef NOISY_CAN_PLACE_FRAME
1296 #endif
1298 }
1301 // There are no frames on the line that take up width and the line is
1302 // not impacted by floats, so we must allow the current frame to be
1303 // placed on the line
1304 #ifdef NOISY_CAN_PLACE_FRAME
1309 }
1311 #endif
1313 }
1315 // Special check for span frames
1317 // If the span either directly or indirectly contains a float then
1318 // it fits. Why? It's kind of complicated, but here goes:
1319 //
1320 // 1. CanPlaceFrame is used for all frame placements on a line,
1321 // and in a span. This includes recursively placement of frames
1322 // inside of spans, and the span itself. Because the logic always
1323 // checks for room before proceeding (the code above here), the
1324 // only things on a line will be those things that "fit".
1325 //
1326 // 2. Before a float is placed on a line, the line has to be empty
1327 // (otherwise it's a "below current line" float and will be placed
1328 // after the line).
1329 //
1330 // Therefore, if the span directly or indirectly has a float
1331 // then it means that at the time of the placement of the float
1332 // the line was empty. Because of #1, only the frames that fit can
1333 // be added after that point, therefore we can assume that the
1334 // current span being placed has fit.
1335 //
1336 // So how do we get here and have a span that should already fit
1337 // and yet doesn't: Simple: span's that have the no-wrap attribute
1338 // set on them and contain a float and are placed where they
1339 // don't naturally fit.
1341 }
1344 // Let it fit, but we reserve the right to roll back.
1345 // Note that we usually won't get here because a text frame will break
1346 // itself to avoid exceeding the available width.
1347 // We'll only get here for text frames that couldn't break early enough.
1348 #ifdef NOISY_CAN_PLACE_FRAME
1350 #endif
1352 // We will want to try backup.
1355 }
1357 #ifdef NOISY_CAN_PLACE_FRAME
1359 #endif
1362 }
1364 /**
1365 * Place the frame. Update running counters.
1366 */
1370 // If the frame's block direction does not match the line's, we can't use
1371 // its ascent; instead, treat it as a block with baseline at the block-end
1372 // edge (or block-begin in the case of an "inverted" line).
1378 // For inline reflow participants, baseline may get assigned as the frame is
1379 // vertically aligned, which happens after this.
1387 }
1397 }
1400 }();
1401 // We ignore line-layout specific layout quirks by setting
1402 // `BaselineExportContext::Other`.
1403 // Note(dshin): For a lot of frames, the export context does not make a
1404 // difference, and we may be wasting the value cached in
1405 // `BlockStartAscent`.
1408 }
1409 }
1411 // Advance to next inline coordinate
1414 // Count the number of non-placeholder frames on the line...
1418 "placeholders should have 0 width/height (checking "
1419 "placeholders were never counted by the old code in "
1422 mTotalPlacedFrames++;
1423 }
1424 }
1436 }
1443 // Prepend the marker frame to the line.
1453 }
1455 // Note: block-coord value will be updated during block-direction alignment
1458 }
1470 }
1471 #ifdef DEBUG
1480 nsRect rect =
1485 }
1487 }
1488 }
1489 #endif
1493 }
1499 }
1501 }
1504 // Add mTrimmableISize to the available width since if the line ends here, the
1505 // width of the inline content will be reduced by mTrimmableISize.
1506 nscoord availableISize =
1511 }
1515 gfxBreakPriority aPriority) {
1517 "Shouldn't be updating the break position with a break that fits"
1522 }
1524 // Remember the last break position that fits; if there was no break that fit,
1525 // just remember the first break
1531 }
1534 }
1536 #define VALIGN_OTHER 0
1537 #define VALIGN_TOP 1
1538 #define VALIGN_BOTTOM 2
1541 // Partially place the children of the block frame. The baseline for
1542 // this operation is set to zero so that the y coordinates for all
1543 // of the placed children will be relative to there.
1547 // *** Note that comments here still use the anachronistic term
1548 // "line-height" when we really mean "size of the line in the block
1549 // direction", "vertical-align" when we really mean "alignment in
1550 // the block direction", and "top" and "bottom" when we really mean
1551 // "block start" and "block end". This is partly for brevity and
1552 // partly to retain the association with the CSS line-height and
1553 // vertical-align properties.
1554 //
1555 // Compute the line-height. The line-height will be the larger of:
1556 //
1557 // [1] maxBCoord - minBCoord (the distance between the first child's
1558 // block-start edge and the last child's block-end edge)
1559 //
1560 // [2] the maximum logical box block size (since not every frame may have
1561 // participated in #1; for example: "top" and "botttom" aligned frames)
1562 //
1563 // [3] the minimum line height ("line-height" property set on the
1564 // block frame)
1567 // Now that the line-height is computed, we need to know where the
1568 // baseline is in the line. Position baseline so that mMinBCoord is just
1569 // inside the start of the line box.
1570 nscoord baselineBCoord;
1575 }
1577 // It's also possible that the line block-size isn't tall enough because
1578 // of "top" and "bottom" aligned elements that were not accounted for in
1579 // min/max BCoord.
1580 //
1581 // The CSS2 spec doesn't really say what happens when to the
1582 // baseline in this situations. What we do is if the largest start
1583 // aligned box block size is greater than the line block-size then we leave
1584 // the baseline alone. If the largest end aligned box is greater
1585 // than the line block-size then we slide the baseline forward by the extra
1586 // amount.
1587 //
1588 // Navigator 4 gives precedence to the first top/bottom aligned
1589 // object. We just let block end aligned objects win.
1591 // When the line is shorter than the maximum block start aligned box
1595 }
1598 }
1599 #ifdef NOISY_BLOCKDIR_ALIGN
1601 baselineBCoord);
1602 #endif
1604 // Now position all of the frames in the root span. We will also
1605 // recurse over the child spans and place any frames we find with
1606 // vertical-align: top or bottom.
1607 // XXX PERFORMANCE: set a bit per-span to avoid the extra work
1608 // (propagate it upward too)
1614 }
1615 }
1620 // Fill in returned line-box and max-element-width data
1626 #ifdef NOISY_BLOCKDIR_ALIGN
1633 #endif
1634 }
1635 }
1637 // Place frames with CSS property vertical-align: top or bottom.
1639 nscoord aDistanceFromStart,
1640 nscoord aLineBSize) {
1643 #ifdef DEBUG
1645 #endif
1655 }
1657 #ifdef NOISY_BLOCKDIR_ALIGN
1664 #endif
1668 // Compute bottom leading
1675 }
1677 #ifdef NOISY_BLOCKDIR_ALIGN
1681 #endif
1683 }
1687 }
1688 }
1689 }
1695 }
1705 // We may need to extend leadings here for ruby annotations as
1706 // required by section Line Spacing in the CSS Ruby spec.
1707 // See http://dev.w3.org/csswg/css-ruby/#line-height
1712 }
1722 }
1723 }
1726 // If we do not require any additional leadings, don't touch anything
1727 // here even if it is greater than the original leading, because the
1728 // latter could be negative.
1733 // If the total leading is not wide enough for ruby annotations
1734 // and/or emphasis marks, extend the side which is not enough. If
1735 // both sides are not wide enough, replace the leadings with the
1736 // requested values.
1744 }
1746 // We have adjusted the leadings, it is no longer a zero
1747 // effective span box.
1749 }
1750 }
1751 }
1754 nscoord aInflationMinFontSize) {
1761 }
1763 }
1768 // e.g. An empty `input[type=button]` should still be line-height sized.
1770 }
1775 }
1776 }
1778 }
1780 #define BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM nscoord_MAX
1781 #define BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM nscoord_MIN
1783 // Place frames in the block direction within a given span (CSS property
1784 // vertical-align) Note: this doesn't place frames with vertical-align:
1785 // top or bottom as those have to wait until the entire line box block
1786 // size is known. This is called after the span frame has finished being
1787 // reflowed so that we know its block size.
1789 // Get parent frame info
1793 // Get the parent frame's font for all of the frames in this span
1801 // See if the span is an empty continuation. It's an empty continuation iff:
1802 // - it has a prev-in-flow
1803 // - it has no next in flow
1804 // - it's zero sized
1810 #ifdef NOISY_BLOCKDIR_ALIGN
1829 }
1831 #endif
1833 // Compute the span's zeroEffectiveSpanBox flag. What we are trying
1834 // to determine is how we should treat the span: should it act
1835 // "normally" according to css2 or should it effectively
1836 // "disappear".
1837 //
1838 // In general, if the document being processed is in full standards
1839 // mode then it should act normally (with one exception). The
1840 // exception case is when a span is continued and yet the span is
1841 // empty (e.g. compressed whitespace). For this kind of span we treat
1842 // it as if it were not there so that it doesn't impact the
1843 // line block-size.
1844 //
1845 // In almost standards mode or quirks mode, we should sometimes make
1846 // it disappear. The cases that matter are those where the span
1847 // contains no real text elements that would provide an ascent and
1848 // descent and height. However, if css style elements have been
1849 // applied to the span (border/padding/margin) so that it's clear the
1850 // document author is intending css2 behavior then we act as if strict
1851 // mode is set.
1852 //
1853 // This code works correctly for preMode, because a blank line
1854 // in PRE mode is encoded as a text node with a LF in it, since
1855 // text nodes with only whitespace are considered in preMode.
1856 //
1857 // Much of this logic is shared with the various implementations of
1858 // nsIFrame::IsEmpty since they need to duplicate the way it makes
1859 // some lines empty. However, nsIFrame::IsEmpty can't be reused here
1860 // since this code sets zeroEffectiveSpanBox even when there are
1861 // non-empty children.
1863 // XXXldb If we really have empty continuations, then all these other
1864 // checks don't make sense for them.
1865 // XXXldb This should probably just use nsIFrame::IsSelfEmpty, assuming that
1866 // it agrees with this code. (If it doesn't agree, it probably should.)
1871 // This code handles an issue with compatibility with non-css
1872 // conformant browsers. In particular, there are some cases
1873 // where the font-size and line-height for a span must be
1874 // ignored and instead the span must *act* as if it were zero
1875 // sized. In general, if the span contains any non-compressed
1876 // text then we don't use this logic.
1877 // However, this is not propagated outwards, since (in compatibility
1878 // mode) we don't want big line heights for things like
1879 // <p><font size="-1">Text</font></p>
1881 // We shouldn't include any whitespace that collapses, unless we're
1882 // preformatted (in which case it shouldn't, but the width=0 test is
1883 // perhaps incorrect). This includes whitespace at the beginning of
1884 // a line and whitespace preceded (?) by other whitespace.
1885 // See bug 134580 and bug 155333.
1893 }
1894 }
1895 }
1897 // Setup baselineBCoord, minBCoord, and maxBCoord
1900 // Use a zero baselineBCoord since we don't yet know where the baseline
1901 // will be (until we know how tall the line is; then we will
1902 // know). In addition, use extreme values for the minBCoord and maxBCoord
1903 // values so that only the child frames will impact their values
1904 // (since these are children of the block, there is no span box to
1905 // provide initial values).
1909 #ifdef NOISY_BLOCKDIR_ALIGN
1913 ": pass1 valign frames: topEdge=%d minLineBSize=%d "
1916 #endif
1918 // Compute the logical block size for this span. The logical block size
1919 // is based on the "line-height" value, not the font-size. Also
1920 // compute the top leading.
1929 // Special-case for a ::first-letter frame, set the line height to
1930 // the frame block size if the user has left line-height == normal
1934 }
1944 // When the span-box is to be ignored, zero out the initial
1945 // values so that the span doesn't impact the final line
1946 // height. The contents of the span can impact the final line
1947 // height.
1949 // Note that things are readjusted for this span after its children
1950 // are reflowed
1954 // The initial values for the min and max block coord values are in the
1955 // span's coordinate space, and cover the logical block size of the span.
1956 // If there are child frames in this span that stick out of this area
1957 // then the minBCoord and maxBCoord are updated by the amount of logical
1958 // blockSize that is outside this range.
1959 minBCoord =
1962 }
1964 // This is the distance from the top edge of the parents visual
1965 // box to the baseline. The span already computed this for us,
1966 // so just use it.
1969 #ifdef NOISY_BLOCKDIR_ALIGN
1973 ": baseLine=%d logicalBSize=%d topLeading=%d h=%d bp=%d,%d "
1980 #endif
1981 }
1989 // sanity check (see bug 105168, non-reproducible crashes from null frame)
1994 }
1996 // Compute the logical block size of the frame
1997 nscoord logicalBSize;
2000 // For span frames the logical-block-size and start-leading were
2001 // pre-computed when the span was reflowed.
2004 // For other elements the logical block size is the same as the
2005 // frame's block size plus its margins.
2006 logicalBSize =
2012 }
2013 }
2015 // Get vertical-align property ("vertical-align" is the CSS name for
2016 // block-direction align)
2020 #ifdef NOISY_BLOCKDIR_ALIGN
2030 }
2032 #endif
2038 // For vertical writing mode where the dominant baseline is centered
2039 // (i.e. text-orientation is not sideways-*), we remap 'middle' to
2040 // 'middle-with-baseline' so that images align sensibly with the
2041 // center-baseline-aligned text.
2044 }
2046 // Swap the meanings of top and bottom when line is inverted
2047 // relative to block direction.
2063 }
2064 }
2065 }
2067 // baseline coord that may be adjusted for script offset
2070 // For superscript and subscript, raise or lower the baseline of the box
2071 // to the proper offset of the parent's box, then proceed as for BASELINE
2079 }
2095 }
2098 }
2100 }
2109 }
2112 }
2114 }
2117 // Align the midpoint of the frame with 1/2 the parents
2118 // x-height above the baseline.
2119 nscoord parentXHeight =
2123 baselineBCoord -
2129 }
2132 }
2135 // The top of the logical box is aligned with the top of
2136 // the parent element's text.
2137 // XXX For vertical text we will need a new API to get the logical
2138 // max-ascent here
2139 nscoord parentAscent =
2148 }
2151 }
2154 // The bottom of the logical box is aligned with the
2155 // bottom of the parent elements text.
2156 nscoord parentDescent =
2166 }
2169 }
2172 // Align the midpoint of the frame with the baseline of the parent.
2179 }
2182 }
2183 }
2185 // We have either a coord, a percent, or a calc().
2187 // Percentages are like lengths, except treated as a percentage
2188 // of the elements line block size value.
2194 });
2196 // According to the CSS2 spec (10.8.1), a positive value
2197 // "raises" the box by the given distance while a negative value
2198 // "lowers" the box by the given distance (with zero being the
2199 // baseline). Since Y coordinates increase towards the bottom of
2200 // the screen we reverse the sign, unless the line orientation is
2201 // inverted relative to block direction.
2202 nscoord revisedBaselineBCoord =
2205 // If we're using a dominant center baseline, we align with the center
2206 // of the frame being placed (bug 1133945).
2211 }
2213 }
2215 // Update minBCoord/maxBCoord for frames that we just placed. Do not factor
2216 // text into the equation.
2218 // Text frames do not contribute to the min/max Y values for the
2219 // line (instead their parent frame's font-size contributes).
2220 // XXXrbs -- relax this restriction because it causes text frames
2221 // to jam together when 'font-size-adjust' is enabled
2222 // and layout is using dynamic font heights (bug 20394)
2223 // -- Note #1: With this code enabled and with the fact that we are
2224 // not using Em[Ascent|Descent] as nsDimensions for text
2225 // metrics in GFX mean that the discussion in bug 13072 cannot
2226 // hold.
2227 // -- Note #2: We still don't want empty-text frames to interfere.
2228 // For example in quirks mode, avoiding empty text frames
2229 // prevents "tall" lines around elements like <hr> since the
2230 // rules of <hr> in quirks.css have pseudo text contents with LF
2231 // in them.
2234 // Only consider text frames if they're not empty and
2235 // line-height=normal.
2240 }
2245 // For spans that were are now placing, use their position
2246 // plus their already computed min-Y and max-Y values for
2247 // computing blockStart and blockEnd.
2251 blockStart =
2254 }
2258 // Check if it's a BR frame that is not alone on its line (it
2259 // is given a block size of zero to indicate this), and if so reset
2260 // blockStart and blockEnd so that BR frames don't influence the line.
2264 }
2265 }
2268 #ifdef NOISY_BLOCKDIR_ALIGN
2270 " [frame]raw: a=%d h=%d bp=%d,%d logical: h=%d leading=%d y=%d "
2276 #endif
2277 }
2280 }
2281 }
2283 }
2285 // Factor in the minimum line block-size when handling the root-span for
2286 // the block.
2288 // We should factor in the block element's minimum line-height (as
2289 // defined in section 10.8.1 of the css2 spec) assuming that
2290 // zeroEffectiveSpanBox is not set on the root span. This only happens
2291 // in some cases in quirks mode:
2292 // (1) if the root span contains non-whitespace text directly (this
2293 // is handled by zeroEffectiveSpanBox
2294 // (2) if this line has a ::marker
2295 // (3) if this is the last line of an LI, DT, or DD element
2296 // (The last line before a block also counts, but not before a
2297 // BR) (NN4/IE5 quirk)
2299 // (1) and (2) above
2306 // (3) above, if the last line of LI, DT, or DD
2310 }
2311 }
2312 }
2316 mHasMarker) {
2317 #ifdef NOISY_BLOCKDIR_ALIGN
2320 #endif
2328 nscoord emphasisHeight =
2333 // If the leadings are negative, fill them first.
2338 }
2342 }
2348 }
2349 }
2350 }
2355 #ifdef NOISY_BLOCKDIR_ALIGN
2357 #endif
2358 #ifdef NOISY_BLOCKDIR_ALIGN
2360 " Used mMinLineBSize: %d, blockStart: %d, blockEnd: "
2363 #endif
2365 // XXX issues:
2366 // [1] BR's on empty lines stop working
2367 // [2] May not honor css2's notion of handling empty elements
2368 // [3] blank lines in a pre-section ("\n") (handled with preMode)
2370 // XXX Are there other problems with this?
2371 #ifdef NOISY_BLOCKDIR_ALIGN
2373 " [span]==> zapping min/maxBCoord: currentValues: %d,%d "
2376 #endif
2378 }
2379 }
2380 }
2385 }
2388 #ifdef NOISY_BLOCKDIR_ALIGN
2391 " Original: minBCoord=%d, maxBCoord=%d, bSize=%d, ascent=%d, "
2396 #endif
2397 nscoord goodMinBCoord =
2401 // For cases like the one in bug 714519 (text-decoration placement
2402 // or making nsLineLayout::IsZeroBSize() handle
2403 // vertical-align:top/bottom on a descendant of the line that's not
2404 // a child of it), we want to treat elements that are
2405 // vertical-align: top or bottom somewhat like children for the
2406 // purposes of this quirk. To some extent, this is guessing, since
2407 // they might end up being aligned anywhere. However, we'll guess
2408 // that they'll be placed aligned with the top or bottom of this
2409 // frame (as though this frame is the only thing in the line).
2410 // (Guessing isn't unreasonable, since all we're doing is reducing the
2411 // scope of a quirk and making the behavior more standards-like.)
2413 // Distribute maxStartBoxBSize to ascent (baselineBCoord - minBCoord), and
2414 // then to descent (maxBCoord - baselineBCoord) by adjusting minBCoord or
2415 // maxBCoord, but not to exceed goodMinBCoord and goodMaxBCoord.
2426 }
2429 }
2430 }
2432 // Likewise, but preferring descent to ascent.
2443 }
2446 }
2447 }
2452 // shrink the logical extents
2455 }
2460 }
2462 // shrink the content by moving its block start down. This is tricky,
2463 // since the block start is the 0 for many coordinates, so what we do is
2464 // move everything else up.
2474 // back up
2477 }
2479 // coordinate system
2481 }
2486 }
2487 #ifdef NOISY_BLOCKDIR_ALIGN
2489 " New: minBCoord=%d, maxBCoord=%d, bSize=%d, ascent=%d, "
2494 #endif
2495 }
2499 #ifdef NOISY_BLOCKDIR_ALIGN
2501 " [span]==> minBCoord=%d maxBCoord=%d delta=%d maxStartBoxBSize=%d "
2504 maxEndBoxBSize);
2505 #endif
2508 }
2511 }
2512 }
2515 // This should not use nsIFrame::MovePositionBy because it happens
2516 // prior to relative positioning. In particular, because
2517 // nsBlockFrame::PlaceLine calls aLineLayout.TrimTrailingWhiteSpace()
2518 // prior to calling aLineLayout.RelativePositionFrames().
2522 }
2530 }
2533 #ifdef REALLY_NOISY_TRIM
2538 #endif
2542 // Maybe the child span has the trailing white-space in it?
2546 // Adjust the child spans frame size
2549 // When the child span is not a direct child of the block
2550 // we need to update the child spans frame rectangle
2551 // because it most likely will not be done again. Spans
2552 // that are direct children of the block will be updated
2553 // later, however, because the VerticalAlignFrames method
2554 // will be run after this method.
2560 }
2562 // Adjust the inline end edge of the span that contains the child span
2565 // Slide any frames that follow the child span over by the
2566 // correct amount. The only thing that can follow the child
2567 // span is empty stuff, so we are just making things
2568 // sensible (keeping the combined area honest).
2573 // When the child span is not a direct child of the block
2574 // we need to update the child span's frame rectangle
2575 // because it most likely will not be done again. Spans
2576 // that are direct children of the block will be updated
2577 // later, however, because the VerticalAlignFrames method
2578 // will be run after this method.
2580 }
2581 }
2582 }
2584 }
2586 // If we hit a frame on the end that's not text and not a placeholder,
2587 // then there is no trailing whitespace to trim. Stop the search.
2591 // Call TrimTrailingWhiteSpace even on empty textframes because they
2592 // might have a soft hyphen which should now appear, changing the frame's
2593 // width
2598 #ifdef NOISY_TRIM
2603 #endif
2607 }
2609 // Delta width not being zero means that
2610 // there is trimmed space in the frame.
2614 // If any trailing space is trimmed, the justification opportunity
2615 // generated by the space should be removed as well.
2618 // See if the text frame has already been placed in its parent
2620 // The frame was already placed during psd's
2621 // reflow. Update the frames rectangle now.
2623 }
2625 // Adjust containing span's right edge
2628 // Slide any frames that follow the text frame over by the
2629 // right amount. The only thing that can follow the text
2630 // frame is empty stuff, so we are just making things
2631 // sensible (keeping the combined area honest).
2636 // When the child span is not a direct child of the block
2637 // we need to update the child spans frame rectangle
2638 // because it most likely will not be done again. Spans
2639 // that are direct children of the block will be updated
2640 // later, however, because the VerticalAlignFrames method
2641 // will be run after this method.
2643 }
2644 }
2645 }
2648 // Pass up to caller so they can shrink their span
2651 }
2652 }
2654 }
2658 }
2662 nscoord deltaISize;
2665 }
2669 // Skip ::markers, empty frames, and placeholders
2671 }
2674 // Skip trimmed whitespaces
2676 }
2678 }
2683 // When we are going across a boundary of ruby base, i.e. entering
2684 // one, leaving one, or both, the following fields will be set to
2685 // the corresponding ruby base frame for handling ruby-align.
2694 };
2698 }
2700 /**
2701 * Assign justification gaps for justification
2702 * opportunities across two frames.
2703 */
2704 /* static */
2719 }
2726 }
2728 // We are no longer going across a ruby base boundary.
2732 }
2738 }
2749 }
2751 }
2753 /**
2754 * Compute the justification info of the given span, and store the
2755 * number of inner opportunities into the frame's justification info.
2756 * It returns the number of non-inner opportunities it detects.
2757 */
2773 }
2779 }
2789 }
2793 // It is not an empty ruby base, but we are not assigning gaps
2794 // to the content for now. Clear the last entered ruby base so
2795 // that we can correctly set the last exited ruby base.
2799 }
2802 }
2806 // There is no justification participant inside this ruby base.
2807 // Ignore this ruby base completely and restore the outer ruby
2808 // base here.
2812 }
2813 }
2820 }
2821 }
2824 }
2828 nscoord aDeltaICoord,
2829 nscoord aDeltaISize) {
2840 // Check whether this expansion should be counted into the reserved
2841 // isize or not. When it is a ruby text container, and it has some
2842 // children linked to the base, it must not have reserved isize,
2843 // or its children won't align with their bases. Otherwise, this
2844 // expansion should be reserved. There are two cases a ruby text
2845 // container does not have children linked to the base:
2846 // 1. it is a container for span; 2. its children are collapsed.
2847 // See bug 1055674 for the second case.
2849 // This ruby text container is a span.
2852 // For ruby text frames, only increase frames
2853 // which are not auto-hidden.
2858 }
2860 // It is a normal ruby text container. Its children will expand
2861 // themselves properly. We only need to expand its own size here.
2863 }
2865 }
2867 /**
2868 * This function applies the changes of icoord and isize caused by
2869 * justification to annotations of the given frame.
2870 */
2872 nscoord aDeltaICoord,
2873 nscoord aDeltaISize) {
2878 aDeltaISize);
2880 // There are two cases where an annotation frame has siblings which
2881 // do not attached to a ruby base-level frame:
2882 // 1. there's an intra-annotation whitespace which has no intra-base
2883 // white-space to pair with;
2884 // 2. there are not enough ruby bases to be paired with annotations.
2885 // In these cases, their size should not be affected, but we still
2886 // need to move them so that they won't overlap other frames.
2892 }
2895 }
2896 }
2911 // Don't apply justification if the frame doesn't participate. Same
2912 // as the condition used in ComputeFrameJustification. Note that,
2913 // we still need to move the frame based on deltaICoord even if the
2914 // frame itself doesn't expand.
2918 // Set corresponding justification gaps here, so that the
2919 // text frame knows how it should add gaps at its sides.
2924 }
2928 }
2932 }
2933 }
2937 }
2942 // It is possible that we assign gaps to non-text frame or an
2943 // orthogonal text frame. Apply the gaps as margin for them.
2947 }
2950 // The gaps added to the end of the frame should also be
2951 // excluded from the isize added to the annotation.
2955 }
2957 }
2963 }
2964 // XXX It is possible that no ruby base ancestor is found because of
2965 // some edge cases like form control or canvas inside ruby text.
2966 // See bug 1138092 comment 4.
2969 }
2971 /**
2972 * This method expands the given frame by the given reserved isize.
2973 */
2980 // do nothing for start
2987 // Each expandable ruby box with ruby-align space-around has a
2988 // gap at each of its sides. For rb/rbc, see comment in
2989 // AssignInterframeJustificationGaps; for rt/rtc, see comment
2990 // in ExpandRubyBoxWithAnnotations.
2992 }
2997 }
2998 // If there are no justification opportunities for space-between,
2999 // fall-through to center per spec.
3001 }
3003 // Indent all children by half of the reserved inline size.
3008 }
3012 }
3016 }
3018 /**
3019 * This method expands the given frame by the reserved inline size.
3020 * It also expands its annotations if they are expandable and have
3021 * reserved isize larger than zero.
3022 */
3028 }
3035 // Inter-character case: don't attempt to expand ruby annotations.
3037 }
3041 // It is necessary to set the rect again because the container
3042 // width was unknown, and zero was used instead when we reflow
3043 // them. The corresponding base containers were repositioned in
3044 // VerticalAlignFrames and PlaceTopBottomFrames.
3048 aContainerSize);
3049 }
3054 }
3057 JustificationComputationState computeState;
3061 }
3063 // Add one gap at each side of this annotation.
3066 }
3071 "Container width should only be different when the current "
3072 "annotation is a ruby text frame, whose parent is not same "
3076 }
3077 }
3079 /**
3080 * This method looks for all expandable ruby box in the given span, and
3081 * calls ExpandRubyBox to expand them in depth-first preorder.
3082 */
3088 }
3091 }
3092 }
3093 }
3102 }
3107 // If the hangable space will be at the start edge of the line, due to
3108 // its bidi direction being against the line direction, we flag this by
3109 // negating the advance.
3114 }
3115 }
3117 }
3119 // If we hit a frame on the end that's not text and not a placeholder or
3120 // <br>, then there is no trailing whitespace to hang. Stop the search.
3122 }
3123 // Scan back for a preceding frame whose whitespace we can hang.
3125 }
3127 }
3135 }
3144 }
3145 }
3147 }
3149 // If we hit a frame on the end that's not text and not a placeholder or
3150 // <br>, then there is no trailing whitespace to trim. Stop the search.
3152 }
3153 // Scan back for a preceding frame whose whitespace we can trim.
3155 }
3157 }
3159 // Align inline frames within the line according to the CSS text-align
3160 // property.
3162 /**
3163 * NOTE: aIsLastLine ain't necessarily so: it is correctly set by caller
3164 * only in cases where the last line needs special handling.
3165 */
3169 "have unconstrained width; this should only result from "
3170 "very large sizes, not attempts at intrinsic width "
3174 #ifdef NOISY_INLINEDIR_ALIGN
3178 #endif
3181 StyleTextAlign textAlign =
3184 // Check if there's trailing whitespace we need to "hang" at line-wrap.
3194 }
3195 }
3203 JustificationComputationState computeState;
3212 additionalGaps++;
3213 }
3214 }
3221 additionalGaps++;
3222 }
3223 }
3224 }
3225 }
3238 // Apply the justification, and make sure to update our linebox
3239 // width to account for it.
3243 // If the trimmable trailing whitespace that we want to hang had
3244 // reverse-inline directionality, adjust line position to account for
3245 // it being at the inline-start side.
3246 // On top of the original "hang" amount, justification will have
3247 // modified its width, so we include that adjustment here.
3250 }
3252 // Gaps that belong to trimmed whitespace were not included in the
3253 // applyState count, so we need to add them here for the assert.
3258 // Similarly, account for the adjustment applied to the trimmed
3259 // whitespace, which is in addition to the adjustment that applies
3260 // within the actual width of the line.
3267 }
3268 // Fall through to the default case if we could not justify to fill
3269 // the space.
3271 }
3275 // Default alignment is to start edge so do nothing, except to apply
3276 // any "reverse-hang" amount resulting from reversed-direction trailing
3277 // space.
3278 // Char is for tables so treat as start if we find it in block layout.
3281 }
3290 }
3299 }
3310 }
3311 }
3315 }
3320 // ::marker shouldn't participate in bidi reordering nor text alignment.
3324 }
3332 }
3335 // For the bidi case, if startFrame is a ::first-line frame, the mIStart and
3336 // mTextIndent offsets will already have been applied to its position, but
3337 // we still need to apply the text-align adjustment |dx| to its position.
3344 }
3345 }
3347 }
3348 }
3350 // This method applies any relative positioning to the given frame.
3354 }
3359 // right and bottom are handled by
3360 // ReflowInput::ComputeRelativeOffsets
3364 }
3366 // This method do relative positioning for ruby annotations.
3377 OverflowAreas rtcOverflowAreas;
3380 }
3381 }
3382 }
3386 OverflowAreas overflowAreas;
3389 // The span's overflow areas come in three parts:
3390 // -- this frame's width and height
3391 // -- pfd->mOverflowAreas, which is the area of a ::marker or the union
3392 // of a relatively positioned frame's absolute children
3393 // -- the bounds of all inline descendants
3394 // The former two parts are computed right here, we gather the descendants
3395 // below.
3396 // At this point psd->mFrame->mBounds might be out of date since
3397 // bidi reordering can move and resize the frames. So use the frame's
3398 // rect instead of mBounds.
3407 mFinalLineBSize);
3408 // The minimum combined area for the frames that are direct
3409 // children of the block starts at the upper left corner of the
3410 // line and is sized to match the size of the line's bounding box
3411 // (the same size as the values returned from VerticalAlignFrames)
3414 }
3419 // Adjust the origin of the frame
3422 // We must position the view correctly before positioning its
3423 // descendants so that widgets are positioned properly (since only
3424 // some views have widgets).
3431 // Note: the combined area of a child is in its coordinate
3432 // system. We adjust the childs combined area into our coordinate
3433 // system before computing the aggregated value by adding in
3434 // <b>x</b> and <b>y</b> which were computed above.
3435 OverflowAreas r;
3437 // Compute a new combined area for the child span before
3438 // aggregating it into our combined area.
3443 // We need to recompute overflow areas in four cases:
3444 // (1) When PFD_RECOMPUTEOVERFLOW is set due to trimming
3445 // (2) When there are text decorations, since we can't recompute the
3446 // overflow area until Reflow and VerticalAlignLine have finished
3447 // (3) When there are text emphasis marks, since the marks may be
3448 // put further away if the text is inside ruby.
3449 // (4) When there are text strokes
3456 }
3458 }
3460 // If we have something that's not an inline but with a complex frame
3461 // hierarchy inside that contains views, they need to be
3462 // positioned.
3463 // All descendant views must be repositioned even if this frame
3464 // does have a view in case this frame's view does not have a
3465 // widget and some of the descendant views do have widgets --
3466 // otherwise the widgets won't be repositioned.
3468 }
3470 // Do this here (rather than along with setting the overflow rect
3471 // below) so we get leaf frames as well. No need to worry
3472 // about the root span, since it doesn't have a frame.
3479 }
3481 // Also compute relative position in the annotations.
3484 }
3486 // If we just computed a spans combined area, we need to update its
3487 // overflow rect...
3492 }
3494 }