summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsRubyBaseContainerFrame.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'layout/generic/nsRubyBaseContainerFrame.cpp')
-rw-r--r--layout/generic/nsRubyBaseContainerFrame.cpp830
1 files changed, 830 insertions, 0 deletions
diff --git a/layout/generic/nsRubyBaseContainerFrame.cpp b/layout/generic/nsRubyBaseContainerFrame.cpp
new file mode 100644
index 0000000000..0241792a23
--- /dev/null
+++ b/layout/generic/nsRubyBaseContainerFrame.cpp
@@ -0,0 +1,830 @@
+/* -*- 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/. */
+
+/* rendering object for CSS "display: ruby-base-container" */
+
+#include "nsRubyBaseContainerFrame.h"
+#include "nsRubyTextContainerFrame.h"
+#include "nsRubyBaseFrame.h"
+#include "nsRubyTextFrame.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/DebugOnly.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/WritingModes.h"
+#include "nsLayoutUtils.h"
+#include "nsLineLayout.h"
+#include "nsPresContext.h"
+#include "nsStyleStructInlines.h"
+#include "nsTextFrame.h"
+#include "gfxContext.h"
+#include "RubyUtils.h"
+
+using namespace mozilla;
+using namespace mozilla::gfx;
+
+//----------------------------------------------------------------------
+
+// Frame class boilerplate
+// =======================
+
+NS_QUERYFRAME_HEAD(nsRubyBaseContainerFrame)
+ NS_QUERYFRAME_ENTRY(nsRubyBaseContainerFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsContainerFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(nsRubyBaseContainerFrame)
+
+nsContainerFrame* NS_NewRubyBaseContainerFrame(PresShell* aPresShell,
+ ComputedStyle* aStyle) {
+ return new (aPresShell)
+ nsRubyBaseContainerFrame(aStyle, aPresShell->GetPresContext());
+}
+
+//----------------------------------------------------------------------
+
+// nsRubyBaseContainerFrame Method Implementations
+// ===============================================
+
+#ifdef DEBUG_FRAME_DUMP
+nsresult nsRubyBaseContainerFrame::GetFrameName(nsAString& aResult) const {
+ return MakeFrameName(u"RubyBaseContainer"_ns, 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->IsTextFrame()) {
+ 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);
+ MOZ_ASSERT(textRun, "fail to build textrun?");
+ if (!textRun || 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->Style()->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(
+ gfxContext* 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(
+ gfxContext* 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(
+ gfxContext* 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 | eSupportsContainLayoutAndPaint |
+ eSupportsAspectRatio)) {
+ return false;
+ }
+ return nsContainerFrame::IsFrameOfType(aFlags &
+ ~(nsIFrame::eLineParticipant));
+}
+
+/* virtual */
+bool nsRubyBaseContainerFrame::CanContinueTextRun() const { return true; }
+
+/* virtual */
+nsIFrame::SizeComputationResult nsRubyBaseContainerFrame::ComputeSize(
+ gfxContext* aRenderingContext, WritingMode aWM, const LogicalSize& aCBSize,
+ nscoord aAvailableISize, const LogicalSize& aMargin,
+ const LogicalSize& aBorderPadding, const StyleSizeOverrides& aSizeOverrides,
+ ComputeSizeFlags aFlags) {
+ // Ruby base container frame is inline,
+ // hence don't compute size before reflow.
+ return {LogicalSize(aWM, NS_UNCONSTRAINEDSIZE, NS_UNCONSTRAINEDSIZE),
+ AspectRatioUsage::None};
+}
+
+Maybe<nscoord> nsRubyBaseContainerFrame::GetNaturalBaselineBOffset(
+ WritingMode aWM, BaselineSharingGroup aBaselineGroup,
+ BaselineExportContext) const {
+ if (aBaselineGroup == BaselineSharingGroup::Last) {
+ return Nothing{};
+ }
+ return Some(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);
+ MOZ_ASSERT(aStatus.IsEmpty(), "Caller should pass a fresh reflow status!");
+
+ if (!aReflowInput.mLineLayout) {
+ NS_ASSERTION(
+ aReflowInput.mLineLayout,
+ "No line layout provided to RubyBaseContainerFrame reflow method.");
+ return;
+ }
+
+ mDescendantLeadings.Reset();
+
+ nsIFrame* lineContainer = aReflowInput.mLineLayout->LineContainerFrame();
+ MoveInlineOverflowToChildList(lineContainer);
+ // 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]->MoveInlineOverflowToChildList(lineContainer);
+ }
+
+ WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
+ LogicalSize availSize(lineWM, aReflowInput.AvailableISize(),
+ aReflowInput.AvailableBSize());
+
+ // We have a reflow input 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 inputs and line layouts.
+ // Since there are pointers refer to reflow inputs 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];
+ WritingMode rtcWM = textContainer->GetWritingMode();
+ WritingMode reflowWM = lineWM.IsOrthogonalTo(rtcWM) ? rtcWM : lineWM;
+ 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->GetLineHeight(), -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, reflowWM,
+ nsSize(0, 0));
+ lineLayout->AttachRootFrameToBaseLineLayout();
+ }
+
+ aReflowInput.mLineLayout->BeginSpan(
+ this, &aReflowInput, 0, aReflowInput.AvailableISize(), &mBaseline);
+
+ bool allowInitialLineBreak, allowLineBreak;
+ GetIsLineBreakAllowed(this, aReflowInput.mLineLayout->LineIsBreakable(),
+ &allowInitialLineBreak, &allowLineBreak);
+
+ // Reflow columns excluding any span
+ RubyReflowInput reflowInput = {allowInitialLineBreak,
+ allowLineBreak && !hasSpan, textContainers,
+ aReflowInput, reflowInputs};
+ aDesiredSize.BSize(lineWM) = 0;
+ aDesiredSize.SetBlockStartAscent(0);
+ nscoord isize = ReflowColumns(reflowInput, aDesiredSize, 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(
+ aStatus.IsInlineBreak() || 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(aStatus.IsInlineBreakBefore() || aStatus.IsComplete() || !hasSpan);
+ if (!aStatus.IsInlineBreakBefore() && aStatus.IsComplete() && 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();
+ }
+
+ // If this ruby base container is empty, size it as if there were
+ // an empty inline child inside.
+ if (mFrames.IsEmpty()) {
+ // Border and padding are suppressed on ruby base container, so we
+ // create a dummy zero-sized borderPadding for setting BSize.
+ WritingMode frameWM = aReflowInput.GetWritingMode();
+ LogicalMargin borderPadding(frameWM);
+ nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, borderPadding,
+ lineWM, frameWM);
+ }
+
+ ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);
+}
+
+/**
+ * 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, ReflowOutput& aDesiredSize,
+ 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;
+ aStatus.Reset();
+
+ 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, aDesiredSize,
+ reflowStatus);
+ if (!reflowStatus.IsInlineBreakBefore()) {
+ columnIndex++;
+ }
+ if (reflowStatus.IsInlineBreak()) {
+ break;
+ }
+ // We are not handling overflow here.
+ MOZ_ASSERT(reflowStatus.IsEmpty());
+ }
+
+ bool isComplete = false;
+ PullFrameState pullFrameState(this, aReflowInput.mTextContainers);
+ while (!reflowStatus.IsInlineBreak()) {
+ // We are not handling overflow here.
+ MOZ_ASSERT(reflowStatus.IsEmpty());
+
+ // 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, aDesiredSize,
+ reflowStatus);
+ if (!reflowStatus.IsInlineBreakBefore()) {
+ columnIndex++;
+ }
+ }
+
+ if (!e.AtEnd() && reflowStatus.IsInlineBreakAfter()) {
+ // The current column has been successfully placed.
+ // Skip to the next column and mark break before.
+ e.Next();
+ e.GetColumn(column);
+ reflowStatus.SetInlineLineBreakBeforeAndReset();
+ }
+ if (!e.AtEnd() || (GetNextInFlow() && !isComplete)) {
+ aStatus.SetIncomplete();
+ }
+
+ if (reflowStatus.IsInlineBreakBefore()) {
+ 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.SetInlineLineBreakBeforeAndReset();
+ return 0;
+ }
+ aStatus.SetInlineLineBreakAfter();
+ MOZ_ASSERT(aStatus.IsComplete() || 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) {
+ PushChildrenToOverflow(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]->PushChildrenToOverflow(
+ textFrame, textFrame->GetPrevSibling());
+ }
+ }
+ } else if (reflowStatus.IsInlineBreakAfter()) {
+ // |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.SetInlineLineBreakAfter();
+ }
+
+ return icoord;
+}
+
+nscoord nsRubyBaseContainerFrame::ReflowOneColumn(
+ const RubyReflowInput& aReflowInput, uint32_t aColumnIndex,
+ const RubyColumn& aColumn, ReflowOutput& aDesiredSize,
+ 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.SetInlineLineBreakBeforeAndReset();
+ 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) {
+ bool isCollapsed = false;
+ if (textFrame->StyleVisibility()->mVisible == StyleVisibility::Collapse) {
+ isCollapsed = true;
+ } else {
+ // 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.
+ nsAutoString annotationText;
+ nsLayoutUtils::GetFrameTextContent(textFrame, annotationText);
+ isCollapsed = annotationText.Equals(baseText);
+ }
+ if (isCollapsed) {
+ textFrame->AddStateBits(NS_RUBY_TEXT_FRAME_COLLAPSED);
+ } else {
+ textFrame->RemoveStateBits(NS_RUBY_TEXT_FRAME_COLLAPSED);
+ }
+ 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(reflowStatus.IsInlineBreak() || 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;
+ WritingMode lineWM = lineLayout->GetWritingMode();
+ nscoord baseIStart = lineLayout->GetCurrentICoord();
+ ReflowOutput metrics(lineWM);
+ lineLayout->ReflowFrame(aColumn.mBaseFrame, reflowStatus, &metrics,
+ pushedFrame);
+ if (MOZ_UNLIKELY(reflowStatus.IsInlineBreak() || 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);
+ // Calculate ascent & descent of the base frame and update desired
+ // size of this base container accordingly.
+ nscoord oldAscent = aDesiredSize.BlockStartAscent();
+ nscoord oldDescent = aDesiredSize.BSize(lineWM) - oldAscent;
+ nscoord baseAscent = metrics.BlockStartAscent();
+ nscoord baseDesent = metrics.BSize(lineWM) - baseAscent;
+ LogicalMargin margin = aColumn.mBaseFrame->GetLogicalUsedMargin(lineWM);
+ nscoord newAscent = std::max(baseAscent + margin.BStart(lineWM), oldAscent);
+ nscoord newDescent = std::max(baseDesent + margin.BEnd(lineWM), oldDescent);
+ aDesiredSize.SetBlockStartAscent(newAscent);
+ aDesiredSize.BSize(lineWM) = newAscent + newDescent;
+ }
+
+ // 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->IsCollapsed()) {
+ 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->IsRubyBaseFrame());
+ 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->IsRubyTextFrame());
+ 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.
+ MOZ_ASSERT(aColumn.begin() != aColumn.end(),
+ "Ruby column shouldn't be empty");
+ nsBlockFrame* oldFloatCB =
+ nsLayoutUtils::GetFloatContainingBlock(*aColumn.begin());
+#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 = do_QueryFrame(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(!reflowStatus.IsInlineBreak() && !pushedFrame,
+ "Any line break inside ruby box should has been suppressed");
+ spanISize = std::max(spanISize, lineLayout->GetCurrentICoord());
+ }
+ return spanISize;
+}