mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-27 12:15:33 +00:00
d77152fcd0
This patch is generated by the following script:
function rename() {
find layout\
-type f\
! -path "./obj*"\
! -path "./.git"\
! -path "./.hg"\
\( -name "*.cpp" -or\
-name "*.h" \)\
-exec sed -i -r "s/$1/$2/g" "{}" \;
}
rename aChildRS aChildRI
rename aContainingBlockRS aContainingBlockRI
rename aFrameRS aFrameRI
rename aLastRS aLastRI
rename aOuterRS aOuterRI
rename aRS aRI
rename blockHtmlRS blockHtmlRI
rename captionRS captionRI
rename cellRS cellRI
rename childRS childRI
rename firstAncestorRS firstAncestorRI
rename flexContainerRS flexContainerRI
rename gridRS gridRI
rename innerRS innerRI
rename lastButOneRS lastButOneRI
rename LineContainerRS LineContainerRI
rename mBlockRS mBlockRI
rename parentRS parentRI
rename secondAncestorRS secondAncestorRI
rename lastRSSize lastRISize
rename lastRSPadding lastRIPadding
MozReview-Commit-ID: YEgZs3WMow
--HG--
extra : rebase_source : c26050c71a3a5b13ef46e6d3582e581702d49ee8
834 lines
31 KiB
C++
834 lines
31 KiB
C++
/* -*- 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;
|
|
}
|
|
|
|
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_WARN_IF_FALSE(NS_INLINE_IS_BREAK(aStatus) ||
|
|
isize == lineSpanSize || mFrames.IsEmpty(), "bad isize");
|
|
|
|
// If there exists any span, the columns must either be completely
|
|
// reflowed, or be not reflowed at all.
|
|
MOZ_ASSERT(NS_INLINE_IS_BREAK_BEFORE(aStatus) ||
|
|
NS_FRAME_IS_COMPLETE(aStatus) || !hasSpan);
|
|
if (!NS_INLINE_IS_BREAK_BEFORE(aStatus) &&
|
|
NS_FRAME_IS_COMPLETE(aStatus) && hasSpan) {
|
|
// Reflow spans
|
|
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;
|
|
}
|