зеркало из https://github.com/mozilla/gecko-dev.git
3346 строки
128 KiB
C++
3346 строки
128 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/. */
|
|
|
|
/* state and methods used while laying out a single line of a block frame */
|
|
|
|
#include "nsLineLayout.h"
|
|
|
|
#include "mozilla/ComputedStyle.h"
|
|
|
|
#include "LayoutLogging.h"
|
|
#include "SVGTextFrame.h"
|
|
#include "nsBlockFrame.h"
|
|
#include "nsBulletFrame.h"
|
|
#include "nsFontMetrics.h"
|
|
#include "nsStyleConsts.h"
|
|
#include "nsContainerFrame.h"
|
|
#include "nsFloatManager.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsGkAtoms.h"
|
|
#include "nsIContent.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsTextFrame.h"
|
|
#include "nsStyleStructInlines.h"
|
|
#include "nsBidiPresUtils.h"
|
|
#include "nsRubyFrame.h"
|
|
#include "nsRubyTextFrame.h"
|
|
#include "RubyUtils.h"
|
|
#include <algorithm>
|
|
|
|
#ifdef DEBUG
|
|
# undef NOISY_INLINEDIR_ALIGN
|
|
# undef NOISY_BLOCKDIR_ALIGN
|
|
# undef NOISY_REFLOW
|
|
# undef REALLY_NOISY_REFLOW
|
|
# undef NOISY_PUSHING
|
|
# undef REALLY_NOISY_PUSHING
|
|
# undef NOISY_CAN_PLACE_FRAME
|
|
# undef NOISY_TRIM
|
|
# undef REALLY_NOISY_TRIM
|
|
#endif
|
|
|
|
using namespace mozilla;
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
nsLineLayout::nsLineLayout(nsPresContext* aPresContext,
|
|
nsFloatManager* aFloatManager,
|
|
const ReflowInput* aOuterReflowInput,
|
|
const nsLineList::iterator* aLine,
|
|
nsLineLayout* aBaseLineLayout)
|
|
: mPresContext(aPresContext),
|
|
mFloatManager(aFloatManager),
|
|
mBlockReflowInput(aOuterReflowInput),
|
|
mBaseLineLayout(aBaseLineLayout),
|
|
mLastOptionalBreakFrame(nullptr),
|
|
mForceBreakFrame(nullptr),
|
|
mBlockRI(nullptr), /* XXX temporary */
|
|
mLastOptionalBreakPriority(gfxBreakPriority::eNoBreak),
|
|
mLastOptionalBreakFrameOffset(-1),
|
|
mForceBreakFrameOffset(-1),
|
|
mMinLineBSize(0),
|
|
mTextIndent(0),
|
|
mMaxStartBoxBSize(0),
|
|
mMaxEndBoxBSize(0),
|
|
mFinalLineBSize(0),
|
|
mFirstLetterStyleOK(false),
|
|
mIsTopOfPage(false),
|
|
mImpactedByFloats(false),
|
|
mLastFloatWasLetterFrame(false),
|
|
mLineIsEmpty(false),
|
|
mLineEndsInBR(false),
|
|
mNeedBackup(false),
|
|
mInFirstLine(false),
|
|
mGotLineBox(false),
|
|
mInFirstLetter(false),
|
|
mHasBullet(false),
|
|
mDirtyNextLine(false),
|
|
mLineAtStart(false),
|
|
mHasRuby(false),
|
|
mSuppressLineWrap(
|
|
nsSVGUtils::IsInSVGTextSubtree(aOuterReflowInput->mFrame))
|
|
#ifdef DEBUG
|
|
,
|
|
mSpansAllocated(0),
|
|
mSpansFreed(0),
|
|
mFramesAllocated(0),
|
|
mFramesFreed(0)
|
|
#endif
|
|
{
|
|
MOZ_ASSERT(aOuterReflowInput, "aOuterReflowInput must not be null");
|
|
NS_ASSERTION(aFloatManager || aOuterReflowInput->mFrame->IsLetterFrame(),
|
|
"float manager should be present");
|
|
MOZ_ASSERT((!!mBaseLineLayout) ==
|
|
aOuterReflowInput->mFrame->IsRubyTextContainerFrame(),
|
|
"Only ruby text container frames have "
|
|
"a different base line layout");
|
|
MOZ_COUNT_CTOR(nsLineLayout);
|
|
|
|
// Stash away some style data that we need
|
|
nsBlockFrame* blockFrame = do_QueryFrame(aOuterReflowInput->mFrame);
|
|
if (blockFrame)
|
|
mStyleText = blockFrame->StyleTextForLineLayout();
|
|
else
|
|
mStyleText = aOuterReflowInput->mFrame->StyleText();
|
|
|
|
mLineNumber = 0;
|
|
mTotalPlacedFrames = 0;
|
|
mBStartEdge = 0;
|
|
mTrimmableISize = 0;
|
|
|
|
mInflationMinFontSize =
|
|
nsLayoutUtils::InflationMinFontSizeFor(aOuterReflowInput->mFrame);
|
|
|
|
// Instead of always pre-initializing the free-lists for frames and
|
|
// spans, we do it on demand so that situations that only use a few
|
|
// frames and spans won't waste a lot of time in unneeded
|
|
// initialization.
|
|
mFrameFreeList = nullptr;
|
|
mSpanFreeList = nullptr;
|
|
|
|
mCurrentSpan = mRootSpan = nullptr;
|
|
mSpanDepth = 0;
|
|
|
|
if (aLine) {
|
|
mGotLineBox = true;
|
|
mLineBox = *aLine;
|
|
}
|
|
}
|
|
|
|
nsLineLayout::~nsLineLayout() {
|
|
MOZ_COUNT_DTOR(nsLineLayout);
|
|
|
|
NS_ASSERTION(nullptr == mRootSpan, "bad line-layout user");
|
|
}
|
|
|
|
// Find out if the frame has a non-null prev-in-flow, i.e., whether it
|
|
// is a continuation.
|
|
inline bool HasPrevInFlow(nsIFrame* aFrame) {
|
|
nsIFrame* prevInFlow = aFrame->GetPrevInFlow();
|
|
return prevInFlow != nullptr;
|
|
}
|
|
|
|
void nsLineLayout::BeginLineReflow(nscoord aICoord, nscoord aBCoord,
|
|
nscoord aISize, nscoord aBSize,
|
|
bool aImpactedByFloats, bool aIsTopOfPage,
|
|
WritingMode aWritingMode,
|
|
const nsSize& aContainerSize) {
|
|
NS_ASSERTION(nullptr == mRootSpan, "bad linelayout user");
|
|
LAYOUT_WARN_IF_FALSE(aISize != NS_UNCONSTRAINEDSIZE,
|
|
"have unconstrained width; this should only result from "
|
|
"very large sizes, not attempts at intrinsic width "
|
|
"calculation");
|
|
#ifdef DEBUG
|
|
if ((aISize != NS_UNCONSTRAINEDSIZE) && CRAZY_SIZE(aISize) &&
|
|
!LineContainerFrame()->GetParent()->IsCrazySizeAssertSuppressed()) {
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": Init: bad caller: width WAS %d(0x%x)\n", aISize, aISize);
|
|
}
|
|
if ((aBSize != NS_UNCONSTRAINEDSIZE) && CRAZY_SIZE(aBSize) &&
|
|
!LineContainerFrame()->GetParent()->IsCrazySizeAssertSuppressed()) {
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": Init: bad caller: height WAS %d(0x%x)\n", aBSize, aBSize);
|
|
}
|
|
#endif
|
|
#ifdef NOISY_REFLOW
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": BeginLineReflow: %d,%d,%d,%d impacted=%s %s\n", aICoord, aBCoord,
|
|
aISize, aBSize, aImpactedByFloats ? "true" : "false",
|
|
aIsTopOfPage ? "top-of-page" : "");
|
|
#endif
|
|
#ifdef DEBUG
|
|
mSpansAllocated = mSpansFreed = mFramesAllocated = mFramesFreed = 0;
|
|
#endif
|
|
|
|
mFirstLetterStyleOK = false;
|
|
mIsTopOfPage = aIsTopOfPage;
|
|
mImpactedByFloats = aImpactedByFloats;
|
|
mTotalPlacedFrames = 0;
|
|
if (!mBaseLineLayout) {
|
|
mLineIsEmpty = true;
|
|
mLineAtStart = true;
|
|
} else {
|
|
mLineIsEmpty = false;
|
|
mLineAtStart = false;
|
|
}
|
|
mLineEndsInBR = false;
|
|
mSpanDepth = 0;
|
|
mMaxStartBoxBSize = mMaxEndBoxBSize = 0;
|
|
|
|
if (mGotLineBox) {
|
|
mLineBox->ClearHasBullet();
|
|
}
|
|
|
|
PerSpanData* psd = NewPerSpanData();
|
|
mCurrentSpan = mRootSpan = psd;
|
|
psd->mReflowInput = mBlockReflowInput;
|
|
psd->mIStart = aICoord;
|
|
psd->mICoord = aICoord;
|
|
psd->mIEnd = aICoord + aISize;
|
|
mContainerSize = aContainerSize;
|
|
|
|
mBStartEdge = aBCoord;
|
|
|
|
psd->mNoWrap = !mStyleText->WhiteSpaceCanWrapStyle() || mSuppressLineWrap;
|
|
psd->mWritingMode = aWritingMode;
|
|
|
|
// If this is the first line of a block then see if the text-indent
|
|
// property amounts to anything.
|
|
|
|
if (0 == mLineNumber && !HasPrevInFlow(mBlockReflowInput->mFrame)) {
|
|
nscoord pctBasis = mBlockReflowInput->ComputedISize();
|
|
mTextIndent = mStyleText->mTextIndent.Resolve(pctBasis);
|
|
psd->mICoord += mTextIndent;
|
|
}
|
|
|
|
PerFrameData* pfd = NewPerFrameData(mBlockReflowInput->mFrame);
|
|
pfd->mAscent = 0;
|
|
pfd->mSpan = psd;
|
|
psd->mFrame = pfd;
|
|
nsIFrame* frame = mBlockReflowInput->mFrame;
|
|
if (frame->IsRubyTextContainerFrame()) {
|
|
// Ruby text container won't be reflowed via ReflowFrame, hence the
|
|
// relative positioning information should be recorded here.
|
|
MOZ_ASSERT(mBaseLineLayout != this);
|
|
pfd->mRelativePos =
|
|
mBlockReflowInput->mStyleDisplay->IsRelativelyPositionedStyle();
|
|
if (pfd->mRelativePos) {
|
|
MOZ_ASSERT(mBlockReflowInput->GetWritingMode() == pfd->mWritingMode,
|
|
"mBlockReflowInput->frame == frame, "
|
|
"hence they should have identical writing mode");
|
|
pfd->mOffsets = mBlockReflowInput->ComputedLogicalOffsets();
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsLineLayout::EndLineReflow() {
|
|
#ifdef NOISY_REFLOW
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": EndLineReflow: width=%d\n",
|
|
mRootSpan->mICoord - mRootSpan->mIStart);
|
|
#endif
|
|
|
|
NS_ASSERTION(!mBaseLineLayout ||
|
|
(!mSpansAllocated && !mSpansFreed && !mSpanFreeList &&
|
|
!mFramesAllocated && !mFramesFreed && !mFrameFreeList),
|
|
"Allocated frames or spans on non-base line layout?");
|
|
MOZ_ASSERT(mRootSpan == mCurrentSpan);
|
|
|
|
UnlinkFrame(mRootSpan->mFrame);
|
|
mCurrentSpan = mRootSpan = nullptr;
|
|
|
|
NS_ASSERTION(mSpansAllocated == mSpansFreed, "leak");
|
|
NS_ASSERTION(mFramesAllocated == mFramesFreed, "leak");
|
|
|
|
#if 0
|
|
static int32_t maxSpansAllocated = NS_LINELAYOUT_NUM_SPANS;
|
|
static int32_t maxFramesAllocated = NS_LINELAYOUT_NUM_FRAMES;
|
|
if (mSpansAllocated > maxSpansAllocated) {
|
|
printf("XXX: saw a line with %d spans\n", mSpansAllocated);
|
|
maxSpansAllocated = mSpansAllocated;
|
|
}
|
|
if (mFramesAllocated > maxFramesAllocated) {
|
|
printf("XXX: saw a line with %d frames\n", mFramesAllocated);
|
|
maxFramesAllocated = mFramesAllocated;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
// XXX swtich to a single mAvailLineWidth that we adjust as each frame
|
|
// on the line is placed. Each span can still have a per-span mICoord that
|
|
// tracks where a child frame is going in its span; they don't need a
|
|
// per-span mIStart?
|
|
|
|
void nsLineLayout::UpdateBand(WritingMode aWM,
|
|
const LogicalRect& aNewAvailSpace,
|
|
nsIFrame* aFloatFrame) {
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
// need to convert to our writing mode, because we might have a different
|
|
// mode from the caller due to dir: auto
|
|
LogicalRect availSpace =
|
|
aNewAvailSpace.ConvertTo(lineWM, aWM, ContainerSize());
|
|
#ifdef REALLY_NOISY_REFLOW
|
|
printf(
|
|
"nsLL::UpdateBand %d, %d, %d, %d, (converted to %d, %d, %d, %d); "
|
|
"frame=%p\n will set mImpacted to true\n",
|
|
aNewAvailSpace.IStart(aWM), aNewAvailSpace.BStart(aWM),
|
|
aNewAvailSpace.ISize(aWM), aNewAvailSpace.BSize(aWM),
|
|
availSpace.IStart(lineWM), availSpace.BStart(lineWM),
|
|
availSpace.ISize(lineWM), availSpace.BSize(lineWM), aFloatFrame);
|
|
#endif
|
|
#ifdef DEBUG
|
|
if ((availSpace.ISize(lineWM) != NS_UNCONSTRAINEDSIZE) &&
|
|
CRAZY_SIZE(availSpace.ISize(lineWM)) &&
|
|
!LineContainerFrame()->GetParent()->IsCrazySizeAssertSuppressed()) {
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": UpdateBand: bad caller: ISize WAS %d(0x%x)\n",
|
|
availSpace.ISize(lineWM), availSpace.ISize(lineWM));
|
|
}
|
|
if ((availSpace.BSize(lineWM) != NS_UNCONSTRAINEDSIZE) &&
|
|
CRAZY_SIZE(availSpace.BSize(lineWM)) &&
|
|
!LineContainerFrame()->GetParent()->IsCrazySizeAssertSuppressed()) {
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": UpdateBand: bad caller: BSize WAS %d(0x%x)\n",
|
|
availSpace.BSize(lineWM), availSpace.BSize(lineWM));
|
|
}
|
|
#endif
|
|
|
|
// Compute the difference between last times width and the new width
|
|
NS_WARNING_ASSERTION(
|
|
mRootSpan->mIEnd != NS_UNCONSTRAINEDSIZE &&
|
|
availSpace.ISize(lineWM) != NS_UNCONSTRAINEDSIZE,
|
|
"have unconstrained inline size; this should only result from very large "
|
|
"sizes, not attempts at intrinsic width calculation");
|
|
// The root span's mIStart moves to aICoord
|
|
nscoord deltaICoord = availSpace.IStart(lineWM) - mRootSpan->mIStart;
|
|
// The inline size of all spans changes by this much (the root span's
|
|
// mIEnd moves to aICoord + aISize, its new inline size is aISize)
|
|
nscoord deltaISize =
|
|
availSpace.ISize(lineWM) - (mRootSpan->mIEnd - mRootSpan->mIStart);
|
|
#ifdef NOISY_REFLOW
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": UpdateBand: %d,%d,%d,%d deltaISize=%d deltaICoord=%d\n",
|
|
availSpace.IStart(lineWM), availSpace.BStart(lineWM),
|
|
availSpace.ISize(lineWM), availSpace.BSize(lineWM), deltaISize,
|
|
deltaICoord);
|
|
#endif
|
|
|
|
// Update the root span position
|
|
mRootSpan->mIStart += deltaICoord;
|
|
mRootSpan->mIEnd += deltaICoord;
|
|
mRootSpan->mICoord += deltaICoord;
|
|
|
|
// Now update the right edges of the open spans to account for any
|
|
// change in available space width
|
|
for (PerSpanData* psd = mCurrentSpan; psd; psd = psd->mParent) {
|
|
psd->mIEnd += deltaISize;
|
|
psd->mContainsFloat = true;
|
|
#ifdef NOISY_REFLOW
|
|
printf(" span %p: oldIEnd=%d newIEnd=%d\n", psd, psd->mIEnd - deltaISize,
|
|
psd->mIEnd);
|
|
#endif
|
|
}
|
|
NS_ASSERTION(mRootSpan->mContainsFloat &&
|
|
mRootSpan->mIStart == availSpace.IStart(lineWM) &&
|
|
mRootSpan->mIEnd == availSpace.IEnd(lineWM),
|
|
"root span was updated incorrectly?");
|
|
|
|
// Update frame bounds
|
|
// Note: Only adjust the outermost frames (the ones that are direct
|
|
// children of the block), not the ones in the child spans. The reason
|
|
// is simple: the frames in the spans have coordinates local to their
|
|
// parent therefore they are moved when their parent span is moved.
|
|
if (deltaICoord != 0) {
|
|
for (PerFrameData* pfd = mRootSpan->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
pfd->mBounds.IStart(lineWM) += deltaICoord;
|
|
}
|
|
}
|
|
|
|
mBStartEdge = availSpace.BStart(lineWM);
|
|
mImpactedByFloats = true;
|
|
|
|
mLastFloatWasLetterFrame = aFloatFrame->IsLetterFrame();
|
|
}
|
|
|
|
nsLineLayout::PerSpanData* nsLineLayout::NewPerSpanData() {
|
|
nsLineLayout* outerLineLayout = GetOutermostLineLayout();
|
|
PerSpanData* psd = outerLineLayout->mSpanFreeList;
|
|
if (!psd) {
|
|
void* mem = outerLineLayout->mArena.Allocate(sizeof(PerSpanData));
|
|
psd = reinterpret_cast<PerSpanData*>(mem);
|
|
} else {
|
|
outerLineLayout->mSpanFreeList = psd->mNextFreeSpan;
|
|
}
|
|
psd->mParent = nullptr;
|
|
psd->mFrame = nullptr;
|
|
psd->mFirstFrame = nullptr;
|
|
psd->mLastFrame = nullptr;
|
|
psd->mContainsFloat = false;
|
|
psd->mHasNonemptyContent = false;
|
|
|
|
#ifdef DEBUG
|
|
outerLineLayout->mSpansAllocated++;
|
|
#endif
|
|
return psd;
|
|
}
|
|
|
|
void nsLineLayout::BeginSpan(nsIFrame* aFrame,
|
|
const ReflowInput* aSpanReflowInput,
|
|
nscoord aIStart, nscoord aIEnd,
|
|
nscoord* aBaseline) {
|
|
NS_ASSERTION(aIEnd != NS_UNCONSTRAINEDSIZE,
|
|
"should no longer be using unconstrained sizes");
|
|
#ifdef NOISY_REFLOW
|
|
nsFrame::IndentBy(stdout, mSpanDepth + 1);
|
|
aFrame->ListTag(stdout);
|
|
printf(": BeginSpan leftEdge=%d rightEdge=%d\n", aIStart, aIEnd);
|
|
#endif
|
|
|
|
PerSpanData* psd = NewPerSpanData();
|
|
// Link up span frame's pfd to point to its child span data
|
|
PerFrameData* pfd = mCurrentSpan->mLastFrame;
|
|
NS_ASSERTION(pfd->mFrame == aFrame, "huh?");
|
|
pfd->mSpan = psd;
|
|
|
|
// Init new span
|
|
psd->mFrame = pfd;
|
|
psd->mParent = mCurrentSpan;
|
|
psd->mReflowInput = aSpanReflowInput;
|
|
psd->mIStart = aIStart;
|
|
psd->mICoord = aIStart;
|
|
psd->mIEnd = aIEnd;
|
|
psd->mBaseline = aBaseline;
|
|
|
|
nsIFrame* frame = aSpanReflowInput->mFrame;
|
|
psd->mNoWrap = !frame->StyleText()->WhiteSpaceCanWrap(frame) ||
|
|
mSuppressLineWrap || frame->Style()->ShouldSuppressLineBreak();
|
|
psd->mWritingMode = aSpanReflowInput->GetWritingMode();
|
|
|
|
// Switch to new span
|
|
mCurrentSpan = psd;
|
|
mSpanDepth++;
|
|
}
|
|
|
|
nscoord nsLineLayout::EndSpan(nsIFrame* aFrame) {
|
|
NS_ASSERTION(mSpanDepth > 0, "end-span without begin-span");
|
|
#ifdef NOISY_REFLOW
|
|
nsFrame::IndentBy(stdout, mSpanDepth);
|
|
aFrame->ListTag(stdout);
|
|
printf(": EndSpan width=%d\n", mCurrentSpan->mICoord - mCurrentSpan->mIStart);
|
|
#endif
|
|
PerSpanData* psd = mCurrentSpan;
|
|
MOZ_ASSERT(psd->mParent, "We never call this on the root");
|
|
|
|
if (psd->mNoWrap && !psd->mParent->mNoWrap) {
|
|
FlushNoWrapFloats();
|
|
}
|
|
|
|
nscoord iSizeResult = psd->mLastFrame ? (psd->mICoord - psd->mIStart) : 0;
|
|
|
|
mSpanDepth--;
|
|
mCurrentSpan->mReflowInput = nullptr; // no longer valid so null it out!
|
|
mCurrentSpan = mCurrentSpan->mParent;
|
|
return iSizeResult;
|
|
}
|
|
|
|
void nsLineLayout::AttachFrameToBaseLineLayout(PerFrameData* aFrame) {
|
|
MOZ_ASSERT(mBaseLineLayout,
|
|
"This method must not be called in a base line layout.");
|
|
|
|
PerFrameData* baseFrame = mBaseLineLayout->LastFrame();
|
|
MOZ_ASSERT(aFrame && baseFrame);
|
|
MOZ_ASSERT(!aFrame->mIsLinkedToBase,
|
|
"The frame must not have been linked with the base");
|
|
#ifdef DEBUG
|
|
LayoutFrameType baseType = baseFrame->mFrame->Type();
|
|
LayoutFrameType annotationType = aFrame->mFrame->Type();
|
|
MOZ_ASSERT((baseType == LayoutFrameType::RubyBaseContainer &&
|
|
annotationType == LayoutFrameType::RubyTextContainer) ||
|
|
(baseType == LayoutFrameType::RubyBase &&
|
|
annotationType == LayoutFrameType::RubyText));
|
|
#endif
|
|
|
|
aFrame->mNextAnnotation = baseFrame->mNextAnnotation;
|
|
baseFrame->mNextAnnotation = aFrame;
|
|
aFrame->mIsLinkedToBase = true;
|
|
}
|
|
|
|
int32_t nsLineLayout::GetCurrentSpanCount() const {
|
|
NS_ASSERTION(mCurrentSpan == mRootSpan, "bad linelayout user");
|
|
int32_t count = 0;
|
|
PerFrameData* pfd = mRootSpan->mFirstFrame;
|
|
while (nullptr != pfd) {
|
|
count++;
|
|
pfd = pfd->mNext;
|
|
}
|
|
return count;
|
|
}
|
|
|
|
void nsLineLayout::SplitLineTo(int32_t aNewCount) {
|
|
NS_ASSERTION(mCurrentSpan == mRootSpan, "bad linelayout user");
|
|
|
|
#ifdef REALLY_NOISY_PUSHING
|
|
printf("SplitLineTo %d (current count=%d); before:\n", aNewCount,
|
|
GetCurrentSpanCount());
|
|
DumpPerSpanData(mRootSpan, 1);
|
|
#endif
|
|
PerSpanData* psd = mRootSpan;
|
|
PerFrameData* pfd = psd->mFirstFrame;
|
|
while (nullptr != pfd) {
|
|
if (--aNewCount == 0) {
|
|
// Truncate list at pfd (we keep pfd, but anything following is freed)
|
|
PerFrameData* next = pfd->mNext;
|
|
pfd->mNext = nullptr;
|
|
psd->mLastFrame = pfd;
|
|
|
|
// Now unlink all of the frames following pfd
|
|
UnlinkFrame(next);
|
|
break;
|
|
}
|
|
pfd = pfd->mNext;
|
|
}
|
|
#ifdef NOISY_PUSHING
|
|
printf("SplitLineTo %d (current count=%d); after:\n", aNewCount,
|
|
GetCurrentSpanCount());
|
|
DumpPerSpanData(mRootSpan, 1);
|
|
#endif
|
|
}
|
|
|
|
void nsLineLayout::PushFrame(nsIFrame* aFrame) {
|
|
PerSpanData* psd = mCurrentSpan;
|
|
NS_ASSERTION(psd->mLastFrame->mFrame == aFrame, "pushing non-last frame");
|
|
|
|
#ifdef REALLY_NOISY_PUSHING
|
|
nsFrame::IndentBy(stdout, mSpanDepth);
|
|
printf("PushFrame %p, before:\n", psd);
|
|
DumpPerSpanData(psd, 1);
|
|
#endif
|
|
|
|
// Take the last frame off of the span's frame list
|
|
PerFrameData* pfd = psd->mLastFrame;
|
|
if (pfd == psd->mFirstFrame) {
|
|
// We are pushing away the only frame...empty the list
|
|
psd->mFirstFrame = nullptr;
|
|
psd->mLastFrame = nullptr;
|
|
} else {
|
|
PerFrameData* prevFrame = pfd->mPrev;
|
|
prevFrame->mNext = nullptr;
|
|
psd->mLastFrame = prevFrame;
|
|
}
|
|
|
|
// Now unlink the frame
|
|
MOZ_ASSERT(!pfd->mNext);
|
|
UnlinkFrame(pfd);
|
|
#ifdef NOISY_PUSHING
|
|
nsFrame::IndentBy(stdout, mSpanDepth);
|
|
printf("PushFrame: %p after:\n", psd);
|
|
DumpPerSpanData(psd, 1);
|
|
#endif
|
|
}
|
|
|
|
void nsLineLayout::UnlinkFrame(PerFrameData* pfd) {
|
|
while (nullptr != pfd) {
|
|
PerFrameData* next = pfd->mNext;
|
|
if (pfd->mIsLinkedToBase) {
|
|
// This frame is linked to a ruby base, and should not be freed
|
|
// now. Just unlink it from the span. It will be freed when its
|
|
// base frame gets unlinked.
|
|
pfd->mNext = pfd->mPrev = nullptr;
|
|
pfd = next;
|
|
continue;
|
|
}
|
|
|
|
// It is a ruby base frame. If there are any annotations
|
|
// linked to this frame, free them first.
|
|
PerFrameData* annotationPFD = pfd->mNextAnnotation;
|
|
while (annotationPFD) {
|
|
PerFrameData* nextAnnotation = annotationPFD->mNextAnnotation;
|
|
MOZ_ASSERT(
|
|
annotationPFD->mNext == nullptr && annotationPFD->mPrev == nullptr,
|
|
"PFD in annotations should have been unlinked.");
|
|
FreeFrame(annotationPFD);
|
|
annotationPFD = nextAnnotation;
|
|
}
|
|
|
|
FreeFrame(pfd);
|
|
pfd = next;
|
|
}
|
|
}
|
|
|
|
void nsLineLayout::FreeFrame(PerFrameData* pfd) {
|
|
if (nullptr != pfd->mSpan) {
|
|
FreeSpan(pfd->mSpan);
|
|
}
|
|
nsLineLayout* outerLineLayout = GetOutermostLineLayout();
|
|
pfd->mNext = outerLineLayout->mFrameFreeList;
|
|
outerLineLayout->mFrameFreeList = pfd;
|
|
#ifdef DEBUG
|
|
outerLineLayout->mFramesFreed++;
|
|
#endif
|
|
}
|
|
|
|
void nsLineLayout::FreeSpan(PerSpanData* psd) {
|
|
// Unlink its frames
|
|
UnlinkFrame(psd->mFirstFrame);
|
|
|
|
nsLineLayout* outerLineLayout = GetOutermostLineLayout();
|
|
// Now put the span on the free list since it's free too
|
|
psd->mNextFreeSpan = outerLineLayout->mSpanFreeList;
|
|
outerLineLayout->mSpanFreeList = psd;
|
|
#ifdef DEBUG
|
|
outerLineLayout->mSpansFreed++;
|
|
#endif
|
|
}
|
|
|
|
bool nsLineLayout::IsZeroBSize() {
|
|
PerSpanData* psd = mCurrentSpan;
|
|
PerFrameData* pfd = psd->mFirstFrame;
|
|
while (nullptr != pfd) {
|
|
if (0 != pfd->mBounds.BSize(psd->mWritingMode)) {
|
|
return false;
|
|
}
|
|
pfd = pfd->mNext;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
nsLineLayout::PerFrameData* nsLineLayout::NewPerFrameData(nsIFrame* aFrame) {
|
|
nsLineLayout* outerLineLayout = GetOutermostLineLayout();
|
|
PerFrameData* pfd = outerLineLayout->mFrameFreeList;
|
|
if (!pfd) {
|
|
void* mem = outerLineLayout->mArena.Allocate(sizeof(PerFrameData));
|
|
pfd = reinterpret_cast<PerFrameData*>(mem);
|
|
} else {
|
|
outerLineLayout->mFrameFreeList = pfd->mNext;
|
|
}
|
|
pfd->mSpan = nullptr;
|
|
pfd->mNext = nullptr;
|
|
pfd->mPrev = nullptr;
|
|
pfd->mNextAnnotation = nullptr;
|
|
pfd->mFrame = aFrame;
|
|
|
|
// all flags default to false
|
|
pfd->mRelativePos = false;
|
|
pfd->mIsTextFrame = false;
|
|
pfd->mIsNonEmptyTextFrame = false;
|
|
pfd->mIsNonWhitespaceTextFrame = false;
|
|
pfd->mIsLetterFrame = false;
|
|
pfd->mRecomputeOverflow = false;
|
|
pfd->mIsBullet = false;
|
|
pfd->mSkipWhenTrimmingWhitespace = false;
|
|
pfd->mIsEmpty = false;
|
|
pfd->mIsPlaceholder = false;
|
|
pfd->mIsLinkedToBase = false;
|
|
|
|
pfd->mWritingMode = aFrame->GetWritingMode();
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
pfd->mBounds = LogicalRect(lineWM);
|
|
pfd->mOverflowAreas.Clear();
|
|
pfd->mMargin = LogicalMargin(lineWM);
|
|
pfd->mBorderPadding = LogicalMargin(lineWM);
|
|
pfd->mOffsets = LogicalMargin(pfd->mWritingMode);
|
|
|
|
pfd->mJustificationInfo = JustificationInfo();
|
|
pfd->mJustificationAssignment = JustificationAssignment();
|
|
|
|
#ifdef DEBUG
|
|
pfd->mBlockDirAlign = 0xFF;
|
|
outerLineLayout->mFramesAllocated++;
|
|
#endif
|
|
return pfd;
|
|
}
|
|
|
|
bool nsLineLayout::LineIsBreakable() const {
|
|
// XXX mTotalPlacedFrames should go away and we should just use
|
|
// mLineIsEmpty here instead
|
|
if ((0 != mTotalPlacedFrames) || mImpactedByFloats) {
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
// Checks all four sides for percentage units. This means it should
|
|
// only be used for things (margin, padding) where percentages on top
|
|
// and bottom depend on the *width* just like percentages on left and
|
|
// right.
|
|
template <typename T>
|
|
static bool HasPercentageUnitSide(const StyleRect<T>& aSides) {
|
|
return aSides.Any([](const auto& aLength) { return aLength.HasPercent(); });
|
|
}
|
|
|
|
static bool IsPercentageAware(const nsIFrame* aFrame, WritingMode aWM) {
|
|
NS_ASSERTION(aFrame, "null frame is not allowed");
|
|
|
|
LayoutFrameType fType = aFrame->Type();
|
|
if (fType == LayoutFrameType::Text) {
|
|
// None of these things can ever be true for text frames.
|
|
return false;
|
|
}
|
|
|
|
// Some of these things don't apply to non-replaced inline frames
|
|
// (that is, fType == LayoutFrameType::Inline), but we won't bother making
|
|
// things unnecessarily complicated, since they'll probably be set
|
|
// quite rarely.
|
|
|
|
const nsStyleMargin* margin = aFrame->StyleMargin();
|
|
if (HasPercentageUnitSide(margin->mMargin)) {
|
|
return true;
|
|
}
|
|
|
|
const nsStylePadding* padding = aFrame->StylePadding();
|
|
if (HasPercentageUnitSide(padding->mPadding)) {
|
|
return true;
|
|
}
|
|
|
|
// Note that borders can't be aware of percentages
|
|
|
|
const nsStylePosition* pos = aFrame->StylePosition();
|
|
|
|
if ((pos->ISizeDependsOnContainer(aWM) && !pos->ISize(aWM).IsAuto()) ||
|
|
pos->MaxISizeDependsOnContainer(aWM) ||
|
|
pos->MinISizeDependsOnContainer(aWM) ||
|
|
pos->OffsetHasPercent(aWM.IsVertical() ? eSideBottom : eSideRight) ||
|
|
pos->OffsetHasPercent(aWM.IsVertical() ? eSideTop : eSideLeft)) {
|
|
return true;
|
|
}
|
|
|
|
if (pos->ISize(aWM).IsAuto()) {
|
|
// We need to check for frames that shrink-wrap when they're auto
|
|
// width.
|
|
const nsStyleDisplay* disp = aFrame->StyleDisplay();
|
|
if (disp->mDisplay == StyleDisplay::InlineBlock ||
|
|
disp->mDisplay == StyleDisplay::InlineTable ||
|
|
fType == LayoutFrameType::HTMLButtonControl ||
|
|
fType == LayoutFrameType::GfxButtonControl ||
|
|
fType == LayoutFrameType::FieldSet ||
|
|
fType == LayoutFrameType::ComboboxDisplay) {
|
|
return true;
|
|
}
|
|
|
|
// Per CSS 2.1, section 10.3.2:
|
|
// If 'height' and 'width' both have computed values of 'auto' and
|
|
// the element has an intrinsic ratio but no intrinsic height or
|
|
// width and the containing block's width does not itself depend
|
|
// on the replaced element's width, then the used value of 'width'
|
|
// is calculated from the constraint equation used for
|
|
// block-level, non-replaced elements in normal flow.
|
|
nsIFrame* f = const_cast<nsIFrame*>(aFrame);
|
|
if (f->GetIntrinsicRatio() != nsSize(0, 0) &&
|
|
// Some percents are treated like 'auto', so check != coord
|
|
!pos->BSize(aWM).ConvertsToLength()) {
|
|
const IntrinsicSize& intrinsicSize = f->GetIntrinsicSize();
|
|
if (intrinsicSize.width.GetUnit() == eStyleUnit_None &&
|
|
intrinsicSize.height.GetUnit() == eStyleUnit_None) {
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
void nsLineLayout::ReflowFrame(nsIFrame* aFrame, nsReflowStatus& aReflowStatus,
|
|
ReflowOutput* aMetrics, bool& aPushedFrame) {
|
|
// Initialize OUT parameter
|
|
aPushedFrame = false;
|
|
|
|
PerFrameData* pfd = NewPerFrameData(aFrame);
|
|
PerSpanData* psd = mCurrentSpan;
|
|
psd->AppendFrame(pfd);
|
|
|
|
#ifdef REALLY_NOISY_REFLOW
|
|
nsFrame::IndentBy(stdout, mSpanDepth);
|
|
printf("%p: Begin ReflowFrame pfd=%p ", psd, pfd);
|
|
aFrame->ListTag(stdout);
|
|
printf("\n");
|
|
#endif
|
|
|
|
if (mCurrentSpan == mRootSpan) {
|
|
pfd->mFrame->RemoveProperty(nsIFrame::LineBaselineOffset());
|
|
} else {
|
|
#ifdef DEBUG
|
|
bool hasLineOffset;
|
|
pfd->mFrame->GetProperty(nsIFrame::LineBaselineOffset(), &hasLineOffset);
|
|
NS_ASSERTION(!hasLineOffset,
|
|
"LineBaselineOffset was set but was not expected");
|
|
#endif
|
|
}
|
|
|
|
mJustificationInfo = JustificationInfo();
|
|
|
|
// Stash copies of some of the computed state away for later
|
|
// (block-direction alignment, for example)
|
|
WritingMode frameWM = pfd->mWritingMode;
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
|
|
// NOTE: While the inline direction coordinate remains relative to the
|
|
// parent span, the block direction coordinate is fixed at the top
|
|
// edge for the line. During VerticalAlignFrames we will repair this
|
|
// so that the block direction coordinate is properly set and relative
|
|
// to the appropriate span.
|
|
pfd->mBounds.IStart(lineWM) = psd->mICoord;
|
|
pfd->mBounds.BStart(lineWM) = mBStartEdge;
|
|
|
|
// We want to guarantee that we always make progress when
|
|
// formatting. Therefore, if the object being placed on the line is
|
|
// too big for the line, but it is the only thing on the line and is not
|
|
// impacted by a float, then we go ahead and place it anyway. (If the line
|
|
// is impacted by one or more floats, then it is safe to break because
|
|
// we can move the line down below float(s).)
|
|
//
|
|
// Capture this state *before* we reflow the frame in case it clears
|
|
// the state out. We need to know how to treat the current frame
|
|
// when breaking.
|
|
bool notSafeToBreak = LineIsEmpty() && !mImpactedByFloats;
|
|
|
|
// Figure out whether we're talking about a textframe here
|
|
LayoutFrameType frameType = aFrame->Type();
|
|
const bool isText = frameType == LayoutFrameType::Text;
|
|
|
|
// Inline-ish and text-ish things don't compute their width;
|
|
// everything else does. We need to give them an available width that
|
|
// reflects the space left on the line.
|
|
LAYOUT_WARN_IF_FALSE(psd->mIEnd != NS_UNCONSTRAINEDSIZE,
|
|
"have unconstrained width; this should only result from "
|
|
"very large sizes, not attempts at intrinsic width "
|
|
"calculation");
|
|
nscoord availableSpaceOnLine = psd->mIEnd - psd->mICoord;
|
|
|
|
// Setup reflow state for reflowing the frame
|
|
Maybe<ReflowInput> reflowInputHolder;
|
|
if (!isText) {
|
|
// Compute the available size for the frame. This available width
|
|
// includes room for the side margins.
|
|
// For now, set the available block-size to unconstrained always.
|
|
LogicalSize availSize = mBlockReflowInput->ComputedSize(frameWM);
|
|
availSize.BSize(frameWM) = NS_UNCONSTRAINEDSIZE;
|
|
reflowInputHolder.emplace(mPresContext, *psd->mReflowInput, aFrame,
|
|
availSize);
|
|
ReflowInput& reflowInput = *reflowInputHolder;
|
|
reflowInput.mLineLayout = this;
|
|
reflowInput.mFlags.mIsTopOfPage = mIsTopOfPage;
|
|
if (reflowInput.ComputedISize() == NS_UNCONSTRAINEDSIZE) {
|
|
reflowInput.AvailableISize() = availableSpaceOnLine;
|
|
}
|
|
WritingMode stateWM = reflowInput.GetWritingMode();
|
|
pfd->mMargin =
|
|
reflowInput.ComputedLogicalMargin().ConvertTo(lineWM, stateWM);
|
|
pfd->mBorderPadding =
|
|
reflowInput.ComputedLogicalBorderPadding().ConvertTo(lineWM, stateWM);
|
|
pfd->mRelativePos =
|
|
reflowInput.mStyleDisplay->IsRelativelyPositionedStyle();
|
|
if (pfd->mRelativePos) {
|
|
pfd->mOffsets =
|
|
reflowInput.ComputedLogicalOffsets().ConvertTo(frameWM, stateWM);
|
|
}
|
|
|
|
// Calculate whether the the frame should have a start margin and
|
|
// subtract the margin from the available width if necessary.
|
|
// The margin will be applied to the starting inline coordinates of
|
|
// the frame in CanPlaceFrame() after reflowing the frame.
|
|
AllowForStartMargin(pfd, reflowInput);
|
|
}
|
|
// if isText(), no need to propagate NS_FRAME_IS_DIRTY from the parent,
|
|
// because reflow doesn't look at the dirty bits on the frame being reflowed.
|
|
|
|
// See if this frame depends on the inline-size of its containing block.
|
|
// If so, disable resize reflow optimizations for the line. (Note that,
|
|
// to be conservative, we do this if we *try* to fit a frame on a
|
|
// line, even if we don't succeed.) (Note also that we can only make
|
|
// this IsPercentageAware check *after* we've constructed our
|
|
// ReflowInput, because that construction may be what forces aFrame
|
|
// to lazily initialize its (possibly-percent-valued) intrinsic size.)
|
|
if (mGotLineBox && IsPercentageAware(aFrame, lineWM)) {
|
|
mLineBox->DisableResizeReflowOptimization();
|
|
}
|
|
|
|
// Note that we don't bother positioning the frame yet, because we're probably
|
|
// going to end up moving it when we do the block-direction alignment.
|
|
|
|
// Adjust float manager coordinate system for the frame.
|
|
ReflowOutput reflowOutput(lineWM);
|
|
#ifdef DEBUG
|
|
reflowOutput.ISize(lineWM) = nscoord(0xdeadbeef);
|
|
reflowOutput.BSize(lineWM) = nscoord(0xdeadbeef);
|
|
#endif
|
|
nscoord tI = pfd->mBounds.LineLeft(lineWM, ContainerSize());
|
|
nscoord tB = pfd->mBounds.BStart(lineWM);
|
|
mFloatManager->Translate(tI, tB);
|
|
|
|
int32_t savedOptionalBreakOffset;
|
|
gfxBreakPriority savedOptionalBreakPriority;
|
|
nsIFrame* savedOptionalBreakFrame = GetLastOptionalBreakPosition(
|
|
&savedOptionalBreakOffset, &savedOptionalBreakPriority);
|
|
|
|
if (!isText) {
|
|
aFrame->Reflow(mPresContext, reflowOutput, *reflowInputHolder,
|
|
aReflowStatus);
|
|
} else {
|
|
static_cast<nsTextFrame*>(aFrame)->ReflowText(
|
|
*this, availableSpaceOnLine,
|
|
psd->mReflowInput->mRenderingContext->GetDrawTarget(), reflowOutput,
|
|
aReflowStatus);
|
|
}
|
|
|
|
pfd->mJustificationInfo = mJustificationInfo;
|
|
mJustificationInfo = JustificationInfo();
|
|
|
|
// See if the frame is a placeholderFrame and if it is process
|
|
// the float. At the same time, check if the frame has any non-collapsed-away
|
|
// content.
|
|
bool placedFloat = false;
|
|
bool isEmpty;
|
|
if (frameType == LayoutFrameType::None) {
|
|
isEmpty = pfd->mFrame->IsEmpty();
|
|
} else {
|
|
if (LayoutFrameType::Placeholder == frameType) {
|
|
isEmpty = true;
|
|
pfd->mIsPlaceholder = true;
|
|
pfd->mSkipWhenTrimmingWhitespace = true;
|
|
nsIFrame* outOfFlowFrame = nsLayoutUtils::GetFloatFromPlaceholder(aFrame);
|
|
if (outOfFlowFrame) {
|
|
if (psd->mNoWrap &&
|
|
// We can always place floats in an empty line.
|
|
!LineIsEmpty() &&
|
|
// We always place floating letter frames. This kinda sucks. They'd
|
|
// usually fall into the LineIsEmpty() check anyway, except when
|
|
// there's something like a bullet before or what not. We actually
|
|
// need to place them now, because they're pretty nasty and they
|
|
// create continuations that are in flow and not a kid of the
|
|
// previous continuation's parent. We don't want the deferred reflow
|
|
// of the letter frame to kill a continuation after we've stored it
|
|
// in the line layout data structures. See bug 1490281 to fix the
|
|
// underlying issue. When that's fixed this check should be removed.
|
|
!outOfFlowFrame->IsLetterFrame() &&
|
|
!GetOutermostLineLayout()->mBlockRI->mFlags.mCanHaveTextOverflow) {
|
|
// We'll do this at the next break opportunity.
|
|
RecordNoWrapFloat(outOfFlowFrame);
|
|
} else {
|
|
placedFloat = TryToPlaceFloat(outOfFlowFrame);
|
|
}
|
|
}
|
|
} else if (isText) {
|
|
// Note non-empty text-frames for inline frame compatibility hackery
|
|
pfd->mIsTextFrame = true;
|
|
nsTextFrame* textFrame = static_cast<nsTextFrame*>(pfd->mFrame);
|
|
isEmpty = !textFrame->HasNoncollapsedCharacters();
|
|
if (!isEmpty) {
|
|
pfd->mIsNonEmptyTextFrame = true;
|
|
nsIContent* content = textFrame->GetContent();
|
|
|
|
const nsTextFragment* frag = content->GetText();
|
|
if (frag) {
|
|
pfd->mIsNonWhitespaceTextFrame = !content->TextIsOnlyWhitespace();
|
|
}
|
|
}
|
|
} else if (LayoutFrameType::Br == frameType) {
|
|
pfd->mSkipWhenTrimmingWhitespace = true;
|
|
isEmpty = false;
|
|
} else {
|
|
if (LayoutFrameType::Letter == frameType) {
|
|
pfd->mIsLetterFrame = true;
|
|
}
|
|
if (pfd->mSpan) {
|
|
isEmpty =
|
|
!pfd->mSpan->mHasNonemptyContent && pfd->mFrame->IsSelfEmpty();
|
|
} else {
|
|
isEmpty = pfd->mFrame->IsEmpty();
|
|
}
|
|
}
|
|
}
|
|
pfd->mIsEmpty = isEmpty;
|
|
|
|
mFloatManager->Translate(-tI, -tB);
|
|
|
|
NS_ASSERTION(reflowOutput.ISize(lineWM) >= 0, "bad inline size");
|
|
NS_ASSERTION(reflowOutput.BSize(lineWM) >= 0, "bad block size");
|
|
if (reflowOutput.ISize(lineWM) < 0) {
|
|
reflowOutput.ISize(lineWM) = 0;
|
|
}
|
|
if (reflowOutput.BSize(lineWM) < 0) {
|
|
reflowOutput.BSize(lineWM) = 0;
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
// Note: break-before means ignore the reflow metrics since the
|
|
// frame will be reflowed another time.
|
|
if (!aReflowStatus.IsInlineBreakBefore()) {
|
|
if ((CRAZY_SIZE(reflowOutput.ISize(lineWM)) ||
|
|
CRAZY_SIZE(reflowOutput.BSize(lineWM))) &&
|
|
!LineContainerFrame()->GetParent()->IsCrazySizeAssertSuppressed()) {
|
|
printf("nsLineLayout: ");
|
|
aFrame->ListTag(stdout);
|
|
printf(" metrics=%d,%d!\n", reflowOutput.Width(), reflowOutput.Height());
|
|
}
|
|
if ((reflowOutput.Width() == nscoord(0xdeadbeef)) ||
|
|
(reflowOutput.Height() == nscoord(0xdeadbeef))) {
|
|
printf("nsLineLayout: ");
|
|
aFrame->ListTag(stdout);
|
|
printf(" didn't set w/h %d,%d!\n", reflowOutput.Width(),
|
|
reflowOutput.Height());
|
|
}
|
|
}
|
|
#endif
|
|
|
|
// Unlike with non-inline reflow, the overflow area here does *not*
|
|
// include the accumulation of the frame's bounds and its inline
|
|
// descendants' bounds. Nor does it include the outline area; it's
|
|
// just the union of the bounds of any absolute children. That is
|
|
// added in later by nsLineLayout::ReflowInlineFrames.
|
|
pfd->mOverflowAreas = reflowOutput.mOverflowAreas;
|
|
|
|
pfd->mBounds.ISize(lineWM) = reflowOutput.ISize(lineWM);
|
|
pfd->mBounds.BSize(lineWM) = reflowOutput.BSize(lineWM);
|
|
|
|
// Size the frame, but |RelativePositionFrames| will size the view.
|
|
aFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd));
|
|
|
|
// Tell the frame that we're done reflowing it
|
|
aFrame->DidReflow(mPresContext, isText ? nullptr : reflowInputHolder.ptr());
|
|
|
|
if (aMetrics) {
|
|
*aMetrics = reflowOutput;
|
|
}
|
|
|
|
if (!aReflowStatus.IsInlineBreakBefore()) {
|
|
// 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).
|
|
if (aReflowStatus.IsComplete()) {
|
|
nsIFrame* kidNextInFlow = aFrame->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)
|
|
kidNextInFlow->GetParent()->DeleteNextInFlowChild(kidNextInFlow, true);
|
|
}
|
|
}
|
|
|
|
// Check whether this frame breaks up text runs. All frames break up text
|
|
// runs (hence return false here) except for text frames and inline
|
|
// containers.
|
|
bool continuingTextRun = aFrame->CanContinueTextRun();
|
|
|
|
// Clear any residual mTrimmableISize if this isn't a text frame
|
|
if (!continuingTextRun && !pfd->mSkipWhenTrimmingWhitespace) {
|
|
mTrimmableISize = 0;
|
|
}
|
|
|
|
// See if we can place the frame. If we can't fit it, then we
|
|
// return now.
|
|
bool optionalBreakAfterFits;
|
|
NS_ASSERTION(isText || !reflowInputHolder->IsFloating(),
|
|
"How'd we get a floated inline frame? "
|
|
"The frame ctor should've dealt with this.");
|
|
if (CanPlaceFrame(pfd, notSafeToBreak, continuingTextRun,
|
|
savedOptionalBreakFrame != nullptr, reflowOutput,
|
|
aReflowStatus, &optionalBreakAfterFits)) {
|
|
if (!isEmpty) {
|
|
psd->mHasNonemptyContent = true;
|
|
mLineIsEmpty = false;
|
|
if (!pfd->mSpan) {
|
|
// nonempty leaf content has been placed
|
|
mLineAtStart = false;
|
|
}
|
|
if (LayoutFrameType::Ruby == frameType) {
|
|
mHasRuby = true;
|
|
SyncAnnotationBounds(pfd);
|
|
}
|
|
}
|
|
|
|
// Place the frame, updating aBounds with the final size and
|
|
// location. Then apply the bottom+right margins (as
|
|
// appropriate) to the frame.
|
|
PlaceFrame(pfd, reflowOutput);
|
|
PerSpanData* span = pfd->mSpan;
|
|
if (span) {
|
|
// The frame we just finished reflowing is an inline
|
|
// container. It needs its child frames aligned in the block direction,
|
|
// so do most of it now.
|
|
VerticalAlignFrames(span);
|
|
}
|
|
|
|
if (!continuingTextRun && !psd->mNoWrap) {
|
|
if (!LineIsEmpty() || placedFloat) {
|
|
// record soft break opportunity after this content that can't be
|
|
// part of a text run. This is not a text frame so we know
|
|
// that offset INT32_MAX means "after the content".
|
|
if (NotifyOptionalBreakPosition(aFrame, INT32_MAX,
|
|
optionalBreakAfterFits,
|
|
gfxBreakPriority::eNormalBreak)) {
|
|
// If this returns true then we are being told to actually break
|
|
// here.
|
|
aReflowStatus.SetInlineLineBreakAfter();
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
PushFrame(aFrame);
|
|
aPushedFrame = true;
|
|
// Undo any saved break positions that the frame might have told us about,
|
|
// since we didn't end up placing it
|
|
RestoreSavedBreakPosition(savedOptionalBreakFrame,
|
|
savedOptionalBreakOffset,
|
|
savedOptionalBreakPriority);
|
|
}
|
|
} else {
|
|
PushFrame(aFrame);
|
|
aPushedFrame = true;
|
|
}
|
|
|
|
#ifdef REALLY_NOISY_REFLOW
|
|
nsFrame::IndentBy(stdout, mSpanDepth);
|
|
printf("End ReflowFrame ");
|
|
aFrame->ListTag(stdout);
|
|
printf(" status=%x\n", aReflowStatus);
|
|
#endif
|
|
}
|
|
|
|
void nsLineLayout::AllowForStartMargin(PerFrameData* pfd,
|
|
ReflowInput& aReflowInput) {
|
|
NS_ASSERTION(!aReflowInput.IsFloating(),
|
|
"How'd we get a floated inline frame? "
|
|
"The frame ctor should've dealt with this.");
|
|
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
|
|
// Only apply start-margin on the first-in flow for inline frames,
|
|
// and make sure to not apply it to any inline other than the first
|
|
// in an ib split. Note that the ib sibling (block-in-inline
|
|
// sibling) annotations only live on the first continuation, but we
|
|
// don't want to apply the start margin for later continuations
|
|
// anyway. For box-decoration-break:clone we apply the start-margin
|
|
// on all continuations.
|
|
if ((pfd->mFrame->GetPrevContinuation() ||
|
|
pfd->mFrame->FrameIsNonFirstInIBSplit()) &&
|
|
aReflowInput.mStyleBorder->mBoxDecorationBreak ==
|
|
StyleBoxDecorationBreak::Slice) {
|
|
// Zero this out so that when we compute the max-element-width of
|
|
// the frame we will properly avoid adding in the starting margin.
|
|
pfd->mMargin.IStart(lineWM) = 0;
|
|
} else if (NS_UNCONSTRAINEDSIZE == aReflowInput.ComputedISize()) {
|
|
NS_WARNING_ASSERTION(
|
|
NS_UNCONSTRAINEDSIZE != aReflowInput.AvailableISize(),
|
|
"have unconstrained inline-size; this should only result from very "
|
|
"large sizes, not attempts at intrinsic inline-size calculation");
|
|
// For inline-ish and text-ish things (which don't compute widths
|
|
// in the reflow state), adjust available inline-size to account
|
|
// for the start margin. The end margin will be accounted for when
|
|
// we finish flowing the frame.
|
|
WritingMode wm = aReflowInput.GetWritingMode();
|
|
aReflowInput.AvailableISize() -=
|
|
pfd->mMargin.ConvertTo(wm, lineWM).IStart(wm);
|
|
}
|
|
}
|
|
|
|
nscoord nsLineLayout::GetCurrentFrameInlineDistanceFromBlock() {
|
|
PerSpanData* psd;
|
|
nscoord x = 0;
|
|
for (psd = mCurrentSpan; psd; psd = psd->mParent) {
|
|
x += psd->mICoord;
|
|
}
|
|
return x;
|
|
}
|
|
|
|
/**
|
|
* This method syncs bounds of ruby annotations and ruby annotation
|
|
* containers from their rect. It is necessary because:
|
|
* Containers are not part of the line in their levels, which means
|
|
* their bounds are not set properly before.
|
|
* Ruby annotations' position may have been changed when reflowing
|
|
* their containers.
|
|
*/
|
|
void nsLineLayout::SyncAnnotationBounds(PerFrameData* aRubyFrame) {
|
|
MOZ_ASSERT(aRubyFrame->mFrame->IsRubyFrame());
|
|
MOZ_ASSERT(aRubyFrame->mSpan);
|
|
|
|
PerSpanData* span = aRubyFrame->mSpan;
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
for (PerFrameData* pfd = span->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
for (PerFrameData* rtc = pfd->mNextAnnotation; rtc;
|
|
rtc = rtc->mNextAnnotation) {
|
|
if (lineWM.IsOrthogonalTo(rtc->mFrame->GetWritingMode())) {
|
|
// Inter-character case: don't attempt to sync annotation bounds.
|
|
continue;
|
|
}
|
|
// When the annotation container is reflowed, the width of the
|
|
// ruby container is unknown so we use a dummy container size;
|
|
// in the case of RTL block direction, the final position will be
|
|
// fixed up later.
|
|
const nsSize dummyContainerSize;
|
|
LogicalRect rtcBounds(lineWM, rtc->mFrame->GetRect(), dummyContainerSize);
|
|
rtc->mBounds = rtcBounds;
|
|
nsSize rtcSize = rtcBounds.Size(lineWM).GetPhysicalSize(lineWM);
|
|
for (PerFrameData* rt = rtc->mSpan->mFirstFrame; rt; rt = rt->mNext) {
|
|
LogicalRect rtBounds = rt->mFrame->GetLogicalRect(lineWM, rtcSize);
|
|
MOZ_ASSERT(rt->mBounds.Size(lineWM) == rtBounds.Size(lineWM),
|
|
"Size of the annotation should not have been changed");
|
|
rt->mBounds.SetOrigin(lineWM, rtBounds.Origin(lineWM));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* See if the frame can be placed now that we know it's desired size.
|
|
* We can always place the frame if the line is empty. Note that we
|
|
* know that the reflow-status is not a break-before because if it was
|
|
* ReflowFrame above would have returned false, preventing this method
|
|
* from being called. The logic in this method assumes that.
|
|
*
|
|
* Note that there is no check against the Y coordinate because we
|
|
* assume that the caller will take care of that.
|
|
*/
|
|
bool nsLineLayout::CanPlaceFrame(PerFrameData* pfd, bool aNotSafeToBreak,
|
|
bool aFrameCanContinueTextRun,
|
|
bool aCanRollBackBeforeFrame,
|
|
ReflowOutput& aMetrics,
|
|
nsReflowStatus& aStatus,
|
|
bool* aOptionalBreakAfterFits) {
|
|
MOZ_ASSERT(pfd && pfd->mFrame, "bad args, null pointers for frame data");
|
|
|
|
*aOptionalBreakAfterFits = true;
|
|
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
/*
|
|
* We want to only apply the end margin if we're the last continuation and
|
|
* either not in an {ib} split or the last inline in it. In all other
|
|
* cases we want to zero it out. That means zeroing it out if any of these
|
|
* conditions hold:
|
|
* 1) The frame is not complete (in this case it will get a next-in-flow)
|
|
* 2) The frame is complete but has a non-fluid continuation on its
|
|
* continuation chain. Note that if it has a fluid continuation, that
|
|
* continuation will get destroyed later, so we don't want to drop the
|
|
* end-margin in that case.
|
|
* 3) The frame is in an {ib} split and is not the last part.
|
|
*
|
|
* However, none of that applies if this is a letter frame (XXXbz why?)
|
|
*
|
|
* For box-decoration-break:clone we apply the end margin on all
|
|
* continuations (that are not letter frames).
|
|
*/
|
|
if ((aStatus.IsIncomplete() ||
|
|
pfd->mFrame->LastInFlow()->GetNextContinuation() ||
|
|
pfd->mFrame->FrameIsNonLastInIBSplit()) &&
|
|
!pfd->mIsLetterFrame &&
|
|
pfd->mFrame->StyleBorder()->mBoxDecorationBreak ==
|
|
StyleBoxDecorationBreak::Slice) {
|
|
pfd->mMargin.IEnd(lineWM) = 0;
|
|
}
|
|
|
|
// Apply the start margin to the frame bounds.
|
|
nscoord startMargin = pfd->mMargin.IStart(lineWM);
|
|
nscoord endMargin = pfd->mMargin.IEnd(lineWM);
|
|
|
|
pfd->mBounds.IStart(lineWM) += startMargin;
|
|
|
|
PerSpanData* psd = mCurrentSpan;
|
|
if (psd->mNoWrap) {
|
|
// When wrapping is off, everything fits.
|
|
return true;
|
|
}
|
|
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
if (nullptr != psd->mFrame) {
|
|
psd->mFrame->mFrame->ListTag(stdout);
|
|
}
|
|
printf(": aNotSafeToBreak=%s frame=", aNotSafeToBreak ? "true" : "false");
|
|
pfd->mFrame->ListTag(stdout);
|
|
printf(" frameWidth=%d, margins=%d,%d\n",
|
|
pfd->mBounds.IEnd(lineWM) + endMargin - psd->mICoord, startMargin,
|
|
endMargin);
|
|
#endif
|
|
|
|
// Set outside to true if the result of the reflow leads to the
|
|
// frame sticking outside of our available area.
|
|
bool outside =
|
|
pfd->mBounds.IEnd(lineWM) - mTrimmableISize + endMargin > psd->mIEnd;
|
|
if (!outside) {
|
|
// If it fits, it fits
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
printf(" ==> inside\n");
|
|
#endif
|
|
return true;
|
|
}
|
|
*aOptionalBreakAfterFits = false;
|
|
|
|
// When it doesn't fit, check for a few special conditions where we
|
|
// allow it to fit anyway.
|
|
if (0 == startMargin + pfd->mBounds.ISize(lineWM) + endMargin) {
|
|
// Empty frames always fit right where they are
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
printf(" ==> empty frame fits\n");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// another special case: always place a BR
|
|
if (pfd->mFrame->IsBrFrame()) {
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
printf(" ==> BR frame fits\n");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
if (aNotSafeToBreak) {
|
|
// There are no frames on the line that take up width and the line is
|
|
// not impacted by floats, so we must allow the current frame to be
|
|
// placed on the line
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
printf(" ==> not-safe and not-impacted fits: ");
|
|
while (nullptr != psd) {
|
|
printf("<psd=%p x=%d left=%d> ", psd, psd->mICoord, psd->mIStart);
|
|
psd = psd->mParent;
|
|
}
|
|
printf("\n");
|
|
#endif
|
|
return true;
|
|
}
|
|
|
|
// Special check for span frames
|
|
if (pfd->mSpan && pfd->mSpan->mContainsFloat) {
|
|
// If the span either directly or indirectly contains a float then
|
|
// it fits. Why? It's kind of complicated, but here goes:
|
|
//
|
|
// 1. CanPlaceFrame is used for all frame placements on a line,
|
|
// and in a span. This includes recursively placement of frames
|
|
// inside of spans, and the span itself. Because the logic always
|
|
// checks for room before proceeding (the code above here), the
|
|
// only things on a line will be those things that "fit".
|
|
//
|
|
// 2. Before a float is placed on a line, the line has to be empty
|
|
// (otherwise it's a "below current line" float and will be placed
|
|
// after the line).
|
|
//
|
|
// Therefore, if the span directly or indirectly has a float
|
|
// then it means that at the time of the placement of the float
|
|
// the line was empty. Because of #1, only the frames that fit can
|
|
// be added after that point, therefore we can assume that the
|
|
// current span being placed has fit.
|
|
//
|
|
// So how do we get here and have a span that should already fit
|
|
// and yet doesn't: Simple: span's that have the no-wrap attribute
|
|
// set on them and contain a float and are placed where they
|
|
// don't naturally fit.
|
|
return true;
|
|
}
|
|
|
|
if (aFrameCanContinueTextRun) {
|
|
// Let it fit, but we reserve the right to roll back.
|
|
// Note that we usually won't get here because a text frame will break
|
|
// itself to avoid exceeding the available width.
|
|
// We'll only get here for text frames that couldn't break early enough.
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
printf(" ==> placing overflowing textrun, requesting backup\n");
|
|
#endif
|
|
|
|
// We will want to try backup.
|
|
mNeedBackup = true;
|
|
return true;
|
|
}
|
|
|
|
#ifdef NOISY_CAN_PLACE_FRAME
|
|
printf(" ==> didn't fit\n");
|
|
#endif
|
|
aStatus.SetInlineLineBreakBeforeAndReset();
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Place the frame. Update running counters.
|
|
*/
|
|
void nsLineLayout::PlaceFrame(PerFrameData* pfd, ReflowOutput& aMetrics) {
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
|
|
// If the frame's block direction does not match the line's, we can't use
|
|
// its ascent; instead, treat it as a block with baseline at the block-end
|
|
// edge (or block-begin in the case of an "inverted" line).
|
|
if (pfd->mWritingMode.GetBlockDir() != lineWM.GetBlockDir()) {
|
|
pfd->mAscent = lineWM.IsLineInverted() ? 0 : aMetrics.BSize(lineWM);
|
|
} else {
|
|
if (aMetrics.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) {
|
|
pfd->mAscent = pfd->mFrame->GetLogicalBaseline(lineWM);
|
|
} else {
|
|
pfd->mAscent = aMetrics.BlockStartAscent();
|
|
}
|
|
}
|
|
|
|
// Advance to next inline coordinate
|
|
mCurrentSpan->mICoord = pfd->mBounds.IEnd(lineWM) + pfd->mMargin.IEnd(lineWM);
|
|
|
|
// Count the number of non-placeholder frames on the line...
|
|
if (pfd->mFrame->IsPlaceholderFrame()) {
|
|
NS_ASSERTION(
|
|
pfd->mBounds.ISize(lineWM) == 0 && pfd->mBounds.BSize(lineWM) == 0,
|
|
"placeholders should have 0 width/height (checking "
|
|
"placeholders were never counted by the old code in "
|
|
"this function)");
|
|
} else {
|
|
mTotalPlacedFrames++;
|
|
}
|
|
}
|
|
|
|
void nsLineLayout::AddBulletFrame(nsBulletFrame* aFrame,
|
|
const ReflowOutput& aMetrics) {
|
|
NS_ASSERTION(mCurrentSpan == mRootSpan, "bad linelayout user");
|
|
NS_ASSERTION(mGotLineBox, "must have line box");
|
|
|
|
nsBlockFrame* blockFrame = do_QueryFrame(mBlockReflowInput->mFrame);
|
|
MOZ_ASSERT(blockFrame, "must be for block");
|
|
if (!blockFrame->BulletIsEmpty()) {
|
|
mHasBullet = true;
|
|
mLineBox->SetHasBullet();
|
|
}
|
|
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
PerFrameData* pfd = NewPerFrameData(aFrame);
|
|
PerSpanData* psd = mRootSpan;
|
|
|
|
MOZ_ASSERT(psd->mFirstFrame, "adding bullet to an empty line?");
|
|
// Prepend the bullet frame to the line.
|
|
psd->mFirstFrame->mPrev = pfd;
|
|
pfd->mNext = psd->mFirstFrame;
|
|
psd->mFirstFrame = pfd;
|
|
|
|
pfd->mIsBullet = true;
|
|
if (aMetrics.BlockStartAscent() == ReflowOutput::ASK_FOR_BASELINE) {
|
|
pfd->mAscent = aFrame->GetLogicalBaseline(lineWM);
|
|
} else {
|
|
pfd->mAscent = aMetrics.BlockStartAscent();
|
|
}
|
|
|
|
// Note: block-coord value will be updated during block-direction alignment
|
|
pfd->mBounds = LogicalRect(lineWM, aFrame->GetRect(), ContainerSize());
|
|
pfd->mOverflowAreas = aMetrics.mOverflowAreas;
|
|
}
|
|
|
|
void nsLineLayout::RemoveBulletFrame(nsBulletFrame* aFrame) {
|
|
PerSpanData* psd = mCurrentSpan;
|
|
MOZ_ASSERT(psd == mRootSpan, "bullet on non-root span?");
|
|
MOZ_ASSERT(psd->mFirstFrame->mFrame == aFrame,
|
|
"bullet is not the first frame?");
|
|
PerFrameData* pfd = psd->mFirstFrame;
|
|
MOZ_ASSERT(pfd != psd->mLastFrame, "bullet is the only frame?");
|
|
pfd->mNext->mPrev = nullptr;
|
|
psd->mFirstFrame = pfd->mNext;
|
|
FreeFrame(pfd);
|
|
}
|
|
|
|
#ifdef DEBUG
|
|
void nsLineLayout::DumpPerSpanData(PerSpanData* psd, int32_t aIndent) {
|
|
nsFrame::IndentBy(stdout, aIndent);
|
|
printf("%p: left=%d x=%d right=%d\n", static_cast<void*>(psd), psd->mIStart,
|
|
psd->mICoord, psd->mIEnd);
|
|
PerFrameData* pfd = psd->mFirstFrame;
|
|
while (nullptr != pfd) {
|
|
nsFrame::IndentBy(stdout, aIndent + 1);
|
|
pfd->mFrame->ListTag(stdout);
|
|
nsRect rect =
|
|
pfd->mBounds.GetPhysicalRect(psd->mWritingMode, ContainerSize());
|
|
printf(" %d,%d,%d,%d\n", rect.x, rect.y, rect.width, rect.height);
|
|
if (pfd->mSpan) {
|
|
DumpPerSpanData(pfd->mSpan, aIndent + 1);
|
|
}
|
|
pfd = pfd->mNext;
|
|
}
|
|
}
|
|
#endif
|
|
|
|
void nsLineLayout::RecordNoWrapFloat(nsIFrame* aFloat) {
|
|
GetOutermostLineLayout()->mBlockRI->mNoWrapFloats.AppendElement(aFloat);
|
|
}
|
|
|
|
void nsLineLayout::FlushNoWrapFloats() {
|
|
auto& noWrapFloats = GetOutermostLineLayout()->mBlockRI->mNoWrapFloats;
|
|
for (nsIFrame* floatedFrame : noWrapFloats) {
|
|
TryToPlaceFloat(floatedFrame);
|
|
}
|
|
noWrapFloats.Clear();
|
|
}
|
|
|
|
bool nsLineLayout::TryToPlaceFloat(nsIFrame* aFloat) {
|
|
// Add mTrimmableISize to the available width since if the line ends here, the
|
|
// width of the inline content will be reduced by mTrimmableISize.
|
|
nscoord availableISize =
|
|
mCurrentSpan->mIEnd - (mCurrentSpan->mICoord - mTrimmableISize);
|
|
NS_ASSERTION(!(aFloat->IsLetterFrame() && GetFirstLetterStyleOK()),
|
|
"FirstLetterStyle set on line with floating first letter");
|
|
return GetOutermostLineLayout()->AddFloat(aFloat, availableISize);
|
|
}
|
|
|
|
bool nsLineLayout::NotifyOptionalBreakPosition(nsIFrame* aFrame,
|
|
int32_t aOffset, bool aFits,
|
|
gfxBreakPriority aPriority) {
|
|
MOZ_ASSERT(!aFits || !mNeedBackup,
|
|
"Shouldn't be updating the break position with a break that fits "
|
|
"after we've already flagged an overrun");
|
|
MOZ_ASSERT(mCurrentSpan, "Should be doing line layout");
|
|
if (mCurrentSpan->mNoWrap) {
|
|
FlushNoWrapFloats();
|
|
}
|
|
|
|
// Remember the last break position that fits; if there was no break that fit,
|
|
// just remember the first break
|
|
if ((aFits && aPriority >= mLastOptionalBreakPriority) ||
|
|
!mLastOptionalBreakFrame) {
|
|
mLastOptionalBreakFrame = aFrame;
|
|
mLastOptionalBreakFrameOffset = aOffset;
|
|
mLastOptionalBreakPriority = aPriority;
|
|
}
|
|
return aFrame && mForceBreakFrame == aFrame &&
|
|
mForceBreakFrameOffset == aOffset;
|
|
}
|
|
|
|
#define VALIGN_OTHER 0
|
|
#define VALIGN_TOP 1
|
|
#define VALIGN_BOTTOM 2
|
|
|
|
void nsLineLayout::VerticalAlignLine() {
|
|
// Partially place the children of the block frame. The baseline for
|
|
// this operation is set to zero so that the y coordinates for all
|
|
// of the placed children will be relative to there.
|
|
PerSpanData* psd = mRootSpan;
|
|
VerticalAlignFrames(psd);
|
|
|
|
// *** Note that comments here still use the anachronistic term
|
|
// "line-height" when we really mean "size of the line in the block
|
|
// direction", "vertical-align" when we really mean "alignment in
|
|
// the block direction", and "top" and "bottom" when we really mean
|
|
// "block start" and "block end". This is partly for brevity and
|
|
// partly to retain the association with the CSS line-height and
|
|
// vertical-align properties.
|
|
//
|
|
// Compute the line-height. The line-height will be the larger of:
|
|
//
|
|
// [1] maxBCoord - minBCoord (the distance between the first child's
|
|
// block-start edge and the last child's block-end edge)
|
|
//
|
|
// [2] the maximum logical box block size (since not every frame may have
|
|
// participated in #1; for example: "top" and "botttom" aligned frames)
|
|
//
|
|
// [3] the minimum line height ("line-height" property set on the
|
|
// block frame)
|
|
nscoord lineBSize = psd->mMaxBCoord - psd->mMinBCoord;
|
|
|
|
// Now that the line-height is computed, we need to know where the
|
|
// baseline is in the line. Position baseline so that mMinBCoord is just
|
|
// inside the start of the line box.
|
|
nscoord baselineBCoord;
|
|
if (psd->mMinBCoord < 0) {
|
|
baselineBCoord = mBStartEdge - psd->mMinBCoord;
|
|
} else {
|
|
baselineBCoord = mBStartEdge;
|
|
}
|
|
|
|
// It's also possible that the line block-size isn't tall enough because
|
|
// of "top" and "bottom" aligned elements that were not accounted for in
|
|
// min/max BCoord.
|
|
//
|
|
// The CSS2 spec doesn't really say what happens when to the
|
|
// baseline in this situations. What we do is if the largest start
|
|
// aligned box block size is greater than the line block-size then we leave
|
|
// the baseline alone. If the largest end aligned box is greater
|
|
// than the line block-size then we slide the baseline forward by the extra
|
|
// amount.
|
|
//
|
|
// Navigator 4 gives precedence to the first top/bottom aligned
|
|
// object. We just let block end aligned objects win.
|
|
if (lineBSize < mMaxEndBoxBSize) {
|
|
// When the line is shorter than the maximum block start aligned box
|
|
nscoord extra = mMaxEndBoxBSize - lineBSize;
|
|
baselineBCoord += extra;
|
|
lineBSize = mMaxEndBoxBSize;
|
|
}
|
|
if (lineBSize < mMaxStartBoxBSize) {
|
|
lineBSize = mMaxStartBoxBSize;
|
|
}
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" [line]==> lineBSize=%d baselineBCoord=%d\n", lineBSize,
|
|
baselineBCoord);
|
|
#endif
|
|
|
|
// Now position all of the frames in the root span. We will also
|
|
// recurse over the child spans and place any frames we find with
|
|
// vertical-align: top or bottom.
|
|
// XXX PERFORMANCE: set a bit per-span to avoid the extra work
|
|
// (propagate it upward too)
|
|
WritingMode lineWM = psd->mWritingMode;
|
|
for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
if (pfd->mBlockDirAlign == VALIGN_OTHER) {
|
|
pfd->mBounds.BStart(lineWM) += baselineBCoord;
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSize());
|
|
}
|
|
}
|
|
PlaceTopBottomFrames(psd, -mBStartEdge, lineBSize);
|
|
|
|
mFinalLineBSize = lineBSize;
|
|
if (mGotLineBox) {
|
|
// Fill in returned line-box and max-element-width data
|
|
mLineBox->SetBounds(lineWM, psd->mIStart, mBStartEdge,
|
|
psd->mICoord - psd->mIStart, lineBSize,
|
|
ContainerSize());
|
|
|
|
mLineBox->SetLogicalAscent(baselineBCoord - mBStartEdge);
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" [line]==> bounds{x,y,w,h}={%d,%d,%d,%d} lh=%d a=%d\n",
|
|
mLineBox->GetBounds().IStart(lineWM),
|
|
mLineBox->GetBounds().BStart(lineWM),
|
|
mLineBox->GetBounds().ISize(lineWM),
|
|
mLineBox->GetBounds().BSize(lineWM), mFinalLineBSize,
|
|
mLineBox->GetLogicalAscent());
|
|
#endif
|
|
}
|
|
}
|
|
|
|
// Place frames with CSS property vertical-align: top or bottom.
|
|
void nsLineLayout::PlaceTopBottomFrames(PerSpanData* psd,
|
|
nscoord aDistanceFromStart,
|
|
nscoord aLineBSize) {
|
|
for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
PerSpanData* span = pfd->mSpan;
|
|
#ifdef DEBUG
|
|
NS_ASSERTION(0xFF != pfd->mBlockDirAlign, "umr");
|
|
#endif
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
nsSize containerSize = ContainerSizeForSpan(psd);
|
|
switch (pfd->mBlockDirAlign) {
|
|
case VALIGN_TOP:
|
|
if (span) {
|
|
pfd->mBounds.BStart(lineWM) = -aDistanceFromStart - span->mMinBCoord;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
-aDistanceFromStart + pfd->mMargin.BStart(lineWM);
|
|
}
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, containerSize);
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" ");
|
|
pfd->mFrame->ListTag(stdout);
|
|
printf(": y=%d dTop=%d [bp.top=%d topLeading=%d]\n",
|
|
pfd->mBounds.BStart(lineWM), aDistanceFromStart,
|
|
span ? pfd->mBorderPadding.BStart(lineWM) : 0,
|
|
span ? span->mBStartLeading : 0);
|
|
#endif
|
|
break;
|
|
case VALIGN_BOTTOM:
|
|
if (span) {
|
|
// Compute bottom leading
|
|
pfd->mBounds.BStart(lineWM) =
|
|
-aDistanceFromStart + aLineBSize - span->mMaxBCoord;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) = -aDistanceFromStart + aLineBSize -
|
|
pfd->mMargin.BEnd(lineWM) -
|
|
pfd->mBounds.BSize(lineWM);
|
|
}
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, containerSize);
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" ");
|
|
pfd->mFrame->ListTag(stdout);
|
|
printf(": y=%d\n", pfd->mBounds.BStart(lineWM));
|
|
#endif
|
|
break;
|
|
}
|
|
if (span) {
|
|
nscoord fromStart = aDistanceFromStart + pfd->mBounds.BStart(lineWM);
|
|
PlaceTopBottomFrames(span, fromStart, aLineBSize);
|
|
}
|
|
}
|
|
}
|
|
|
|
static nscoord GetBSizeOfEmphasisMarks(nsIFrame* aSpanFrame, float aInflation) {
|
|
RefPtr<nsFontMetrics> fm = nsLayoutUtils::GetFontMetricsOfEmphasisMarks(
|
|
aSpanFrame->Style(), aSpanFrame->PresContext(), aInflation);
|
|
return fm->MaxHeight();
|
|
}
|
|
|
|
void nsLineLayout::AdjustLeadings(nsIFrame* spanFrame, PerSpanData* psd,
|
|
const nsStyleText* aStyleText,
|
|
float aInflation,
|
|
bool* aZeroEffectiveSpanBox) {
|
|
MOZ_ASSERT(spanFrame == psd->mFrame->mFrame);
|
|
nscoord requiredStartLeading = 0;
|
|
nscoord requiredEndLeading = 0;
|
|
if (spanFrame->IsRubyFrame()) {
|
|
// We may need to extend leadings here for ruby annotations as
|
|
// required by section Line Spacing in the CSS Ruby spec.
|
|
// See http://dev.w3.org/csswg/css-ruby/#line-height
|
|
auto rubyFrame = static_cast<nsRubyFrame*>(spanFrame);
|
|
RubyBlockLeadings leadings = rubyFrame->GetBlockLeadings();
|
|
requiredStartLeading += leadings.mStart;
|
|
requiredEndLeading += leadings.mEnd;
|
|
}
|
|
if (aStyleText->HasTextEmphasis()) {
|
|
nscoord bsize = GetBSizeOfEmphasisMarks(spanFrame, aInflation);
|
|
LogicalSide side = aStyleText->TextEmphasisSide(mRootSpan->mWritingMode);
|
|
if (side == eLogicalSideBStart) {
|
|
requiredStartLeading += bsize;
|
|
} else {
|
|
MOZ_ASSERT(side == eLogicalSideBEnd,
|
|
"emphasis marks must be in block axis");
|
|
requiredEndLeading += bsize;
|
|
}
|
|
}
|
|
|
|
nscoord requiredLeading = requiredStartLeading + requiredEndLeading;
|
|
// If we do not require any additional leadings, don't touch anything
|
|
// here even if it is greater than the original leading, because the
|
|
// latter could be negative.
|
|
if (requiredLeading != 0) {
|
|
nscoord leading = psd->mBStartLeading + psd->mBEndLeading;
|
|
nscoord deltaLeading = requiredLeading - leading;
|
|
if (deltaLeading > 0) {
|
|
// If the total leading is not wide enough for ruby annotations
|
|
// and/or emphasis marks, extend the side which is not enough. If
|
|
// both sides are not wide enough, replace the leadings with the
|
|
// requested values.
|
|
if (requiredStartLeading < psd->mBStartLeading) {
|
|
psd->mBEndLeading += deltaLeading;
|
|
} else if (requiredEndLeading < psd->mBEndLeading) {
|
|
psd->mBStartLeading += deltaLeading;
|
|
} else {
|
|
psd->mBStartLeading = requiredStartLeading;
|
|
psd->mBEndLeading = requiredEndLeading;
|
|
}
|
|
psd->mLogicalBSize += deltaLeading;
|
|
// We have adjusted the leadings, it is no longer a zero
|
|
// effective span box.
|
|
*aZeroEffectiveSpanBox = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
static float GetInflationForBlockDirAlignment(nsIFrame* aFrame,
|
|
nscoord aInflationMinFontSize) {
|
|
if (nsSVGUtils::IsInSVGTextSubtree(aFrame)) {
|
|
const nsIFrame* container =
|
|
nsLayoutUtils::GetClosestFrameOfType(aFrame, LayoutFrameType::SVGText);
|
|
NS_ASSERTION(container, "expected to find an ancestor SVGTextFrame");
|
|
return static_cast<const SVGTextFrame*>(container)
|
|
->GetFontSizeScaleFactor();
|
|
}
|
|
return nsLayoutUtils::FontSizeInflationInner(aFrame, aInflationMinFontSize);
|
|
}
|
|
|
|
#define BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM nscoord_MAX
|
|
#define BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM nscoord_MIN
|
|
|
|
// Place frames in the block direction within a given span (CSS property
|
|
// vertical-align) Note: this doesn't place frames with vertical-align:
|
|
// top or bottom as those have to wait until the entire line box block
|
|
// size is known. This is called after the span frame has finished being
|
|
// reflowed so that we know its block size.
|
|
void nsLineLayout::VerticalAlignFrames(PerSpanData* psd) {
|
|
// Get parent frame info
|
|
PerFrameData* spanFramePFD = psd->mFrame;
|
|
nsIFrame* spanFrame = spanFramePFD->mFrame;
|
|
|
|
// Get the parent frame's font for all of the frames in this span
|
|
float inflation =
|
|
GetInflationForBlockDirAlignment(spanFrame, mInflationMinFontSize);
|
|
RefPtr<nsFontMetrics> fm =
|
|
nsLayoutUtils::GetFontMetricsForFrame(spanFrame, inflation);
|
|
|
|
bool preMode = mStyleText->WhiteSpaceIsSignificant();
|
|
|
|
// See if the span is an empty continuation. It's an empty continuation iff:
|
|
// - it has a prev-in-flow
|
|
// - it has no next in flow
|
|
// - it's zero sized
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
bool emptyContinuation = psd != mRootSpan && spanFrame->GetPrevInFlow() &&
|
|
!spanFrame->GetNextInFlow() &&
|
|
spanFramePFD->mBounds.IsZeroSize();
|
|
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf("[%sSpan]", (psd == mRootSpan) ? "Root" : "");
|
|
spanFrame->ListTag(stdout);
|
|
printf(": preMode=%s strictMode=%s w/h=%d,%d emptyContinuation=%s",
|
|
preMode ? "yes" : "no",
|
|
mPresContext->CompatibilityMode() != eCompatibility_NavQuirks ? "yes"
|
|
: "no",
|
|
spanFramePFD->mBounds.ISize(lineWM),
|
|
spanFramePFD->mBounds.BSize(lineWM), emptyContinuation ? "yes" : "no");
|
|
if (psd != mRootSpan) {
|
|
printf(" bp=%d,%d,%d,%d margin=%d,%d,%d,%d",
|
|
spanFramePFD->mBorderPadding.Top(lineWM),
|
|
spanFramePFD->mBorderPadding.Right(lineWM),
|
|
spanFramePFD->mBorderPadding.Bottom(lineWM),
|
|
spanFramePFD->mBorderPadding.Left(lineWM),
|
|
spanFramePFD->mMargin.Top(lineWM),
|
|
spanFramePFD->mMargin.Right(lineWM),
|
|
spanFramePFD->mMargin.Bottom(lineWM),
|
|
spanFramePFD->mMargin.Left(lineWM));
|
|
}
|
|
printf("\n");
|
|
#endif
|
|
|
|
// Compute the span's zeroEffectiveSpanBox flag. What we are trying
|
|
// to determine is how we should treat the span: should it act
|
|
// "normally" according to css2 or should it effectively
|
|
// "disappear".
|
|
//
|
|
// In general, if the document being processed is in full standards
|
|
// mode then it should act normally (with one exception). The
|
|
// exception case is when a span is continued and yet the span is
|
|
// empty (e.g. compressed whitespace). For this kind of span we treat
|
|
// it as if it were not there so that it doesn't impact the
|
|
// line block-size.
|
|
//
|
|
// In almost standards mode or quirks mode, we should sometimes make
|
|
// it disappear. The cases that matter are those where the span
|
|
// contains no real text elements that would provide an ascent and
|
|
// descent and height. However, if css style elements have been
|
|
// applied to the span (border/padding/margin) so that it's clear the
|
|
// document author is intending css2 behavior then we act as if strict
|
|
// mode is set.
|
|
//
|
|
// This code works correctly for preMode, because a blank line
|
|
// in PRE mode is encoded as a text node with a LF in it, since
|
|
// text nodes with only whitespace are considered in preMode.
|
|
//
|
|
// Much of this logic is shared with the various implementations of
|
|
// nsIFrame::IsEmpty since they need to duplicate the way it makes
|
|
// some lines empty. However, nsIFrame::IsEmpty can't be reused here
|
|
// since this code sets zeroEffectiveSpanBox even when there are
|
|
// non-empty children.
|
|
bool zeroEffectiveSpanBox = false;
|
|
// XXXldb If we really have empty continuations, then all these other
|
|
// checks don't make sense for them.
|
|
// XXXldb This should probably just use nsIFrame::IsSelfEmpty, assuming that
|
|
// it agrees with this code. (If it doesn't agree, it probably should.)
|
|
if ((emptyContinuation ||
|
|
mPresContext->CompatibilityMode() != eCompatibility_FullStandards) &&
|
|
((psd == mRootSpan) || (spanFramePFD->mBorderPadding.IsAllZero() &&
|
|
spanFramePFD->mMargin.IsAllZero()))) {
|
|
// This code handles an issue with compatibility with non-css
|
|
// conformant browsers. In particular, there are some cases
|
|
// where the font-size and line-height for a span must be
|
|
// ignored and instead the span must *act* as if it were zero
|
|
// sized. In general, if the span contains any non-compressed
|
|
// text then we don't use this logic.
|
|
// However, this is not propagated outwards, since (in compatibility
|
|
// mode) we don't want big line heights for things like
|
|
// <p><font size="-1">Text</font></p>
|
|
|
|
// We shouldn't include any whitespace that collapses, unless we're
|
|
// preformatted (in which case it shouldn't, but the width=0 test is
|
|
// perhaps incorrect). This includes whitespace at the beginning of
|
|
// a line and whitespace preceded (?) by other whitespace.
|
|
// See bug 134580 and bug 155333.
|
|
zeroEffectiveSpanBox = true;
|
|
for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
if (pfd->mIsTextFrame &&
|
|
(pfd->mIsNonWhitespaceTextFrame || preMode ||
|
|
pfd->mBounds.ISize(mRootSpan->mWritingMode) != 0)) {
|
|
zeroEffectiveSpanBox = false;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Setup baselineBCoord, minBCoord, and maxBCoord
|
|
nscoord baselineBCoord, minBCoord, maxBCoord;
|
|
if (psd == mRootSpan) {
|
|
// Use a zero baselineBCoord since we don't yet know where the baseline
|
|
// will be (until we know how tall the line is; then we will
|
|
// know). In addition, use extreme values for the minBCoord and maxBCoord
|
|
// values so that only the child frames will impact their values
|
|
// (since these are children of the block, there is no span box to
|
|
// provide initial values).
|
|
baselineBCoord = 0;
|
|
minBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM;
|
|
maxBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM;
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf("[RootSpan]");
|
|
spanFrame->ListTag(stdout);
|
|
printf(
|
|
": pass1 valign frames: topEdge=%d minLineBSize=%d "
|
|
"zeroEffectiveSpanBox=%s\n",
|
|
mBStartEdge, mMinLineBSize, zeroEffectiveSpanBox ? "yes" : "no");
|
|
#endif
|
|
} else {
|
|
// Compute the logical block size for this span. The logical block size
|
|
// is based on the "line-height" value, not the font-size. Also
|
|
// compute the top leading.
|
|
float inflation =
|
|
GetInflationForBlockDirAlignment(spanFrame, mInflationMinFontSize);
|
|
nscoord logicalBSize = ReflowInput::CalcLineHeight(
|
|
spanFrame->GetContent(), spanFrame->Style(), spanFrame->PresContext(),
|
|
mBlockReflowInput->ComputedHeight(), inflation);
|
|
nscoord contentBSize = spanFramePFD->mBounds.BSize(lineWM) -
|
|
spanFramePFD->mBorderPadding.BStartEnd(lineWM);
|
|
|
|
// Special-case for a ::first-letter frame, set the line height to
|
|
// the frame block size if the user has left line-height == normal
|
|
const nsStyleText* styleText = spanFrame->StyleText();
|
|
if (spanFramePFD->mIsLetterFrame && !spanFrame->GetPrevInFlow() &&
|
|
styleText->mLineHeight.GetUnit() == eStyleUnit_Normal) {
|
|
logicalBSize = spanFramePFD->mBounds.BSize(lineWM);
|
|
}
|
|
|
|
nscoord leading = logicalBSize - contentBSize;
|
|
psd->mBStartLeading = leading / 2;
|
|
psd->mBEndLeading = leading - psd->mBStartLeading;
|
|
psd->mLogicalBSize = logicalBSize;
|
|
AdjustLeadings(spanFrame, psd, styleText, inflation, &zeroEffectiveSpanBox);
|
|
|
|
if (zeroEffectiveSpanBox) {
|
|
// When the span-box is to be ignored, zero out the initial
|
|
// values so that the span doesn't impact the final line
|
|
// height. The contents of the span can impact the final line
|
|
// height.
|
|
|
|
// Note that things are readjusted for this span after its children
|
|
// are reflowed
|
|
minBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM;
|
|
maxBCoord = BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM;
|
|
} else {
|
|
// The initial values for the min and max block coord values are in the
|
|
// span's coordinate space, and cover the logical block size of the span.
|
|
// If there are child frames in this span that stick out of this area
|
|
// then the minBCoord and maxBCoord are updated by the amount of logical
|
|
// blockSize that is outside this range.
|
|
minBCoord =
|
|
spanFramePFD->mBorderPadding.BStart(lineWM) - psd->mBStartLeading;
|
|
maxBCoord = minBCoord + psd->mLogicalBSize;
|
|
}
|
|
|
|
// This is the distance from the top edge of the parents visual
|
|
// box to the baseline. The span already computed this for us,
|
|
// so just use it.
|
|
*psd->mBaseline = baselineBCoord = spanFramePFD->mAscent;
|
|
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf("[%sSpan]", (psd == mRootSpan) ? "Root" : "");
|
|
spanFrame->ListTag(stdout);
|
|
printf(
|
|
": baseLine=%d logicalBSize=%d topLeading=%d h=%d bp=%d,%d "
|
|
"zeroEffectiveSpanBox=%s\n",
|
|
baselineBCoord, psd->mLogicalBSize, psd->mBStartLeading,
|
|
spanFramePFD->mBounds.BSize(lineWM),
|
|
spanFramePFD->mBorderPadding.Top(lineWM),
|
|
spanFramePFD->mBorderPadding.Bottom(lineWM),
|
|
zeroEffectiveSpanBox ? "yes" : "no");
|
|
#endif
|
|
}
|
|
|
|
nscoord maxStartBoxBSize = 0;
|
|
nscoord maxEndBoxBSize = 0;
|
|
PerFrameData* pfd = psd->mFirstFrame;
|
|
while (nullptr != pfd) {
|
|
nsIFrame* frame = pfd->mFrame;
|
|
|
|
// sanity check (see bug 105168, non-reproducible crashes from null frame)
|
|
NS_ASSERTION(frame,
|
|
"null frame in PerFrameData - something is very very bad");
|
|
if (!frame) {
|
|
return;
|
|
}
|
|
|
|
// Compute the logical block size of the frame
|
|
nscoord logicalBSize;
|
|
PerSpanData* frameSpan = pfd->mSpan;
|
|
if (frameSpan) {
|
|
// For span frames the logical-block-size and start-leading were
|
|
// pre-computed when the span was reflowed.
|
|
logicalBSize = frameSpan->mLogicalBSize;
|
|
} else {
|
|
// For other elements the logical block size is the same as the
|
|
// frame's block size plus its margins.
|
|
logicalBSize =
|
|
pfd->mBounds.BSize(lineWM) + pfd->mMargin.BStartEnd(lineWM);
|
|
if (logicalBSize < 0 &&
|
|
mPresContext->CompatibilityMode() == eCompatibility_NavQuirks) {
|
|
pfd->mAscent -= logicalBSize;
|
|
logicalBSize = 0;
|
|
}
|
|
}
|
|
|
|
// Get vertical-align property ("vertical-align" is the CSS name for
|
|
// block-direction align)
|
|
const nsStyleCoord& verticalAlign = frame->StyleDisplay()->mVerticalAlign;
|
|
uint8_t verticalAlignEnum = frame->VerticalAlignEnum();
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" [frame]");
|
|
frame->ListTag(stdout);
|
|
printf(": verticalAlignUnit=%d (enum == %d", verticalAlign.GetUnit(),
|
|
((eStyleUnit_Enumerated == verticalAlign.GetUnit())
|
|
? verticalAlign.GetIntValue()
|
|
: -1));
|
|
if (verticalAlignEnum != nsIFrame::eInvalidVerticalAlign) {
|
|
printf(", after SVG dominant-baseline conversion == %d",
|
|
verticalAlignEnum);
|
|
}
|
|
printf(")\n");
|
|
#endif
|
|
|
|
if (verticalAlignEnum != nsIFrame::eInvalidVerticalAlign) {
|
|
if (lineWM.IsVertical()) {
|
|
if (verticalAlignEnum == NS_STYLE_VERTICAL_ALIGN_MIDDLE) {
|
|
// For vertical writing mode where the dominant baseline is centered
|
|
// (i.e. text-orientation is not sideways-*), we remap 'middle' to
|
|
// 'middle-with-baseline' so that images align sensibly with the
|
|
// center-baseline-aligned text.
|
|
if (!lineWM.IsSideways()) {
|
|
verticalAlignEnum = NS_STYLE_VERTICAL_ALIGN_MIDDLE_WITH_BASELINE;
|
|
}
|
|
} else if (lineWM.IsLineInverted()) {
|
|
// Swap the meanings of top and bottom when line is inverted
|
|
// relative to block direction.
|
|
switch (verticalAlignEnum) {
|
|
case NS_STYLE_VERTICAL_ALIGN_TOP:
|
|
verticalAlignEnum = NS_STYLE_VERTICAL_ALIGN_BOTTOM;
|
|
break;
|
|
case NS_STYLE_VERTICAL_ALIGN_BOTTOM:
|
|
verticalAlignEnum = NS_STYLE_VERTICAL_ALIGN_TOP;
|
|
break;
|
|
case NS_STYLE_VERTICAL_ALIGN_TEXT_TOP:
|
|
verticalAlignEnum = NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM;
|
|
break;
|
|
case NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM:
|
|
verticalAlignEnum = NS_STYLE_VERTICAL_ALIGN_TEXT_TOP;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
// baseline coord that may be adjusted for script offset
|
|
nscoord revisedBaselineBCoord = baselineBCoord;
|
|
|
|
// For superscript and subscript, raise or lower the baseline of the box
|
|
// to the proper offset of the parent's box, then proceed as for BASELINE
|
|
if (verticalAlignEnum == NS_STYLE_VERTICAL_ALIGN_SUB ||
|
|
verticalAlignEnum == NS_STYLE_VERTICAL_ALIGN_SUPER) {
|
|
revisedBaselineBCoord +=
|
|
lineWM.FlowRelativeToLineRelativeFactor() *
|
|
(verticalAlignEnum == NS_STYLE_VERTICAL_ALIGN_SUB
|
|
? fm->SubscriptOffset()
|
|
: -fm->SuperscriptOffset());
|
|
verticalAlignEnum = NS_STYLE_VERTICAL_ALIGN_BASELINE;
|
|
}
|
|
|
|
switch (verticalAlignEnum) {
|
|
default:
|
|
case NS_STYLE_VERTICAL_ALIGN_BASELINE:
|
|
if (lineWM.IsVertical() && !lineWM.IsSideways()) {
|
|
if (frameSpan) {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
revisedBaselineBCoord - pfd->mBounds.BSize(lineWM) / 2;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) = revisedBaselineBCoord -
|
|
logicalBSize / 2 +
|
|
pfd->mMargin.BStart(lineWM);
|
|
}
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) = revisedBaselineBCoord - pfd->mAscent;
|
|
}
|
|
pfd->mBlockDirAlign = VALIGN_OTHER;
|
|
break;
|
|
|
|
case NS_STYLE_VERTICAL_ALIGN_TOP: {
|
|
pfd->mBlockDirAlign = VALIGN_TOP;
|
|
nscoord subtreeBSize = logicalBSize;
|
|
if (frameSpan) {
|
|
subtreeBSize = frameSpan->mMaxBCoord - frameSpan->mMinBCoord;
|
|
NS_ASSERTION(subtreeBSize >= logicalBSize,
|
|
"unexpected subtree block size");
|
|
}
|
|
if (subtreeBSize > maxStartBoxBSize) {
|
|
maxStartBoxBSize = subtreeBSize;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NS_STYLE_VERTICAL_ALIGN_BOTTOM: {
|
|
pfd->mBlockDirAlign = VALIGN_BOTTOM;
|
|
nscoord subtreeBSize = logicalBSize;
|
|
if (frameSpan) {
|
|
subtreeBSize = frameSpan->mMaxBCoord - frameSpan->mMinBCoord;
|
|
NS_ASSERTION(subtreeBSize >= logicalBSize,
|
|
"unexpected subtree block size");
|
|
}
|
|
if (subtreeBSize > maxEndBoxBSize) {
|
|
maxEndBoxBSize = subtreeBSize;
|
|
}
|
|
break;
|
|
}
|
|
|
|
case NS_STYLE_VERTICAL_ALIGN_MIDDLE: {
|
|
// Align the midpoint of the frame with 1/2 the parents
|
|
// x-height above the baseline.
|
|
nscoord parentXHeight =
|
|
lineWM.FlowRelativeToLineRelativeFactor() * fm->XHeight();
|
|
if (frameSpan) {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
baselineBCoord -
|
|
(parentXHeight + pfd->mBounds.BSize(lineWM)) / 2;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) = baselineBCoord -
|
|
(parentXHeight + logicalBSize) / 2 +
|
|
pfd->mMargin.BStart(lineWM);
|
|
}
|
|
pfd->mBlockDirAlign = VALIGN_OTHER;
|
|
break;
|
|
}
|
|
|
|
case NS_STYLE_VERTICAL_ALIGN_TEXT_TOP: {
|
|
// The top of the logical box is aligned with the top of
|
|
// the parent element's text.
|
|
// XXX For vertical text we will need a new API to get the logical
|
|
// max-ascent here
|
|
nscoord parentAscent =
|
|
lineWM.IsLineInverted() ? fm->MaxDescent() : fm->MaxAscent();
|
|
if (frameSpan) {
|
|
pfd->mBounds.BStart(lineWM) = baselineBCoord - parentAscent -
|
|
pfd->mBorderPadding.BStart(lineWM) +
|
|
frameSpan->mBStartLeading;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
baselineBCoord - parentAscent + pfd->mMargin.BStart(lineWM);
|
|
}
|
|
pfd->mBlockDirAlign = VALIGN_OTHER;
|
|
break;
|
|
}
|
|
|
|
case NS_STYLE_VERTICAL_ALIGN_TEXT_BOTTOM: {
|
|
// The bottom of the logical box is aligned with the
|
|
// bottom of the parent elements text.
|
|
nscoord parentDescent =
|
|
lineWM.IsLineInverted() ? fm->MaxAscent() : fm->MaxDescent();
|
|
if (frameSpan) {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
baselineBCoord + parentDescent - pfd->mBounds.BSize(lineWM) +
|
|
pfd->mBorderPadding.BEnd(lineWM) - frameSpan->mBEndLeading;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) = baselineBCoord + parentDescent -
|
|
pfd->mBounds.BSize(lineWM) -
|
|
pfd->mMargin.BEnd(lineWM);
|
|
}
|
|
pfd->mBlockDirAlign = VALIGN_OTHER;
|
|
break;
|
|
}
|
|
|
|
case NS_STYLE_VERTICAL_ALIGN_MIDDLE_WITH_BASELINE: {
|
|
// Align the midpoint of the frame with the baseline of the parent.
|
|
if (frameSpan) {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
baselineBCoord - pfd->mBounds.BSize(lineWM) / 2;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) =
|
|
baselineBCoord - logicalBSize / 2 + pfd->mMargin.BStart(lineWM);
|
|
}
|
|
pfd->mBlockDirAlign = VALIGN_OTHER;
|
|
break;
|
|
}
|
|
}
|
|
} else {
|
|
// We have either a coord, a percent, or a calc().
|
|
nscoord pctBasis = 0;
|
|
if (verticalAlign.HasPercent()) {
|
|
// Percentages are like lengths, except treated as a percentage
|
|
// of the elements line block size value.
|
|
float inflation =
|
|
GetInflationForBlockDirAlignment(frame, mInflationMinFontSize);
|
|
pctBasis = ReflowInput::CalcLineHeight(
|
|
frame->GetContent(), frame->Style(), frame->PresContext(),
|
|
mBlockReflowInput->ComputedBSize(), inflation);
|
|
}
|
|
nscoord offset = verticalAlign.ComputeCoordPercentCalc(pctBasis);
|
|
// According to the CSS2 spec (10.8.1), a positive value
|
|
// "raises" the box by the given distance while a negative value
|
|
// "lowers" the box by the given distance (with zero being the
|
|
// baseline). Since Y coordinates increase towards the bottom of
|
|
// the screen we reverse the sign, unless the line orientation is
|
|
// inverted relative to block direction.
|
|
nscoord revisedBaselineBCoord =
|
|
baselineBCoord - offset * lineWM.FlowRelativeToLineRelativeFactor();
|
|
if (lineWM.IsVertical() && !lineWM.IsSideways()) {
|
|
// If we're using a dominant center baseline, we align with the center
|
|
// of the frame being placed (bug 1133945).
|
|
pfd->mBounds.BStart(lineWM) =
|
|
revisedBaselineBCoord - pfd->mBounds.BSize(lineWM) / 2;
|
|
} else {
|
|
pfd->mBounds.BStart(lineWM) = revisedBaselineBCoord - pfd->mAscent;
|
|
}
|
|
pfd->mBlockDirAlign = VALIGN_OTHER;
|
|
}
|
|
|
|
// Update minBCoord/maxBCoord for frames that we just placed. Do not factor
|
|
// text into the equation.
|
|
if (pfd->mBlockDirAlign == VALIGN_OTHER) {
|
|
// Text frames do not contribute to the min/max Y values for the
|
|
// line (instead their parent frame's font-size contributes).
|
|
// XXXrbs -- relax this restriction because it causes text frames
|
|
// to jam together when 'font-size-adjust' is enabled
|
|
// and layout is using dynamic font heights (bug 20394)
|
|
// -- Note #1: With this code enabled and with the fact that we are
|
|
// not using Em[Ascent|Descent] as nsDimensions for text
|
|
// metrics in GFX mean that the discussion in bug 13072 cannot
|
|
// hold.
|
|
// -- Note #2: We still don't want empty-text frames to interfere.
|
|
// For example in quirks mode, avoiding empty text frames
|
|
// prevents "tall" lines around elements like <hr> since the
|
|
// rules of <hr> in quirks.css have pseudo text contents with LF
|
|
// in them.
|
|
bool canUpdate;
|
|
if (pfd->mIsTextFrame) {
|
|
// Only consider text frames if they're not empty and
|
|
// line-height=normal.
|
|
canUpdate =
|
|
pfd->mIsNonWhitespaceTextFrame &&
|
|
frame->StyleText()->mLineHeight.GetUnit() == eStyleUnit_Normal;
|
|
} else {
|
|
canUpdate = !pfd->mIsPlaceholder;
|
|
}
|
|
|
|
if (canUpdate) {
|
|
nscoord blockStart, blockEnd;
|
|
if (frameSpan) {
|
|
// For spans that were are now placing, use their position
|
|
// plus their already computed min-Y and max-Y values for
|
|
// computing blockStart and blockEnd.
|
|
blockStart = pfd->mBounds.BStart(lineWM) + frameSpan->mMinBCoord;
|
|
blockEnd = pfd->mBounds.BStart(lineWM) + frameSpan->mMaxBCoord;
|
|
} else {
|
|
blockStart =
|
|
pfd->mBounds.BStart(lineWM) - pfd->mMargin.BStart(lineWM);
|
|
blockEnd = blockStart + logicalBSize;
|
|
}
|
|
if (!preMode &&
|
|
mPresContext->CompatibilityMode() != eCompatibility_FullStandards &&
|
|
!logicalBSize) {
|
|
// Check if it's a BR frame that is not alone on its line (it
|
|
// is given a block size of zero to indicate this), and if so reset
|
|
// blockStart and blockEnd so that BR frames don't influence the line.
|
|
if (frame->IsBrFrame()) {
|
|
blockStart = BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM;
|
|
blockEnd = BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM;
|
|
}
|
|
}
|
|
if (blockStart < minBCoord) minBCoord = blockStart;
|
|
if (blockEnd > maxBCoord) maxBCoord = blockEnd;
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(
|
|
" [frame]raw: a=%d h=%d bp=%d,%d logical: h=%d leading=%d y=%d "
|
|
"minBCoord=%d maxBCoord=%d\n",
|
|
pfd->mAscent, pfd->mBounds.BSize(lineWM),
|
|
pfd->mBorderPadding.Top(lineWM), pfd->mBorderPadding.Bottom(lineWM),
|
|
logicalBSize, frameSpan ? frameSpan->mBStartLeading : 0,
|
|
pfd->mBounds.BStart(lineWM), minBCoord, maxBCoord);
|
|
#endif
|
|
}
|
|
if (psd != mRootSpan) {
|
|
frame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd));
|
|
}
|
|
}
|
|
pfd = pfd->mNext;
|
|
}
|
|
|
|
// Factor in the minimum line block-size when handling the root-span for
|
|
// the block.
|
|
if (psd == mRootSpan) {
|
|
// We should factor in the block element's minimum line-height (as
|
|
// defined in section 10.8.1 of the css2 spec) assuming that
|
|
// zeroEffectiveSpanBox is not set on the root span. This only happens
|
|
// in some cases in quirks mode:
|
|
// (1) if the root span contains non-whitespace text directly (this
|
|
// is handled by zeroEffectiveSpanBox
|
|
// (2) if this line has a bullet
|
|
// (3) if this is the last line of an LI, DT, or DD element
|
|
// (The last line before a block also counts, but not before a
|
|
// BR) (NN4/IE5 quirk)
|
|
|
|
// (1) and (2) above
|
|
bool applyMinLH = !zeroEffectiveSpanBox || mHasBullet;
|
|
bool isLastLine =
|
|
!mGotLineBox || (!mLineBox->IsLineWrapped() && !mLineEndsInBR);
|
|
if (!applyMinLH && isLastLine) {
|
|
nsIContent* blockContent = mRootSpan->mFrame->mFrame->GetContent();
|
|
if (blockContent) {
|
|
// (3) above, if the last line of LI, DT, or DD
|
|
if (blockContent->IsAnyOfHTMLElements(nsGkAtoms::li, nsGkAtoms::dt,
|
|
nsGkAtoms::dd)) {
|
|
applyMinLH = true;
|
|
}
|
|
}
|
|
}
|
|
if (applyMinLH) {
|
|
if (psd->mHasNonemptyContent || preMode || mHasBullet) {
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" [span]==> adjusting min/maxBCoord: currentValues: %d,%d",
|
|
minBCoord, maxBCoord);
|
|
#endif
|
|
nscoord minimumLineBSize = mMinLineBSize;
|
|
nscoord blockStart = -nsLayoutUtils::GetCenteredFontBaseline(
|
|
fm, minimumLineBSize, lineWM.IsLineInverted());
|
|
nscoord blockEnd = blockStart + minimumLineBSize;
|
|
|
|
if (mStyleText->HasTextEmphasis()) {
|
|
nscoord fontMaxHeight = fm->MaxHeight();
|
|
nscoord emphasisHeight =
|
|
GetBSizeOfEmphasisMarks(spanFrame, inflation);
|
|
nscoord delta = fontMaxHeight + emphasisHeight - minimumLineBSize;
|
|
if (delta > 0) {
|
|
if (minimumLineBSize < fontMaxHeight) {
|
|
// If the leadings are negative, fill them first.
|
|
nscoord ascent = fm->MaxAscent();
|
|
nscoord descent = fm->MaxDescent();
|
|
if (lineWM.IsLineInverted()) {
|
|
Swap(ascent, descent);
|
|
}
|
|
blockStart = -ascent;
|
|
blockEnd = descent;
|
|
delta = emphasisHeight;
|
|
}
|
|
LogicalSide side = mStyleText->TextEmphasisSide(lineWM);
|
|
if (side == eLogicalSideBStart) {
|
|
blockStart -= delta;
|
|
} else {
|
|
blockEnd += delta;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (blockStart < minBCoord) minBCoord = blockStart;
|
|
if (blockEnd > maxBCoord) maxBCoord = blockEnd;
|
|
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" new values: %d,%d\n", minBCoord, maxBCoord);
|
|
#endif
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(
|
|
" Used mMinLineBSize: %d, blockStart: %d, blockEnd: "
|
|
"%d\n",
|
|
mMinLineBSize, blockStart, blockEnd);
|
|
#endif
|
|
} else {
|
|
// XXX issues:
|
|
// [1] BR's on empty lines stop working
|
|
// [2] May not honor css2's notion of handling empty elements
|
|
// [3] blank lines in a pre-section ("\n") (handled with preMode)
|
|
|
|
// XXX Are there other problems with this?
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(
|
|
" [span]==> zapping min/maxBCoord: currentValues: %d,%d "
|
|
"newValues: 0,0\n",
|
|
minBCoord, maxBCoord);
|
|
#endif
|
|
minBCoord = maxBCoord = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ((minBCoord == BLOCKDIR_ALIGN_FRAMES_NO_MINIMUM) ||
|
|
(maxBCoord == BLOCKDIR_ALIGN_FRAMES_NO_MAXIMUM)) {
|
|
minBCoord = maxBCoord = baselineBCoord;
|
|
}
|
|
|
|
if (psd != mRootSpan && zeroEffectiveSpanBox) {
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(" [span]adjusting for zeroEffectiveSpanBox\n");
|
|
printf(
|
|
" Original: minBCoord=%d, maxBCoord=%d, bSize=%d, ascent=%d, "
|
|
"logicalBSize=%d, topLeading=%d, bottomLeading=%d\n",
|
|
minBCoord, maxBCoord, spanFramePFD->mBounds.BSize(lineWM),
|
|
spanFramePFD->mAscent, psd->mLogicalBSize, psd->mBStartLeading,
|
|
psd->mBEndLeading);
|
|
#endif
|
|
nscoord goodMinBCoord =
|
|
spanFramePFD->mBorderPadding.BStart(lineWM) - psd->mBStartLeading;
|
|
nscoord goodMaxBCoord = goodMinBCoord + psd->mLogicalBSize;
|
|
|
|
// For cases like the one in bug 714519 (text-decoration placement
|
|
// or making nsLineLayout::IsZeroBSize() handle
|
|
// vertical-align:top/bottom on a descendant of the line that's not
|
|
// a child of it), we want to treat elements that are
|
|
// vertical-align: top or bottom somewhat like children for the
|
|
// purposes of this quirk. To some extent, this is guessing, since
|
|
// they might end up being aligned anywhere. However, we'll guess
|
|
// that they'll be placed aligned with the top or bottom of this
|
|
// frame (as though this frame is the only thing in the line).
|
|
// (Guessing isn't crazy, since all we're doing is reducing the
|
|
// scope of a quirk and making the behavior more standards-like.)
|
|
if (maxStartBoxBSize > maxBCoord - minBCoord) {
|
|
// Distribute maxStartBoxBSize to ascent (baselineBCoord - minBCoord), and
|
|
// then to descent (maxBCoord - baselineBCoord) by adjusting minBCoord or
|
|
// maxBCoord, but not to exceed goodMinBCoord and goodMaxBCoord.
|
|
nscoord distribute = maxStartBoxBSize - (maxBCoord - minBCoord);
|
|
nscoord ascentSpace = std::max(minBCoord - goodMinBCoord, 0);
|
|
if (distribute > ascentSpace) {
|
|
distribute -= ascentSpace;
|
|
minBCoord -= ascentSpace;
|
|
nscoord descentSpace = std::max(goodMaxBCoord - maxBCoord, 0);
|
|
if (distribute > descentSpace) {
|
|
maxBCoord += descentSpace;
|
|
} else {
|
|
maxBCoord += distribute;
|
|
}
|
|
} else {
|
|
minBCoord -= distribute;
|
|
}
|
|
}
|
|
if (maxEndBoxBSize > maxBCoord - minBCoord) {
|
|
// Likewise, but preferring descent to ascent.
|
|
nscoord distribute = maxEndBoxBSize - (maxBCoord - minBCoord);
|
|
nscoord descentSpace = std::max(goodMaxBCoord - maxBCoord, 0);
|
|
if (distribute > descentSpace) {
|
|
distribute -= descentSpace;
|
|
maxBCoord += descentSpace;
|
|
nscoord ascentSpace = std::max(minBCoord - goodMinBCoord, 0);
|
|
if (distribute > ascentSpace) {
|
|
minBCoord -= ascentSpace;
|
|
} else {
|
|
minBCoord -= distribute;
|
|
}
|
|
} else {
|
|
maxBCoord += distribute;
|
|
}
|
|
}
|
|
|
|
if (minBCoord > goodMinBCoord) {
|
|
nscoord adjust = minBCoord - goodMinBCoord; // positive
|
|
|
|
// shrink the logical extents
|
|
psd->mLogicalBSize -= adjust;
|
|
psd->mBStartLeading -= adjust;
|
|
}
|
|
if (maxBCoord < goodMaxBCoord) {
|
|
nscoord adjust = goodMaxBCoord - maxBCoord;
|
|
psd->mLogicalBSize -= adjust;
|
|
psd->mBEndLeading -= adjust;
|
|
}
|
|
if (minBCoord > 0) {
|
|
// shrink the content by moving its block start down. This is tricky,
|
|
// since the block start is the 0 for many coordinates, so what we do is
|
|
// move everything else up.
|
|
spanFramePFD->mAscent -= minBCoord; // move the baseline up
|
|
spanFramePFD->mBounds.BSize(lineWM) -=
|
|
minBCoord; // move the block end up
|
|
psd->mBStartLeading += minBCoord;
|
|
*psd->mBaseline -= minBCoord;
|
|
|
|
pfd = psd->mFirstFrame;
|
|
while (nullptr != pfd) {
|
|
pfd->mBounds.BStart(lineWM) -= minBCoord; // move all the children
|
|
// back up
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd));
|
|
pfd = pfd->mNext;
|
|
}
|
|
maxBCoord -= minBCoord; // since minBCoord is in the frame's own
|
|
// coordinate system
|
|
minBCoord = 0;
|
|
}
|
|
if (maxBCoord < spanFramePFD->mBounds.BSize(lineWM)) {
|
|
nscoord adjust = spanFramePFD->mBounds.BSize(lineWM) - maxBCoord;
|
|
spanFramePFD->mBounds.BSize(lineWM) -= adjust; // move the bottom up
|
|
psd->mBEndLeading += adjust;
|
|
}
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(
|
|
" New: minBCoord=%d, maxBCoord=%d, bSize=%d, ascent=%d, "
|
|
"logicalBSize=%d, topLeading=%d, bottomLeading=%d\n",
|
|
minBCoord, maxBCoord, spanFramePFD->mBounds.BSize(lineWM),
|
|
spanFramePFD->mAscent, psd->mLogicalBSize, psd->mBStartLeading,
|
|
psd->mBEndLeading);
|
|
#endif
|
|
}
|
|
|
|
psd->mMinBCoord = minBCoord;
|
|
psd->mMaxBCoord = maxBCoord;
|
|
#ifdef NOISY_BLOCKDIR_ALIGN
|
|
printf(
|
|
" [span]==> minBCoord=%d maxBCoord=%d delta=%d maxStartBoxBSize=%d "
|
|
"maxEndBoxBSize=%d\n",
|
|
minBCoord, maxBCoord, maxBCoord - minBCoord, maxStartBoxBSize,
|
|
maxEndBoxBSize);
|
|
#endif
|
|
if (maxStartBoxBSize > mMaxStartBoxBSize) {
|
|
mMaxStartBoxBSize = maxStartBoxBSize;
|
|
}
|
|
if (maxEndBoxBSize > mMaxEndBoxBSize) {
|
|
mMaxEndBoxBSize = maxEndBoxBSize;
|
|
}
|
|
}
|
|
|
|
static void SlideSpanFrameRect(nsIFrame* aFrame, nscoord aDeltaWidth) {
|
|
// This should not use nsIFrame::MovePositionBy because it happens
|
|
// prior to relative positioning. In particular, because
|
|
// nsBlockFrame::PlaceLine calls aLineLayout.TrimTrailingWhiteSpace()
|
|
// prior to calling aLineLayout.RelativePositionFrames().
|
|
nsPoint p = aFrame->GetPosition();
|
|
p.x -= aDeltaWidth;
|
|
aFrame->SetPosition(p);
|
|
}
|
|
|
|
bool nsLineLayout::TrimTrailingWhiteSpaceIn(PerSpanData* psd,
|
|
nscoord* aDeltaISize) {
|
|
PerFrameData* pfd = psd->mFirstFrame;
|
|
if (!pfd) {
|
|
*aDeltaISize = 0;
|
|
return false;
|
|
}
|
|
pfd = pfd->Last();
|
|
while (nullptr != pfd) {
|
|
#ifdef REALLY_NOISY_TRIM
|
|
psd->mFrame->mFrame->ListTag(stdout);
|
|
printf(": attempting trim of ");
|
|
pfd->mFrame->ListTag(stdout);
|
|
printf("\n");
|
|
#endif
|
|
PerSpanData* childSpan = pfd->mSpan;
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
if (childSpan) {
|
|
// Maybe the child span has the trailing white-space in it?
|
|
if (TrimTrailingWhiteSpaceIn(childSpan, aDeltaISize)) {
|
|
nscoord deltaISize = *aDeltaISize;
|
|
if (deltaISize) {
|
|
// Adjust the child spans frame size
|
|
pfd->mBounds.ISize(lineWM) -= deltaISize;
|
|
if (psd != mRootSpan) {
|
|
// When the child span is not a direct child of the block
|
|
// we need to update the child spans frame rectangle
|
|
// because it most likely will not be done again. Spans
|
|
// that are direct children of the block will be updated
|
|
// later, however, because the VerticalAlignFrames method
|
|
// will be run after this method.
|
|
nsSize containerSize = ContainerSizeForSpan(childSpan);
|
|
nsIFrame* f = pfd->mFrame;
|
|
LogicalRect r(lineWM, f->GetRect(), containerSize);
|
|
r.ISize(lineWM) -= deltaISize;
|
|
f->SetRect(lineWM, r, containerSize);
|
|
}
|
|
|
|
// Adjust the inline end edge of the span that contains the child span
|
|
psd->mICoord -= deltaISize;
|
|
|
|
// Slide any frames that follow the child span over by the
|
|
// correct amount. The only thing that can follow the child
|
|
// span is empty stuff, so we are just making things
|
|
// sensible (keeping the combined area honest).
|
|
while (pfd->mNext) {
|
|
pfd = pfd->mNext;
|
|
pfd->mBounds.IStart(lineWM) -= deltaISize;
|
|
if (psd != mRootSpan) {
|
|
// When the child span is not a direct child of the block
|
|
// we need to update the child span's frame rectangle
|
|
// because it most likely will not be done again. Spans
|
|
// that are direct children of the block will be updated
|
|
// later, however, because the VerticalAlignFrames method
|
|
// will be run after this method.
|
|
SlideSpanFrameRect(pfd->mFrame, deltaISize);
|
|
}
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
} else if (!pfd->mIsTextFrame && !pfd->mSkipWhenTrimmingWhitespace) {
|
|
// If we hit a frame on the end that's not text and not a placeholder,
|
|
// then there is no trailing whitespace to trim. Stop the search.
|
|
*aDeltaISize = 0;
|
|
return true;
|
|
} else if (pfd->mIsTextFrame) {
|
|
// Call TrimTrailingWhiteSpace even on empty textframes because they
|
|
// might have a soft hyphen which should now appear, changing the frame's
|
|
// width
|
|
nsTextFrame::TrimOutput trimOutput =
|
|
static_cast<nsTextFrame*>(pfd->mFrame)
|
|
->TrimTrailingWhiteSpace(
|
|
mBlockReflowInput->mRenderingContext->GetDrawTarget());
|
|
#ifdef NOISY_TRIM
|
|
psd->mFrame->mFrame->ListTag(stdout);
|
|
printf(": trim of ");
|
|
pfd->mFrame->ListTag(stdout);
|
|
printf(" returned %d\n", trimOutput.mDeltaWidth);
|
|
#endif
|
|
|
|
if (trimOutput.mChanged) {
|
|
pfd->mRecomputeOverflow = true;
|
|
}
|
|
|
|
// Delta width not being zero means that
|
|
// there is trimmed space in the frame.
|
|
if (trimOutput.mDeltaWidth) {
|
|
pfd->mBounds.ISize(lineWM) -= trimOutput.mDeltaWidth;
|
|
|
|
// If any trailing space is trimmed, the justification opportunity
|
|
// generated by the space should be removed as well.
|
|
pfd->mJustificationInfo.CancelOpportunityForTrimmedSpace();
|
|
|
|
// See if the text frame has already been placed in its parent
|
|
if (psd != mRootSpan) {
|
|
// The frame was already placed during psd's
|
|
// reflow. Update the frames rectangle now.
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd));
|
|
}
|
|
|
|
// Adjust containing span's right edge
|
|
psd->mICoord -= trimOutput.mDeltaWidth;
|
|
|
|
// Slide any frames that follow the text frame over by the
|
|
// right amount. The only thing that can follow the text
|
|
// frame is empty stuff, so we are just making things
|
|
// sensible (keeping the combined area honest).
|
|
while (pfd->mNext) {
|
|
pfd = pfd->mNext;
|
|
pfd->mBounds.IStart(lineWM) -= trimOutput.mDeltaWidth;
|
|
if (psd != mRootSpan) {
|
|
// When the child span is not a direct child of the block
|
|
// we need to update the child spans frame rectangle
|
|
// because it most likely will not be done again. Spans
|
|
// that are direct children of the block will be updated
|
|
// later, however, because the VerticalAlignFrames method
|
|
// will be run after this method.
|
|
SlideSpanFrameRect(pfd->mFrame, trimOutput.mDeltaWidth);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (pfd->mIsNonEmptyTextFrame || trimOutput.mChanged) {
|
|
// Pass up to caller so they can shrink their span
|
|
*aDeltaISize = trimOutput.mDeltaWidth;
|
|
return true;
|
|
}
|
|
}
|
|
pfd = pfd->mPrev;
|
|
}
|
|
|
|
*aDeltaISize = 0;
|
|
return false;
|
|
}
|
|
|
|
bool nsLineLayout::TrimTrailingWhiteSpace() {
|
|
PerSpanData* psd = mRootSpan;
|
|
nscoord deltaISize;
|
|
TrimTrailingWhiteSpaceIn(psd, &deltaISize);
|
|
return 0 != deltaISize;
|
|
}
|
|
|
|
bool nsLineLayout::PerFrameData::ParticipatesInJustification() const {
|
|
if (mIsBullet || mIsEmpty || mSkipWhenTrimmingWhitespace) {
|
|
// Skip bullets, empty frames, and placeholders
|
|
return false;
|
|
}
|
|
if (mIsTextFrame && !mIsNonWhitespaceTextFrame &&
|
|
static_cast<nsTextFrame*>(mFrame)->IsAtEndOfLine()) {
|
|
// Skip trimmed whitespaces
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
struct nsLineLayout::JustificationComputationState {
|
|
PerFrameData* mFirstParticipant;
|
|
PerFrameData* mLastParticipant;
|
|
// When we are going across a boundary of ruby base, i.e. entering
|
|
// one, leaving one, or both, the following fields will be set to
|
|
// the corresponding ruby base frame for handling ruby-align.
|
|
PerFrameData* mLastExitedRubyBase;
|
|
PerFrameData* mLastEnteredRubyBase;
|
|
|
|
JustificationComputationState()
|
|
: mFirstParticipant(nullptr),
|
|
mLastParticipant(nullptr),
|
|
mLastExitedRubyBase(nullptr),
|
|
mLastEnteredRubyBase(nullptr) {}
|
|
};
|
|
|
|
static bool IsRubyAlignSpaceAround(nsIFrame* aRubyBase) {
|
|
return aRubyBase->StyleText()->mRubyAlign == NS_STYLE_RUBY_ALIGN_SPACE_AROUND;
|
|
}
|
|
|
|
/**
|
|
* Assign justification gaps for justification
|
|
* opportunities across two frames.
|
|
*/
|
|
/* static */ int nsLineLayout::AssignInterframeJustificationGaps(
|
|
PerFrameData* aFrame, JustificationComputationState& aState) {
|
|
PerFrameData* prev = aState.mLastParticipant;
|
|
MOZ_ASSERT(prev);
|
|
|
|
auto& assign = aFrame->mJustificationAssignment;
|
|
auto& prevAssign = prev->mJustificationAssignment;
|
|
|
|
if (aState.mLastExitedRubyBase || aState.mLastEnteredRubyBase) {
|
|
PerFrameData* exitedRubyBase = aState.mLastExitedRubyBase;
|
|
if (!exitedRubyBase || IsRubyAlignSpaceAround(exitedRubyBase->mFrame)) {
|
|
prevAssign.mGapsAtEnd = 1;
|
|
} else {
|
|
exitedRubyBase->mJustificationAssignment.mGapsAtEnd = 1;
|
|
}
|
|
|
|
PerFrameData* enteredRubyBase = aState.mLastEnteredRubyBase;
|
|
if (!enteredRubyBase || IsRubyAlignSpaceAround(enteredRubyBase->mFrame)) {
|
|
assign.mGapsAtStart = 1;
|
|
} else {
|
|
enteredRubyBase->mJustificationAssignment.mGapsAtStart = 1;
|
|
}
|
|
|
|
// We are no longer going across a ruby base boundary.
|
|
aState.mLastExitedRubyBase = nullptr;
|
|
aState.mLastEnteredRubyBase = nullptr;
|
|
return 1;
|
|
}
|
|
|
|
const auto& info = aFrame->mJustificationInfo;
|
|
const auto& prevInfo = prev->mJustificationInfo;
|
|
if (!info.mIsStartJustifiable && !prevInfo.mIsEndJustifiable) {
|
|
return 0;
|
|
}
|
|
|
|
if (!info.mIsStartJustifiable) {
|
|
prevAssign.mGapsAtEnd = 2;
|
|
assign.mGapsAtStart = 0;
|
|
} else if (!prevInfo.mIsEndJustifiable) {
|
|
prevAssign.mGapsAtEnd = 0;
|
|
assign.mGapsAtStart = 2;
|
|
} else {
|
|
prevAssign.mGapsAtEnd = 1;
|
|
assign.mGapsAtStart = 1;
|
|
}
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* Compute the justification info of the given span, and store the
|
|
* number of inner opportunities into the frame's justification info.
|
|
* It returns the number of non-inner opportunities it detects.
|
|
*/
|
|
int32_t nsLineLayout::ComputeFrameJustification(
|
|
PerSpanData* aPSD, JustificationComputationState& aState) {
|
|
NS_ASSERTION(aPSD, "null arg");
|
|
NS_ASSERTION(!aState.mLastParticipant || !aState.mLastParticipant->mSpan,
|
|
"Last participant shall always be a leaf frame");
|
|
bool firstChild = true;
|
|
int32_t& innerOpportunities =
|
|
aPSD->mFrame->mJustificationInfo.mInnerOpportunities;
|
|
MOZ_ASSERT(innerOpportunities == 0,
|
|
"Justification info should not have been set yet.");
|
|
int32_t outerOpportunities = 0;
|
|
|
|
for (PerFrameData* pfd = aPSD->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
if (!pfd->ParticipatesInJustification()) {
|
|
continue;
|
|
}
|
|
|
|
bool isRubyBase = pfd->mFrame->IsRubyBaseFrame();
|
|
PerFrameData* outerRubyBase = aState.mLastEnteredRubyBase;
|
|
if (isRubyBase) {
|
|
aState.mLastEnteredRubyBase = pfd;
|
|
}
|
|
|
|
int extraOpportunities = 0;
|
|
if (pfd->mSpan) {
|
|
PerSpanData* span = pfd->mSpan;
|
|
extraOpportunities = ComputeFrameJustification(span, aState);
|
|
innerOpportunities += pfd->mJustificationInfo.mInnerOpportunities;
|
|
} else {
|
|
if (pfd->mIsTextFrame) {
|
|
innerOpportunities += pfd->mJustificationInfo.mInnerOpportunities;
|
|
}
|
|
|
|
if (!aState.mLastParticipant) {
|
|
aState.mFirstParticipant = pfd;
|
|
// It is not an empty ruby base, but we are not assigning gaps
|
|
// to the content for now. Clear the last entered ruby base so
|
|
// that we can correctly set the last exited ruby base.
|
|
aState.mLastEnteredRubyBase = nullptr;
|
|
} else {
|
|
extraOpportunities = AssignInterframeJustificationGaps(pfd, aState);
|
|
}
|
|
|
|
aState.mLastParticipant = pfd;
|
|
}
|
|
|
|
if (isRubyBase) {
|
|
if (aState.mLastEnteredRubyBase == pfd) {
|
|
// There is no justification participant inside this ruby base.
|
|
// Ignore this ruby base completely and restore the outer ruby
|
|
// base here.
|
|
aState.mLastEnteredRubyBase = outerRubyBase;
|
|
} else {
|
|
aState.mLastExitedRubyBase = pfd;
|
|
}
|
|
}
|
|
|
|
if (firstChild) {
|
|
outerOpportunities = extraOpportunities;
|
|
firstChild = false;
|
|
} else {
|
|
innerOpportunities += extraOpportunities;
|
|
}
|
|
}
|
|
|
|
return outerOpportunities;
|
|
}
|
|
|
|
void nsLineLayout::AdvanceAnnotationInlineBounds(PerFrameData* aPFD,
|
|
const nsSize& aContainerSize,
|
|
nscoord aDeltaICoord,
|
|
nscoord aDeltaISize) {
|
|
nsIFrame* frame = aPFD->mFrame;
|
|
LayoutFrameType frameType = frame->Type();
|
|
MOZ_ASSERT(frameType == LayoutFrameType::RubyText ||
|
|
frameType == LayoutFrameType::RubyTextContainer);
|
|
MOZ_ASSERT(aPFD->mSpan, "rt and rtc should have span.");
|
|
|
|
PerSpanData* psd = aPFD->mSpan;
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
aPFD->mBounds.IStart(lineWM) += aDeltaICoord;
|
|
|
|
// Check whether this expansion should be counted into the reserved
|
|
// isize or not. When it is a ruby text container, and it has some
|
|
// children linked to the base, it must not have reserved isize,
|
|
// or its children won't align with their bases. Otherwise, this
|
|
// expansion should be reserved. There are two cases a ruby text
|
|
// container does not have children linked to the base:
|
|
// 1. it is a container for span; 2. its children are collapsed.
|
|
// See bug 1055674 for the second case.
|
|
if (frameType == LayoutFrameType::RubyText ||
|
|
// This ruby text container is a span.
|
|
(psd->mFirstFrame == psd->mLastFrame && psd->mFirstFrame &&
|
|
!psd->mFirstFrame->mIsLinkedToBase)) {
|
|
// For ruby text frames, only increase frames
|
|
// which are not auto-hidden.
|
|
if (frameType != LayoutFrameType::RubyText ||
|
|
!static_cast<nsRubyTextFrame*>(frame)->IsAutoHidden()) {
|
|
nscoord reservedISize = RubyUtils::GetReservedISize(frame);
|
|
RubyUtils::SetReservedISize(frame, reservedISize + aDeltaISize);
|
|
}
|
|
} else {
|
|
// It is a normal ruby text container. Its children will expand
|
|
// themselves properly. We only need to expand its own size here.
|
|
aPFD->mBounds.ISize(lineWM) += aDeltaISize;
|
|
}
|
|
aPFD->mFrame->SetRect(lineWM, aPFD->mBounds, aContainerSize);
|
|
}
|
|
|
|
/**
|
|
* This function applies the changes of icoord and isize caused by
|
|
* justification to annotations of the given frame.
|
|
*/
|
|
void nsLineLayout::ApplyLineJustificationToAnnotations(PerFrameData* aPFD,
|
|
nscoord aDeltaICoord,
|
|
nscoord aDeltaISize) {
|
|
PerFrameData* pfd = aPFD->mNextAnnotation;
|
|
while (pfd) {
|
|
nsSize containerSize = pfd->mFrame->GetParent()->GetSize();
|
|
AdvanceAnnotationInlineBounds(pfd, containerSize, aDeltaICoord,
|
|
aDeltaISize);
|
|
|
|
// There are two cases where an annotation frame has siblings which
|
|
// do not attached to a ruby base-level frame:
|
|
// 1. there's an intra-annotation whitespace which has no intra-base
|
|
// white-space to pair with;
|
|
// 2. there are not enough ruby bases to be paired with annotations.
|
|
// In these cases, their size should not be affected, but we still
|
|
// need to move them so that they won't overlap other frames.
|
|
PerFrameData* sibling = pfd->mNext;
|
|
while (sibling && !sibling->mIsLinkedToBase) {
|
|
AdvanceAnnotationInlineBounds(sibling, containerSize,
|
|
aDeltaICoord + aDeltaISize, 0);
|
|
sibling = sibling->mNext;
|
|
}
|
|
|
|
pfd = pfd->mNextAnnotation;
|
|
}
|
|
}
|
|
|
|
nscoord nsLineLayout::ApplyFrameJustification(
|
|
PerSpanData* aPSD, JustificationApplicationState& aState) {
|
|
NS_ASSERTION(aPSD, "null arg");
|
|
|
|
nscoord deltaICoord = 0;
|
|
for (PerFrameData* pfd = aPSD->mFirstFrame; pfd != nullptr;
|
|
pfd = pfd->mNext) {
|
|
nscoord dw = 0;
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
const auto& assign = pfd->mJustificationAssignment;
|
|
bool isInlineText =
|
|
pfd->mIsTextFrame && !pfd->mWritingMode.IsOrthogonalTo(lineWM);
|
|
|
|
// Don't apply justification if the frame doesn't participate. Same
|
|
// as the condition used in ComputeFrameJustification. Note that,
|
|
// we still need to move the frame based on deltaICoord even if the
|
|
// frame itself doesn't expand.
|
|
if (pfd->ParticipatesInJustification()) {
|
|
if (isInlineText) {
|
|
if (aState.IsJustifiable()) {
|
|
// Set corresponding justification gaps here, so that the
|
|
// text frame knows how it should add gaps at its sides.
|
|
const auto& info = pfd->mJustificationInfo;
|
|
auto textFrame = static_cast<nsTextFrame*>(pfd->mFrame);
|
|
textFrame->AssignJustificationGaps(assign);
|
|
dw = aState.Consume(JustificationUtils::CountGaps(info, assign));
|
|
}
|
|
|
|
if (dw) {
|
|
pfd->mRecomputeOverflow = true;
|
|
}
|
|
} else {
|
|
if (nullptr != pfd->mSpan) {
|
|
dw = ApplyFrameJustification(pfd->mSpan, aState);
|
|
}
|
|
}
|
|
} else {
|
|
MOZ_ASSERT(!assign.TotalGaps(),
|
|
"Non-participants shouldn't have assigned gaps");
|
|
}
|
|
|
|
pfd->mBounds.ISize(lineWM) += dw;
|
|
nscoord gapsAtEnd = 0;
|
|
if (!isInlineText && assign.TotalGaps()) {
|
|
// It is possible that we assign gaps to non-text frame or an
|
|
// orthogonal text frame. Apply the gaps as margin for them.
|
|
deltaICoord += aState.Consume(assign.mGapsAtStart);
|
|
gapsAtEnd = aState.Consume(assign.mGapsAtEnd);
|
|
dw += gapsAtEnd;
|
|
}
|
|
pfd->mBounds.IStart(lineWM) += deltaICoord;
|
|
|
|
// The gaps added to the end of the frame should also be
|
|
// excluded from the isize added to the annotation.
|
|
ApplyLineJustificationToAnnotations(pfd, deltaICoord, dw - gapsAtEnd);
|
|
deltaICoord += dw;
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(aPSD));
|
|
}
|
|
return deltaICoord;
|
|
}
|
|
|
|
static nsIFrame* FindNearestRubyBaseAncestor(nsIFrame* aFrame) {
|
|
MOZ_ASSERT(aFrame->Style()->ShouldSuppressLineBreak());
|
|
while (aFrame && !aFrame->IsRubyBaseFrame()) {
|
|
aFrame = aFrame->GetParent();
|
|
}
|
|
// XXX It is possible that no ruby base ancestor is found because of
|
|
// some edge cases like form control or canvas inside ruby text.
|
|
// See bug 1138092 comment 4.
|
|
NS_WARNING_ASSERTION(aFrame, "no ruby base ancestor?");
|
|
return aFrame;
|
|
}
|
|
|
|
/**
|
|
* This method expands the given frame by the given reserved isize.
|
|
*/
|
|
void nsLineLayout::ExpandRubyBox(PerFrameData* aFrame, nscoord aReservedISize,
|
|
const nsSize& aContainerSize) {
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
auto rubyAlign = aFrame->mFrame->StyleText()->mRubyAlign;
|
|
switch (rubyAlign) {
|
|
case NS_STYLE_RUBY_ALIGN_START:
|
|
// do nothing for start
|
|
break;
|
|
case NS_STYLE_RUBY_ALIGN_SPACE_BETWEEN:
|
|
case NS_STYLE_RUBY_ALIGN_SPACE_AROUND: {
|
|
int32_t opportunities = aFrame->mJustificationInfo.mInnerOpportunities;
|
|
int32_t gaps = opportunities * 2;
|
|
if (rubyAlign == NS_STYLE_RUBY_ALIGN_SPACE_AROUND) {
|
|
// Each expandable ruby box with ruby-align space-around has a
|
|
// gap at each of its sides. For rb/rbc, see comment in
|
|
// AssignInterframeJustificationGaps; for rt/rtc, see comment
|
|
// in ExpandRubyBoxWithAnnotations.
|
|
gaps += 2;
|
|
}
|
|
if (gaps > 0) {
|
|
JustificationApplicationState state(gaps, aReservedISize);
|
|
ApplyFrameJustification(aFrame->mSpan, state);
|
|
break;
|
|
}
|
|
// If there are no justification opportunities for space-between,
|
|
// fall-through to center per spec.
|
|
MOZ_FALLTHROUGH;
|
|
}
|
|
case NS_STYLE_RUBY_ALIGN_CENTER:
|
|
// Indent all children by half of the reserved inline size.
|
|
for (PerFrameData* child = aFrame->mSpan->mFirstFrame; child;
|
|
child = child->mNext) {
|
|
child->mBounds.IStart(lineWM) += aReservedISize / 2;
|
|
child->mFrame->SetRect(lineWM, child->mBounds, aContainerSize);
|
|
}
|
|
break;
|
|
default:
|
|
MOZ_ASSERT_UNREACHABLE("Unknown ruby-align value");
|
|
}
|
|
|
|
aFrame->mBounds.ISize(lineWM) += aReservedISize;
|
|
aFrame->mFrame->SetRect(lineWM, aFrame->mBounds, aContainerSize);
|
|
}
|
|
|
|
/**
|
|
* This method expands the given frame by the reserved inline size.
|
|
* It also expands its annotations if they are expandable and have
|
|
* reserved isize larger than zero.
|
|
*/
|
|
void nsLineLayout::ExpandRubyBoxWithAnnotations(PerFrameData* aFrame,
|
|
const nsSize& aContainerSize) {
|
|
nscoord reservedISize = RubyUtils::GetReservedISize(aFrame->mFrame);
|
|
if (reservedISize) {
|
|
ExpandRubyBox(aFrame, reservedISize, aContainerSize);
|
|
}
|
|
|
|
WritingMode lineWM = mRootSpan->mWritingMode;
|
|
bool isLevelContainer = aFrame->mFrame->IsRubyBaseContainerFrame();
|
|
for (PerFrameData* annotation = aFrame->mNextAnnotation; annotation;
|
|
annotation = annotation->mNextAnnotation) {
|
|
if (lineWM.IsOrthogonalTo(annotation->mFrame->GetWritingMode())) {
|
|
// Inter-character case: don't attempt to expand ruby annotations.
|
|
continue;
|
|
}
|
|
if (isLevelContainer) {
|
|
nsIFrame* rtcFrame = annotation->mFrame;
|
|
MOZ_ASSERT(rtcFrame->IsRubyTextContainerFrame());
|
|
// It is necessary to set the rect again because the container
|
|
// width was unknown, and zero was used instead when we reflow
|
|
// them. The corresponding base containers were repositioned in
|
|
// VerticalAlignFrames and PlaceTopBottomFrames.
|
|
MOZ_ASSERT(rtcFrame->GetLogicalSize(lineWM) ==
|
|
annotation->mBounds.Size(lineWM));
|
|
rtcFrame->SetPosition(lineWM, annotation->mBounds.Origin(lineWM),
|
|
aContainerSize);
|
|
}
|
|
|
|
nscoord reservedISize = RubyUtils::GetReservedISize(annotation->mFrame);
|
|
if (!reservedISize) {
|
|
continue;
|
|
}
|
|
|
|
MOZ_ASSERT(annotation->mSpan);
|
|
JustificationComputationState computeState;
|
|
ComputeFrameJustification(annotation->mSpan, computeState);
|
|
if (!computeState.mFirstParticipant) {
|
|
continue;
|
|
}
|
|
if (IsRubyAlignSpaceAround(annotation->mFrame)) {
|
|
// Add one gap at each side of this annotation.
|
|
computeState.mFirstParticipant->mJustificationAssignment.mGapsAtStart = 1;
|
|
computeState.mLastParticipant->mJustificationAssignment.mGapsAtEnd = 1;
|
|
}
|
|
nsIFrame* parentFrame = annotation->mFrame->GetParent();
|
|
nsSize containerSize = parentFrame->GetSize();
|
|
MOZ_ASSERT(containerSize == aContainerSize ||
|
|
parentFrame->IsRubyTextContainerFrame(),
|
|
"Container width should only be different when the current "
|
|
"annotation is a ruby text frame, whose parent is not same "
|
|
"as its base frame.");
|
|
ExpandRubyBox(annotation, reservedISize, containerSize);
|
|
ExpandInlineRubyBoxes(annotation->mSpan);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* This method looks for all expandable ruby box in the given span, and
|
|
* calls ExpandRubyBox to expand them in depth-first preorder.
|
|
*/
|
|
void nsLineLayout::ExpandInlineRubyBoxes(PerSpanData* aSpan) {
|
|
nsSize containerSize = ContainerSizeForSpan(aSpan);
|
|
for (PerFrameData* pfd = aSpan->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
if (RubyUtils::IsExpandableRubyBox(pfd->mFrame)) {
|
|
ExpandRubyBoxWithAnnotations(pfd, containerSize);
|
|
}
|
|
if (pfd->mSpan) {
|
|
ExpandInlineRubyBoxes(pfd->mSpan);
|
|
}
|
|
}
|
|
}
|
|
|
|
// Align inline frames within the line according to the CSS text-align
|
|
// property.
|
|
void nsLineLayout::TextAlignLine(nsLineBox* aLine, bool aIsLastLine) {
|
|
/**
|
|
* NOTE: aIsLastLine ain't necessarily so: it is correctly set by caller
|
|
* only in cases where the last line needs special handling.
|
|
*/
|
|
PerSpanData* psd = mRootSpan;
|
|
WritingMode lineWM = psd->mWritingMode;
|
|
LAYOUT_WARN_IF_FALSE(psd->mIEnd != NS_UNCONSTRAINEDSIZE,
|
|
"have unconstrained width; this should only result from "
|
|
"very large sizes, not attempts at intrinsic width "
|
|
"calculation");
|
|
nscoord availISize = psd->mIEnd - psd->mIStart;
|
|
nscoord remainingISize = availISize - aLine->ISize();
|
|
#ifdef NOISY_INLINEDIR_ALIGN
|
|
mBlockReflowInput->mFrame->ListTag(stdout);
|
|
printf(": availISize=%d lineBounds.IStart=%d lineISize=%d delta=%d\n",
|
|
availISize, aLine->IStart(), aLine->ISize(), remainingISize);
|
|
#endif
|
|
|
|
// 'text-align-last: auto' is equivalent to the value of the 'text-align'
|
|
// property except when 'text-align' is set to 'justify', in which case it
|
|
// is 'justify' when 'text-justify' is 'distribute' and 'start' otherwise.
|
|
//
|
|
// XXX: the code below will have to change when we implement text-justify
|
|
//
|
|
nscoord dx = 0;
|
|
uint8_t textAlign = mStyleText->mTextAlign;
|
|
if (aIsLastLine) {
|
|
if (mStyleText->mTextAlignLast == NS_STYLE_TEXT_ALIGN_AUTO) {
|
|
if (textAlign == NS_STYLE_TEXT_ALIGN_JUSTIFY) {
|
|
textAlign = NS_STYLE_TEXT_ALIGN_START;
|
|
}
|
|
} else {
|
|
textAlign = mStyleText->mTextAlignLast;
|
|
}
|
|
}
|
|
|
|
bool isSVG = nsSVGUtils::IsInSVGTextSubtree(mBlockReflowInput->mFrame);
|
|
bool doTextAlign = remainingISize > 0;
|
|
|
|
int32_t additionalGaps = 0;
|
|
if (!isSVG &&
|
|
(mHasRuby || (doTextAlign && textAlign == NS_STYLE_TEXT_ALIGN_JUSTIFY))) {
|
|
JustificationComputationState computeState;
|
|
ComputeFrameJustification(psd, computeState);
|
|
if (mHasRuby && computeState.mFirstParticipant) {
|
|
PerFrameData* firstFrame = computeState.mFirstParticipant;
|
|
if (firstFrame->mFrame->Style()->ShouldSuppressLineBreak()) {
|
|
MOZ_ASSERT(!firstFrame->mJustificationAssignment.mGapsAtStart);
|
|
nsIFrame* rubyBase = FindNearestRubyBaseAncestor(firstFrame->mFrame);
|
|
if (rubyBase && IsRubyAlignSpaceAround(rubyBase)) {
|
|
firstFrame->mJustificationAssignment.mGapsAtStart = 1;
|
|
additionalGaps++;
|
|
}
|
|
}
|
|
PerFrameData* lastFrame = computeState.mLastParticipant;
|
|
if (lastFrame->mFrame->Style()->ShouldSuppressLineBreak()) {
|
|
MOZ_ASSERT(!lastFrame->mJustificationAssignment.mGapsAtEnd);
|
|
nsIFrame* rubyBase = FindNearestRubyBaseAncestor(lastFrame->mFrame);
|
|
if (rubyBase && IsRubyAlignSpaceAround(rubyBase)) {
|
|
lastFrame->mJustificationAssignment.mGapsAtEnd = 1;
|
|
additionalGaps++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isSVG && doTextAlign) {
|
|
switch (textAlign) {
|
|
case NS_STYLE_TEXT_ALIGN_JUSTIFY: {
|
|
int32_t opportunities =
|
|
psd->mFrame->mJustificationInfo.mInnerOpportunities;
|
|
if (opportunities > 0) {
|
|
int32_t gaps = opportunities * 2 + additionalGaps;
|
|
JustificationApplicationState applyState(gaps, remainingISize);
|
|
|
|
// Apply the justification, and make sure to update our linebox
|
|
// width to account for it.
|
|
aLine->ExpandBy(ApplyFrameJustification(psd, applyState),
|
|
ContainerSizeForSpan(psd));
|
|
|
|
MOZ_ASSERT(applyState.mGaps.mHandled == applyState.mGaps.mCount,
|
|
"Unprocessed justification gaps");
|
|
MOZ_ASSERT(
|
|
applyState.mWidth.mConsumed == applyState.mWidth.mAvailable,
|
|
"Unprocessed justification width");
|
|
break;
|
|
}
|
|
// Fall through to the default case if we could not justify to fill
|
|
// the space.
|
|
MOZ_FALLTHROUGH;
|
|
}
|
|
|
|
case NS_STYLE_TEXT_ALIGN_START:
|
|
// default alignment is to start edge so do nothing
|
|
break;
|
|
|
|
case NS_STYLE_TEXT_ALIGN_LEFT:
|
|
case NS_STYLE_TEXT_ALIGN_MOZ_LEFT:
|
|
if (!lineWM.IsBidiLTR()) {
|
|
dx = remainingISize;
|
|
}
|
|
break;
|
|
|
|
case NS_STYLE_TEXT_ALIGN_RIGHT:
|
|
case NS_STYLE_TEXT_ALIGN_MOZ_RIGHT:
|
|
if (lineWM.IsBidiLTR()) {
|
|
dx = remainingISize;
|
|
}
|
|
break;
|
|
|
|
case NS_STYLE_TEXT_ALIGN_END:
|
|
dx = remainingISize;
|
|
break;
|
|
|
|
case NS_STYLE_TEXT_ALIGN_CENTER:
|
|
case NS_STYLE_TEXT_ALIGN_MOZ_CENTER:
|
|
dx = remainingISize / 2;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (mHasRuby) {
|
|
ExpandInlineRubyBoxes(mRootSpan);
|
|
}
|
|
|
|
if (mPresContext->BidiEnabled() &&
|
|
(!mPresContext->IsVisualMode() || !lineWM.IsBidiLTR())) {
|
|
PerFrameData* startFrame = psd->mFirstFrame;
|
|
MOZ_ASSERT(startFrame, "empty line?");
|
|
if (startFrame->mIsBullet) {
|
|
// Bullet shouldn't participate in bidi reordering.
|
|
startFrame = startFrame->mNext;
|
|
MOZ_ASSERT(startFrame, "no frame after bullet?");
|
|
MOZ_ASSERT(!startFrame->mIsBullet, "multiple bullets?");
|
|
}
|
|
nsBidiPresUtils::ReorderFrames(startFrame->mFrame, aLine->GetChildCount(),
|
|
lineWM, mContainerSize,
|
|
psd->mIStart + mTextIndent + dx);
|
|
if (dx) {
|
|
aLine->IndentBy(dx, ContainerSize());
|
|
}
|
|
} else if (dx) {
|
|
for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
pfd->mBounds.IStart(lineWM) += dx;
|
|
pfd->mFrame->SetRect(lineWM, pfd->mBounds, ContainerSizeForSpan(psd));
|
|
}
|
|
aLine->IndentBy(dx, ContainerSize());
|
|
}
|
|
}
|
|
|
|
// This method applies any relative positioning to the given frame.
|
|
void nsLineLayout::ApplyRelativePositioning(PerFrameData* aPFD) {
|
|
if (!aPFD->mRelativePos) {
|
|
return;
|
|
}
|
|
|
|
nsIFrame* frame = aPFD->mFrame;
|
|
WritingMode frameWM = aPFD->mWritingMode;
|
|
LogicalPoint origin = frame->GetLogicalPosition(ContainerSize());
|
|
// right and bottom are handled by
|
|
// ReflowInput::ComputeRelativeOffsets
|
|
ReflowInput::ApplyRelativePositioning(frame, frameWM, aPFD->mOffsets, &origin,
|
|
ContainerSize());
|
|
frame->SetPosition(frameWM, origin, ContainerSize());
|
|
}
|
|
|
|
// This method do relative positioning for ruby annotations.
|
|
void nsLineLayout::RelativePositionAnnotations(
|
|
PerSpanData* aRubyPSD, nsOverflowAreas& aOverflowAreas) {
|
|
MOZ_ASSERT(aRubyPSD->mFrame->mFrame->IsRubyFrame());
|
|
for (PerFrameData* pfd = aRubyPSD->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
MOZ_ASSERT(pfd->mFrame->IsRubyBaseContainerFrame());
|
|
for (PerFrameData* rtc = pfd->mNextAnnotation; rtc;
|
|
rtc = rtc->mNextAnnotation) {
|
|
nsIFrame* rtcFrame = rtc->mFrame;
|
|
MOZ_ASSERT(rtcFrame->IsRubyTextContainerFrame());
|
|
ApplyRelativePositioning(rtc);
|
|
nsOverflowAreas rtcOverflowAreas;
|
|
RelativePositionFrames(rtc->mSpan, rtcOverflowAreas);
|
|
aOverflowAreas.UnionWith(rtcOverflowAreas + rtcFrame->GetPosition());
|
|
}
|
|
}
|
|
}
|
|
|
|
void nsLineLayout::RelativePositionFrames(PerSpanData* psd,
|
|
nsOverflowAreas& aOverflowAreas) {
|
|
nsOverflowAreas overflowAreas;
|
|
WritingMode wm = psd->mWritingMode;
|
|
if (psd != mRootSpan) {
|
|
// The span's overflow areas come in three parts:
|
|
// -- this frame's width and height
|
|
// -- pfd->mOverflowAreas, which is the area of a bullet or the union
|
|
// of a relatively positioned frame's absolute children
|
|
// -- the bounds of all inline descendants
|
|
// The former two parts are computed right here, we gather the descendants
|
|
// below.
|
|
// At this point psd->mFrame->mBounds might be out of date since
|
|
// bidi reordering can move and resize the frames. So use the frame's
|
|
// rect instead of mBounds.
|
|
nsRect adjustedBounds(nsPoint(0, 0), psd->mFrame->mFrame->GetSize());
|
|
|
|
overflowAreas.ScrollableOverflow().UnionRect(
|
|
psd->mFrame->mOverflowAreas.ScrollableOverflow(), adjustedBounds);
|
|
overflowAreas.VisualOverflow().UnionRect(
|
|
psd->mFrame->mOverflowAreas.VisualOverflow(), adjustedBounds);
|
|
} else {
|
|
LogicalRect rect(wm, psd->mIStart, mBStartEdge, psd->mICoord - psd->mIStart,
|
|
mFinalLineBSize);
|
|
// The minimum combined area for the frames that are direct
|
|
// children of the block starts at the upper left corner of the
|
|
// line and is sized to match the size of the line's bounding box
|
|
// (the same size as the values returned from VerticalAlignFrames)
|
|
overflowAreas.VisualOverflow() = rect.GetPhysicalRect(wm, ContainerSize());
|
|
overflowAreas.ScrollableOverflow() = overflowAreas.VisualOverflow();
|
|
}
|
|
|
|
for (PerFrameData* pfd = psd->mFirstFrame; pfd; pfd = pfd->mNext) {
|
|
nsIFrame* frame = pfd->mFrame;
|
|
|
|
// Adjust the origin of the frame
|
|
ApplyRelativePositioning(pfd);
|
|
|
|
// We must position the view correctly before positioning its
|
|
// descendants so that widgets are positioned properly (since only
|
|
// some views have widgets).
|
|
if (frame->HasView())
|
|
nsContainerFrame::SyncFrameViewAfterReflow(
|
|
mPresContext, frame, frame->GetView(),
|
|
pfd->mOverflowAreas.VisualOverflow(), NS_FRAME_NO_SIZE_VIEW);
|
|
|
|
// Note: the combined area of a child is in its coordinate
|
|
// system. We adjust the childs combined area into our coordinate
|
|
// system before computing the aggregated value by adding in
|
|
// <b>x</b> and <b>y</b> which were computed above.
|
|
nsOverflowAreas r;
|
|
if (pfd->mSpan) {
|
|
// Compute a new combined area for the child span before
|
|
// aggregating it into our combined area.
|
|
RelativePositionFrames(pfd->mSpan, r);
|
|
} else {
|
|
r = pfd->mOverflowAreas;
|
|
if (pfd->mIsTextFrame) {
|
|
// We need to recompute overflow areas in four cases:
|
|
// (1) When PFD_RECOMPUTEOVERFLOW is set due to trimming
|
|
// (2) When there are text decorations, since we can't recompute the
|
|
// overflow area until Reflow and VerticalAlignLine have finished
|
|
// (3) When there are text emphasis marks, since the marks may be
|
|
// put further away if the text is inside ruby.
|
|
// (4) When there are text strokes
|
|
if (pfd->mRecomputeOverflow ||
|
|
frame->Style()->HasTextDecorationLines() ||
|
|
frame->StyleText()->HasTextEmphasis() ||
|
|
frame->StyleText()->HasWebkitTextStroke()) {
|
|
nsTextFrame* f = static_cast<nsTextFrame*>(frame);
|
|
r = f->RecomputeOverflow(mBlockReflowInput->mFrame);
|
|
}
|
|
frame->FinishAndStoreOverflow(r, frame->GetSize());
|
|
}
|
|
|
|
// If we have something that's not an inline but with a complex frame
|
|
// hierarchy inside that contains views, they need to be
|
|
// positioned.
|
|
// All descendant views must be repositioned even if this frame
|
|
// does have a view in case this frame's view does not have a
|
|
// widget and some of the descendant views do have widgets --
|
|
// otherwise the widgets won't be repositioned.
|
|
nsContainerFrame::PositionChildViews(frame);
|
|
}
|
|
|
|
// Do this here (rather than along with setting the overflow rect
|
|
// below) so we get leaf frames as well. No need to worry
|
|
// about the root span, since it doesn't have a frame.
|
|
if (frame->HasView())
|
|
nsContainerFrame::SyncFrameViewAfterReflow(
|
|
mPresContext, frame, frame->GetView(), r.VisualOverflow(),
|
|
NS_FRAME_NO_MOVE_VIEW);
|
|
|
|
overflowAreas.UnionWith(r + frame->GetPosition());
|
|
}
|
|
|
|
// Also compute relative position in the annotations.
|
|
if (psd->mFrame->mFrame->IsRubyFrame()) {
|
|
RelativePositionAnnotations(psd, overflowAreas);
|
|
}
|
|
|
|
// If we just computed a spans combined area, we need to update its
|
|
// overflow rect...
|
|
if (psd != mRootSpan) {
|
|
PerFrameData* spanPFD = psd->mFrame;
|
|
nsIFrame* frame = spanPFD->mFrame;
|
|
frame->FinishAndStoreOverflow(overflowAreas, frame->GetSize());
|
|
}
|
|
aOverflowAreas = overflowAreas;
|
|
}
|