static
void DebugCheckChildSize(nsIFrame* aChild,
nsHTMLReflowMetrics& aMet)
{
WritingMode wm = aMet.GetWritingMode();
if ((aMet.ISize(wm) < 0) || (aMet.ISize(wm) > PROBABLY_TOO_LARGE)) {
printf("WARNING: cell content %p has large inline size %d \n",
static_cast<void*>(aChild), int32_t(aMet.ISize(wm)));
}
}
/* virtual */ void
nsRubyTextFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsRubyBaseFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (!aReflowState.mLineLayout) {
NS_ASSERTION(aReflowState.mLineLayout,
"No line layout provided to RubyTextFrame reflow method.");
aStatus = NS_FRAME_COMPLETE;
return;
}
WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode();
WritingMode frameWM = aReflowState.GetWritingMode();
LogicalMargin borderPadding = aReflowState.ComputedLogicalBorderPadding();
aStatus = NS_FRAME_COMPLETE;
LogicalSize availSize(lineWM, aReflowState.AvailableWidth(),
aReflowState.AvailableHeight());
// Begin the span for the ruby text frame
nscoord availableISize = aReflowState.AvailableISize();
NS_ASSERTION(availableISize != NS_UNCONSTRAINEDSIZE,
"should no longer use available widths");
// Subtract off inline axis border+padding from availableISize
availableISize -= borderPadding.IStartEnd(frameWM);
aReflowState.mLineLayout->BeginSpan(this, &aReflowState,
borderPadding.IStart(frameWM),
availableISize, &mBaseline);
for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {
nsReflowStatus frameReflowStatus;
nsHTMLReflowMetrics metrics(aReflowState, aDesiredSize.mFlags);
bool pushedFrame;
aReflowState.mLineLayout->ReflowFrame(e.get(), frameReflowStatus,
&metrics, pushedFrame);
NS_ASSERTION(!pushedFrame,
"Ruby line breaking is not yet implemented");
e.get()->SetSize(LogicalSize(lineWM, metrics.ISize(lineWM),
metrics.BSize(lineWM)));
}
aDesiredSize.ISize(lineWM) = aReflowState.mLineLayout->EndSpan(this);
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, aReflowState,
borderPadding, lineWM, frameWM);
}
/* virtual */ void
nsRubyTextFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
// Even if we want to hide this frame, we have to reflow it first.
// If we leave it dirty, changes to its content will never be
// propagated to the ancestors, then it won't be displayed even if
// the content is no longer the same, until next reflow triggered by
// some other change. In general, we always reflow all the frames we
// created. There might be other problems if we don't do that.
nsRubyTextFrameSuper::Reflow(aPresContext, aDesiredSize,
aReflowState, aStatus);
if (IsAutoHidden()) {
// Reset the ISize. The BSize is not changed so that it won't
// affect vertical positioning in unexpected way.
WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode();
aDesiredSize.ISize(lineWM) = 0;
aDesiredSize.SetOverflowAreasToDesiredBounds();
}
}
/* virtual */ void
nsRubyTextContainerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsRubyTextContainerFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
// All rt children have already been reflowed. All we need to do is clean up
// the line layout.
aStatus = NS_FRAME_COMPLETE;
mozilla::WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode();
mozilla::WritingMode frameWM = aReflowState.GetWritingMode();
mozilla::LogicalMargin borderPadding =
aReflowState.ComputedLogicalBorderPadding();
aDesiredSize.ISize(lineWM) = mISize;
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, aReflowState,
borderPadding, lineWM, frameWM);
nscoord bsize = aDesiredSize.BSize(lineWM);
if (!mLines.empty()) {
// Okay to use BlockStartAscent because it has just been correctly set by
// nsLayoutUtils::SetBSizeFromFontMetrics.
mLines.begin()->SetLogicalAscent(aDesiredSize.BlockStartAscent());
mLines.begin()->SetBounds(aReflowState.GetWritingMode(), 0, 0, mISize,
bsize, mISize);
}
if (mLineLayout) {
mLineLayout->EndLineReflow();
mLineLayout = nullptr;
}
}
void
nsPageContentFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsPageContentFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aStatus = NS_FRAME_COMPLETE; // initialize out parameter
if (GetPrevInFlow() && (GetStateBits() & NS_FRAME_FIRST_REFLOW)) {
nsresult rv = aPresContext->PresShell()->FrameConstructor()
->ReplicateFixedFrames(this);
if (NS_FAILED(rv)) {
return;
}
}
// Set our size up front, since some parts of reflow depend on it
// being already set. Note that the computed height may be
// unconstrained; that's ok. Consumers should watch out for that.
nsSize maxSize(aReflowState.ComputedWidth(),
aReflowState.ComputedHeight());
SetSize(maxSize);
// A PageContentFrame must always have one child: the canvas frame.
// Resize our frame allowing it only to be as big as we are
// XXX Pay attention to the page's border and padding...
if (mFrames.NotEmpty()) {
nsIFrame* frame = mFrames.FirstChild();
WritingMode wm = frame->GetWritingMode();
LogicalSize logicalSize(wm, maxSize);
nsHTMLReflowState kidReflowState(aPresContext, aReflowState,
frame, logicalSize);
kidReflowState.SetComputedBSize(logicalSize.BSize(wm));
// Reflow the page content area
ReflowChild(frame, aPresContext, aDesiredSize, kidReflowState, 0, 0, 0, aStatus);
// The document element's background should cover the entire canvas, so
// take into account the combined area and any space taken up by
// absolutely positioned elements
nsMargin padding(0,0,0,0);
// XXXbz this screws up percentage padding (sets padding to zero
// in the percentage padding case)
kidReflowState.mStylePadding->GetPadding(padding);
// This is for shrink-to-fit, and therefore we want to use the
// scrollable overflow, since the purpose of shrink to fit is to
// make the content that ought to be reachable (represented by the
// scrollable overflow) fit in the page.
if (frame->HasOverflowAreas()) {
// The background covers the content area and padding area, so check
// for children sticking outside the child frame's padding edge
nscoord xmost = aDesiredSize.ScrollableOverflow().XMost();
if (xmost > aDesiredSize.Width()) {
nscoord widthToFit = xmost + padding.right +
kidReflowState.mStyleBorder->GetComputedBorderWidth(NS_SIDE_RIGHT);
float ratio = float(maxSize.width) / widthToFit;
NS_ASSERTION(ratio >= 0.0 && ratio < 1.0, "invalid shrink-to-fit ratio");
mPD->mShrinkToFitRatio = std::min(mPD->mShrinkToFitRatio, ratio);
}
}
// Place and size the child
FinishReflowChild(frame, aPresContext, aDesiredSize, &kidReflowState, 0, 0, 0);
NS_ASSERTION(aPresContext->IsDynamic() || !NS_FRAME_IS_FULLY_COMPLETE(aStatus) ||
!frame->GetNextInFlow(), "bad child flow list");
}
// Reflow our fixed frames
nsReflowStatus fixedStatus = NS_FRAME_COMPLETE;
ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowState, fixedStatus);
NS_ASSERTION(NS_FRAME_IS_COMPLETE(fixedStatus), "fixed frames can be truncated, but not incomplete");
// Return our desired size
WritingMode wm = aReflowState.GetWritingMode();
aDesiredSize.ISize(wm) = aReflowState.ComputedISize();
if (aReflowState.ComputedBSize() != NS_UNCONSTRAINEDSIZE) {
aDesiredSize.BSize(wm) = aReflowState.ComputedBSize();
}
FinishAndStoreOverflow(&aDesiredSize);
NS_FRAME_SET_TRUNCATION(aStatus, aReflowState, aDesiredSize);
}
/* virtual */ void
nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
aStatus = NS_FRAME_COMPLETE;
if (!aReflowState.mLineLayout) {
NS_ASSERTION(
aReflowState.mLineLayout,
"No line layout provided to RubyBaseContainerFrame reflow method.");
return;
}
MoveOverflowToChildList();
// Ask text containers to drain overflows
AutoRubyTextContainerArray textContainers(this);
const uint32_t rtcCount = textContainers.Length();
for (uint32_t i = 0; i < rtcCount; i++) {
textContainers[i]->MoveOverflowToChildList();
}
WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode();
LogicalSize availSize(lineWM, aReflowState.AvailableISize(),
aReflowState.AvailableBSize());
// We have a reflow state and a line layout for each RTC.
// They are conceptually the state of the RTCs, but we don't actually
// reflow those RTCs in this code. These two arrays are holders of
// the reflow states and line layouts.
// Since there are pointers refer to reflow states and line layouts,
// it is necessary to guarantee that they won't be moved. For this
// reason, they are wrapped in UniquePtr here.
nsAutoTArray<UniquePtr<nsHTMLReflowState>, RTC_ARRAY_SIZE> reflowStates;
nsAutoTArray<UniquePtr<nsLineLayout>, RTC_ARRAY_SIZE> lineLayouts;
reflowStates.SetCapacity(rtcCount);
lineLayouts.SetCapacity(rtcCount);
// Begin the line layout for each ruby text container in advance.
bool hasSpan = false;
for (uint32_t i = 0; i < rtcCount; i++) {
nsRubyTextContainerFrame* textContainer = textContainers[i];
if (textContainer->IsSpanContainer()) {
hasSpan = true;
}
nsHTMLReflowState* reflowState = new nsHTMLReflowState(
aPresContext, *aReflowState.parentReflowState, textContainer,
availSize.ConvertTo(textContainer->GetWritingMode(), lineWM));
reflowStates.AppendElement(reflowState);
nsLineLayout* lineLayout = new nsLineLayout(aPresContext,
reflowState->mFloatManager,
reflowState, nullptr,
aReflowState.mLineLayout);
lineLayout->SetSuppressLineWrap(true);
lineLayouts.AppendElement(lineLayout);
// Line number is useless for ruby text
// XXX nullptr here may cause problem, see comments for
// nsLineLayout::mBlockRS and nsLineLayout::AddFloat
lineLayout->Init(nullptr, reflowState->CalcLineHeight(), -1);
reflowState->mLineLayout = lineLayout;
// Border and padding are suppressed on ruby text containers.
// If the writing mode is vertical-rl, the horizontal position of
// rt frames will be updated when reflowing this text container,
// hence leave container size 0 here for now.
lineLayout->BeginLineReflow(0, 0, reflowState->ComputedISize(),
NS_UNCONSTRAINEDSIZE,
false, false, lineWM, nsSize(0, 0));
lineLayout->AttachRootFrameToBaseLineLayout();
}
aReflowState.mLineLayout->BeginSpan(this, &aReflowState,
0, aReflowState.AvailableISize(),
&mBaseline);
bool allowInitialLineBreak, allowLineBreak;
GetIsLineBreakAllowed(this, aReflowState.mLineLayout->LineIsBreakable(),
&allowInitialLineBreak, &allowLineBreak);
nscoord isize = 0;
// Reflow columns excluding any span
ReflowState reflowState = {
allowInitialLineBreak, allowLineBreak && !hasSpan,
textContainers, aReflowState, reflowStates
};
isize = ReflowColumns(reflowState, aStatus);
DebugOnly<nscoord> lineSpanSize = aReflowState.mLineLayout->EndSpan(this);
aDesiredSize.ISize(lineWM) = isize;
// When there are no frames inside the ruby base container, EndSpan
// will return 0. However, in this case, the actual width of the
// container could be non-zero because of non-empty ruby annotations.
// XXX When bug 765861 gets fixed, this warning should be upgraded.
NS_WARN_IF_FALSE(NS_INLINE_IS_BREAK(aStatus) ||
isize == lineSpanSize || mFrames.IsEmpty(), "bad isize");
// If there exists any span, the columns must either be completely
// reflowed, or be not reflowed at all.
MOZ_ASSERT(NS_INLINE_IS_BREAK_BEFORE(aStatus) ||
NS_FRAME_IS_COMPLETE(aStatus) || !hasSpan);
if (!NS_INLINE_IS_BREAK_BEFORE(aStatus) &&
NS_FRAME_IS_COMPLETE(aStatus) && hasSpan) {
// Reflow spans
ReflowState reflowState = {
false, false, textContainers, aReflowState, reflowStates
};
nscoord spanISize = ReflowSpans(reflowState);
isize = std::max(isize, spanISize);
}
for (uint32_t i = 0; i < rtcCount; i++) {
// It happens before the ruby text container is reflowed, and that
// when it is reflowed, it will just use this size.
nsRubyTextContainerFrame* textContainer = textContainers[i];
nsLineLayout* lineLayout = lineLayouts[i].get();
RubyUtils::ClearReservedISize(textContainer);
nscoord rtcISize = lineLayout->GetCurrentICoord();
// Only span containers and containers with collapsed annotations
// need reserving isize. For normal ruby text containers, their
// children will be expanded properly. We only need to expand their
// own size.
if (!textContainer->IsSpanContainer()) {
rtcISize = isize;
} else if (isize > rtcISize) {
RubyUtils::SetReservedISize(textContainer, isize - rtcISize);
}
lineLayout->VerticalAlignLine();
textContainer->SetISize(rtcISize);
lineLayout->EndLineReflow();
}
// Border and padding are suppressed on ruby base container,
// create a fake borderPadding for setting BSize.
WritingMode frameWM = aReflowState.GetWritingMode();
LogicalMargin borderPadding(frameWM);
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize,
borderPadding, lineWM, frameWM);
}
/* virtual */ void
nsRubyFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsRubyFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (!aReflowState.mLineLayout) {
NS_ASSERTION(aReflowState.mLineLayout,
"No line layout provided to RubyFrame reflow method.");
aStatus = NS_FRAME_COMPLETE;
return;
}
// Grab overflow frames from prev-in-flow and its own.
MoveOverflowToChildList();
// Clear leadings
mBStartLeading = mBEndLeading = 0;
// Begin the span for the ruby frame
WritingMode frameWM = aReflowState.GetWritingMode();
WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode();
LogicalMargin borderPadding = aReflowState.ComputedLogicalBorderPadding();
nscoord startEdge = 0;
const bool boxDecorationBreakClone =
StyleBorder()->mBoxDecorationBreak == NS_STYLE_BOX_DECORATION_BREAK_CLONE;
if (boxDecorationBreakClone || !GetPrevContinuation()) {
startEdge = borderPadding.IStart(frameWM);
}
NS_ASSERTION(aReflowState.AvailableISize() != NS_UNCONSTRAINEDSIZE,
"should no longer use available widths");
nscoord availableISize = aReflowState.AvailableISize();
availableISize -= startEdge + borderPadding.IEnd(frameWM);
aReflowState.mLineLayout->BeginSpan(this, &aReflowState,
startEdge, availableISize, &mBaseline);
aStatus = NS_FRAME_COMPLETE;
for (RubySegmentEnumerator e(this); !e.AtEnd(); e.Next()) {
ReflowSegment(aPresContext, aReflowState, e.GetBaseContainer(), aStatus);
if (NS_INLINE_IS_BREAK(aStatus)) {
// A break occurs when reflowing the segment.
// Don't continue reflowing more segments.
break;
}
}
ContinuationTraversingState pullState(this);
while (aStatus == NS_FRAME_COMPLETE) {
nsRubyBaseContainerFrame* baseContainer =
PullOneSegment(aReflowState.mLineLayout, pullState);
if (!baseContainer) {
// No more continuations after, finish now.
break;
}
ReflowSegment(aPresContext, aReflowState, baseContainer, aStatus);
}
// We never handle overflow in ruby.
MOZ_ASSERT(!NS_FRAME_OVERFLOW_IS_INCOMPLETE(aStatus));
aDesiredSize.ISize(lineWM) = aReflowState.mLineLayout->EndSpan(this);
if (boxDecorationBreakClone || !GetPrevContinuation()) {
aDesiredSize.ISize(lineWM) += borderPadding.IStart(frameWM);
}
if (boxDecorationBreakClone || NS_FRAME_IS_COMPLETE(aStatus)) {
aDesiredSize.ISize(lineWM) += borderPadding.IEnd(frameWM);
}
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize,
borderPadding, lineWM, frameWM);
}
void
nsInlineFrame::ReflowFrames(nsPresContext* aPresContext,
const nsHTMLReflowState& aReflowState,
InlineReflowState& irs,
nsHTMLReflowMetrics& aMetrics,
nsReflowStatus& aStatus)
{
aStatus = NS_FRAME_COMPLETE;
nsLineLayout* lineLayout = aReflowState.mLineLayout;
bool inFirstLine = aReflowState.mLineLayout->GetInFirstLine();
RestyleManager* restyleManager = aPresContext->RestyleManager();
WritingMode frameWM = aReflowState.GetWritingMode();
WritingMode lineWM = aReflowState.mLineLayout->mRootSpan->mWritingMode;
LogicalMargin framePadding = aReflowState.ComputedLogicalBorderPadding();
nscoord startEdge = 0;
const bool boxDecorationBreakClone =
MOZ_UNLIKELY(StyleBorder()->mBoxDecorationBreak ==
NS_STYLE_BOX_DECORATION_BREAK_CLONE);
// Don't offset by our start borderpadding if we have a prev continuation or
// if we're in a part of an {ib} split other than the first one. For
// box-decoration-break:clone we always offset our start since all
// continuations have border/padding.
if ((!GetPrevContinuation() && !FrameIsNonFirstInIBSplit()) ||
boxDecorationBreakClone) {
startEdge = framePadding.IStart(frameWM);
}
nscoord availableISize = aReflowState.AvailableISize();
NS_ASSERTION(availableISize != NS_UNCONSTRAINEDSIZE,
"should no longer use available widths");
// Subtract off inline axis border+padding from availableISize
availableISize -= startEdge;
availableISize -= framePadding.IEnd(frameWM);
lineLayout->BeginSpan(this, &aReflowState, startEdge,
startEdge + availableISize, &mBaseline);
// First reflow our principal children.
nsIFrame* frame = mFrames.FirstChild();
bool done = false;
while (frame) {
// Check if we should lazily set the child frame's parent pointer.
if (irs.mSetParentPointer) {
bool havePrevBlock =
irs.mLineContainer && irs.mLineContainer->GetPrevContinuation();
nsIFrame* child = frame;
do {
// If our block is the first in flow, then any floats under the pulled
// frame must already belong to our block.
if (havePrevBlock) {
// This has to happen before we update frame's parent; we need to
// know frame's ancestry under its old block.
// The blockChildren.ContainsFrame check performed by
// ReparentFloatsForInlineChild here may be slow, but we can't
// easily avoid it because we don't know where 'frame' originally
// came from. If we really really have to optimize this we could
// cache whether frame->GetParent() is under its containing blocks
// overflowList or not.
ReparentFloatsForInlineChild(irs.mLineContainer, child, false);
}
child->SetParent(this);
if (inFirstLine) {
restyleManager->ReparentStyleContext(child);
nsLayoutUtils::MarkDescendantsDirty(child);
}
// We also need to do the same for |frame|'s next-in-flows that are in
// the sibling list. Otherwise, if we reflow |frame| and it's complete
// we'll crash when trying to delete its next-in-flow.
// This scenario doesn't happen often, but it can happen.
nsIFrame* nextSibling = child->GetNextSibling();
child = child->GetNextInFlow();
if (MOZ_UNLIKELY(child)) {
while (child != nextSibling && nextSibling) {
nextSibling = nextSibling->GetNextSibling();
}
if (!nextSibling) {
child = nullptr;
}
}
MOZ_ASSERT(!child || mFrames.ContainsFrame(child));
} while (child);
// Fix the parent pointer for ::first-letter child frame next-in-flows,
// so nsFirstLetterFrame::Reflow can destroy them safely (bug 401042).
nsIFrame* realFrame = nsPlaceholderFrame::GetRealFrameFor(frame);
if (realFrame->GetType() == nsGkAtoms::letterFrame) {
nsIFrame* child = realFrame->GetFirstPrincipalChild();
if (child) {
NS_ASSERTION(child->GetType() == nsGkAtoms::textFrame,
"unexpected frame type");
nsIFrame* nextInFlow = child->GetNextInFlow();
for ( ; nextInFlow; nextInFlow = nextInFlow->GetNextInFlow()) {
NS_ASSERTION(nextInFlow->GetType() == nsGkAtoms::textFrame,
"unexpected frame type");
if (mFrames.ContainsFrame(nextInFlow)) {
nextInFlow->SetParent(this);
if (inFirstLine) {
restyleManager->ReparentStyleContext(nextInFlow);
nsLayoutUtils::MarkDescendantsDirty(nextInFlow);
}
}
else {
#ifdef DEBUG
// Once we find a next-in-flow that isn't ours none of the
// remaining next-in-flows should be either.
for ( ; nextInFlow; nextInFlow = nextInFlow->GetNextInFlow()) {
NS_ASSERTION(!mFrames.ContainsFrame(nextInFlow),
"unexpected letter frame flow");
}
#endif
break;
}
}
}
}
}
MOZ_ASSERT(frame->GetParent() == this);
if (!done) {
bool reflowingFirstLetter = lineLayout->GetFirstLetterStyleOK();
ReflowInlineFrame(aPresContext, aReflowState, irs, frame, aStatus);
done = NS_INLINE_IS_BREAK(aStatus) ||
(!reflowingFirstLetter && NS_FRAME_IS_NOT_COMPLETE(aStatus));
if (done) {
if (!irs.mSetParentPointer) {
break;
}
// Keep reparenting the remaining siblings, but don't reflow them.
nsFrameList* pushedFrames = GetOverflowFrames();
if (pushedFrames && pushedFrames->FirstChild() == frame) {
// Don't bother if |frame| was pushed to our overflow list.
break;
}
} else {
irs.mPrevFrame = frame;
}
}
frame = frame->GetNextSibling();
}
// Attempt to pull frames from our next-in-flow until we can't
if (!done && GetNextInFlow()) {
while (true) {
bool reflowingFirstLetter = lineLayout->GetFirstLetterStyleOK();
bool isComplete;
if (!frame) { // Could be non-null if we pulled a first-letter frame and
// it created a continuation, since we don't push those.
frame = PullOneFrame(aPresContext, irs, &isComplete);
}
#ifdef NOISY_PUSHING
printf("%p pulled up %p\n", this, frame);
#endif
if (nullptr == frame) {
if (!isComplete) {
aStatus = NS_FRAME_NOT_COMPLETE;
}
break;
}
ReflowInlineFrame(aPresContext, aReflowState, irs, frame, aStatus);
if (NS_INLINE_IS_BREAK(aStatus) ||
(!reflowingFirstLetter && NS_FRAME_IS_NOT_COMPLETE(aStatus))) {
break;
}
irs.mPrevFrame = frame;
frame = frame->GetNextSibling();
}
}
NS_ASSERTION(!NS_FRAME_IS_COMPLETE(aStatus) || !GetOverflowFrames(),
"We can't be complete AND have overflow frames!");
// If after reflowing our children they take up no area then make
// sure that we don't either.
//
// Note: CSS demands that empty inline elements still affect the
// line-height calculations. However, continuations of an inline
// that are empty we force to empty so that things like collapsed
// whitespace in an inline element don't affect the line-height.
aMetrics.ISize(lineWM) = lineLayout->EndSpan(this);
// Compute final width.
// XXX Note that that the padding start and end are in the frame's
// writing mode, but the metrics' inline-size is in the line's
// writing mode. This makes sense if the line and frame are both
// vertical or both horizontal, but what should happen with
// orthogonal inlines?
// Make sure to not include our start border and padding if we have a prev
// continuation or if we're in a part of an {ib} split other than the first
// one. For box-decoration-break:clone we always include our start border
// and padding since all continuations have them.
if ((!GetPrevContinuation() && !FrameIsNonFirstInIBSplit()) ||
boxDecorationBreakClone) {
aMetrics.ISize(lineWM) += framePadding.IStart(frameWM);
}
/*
* We want to only apply the end border and padding if we're the last
* continuation and either not in an {ib} split or the last part of it. To
* be the last continuation we have to be complete (so that we won't get a
* next-in-flow) and have no non-fluid continuations on our continuation
* chain. For box-decoration-break:clone we always apply the end border and
* padding since all continuations have them.
*/
if ((NS_FRAME_IS_COMPLETE(aStatus) &&
!LastInFlow()->GetNextContinuation() &&
!FrameIsNonLastInIBSplit()) ||
boxDecorationBreakClone) {
aMetrics.ISize(lineWM) += framePadding.IEnd(frameWM);
}
nsLayoutUtils::SetBSizeFromFontMetrics(this, aMetrics, aReflowState,
framePadding, lineWM, frameWM);
// For now our overflow area is zero. The real value will be
// computed in |nsLineLayout::RelativePositionFrames|.
aMetrics.mOverflowAreas.Clear();
#ifdef NOISY_FINAL_SIZE
ListTag(stdout);
printf(": metrics=%d,%d ascent=%d\n",
aMetrics.Width(), aMetrics.Height(), aMetrics.TopAscent());
#endif
}
void
nsFirstLetterFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aMetrics,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aReflowStatus)
{
MarkInReflow();
DO_GLOBAL_REFLOW_COUNT("nsFirstLetterFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aMetrics, aReflowStatus);
// Grab overflow list
DrainOverflowFrames(aPresContext);
nsIFrame* kid = mFrames.FirstChild();
// Setup reflow state for our child
WritingMode wm = aReflowState.GetWritingMode();
LogicalSize availSize = aReflowState.AvailableSize();
const LogicalMargin& bp = aReflowState.ComputedLogicalBorderPadding();
NS_ASSERTION(availSize.ISize(wm) != NS_UNCONSTRAINEDSIZE,
"should no longer use unconstrained inline size");
availSize.ISize(wm) -= bp.IStartEnd(wm);
if (NS_UNCONSTRAINEDSIZE != availSize.BSize(wm)) {
availSize.BSize(wm) -= bp.BStartEnd(wm);
}
WritingMode lineWM = aMetrics.GetWritingMode();
nsHTMLReflowMetrics kidMetrics(lineWM);
// Reflow the child
if (!aReflowState.mLineLayout) {
// When there is no lineLayout provided, we provide our own. The
// only time that the first-letter-frame is not reflowing in a
// line context is when its floating.
WritingMode kidWritingMode = GetWritingMode(kid);
LogicalSize kidAvailSize = availSize.ConvertTo(kidWritingMode, wm);
nsHTMLReflowState rs(aPresContext, aReflowState, kid, kidAvailSize);
nsLineLayout ll(aPresContext, nullptr, &aReflowState, nullptr, nullptr);
ll.BeginLineReflow(bp.IStart(wm), bp.BStart(wm),
availSize.ISize(wm), NS_UNCONSTRAINEDSIZE,
false, true, kidWritingMode,
nsSize(aReflowState.AvailableWidth(),
aReflowState.AvailableHeight()));
rs.mLineLayout = ≪
ll.SetInFirstLetter(true);
ll.SetFirstLetterStyleOK(true);
kid->Reflow(aPresContext, kidMetrics, rs, aReflowStatus);
ll.EndLineReflow();
ll.SetInFirstLetter(false);
// In the floating first-letter case, we need to set this ourselves;
// nsLineLayout::BeginSpan will set it in the other case
mBaseline = kidMetrics.BlockStartAscent();
// Place and size the child and update the output metrics
LogicalSize convertedSize = kidMetrics.Size(lineWM).ConvertTo(wm, lineWM);
kid->SetRect(nsRect(bp.IStart(wm), bp.BStart(wm),
convertedSize.ISize(wm), convertedSize.BSize(wm)));
kid->FinishAndStoreOverflow(&kidMetrics);
kid->DidReflow(aPresContext, nullptr, nsDidReflowStatus::FINISHED);
convertedSize.ISize(wm) += bp.IStartEnd(wm);
convertedSize.BSize(wm) += bp.BStartEnd(wm);
aMetrics.SetSize(wm, convertedSize);
aMetrics.SetBlockStartAscent(kidMetrics.BlockStartAscent() +
bp.BStart(wm));
// Ensure that the overflow rect contains the child textframe's
// overflow rect.
// Note that if this is floating, the overline/underline drawable
// area is in the overflow rect of the child textframe.
aMetrics.UnionOverflowAreasWithDesiredBounds();
ConsiderChildOverflow(aMetrics.mOverflowAreas, kid);
FinishAndStoreOverflow(&aMetrics);
}
else {
// Pretend we are a span and reflow the child frame
nsLineLayout* ll = aReflowState.mLineLayout;
bool pushedFrame;
ll->SetInFirstLetter(
mStyleContext->GetPseudo() == nsCSSPseudoElements::firstLetter);
ll->BeginSpan(this, &aReflowState, bp.IStart(wm),
availSize.ISize(wm), &mBaseline);
ll->ReflowFrame(kid, aReflowStatus, &kidMetrics, pushedFrame);
NS_ASSERTION(lineWM.IsVertical() == wm.IsVertical(),
"we're assuming we can mix sizes between lineWM and wm "
"since we shouldn't have orthogonal writing modes within "
"a line.");
aMetrics.ISize(lineWM) = ll->EndSpan(this) + bp.IStartEnd(wm);
ll->SetInFirstLetter(false);
nsLayoutUtils::SetBSizeFromFontMetrics(this, aMetrics, bp, lineWM, wm);
}
if (!NS_INLINE_IS_BREAK_BEFORE(aReflowStatus)) {
// Create a continuation or remove existing continuations based on
// the reflow completion status.
if (NS_FRAME_IS_COMPLETE(aReflowStatus)) {
if (aReflowState.mLineLayout) {
aReflowState.mLineLayout->SetFirstLetterStyleOK(false);
}
nsIFrame* kidNextInFlow = kid->GetNextInFlow();
if (kidNextInFlow) {
// Remove all of the childs next-in-flows
kidNextInFlow->GetParent()->DeleteNextInFlowChild(kidNextInFlow, true);
}
}
else {
// Create a continuation for the child frame if it doesn't already
// have one.
if (!IsFloating()) {
CreateNextInFlow(kid);
// And then push it to our overflow list
const nsFrameList& overflow = mFrames.RemoveFramesAfter(kid);
if (overflow.NotEmpty()) {
SetOverflowFrames(overflow);
}
} else if (!kid->GetNextInFlow()) {
// For floating first letter frames (if a continuation wasn't already
// created for us) we need to put the continuation with the rest of the
// text that the first letter frame was made out of.
nsIFrame* continuation;
CreateContinuationForFloatingParent(aPresContext, kid,
&continuation, true);
}
}
}
NS_FRAME_SET_TRUNCATION(aReflowStatus, aReflowState, aMetrics);
}
/* virtual */ void
nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext,
nsHTMLReflowMetrics& aDesiredSize,
const nsHTMLReflowState& aReflowState,
nsReflowStatus& aStatus)
{
DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame");
DISPLAY_REFLOW(aPresContext, this, aReflowState, aDesiredSize, aStatus);
if (!aReflowState.mLineLayout) {
NS_ASSERTION(
aReflowState.mLineLayout,
"No line layout provided to RubyBaseContainerFrame reflow method.");
aStatus = NS_FRAME_COMPLETE;
return;
}
aStatus = NS_FRAME_COMPLETE;
nscoord isize = 0;
int baseNum = 0;
nscoord leftoverSpace = 0;
nscoord spaceApart = 0;
WritingMode lineWM = aReflowState.mLineLayout->GetWritingMode();
WritingMode frameWM = aReflowState.GetWritingMode();
LogicalMargin borderPadding =
aReflowState.ComputedLogicalBorderPadding();
nscoord baseStart = 0;
LogicalSize availSize(lineWM, aReflowState.AvailableWidth(),
aReflowState.AvailableHeight());
// Begin the line layout for each ruby text container in advance.
for (uint32_t i = 0; i < mTextContainers.Length(); i++) {
nsRubyTextContainerFrame* rtcFrame = mTextContainers.ElementAt(i);
nsHTMLReflowState rtcReflowState(aPresContext,
*aReflowState.parentReflowState,
rtcFrame, availSize);
rtcReflowState.mLineLayout = aReflowState.mLineLayout;
// FIXME: Avoid using/needing the rtcReflowState argument
rtcFrame->BeginRTCLineLayout(aPresContext, rtcReflowState);
}
for (nsFrameList::Enumerator e(mFrames); !e.AtEnd(); e.Next()) {
nsIFrame* rbFrame = e.get();
if (rbFrame->GetType() != nsGkAtoms::rubyBaseFrame) {
NS_ASSERTION(false, "Unrecognized child type for ruby base container");
continue;
}
nsReflowStatus frameReflowStatus;
nsHTMLReflowMetrics metrics(aReflowState, aDesiredSize.mFlags);
// Determine if we need more spacing between bases in the inline direction
// depending on the inline size of the corresponding annotations
// FIXME: The use of GetPrefISize here and below is easier but not ideal. It
// would be better to use metrics from reflow.
nscoord prefWidth = rbFrame->GetPrefISize(aReflowState.rendContext);
nscoord textWidth = 0;
for (uint32_t i = 0; i < mTextContainers.Length(); i++) {
nsRubyTextFrame* rtFrame = do_QueryFrame(mTextContainers.ElementAt(i)->
PrincipalChildList().FrameAt(baseNum));
if (rtFrame) {
int newWidth = rtFrame->GetPrefISize(aReflowState.rendContext);
if (newWidth > textWidth) {
textWidth = newWidth;
}
}
}
if (textWidth > prefWidth) {
spaceApart = std::max((textWidth - prefWidth) / 2, spaceApart);
leftoverSpace = spaceApart;
} else {
spaceApart = leftoverSpace;
leftoverSpace = 0;
}
if (spaceApart > 0) {
aReflowState.mLineLayout->AdvanceICoord(spaceApart);
}
baseStart = aReflowState.mLineLayout->GetCurrentICoord();
bool pushedFrame;
aReflowState.mLineLayout->ReflowFrame(rbFrame, frameReflowStatus,
&metrics, pushedFrame);
NS_ASSERTION(!pushedFrame, "Ruby line breaking is not yet implemented");
isize += metrics.ISize(lineWM);
rbFrame->SetSize(LogicalSize(lineWM, metrics.ISize(lineWM),
metrics.BSize(lineWM)));
FinishReflowChild(rbFrame, aPresContext, metrics, &aReflowState, 0, 0,
NS_FRAME_NO_MOVE_FRAME | NS_FRAME_NO_MOVE_VIEW);
// Now reflow the ruby text boxes that correspond to this ruby base box.
for (uint32_t i = 0; i < mTextContainers.Length(); i++) {
nsRubyTextFrame* rtFrame = do_QueryFrame(mTextContainers.ElementAt(i)->
PrincipalChildList().FrameAt(baseNum));
nsRubyTextContainerFrame* rtcFrame = mTextContainers.ElementAt(i);
if (rtFrame) {
nsHTMLReflowMetrics rtcMetrics(*aReflowState.parentReflowState,
aDesiredSize.mFlags);
nsHTMLReflowState rtcReflowState(aPresContext,
*aReflowState.parentReflowState,
rtcFrame, availSize);
rtcReflowState.mLineLayout = rtcFrame->GetLineLayout();
rtcFrame->ReflowRubyTextFrame(rtFrame, rbFrame, baseStart,
aPresContext, rtcMetrics,
rtcReflowState);
}
}
baseNum++;
}
// Reflow ruby annotations which do not have a corresponding ruby base box due
// to a ruby base shortage. According to the spec, an empty ruby base is
// assumed to exist for each of these annotations.
bool continueReflow = true;
while (continueReflow) {
continueReflow = false;
for (uint32_t i = 0; i < mTextContainers.Length(); i++) {
nsRubyTextFrame* rtFrame = do_QueryFrame(mTextContainers.ElementAt(i)->
PrincipalChildList().FrameAt(baseNum));
nsRubyTextContainerFrame* rtcFrame = mTextContainers.ElementAt(i);
if (rtFrame) {
continueReflow = true;
nsHTMLReflowMetrics rtcMetrics(*aReflowState.parentReflowState,
aDesiredSize.mFlags);
nsHTMLReflowState rtcReflowState(aPresContext,
*aReflowState.parentReflowState,
rtcFrame, availSize);
rtcReflowState.mLineLayout = rtcFrame->GetLineLayout();
rtcFrame->ReflowRubyTextFrame(rtFrame, nullptr, baseStart,
aPresContext, rtcMetrics,
rtcReflowState);
// Update the inline coord to make space for subsequent ruby annotations
// (since there is no corresponding base inline size to use).
baseStart += rtcMetrics.ISize(lineWM);
}
}
baseNum++;
}
aDesiredSize.ISize(lineWM) = isize;
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, aReflowState,
borderPadding, lineWM, frameWM);
}
