summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsRubyFrame.cpp
diff options
context:
space:
mode:
authorDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
committerDaniel Baumann <daniel.baumann@progress-linux.org>2024-04-07 19:33:14 +0000
commit36d22d82aa202bb199967e9512281e9a53db42c9 (patch)
tree105e8c98ddea1c1e4784a60a5a6410fa416be2de /layout/generic/nsRubyFrame.cpp
parentInitial commit. (diff)
downloadfirefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.tar.xz
firefox-esr-36d22d82aa202bb199967e9512281e9a53db42c9.zip
Adding upstream version 115.7.0esr.upstream/115.7.0esrupstream
Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>
Diffstat (limited to 'layout/generic/nsRubyFrame.cpp')
-rw-r--r--layout/generic/nsRubyFrame.cpp427
1 files changed, 427 insertions, 0 deletions
diff --git a/layout/generic/nsRubyFrame.cpp b/layout/generic/nsRubyFrame.cpp
new file mode 100644
index 0000000000..399472105a
--- /dev/null
+++ b/layout/generic/nsRubyFrame.cpp
@@ -0,0 +1,427 @@
+/* -*- 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" */
+
+#include "nsRubyFrame.h"
+
+#include "RubyUtils.h"
+#include "mozilla/ComputedStyle.h"
+#include "mozilla/Maybe.h"
+#include "mozilla/PresShell.h"
+#include "mozilla/StaticPrefs_layout.h"
+#include "mozilla/WritingModes.h"
+#include "nsLayoutUtils.h"
+#include "nsLineLayout.h"
+#include "nsPresContext.h"
+#include "nsContainerFrameInlines.h"
+#include "nsRubyBaseContainerFrame.h"
+#include "nsRubyTextContainerFrame.h"
+
+using namespace mozilla;
+
+//----------------------------------------------------------------------
+
+// Frame class boilerplate
+// =======================
+
+NS_QUERYFRAME_HEAD(nsRubyFrame)
+ NS_QUERYFRAME_ENTRY(nsRubyFrame)
+NS_QUERYFRAME_TAIL_INHERITING(nsInlineFrame)
+
+NS_IMPL_FRAMEARENA_HELPERS(nsRubyFrame)
+
+nsContainerFrame* NS_NewRubyFrame(PresShell* aPresShell,
+ ComputedStyle* aStyle) {
+ return new (aPresShell) nsRubyFrame(aStyle, aPresShell->GetPresContext());
+}
+
+//----------------------------------------------------------------------
+
+// nsRubyFrame Method Implementations
+// ==================================
+
+/* 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(u"Ruby"_ns, aResult);
+}
+#endif
+
+/* virtual */
+void nsRubyFrame::AddInlineMinISize(gfxContext* aRenderingContext,
+ nsIFrame::InlineMinISizeData* aData) {
+ auto handleChildren = [aRenderingContext](auto frame, auto data) {
+ for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
+ e.Next()) {
+ e.GetBaseContainer()->AddInlineMinISize(aRenderingContext, data);
+ }
+ };
+ DoInlineIntrinsicISize(aData, handleChildren);
+}
+
+/* virtual */
+void nsRubyFrame::AddInlinePrefISize(gfxContext* aRenderingContext,
+ nsIFrame::InlinePrefISizeData* aData) {
+ auto handleChildren = [aRenderingContext](auto frame, auto data) {
+ for (RubySegmentEnumerator e(static_cast<nsRubyFrame*>(frame)); !e.AtEnd();
+ e.Next()) {
+ e.GetBaseContainer()->AddInlinePrefISize(aRenderingContext, data);
+ }
+ };
+ DoInlineIntrinsicISize(aData, handleChildren);
+ 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.
+ MoveInlineOverflowToChildList(aReflowInput.mLineLayout->LineContainerFrame());
+
+ // Clear leadings
+ mLeadings.Reset();
+
+ // Begin the span for the ruby frame
+ WritingMode frameWM = aReflowInput.GetWritingMode();
+ WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
+ LogicalMargin borderPadding =
+ aReflowInput.ComputedLogicalBorderPadding(frameWM);
+ nsLayoutUtils::SetBSizeFromFontMetrics(this, aDesiredSize, borderPadding,
+ lineWM, frameWM);
+
+ nscoord startEdge = 0;
+ const bool boxDecorationBreakClone =
+ StyleBorder()->mBoxDecorationBreak == StyleBoxDecorationBreak::Clone;
+ if (boxDecorationBreakClone || !GetPrevContinuation()) {
+ startEdge = borderPadding.IStart(frameWM);
+ }
+ NS_ASSERTION(aReflowInput.AvailableISize() != NS_UNCONSTRAINEDSIZE,
+ "should no longer use available widths");
+ nscoord endEdge = aReflowInput.AvailableISize() - borderPadding.IEnd(frameWM);
+ aReflowInput.mLineLayout->BeginSpan(this, &aReflowInput, startEdge, endEdge,
+ &mBaseline);
+
+ for (RubySegmentEnumerator e(this); !e.AtEnd(); e.Next()) {
+ ReflowSegment(aPresContext, aReflowInput, aDesiredSize.BlockStartAscent(),
+ aDesiredSize.BSize(lineWM), e.GetBaseContainer(), aStatus);
+
+ if (aStatus.IsInlineBreak()) {
+ // A break occurs when reflowing the segment.
+ // Don't continue reflowing more segments.
+ break;
+ }
+ }
+
+ ContinuationTraversingState pullState(this);
+ while (aStatus.IsEmpty()) {
+ nsRubyBaseContainerFrame* baseContainer =
+ PullOneSegment(aReflowInput.mLineLayout, pullState);
+ if (!baseContainer) {
+ // No more continuations after, finish now.
+ break;
+ }
+ ReflowSegment(aPresContext, aReflowInput, aDesiredSize.BlockStartAscent(),
+ aDesiredSize.BSize(lineWM), baseContainer, aStatus);
+ }
+ // We never handle overflow in ruby.
+ MOZ_ASSERT(!aStatus.IsOverflowIncomplete());
+
+ aDesiredSize.ISize(lineWM) = aReflowInput.mLineLayout->EndSpan(this);
+ if (boxDecorationBreakClone || !GetPrevContinuation()) {
+ aDesiredSize.ISize(lineWM) += borderPadding.IStart(frameWM);
+ }
+ if (boxDecorationBreakClone || aStatus.IsComplete()) {
+ aDesiredSize.ISize(lineWM) += borderPadding.IEnd(frameWM);
+ }
+
+ // Update descendant leadings of ancestor ruby base container.
+ if (nsRubyBaseContainerFrame* rbc = FindRubyBaseContainerAncestor(this)) {
+ rbc->UpdateDescendantLeadings(mLeadings);
+ }
+
+ ReflowAbsoluteFrames(aPresContext, aDesiredSize, aReflowInput, aStatus);
+}
+
+void nsRubyFrame::ReflowSegment(nsPresContext* aPresContext,
+ const ReflowInput& aReflowInput,
+ nscoord aBlockStartAscent, nscoord aBlockSize,
+ nsRubyBaseContainerFrame* aBaseContainer,
+ nsReflowStatus& aStatus) {
+ WritingMode lineWM = aReflowInput.mLineLayout->GetWritingMode();
+ LogicalSize availSize(lineWM, aReflowInput.AvailableISize(),
+ aReflowInput.AvailableBSize());
+ NS_ASSERTION(!GetWritingMode().IsOrthogonalTo(lineWM),
+ "Ruby frame writing-mode shouldn't be orthogonal to its line");
+
+ AutoRubyTextContainerArray textContainers(aBaseContainer);
+ const uint32_t rtcCount = textContainers.Length();
+
+ ReflowOutput baseMetrics(aReflowInput);
+ bool pushedFrame;
+ aReflowInput.mLineLayout->ReflowFrame(aBaseContainer, aStatus, &baseMetrics,
+ pushedFrame);
+
+ if (aStatus.IsInlineBreakBefore()) {
+ if (aBaseContainer != mFrames.FirstChild()) {
+ // Some segments may have been reflowed before, hence it is not
+ // a break-before for the ruby container.
+ aStatus.Reset();
+ aStatus.SetInlineLineBreakAfter();
+ aStatus.SetIncomplete();
+ PushChildrenToOverflow(aBaseContainer, aBaseContainer->GetPrevSibling());
+ aReflowInput.mLineLayout->SetDirtyNextLine();
+ }
+ // This base container is not placed at all, we can skip all
+ // text containers paired with it.
+ return;
+ }
+ if (aStatus.IsIncomplete()) {
+ // It always promise that if the status is incomplete, there is a
+ // break occurs. Break before has been processed above. However,
+ // it is possible that break after happens with the frame reflow
+ // completed. It happens if there is a force break at the end.
+ MOZ_ASSERT(aStatus.IsInlineBreakAfter());
+ // Find the previous sibling which we will
+ // insert new continuations after.
+ nsIFrame* lastChild;
+ if (rtcCount > 0) {
+ lastChild = textContainers.LastElement();
+ } else {
+ lastChild = aBaseContainer;
+ }
+
+ // Create continuations for the base container
+ nsIFrame* newBaseContainer = CreateNextInFlow(aBaseContainer);
+ // newBaseContainer is null if there are existing next-in-flows.
+ // We only need to move and push if there were not.
+ if (newBaseContainer) {
+ // Move the new frame after all the text containers
+ mFrames.RemoveFrame(newBaseContainer);
+ mFrames.InsertFrame(nullptr, lastChild, newBaseContainer);
+
+ // Create continuations for text containers
+ nsIFrame* newLastChild = newBaseContainer;
+ for (uint32_t i = 0; i < rtcCount; i++) {
+ nsIFrame* newTextContainer = CreateNextInFlow(textContainers[i]);
+ MOZ_ASSERT(newTextContainer,
+ "Next-in-flow of rtc should not exist "
+ "if the corresponding rbc does not");
+ mFrames.RemoveFrame(newTextContainer);
+ mFrames.InsertFrame(nullptr, newLastChild, newTextContainer);
+ newLastChild = newTextContainer;
+ }
+ }
+ if (lastChild != mFrames.LastChild()) {
+ // Always push the next frame after the last child in this segment.
+ // It is possible that we pulled it back before our next-in-flow
+ // drain our overflow.
+ PushChildrenToOverflow(lastChild->GetNextSibling(), lastChild);
+ aReflowInput.mLineLayout->SetDirtyNextLine();
+ }
+ } else if (rtcCount) {
+ DestroyContext context(PresShell());
+ // If the ruby base container is reflowed completely, the line
+ // layout will remove the next-in-flows of that frame. But the
+ // line layout is not aware of the ruby text containers, hence
+ // it is necessary to remove them here.
+ for (uint32_t i = 0; i < rtcCount; i++) {
+ if (nsIFrame* nextRTC = textContainers[i]->GetNextInFlow()) {
+ nextRTC->GetParent()->DeleteNextInFlowChild(context, nextRTC, true);
+ }
+ }
+ }
+
+ nscoord segmentISize = baseMetrics.ISize(lineWM);
+ const nsSize dummyContainerSize;
+ LogicalRect baseRect =
+ aBaseContainer->GetLogicalRect(lineWM, dummyContainerSize);
+ // We need to position our rtc frames on one side or the other of the
+ // base container's rect, using a coordinate space that's relative to
+ // the ruby frame. Right now, the base container's rect's block-axis
+ // position is relative to the block container frame containing the
+ // lines, so here we reset it to the different between the ascents of
+ // the ruby container and the ruby base container, assuming they are
+ // aligned with the baseline.
+ // XXX We may need to add border/padding here. See bug 1055667.
+ baseRect.BStart(lineWM) = aBlockStartAscent - baseMetrics.BlockStartAscent();
+ // The rect for offsets of text containers.
+ LogicalRect offsetRect = baseRect;
+ RubyBlockLeadings descLeadings = aBaseContainer->GetDescendantLeadings();
+ offsetRect.BStart(lineWM) -= descLeadings.mStart;
+ offsetRect.BSize(lineWM) += descLeadings.mStart + descLeadings.mEnd;
+ Maybe<LineRelativeDir> lastLineSide;
+ 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");
+ const LogicalSize size = textMetrics.Size(lineWM);
+ textContainer->SetSize(lineWM, size);
+
+ nscoord reservedISize = RubyUtils::GetReservedISize(textContainer);
+ segmentISize = std::max(segmentISize, size.ISize(lineWM) + reservedISize);
+
+ Maybe<LineRelativeDir> lineSide;
+ switch (textContainer->StyleText()->mRubyPosition) {
+ case StyleRubyPosition::Over:
+ lineSide.emplace(eLineRelativeDirOver);
+ break;
+ case StyleRubyPosition::Under:
+ lineSide.emplace(eLineRelativeDirUnder);
+ break;
+ case StyleRubyPosition::AlternateOver:
+ if (lastLineSide.isSome() &&
+ lastLineSide.value() == eLineRelativeDirOver) {
+ lineSide.emplace(eLineRelativeDirUnder);
+ } else {
+ lineSide.emplace(eLineRelativeDirOver);
+ }
+ break;
+ case StyleRubyPosition::AlternateUnder:
+ if (lastLineSide.isSome() &&
+ lastLineSide.value() == eLineRelativeDirUnder) {
+ lineSide.emplace(eLineRelativeDirOver);
+ } else {
+ lineSide.emplace(eLineRelativeDirUnder);
+ }
+ break;
+ default:
+ // XXX inter-character support in bug 1055672
+ MOZ_ASSERT_UNREACHABLE("Unsupported ruby-position");
+ }
+ lastLineSide = lineSide;
+
+ LogicalPoint position(lineWM);
+ if (lineSide.isSome()) {
+ LogicalSide logicalSide =
+ lineWM.LogicalSideForLineRelativeDir(lineSide.value());
+ if (StaticPrefs::layout_css_ruby_intercharacter_enabled() &&
+ rtcWM.IsVerticalRL() &&
+ lineWM.GetInlineDir() == WritingMode::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 (logicalSide == eLogicalSideBStart) {
+ offsetRect.BStart(lineWM) -= size.BSize(lineWM);
+ offsetRect.BSize(lineWM) += size.BSize(lineWM);
+ position = offsetRect.Origin(lineWM);
+ } else if (logicalSide == 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,
+ ReflowChildFlags::Default);
+ }
+ MOZ_ASSERT(baseRect.ISize(lineWM) == offsetRect.ISize(lineWM),
+ "Annotations should only be placed on the block directions");
+
+ nscoord deltaISize = segmentISize - baseMetrics.ISize(lineWM);
+ if (deltaISize <= 0) {
+ RubyUtils::ClearReservedISize(aBaseContainer);
+ } else {
+ RubyUtils::SetReservedISize(aBaseContainer, deltaISize);
+ aReflowInput.mLineLayout->AdvanceICoord(deltaISize);
+ }
+
+ // Set block leadings of the base container.
+ // The leadings are the difference between the offsetRect and the rect
+ // of this ruby container, which has block start zero and block size
+ // aBlockSize.
+ nscoord startLeading = -offsetRect.BStart(lineWM);
+ nscoord endLeading = offsetRect.BEnd(lineWM) - aBlockSize;
+ // 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 =
+ do_QueryFrame(aLineLayout->LineContainerFrame())) {
+ if (oldFloatCB && oldFloatCB != newFloatCB) {
+ newFloatCB->ReparentFloats(baseFrame, oldFloatCB, true);
+ }
+ }
+
+ return static_cast<nsRubyBaseContainerFrame*>(baseFrame);
+}