tor-browser

RubyUtils.cpp (7023B)

---

/* -*- 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/. */

#include "RubyUtils.h"

#include "nsRubyBaseContainerFrame.h"
#include "nsRubyBaseFrame.h"
#include "nsRubyFrame.h"
#include "nsRubyTextContainerFrame.h"
#include "nsRubyTextFrame.h"

using namespace mozilla;

NS_DECLARE_FRAME_PROPERTY_SMALL_VALUE(ReservedISize, nscoord)

/* static */
void RubyUtils::SetReservedISize(nsIFrame* aFrame, nscoord aISize) {
 MOZ_ASSERT(IsExpandableRubyBox(aFrame));
 aFrame->SetProperty(ReservedISize(), aISize);
}

/* static */
void RubyUtils::ClearReservedISize(nsIFrame* aFrame) {
 MOZ_ASSERT(IsExpandableRubyBox(aFrame));
 aFrame->RemoveProperty(ReservedISize());
}

/* static */
nscoord RubyUtils::GetReservedISize(nsIFrame* aFrame) {
 MOZ_ASSERT(IsExpandableRubyBox(aFrame));
 return aFrame->GetProperty(ReservedISize());
}

AutoRubyTextContainerArray::AutoRubyTextContainerArray(
   nsRubyBaseContainerFrame* aBaseContainer) {
 for (nsIFrame* frame = aBaseContainer->GetNextSibling();
      frame && frame->IsRubyTextContainerFrame();
      frame = frame->GetNextSibling()) {
   AppendElement(static_cast<nsRubyTextContainerFrame*>(frame));
 }
}

nsIFrame* RubyColumn::Iterator::operator*() const {
 nsIFrame* frame;
 if (mIndex == -1) {
   frame = mColumn.mBaseFrame;
 } else {
   frame = mColumn.mTextFrames[mIndex];
 }
 MOZ_ASSERT(frame, "Frame here cannot be null");
 return frame;
}

void RubyColumn::Iterator::SkipUntilExistingFrame() {
 if (mIndex == -1) {
   if (mColumn.mBaseFrame) {
     return;
   }
   ++mIndex;
 }
 int32_t numTextFrames = mColumn.mTextFrames.Length();
 for (; mIndex < numTextFrames; ++mIndex) {
   if (mColumn.mTextFrames[mIndex]) {
     break;
   }
 }
}

RubySegmentEnumerator::RubySegmentEnumerator(nsRubyFrame* aRubyFrame) {
 nsIFrame* frame = aRubyFrame->PrincipalChildList().FirstChild();
 MOZ_ASSERT(!frame || frame->IsRubyBaseContainerFrame());
 mBaseContainer = static_cast<nsRubyBaseContainerFrame*>(frame);
}

void RubySegmentEnumerator::Next() {
 MOZ_ASSERT(mBaseContainer);
 nsIFrame* frame = mBaseContainer->GetNextSibling();
 while (frame && !frame->IsRubyBaseContainerFrame()) {
   frame = frame->GetNextSibling();
 }
 mBaseContainer = static_cast<nsRubyBaseContainerFrame*>(frame);
}

RubyColumnEnumerator::RubyColumnEnumerator(
   nsRubyBaseContainerFrame* aBaseContainer,
   const AutoRubyTextContainerArray& aTextContainers)
   : mAtIntraLevelWhitespace(false) {
 const uint32_t rtcCount = aTextContainers.Length();
 mFrames.SetCapacity(rtcCount + 1);

 nsIFrame* rbFrame = aBaseContainer->PrincipalChildList().FirstChild();
 MOZ_ASSERT(!rbFrame || rbFrame->IsRubyBaseFrame());
 mFrames.AppendElement(static_cast<nsRubyContentFrame*>(rbFrame));
 for (uint32_t i = 0; i < rtcCount; i++) {
   nsRubyTextContainerFrame* container = aTextContainers[i];
   // If the container is for span, leave a nullptr here.
   // Spans do not take part in pairing.
   nsIFrame* rtFrame = !container->IsSpanContainer()
                           ? container->PrincipalChildList().FirstChild()
                           : nullptr;
   MOZ_ASSERT(!rtFrame || rtFrame->IsRubyTextFrame());
   mFrames.AppendElement(static_cast<nsRubyContentFrame*>(rtFrame));
 }

 // We have to init mAtIntraLevelWhitespace to be correct for the
 // first column. There are two ways we could end up with intra-level
 // whitespace in our first colum:
 // 1. The current segment itself is an inter-segment whitespace;
 // 2. If our ruby segment is split across multiple lines, and some
 //    intra-level whitespace happens to fall right after a line-break.
 //    Each line will get its own nsRubyBaseContainerFrame, and the
 //    container right after the line-break will end up with its first
 //    column containing that intra-level whitespace.
 for (uint32_t i = 0, iend = mFrames.Length(); i < iend; i++) {
   nsRubyContentFrame* frame = mFrames[i];
   if (frame && frame->IsIntraLevelWhitespace()) {
     mAtIntraLevelWhitespace = true;
     break;
   }
 }
}

