d93880e505
nsReflowStatus::IsEmpty() assertions are added after DISPLAY_REFLOW in the beginning of the Reflow(). A few Reflow() implementations have Reset() calls at the end which are left in place by this patch (with an explanatory comment added to each). These ending Reset()s are only needed for cases where a non-splittable frame passes its own nsReflowStatus to a child's reflow method. Just in case the child leaves a "not fully complete" value in the nsReflowStatus, the non-splittable parent frame must clear out the nsReflowStatus before returning, so that its own parent doesn't then try to split it. MozReview-Commit-ID: 6Jj3jfMAqj4
429 lines
17 KiB
C++
429 lines
17 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" */
|
|
|
|
#include "nsRubyFrame.h"
|
|
|
|
#include "RubyUtils.h"
|
|
#include "mozilla/Maybe.h"
|
|
#include "mozilla/WritingModes.h"
|
|
#include "nsLineLayout.h"
|
|
#include "nsPresContext.h"
|
|
#include "nsRubyBaseContainerFrame.h"
|
|
#include "nsRubyTextContainerFrame.h"
|
|
#include "nsStyleContext.h"
|
|
|
|
using namespace mozilla;
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// Frame class boilerplate
|
|
// =======================
|
|
|
|
NS_QUERYFRAME_HEAD(nsRubyFrame)
|
|
NS_QUERYFRAME_ENTRY(nsRubyFrame)
|
|
NS_QUERYFRAME_TAIL_INHERITING(nsInlineFrame)
|
|
|
|
NS_IMPL_FRAMEARENA_HELPERS(nsRubyFrame)
|
|
|
|
nsContainerFrame*
|
|
NS_NewRubyFrame(nsIPresShell* aPresShell,
|
|
nsStyleContext* aContext)
|
|
{
|
|
return new (aPresShell) nsRubyFrame(aContext);
|
|
}
|
|
|
|
//----------------------------------------------------------------------
|
|
|
|
// nsRubyFrame Method Implementations
|
|
// ==================================
|
|
|
|
/* virtual */ bool
|
|
nsRubyFrame::IsFrameOfType(uint32_t aFlags) const
|
|
{
|
|
if (aFlags & eBidiInlineContainer) {
|
|
return false;
|
|
}
|
|
return nsInlineFrame::IsFrameOfType(aFlags);
|
|
}
|
|
|
|
#ifdef DEBUG_FRAME_DUMP
|
|
nsresult
|
|
nsRubyFrame::GetFrameName(nsAString& aResult) const
|
|
{
|
|
return MakeFrameName(NS_LITERAL_STRING("Ruby"), aResult);
|
|
}
|
|
#endif
|
|
|
|
/* virtual */ void
|
|
nsRubyFrame::AddInlineMinISize(gfxContext *aRenderingContext,
|
|
nsIFrame::InlineMinISizeData *aData)
|
|
{
|
|
for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
|
|
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame));
|
|
!e.AtEnd(); e.Next()) {
|
|
e.GetBaseContainer()->AddInlineMinISize(aRenderingContext, aData);
|
|
}
|
|
}
|
|
}
|
|
|
|
/* virtual */ void
|
|
nsRubyFrame::AddInlinePrefISize(gfxContext *aRenderingContext,
|
|
nsIFrame::InlinePrefISizeData *aData)
|
|
{
|
|
for (nsIFrame* frame = this; frame; frame = frame->GetNextInFlow()) {
|
|
for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame));
|
|
!e.AtEnd(); e.Next()) {
|
|
e.GetBaseContainer()->AddInlinePrefISize(aRenderingContext, aData);
|
|
}
|
|
}
|
|
aData->mLineIsEmpty = false;
|
|
}
|
|
|
|
static nsRubyBaseContainerFrame*
|
|
FindRubyBaseContainerAncestor(nsIFrame* aFrame)
|
|
{
|
|
for (nsIFrame* ancestor = aFrame->GetParent();
|
|
ancestor && ancestor->IsFrameOfType(nsIFrame::eLineParticipant);
|
|
ancestor = ancestor->GetParent()) {
|
|
if (ancestor->IsRubyBaseContainerFrame()) {
|
|
return static_cast<nsRubyBaseContainerFrame*>(ancestor);
|
|
}
|
|
}
|
|
return nullptr;
|
|
}
|
|
|
|
/* virtual */ void
|
|
nsRubyFrame::Reflow(nsPresContext* aPresContext,
|
|
ReflowOutput& aDesiredSize,
|
|
const ReflowInput& aReflowInput,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
MarkInReflow();
|
|
DO_GLOBAL_REFLOW_COUNT("nsRubyFrame");
|
|
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 RubyFrame reflow method.");
|
|
return;
|
|
}
|
|
|
|
// Grab overflow frames from prev-in-flow and its own.
|
|
MoveOverflowToChildList();
|
|
|
|
// Clear leadings
|
|
mLeadings.Reset();
|
|
|
|
// Since the ruby base container is going to reflow not only the ruby
|
|
// base frames, but also the ruby text frames, and then *afterwards*
|
|
// we're going to reflow the ruby text containers (which do not reflow
|
|
// their children), we need to transfer NS_FRAME_IS_DIRTY status from
|
|
// the ruby text containers to their child ruby texts now, both so
|
|
// that the ruby texts are marked dirty if needed, and so that the
|
|
// ruby text container doesn't mark the ruby text frames dirty *after*
|
|
// they're reflowed and leave dirty bits in a clean tree (suppressing
|
|
// future reflows, due to lack of a queued reflow to clean them).
|
|
for (nsIFrame* child : PrincipalChildList()) {
|
|
if (child->HasAnyStateBits(NS_FRAME_IS_DIRTY) &&
|
|
child->IsRubyTextContainerFrame()) {
|
|
for (nsIFrame* grandchild : child->PrincipalChildList()) {
|
|
grandchild->AddStateBits(NS_FRAME_IS_DIRTY);
|
|
}
|
|
// Replace NS_FRAME_IS_DIRTY with NS_FRAME_HAS_DIRTY_CHILDREN so
|
|
// we still have a dirty marking, but one that we won't transfer
|
|
// to children again.
|
|
child->RemoveStateBits(NS_FRAME_IS_DIRTY);
|
|
child->AddStateBits(NS_FRAME_HAS_DIRTY_CHILDREN);
|
|
}
|
|
}
|
|
|
|
// Begin the span for the ruby frame
|
|
WritingMode frameWM = aReflowInput.GetWritingMode();
|
|
WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
|
|
LogicalMargin borderPadding = aReflowInput.ComputedLogicalBorderPadding();
|
|
nscoord startEdge = 0;
|
|
const bool boxDecorationBreakClone =
|
|
StyleBorder()->mBoxDecorationBreak == StyleBoxDecorationBreak::Clone;
|
|
if (boxDecorationBreakClone || !GetPrevContinuation()) {
|
|
startEdge = borderPadding.IStart(frameWM);
|
|
}
|
|
NS_ASSERTION(aReflowInput.AvailableISize() != NS_UNCONSTRAINEDSIZE,
|
|
"should no longer use available widths");
|
|
nscoord availableISize = aReflowInput.AvailableISize();
|
|
availableISize -= startEdge + borderPadding.IEnd(frameWM);
|
|
aReflowInput.mLineLayout->BeginSpan(this, &aReflowInput,
|
|
startEdge, availableISize, &mBaseline);
|
|
|
|
for (RubySegmentEnumerator e(this); !e.AtEnd(); e.Next()) {
|
|
ReflowSegment(aPresContext, aReflowInput, e.GetBaseContainer(), aStatus);
|
|
|
|
if (aStatus.IsInlineBreak()) {
|
|
// A break occurs when reflowing the segment.
|
|
// Don't continue reflowing more segments.
|
|
break;
|
|
}
|
|
}
|
|
|
|
ContinuationTraversingState pullState(this);
|
|
while (aStatus.IsEmpty()) {
|
|
nsRubyBaseContainerFrame* baseContainer =
|
|
PullOneSegment(aReflowInput.mLineLayout, pullState);
|
|
if (!baseContainer) {
|
|
// No more continuations after, finish now.
|
|
break;
|
|
}
|
|
ReflowSegment(aPresContext, aReflowInput, baseContainer, aStatus);
|
|
}
|
|
// We never handle overflow in ruby.
|
|
MOZ_ASSERT(!aStatus.IsOverflowIncomplete());
|
|
|
|
aDesiredSize.ISize(lineWM) = aReflowInput.mLineLayout->EndSpan(this);
|
|
if (boxDecorationBreakClone || !GetPrevContinuation()) {
|
|
aDesiredSize.ISize(lineWM) += borderPadding.IStart(frameWM);
|
|
}
|
|
if (boxDecorationBreakClone || aStatus.IsComplete()) {
|
|
aDesiredSize.ISize(lineWM) += borderPadding.IEnd(frameWM);
|
|
}
|
|
|
|
// Update descendant leadings of ancestor ruby base container.
|
|
if (nsRubyBaseContainerFrame* rbc = FindRubyBaseContainerAncestor(this)) {
|
|
rbc->UpdateDescendantLeadings(mLeadings);
|
|
}
|
|
|
|
nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize,
|
|
borderPadding, lineWM, frameWM);
|
|
}
|
|
|
|
void
|
|
nsRubyFrame::ReflowSegment(nsPresContext* aPresContext,
|
|
const ReflowInput& aReflowInput,
|
|
nsRubyBaseContainerFrame* aBaseContainer,
|
|
nsReflowStatus& aStatus)
|
|
{
|
|
WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
|
|
LogicalSize availSize(lineWM, aReflowInput.AvailableISize(),
|
|
aReflowInput.AvailableBSize());
|
|
WritingMode rubyWM = GetWritingMode();
|
|
NS_ASSERTION(!rubyWM.IsOrthogonalTo(lineWM),
|
|
"Ruby frame writing-mode shouldn't be orthogonal to its line");
|
|
|
|
AutoRubyTextContainerArray textContainers(aBaseContainer);
|
|
const uint32_t rtcCount = textContainers.Length();
|
|
|
|
ReflowOutput baseMetrics(aReflowInput);
|
|
bool pushedFrame;
|
|
aReflowInput.mLineLayout->ReflowFrame(aBaseContainer, aStatus,
|
|
&baseMetrics, pushedFrame);
|
|
|
|
if (aStatus.IsInlineBreakBefore()) {
|
|
if (aBaseContainer != mFrames.FirstChild()) {
|
|
// Some segments may have been reflowed before, hence it is not
|
|
// a break-before for the ruby container.
|
|
aStatus.Reset();
|
|
aStatus.SetInlineLineBreakAfter();
|
|
aStatus.SetIncomplete();
|
|
PushChildren(aBaseContainer, aBaseContainer->GetPrevSibling());
|
|
aReflowInput.mLineLayout->SetDirtyNextLine();
|
|
}
|
|
// This base container is not placed at all, we can skip all
|
|
// text containers paired with it.
|
|
return;
|
|
}
|
|
if (aStatus.IsIncomplete()) {
|
|
// It always promise that if the status is incomplete, there is a
|
|
// break occurs. Break before has been processed above. However,
|
|
// it is possible that break after happens with the frame reflow
|
|
// completed. It happens if there is a force break at the end.
|
|
MOZ_ASSERT(aStatus.IsInlineBreakAfter());
|
|
// Find the previous sibling which we will
|
|
// insert new continuations after.
|
|
nsIFrame* lastChild;
|
|
if (rtcCount > 0) {
|
|
lastChild = textContainers.LastElement();
|
|
} else {
|
|
lastChild = aBaseContainer;
|
|
}
|
|
|
|
// Create continuations for the base container
|
|
nsIFrame* newBaseContainer = CreateNextInFlow(aBaseContainer);
|
|
// newBaseContainer is null if there are existing next-in-flows.
|
|
// We only need to move and push if there were not.
|
|
if (newBaseContainer) {
|
|
// Move the new frame after all the text containers
|
|
mFrames.RemoveFrame(newBaseContainer);
|
|
mFrames.InsertFrame(nullptr, lastChild, newBaseContainer);
|
|
|
|
// Create continuations for text containers
|
|
nsIFrame* newLastChild = newBaseContainer;
|
|
for (uint32_t i = 0; i < rtcCount; i++) {
|
|
nsIFrame* newTextContainer = CreateNextInFlow(textContainers[i]);
|
|
MOZ_ASSERT(newTextContainer, "Next-in-flow of rtc should not exist "
|
|
"if the corresponding rbc does not");
|
|
mFrames.RemoveFrame(newTextContainer);
|
|
mFrames.InsertFrame(nullptr, newLastChild, newTextContainer);
|
|
newLastChild = newTextContainer;
|
|
}
|
|
}
|
|
if (lastChild != mFrames.LastChild()) {
|
|
// Always push the next frame after the last child in this segment.
|
|
// It is possible that we pulled it back before our next-in-flow
|
|
// drain our overflow.
|
|
PushChildren(lastChild->GetNextSibling(), lastChild);
|
|
aReflowInput.mLineLayout->SetDirtyNextLine();
|
|
}
|
|
} else {
|
|
// If the ruby base container is reflowed completely, the line
|
|
// layout will remove the next-in-flows of that frame. But the
|
|
// line layout is not aware of the ruby text containers, hence
|
|
// it is necessary to remove them here.
|
|
for (uint32_t i = 0; i < rtcCount; i++) {
|
|
nsIFrame* nextRTC = textContainers[i]->GetNextInFlow();
|
|
if (nextRTC) {
|
|
nextRTC->GetParent()->DeleteNextInFlowChild(nextRTC, true);
|
|
}
|
|
}
|
|
}
|
|
|
|
nscoord segmentISize = baseMetrics.ISize(lineWM);
|
|
const nsSize dummyContainerSize;
|
|
LogicalRect baseRect =
|
|
aBaseContainer->GetLogicalRect(lineWM, dummyContainerSize);
|
|
// We need to position our rtc frames on one side or the other of the
|
|
// base container's rect, using a coordinate space that's relative to
|
|
// the ruby frame. Right now, the base container's rect's block-axis
|
|
// position is relative to the block container frame containing the
|
|
// lines, so we use 0 instead. (i.e. we assume that the base container
|
|
// is adjacent to the ruby frame's block-start edge.)
|
|
// XXX We may need to add border/padding here. See bug 1055667.
|
|
baseRect.BStart(lineWM) = 0;
|
|
// The rect for offsets of text containers.
|
|
LogicalRect offsetRect = baseRect;
|
|
RubyBlockLeadings descLeadings = aBaseContainer->GetDescendantLeadings();
|
|
offsetRect.BStart(lineWM) -= descLeadings.mStart;
|
|
offsetRect.BSize(lineWM) += descLeadings.mStart + descLeadings.mEnd;
|
|
for (uint32_t i = 0; i < rtcCount; i++) {
|
|
nsRubyTextContainerFrame* textContainer = textContainers[i];
|
|
WritingMode rtcWM = textContainer->GetWritingMode();
|
|
nsReflowStatus textReflowStatus;
|
|
ReflowOutput textMetrics(aReflowInput);
|
|
ReflowInput textReflowInput(aPresContext, aReflowInput, textContainer,
|
|
availSize.ConvertTo(rtcWM, lineWM));
|
|
textContainer->Reflow(aPresContext, textMetrics,
|
|
textReflowInput, textReflowStatus);
|
|
// Ruby text containers always return complete reflow status even when
|
|
// they have continuations, because the breaking has already been
|
|
// handled when reflowing the base containers.
|
|
NS_ASSERTION(textReflowStatus.IsEmpty(),
|
|
"Ruby text container must not break itself inside");
|
|
// The metrics is initialized with reflow state of this ruby frame,
|
|
// hence the writing-mode is tied to rubyWM instead of rtcWM.
|
|
LogicalSize size = textMetrics.Size(rubyWM).ConvertTo(lineWM, rubyWM);
|
|
textContainer->SetSize(lineWM, size);
|
|
|
|
nscoord reservedISize = RubyUtils::GetReservedISize(textContainer);
|
|
segmentISize = std::max(segmentISize, size.ISize(lineWM) + reservedISize);
|
|
|
|
uint8_t rubyPosition = textContainer->StyleText()->mRubyPosition;
|
|
MOZ_ASSERT(rubyPosition == NS_STYLE_RUBY_POSITION_OVER ||
|
|
rubyPosition == NS_STYLE_RUBY_POSITION_UNDER);
|
|
Maybe<LogicalSide> side;
|
|
if (rubyPosition == NS_STYLE_RUBY_POSITION_OVER) {
|
|
side.emplace(lineWM.LogicalSideForLineRelativeDir(eLineRelativeDirOver));
|
|
} else if (rubyPosition == NS_STYLE_RUBY_POSITION_UNDER) {
|
|
side.emplace(lineWM.LogicalSideForLineRelativeDir(eLineRelativeDirUnder));
|
|
} else {
|
|
// XXX inter-character support in bug 1055672
|
|
MOZ_ASSERT_UNREACHABLE("Unsupported ruby-position");
|
|
}
|
|
|
|
LogicalPoint position(lineWM);
|
|
if (side.isSome()) {
|
|
if (nsLayoutUtils::IsInterCharacterRubyEnabled() &&
|
|
rtcWM.IsVerticalRL() &&
|
|
lineWM.GetInlineDir() == WritingMode::eInlineLTR) {
|
|
// Inter-character ruby annotations are only supported for vertical-rl
|
|
// in ltr horizontal writing. Fall back to non-inter-character behavior
|
|
// otherwise.
|
|
LogicalPoint offset(lineWM, offsetRect.ISize(lineWM),
|
|
offsetRect.BSize(lineWM) > size.BSize(lineWM) ?
|
|
(offsetRect.BSize(lineWM) - size.BSize(lineWM)) / 2 : 0);
|
|
position = offsetRect.Origin(lineWM) + offset;
|
|
aReflowInput.mLineLayout->AdvanceICoord(size.ISize(lineWM));
|
|
} else if (side.value() == eLogicalSideBStart) {
|
|
offsetRect.BStart(lineWM) -= size.BSize(lineWM);
|
|
offsetRect.BSize(lineWM) += size.BSize(lineWM);
|
|
position = offsetRect.Origin(lineWM);
|
|
} else if (side.value() == eLogicalSideBEnd) {
|
|
position = offsetRect.Origin(lineWM) +
|
|
LogicalPoint(lineWM, 0, offsetRect.BSize(lineWM));
|
|
offsetRect.BSize(lineWM) += size.BSize(lineWM);
|
|
} else {
|
|
MOZ_ASSERT_UNREACHABLE("???");
|
|
}
|
|
}
|
|
// Using a dummy container-size here, so child positioning may not be
|
|
// correct. We will fix it in nsLineLayout after the whole line is
|
|
// reflowed.
|
|
FinishReflowChild(textContainer, aPresContext, textMetrics,
|
|
&textReflowInput, lineWM, position, dummyContainerSize, 0);
|
|
}
|
|
MOZ_ASSERT(baseRect.ISize(lineWM) == offsetRect.ISize(lineWM),
|
|
"Annotations should only be placed on the block directions");
|
|
|
|
nscoord deltaISize = segmentISize - baseMetrics.ISize(lineWM);
|
|
if (deltaISize <= 0) {
|
|
RubyUtils::ClearReservedISize(aBaseContainer);
|
|
} else {
|
|
RubyUtils::SetReservedISize(aBaseContainer, deltaISize);
|
|
aReflowInput.mLineLayout->AdvanceICoord(deltaISize);
|
|
}
|
|
|
|
// Set block leadings of the base container
|
|
nscoord startLeading = baseRect.BStart(lineWM) - offsetRect.BStart(lineWM);
|
|
nscoord endLeading = offsetRect.BEnd(lineWM) - baseRect.BEnd(lineWM);
|
|
// XXX When bug 765861 gets fixed, this warning should be upgraded.
|
|
NS_WARNING_ASSERTION(startLeading >= 0 && endLeading >= 0,
|
|
"Leadings should be non-negative (because adding "
|
|
"ruby annotation can only increase the size)");
|
|
mLeadings.Update(startLeading, endLeading);
|
|
}
|
|
|
|
nsRubyBaseContainerFrame*
|
|
nsRubyFrame::PullOneSegment(const nsLineLayout* aLineLayout,
|
|
ContinuationTraversingState& aState)
|
|
{
|
|
// Pull a ruby base container
|
|
nsIFrame* baseFrame = GetNextInFlowChild(aState);
|
|
if (!baseFrame) {
|
|
return nullptr;
|
|
}
|
|
MOZ_ASSERT(baseFrame->IsRubyBaseContainerFrame());
|
|
|
|
// Get the float containing block of the base frame before we pull it.
|
|
nsBlockFrame* oldFloatCB =
|
|
nsLayoutUtils::GetFloatContainingBlock(baseFrame);
|
|
PullNextInFlowChild(aState);
|
|
|
|
// Pull all ruby text containers following the base container
|
|
nsIFrame* nextFrame;
|
|
while ((nextFrame = GetNextInFlowChild(aState)) != nullptr &&
|
|
nextFrame->IsRubyTextContainerFrame()) {
|
|
PullNextInFlowChild(aState);
|
|
}
|
|
|
|
if (nsBlockFrame* newFloatCB =
|
|
nsLayoutUtils::GetAsBlock(aLineLayout->LineContainerFrame())) {
|
|
if (oldFloatCB && oldFloatCB != newFloatCB) {
|
|
newFloatCB->ReparentFloats(baseFrame, oldFloatCB, true);
|
|
}
|
|
}
|
|
|
|
return static_cast<nsRubyBaseContainerFrame*>(baseFrame);
|
|
}
|