mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-20 00:35:44 +00:00
c64c145dd4
Currently, when using ReflowChildFlags::ApplyRelativePositioning flag in FinishReflowChild(), we (implicitly) force the callers to pass aWM and aPos in the same writing-mode as the reflow input, i.e. the child's writing-mode. This results in an unintuitive LogicalPoint conversion `mContainerSize - mMetrics.PhysicalSize()` in nsBlockReflowContext::PlaceBlock(). We should allow the callers to use their preferred aWM and aPos (either in parent's wm or child's wm), and do the necessary conversion in FinishReflowChild() (like we did to convert aDesiredSize from ReflowOutput's wm to aWM). Also, correct the documentation for aWM in ReflowChild() and FinishReflowChild(). aWM doesn't need to be the containing frame's writing-mode. It can be any as long as it is the writing-mode that aPos is used. Differential Revision: https://phabricator.services.mozilla.com/D65859 --HG-- extra : moz-landing-system : lando
442 lines
18 KiB
C++
442 lines
18 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/* class that a parent frame uses to reflow a block frame */
|
|
|
|
#include "nsBlockReflowContext.h"
|
|
#include "BlockReflowInput.h"
|
|
#include "nsFloatManager.h"
|
|
#include "nsColumnSetFrame.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsBlockFrame.h"
|
|
#include "nsLineBox.h"
|
|
#include "nsLayoutUtils.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
#ifdef DEBUG
|
|
# include "nsBlockDebugFlags.h" // For NOISY_BLOCK_DIR_MARGINS
|
|
#endif
|
|
|
|
nsBlockReflowContext::nsBlockReflowContext(nsPresContext* aPresContext,
|
|
const ReflowInput& aParentRI)
|
|
: mPresContext(aPresContext),
|
|
mOuterReflowInput(aParentRI),
|
|
mFrame(nullptr),
|
|
mSpace(aParentRI.GetWritingMode()),
|
|
mICoord(0),
|
|
mBCoord(0),
|
|
mMetrics(aParentRI) {}
|
|
|
|
static nsIFrame* DescendIntoBlockLevelFrame(nsIFrame* aFrame) {
|
|
LayoutFrameType type = aFrame->Type();
|
|
if (type == LayoutFrameType::ColumnSet) {
|
|
static_cast<nsColumnSetFrame*>(aFrame)->DrainOverflowColumns();
|
|
nsIFrame* child = aFrame->PrincipalChildList().FirstChild();
|
|
if (child) {
|
|
return DescendIntoBlockLevelFrame(child);
|
|
}
|
|
}
|
|
return aFrame;
|
|
}
|
|
|
|
bool nsBlockReflowContext::ComputeCollapsedBStartMargin(
|
|
const ReflowInput& aRI, nsCollapsingMargin* aMargin,
|
|
nsIFrame* aClearanceFrame, bool* aMayNeedRetry, bool* aBlockIsEmpty) {
|
|
WritingMode wm = aRI.GetWritingMode();
|
|
WritingMode parentWM = mMetrics.GetWritingMode();
|
|
|
|
// Include block-start element of frame's margin
|
|
aMargin->Include(
|
|
aRI.ComputedLogicalMargin().ConvertTo(parentWM, wm).BStart(parentWM));
|
|
|
|
// The inclusion of the block-end margin when empty is done by the caller
|
|
// since it doesn't need to be done by the top-level (non-recursive)
|
|
// caller.
|
|
|
|
#ifdef NOISY_BLOCK_DIR_MARGINS
|
|
aRI.mFrame->ListTag(stdout);
|
|
printf(": %d => %d\n", aRI.ComputedLogicalMargin().BStart(wm),
|
|
aMargin->get());
|
|
#endif
|
|
|
|
bool dirtiedLine = false;
|
|
bool setBlockIsEmpty = false;
|
|
|
|
// Calculate the frame's generational block-start-margin from its child
|
|
// blocks. Note that if the frame has a non-zero block-start-border or
|
|
// block-start-padding then this step is skipped because it will be a margin
|
|
// root. It is also skipped if the frame is a margin root for other
|
|
// reasons.
|
|
nsIFrame* frame = DescendIntoBlockLevelFrame(aRI.mFrame);
|
|
nsPresContext* prescontext = frame->PresContext();
|
|
nsBlockFrame* block = nullptr;
|
|
if (0 == aRI.ComputedLogicalBorderPadding().BStart(wm)) {
|
|
block = do_QueryFrame(frame);
|
|
if (block) {
|
|
bool bStartMarginRoot, unused;
|
|
block->IsMarginRoot(&bStartMarginRoot, &unused);
|
|
if (bStartMarginRoot) {
|
|
block = nullptr;
|
|
}
|
|
}
|
|
}
|
|
|
|
// iterate not just through the lines of 'block' but also its
|
|
// overflow lines and the normal and overflow lines of its next in
|
|
// flows. Note that this will traverse some frames more than once:
|
|
// for example, if A contains B and A->nextinflow contains
|
|
// B->nextinflow, we'll traverse B->nextinflow twice. But this is
|
|
// OK because our traversal is idempotent.
|
|
for (; block; block = static_cast<nsBlockFrame*>(block->GetNextInFlow())) {
|
|
for (int overflowLines = 0; overflowLines <= 1; ++overflowLines) {
|
|
nsBlockFrame::LineIterator line;
|
|
nsBlockFrame::LineIterator line_end;
|
|
bool anyLines = true;
|
|
if (overflowLines) {
|
|
nsBlockFrame::FrameLines* frames = block->GetOverflowLines();
|
|
nsLineList* lines = frames ? &frames->mLines : nullptr;
|
|
if (!lines) {
|
|
anyLines = false;
|
|
} else {
|
|
line = lines->begin();
|
|
line_end = lines->end();
|
|
}
|
|
} else {
|
|
line = block->LinesBegin();
|
|
line_end = block->LinesEnd();
|
|
}
|
|
for (; anyLines && line != line_end; ++line) {
|
|
if (!aClearanceFrame && line->HasClearance()) {
|
|
// If we don't have a clearance frame, then we're computing
|
|
// the collapsed margin in the first pass, assuming that all
|
|
// lines have no clearance. So clear their clearance flags.
|
|
line->ClearHasClearance();
|
|
line->MarkDirty();
|
|
dirtiedLine = true;
|
|
}
|
|
|
|
bool isEmpty;
|
|
if (line->IsInline()) {
|
|
isEmpty = line->IsEmpty();
|
|
} else {
|
|
nsIFrame* kid = line->mFirstChild;
|
|
if (kid == aClearanceFrame) {
|
|
line->SetHasClearance();
|
|
line->MarkDirty();
|
|
dirtiedLine = true;
|
|
if (!setBlockIsEmpty && aBlockIsEmpty) {
|
|
setBlockIsEmpty = true;
|
|
*aBlockIsEmpty = false;
|
|
}
|
|
goto done;
|
|
}
|
|
// Here is where we recur. Now that we have determined that a
|
|
// generational collapse is required we need to compute the
|
|
// child blocks margin and so in so that we can look into
|
|
// it. For its margins to be computed we need to have a reflow
|
|
// input for it.
|
|
|
|
// We may have to construct an extra reflow input here if
|
|
// we drilled down through a block wrapper. At the moment
|
|
// we can only drill down one level so we only have to support
|
|
// one extra reflow input.
|
|
const ReflowInput* outerReflowInput = &aRI;
|
|
if (frame != aRI.mFrame) {
|
|
NS_ASSERTION(frame->GetParent() == aRI.mFrame,
|
|
"Can only drill through one level of block wrapper");
|
|
LogicalSize availSpace = aRI.ComputedSize(frame->GetWritingMode());
|
|
outerReflowInput =
|
|
new ReflowInput(prescontext, aRI, frame, availSpace);
|
|
}
|
|
{
|
|
LogicalSize availSpace =
|
|
outerReflowInput->ComputedSize(kid->GetWritingMode());
|
|
ReflowInput innerReflowInput(prescontext, *outerReflowInput, kid,
|
|
availSpace);
|
|
// Record that we're being optimistic by assuming the kid
|
|
// has no clearance
|
|
if (kid->StyleDisplay()->mBreakType != StyleClear::None ||
|
|
!nsBlockFrame::BlockCanIntersectFloats(kid)) {
|
|
*aMayNeedRetry = true;
|
|
}
|
|
if (ComputeCollapsedBStartMargin(innerReflowInput, aMargin,
|
|
aClearanceFrame, aMayNeedRetry,
|
|
&isEmpty)) {
|
|
line->MarkDirty();
|
|
dirtiedLine = true;
|
|
}
|
|
if (isEmpty) {
|
|
WritingMode innerWM = innerReflowInput.GetWritingMode();
|
|
LogicalMargin innerMargin =
|
|
innerReflowInput.ComputedLogicalMargin().ConvertTo(parentWM,
|
|
innerWM);
|
|
aMargin->Include(innerMargin.BEnd(parentWM));
|
|
}
|
|
}
|
|
if (outerReflowInput != &aRI) {
|
|
delete const_cast<ReflowInput*>(outerReflowInput);
|
|
}
|
|
}
|
|
if (!isEmpty) {
|
|
if (!setBlockIsEmpty && aBlockIsEmpty) {
|
|
setBlockIsEmpty = true;
|
|
*aBlockIsEmpty = false;
|
|
}
|
|
goto done;
|
|
}
|
|
}
|
|
if (!setBlockIsEmpty && aBlockIsEmpty) {
|
|
// The first time we reach here is when this is the first block
|
|
// and we have processed all its normal lines.
|
|
setBlockIsEmpty = true;
|
|
// All lines are empty, or we wouldn't be here!
|
|
*aBlockIsEmpty = aRI.mFrame->IsSelfEmpty();
|
|
}
|
|
}
|
|
}
|
|
done:
|
|
|
|
if (!setBlockIsEmpty && aBlockIsEmpty) {
|
|
*aBlockIsEmpty = aRI.mFrame->IsEmpty();
|
|
}
|
|
|
|
#ifdef NOISY_BLOCK_DIR_MARGINS
|
|
aRI.mFrame->ListTag(stdout);
|
|
printf(": => %d\n", aMargin->get());
|
|
#endif
|
|
|
|
return dirtiedLine;
|
|
}
|
|
|
|
void nsBlockReflowContext::ReflowBlock(
|
|
const LogicalRect& aSpace, bool aApplyBStartMargin,
|
|
nsCollapsingMargin& aPrevMargin, nscoord aClearance,
|
|
bool aIsAdjacentWithBStart, nsLineBox* aLine, ReflowInput& aFrameRI,
|
|
nsReflowStatus& aFrameReflowStatus, BlockReflowInput& aState) {
|
|
mFrame = aFrameRI.mFrame;
|
|
mWritingMode = aState.mReflowInput.GetWritingMode();
|
|
mContainerSize = aState.ContainerSize();
|
|
mSpace = aSpace;
|
|
|
|
if (!aIsAdjacentWithBStart) {
|
|
aFrameRI.mFlags.mIsTopOfPage = false; // make sure this is cleared
|
|
}
|
|
|
|
if (aApplyBStartMargin) {
|
|
mBStartMargin = aPrevMargin;
|
|
|
|
#ifdef NOISY_BLOCK_DIR_MARGINS
|
|
mOuterReflowInput.mFrame->ListTag(stdout);
|
|
printf(": reflowing ");
|
|
mFrame->ListTag(stdout);
|
|
printf(" margin => %d, clearance => %d\n", mBStartMargin.get(), aClearance);
|
|
#endif
|
|
|
|
// Adjust the available size if it's constrained so that the
|
|
// child frame doesn't think it can reflow into its margin area.
|
|
if (mWritingMode.IsOrthogonalTo(mFrame->GetWritingMode())) {
|
|
if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableISize()) {
|
|
aFrameRI.AvailableISize() -= mBStartMargin.get() + aClearance;
|
|
aFrameRI.AvailableISize() = std::max(0, aFrameRI.AvailableISize());
|
|
}
|
|
} else {
|
|
if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableBSize()) {
|
|
aFrameRI.AvailableBSize() -= mBStartMargin.get() + aClearance;
|
|
aFrameRI.AvailableBSize() = std::max(0, aFrameRI.AvailableBSize());
|
|
}
|
|
}
|
|
} else {
|
|
// nsBlockFrame::ReflowBlock might call us multiple times with
|
|
// *different* values of aApplyBStartMargin.
|
|
mBStartMargin.Zero();
|
|
}
|
|
|
|
nscoord tI = 0, tB = 0;
|
|
// The values of x and y do not matter for floats, so don't bother
|
|
// calculating them. Floats are guaranteed to have their own float
|
|
// manager, so tI and tB don't matter. mICoord and mBCoord don't
|
|
// matter becacuse they are only used in PlaceBlock, which is not used
|
|
// for floats.
|
|
if (aLine) {
|
|
// Compute inline/block coordinate where reflow will begin. Use the
|
|
// rules from 10.3.3 to determine what to apply. At this point in the
|
|
// reflow auto inline-start/end margins will have a zero value.
|
|
|
|
WritingMode frameWM = aFrameRI.GetWritingMode();
|
|
LogicalMargin usedMargin =
|
|
aFrameRI.ComputedLogicalMargin().ConvertTo(mWritingMode, frameWM);
|
|
mICoord = mSpace.IStart(mWritingMode) + usedMargin.IStart(mWritingMode);
|
|
mBCoord = mSpace.BStart(mWritingMode) + mBStartMargin.get() + aClearance;
|
|
|
|
LogicalRect space(
|
|
mWritingMode, mICoord, mBCoord,
|
|
mSpace.ISize(mWritingMode) - usedMargin.IStartEnd(mWritingMode),
|
|
mSpace.BSize(mWritingMode) - usedMargin.BStartEnd(mWritingMode));
|
|
tI = space.LineLeft(mWritingMode, mContainerSize);
|
|
tB = mBCoord;
|
|
|
|
if ((mFrame->GetStateBits() & NS_BLOCK_FLOAT_MGR) == 0)
|
|
aFrameRI.mBlockDelta =
|
|
mOuterReflowInput.mBlockDelta + mBCoord - aLine->BStart();
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
mMetrics.ISize(mWritingMode) = nscoord(0xdeadbeef);
|
|
mMetrics.BSize(mWritingMode) = nscoord(0xdeadbeef);
|
|
#endif
|
|
|
|
mOuterReflowInput.mFloatManager->Translate(tI, tB);
|
|
mFrame->Reflow(mPresContext, mMetrics, aFrameRI, aFrameReflowStatus);
|
|
mOuterReflowInput.mFloatManager->Translate(-tI, -tB);
|
|
|
|
#ifdef DEBUG
|
|
if (!aFrameReflowStatus.IsInlineBreakBefore()) {
|
|
if ((CRAZY_SIZE(mMetrics.ISize(mWritingMode)) ||
|
|
CRAZY_SIZE(mMetrics.BSize(mWritingMode))) &&
|
|
!mFrame->GetParent()->IsCrazySizeAssertSuppressed()) {
|
|
printf("nsBlockReflowContext: ");
|
|
mFrame->ListTag(stdout);
|
|
printf(" metrics=%d,%d!\n", mMetrics.ISize(mWritingMode),
|
|
mMetrics.BSize(mWritingMode));
|
|
}
|
|
if ((mMetrics.ISize(mWritingMode) == nscoord(0xdeadbeef)) ||
|
|
(mMetrics.BSize(mWritingMode) == nscoord(0xdeadbeef))) {
|
|
printf("nsBlockReflowContext: ");
|
|
mFrame->ListTag(stdout);
|
|
printf(" didn't set i/b %d,%d!\n", mMetrics.ISize(mWritingMode),
|
|
mMetrics.BSize(mWritingMode));
|
|
}
|
|
}
|
|
#endif
|
|
|
|
if (!mFrame->HasOverflowAreas()) {
|
|
mMetrics.SetOverflowAreasToDesiredBounds();
|
|
}
|
|
|
|
if (!aFrameReflowStatus.IsInlineBreakBefore() &&
|
|
aFrameReflowStatus.IsFullyComplete()) {
|
|
// If frame is complete and has a next-in-flow, we need to delete
|
|
// them now. Do not do this when a break-before is signaled because
|
|
// the frame is going to get reflowed again (whether the frame is
|
|
// (in)complete is undefined in that case anyway).
|
|
if (nsIFrame* kidNextInFlow = mFrame->GetNextInFlow()) {
|
|
// Remove all of the childs next-in-flows. Make sure that we ask
|
|
// the right parent to do the removal (it's possible that the
|
|
// parent is not this because we are executing pullup code).
|
|
// Floats will eventually be removed via nsBlockFrame::RemoveFloat
|
|
// which detaches the placeholder from the float.
|
|
nsOverflowContinuationTracker::AutoFinish fini(aState.mOverflowTracker,
|
|
mFrame);
|
|
kidNextInFlow->GetParent()->DeleteNextInFlowChild(kidNextInFlow, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* Attempt to place the block frame within the available space. If
|
|
* it fits, apply inline-dir ("horizontal") positioning (CSS 10.3.3),
|
|
* collapse margins (CSS2 8.3.1). Also apply relative positioning.
|
|
*/
|
|
bool nsBlockReflowContext::PlaceBlock(const ReflowInput& aReflowInput,
|
|
bool aForceFit, nsLineBox* aLine,
|
|
nsCollapsingMargin& aBEndMarginResult,
|
|
nsOverflowAreas& aOverflowAreas,
|
|
const nsReflowStatus& aReflowStatus) {
|
|
// Compute collapsed block-end margin value.
|
|
WritingMode wm = aReflowInput.GetWritingMode();
|
|
WritingMode parentWM = mMetrics.GetWritingMode();
|
|
|
|
// Don't apply the block-end margin if the block has a *later* sibling across
|
|
// column-span split.
|
|
if (aReflowStatus.IsComplete() && !mFrame->HasColumnSpanSiblings()) {
|
|
aBEndMarginResult = mMetrics.mCarriedOutBEndMargin;
|
|
aBEndMarginResult.Include(aReflowInput.ComputedLogicalMargin()
|
|
.ConvertTo(parentWM, wm)
|
|
.BEnd(parentWM));
|
|
} else {
|
|
// The used block-end-margin is set to zero before a break.
|
|
aBEndMarginResult.Zero();
|
|
}
|
|
|
|
nscoord backupContainingBlockAdvance = 0;
|
|
|
|
// Check whether the block's block-end margin collapses with its block-start
|
|
// margin. See CSS 2.1 section 8.3.1; those rules seem to match
|
|
// nsBlockFrame::IsEmpty(). Any such block must have zero block-size so
|
|
// check that first. Note that a block can have clearance and still
|
|
// have adjoining block-start/end margins, because the clearance goes
|
|
// above the block-start margin.
|
|
// Mark the frame as non-dirty; it has been reflowed (or we wouldn't
|
|
// be here), and we don't want to assert in CachedIsEmpty()
|
|
mFrame->RemoveStateBits(NS_FRAME_IS_DIRTY);
|
|
bool empty = 0 == mMetrics.BSize(parentWM) && aLine->CachedIsEmpty();
|
|
if (empty) {
|
|
// Collapse the block-end margin with the block-start margin that was
|
|
// already applied.
|
|
aBEndMarginResult.Include(mBStartMargin);
|
|
|
|
#ifdef NOISY_BLOCK_DIR_MARGINS
|
|
printf(" ");
|
|
mOuterReflowInput.mFrame->ListTag(stdout);
|
|
printf(": ");
|
|
mFrame->ListTag(stdout);
|
|
printf(
|
|
" -- collapsing block start & end margin together; BStart=%d "
|
|
"spaceBStart=%d\n",
|
|
mBCoord, mSpace.BStart(mWritingMode));
|
|
#endif
|
|
// Section 8.3.1 of CSS 2.1 says that blocks with adjoining
|
|
// "top/bottom" (i.e. block-start/end) margins whose top margin collapses
|
|
// with their parent's top margin should have their top border-edge at the
|
|
// top border-edge of their parent. We actually don't have to do
|
|
// anything special to make this happen. In that situation,
|
|
// nsBlockFrame::ShouldApplyBStartMargin will have returned false,
|
|
// and mBStartMargin and aClearance will have been zero in
|
|
// ReflowBlock.
|
|
|
|
// If we did apply our block-start margin, but now we're collapsing it
|
|
// into the block-end margin, we need to back up the containing
|
|
// block's bCoord-advance by our block-start margin so that it doesn't get
|
|
// counted twice. Note that here we're allowing the line's bounds
|
|
// to become different from the block's position; we do this
|
|
// because the containing block will place the next line at the
|
|
// line's BEnd, and it must place the next line at a different
|
|
// point from where this empty block will be.
|
|
backupContainingBlockAdvance = mBStartMargin.get();
|
|
}
|
|
|
|
// See if the frame fit. If it's the first frame or empty then it
|
|
// always fits. If the block-size is unconstrained then it always fits,
|
|
// even if there's some sort of integer overflow that makes bCoord +
|
|
// mMetrics.BSize() appear to go beyond the available block size.
|
|
if (!empty && !aForceFit &&
|
|
mSpace.BSize(mWritingMode) != NS_UNCONSTRAINEDSIZE) {
|
|
nscoord bEnd =
|
|
mBCoord - backupContainingBlockAdvance + mMetrics.BSize(mWritingMode);
|
|
if (bEnd > mSpace.BEnd(mWritingMode)) {
|
|
// didn't fit, we must acquit.
|
|
mFrame->DidReflow(mPresContext, &aReflowInput);
|
|
return false;
|
|
}
|
|
}
|
|
|
|
aLine->SetBounds(mWritingMode, mICoord,
|
|
mBCoord - backupContainingBlockAdvance,
|
|
mMetrics.ISize(mWritingMode), mMetrics.BSize(mWritingMode),
|
|
mContainerSize);
|
|
|
|
// Now place the frame and complete the reflow process
|
|
nsContainerFrame::FinishReflowChild(
|
|
mFrame, mPresContext, mMetrics, &aReflowInput, mWritingMode,
|
|
LogicalPoint(mWritingMode, mICoord, mBCoord), mContainerSize,
|
|
nsIFrame::ReflowChildFlags::ApplyRelativePositioning);
|
|
|
|
aOverflowAreas = mMetrics.mOverflowAreas + mFrame->GetPosition();
|
|
|
|
return true;
|
|
}
|