| blob | eb41a1961ec7e184551789d5fb9c4b0f03a1c982 |
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 /* struct containing the input to nsIFrame::Reflow */
11 #include <algorithm>
44 }
46 /**
47 * Adjusts the margin for a list (ol, ul), if necessary, depending on
48 * font inflation settings. Unfortunately, because bullets from a list are
49 * placed in the margin area, we only have ~40px in which to place the
50 * bullets. When they are inflated, however, this causes problems, since
51 * the text takes up more space than is available in the margin.
52 *
53 * This method will return a small amount (in app units) by which the
54 * margin can be adjusted, so that the space is available for list
55 * bullets to be rendered with font inflation enabled.
56 */
60 }
62 // We only want to adjust the margins if we're dealing with an ordered list.
66 }
71 }
73 // The HTML spec states that the default padding for ordered lists
74 // begins at 40px, indicating that we have 40px of space to place a
75 // bullet. When performing font inflation calculations, we add space
76 // equivalent to this, but simply inflated at the same amount as the
77 // text, in app units.
83 }
91 }
94 }
106 }
116 }
118 // Initialize a <b>root</b> reflow input with a rendering context to
119 // use for measuring things.
132 }
135 }
139 }
140 // When we encounter a PageContent frame this will be set to true.
142 }
144 // Initialize a reflow input for a child frame's reflow. Some state
145 // is copied from the parent reflow input; the remaining state is
146 // computed.
151 InitFlags aFlags,
153 ComputeSizeFlags aComputeSizeFlags)
177 // If we're setting up for an orthogonal flow, and the parent reflow input
178 // had a constrained ComputedBSize, we can use that as our AvailableISize
179 // in preference to leaving it unconstrained.
183 }
184 }
186 // Note: mFlags was initialized as a copy of aParentReflowInput.mFlags up in
187 // this constructor's init list, so the only flags that we need to explicitly
188 // initialize here are those that may need a value other than our parent's.
200 // aPresContext->IsPaginated() and the named pages pref should have been
201 // checked when constructing the root ReflowInput.
205 }
207 {
211 // PageContent requires paginated reflow.
215 "mFlags.mCanHaveClassABreakpoints should have been "
224 // Never allow breakpoints inside of out-of-flow frames.
227 }
228 // This frame type can have class A breakpoints, inherit this flag
229 // from the parent (this is done for all flags during construction).
230 // This also includes Canvas frames, as each PageContent frame always
231 // has exactly one child which is a Canvas frame.
232 // Do NOT include the subclasses of BlockFrame here, as the ones for
233 // which this could be applicable (ColumnSetWrapper and the MathML
234 // frames) cannot have class A breakpoints.
241 }
242 }
248 }
252 }
253 }
260 return mFrame
263 aSize)
265 }
276 nscoord outside =
281 }
290 }
292 }
300 }
305 }
307 }
310 // Note that we could make a stronger optimization for IsBResize if
311 // we use it in a ShouldReflowChild test that replaces the current
312 // checks of NS_FRAME_IS_DIRTY | NS_FRAME_HAS_DIRTY_CHILDREN, if it
313 // were tested there along with NS_FRAME_CONTAINS_RELATIVE_BSIZE.
314 // This would need to be combined with a slight change in which
315 // frames NS_FRAME_CONTAINS_RELATIVE_BSIZE is marked on.
320 }
323 ResetResizeFlags aFlags) {
324 // It'd be nice to assert that |frame| is not in reflow, but this fails
325 // because viewport frames reset the computed isize on a copy of their reflow
326 // input when reflowing fixed-pos kids. In that case we actually don't want
327 // to mess with the resize flags, because comparing the frame's rect to the
328 // munged computed isize is pointless.
334 }
335 }
336 }
339 ResetResizeFlags aFlags) {
340 // It'd be nice to assert that |frame| is not in reflow, but this fails
341 // for the same reason as above.
347 }
348 }
349 }
356 // Look up the parent chain for an orthogonal inline limit,
357 // and reset AvailableISize() if found.
364 }
365 }
366 }
369 "have unconstrained inline-size; this should only "
370 "result from very large sizes, not attempts at "
382 // Placeholders have a no-op Reflow method that doesn't need the rest of
383 // this initialization, so we bail out early.
386 }
401 // An SVG foreignObject frame is inherently constrained block-size.
408 // Don't set NS_FRAME_IN_CONSTRAINED_BSIZE on body or html elements.
411 // If our block-size was specified as a percentage, then this could
412 // actually resolve to 'auto', based on:
413 // http://www.w3.org/TR/CSS21/visudet.html#the-height-property
426 // If we've reached the top of the tree, then we don't have
427 // a constrained block-size.
430 }
436 }
437 }
440 }
441 }
445 // Orthogonal frames are always reflowed with an unconstrained
446 // dimension to avoid incomplete reflow across an orthogonal
447 // boundary. Normally this is the block-size, but for column sets
448 // with auto-height it's the inline-size, so that they can add
449 // columns in the container's block direction
455 }
456 }
459 // In the case that a box is size contained in block axis, we want to ensure
460 // that it is also monolithic. We do this by setting AvailableBSize() to an
461 // unconstrained size to avoid fragmentation.
463 }
469 "have unconstrained inline-size; this should only "
470 "result from very large sizes, not attempts at "
472 }
477 // Keep this in sync with nsIFrame::GetContainingBlock.
481 }
483 }
489 }
493 }
495 // To avoid a long walk up the frame tree check if the parent frame can be a
496 // containing block for mFrame.
498 mStyleDisplay) &&
501 // Inner table frames need to use the containing block of the outer
502 // table frame.
507 }
510 }
511 }
513 /* Check whether CalcQuirkContainingBlockHeight would stop on the
514 * given reflow input, using its block as a height. (essentially
515 * returns false for any case in which CalcQuirkContainingBlockHeight
516 * has a "continue" in its main loop.)
517 *
518 * XXX Maybe refactor CalcQuirkContainingBlockHeight so it uses
519 * this function as well
520 */
522 LayoutFrameType aFrameType) {
525 // Note: This next condition could change due to a style change,
526 // but that would cause a style reflow anyway, which means we're ok.
530 }
531 }
532 }
534 }
537 LayoutFrameType aFrameType) {
543 // We should report that we have a resize in the inline dimension if
544 // *either* the border-box size or the content-box size in that
545 // dimension has changed. It might not actually be necessary to do
546 // this if the border-box size has changed and the content-box size
547 // has not changed, but since we've historically used the flag to mean
548 // border-box size change, continue to do that. It's possible for
549 // the content-box size to change without a border-box size change or
550 // a style change given (1) a fixed width (possibly fixed by max-width
551 // or min-width), box-sizing:border-box, and percentage padding;
552 // (2) box-sizing:content-box, M% width, and calc(Npx - M%) padding.
553 //
554 // However, we don't actually have the information at this point to tell
555 // whether the content-box size has changed, since both style data and the
556 // UsedPaddingProperty() have already been updated in
557 // SizeComputationInput::InitOffsets(). So, we check the HasPaddingChange()
558 // bit for the cases where it's possible for the content-box size to have
559 // changed without either (a) a change in the border-box size or (b) an
560 // nsChangeHint_NeedDirtyReflow change hint due to change in border or
561 // padding.
562 //
563 // We don't clear the HasPaddingChange() bit here, since sometimes we
564 // construct reflow input (e.g. in nsBlockFrame::ReflowBlockFrame to compute
565 // margin collapsing) without reflowing the frame. Instead, we clear it in
566 // nsIFrame::DidReflow().
568 // is the border-box resizing?
571 // or is the content-box resizing? (see comment above)
576 // Create our font inflation data if we don't have it already, and
577 // give it our current width information.
579 // Avoid running this at the box-to-block interface
580 // (where we shouldn't be inflating anyway, and where
581 // reflow input construction is probably to construct a
582 // dummy parent reflow input anyway).
586 // When font size inflation is enabled, a change in either:
587 // * the effective width of a font inflation flow root
588 // * the width of the frame
589 // needs to cause a dirty reflow since they change the font size
590 // inflation calculations, which in turn change the size of text,
591 // line-heights, etc. This is relatively similar to a classic
592 // case of style change reflow, except that because inflation
593 // doesn't affect the intrinsic sizing codepath, there's no need
594 // to invalidate intrinsic sizes.
595 //
596 // Note that this makes horizontal resizing a good bit more
597 // expensive. However, font size inflation is targeted at a set of
598 // devices (zoom-and-pan devices) where the main use case for
599 // horizontal resizing needing to be efficient (window resizing) is
600 // not present. It does still increase the cost of dynamic changes
601 // caused by script where a style or content change in one place
602 // causes a resize in another (e.g., rebalancing a table).
604 // FIXME: This isn't so great for the cases where
605 // ReflowInput::SetComputedWidth is called, if the first time
606 // we go through InitResizeFlags we set IsHResize() to true, and then
607 // the second time we'd set it to false even without the
608 // NS_FRAME_IS_DIRTY bit already set.
610 // Foreign object frames use dirty bits in a special way.
615 }
618 }
620 // Mark intrinsic widths on all descendants dirty. We need to do
621 // this (1) since we're changing the size of text and need to
622 // clear text runs on text frames and (2) since we actually are
623 // changing some intrinsic widths, but only those that live inside
624 // of containers.
626 // It makes sense to do this for descendants but not ancestors
627 // (which is unusual) because we're only changing the unusual
628 // inflation-dependent intrinsic widths (i.e., ones computed with
629 // nsPresContext::mInflationDisabledForShrinkWrap set to false),
630 // which should never affect anything outside of their inflation
631 // flow root (or, for that matter, even their inflation
632 // container).
634 // This is also different from what PresShell::FrameNeedsReflow
635 // does because it doesn't go through placeholders. It doesn't
636 // need to because we're actually doing something that cares about
637 // frame tree geometry (the width on an ancestor) rather than
638 // style.
649 }
650 }
652 }
653 }
657 // XXX Should we really need to null check mCBReflowInput? (We do for
658 // at least nsBoxFrame).
660 // When we have an nsChangeHint_UpdateComputedBSize, we'll set a bit
661 // on the frame to indicate we're resizing. This might catch cases,
662 // such as a change between auto and a length, where the box doesn't
663 // actually resize but children with percentages resize (since those
664 // percentages become auto if their containing block is auto).
667 // We don't clear the HasBSizeChange state here, since sometimes we
668 // construct a ReflowInput (e.g. in nsBlockFrame::ReflowBlockFrame to
669 // compute margin collapsing) without reflowing the frame. Instead, we
670 // clear it in nsIFrame::DidReflow.
676 // We have a percentage (or calc-with-percentage) block-size, and the
677 // value it's relative to has changed.
683 NS_TABLE_CELL_HAD_SPECIAL_REFLOW)) &&
685 // Need to set the bit on the cell so that
686 // mCBReflowInput->IsBResize() is set correctly below when
687 // reflowing descendant.
691 // XXX Is this problematic for relatively positioned inlines acting
692 // as containing block for absolutely positioned elements?
693 // Possibly; in that case we should at least be checking
694 // IsSubtreeDirty(), I'd think.
699 // We have an 'auto' block-size.
701 mCBReflowInput) {
702 // FIXME: This should probably also check IsIResize().
706 }
709 // We have a non-'auto' block-size, i.e., a length. Set the BResize
710 // flag to whether the size is actually different.
714 }
717 // FIXME: condition this on not-abspos?
724 // If mFrame is a flex item, and mFrame's block axis is the flex container's
725 // main axis (e.g. in a column-oriented flex container with same
726 // writing-mode), then its block-size depends on its CB size, if its
727 // flex-basis has a percentage.
732 }
735 // line-height depends on block bsize
737 // but only on containing blocks if this frame is not a suitable block
739 }
741 // If we're the descendant of a table cell that performs special bsize
742 // reflows and we could be the child that requires them, always set
743 // the block-axis resize in case this is the first pass before the
744 // special bsize reflow. However, don't do this if it actually is
745 // the special bsize reflow, since in that case it will already be
746 // set correctly above if we need it set.
753 }
755 // Set NS_FRAME_CONTAINS_RELATIVE_BSIZE if it's needed.
757 // It would be nice to check that |ComputedBSize != NS_UNCONSTRAINEDSIZE|
758 // &&ed with the percentage bsize check. However, this doesn't get
759 // along with table special bsize reflows, since a special bsize
760 // reflow (a quirk that makes such percentage height work on children
761 // of table cells) can cause not just a single percentage height to
762 // become fixed, but an entire descendant chain of percentage height
763 // to become fixed.
771 }
775 }
778 // Keep track of whether we've hit the containing block, because
779 // we need to go at least that far.
782 }
784 // XXX What about orthogonal flows? It doesn't make sense to
785 // keep propagating this bit across an orthogonal boundary,
786 // where the meaning of BSize changes. Bug 1175517.
790 // Note: We actually don't need to set the
791 // NS_FRAME_CONTAINS_RELATIVE_BSIZE bit for the cases
792 // where we hit the early break statements in
793 // CalcQuirkContainingBlockHeight. But it doesn't hurt
794 // us to set the bit in these cases.
795 }
797 // If we're reflowing everything, then we'll find out if we need
798 // to re-set this.
800 }
801 }
808 }
809 }
816 }
819 // We consider mFrame with a prev-in-flow being in a fragmented context
820 // because nsColumnSetFrame can reflow its last column with an unconstrained
821 // available block-size.
823 }
825 /* static */
832 // Compute the 'inlineStart' and 'inlineEnd' values. 'inlineStart'
833 // moves the boxes to the end of the line, and 'inlineEnd' moves the
834 // boxes to the start of the line. The computed values are always:
835 // inlineStart=-inlineEnd
841 // If neither 'inlineStart' nor 'inlineEnd' is auto, then we're
842 // over-constrained and we ignore one of them
845 }
849 // If both are 'auto' (their initial values), the computed values are 0
852 // 'inlineEnd' isn't 'auto' so compute its value
856 // Computed value for 'inlineStart' is minus the value of 'inlineEnd'
858 }
863 // 'InlineStart' isn't 'auto' so compute its value
867 // Computed value for 'inlineEnd' is minus the value of 'inlineStart'
869 }
871 // Compute the 'blockStart' and 'blockEnd' values. The 'blockStart'
872 // and 'blockEnd' properties move relatively positioned elements in
873 // the block progression direction. They also must be each other's
874 // negative
880 // Check for percentage based values and a containing block block-size
881 // that depends on the content block-size. Treat them like 'auto'
885 }
888 }
889 }
891 // If neither is 'auto', 'block-end' is ignored
894 }
898 // If both are 'auto' (their initial values), the computed values are 0
901 // 'blockEnd' isn't 'auto' so compute its value
905 // Computed value for 'blockStart' is minus the value of 'blockEnd'
907 }
912 // 'blockStart' isn't 'auto' so compute its value
916 // Computed value for 'blockEnd' is minus the value of 'blockStart'
918 }
920 // Convert the offsets to physical coordinates and store them on the frame
928 }
935 }
937 /* static */
943 "We assume that changing the 'position' property causes "
944 "frame reconstruction. If that ever changes, this code "
945 "should call "
948 }
950 // Store the normal position
959 // Sticky positioning for elements with multiple frames needs to be
960 // computed all at once. We can't safely do that here because we might be
961 // partway through (re)positioning the frames, so leave it until the scroll
962 // container reflows and calls StickyScrollContainer::UpdatePositions.
963 // For single-frame sticky positioned elements, though, go ahead and apply
964 // it now to avoid unnecessary overflow updates later.
969 }
970 }
971 }
973 // static
975 WritingMode aContainingBlockWM,
983 // Note that this case is different from the neither-'auto'
984 // case below, where the spec says to ignore 'left'/'right'.
985 // Ignore the specified value for 'margin-right'.
988 // Both 'margin-left' and 'margin-right' are 'auto', so they get
989 // equal values
993 }
995 // Just 'margin-left' is 'auto'
997 }
1000 // Just 'margin-right' is 'auto'
1003 // We're over-constrained so use the direction of the containing
1004 // block to dictate which value to ignore. (And note that the
1005 // spec says to ignore 'left' or 'right' rather than
1006 // 'margin-left' or 'margin-right'.)
1007 // Note that this case is different from the both-'auto' case
1008 // above, where the spec says to ignore
1009 // 'margin-left'/'margin-right'.
1010 // Ignore the specified value for 'right'.
1012 }
1013 }
1014 }
1016 // static
1018 WritingMode aContainingBlockWM,
1025 // Both 'margin-top' and 'margin-bottom' are 'auto', so they get
1026 // equal values
1031 // Just margin-block-start is 'auto'
1033 }
1036 // Just margin-block-end is 'auto'
1039 // We're over-constrained so ignore the specified value for
1040 // block-end. (And note that the spec says to ignore 'bottom'
1041 // rather than 'margin-bottom'.)
1043 }
1044 }
1045 }
1051 // Subtract the size of the frame from the container size that we
1052 // use for converting between the logical and physical origins of
1053 // the frame. This accounts for the fact that logical origins in RTL
1054 // coordinate systems are at the top right of the frame instead of
1055 // the top left.
1057 nsPoint pos =
1063 }
1071 /* Now aFrame is the containing block we want */
1073 /* Check whether the containing block is currently being reflowed.
1074 If so, use the info from the reflow input. */
1080 /* do nothing */
1081 }
1084 }
1092 /* Didn't find a reflow reflowInput for aFrame. Just compute the
1093 information we want, on the assumption that aFrame already knows its
1094 size. This really ought to be true by now. */
1098 // Compute CB's offset & content-box size by subtracting borderpadding from
1099 // frame size.
1103 }
1106 }
1109 // offset from inline-start edge of containing block (which is a padding edge)
1110 nscoord mIStart;
1111 // offset from block-start edge of containing block (which is a padding edge)
1112 nscoord mBStart;
1113 WritingMode mWritingMode;
1114 };
1116 /**
1117 * aInsideBoxSizing returns the part of the padding, border, and margin
1118 * in the aAxis dimension that goes inside the edge given by box-sizing;
1119 * aOutsideBoxSizing returns the rest.
1120 */
1131 nscoord borderStartEnd =
1136 // See if the style system can provide us the padding directly
1141 // We have to compute the start and end values
1148 }
1150 // See if the style system can provide us the margin directly
1155 // We have to compute the start and end values
1157 // We set this to 0 for now, and fix it up later in
1158 // InitAbsoluteConstraints (which is caller of this function, via
1159 // CalculateHypotheticalPosition).
1164 }
1166 // We set this to 0 for now, and fix it up later in
1167 // InitAbsoluteConstraints (which is caller of this function, via
1168 // CalculateHypotheticalPosition).
1173 }
1175 }
1181 }
1185 }
1187 /**
1188 * Returns true iff a pre-order traversal of the normal child
1189 * frames rooted at aFrame finds no non-empty frame before aDescendant.
1190 */
1197 }
1206 }
1211 }
1212 }
1213 }
1216 }
1219 WritingMode aOtherWm) {
1221 // Dedicated short circuit for the common case.
1223 }
1230 Side thisStartSide =
1232 Side otherStartSide =
1235 }
1239 }
1243 }
1245 // Calculate the position of the hypothetical box that the element would have
1246 // if it were in the flow.
1247 // The values returned are relative to the padding edge of the absolute
1248 // containing block. The writing-mode of the hypothetical box position will
1249 // have the same block direction as the absolute containing block, but may
1250 // differ in inline-bidi direction.
1251 // In the code below, |aCBReflowInput->frame| is the absolute containing block,
1252 // while |containingBlock| is the nearest block container of the placeholder
1253 // frame, which may be different from the absolute containing block.
1261 // Find the nearest containing block frame to the placeholder frame,
1262 // and its inline-start edge and width.
1263 nscoord blockIStartContentEdge;
1264 // Dummy writing mode for blockContentSize, will be changed as needed by
1265 // GetHypotheticalBoxContainer.
1270 // Now blockContentSize is in containingBlock's writing mode.
1272 // If it's a replaced element and it has a 'auto' value for
1273 //'inline size', see if we can get the intrinsic size. This will allow
1274 // us to exactly determine both the inline edges
1281 // See if we can get the intrinsic size of the element
1283 }
1285 // See if we can calculate what the box inline size would have been if
1286 // the element had been in the flow
1289 // For non-replaced inline-level elements the 'inline size' property
1290 // doesn't apply, so we don't know what the inline size would have
1291 // been without reflowing it
1293 // It's either a replaced inline-level element or a block-level element
1295 // Determine the total amount of inline direction
1296 // border/padding/margin that the element would have had if it had
1297 // been in the flow. Note that we ignore any 'auto' and 'inherit'
1298 // values
1305 // It's a replaced element with an 'auto' inline size so the box inline
1306 // size is its intrinsic size plus any border/padding/margin
1310 }
1312 // The box inline size is the containing block inline size
1315 // We need to compute it. It's important we do this, because if it's
1316 // percentage based this computed value may be different from the computed
1317 // value calculated using the absolute containing block width
1327 }
1328 }
1330 // Get the placeholder x-offset and y-offset in the coordinate
1331 // space of its containing block
1332 // XXXbz the placeholder is not fully reflowed yet if our containing block is
1333 // relatively positioned...
1334 nsSize containerSize =
1340 containerSize);
1342 // First, determine the hypothetical box's mBStart. We want to check the
1343 // content insertion frame of containingBlock for block-ness, but make
1344 // sure to compute all coordinates in the coordinate system of
1345 // containingBlock.
1349 // Use a null containerSize to convert a LogicalPoint functioning as a
1350 // vector into a physical nsPoint vector.
1354 nullContainerSize);
1358 // Give up. We're probably dealing with somebody using
1359 // position:absolute inside native-anonymous content anyway.
1366 // How we determine the hypothetical box depends on whether the element
1367 // would have been inline-level or block-level
1371 // Use the block-start of the inline box which the placeholder lives in
1372 // as the hypothetical box's block-start.
1375 // The element would have been block-level which means it would
1376 // be below the line containing the placeholder frame, unless
1377 // all the frames before it are empty. In that case, it would
1378 // have been just before this line.
1379 // XXXbz the line box is not fully reflowed yet if our
1380 // containing block is relatively positioned...
1393 }
1394 }
1395 }
1403 }
1405 }
1407 }
1411 // The top of the hypothetical box is the top of the line
1412 // containing the placeholder, since there is nothing in the
1413 // line before our placeholder except empty frames.
1417 // The top of the hypothetical box is just below the line
1418 // containing the placeholder.
1420 }
1422 // Just use the placeholder's block-offset wrt the containing block
1424 }
1425 }
1426 }
1428 // The containing block is not a block, so it's probably something
1429 // like a XUL box, etc.
1430 // Just use the placeholder's block-offset
1432 }
1434 // Second, determine the hypothetical box's mIStart.
1435 // How we determine the hypothetical box depends on whether the element
1436 // would have been inline-level or block-level
1439 // The placeholder represents the IStart edge of the hypothetical box.
1440 // (Or if mFlags.mIOffsetsNeedCSSAlign is set, it represents the IStart
1441 // edge of the Alignment Container.)
1445 }
1447 // The current coordinate space is that of the nearest block to the
1448 // placeholder. Convert to the coordinate space of the absolute containing
1449 // block.
1450 nsPoint cbOffset =
1458 // If block direction doesn't match (whether orthogonal or antiparallel),
1459 // we'll have to convert aHypotheticalPos to be in terms of cbwm.
1460 // This upcoming conversion must be taken into account for border offsets.
1463 // The specified offsets are relative to the absolute containing block's
1464 // padding edge and our current values are relative to the border edge, so
1465 // translate.
1471 }
1477 }
1478 // At this point, we have computed aHypotheticalPos using the writing mode
1479 // of the placeholder's containing block.
1482 // If the block direction we used in calculating aHypotheticalPos does not
1483 // match the absolute containing block's, we need to convert here so that
1484 // aHypotheticalPos is usable in relation to the absolute containing block.
1485 // This requires computing or measuring the abspos frame's block-size,
1486 // which is not otherwise required/used here (as aHypotheticalPos
1487 // records only the block-start coordinate).
1489 // This is similar to the inline-size calculation for a replaced
1490 // inline-level element or a block-level element (above), except that
1491 // 'auto' sizing is handled differently in the block direction for non-
1492 // replaced elements and replaced elements lacking an intrinsic size.
1494 // Determine the total amount of block direction
1495 // border/padding/margin that the element would have had if it had
1496 // been in the flow. Note that we ignore any 'auto' and 'inherit'
1497 // values.
1502 nscoord boxBSize;
1506 // It's a replaced element with an 'auto' block size so the box
1507 // block size is its intrinsic size plus any border/padding/margin
1511 // XXX Bug 1191801
1512 // Figure out how to get the correct boxBSize here (need to reflow the
1513 // positioned frame?)
1515 }
1517 // We need to compute it. It's important we do this, because if it's
1518 // percentage-based this computed value may be different from the
1519 // computed value calculated using the absolute containing block height.
1524 }
1529 origin =
1537 }
1538 }
1545 "If any of the block-start and block-end are auto, aBlockSize "
1553 }
1555 // We don't have to compute the inline size by aspect-ratio and the resolved
1556 // block size (from insets) for replaced elements.
1559 }
1561 // If inline size is specified, we should have it by mFrame->ComputeSize()
1562 // already.
1565 }
1567 // If both inline insets are non-auto, mFrame->ComputeSize() should get a
1568 // possible inline size by those insets, so we don't rely on aspect-ratio.
1572 }
1574 // Just an error handling. If |aBlockSize| is NS_UNCONSTRAINEDSIZE, there must
1575 // be something wrong, and we don't want to continue the calculation for
1576 // aspect-ratio. So we return false if this happens.
1578 }
1580 // FIXME: Move this into nsIFrame::ComputeSize() if possible, so most of the
1581 // if-checks can be simplier.
1587 // Two cases we don't want to early return:
1588 // 1. If the block size behaves as initial value and we haven't resolved it in
1589 // ComputeSize() yet, we need to apply |aAutoBSize|.
1590 // Also, we check both computed style and |resultSize.BSize(wm)| to avoid
1591 // applying |aAutoBSize| when the resolved block size is saturated at
1592 // nscoord_MAX, and wrongly treated as NS_UNCONSTRAINEDSIZE because of a
1593 // giant specified block-size.
1594 // 2. If the block size needs to be computed via aspect-ratio and
1595 // |aAutoBSize|, we need to apply |aAutoBSize|. In this case,
1596 // |resultSize.BSize(wm)| may not be NS_UNCONSTRAINEDSIZE because we apply
1597 // aspect-ratio in ComputeSize() for block axis by default, so we have to
1598 // check its computed style.
1604 bSizeBehavesAsInitial &&
1608 }
1610 // For non-replaced elements with block-size auto, the block-size
1611 // fills the remaining space, and we clamp it by min/max size constraints.
1616 }
1618 // Calculate transferred inline size through aspect-ratio.
1619 // For non-replaced elements, we always take box-sizing into account.
1630 "This flag should have been set because nsIFrame::ComputeSize() "
1631 "returns AspectRatioUsage::ToComputeBSize unconditionally for "
1636 }
1641 LayoutFrameType aFrameType) {
1658 // If both 'left' and 'right' are 'auto' or both 'top' and 'bottom' are
1659 // 'auto', then compute the hypothetical box position where the element would
1660 // have been if it had been in the flow
1661 nsHypotheticalPosition hypotheticalPos;
1669 PLACEHOLDER_STATICPOS_NEEDS_CSSALIGN)) {
1672 // If the (as-yet unknown) static position will determine the inline
1673 // and/or block offsets, set flags to note those offsets aren't valid
1674 // until we can do CSS Box Alignment on the OOF frame.
1677 }
1685 NS_STATE_GRID_IS_ROW_MASONRY)) {
1686 // Disable CSS alignment in Masonry layout since we don't have real grid
1687 // areas in that axis. We'll use the placeholder position instead as it
1688 // was calculated by nsGridContainerFrame::MasonryLayout.
1697 }
1698 }
1700 // XXXmats all this is broken for orthogonal writing-modes: bug 1521988.
1703 aFrameType);
1705 // 'hypotheticalPos' is relative to the padding rect of the CB *frame*.
1706 // In grid layout the CB is the grid area rectangle, so we translate
1707 // 'hypotheticalPos' to be relative that rectangle here.
1717 }
1721 }
1722 }
1723 }
1725 // Initialize the 'left' and 'right' computed offsets
1726 // XXX Handle new 'static-position' value...
1728 // Size of the containing block in its writing mode
1737 }
1743 }
1752 }
1753 }
1760 }
1766 }
1769 // Treat 'top' like 'static-position'
1772 }
1779 }
1783 }
1784 }
1788 {
1802 }
1810 // XXX Now that we have ComputeSize, can we condense many of the
1811 // branches off of widthIsAuto?
1822 // We know 'right' is not 'auto' anymore thanks to the hypothetical
1823 // box code above.
1824 // Solve for 'left'.
1826 // XXXldb This, and the corresponding code in
1827 // nsAbsoluteContainingBlock.cpp, could probably go away now that
1828 // we always compute widths.
1834 }
1836 // We know 'left' is not 'auto' anymore thanks to the hypothetical
1837 // box code above.
1838 // Solve for 'right'.
1840 // XXXldb This, and the corresponding code in
1841 // nsAbsoluteContainingBlock.cpp, could probably go away now that
1842 // we always compute widths.
1848 }
1851 // Neither 'inline-start' nor 'inline-end' is 'auto'.
1853 // For orthogonal blocks, we need to handle the case where the block had
1854 // unconstrained block-size, which mapped to unconstrained inline-size
1855 // in the containing block's writing mode.
1860 // FIXME: Bug 1602669: if |autoISize| happens to be numerically equal to
1861 // NS_UNCONSTRAINEDSIZE, we may get some unexpected behavior. We need a
1862 // better way to distinguish between unconstrained size and resolved
1863 // size.
1868 LogicalSize computedSizeInWM =
1872 }
1874 // However, the inline-size might
1875 // still not fill all the available space (even though we didn't
1876 // shrink-wrap) in case:
1877 // * inline-size was specified
1878 // * we're dealing with a replaced element
1879 // * width was constrained by min- or max-inline-size.
1881 nscoord availMarginSpace =
1888 }
1893 // solve for block-start
1900 }
1902 // solve for block-end
1909 }
1912 // Neither block-start nor -end is 'auto'.
1916 // FIXME: Bug 1602669: if |autoBSize| happens to be numerically equal to
1917 // NS_UNCONSTRAINEDSIZE, we may get some unexpected behavior. We need a
1918 // better way to distinguish between unconstrained size and resolved size.
1922 // For orthogonal case, the inline size in |wm| should have been handled by
1923 // ComputeSize(). In other words, we only have to apply |autoBSize| to
1924 // the computed size if this value can represent the block size in |wm|.
1926 // We handle the unconstrained block-size in current block's writing
1927 // mode 'wm'.
1928 LogicalSize computedSizeInWM =
1932 }
1934 // The block-size might still not fill all the available space in case:
1935 // * bsize was specified
1936 // * we're dealing with a replaced element
1937 // * bsize was constrained by min- or max-bsize.
1944 }
1950 // If we have auto margins, update our UsedMarginProperty. The property
1951 // will have already been created by InitOffsets if it is needed.
1953 marginBEndIsAuto) {
1956 "UsedMarginProperty should have been created "
1959 }
1960 }
1962 // This will not be converted to abstract coordinates because it's only
1963 // used in CalcQuirkContainingBlockHeight
1968 // zero auto margins
1978 }
1980 /* Get the height based on the viewport of the containing block specified
1981 * in aReflowInput when the containing block has mComputedHeight ==
1982 * NS_UNCONSTRAINEDSIZE This will walk up the chain of containing blocks looking
1983 * for a computed height until it finds the canvas frame, or it encounters a
1984 * frame that is not a block, area, or scroll frame. This handles compatibility
1985 * with IE (see bug 85016 and bug 219693)
1986 *
1987 * When we encounter scrolledContent block frames, we skip over them,
1988 * since they are guaranteed to not be useful for computing the containing
1989 * block.
1990 *
1991 * See also IsQuirkContainingBlockHeight.
1992 */
1998 // initialize the default to NS_UNCONSTRAINEDSIZE as this is the containings
1999 // block computed height when this function is called. It is possible that we
2000 // don't alter this height especially if we are restricted to one level
2006 // if the ancestor is auto height then skip it and continue up if it
2007 // is the first block frame and possibly the body/html
2013 // If the current frame we're looking at is positioned, we don't want to
2014 // go any further (see bug 221784). The behavior we want here is: 1) If
2015 // not auto-height, use this as the percentage base. 2) If auto-height,
2016 // keep looking, unless the frame is positioned.
2022 }
2023 }
2025 // Always continue on to the height calculation
2028 // only use the page content frame for a height basis if it is the first
2029 // in flow
2033 }
2035 // if the ancestor is the page content frame then the percent base is
2036 // the avail height, otherwise it is the computed height
2039 // if unconstrained - don't sutract borders - would result in huge height
2042 // if we got to the canvas or page content frame, then subtract out
2043 // margin/border/padding for the BODY and HTML elements
2049 #ifdef DEBUG
2050 // make sure the first ancestor is the HTML and the second is the BODY
2056 }
2057 }
2063 }
2064 }
2065 #endif
2067 }
2068 // if we got to the html frame (a block child of the canvas) ...
2071 // ... then subtract out margin/border/padding for the BODY element
2073 }
2075 }
2077 // Make sure not to return a negative height here!
2079 }
2081 // Called by InitConstraints() to compute the containing block rectangle for
2082 // the element. Handles the special logic for absolutely positioned elements
2085 // Unless the element is absolutely positioned, the containing block is
2086 // formed by the content edge of the nearest block-level ancestor
2095 "Why provide a percentage basis when the containing block's "
2098 }
2101 // XXXfr hack for making frames behave properly when in overflow
2102 // container lists, see bug 154892; need to revisit later
2107 // See if the ancestor is block-level or inline-level
2110 // Base our size on the actual size of the frame. In cases when this is
2111 // completely bogus (eg initial reflow), this code shouldn't even be
2112 // called, since the code in nsInlineFrame::Reflow will pass in
2113 // the containing block dimensions to our constructor.
2114 // XXXbz we should be taking the in-flows into account too, but
2115 // that's very hard.
2117 LogicalMargin computedBorder =
2119 computedPadding;
2127 // If the ancestor is block-level, the containing block is formed by the
2128 // padding edge of the ancestor
2130 }
2134 };
2135 // an element in quirks mode gets a containing block based on looking for a
2136 // parent with a non-auto height if the element has a percent height.
2137 // Note: We don't emulate this quirk for percents in calc(), or in vertical
2138 // writing modes, or if the containing block is a flex or grid item.
2149 }
2150 }
2151 }
2154 }
2156 // XXX refactor this code to have methods for each set of properties
2157 // we are computing: width,height,line-height; margin; offsets
2162 LayoutFrameType aFrameType) {
2167 // If this is a reflow root, then set the computed width and
2168 // height equal to the available space
2170 // XXXldb This doesn't mean what it used to!
2173 // Override mComputedMargin since reflow roots start from the
2174 // frame's boundary, which is inside the margin.
2190 NS_UNCONSTRAINEDSIZE);
2192 // Get the containing block's reflow input
2197 // If we weren't given a containing block size, then compute one.
2200 }
2202 // See if the containing block height is based on the size of its
2203 // content
2205 // See if the containing block is a cell frame which needs
2206 // to use the mComputedHeight of the cell instead of what the cell block
2207 // passed in.
2208 // XXX It seems like this could lead to bugs with min-height and friends
2211 }
2212 }
2214 // XXX Might need to also pass the CB height (not width) for page boxes,
2215 // too, if we implement them.
2217 // For calculating positioning offsets, margins, borders and
2218 // padding, we use the writing mode of the containing block
2223 // For calculating the size of this box, we use its own writing mode
2227 // Check for a percentage based block size and a containing block
2228 // block size that depends on the content block size
2231 // this if clause enables %-blockSize on replaced inline frames,
2232 // such as images. See bug 54119. The else clause "blockSizeUnit =
2233 // eStyleUnit_Auto;" used to be called exclusively.
2235 // Get the containing block's reflow input
2237 // in quirks mode, get the cb height using the special quirk method
2245 }
2248 }
2249 }
2250 // in standard mode, use the cb block size. if it's "auto",
2251 // as will be the case by default in BODY, use auto block size
2252 // as per CSS2 spec.
2259 }
2260 }
2262 // default to interpreting the blockSize like 'auto'
2264 }
2265 }
2266 }
2268 // Compute our offsets if the element is relatively positioned. We
2269 // need the correct containing block inline-size and block-size
2270 // here, which is why we need to do it after all the quirks-n-such
2271 // above. (If the element is sticky positioned, we need to wait
2272 // until the scroll container knows its size, so we compute offsets
2273 // from StickyScrollContainer::UpdatePositions.)
2279 // Initialize offsets to 0
2281 }
2283 // Calculate the computed values for min and max properties. Note that
2284 // this MUST come after we've computed our border and padding.
2287 // Calculate the computed inlineSize and blockSize.
2288 // This varies by frame type.
2291 // Internal table elements. The rules vary depending on the type.
2292 // Calculate the computed isize
2298 // 'inlineSize' property doesn't apply to table rows and row groups
2301 }
2303 // calc() with both percentages and lengths act like auto on internal
2304 // table elements
2307 // Internal table elements don't have margins. Only tables and
2308 // cells have border and padding
2315 }
2322 }
2324 // Calculate the computed block size
2327 // 'blockSize' property doesn't apply to table columns and column groups
2329 }
2330 // calc() with both percentages and lengths acts like 'auto' on internal
2331 // table elements
2339 }
2341 // Doesn't apply to internal table elements
2344 NS_UNCONSTRAINEDSIZE);
2347 // XXXfr hack for making frames behave properly when in overflow
2348 // container lists, see bug 154892; need to revisit later
2352 aFrameType);
2362 }
2363 }
2365 }();
2369 // An inner table frame is not inline-level, even if it happens to
2370 // have 'display:inline-table'. (That makes its table-wrapper frame be
2371 // inline-level, but not the inner table frame)
2373 }
2376 }
2380 // Internal table values on replaced elements behave as inline
2381 // https://drafts.csswg.org/css-tables-3/#table-structure
2382 //
2383 // ... it is handled instead as though the author had declared
2384 // either 'block' (for 'table' display) or 'inline' (for all
2385 // other values)"
2386 //
2387 // FIXME(emilio): The only test that covers this is
2388 // table-anonymous-objects-211.xht, which fails on other browsers (but
2389 // differently to us, if you just remove this condition).
2391 }
2394 // Floats are treated as inline-level and also shrink-wrap.
2396 }
2398 }();
2403 }
2405 // Shrink-wrap replaced elements when in-flow (out of flows are
2406 // handled above). We exclude replaced elements in grid or flex
2407 // contexts, where we don't want to shrink-wrap unconditionally (so
2408 // that stretching can happen). When grid/flex explicitly want
2409 // shrink-wrapping, they can request it directly using the relevant
2410 // flag.
2412 }
2415 // Shrink-wrap blocks that are orthogonal to their container (unless
2416 // we're in a grid?)
2418 }
2420 }();
2424 }
2427 // For orthogonal flows, where we found a parent orthogonal-limit for
2428 // AvailableISize() in Init(), we'll use the same here as well.
2430 }
2450 }
2453 }
2455 // Exclude flex and grid items.
2457 }
2462 // Exclude outside ::markers.
2464 }
2466 // Exclude -moz-column-content since it cannot have any margin.
2468 }
2470 }();
2474 }
2475 }
2476 }
2478 // Save our containing block dimensions
2480 }
2490 }
2493 }
2494 }
2497 LayoutFrameType aFrameType,
2498 ComputeSizeFlags aFlags,
2504 // Compute margins from the specified margin style information. These
2505 // become the default computed values, and may be adjusted below
2506 // XXX fix to provide 0,0 for the top&bottom margins for
2507 // inline-non-replaced elements
2509 // Note that ComputeMargin() simplistically resolves 'auto' margins to 0.
2510 // In formatting contexts where this isn't correct, some later code will
2511 // need to update the UsedMargin() property with the actual resolved value.
2512 // One example of this is ::CalculateBlockSideMargins().
2519 LayoutDeviceIntMargin widgetPadding;
2532 nsMargin stylePadding;
2533 // If the caller passes a padding that doesn't match our style (like
2534 // nsTextControlFrame might due due to theming), then we also need a
2535 // padding prop.
2540 }
2542 // Add [align|justify]-content:baseline padding contribution.
2545 Prop aProp) {
2550 LogicalSide side;
2556 }
2560 // We have a baseline-adjusted block-axis start padding, so
2561 // we need this to mark lines dirty when mIsBResize is true:
2563 }
2564 }
2565 };
2568 }
2571 }
2582 // Do nothing since the border local variable is initialized all zero.
2587 }
2591 // scrollbars may have had their width or height smashed to zero
2592 // by the associated scrollframe, in which case we must not report
2593 // any padding or border.
2598 }
2599 }
2604 // Note: If a padding change is already detectable without resolving the
2605 // percentage, e.g. a padding is changing from 50px to 50%,
2606 // nsIFrame::DidSetComputedStyle() will cache the old padding in
2607 // UsedPaddingProperty().
2610 // Our padding may have changed, but we can't tell at this point.
2612 }
2613 // Keep mHasPaddingChange bit set until we've done reflow. We'll clear it in
2614 // nsIFrame::DidReflow()
2619 }
2621 // This code enforces section 10.3.3 of the CSS2 spec for this formula:
2622 //
2623 // 'margin-left' + 'border-left-width' + 'padding-left' + 'width' +
2624 // 'padding-right' + 'border-right-width' + 'margin-right'
2625 // = width of containing block
2626 //
2627 // Note: the width unit is not auto when this is called
2632 // Calculations here are done in the containing block's writing mode,
2633 // which is where margins will eventually be applied: we're calculating
2634 // margins that will be used by the container in its inline direction,
2635 // which in the case of an orthogonal contained block will correspond to
2636 // the block direction of this reflow input. So in the orthogonal-flow
2637 // case, "CalculateBlock*Side*Margins" will actually end up adjusting
2638 // the BStart/BEnd margins; those are the "sides" of the block from its
2639 // container's point of view.
2640 WritingMode cbWM =
2646 // For orthogonal flows, where we found a parent orthogonal-limit
2647 // for AvailableISize() in Init(), we don't have meaningful sizes to
2648 // adjust. Act like the sum is already correct (below).
2650 }
2654 "have unconstrained inline-size; this should only "
2655 "result from very large sizes, not attempts at "
2661 computedISizeCBWM;
2663 // The sum is already correct
2665 }
2667 // Determine the start and end margin values. The isize value
2668 // remains constant while we do this.
2670 // Calculate how much space is available for margins
2673 // If the available margin space is negative, then don't follow the
2674 // usual overconstraint rules.
2679 }
2681 // The css2 spec clearly defines how block elements should behave
2682 // in section 10.3.3.
2687 // Neither margin is 'auto' so we're over constrained. Use the
2688 // 'direction' property of the parent to tell which margin to
2689 // ignore
2690 // First check if there is an HTML alignment that we should honor
2692 mParentReflowInput
2704 }
2705 }
2706 // Otherwise apply the CSS rules, and ignore one margin by forcing
2707 // it to 'auto', depending on 'direction'.
2710 }
2711 }
2713 // Logic which is common to blocks and tables
2714 // The computed margins need not be zero because the 'auto' could come from
2715 // overconstraint or from HTML alignment so values need to be accumulated
2719 // Both margins are 'auto' so the computed addition should be equal
2725 }
2728 }
2732 // Update the UsedMargin property if we were tracking it already.
2736 }
2737 }
2738 }
2740 // For "normal" we use the font's normal line height (em height + leading).
2741 // If both internal leading and external leading specified by font itself are
2742 // zeros, we should compensate this by creating extra (external) leading.
2743 // This is necessary because without this compensation, normal line height might
2744 // look too tight.
2753 }
2755 }
2766 }
2768 }
2771 // For factor units the computed value of the line-height property
2772 // is found by multiplying the factor by the font's computed size
2773 // (adjusted for min-size prefs and text zoom).
2777 }
2782 }
2792 }
2793 // If we don't have a pres context, use a 1.2em fallback.
2796 }
2801 }
2811 }
2818 // Setting used line height can change a frame's block-size if mFrame's
2819 // block-size behaves as auto.
2821 }
2822 }
2824 /* static */
2828 nscoord aBlockBSize,
2835 }
2841 nscoord lineHeight =
2849 // For Web-compatibility, single-line text input elements cannot
2850 // have a line-height smaller than 'normal'.
2857 }
2858 }
2859 }
2862 }
2865 nscoord aPercentBasis,
2866 LayoutFrameType aFrameType) {
2867 // SVG text frames have no margin.
2870 }
2873 // Table frame's margin is inherited to the table wrapper frame via the
2874 // ::-moz-table-wrapper rule in ua.css, so don't set any margins for it.
2877 }
2879 // If style style can provide us the margin directly, then use it.
2882 nsMargin margin;
2885 // We have to compute the value. Note that this calculation is
2886 // performed according to the writing mode of the containing block
2887 // (http://dev.w3.org/csswg/css-writing-modes-3/#orthogonal-flows)
2890 }
2905 }
2907 // ... but font-size-inflation-based margin adjustment uses the
2908 // frame's writing mode
2915 }
2918 }
2921 nscoord aPercentBasis,
2922 LayoutFrameType aFrameType) {
2923 // If style can provide us the padding directly, then use it.
2925 nsMargin padding;
2927 // a table row/col group, row/col doesn't have padding
2928 // XXXldb Neither do border-collapse tables.
2935 // We have to compute the value. This calculation is performed
2936 // according to the writing mode of the containing block
2937 // (http://dev.w3.org/csswg/css-writing-modes-3/#orthogonal-flows)
2938 // clamp negative calc() results to 0
2941 }
2961 }
2963 }
2979 // Convert themed widget's physical dimensions to logical coords.
2980 minWidgetSize = {
2983 // GetMinimumWidgetSize() returns border-box; we need content-box.
2985 }
2987 // NOTE: min-width:auto resolves to 0, except on a flex item. (But
2988 // even there, it's supposed to be ignored (i.e. treated as 0) until
2989 // the flex container explicitly resolves & considers it.)
2995 }
2999 }
3002 // Specified value of 'none'
3007 }
3009 // If the computed value of 'min-width' is greater than the value of
3010 // 'max-width', 'max-width' is set to the value of 'min-width'
3013 }
3015 // Check for percentage based values and a containing block height that
3016 // depends on the content height. Treat them like the initial value.
3017 // Likewise, check for calc() with percentages on internal table elements;
3018 // that's treated as the initial value too.
3024 }
3027 }
3029 };
3031 // NOTE: min-height:auto resolves to 0, except on a flex item. (But
3032 // even there, it's supposed to be ignored (i.e. treated as 0) until
3033 // the flex container explicitly resolves & considers it.)
3040 }
3044 }
3047 // Specified value of 'none'
3053 }
3055 // If the computed value of 'min-height' is greater than the value of
3056 // 'max-height', 'max-height' is set to the value of 'min-height'
3059 }
3060 }
3065 }