forked from mirrors/gecko-dev
463 lines
18 KiB
C++
463 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
|
|
#undef NOISY_MAX_ELEMENT_SIZE
|
|
#undef REALLY_NOISY_MAX_ELEMENT_SIZE
|
|
#undef NOISY_BLOCK_DIR_MARGINS
|
|
#else
|
|
#undef NOISY_MAX_ELEMENT_SIZE
|
|
#undef REALLY_NOISY_MAX_ELEMENT_SIZE
|
|
#undef 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_BLOCKDIR_MARGINS
|
|
nsFrame::ListTag(stdout, aRI.mFrame);
|
|
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 = nsLayoutUtils::GetAsBlock(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
|
|
// state for it.
|
|
|
|
// We may have to construct an extra reflow state 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 state.
|
|
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_BLOCKDIR_MARGINS
|
|
nsFrame::ListTag(stdout, aRI.mFrame);
|
|
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_BLOCKDIR_MARGINS
|
|
nsFrame::ListTag(stdout, mOuterReflowInput.mFrame);
|
|
printf(": reflowing ");
|
|
nsFrame::ListTag(stdout, mFrame);
|
|
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;
|
|
}
|
|
} else {
|
|
if (NS_UNCONSTRAINEDSIZE != aFrameRI.AvailableBSize()) {
|
|
aFrameRI.AvailableBSize() -= mBStartMargin.get() + aClearance;
|
|
}
|
|
}
|
|
} 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: ");
|
|
nsFrame::ListTag(stdout, mFrame);
|
|
printf(" metrics=%d,%d!\n",
|
|
mMetrics.ISize(mWritingMode), mMetrics.BSize(mWritingMode));
|
|
}
|
|
if ((mMetrics.ISize(mWritingMode) == nscoord(0xdeadbeef)) ||
|
|
(mMetrics.BSize(mWritingMode) == nscoord(0xdeadbeef))) {
|
|
printf("nsBlockReflowContext: ");
|
|
nsFrame::ListTag(stdout, mFrame);
|
|
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();
|
|
if (aReflowStatus.IsComplete()) {
|
|
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_BLOCKDIR_MARGINS
|
|
printf(" ");
|
|
nsFrame::ListTag(stdout, mOuterReflowInput.mFrame);
|
|
printf(": ");
|
|
nsFrame::ListTag(stdout, mFrame);
|
|
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);
|
|
|
|
WritingMode frameWM = mFrame->GetWritingMode();
|
|
LogicalPoint logPos =
|
|
LogicalPoint(mWritingMode, mICoord, mBCoord).
|
|
ConvertTo(frameWM, mWritingMode,
|
|
mContainerSize - mMetrics.PhysicalSize());
|
|
|
|
// ApplyRelativePositioning in right-to-left writing modes needs to
|
|
// know the updated frame width
|
|
mFrame->SetSize(mWritingMode, mMetrics.Size(mWritingMode));
|
|
aReflowInput.ApplyRelativePositioning(&logPos, mContainerSize);
|
|
|
|
// Now place the frame and complete the reflow process
|
|
nsContainerFrame::FinishReflowChild(mFrame, mPresContext, mMetrics,
|
|
&aReflowInput, frameWM, logPos,
|
|
mContainerSize, 0);
|
|
|
|
aOverflowAreas = mMetrics.mOverflowAreas + mFrame->GetPosition();
|
|
|
|
return true;
|
|
}
|