void RubyColumnEnumerator::Next() {
 bool advancingToIntraLevelWhitespace = false;
 for (uint32_t i = 0, iend = mFrames.Length(); i < iend; i++) {
   nsRubyContentFrame* frame = mFrames[i];
   // If we've got intra-level whitespace frames at some levels in the
   // current ruby column, we "faked" an anonymous box for all other
   // levels for this column. So when we advance off this column, we
   // don't advance any of the frames in those levels, because we're
   // just advancing across the "fake" frames.
   if (frame &&
       (!mAtIntraLevelWhitespace || frame->IsIntraLevelWhitespace())) {
     nsIFrame* nextSibling = frame->GetNextSibling();
     MOZ_ASSERT(!nextSibling || nextSibling->Type() == frame->Type(),
                "Frame type should be identical among a level");
     mFrames[i] = frame = static_cast<nsRubyContentFrame*>(nextSibling);
     if (!advancingToIntraLevelWhitespace && frame &&
         frame->IsIntraLevelWhitespace()) {
       advancingToIntraLevelWhitespace = true;
     }
   }
 }
 MOZ_ASSERT(!advancingToIntraLevelWhitespace || !mAtIntraLevelWhitespace,
            "Should never have adjacent intra-level whitespace columns");
 mAtIntraLevelWhitespace = advancingToIntraLevelWhitespace;
}

bool RubyColumnEnumerator::AtEnd() const {
 for (uint32_t i = 0, iend = mFrames.Length(); i < iend; i++) {
   if (mFrames[i]) {
     return false;
   }
 }
 return true;
}

nsRubyContentFrame* RubyColumnEnumerator::GetFrameAtLevel(
   uint32_t aIndex) const {
 // If the current ruby column is for intra-level whitespaces, we
 // return nullptr for any levels that do not have an actual intra-
 // level whitespace frame in this column.  This nullptr represents
 // an anonymous empty intra-level whitespace box.  (In this case,
 // it's important that we NOT return mFrames[aIndex], because it's
 // really part of the next column, not the current one.)
 nsRubyContentFrame* frame = mFrames[aIndex];
 return !mAtIntraLevelWhitespace || (frame && frame->IsIntraLevelWhitespace())
            ? frame
            : nullptr;
}

void RubyColumnEnumerator::GetColumn(RubyColumn& aColumn) const {
 nsRubyContentFrame* rbFrame = GetFrameAtLevel(0);
 MOZ_ASSERT(!rbFrame || rbFrame->IsRubyBaseFrame());
 aColumn.mBaseFrame = static_cast<nsRubyBaseFrame*>(rbFrame);
 aColumn.mTextFrames.ClearAndRetainStorage();
 for (uint32_t i = 1, iend = mFrames.Length(); i < iend; i++) {
   nsRubyContentFrame* rtFrame = GetFrameAtLevel(i);
   MOZ_ASSERT(!rtFrame || rtFrame->IsRubyTextFrame());
   aColumn.mTextFrames.AppendElement(static_cast<nsRubyTextFrame*>(rtFrame));
 }
 aColumn.mIsIntraLevelWhitespace = mAtIntraLevelWhitespace;
}