/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ /* vim: set ts=2 et sw=2 tw=80: */ /* This Source Code is subject to the terms of the Mozilla Public License * version 2.0 (the "License"). You can obtain a copy of the License at * http://mozilla.org/MPL/2.0/. */ /* rendering object for CSS "display: ruby-base-container" */ #include "nsRubyBaseContainerFrame.h" #include "nsRubyTextContainerFrame.h" #include "nsRubyBaseFrame.h" #include "nsRubyTextFrame.h" #include "mozilla/DebugOnly.h" #include "mozilla/Maybe.h" #include "mozilla/WritingModes.h" #include "nsLayoutUtils.h" #include "nsLineLayout.h" #include "nsPresContext.h" #include "nsStyleContext.h" #include "nsStyleStructInlines.h" #include "nsTextFrame.h" #include "RubyUtils.h" using namespace mozilla; //---------------------------------------------------------------------- // Frame class boilerplate // ======================= NS_QUERYFRAME_HEAD(nsRubyBaseContainerFrame) NS_QUERYFRAME_ENTRY(nsRubyBaseContainerFrame) NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame) NS_IMPL_FRAMEARENA_HELPERS(nsRubyBaseContainerFrame) nsContainerFrame* NS_NewRubyBaseContainerFrame(nsIPresShell* aPresShell, nsStyleContext* aContext) { return new (aPresShell) nsRubyBaseContainerFrame(aContext); } //---------------------------------------------------------------------- // nsRubyBaseContainerFrame Method Implementations // =============================================== nsIAtom* nsRubyBaseContainerFrame::GetType() const { return nsGkAtoms::rubyBaseContainerFrame; } #ifdef DEBUG_FRAME_DUMP nsresult nsRubyBaseContainerFrame::GetFrameName(nsAString& aResult) const { return MakeFrameName(NS_LITERAL_STRING("RubyBaseContainer"), aResult); } #endif static gfxBreakPriority LineBreakBefore(nsIFrame* aFrame, DrawTarget* aDrawTarget, nsIFrame* aLineContainerFrame, const nsLineList::iterator* aLine) { for (nsIFrame* child = aFrame; child; child = child->PrincipalChildList().FirstChild()) { if (!child->CanContinueTextRun()) { // It is not an inline element. We can break before it. return gfxBreakPriority::eNormalBreak; } if (child->GetType() != nsGkAtoms::textFrame) { continue; } auto textFrame = static_cast<nsTextFrame*>(child); gfxSkipCharsIterator iter = textFrame->EnsureTextRun(nsTextFrame::eInflated, aDrawTarget, aLineContainerFrame, aLine); iter.SetOriginalOffset(textFrame->GetContentOffset()); uint32_t pos = iter.GetSkippedOffset(); gfxTextRun* textRun = textFrame->GetTextRun(nsTextFrame::eInflated); if (pos >= textRun->GetLength()) { // The text frame contains no character at all. return gfxBreakPriority::eNoBreak; } // Return whether we can break before the first character. if (textRun->CanBreakLineBefore(pos)) { return gfxBreakPriority::eNormalBreak; } // Check whether we can wrap word here. const nsStyleText* textStyle = textFrame->StyleText(); if (textStyle->WordCanWrap(textFrame) && textRun->IsClusterStart(pos)) { return gfxBreakPriority::eWordWrapBreak; } // We cannot break before. return gfxBreakPriority::eNoBreak; } // Neither block, nor text frame is found as a leaf. We won't break // before this base frame. It is the behavior of empty spans. return gfxBreakPriority::eNoBreak; } static void GetIsLineBreakAllowed(nsIFrame* aFrame, bool aIsLineBreakable, bool* aAllowInitialLineBreak, bool* aAllowLineBreak) { nsIFrame* parent = aFrame->GetParent(); bool lineBreakSuppressed = parent->StyleContext()->ShouldSuppressLineBreak(); // Allow line break between ruby bases when white-space allows, // we are not inside a nested ruby, and there is no span. bool allowLineBreak = !lineBreakSuppressed && aFrame->StyleText()->WhiteSpaceCanWrap(aFrame); bool allowInitialLineBreak = allowLineBreak; if (!aFrame->GetPrevInFlow()) { allowInitialLineBreak = !lineBreakSuppressed && parent->StyleText()->WhiteSpaceCanWrap(parent); } if (!aIsLineBreakable) { allowInitialLineBreak = false; } *aAllowInitialLineBreak = allowInitialLineBreak; *aAllowLineBreak = allowLineBreak; } /** * @param aBaseISizeData is an in/out param. This method updates the * `skipWhitespace` and `trailingWhitespace` fields of the struct with * the base level frame. Note that we don't need to do the same thing * for ruby text frames, because they are text run container themselves * (see nsTextFrame.cpp:BuildTextRuns), and thus no whitespace collapse * happens across the boundary of those frames. */ static nscoord CalculateColumnPrefISize(nsRenderingContext* aRenderingContext, const RubyColumnEnumerator& aEnumerator, nsIFrame::InlineIntrinsicISizeData* aBaseISizeData) { nscoord max = 0; uint32_t levelCount = aEnumerator.GetLevelCount(); for (uint32_t i = 0; i < levelCount; i++) { nsIFrame* frame = aEnumerator.GetFrameAtLevel(i); if (frame) { nsIFrame::InlinePrefISizeData data; if (i == 0) { data.SetLineContainer(aBaseISizeData->LineContainer()); data.mSkipWhitespace = aBaseISizeData->mSkipWhitespace; data.mTrailingWhitespace = aBaseISizeData->mTrailingWhitespace; } else { // The line container of ruby text frames is their parent, // ruby text container frame. data.SetLineContainer(frame->GetParent()); } frame->AddInlinePrefISize(aRenderingContext, &data); MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines"); max = std::max(max, data.mCurrentLine); if (i == 0) { aBaseISizeData->mSkipWhitespace = data.mSkipWhitespace; aBaseISizeData->mTrailingWhitespace = data.mTrailingWhitespace; } } } return max; } // FIXME Currently we use pref isize of ruby content frames for // computing min isize of ruby frame, which may cause problem. // See bug 1134945. /* virtual */ void nsRubyBaseContainerFrame::AddInlineMinISize( nsRenderingContext *aRenderingContext, nsIFrame::InlineMinISizeData *aData) { AutoRubyTextContainerArray textContainers(this); for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) { if (textContainers[i]->IsSpanContainer()) { // Since spans are not breakable internally, use our pref isize // directly if there is any span. nsIFrame::InlinePrefISizeData data; data.SetLineContainer(aData->LineContainer()); data.mSkipWhitespace = aData->mSkipWhitespace; data.mTrailingWhitespace = aData->mTrailingWhitespace; AddInlinePrefISize(aRenderingContext, &data); aData->mCurrentLine += data.mCurrentLine; if (data.mCurrentLine > 0) { aData->mAtStartOfLine = false; } aData->mSkipWhitespace = data.mSkipWhitespace; aData->mTrailingWhitespace = data.mTrailingWhitespace; return; } } bool firstFrame = true; bool allowInitialLineBreak, allowLineBreak; GetIsLineBreakAllowed(this, !aData->mAtStartOfLine, &allowInitialLineBreak, &allowLineBreak); for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) { RubyColumnEnumerator enumerator( static_cast<nsRubyBaseContainerFrame*>(frame), textContainers); for (; !enumerator.AtEnd(); enumerator.Next()) { if (firstFrame ? allowInitialLineBreak : allowLineBreak) { nsIFrame* baseFrame = enumerator.GetFrameAtLevel(0); if (baseFrame) { gfxBreakPriority breakPriority = LineBreakBefore(baseFrame, aRenderingContext->GetDrawTarget(), nullptr, nullptr); if (breakPriority != gfxBreakPriority::eNoBreak) { aData->OptionallyBreak(); } } } firstFrame = false; nscoord isize = CalculateColumnPrefISize(aRenderingContext, enumerator, aData); aData->mCurrentLine += isize; if (isize > 0) { aData->mAtStartOfLine = false; } } } } /* virtual */ void nsRubyBaseContainerFrame::AddInlinePrefISize( nsRenderingContext *aRenderingContext, nsIFrame::InlinePrefISizeData *aData) { AutoRubyTextContainerArray textContainers(this); nscoord sum = 0; for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) { RubyColumnEnumerator enumerator( static_cast<nsRubyBaseContainerFrame*>(frame), textContainers); for (; !enumerator.AtEnd(); enumerator.Next()) { sum += CalculateColumnPrefISize(aRenderingContext, enumerator, aData); } } for (uint32_t i = 0, iend = textContainers.Length(); i < iend; i++) { if (textContainers[i]->IsSpanContainer()) { nsIFrame* frame = textContainers[i]->PrincipalChildList().FirstChild(); nsIFrame::InlinePrefISizeData data; frame->AddInlinePrefISize(aRenderingContext, &data); MOZ_ASSERT(data.mPrevLines == 0, "Shouldn't have prev lines"); sum = std::max(sum, data.mCurrentLine); } } aData->mCurrentLine += sum; } /* virtual */ bool nsRubyBaseContainerFrame::IsFrameOfType(uint32_t aFlags) const { if (aFlags & eSupportsCSSTransforms) { return false; } return nsContainerFrame::IsFrameOfType(aFlags & ~(nsIFrame::eLineParticipant)); } /* virtual */ bool nsRubyBaseContainerFrame::CanContinueTextRun() const { return true; } /* virtual */ LogicalSize nsRubyBaseContainerFrame::ComputeSize(nsRenderingContext *aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize, nscoord aAvailableISize, const LogicalSize& aMargin, const LogicalSize& aBorder, const LogicalSize& aPadding, ComputeSizeFlags aFlags) { // Ruby base container frame is inline, // hence don't compute size before reflow. return LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE); } /* virtual */ nscoord nsRubyBaseContainerFrame::GetLogicalBaseline(WritingMode aWritingMode) const { return mBaseline; } struct nsRubyBaseContainerFrame::RubyReflowInput { bool mAllowInitialLineBreak; bool mAllowLineBreak; const AutoRubyTextContainerArray& mTextContainers; const ReflowInput& mBaseReflowInput; const nsTArray<UniquePtr<ReflowInput>>& mTextReflowInputs; }; /* virtual */ void nsRubyBaseContainerFrame::Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize, const ReflowInput& aReflowInput, nsReflowStatus& aStatus) { MarkInReflow(); DO_GLOBAL_REFLOW_COUNT("nsRubyBaseContainerFrame"); DISPLAY_REFLOW(aPresContext, this, aReflowInput, aDesiredSize, aStatus); aStatus = NS_FRAME_COMPLETE; if (!aReflowInput.mLineLayout) { NS_ASSERTION( aReflowInput.mLineLayout, "No line layout provided to RubyBaseContainerFrame reflow method."); return; } mDescendantLeadings.Reset(); 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 = aReflowInput.mLineLayout->GetWritingMode(); LogicalSize availSize(lineWM, aReflowInput.AvailableISize(), aReflowInput.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. AutoTArray<UniquePtr<ReflowInput>, RTC_ARRAY_SIZE> reflowInputs; AutoTArray<UniquePtr<nsLineLayout>, RTC_ARRAY_SIZE> lineLayouts; reflowInputs.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; } ReflowInput* reflowInput = new ReflowInput( aPresContext, *aReflowInput.mParentReflowInput, textContainer, availSize.ConvertTo(textContainer->GetWritingMode(), lineWM)); reflowInputs.AppendElement(reflowInput); nsLineLayout* lineLayout = new nsLineLayout(aPresContext, reflowInput->mFloatManager, reflowInput, nullptr, aReflowInput.mLineLayout); lineLayout->SetSuppressLineWrap(true); lineLayouts.AppendElement(lineLayout); // Line number is useless for ruby text // XXX nullptr here may cause problem, see comments for // nsLineLayout::mBlockRI and nsLineLayout::AddFloat lineLayout->Init(nullptr, reflowInput->CalcLineHeight(), -1); reflowInput->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, reflowInput->ComputedISize(), NS_UNCONSTRAINEDSIZE, false, false, lineWM, nsSize(0, 0)); lineLayout->AttachRootFrameToBaseLineLayout(); } aReflowInput.mLineLayout->BeginSpan(this, &aReflowInput, 0, aReflowInput.AvailableISize(), &mBaseline); bool allowInitialLineBreak, allowLineBreak; GetIsLineBreakAllowed(this, aReflowInput.mLineLayout->LineIsBreakable(), &allowInitialLineBreak, &allowLineBreak); nscoord isize = 0; // Reflow columns excluding any span RubyReflowInput reflowInput = { allowInitialLineBreak, allowLineBreak && !hasSpan, textContainers, aReflowInput, reflowInputs }; isize = ReflowColumns(reflowInput, aStatus); DebugOnly<nscoord> lineSpanSize = aReflowInput.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_WARNING_ASSERTION( 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 RubyReflowInput reflowInput = { false, false, textContainers, aReflowInput, reflowInputs }; nscoord spanISize = ReflowSpans(reflowInput); 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 = aReflowInput.GetWritingMode(); LogicalMargin borderPadding(frameWM); nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, borderPadding, lineWM, frameWM); } /** * This struct stores the continuations after this frame and * corresponding text containers. It is used to speed up looking * ahead for nonempty continuations. */ struct MOZ_STACK_CLASS nsRubyBaseContainerFrame::PullFrameState { ContinuationTraversingState mBase; AutoTArray<ContinuationTraversingState, RTC_ARRAY_SIZE> mTexts; const AutoRubyTextContainerArray& mTextContainers; PullFrameState(nsRubyBaseContainerFrame* aBaseContainer, const AutoRubyTextContainerArray& aTextContainers); }; nscoord nsRubyBaseContainerFrame::ReflowColumns(const RubyReflowInput& aReflowInput, nsReflowStatus& aStatus) { nsLineLayout* lineLayout = aReflowInput.mBaseReflowInput.mLineLayout; const uint32_t rtcCount = aReflowInput.mTextContainers.Length(); nscoord icoord = lineLayout->GetCurrentICoord(); MOZ_ASSERT(icoord == 0, "border/padding of rbc should have been suppressed"); nsReflowStatus reflowStatus = NS_FRAME_COMPLETE; aStatus = NS_FRAME_COMPLETE; uint32_t columnIndex = 0; RubyColumn column; column.mTextFrames.SetCapacity(rtcCount); RubyColumnEnumerator e(this, aReflowInput.mTextContainers); for (; !e.AtEnd(); e.Next()) { e.GetColumn(column); icoord += ReflowOneColumn(aReflowInput, columnIndex, column, reflowStatus); if (!NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) { columnIndex++; } if (NS_INLINE_IS_BREAK(reflowStatus)) { break; } // We are not handling overflow here. MOZ_ASSERT(reflowStatus == NS_FRAME_COMPLETE); } bool isComplete = false; PullFrameState pullFrameState(this, aReflowInput.mTextContainers); while (!NS_INLINE_IS_BREAK(reflowStatus)) { // We are not handling overflow here. MOZ_ASSERT(reflowStatus == NS_FRAME_COMPLETE); // Try pull some frames from next continuations. This call replaces // frames in |column| with the frame pulled in each level. PullOneColumn(lineLayout, pullFrameState, column, isComplete); if (isComplete) { // No more frames can be pulled. break; } icoord += ReflowOneColumn(aReflowInput, columnIndex, column, reflowStatus); if (!NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) { columnIndex++; } } if (!e.AtEnd() && NS_INLINE_IS_BREAK_AFTER(reflowStatus)) { // The current column has been successfully placed. // Skip to the next column and mark break before. e.Next(); e.GetColumn(column); reflowStatus = NS_INLINE_LINE_BREAK_BEFORE(); } if (!e.AtEnd() || (GetNextInFlow() && !isComplete)) { NS_FRAME_SET_INCOMPLETE(aStatus); } if (NS_INLINE_IS_BREAK_BEFORE(reflowStatus)) { if (!columnIndex || !aReflowInput.mAllowLineBreak) { // If no column has been placed yet, or we have any span, // the whole container should be in the next line. aStatus = NS_INLINE_LINE_BREAK_BEFORE(); return 0; } aStatus = NS_INLINE_LINE_BREAK_AFTER(aStatus); MOZ_ASSERT(NS_FRAME_IS_COMPLETE(aStatus) || aReflowInput.mAllowLineBreak); // If we are on an intra-level whitespace column, null values in // column.mBaseFrame and column.mTextFrames don't represent the // end of the frame-sibling-chain at that level -- instead, they // represent an anonymous empty intra-level whitespace box. It is // likely that there are frames in the next column (which can't be // intra-level whitespace). Those frames should be pushed as well. Maybe<RubyColumn> nextColumn; if (column.mIsIntraLevelWhitespace && !e.AtEnd()) { e.Next(); nextColumn.emplace(); e.GetColumn(nextColumn.ref()); } nsIFrame* baseFrame = column.mBaseFrame; if (!baseFrame & nextColumn.isSome()) { baseFrame = nextColumn->mBaseFrame; } if (baseFrame) { PushChildren(baseFrame, baseFrame->GetPrevSibling()); } for (uint32_t i = 0; i < rtcCount; i++) { nsRubyTextFrame* textFrame = column.mTextFrames[i]; if (!textFrame && nextColumn.isSome()) { textFrame = nextColumn->mTextFrames[i]; } if (textFrame) { aReflowInput.mTextContainers[i]->PushChildren( textFrame, textFrame->GetPrevSibling()); } } } else if (NS_INLINE_IS_BREAK_AFTER(reflowStatus)) { // |reflowStatus| being break after here may only happen when // there is a break after the column just pulled, or the whole // segment has been completely reflowed. In those cases, we do // not need to push anything. MOZ_ASSERT(e.AtEnd()); aStatus = NS_INLINE_LINE_BREAK_AFTER(aStatus); } return icoord; } nscoord nsRubyBaseContainerFrame::ReflowOneColumn(const RubyReflowInput& aReflowInput, uint32_t aColumnIndex, const RubyColumn& aColumn, nsReflowStatus& aStatus) { const ReflowInput& baseReflowInput = aReflowInput.mBaseReflowInput; const auto& textReflowInputs = aReflowInput.mTextReflowInputs; nscoord istart = baseReflowInput.mLineLayout->GetCurrentICoord(); if (aColumn.mBaseFrame) { bool allowBreakBefore = aColumnIndex ? aReflowInput.mAllowLineBreak : aReflowInput.mAllowInitialLineBreak; if (allowBreakBefore) { gfxBreakPriority breakPriority = LineBreakBefore( aColumn.mBaseFrame, baseReflowInput.mRenderingContext->GetDrawTarget(), baseReflowInput.mLineLayout->LineContainerFrame(), baseReflowInput.mLineLayout->GetLine()); if (breakPriority != gfxBreakPriority::eNoBreak) { gfxBreakPriority lastBreakPriority = baseReflowInput.mLineLayout->LastOptionalBreakPriority(); if (breakPriority >= lastBreakPriority) { // Either we have been overflow, or we are forced // to break here, do break before. if (istart > baseReflowInput.AvailableISize() || baseReflowInput.mLineLayout->NotifyOptionalBreakPosition( aColumn.mBaseFrame, 0, true, breakPriority)) { aStatus = NS_INLINE_LINE_BREAK_BEFORE(); return 0; } } } } } const uint32_t rtcCount = aReflowInput.mTextContainers.Length(); MOZ_ASSERT(aColumn.mTextFrames.Length() == rtcCount); MOZ_ASSERT(textReflowInputs.Length() == rtcCount); nscoord columnISize = 0; nsAutoString baseText; if (aColumn.mBaseFrame) { nsLayoutUtils::GetFrameTextContent(aColumn.mBaseFrame, baseText); } // Reflow text frames for (uint32_t i = 0; i < rtcCount; i++) { nsRubyTextFrame* textFrame = aColumn.mTextFrames[i]; if (textFrame) { nsAutoString annotationText; nsLayoutUtils::GetFrameTextContent(textFrame, annotationText); // Per CSS Ruby spec, the content comparison for auto-hiding // takes place prior to white spaces collapsing (white-space) // and text transformation (text-transform), and ignores elements // (considers only the textContent of the boxes). Which means // using the content tree text comparison is correct. if (annotationText.Equals(baseText)) { textFrame->AddStateBits(NS_RUBY_TEXT_FRAME_AUTOHIDE); } else { textFrame->RemoveStateBits(NS_RUBY_TEXT_FRAME_AUTOHIDE); } RubyUtils::ClearReservedISize(textFrame); bool pushedFrame; nsReflowStatus reflowStatus; nsLineLayout* lineLayout = textReflowInputs[i]->mLineLayout; nscoord textIStart = lineLayout->GetCurrentICoord(); lineLayout->ReflowFrame(textFrame, reflowStatus, nullptr, pushedFrame); if (MOZ_UNLIKELY(NS_INLINE_IS_BREAK(reflowStatus) || pushedFrame)) { MOZ_ASSERT_UNREACHABLE( "Any line break inside ruby box should have been suppressed"); // For safety, always drain the overflow list, so that // no frames are left there after reflow. textFrame->DrainSelfOverflowList(); } nscoord textISize = lineLayout->GetCurrentICoord() - textIStart; columnISize = std::max(columnISize, textISize); } } // Reflow the base frame if (aColumn.mBaseFrame) { RubyUtils::ClearReservedISize(aColumn.mBaseFrame); bool pushedFrame; nsReflowStatus reflowStatus; nsLineLayout* lineLayout = baseReflowInput.mLineLayout; nscoord baseIStart = lineLayout->GetCurrentICoord(); lineLayout->ReflowFrame(aColumn.mBaseFrame, reflowStatus, nullptr, pushedFrame); if (MOZ_UNLIKELY(NS_INLINE_IS_BREAK(reflowStatus) || pushedFrame)) { MOZ_ASSERT_UNREACHABLE( "Any line break inside ruby box should have been suppressed"); // For safety, always drain the overflow list, so that // no frames are left there after reflow. aColumn.mBaseFrame->DrainSelfOverflowList(); } nscoord baseISize = lineLayout->GetCurrentICoord() - baseIStart; columnISize = std::max(columnISize, baseISize); } // Align all the line layout to the new coordinate. nscoord icoord = istart + columnISize; nscoord deltaISize = icoord - baseReflowInput.mLineLayout->GetCurrentICoord(); if (deltaISize > 0) { baseReflowInput.mLineLayout->AdvanceICoord(deltaISize); if (aColumn.mBaseFrame) { RubyUtils::SetReservedISize(aColumn.mBaseFrame, deltaISize); } } for (uint32_t i = 0; i < rtcCount; i++) { if (aReflowInput.mTextContainers[i]->IsSpanContainer()) { continue; } nsLineLayout* lineLayout = textReflowInputs[i]->mLineLayout; nsRubyTextFrame* textFrame = aColumn.mTextFrames[i]; nscoord deltaISize = icoord - lineLayout->GetCurrentICoord(); if (deltaISize > 0) { lineLayout->AdvanceICoord(deltaISize); if (textFrame && !textFrame->IsAutoHidden()) { RubyUtils::SetReservedISize(textFrame, deltaISize); } } if (aColumn.mBaseFrame && textFrame) { lineLayout->AttachLastFrameToBaseLineLayout(); } } return columnISize; } nsRubyBaseContainerFrame::PullFrameState::PullFrameState( nsRubyBaseContainerFrame* aBaseContainer, const AutoRubyTextContainerArray& aTextContainers) : mBase(aBaseContainer) , mTextContainers(aTextContainers) { const uint32_t rtcCount = aTextContainers.Length(); for (uint32_t i = 0; i < rtcCount; i++) { mTexts.AppendElement(aTextContainers[i]); } } void nsRubyBaseContainerFrame::PullOneColumn(nsLineLayout* aLineLayout, PullFrameState& aPullFrameState, RubyColumn& aColumn, bool& aIsComplete) { const AutoRubyTextContainerArray& textContainers = aPullFrameState.mTextContainers; const uint32_t rtcCount = textContainers.Length(); nsIFrame* nextBase = GetNextInFlowChild(aPullFrameState.mBase); MOZ_ASSERT(!nextBase || nextBase->GetType() == nsGkAtoms::rubyBaseFrame); aColumn.mBaseFrame = static_cast<nsRubyBaseFrame*>(nextBase); bool foundFrame = !!aColumn.mBaseFrame; bool pullingIntraLevelWhitespace = aColumn.mBaseFrame && aColumn.mBaseFrame->IsIntraLevelWhitespace(); aColumn.mTextFrames.ClearAndRetainStorage(); for (uint32_t i = 0; i < rtcCount; i++) { nsIFrame* nextText = textContainers[i]->GetNextInFlowChild(aPullFrameState.mTexts[i]); MOZ_ASSERT(!nextText || nextText->GetType() == nsGkAtoms::rubyTextFrame); nsRubyTextFrame* textFrame = static_cast<nsRubyTextFrame*>(nextText); aColumn.mTextFrames.AppendElement(textFrame); foundFrame = foundFrame || nextText; if (nextText && !pullingIntraLevelWhitespace) { pullingIntraLevelWhitespace = textFrame->IsIntraLevelWhitespace(); } } // If there exists any frame in continations, we haven't // completed the reflow process. aIsComplete = !foundFrame; if (!foundFrame) { return; } aColumn.mIsIntraLevelWhitespace = pullingIntraLevelWhitespace; if (pullingIntraLevelWhitespace) { // We are pulling an intra-level whitespace. Drop all frames which // are not part of this intra-level whitespace column. (Those frames // are really part of the *next* column, after the pulled one.) if (aColumn.mBaseFrame && !aColumn.mBaseFrame->IsIntraLevelWhitespace()) { aColumn.mBaseFrame = nullptr; } for (uint32_t i = 0; i < rtcCount; i++) { nsRubyTextFrame*& textFrame = aColumn.mTextFrames[i]; if (textFrame && !textFrame->IsIntraLevelWhitespace()) { textFrame = nullptr; } } } else { // We are not pulling an intra-level whitespace, which means all // elements we are going to pull can have non-whitespace content, // which may contain float which we need to reparent. nsBlockFrame* oldFloatCB = nullptr; for (nsIFrame* frame : aColumn) { oldFloatCB = nsLayoutUtils::GetFloatContainingBlock(frame); break; } #ifdef DEBUG MOZ_ASSERT(oldFloatCB, "Must have found a float containing block"); for (nsIFrame* frame : aColumn) { MOZ_ASSERT(nsLayoutUtils::GetFloatContainingBlock(frame) == oldFloatCB, "All frames in the same ruby column should share " "the same old float containing block"); } #endif nsBlockFrame* newFloatCB = nsLayoutUtils::GetAsBlock(aLineLayout->LineContainerFrame()); MOZ_ASSERT(newFloatCB, "Must have a float containing block"); if (oldFloatCB != newFloatCB) { for (nsIFrame* frame : aColumn) { newFloatCB->ReparentFloats(frame, oldFloatCB, false); } } } // Pull the frames of this column. if (aColumn.mBaseFrame) { DebugOnly<nsIFrame*> pulled = PullNextInFlowChild(aPullFrameState.mBase); MOZ_ASSERT(pulled == aColumn.mBaseFrame, "pulled a wrong frame?"); } for (uint32_t i = 0; i < rtcCount; i++) { if (aColumn.mTextFrames[i]) { DebugOnly<nsIFrame*> pulled = textContainers[i]->PullNextInFlowChild(aPullFrameState.mTexts[i]); MOZ_ASSERT(pulled == aColumn.mTextFrames[i], "pulled a wrong frame?"); } } if (!aIsComplete) { // We pulled frames from the next line, hence mark it dirty. aLineLayout->SetDirtyNextLine(); } } nscoord nsRubyBaseContainerFrame::ReflowSpans(const RubyReflowInput& aReflowInput) { nscoord spanISize = 0; for (uint32_t i = 0, iend = aReflowInput.mTextContainers.Length(); i < iend; i++) { nsRubyTextContainerFrame* container = aReflowInput.mTextContainers[i]; if (!container->IsSpanContainer()) { continue; } nsIFrame* rtFrame = container->PrincipalChildList().FirstChild(); nsReflowStatus reflowStatus; bool pushedFrame; nsLineLayout* lineLayout = aReflowInput.mTextReflowInputs[i]->mLineLayout; MOZ_ASSERT(lineLayout->GetCurrentICoord() == 0, "border/padding of rtc should have been suppressed"); lineLayout->ReflowFrame(rtFrame, reflowStatus, nullptr, pushedFrame); MOZ_ASSERT(!NS_INLINE_IS_BREAK(reflowStatus) && !pushedFrame, "Any line break inside ruby box should has been suppressed"); spanISize = std::max(spanISize, lineLayout->GetCurrentICoord()); } return spanISize; }