summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsBlockReflowContext.cpp
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/generic/nsBlockReflowContext.cpp
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/generic/nsBlockReflowContext.cpp')
-rw-r--r--layout/generic/nsBlockReflowContext.cpp464
1 files changed, 464 insertions, 0 deletions
diff --git a/layout/generic/nsBlockReflowContext.cpp b/layout/generic/nsBlockReflowContext.cpp
new file mode 100644
index 000000000..3be74c929
--- /dev/null
+++ b/layout/generic/nsBlockReflowContext.cpp
@@ -0,0 +1,464 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+// vim:cindent:ts=2:et:sw=2:
+/* 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& aParentRS)
+ : mPresContext(aPresContext),
+ mOuterReflowInput(aParentRS),
+ mSpace(aParentRS.GetWritingMode()),
+ mMetrics(aParentRS)
+{
+}
+
+static nsIFrame* DescendIntoBlockLevelFrame(nsIFrame* aFrame)
+{
+ nsIAtom* type = aFrame->GetType();
+ if (type == nsGkAtoms::columnSetFrame) {
+ 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 (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus)) {
+ 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 (!NS_INLINE_IS_BREAK_BEFORE(aFrameReflowStatus) ||
+ (mFrame->GetStateBits() & NS_FRAME_OUT_OF_FLOW)) {
+ // 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 (and may end up wanting
+ // a next-in-flow where it ends up), unless it is an out of flow frame.
+ if (NS_FRAME_IS_FULLY_COMPLETE(aFrameReflowStatus)) {
+ nsIFrame* kidNextInFlow = mFrame->GetNextInFlow();
+ if (nullptr != kidNextInFlow) {
+ // 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,
+ nsReflowStatus aReflowStatus)
+{
+ // Compute collapsed block-end margin value.
+ WritingMode wm = aReflowInput.GetWritingMode();
+ WritingMode parentWM = mMetrics.GetWritingMode();
+ if (NS_FRAME_IS_COMPLETE(aReflowStatus)) {
+ 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,
+ nsDidReflowStatus::FINISHED);
+ 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;
+}