Ting-Yu Lin
1e2c727426
In order to compute the rect, we need to have all the inline continuations reflowed and placed. Therefore, this patch introduces a new phase in `nsBlockFrame::Reflow()` to reflow all the absolute descendants under inline containing blocks, and adds the absolute descendants' overflow areas into inline frames and lines' overflow areas. Differential Revision: https://phabricator.services.mozilla.com/D301184
494 lines
20 KiB
C++
494 lines
20 KiB
C++
/* 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/. */
|
|
|
|
/* rendering object for CSS "display: ruby" */
|
|
|
|
#include "nsRubyFrame.h"
|
|
|
|
#include "RubyUtils.h"
|
|
#include "mozilla/ComputedStyle.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/PresShell.h"
|
|
#include "mozilla/StaticPrefs_layout.h"
|
|
#include "mozilla/WritingModes.h"
|
|
#include "nsContainerFrameInlines.h"
|
|
#include "nsLayoutUtils.h"
|
|
#include "nsLineLayout.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsRubyBaseContainerFrame.h"
|
|
#include "nsRubyTextContainerFrame.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Frame class boilerplate
|
|
// =======================
|
|
|
|
NS_QUERYFRAME_HEAD(nsRubyFrame)
|
|
NS_QUERYFRAME_ENTRY(nsRubyFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsInlineFrame)
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsRubyFrame)
|
|
|
|
nsContainerFrame* NS_NewRubyFrame(PresShell* aPresShell,
|
|
ComputedStyle* aStyle) {
|
|
return new (aPresShell) nsRubyFrame(aStyle, aPresShell->GetPresContext());
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsRubyFrame Method Implementations
|
|
// ==================================
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult nsRubyFrame::GetFrameName(nsAString& aResult) const {
|
|
return MakeFrameName(u"Ruby"_ns, aResult);
|
|
}
|
|
#endif
|
|
|
|
/* virtual */
|
|
void nsRubyFrame::AddInlineMinISize(const IntrinsicSizeInput& aInput,
|
|
InlineMinISizeData* aData) {
|
|
auto handleChildren = [&](auto frame, auto data) {
|
|
// Ruby frames shouldn't have percentage block sizes that require a
|
|
// percentage basis for resolution.
|
|
const IntrinsicSizeInput input(aInput.mContext, Nothing(), Nothing());
|
|
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
|
|
e.Next()) {
|
|
e.GetBaseContainer()->AddInlineMinISize(input, data);
|
|
}
|
|
};
|
|
DoInlineIntrinsicISize(aData, handleChildren);
|
|
}
|
|
|
|
/* virtual */
|
|
void nsRubyFrame::AddInlinePrefISize(const IntrinsicSizeInput& aInput,
|
|
InlinePrefISizeData* aData) {
|
|
auto handleChildren = [&](auto frame, auto data) {
|
|
// Ruby frames shouldn't have percentage block sizes that require a
|
|
// percentage basis for resolution.
|
|
const IntrinsicSizeInput input(aInput.mContext, Nothing(), Nothing());
|
|
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
|
|
e.Next()) {
|
|
e.GetBaseContainer()->AddInlinePrefISize(input, data);
|
|
}
|
|
};
|
|
DoInlineIntrinsicISize(aData, handleChildren);
|
|
aData->mLineIsEmpty = false;
|
|
}
|
|
|
|
static nsRubyBaseContainerFrame* FindRubyBaseContainerAncestor(
|
|
nsIFrame* aFrame) {
|
|
for (nsIFrame* ancestor = aFrame->GetParent();
|
|
ancestor && ancestor->IsLineParticipant();
|
|
ancestor = ancestor->GetParent()) {
|
|
if (ancestor->IsRubyBaseContainerFrame()) {
|
|
return static_cast<nsRubyBaseContainerFrame*>(ancestor);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/* virtual */
|
|
void nsRubyFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus) {
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsRubyFrame");
|
|
MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
|
|
|
|
if (!aReflowInput.mLineLayout) {
|
|
NS_ASSERTION(aReflowInput.mLineLayout,
|
|
"No line layout provided to RubyFrame reflow method.");
|
|
return;
|
|
}
|
|
|
|
// Grab overflow frames from prev-in-flow and its own.
|
|
MoveInlineOverflowToChildList(aReflowInput.mLineLayout->LineContainerFrame());
|
|
|
|
// Clear leadings and ruby-positioning metrics.
|
|
mLeadings.Reset();
|
|
mRubyMetrics = mozilla::RubyMetrics();
|
|
|
|
// Begin the span for the ruby frame
|
|
WritingMode frameWM = aReflowInput.GetWritingMode();
|
|
WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
|
|
LogicalMargin borderPadding =
|
|
aReflowInput.ComputedLogicalBorderPadding(frameWM);
|
|
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, borderPadding,
|
|
lineWM, frameWM);
|
|
|
|
nscoord startEdge = 0;
|
|
const bool boxDecorationBreakClone =
|
|
StyleBorder()->mBoxDecorationBreak == StyleBoxDecorationBreak::Clone;
|
|
if (boxDecorationBreakClone || !GetPrevContinuation()) {
|
|
startEdge = borderPadding.IStart(frameWM);
|
|
}
|
|
NS_ASSERTION(aReflowInput.AvailableISize() != NS_UNCONSTRAINEDSIZE,
|
|
"should no longer use available widths");
|
|
nscoord endEdge = aReflowInput.AvailableISize() - borderPadding.IEnd(frameWM);
|
|
aReflowInput.mLineLayout->BeginSpan(this, &aReflowInput, startEdge, endEdge,
|
|
&mBaseline);
|
|
|
|
for (RubySegmentEnumerator e(this); !e.AtEnd(); e.Next()) {
|
|
ReflowSegment(aPresContext, aReflowInput, aDesiredSize.BlockStartAscent(),
|
|
aDesiredSize.BSize(lineWM), e.GetBaseContainer(), aStatus);
|
|
|
|
if (aStatus.IsInlineBreak()) {
|
|
// A break occurs when reflowing the segment.
|
|
// Don't continue reflowing more segments.
|
|
break;
|
|
}
|
|
}
|
|
|
|
ContinuationTraversingState pullState(this);
|
|
while (aStatus.IsEmpty()) {
|
|
nsRubyBaseContainerFrame* baseContainer =
|
|
PullOneSegment(aReflowInput.mLineLayout, pullState);
|
|
if (!baseContainer) {
|
|
// No more continuations after, finish now.
|
|
break;
|
|
}
|
|
ReflowSegment(aPresContext, aReflowInput, aDesiredSize.BlockStartAscent(),
|
|
aDesiredSize.BSize(lineWM), baseContainer, aStatus);
|
|
}
|
|
// We never handle overflow in ruby.
|
|
MOZ_ASSERT(!aStatus.IsOverflowIncomplete());
|
|
|
|
aDesiredSize.ISize(lineWM) = aReflowInput.mLineLayout->EndSpan(this);
|
|
if (boxDecorationBreakClone || !GetPrevContinuation()) {
|
|
aDesiredSize.ISize(lineWM) += borderPadding.IStart(frameWM);
|
|
}
|
|
if (boxDecorationBreakClone || aStatus.IsComplete()) {
|
|
aDesiredSize.ISize(lineWM) += borderPadding.IEnd(frameWM);
|
|
}
|
|
|
|
// Update descendant leadings of ancestor ruby base container.
|
|
if (nsRubyBaseContainerFrame* rbc = FindRubyBaseContainerAncestor(this)) {
|
|
rbc->UpdateDescendantLeadings(mLeadings);
|
|
}
|
|
|
|
if (!StaticPrefs::layout_abspos_fragment_aware_inline_cb_enabled()) {
|
|
// This is the legacy, spec-incompatible behavior to reflow abspos children
|
|
// using only the first ruby fragment's rect.
|
|
ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);
|
|
}
|
|
}
|
|
|
|
void nsRubyFrame::ReflowSegment(nsPresContext* aPresContext,
|
|
const ReflowInput& aReflowInput,
|
|
nscoord aBlockStartAscent, nscoord aBlockSize,
|
|
nsRubyBaseContainerFrame* aBaseContainer,
|
|
nsReflowStatus& aStatus) {
|
|
WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
|
|
LogicalSize availSize(lineWM, aReflowInput.AvailableISize(),
|
|
aReflowInput.AvailableBSize());
|
|
NS_ASSERTION(!GetWritingMode().IsOrthogonalTo(lineWM),
|
|
"Ruby frame writing-mode shouldn't be orthogonal to its line");
|
|
|
|
AutoRubyTextContainerArray textContainers(aBaseContainer);
|
|
const uint32_t rtcCount = textContainers.Length();
|
|
|
|
ReflowOutput baseMetrics(aReflowInput);
|
|
bool pushedFrame;
|
|
aReflowInput.mLineLayout->ReflowFrame(aBaseContainer, aStatus, &baseMetrics,
|
|
pushedFrame);
|
|
|
|
if (aStatus.IsInlineBreakBefore()) {
|
|
if (aBaseContainer != mFrames.FirstChild()) {
|
|
// Some segments may have been reflowed before, hence it is not
|
|
// a break-before for the ruby container.
|
|
aStatus.Reset();
|
|
aStatus.SetInlineLineBreakAfter();
|
|
aStatus.SetIncomplete();
|
|
PushChildrenToOverflow(aBaseContainer, aBaseContainer->GetPrevSibling());
|
|
aReflowInput.mLineLayout->SetDirtyNextLine();
|
|
}
|
|
// This base container is not placed at all, we can skip all
|
|
// text containers paired with it.
|
|
return;
|
|
}
|
|
if (aStatus.IsIncomplete()) {
|
|
// It always promise that if the status is incomplete, there is a
|
|
// break occurs. Break before has been processed above. However,
|
|
// it is possible that break after happens with the frame reflow
|
|
// completed. It happens if there is a force break at the end.
|
|
MOZ_ASSERT(aStatus.IsInlineBreakAfter());
|
|
// Find the previous sibling which we will
|
|
// insert new continuations after.
|
|
nsIFrame* lastChild;
|
|
if (rtcCount > 0) {
|
|
lastChild = textContainers.LastElement();
|
|
} else {
|
|
lastChild = aBaseContainer;
|
|
}
|
|
|
|
// Create continuations for the base container
|
|
nsIFrame* newBaseContainer = CreateNextInFlow(aBaseContainer);
|
|
// newBaseContainer is null if there are existing next-in-flows.
|
|
// We only need to move and push if there were not.
|
|
if (newBaseContainer) {
|
|
// Move the new frame after all the text containers
|
|
mFrames.RemoveFrame(newBaseContainer);
|
|
mFrames.InsertFrame(nullptr, lastChild, newBaseContainer);
|
|
|
|
// Create continuations for text containers
|
|
nsIFrame* newLastChild = newBaseContainer;
|
|
for (uint32_t i = 0; i < rtcCount; i++) {
|
|
nsIFrame* newTextContainer = CreateNextInFlow(textContainers[i]);
|
|
MOZ_ASSERT(newTextContainer,
|
|
"Next-in-flow of rtc should not exist "
|
|
"if the corresponding rbc does not");
|
|
mFrames.RemoveFrame(newTextContainer);
|
|
mFrames.InsertFrame(nullptr, newLastChild, newTextContainer);
|
|
newLastChild = newTextContainer;
|
|
}
|
|
}
|
|
if (lastChild != mFrames.LastChild()) {
|
|
// Always push the next frame after the last child in this segment.
|
|
// It is possible that we pulled it back before our next-in-flow
|
|
// drain our overflow.
|
|
PushChildrenToOverflow(lastChild->GetNextSibling(), lastChild);
|
|
aReflowInput.mLineLayout->SetDirtyNextLine();
|
|
}
|
|
} else if (rtcCount) {
|
|
DestroyContext context(PresShell());
|
|
// If the ruby base container is reflowed completely, the line
|
|
// layout will remove the next-in-flows of that frame. But the
|
|
// line layout is not aware of the ruby text containers, hence
|
|
// it is necessary to remove them here.
|
|
for (uint32_t i = 0; i < rtcCount; i++) {
|
|
if (nsIFrame* nextRTC = textContainers[i]->GetNextInFlow()) {
|
|
nextRTC->GetParent()->DeleteNextInFlowChild(context, nextRTC, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord segmentISize = baseMetrics.ISize(lineWM);
|
|
const nsSize dummyContainerSize;
|
|
LogicalRect baseRect =
|
|
aBaseContainer->GetLogicalRect(lineWM, dummyContainerSize);
|
|
// We need to position our rtc frames on one side or the other of the
|
|
// base container's rect, using a coordinate space that's relative to
|
|
// the ruby frame. Right now, the base container's rect's block-axis
|
|
// position is relative to the block container frame containing the
|
|
// lines, so here we reset it to the different between the ascents of
|
|
// the ruby container and the ruby base container, assuming they are
|
|
// aligned with the baseline.
|
|
// XXX We may need to add border/padding here. See bug 1055667.
|
|
baseRect.BStart(lineWM) = aBlockStartAscent - baseMetrics.BlockStartAscent();
|
|
// The rect for offsets of text containers.
|
|
LogicalRect offsetRect = baseRect;
|
|
|
|
// Should we do ruby positioning based on em-normalized ascent/descent?
|
|
// This seems to be roughly what Chrome does, and with many fonts it gives
|
|
// a better result (ruby closer to the base text) than using the font's
|
|
// declared metrics, if its ascent/descent incorporate lots of extra space.
|
|
bool normalizeRubyMetrics = aPresContext->NormalizeRubyMetrics();
|
|
float rubyMetricsFactor =
|
|
normalizeRubyMetrics ? aPresContext->RubyPositioningFactor() : 0.0f;
|
|
mozilla::RubyMetrics rubyMetrics;
|
|
|
|
if (normalizeRubyMetrics) {
|
|
// Get base container's ascent & descent, normalized to 1em (scaled by the
|
|
// ruby positioning factor) overall extent, and adjust offsetRect to match.
|
|
rubyMetrics = aBaseContainer->RubyMetrics(rubyMetricsFactor);
|
|
offsetRect.BStart(lineWM) +=
|
|
baseMetrics.BlockStartAscent() - rubyMetrics.mAscent;
|
|
offsetRect.BSize(lineWM) = rubyMetrics.mAscent + rubyMetrics.mDescent;
|
|
} else {
|
|
RubyBlockLeadings descLeadings = aBaseContainer->GetDescendantLeadings();
|
|
offsetRect.BStart(lineWM) -= descLeadings.mStart;
|
|
offsetRect.BSize(lineWM) += descLeadings.mStart + descLeadings.mEnd;
|
|
}
|
|
|
|
Maybe<LineRelativeDir> lastLineSide;
|
|
|
|
// Keep track of any leading required on block-start and/or block-end sides
|
|
// of the base frame to accommodate annotations that project beyond it.
|
|
nscoord startLeading = 0, endLeading = 0;
|
|
|
|
for (uint32_t i = 0; i < rtcCount; i++) {
|
|
nsRubyTextContainerFrame* textContainer = textContainers[i];
|
|
WritingMode rtcWM = textContainer->GetWritingMode();
|
|
nsReflowStatus textReflowStatus;
|
|
ReflowOutput textMetrics(aReflowInput);
|
|
ReflowInput textReflowInput(aPresContext, aReflowInput, textContainer,
|
|
availSize.ConvertTo(rtcWM, lineWM));
|
|
textContainer->Reflow(aPresContext, textMetrics, textReflowInput,
|
|
textReflowStatus);
|
|
// Ruby text containers always return complete reflow status even when
|
|
// they have continuations, because the breaking has already been
|
|
// handled when reflowing the base containers.
|
|
NS_ASSERTION(textReflowStatus.IsEmpty(),
|
|
"Ruby text container must not break itself inside");
|
|
|
|
nscoord textEmHeight = 0;
|
|
nscoord ascentDelta = 0;
|
|
nscoord bStartMargin = 0;
|
|
if (normalizeRubyMetrics) {
|
|
auto [ascent, descent] = textContainer->RubyMetrics(rubyMetricsFactor);
|
|
const auto* firstChild = textContainer->PrincipalChildList().FirstChild();
|
|
textEmHeight = ascent + descent;
|
|
nscoord textBlockStartAscent =
|
|
firstChild && textMetrics.BlockStartAscent() ==
|
|
ReflowOutput::ASK_FOR_BASELINE
|
|
? firstChild->GetLogicalBaseline(lineWM)
|
|
: textMetrics.BlockStartAscent();
|
|
ascentDelta = textBlockStartAscent - ascent;
|
|
bStartMargin =
|
|
firstChild ? firstChild->GetLogicalUsedMargin(lineWM).BStart(lineWM)
|
|
: 0;
|
|
}
|
|
|
|
const LogicalSize size = textMetrics.Size(lineWM);
|
|
textContainer->SetSize(lineWM, size);
|
|
|
|
nscoord reservedISize = RubyUtils::GetReservedISize(textContainer);
|
|
segmentISize = std::max(segmentISize, size.ISize(lineWM) + reservedISize);
|
|
|
|
Maybe<LineRelativeDir> lineSide;
|
|
switch (textContainer->StyleText()->mRubyPosition) {
|
|
case StyleRubyPosition::Over:
|
|
lineSide.emplace(LineRelativeDir::Over);
|
|
break;
|
|
case StyleRubyPosition::Under:
|
|
lineSide.emplace(LineRelativeDir::Under);
|
|
break;
|
|
case StyleRubyPosition::AlternateOver:
|
|
if (lastLineSide.isSome() &&
|
|
lastLineSide.value() == LineRelativeDir::Over) {
|
|
lineSide.emplace(LineRelativeDir::Under);
|
|
} else {
|
|
lineSide.emplace(LineRelativeDir::Over);
|
|
}
|
|
break;
|
|
case StyleRubyPosition::AlternateUnder:
|
|
if (lastLineSide.isSome() &&
|
|
lastLineSide.value() == LineRelativeDir::Under) {
|
|
lineSide.emplace(LineRelativeDir::Over);
|
|
} else {
|
|
lineSide.emplace(LineRelativeDir::Under);
|
|
}
|
|
break;
|
|
default:
|
|
// XXX inter-character support in bug 1055672
|
|
MOZ_ASSERT_UNREACHABLE("Unsupported ruby-position");
|
|
}
|
|
lastLineSide = lineSide;
|
|
|
|
LogicalPoint position(lineWM);
|
|
if (lineSide.isSome()) {
|
|
LogicalSide logicalSide =
|
|
lineWM.LogicalSideForLineRelativeDir(lineSide.value());
|
|
if (StaticPrefs::layout_css_ruby_intercharacter_enabled() &&
|
|
rtcWM.IsVerticalRL() &&
|
|
lineWM.GetInlineDir() == WritingMode::InlineDir::LTR) {
|
|
// Inter-character ruby annotations are only supported for vertical-rl
|
|
// in ltr horizontal writing. Fall back to non-inter-character behavior
|
|
// otherwise.
|
|
LogicalPoint offset(
|
|
lineWM, offsetRect.ISize(lineWM),
|
|
offsetRect.BSize(lineWM) > size.BSize(lineWM)
|
|
? (offsetRect.BSize(lineWM) - size.BSize(lineWM)) / 2
|
|
: 0);
|
|
position = offsetRect.Origin(lineWM) + offset;
|
|
aReflowInput.mLineLayout->AdvanceICoord(size.ISize(lineWM));
|
|
} else if (logicalSide == LogicalSide::BStart) {
|
|
if (normalizeRubyMetrics) {
|
|
offsetRect.BStart(lineWM) -= textEmHeight;
|
|
offsetRect.BSize(lineWM) += textEmHeight;
|
|
position.I(lineWM) = offsetRect.IStart(lineWM);
|
|
position.B(lineWM) = offsetRect.BStart(lineWM) - ascentDelta;
|
|
rubyMetrics.mAscent += textEmHeight;
|
|
} else {
|
|
offsetRect.BStart(lineWM) -= size.BSize(lineWM);
|
|
offsetRect.BSize(lineWM) += size.BSize(lineWM);
|
|
position = offsetRect.Origin(lineWM);
|
|
}
|
|
// Record leading that will be needed on the block-start side to
|
|
// accommodate the ruby text.
|
|
startLeading = -position.B(lineWM);
|
|
} else if (logicalSide == LogicalSide::BEnd) {
|
|
if (normalizeRubyMetrics) {
|
|
position.I(lineWM) = offsetRect.IStart(lineWM);
|
|
position.B(lineWM) =
|
|
offsetRect.BEnd(lineWM) - ascentDelta - bStartMargin;
|
|
offsetRect.BSize(lineWM) += textEmHeight;
|
|
rubyMetrics.mDescent += textEmHeight;
|
|
} else {
|
|
position = offsetRect.Origin(lineWM) +
|
|
LogicalPoint(lineWM, 0, offsetRect.BSize(lineWM));
|
|
offsetRect.BSize(lineWM) += size.BSize(lineWM);
|
|
}
|
|
// Record leading that will be needed on the block-end side to
|
|
// accommodate the ruby text.
|
|
endLeading = position.B(lineWM) + size.BSize(lineWM) - aBlockSize;
|
|
} else {
|
|
MOZ_ASSERT_UNREACHABLE("???");
|
|
}
|
|
}
|
|
// Using a dummy container-size here, so child positioning may not be
|
|
// correct. We will fix it in nsLineLayout after the whole line is
|
|
// reflowed.
|
|
FinishReflowChild(textContainer, aPresContext, textMetrics,
|
|
&textReflowInput, lineWM, position, dummyContainerSize,
|
|
ReflowChildFlags::Default);
|
|
}
|
|
MOZ_ASSERT(baseRect.ISize(lineWM) == offsetRect.ISize(lineWM),
|
|
"Annotations should only be placed on the block directions");
|
|
|
|
nscoord deltaISize = segmentISize - baseMetrics.ISize(lineWM);
|
|
if (deltaISize <= 0) {
|
|
RubyUtils::ClearReservedISize(aBaseContainer);
|
|
} else {
|
|
RubyUtils::SetReservedISize(aBaseContainer, deltaISize);
|
|
aReflowInput.mLineLayout->AdvanceICoord(deltaISize);
|
|
}
|
|
|
|
// Record leadings needed for the block container.
|
|
// The leadings are the difference between the rect of this ruby container,
|
|
// which has block start zero and block size aBlockSize, and the block-start/
|
|
// block-end edges of the outermost annotations.
|
|
// We clamp the values here because if there was significant leading built
|
|
// into the font's original metrics, the annotations may be entirely within
|
|
// this space, but we don't want to introduce negative leading.
|
|
mLeadings.Update(std::max(0, startLeading), std::max(0, endLeading));
|
|
|
|
// Record metrics to be used if any further annotations are added.
|
|
mRubyMetrics.CombineWith(rubyMetrics);
|
|
}
|
|
|
|
nsRubyBaseContainerFrame* nsRubyFrame::PullOneSegment(
|
|
const nsLineLayout* aLineLayout, ContinuationTraversingState& aState) {
|
|
// Pull a ruby base container
|
|
nsIFrame* baseFrame = GetNextInFlowChild(aState);
|
|
if (!baseFrame) {
|
|
return nullptr;
|
|
}
|
|
MOZ_ASSERT(baseFrame->IsRubyBaseContainerFrame());
|
|
|
|
// Get the float containing block of the base frame before we pull it.
|
|
nsBlockFrame* oldFloatCB = nsLayoutUtils::GetFloatContainingBlock(baseFrame);
|
|
PullNextInFlowChild(aState);
|
|
|
|
// Pull all ruby text containers following the base container
|
|
nsIFrame* nextFrame;
|
|
while ((nextFrame = GetNextInFlowChild(aState)) != nullptr &&
|
|
nextFrame->IsRubyTextContainerFrame()) {
|
|
PullNextInFlowChild(aState);
|
|
}
|
|
|
|
if (nsBlockFrame* newFloatCB =
|
|
do_QueryFrame(aLineLayout->LineContainerFrame())) {
|
|
if (oldFloatCB && oldFloatCB != newFloatCB) {
|
|
newFloatCB->ReparentFloats(baseFrame, oldFloatCB, true);
|
|
}
|
|
}
|
|
|
|
return static_cast<nsRubyBaseContainerFrame*>(baseFrame);
|
|
}
|