mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-12-12 17:22:04 +00:00
dd3c20ccd8
In order to apply Automatic content-based minimum sizes, we have to know the content size on the block axis. We cannot get the content size until we finish the reflow of the child frames. So we have to keep a flag which indicates the size of the ratio-dependent axis is overrideen by aspect-ratio in ReflowInput. We will set the correct return value in the next patch, For now, we always return AspectRatioUsage::None. Differential Revision: https://phabricator.services.mozilla.com/D79335
821 lines
32 KiB
C++
821 lines
32 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
|
|
/* vim: set ts=8 sts=2 et sw=2 tw=80: */
|
|
/* This Source Code Form is subject to the terms of the Mozilla Public
|
|
* License, v. 2.0. If a copy of the MPL was not distributed with this
|
|
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */
|
|
|
|
/* 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 "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)) {
|
|
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& 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),
|
|
AspectRatioUsage::None};
|
|
}
|
|
|
|
/* 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);
|
|
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->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, 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) {
|
|
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(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->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->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;
|
|
}
|