/* -*- Mode: C++; tab-width: 2; 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/. */ #ifndef mozilla_RubyUtils_h_ #define mozilla_RubyUtils_h_ #include "nsTArray.h" #include "nsGkAtoms.h" #include "nsCSSAnonBoxes.h" #define RTC_ARRAY_SIZE 1 class nsRubyFrame; class nsRubyBaseFrame; class nsRubyTextFrame; class nsRubyContentFrame; class nsRubyBaseContainerFrame; class nsRubyTextContainerFrame; namespace mozilla { /** * Reserved ISize * * With some exceptions, each ruby internal box has two isizes, which * are the reflowed isize and the final isize. The reflowed isize is * what a box itself needs. It is determined when the box gets reflowed. * * The final isize is what a box should be as the final result. For a * ruby base/text box, the final isize is the size of its ruby column. * For a ruby base/text container, the final isize is the size of its * ruby segment. The final isize is never smaller than the reflowed * isize. It is initially determined when a ruby column/segment gets * fully reflowed, and may be advanced when a box is expanded, e.g. * for justification. * * The difference between the reflowed isize and the final isize is * reserved in the line layout after reflowing a box, hence it is called * "Reserved ISize" here. It is used to expand the ruby boxes from their * reflowed isize to the final isize during alignment of the line. * * There are three exceptions for the final isize: * 1. A ruby text container has a larger final isize only if it is for * a span or collapsed annotations. * 2. A ruby base container has a larger final isize only if at least * one of its ruby text containers does. * 3. If a ruby text container has a larger final isize, its children * must not have. */ class RubyUtils { public: static inline bool IsRubyContentBox(nsIAtom* aFrameType) { return aFrameType == nsGkAtoms::rubyBaseFrame || aFrameType == nsGkAtoms::rubyTextFrame; } static inline bool IsRubyContainerBox(nsIAtom* aFrameType) { return aFrameType == nsGkAtoms::rubyBaseContainerFrame || aFrameType == nsGkAtoms::rubyTextContainerFrame; } static inline bool IsRubyBox(nsIAtom* aFrameType) { return aFrameType == nsGkAtoms::rubyFrame || IsRubyContentBox(aFrameType) || IsRubyContainerBox(aFrameType); } static inline bool IsExpandableRubyBox(nsIFrame* aFrame) { nsIAtom* type = aFrame->GetType(); return IsRubyContentBox(type) || IsRubyContainerBox(type); } static inline bool IsRubyPseudo(nsIAtom* aPseudo) { return aPseudo == nsCSSAnonBoxes::ruby || aPseudo == nsCSSAnonBoxes::rubyBase || aPseudo == nsCSSAnonBoxes::rubyText || aPseudo == nsCSSAnonBoxes::rubyBaseContainer || aPseudo == nsCSSAnonBoxes::rubyTextContainer; } static void SetReservedISize(nsIFrame* aFrame, nscoord aISize); static void ClearReservedISize(nsIFrame* aFrame); static nscoord GetReservedISize(nsIFrame* aFrame); }; /** * This array stores all ruby text containers of the ruby segment * of the given ruby base container. */ class MOZ_RAII AutoRubyTextContainerArray final : public AutoTArray<nsRubyTextContainerFrame*, RTC_ARRAY_SIZE> { public: explicit AutoRubyTextContainerArray(nsRubyBaseContainerFrame* aBaseContainer); }; /** * This enumerator enumerates each ruby segment. */ class MOZ_STACK_CLASS RubySegmentEnumerator { public: explicit RubySegmentEnumerator(nsRubyFrame* aRubyFrame); void Next(); bool AtEnd() const { return !mBaseContainer; } nsRubyBaseContainerFrame* GetBaseContainer() const { return mBaseContainer; } private: nsRubyBaseContainerFrame* mBaseContainer; }; /** * Ruby column is a unit consists of one ruby base and all ruby * annotations paired with it. * See http://dev.w3.org/csswg/css-ruby/#ruby-pairing */ struct MOZ_STACK_CLASS RubyColumn { nsRubyBaseFrame* mBaseFrame; AutoTArray<nsRubyTextFrame*, RTC_ARRAY_SIZE> mTextFrames; bool mIsIntraLevelWhitespace; RubyColumn() : mBaseFrame(nullptr), mIsIntraLevelWhitespace(false) { } // Helper class to support iteration across the frames within a single // RubyColumn (the column's ruby base and its annotations). class MOZ_STACK_CLASS Iterator { public: nsIFrame* operator*() const; Iterator& operator++() { ++mIndex; SkipUntilExistingFrame(); return *this; } Iterator operator++(int) { auto ret = *this; ++*this; return ret; } friend bool operator==(const Iterator& aIter1, const Iterator& aIter2) { MOZ_ASSERT(&aIter1.mColumn == &aIter2.mColumn, "Should only compare iterators of the same ruby column"); return aIter1.mIndex == aIter2.mIndex; } friend bool operator!=(const Iterator& aIter1, const Iterator& aIter2) { return !(aIter1 == aIter2); } private: Iterator(const RubyColumn& aColumn, int32_t aIndex) : mColumn(aColumn) , mIndex(aIndex) { MOZ_ASSERT(aIndex == -1 || (aIndex >= 0 && aIndex <= int32_t(aColumn.mTextFrames.Length()))); SkipUntilExistingFrame(); } friend struct RubyColumn; // for the constructor void SkipUntilExistingFrame(); const RubyColumn& mColumn; // -1 means the ruby base frame, // non-negative means the index of ruby text frame // a value of mTextFrames.Length() means we're done iterating int32_t mIndex = -1; }; Iterator begin() const { return Iterator(*this, -1); } Iterator end() const { return Iterator(*this, mTextFrames.Length()); } Iterator cbegin() const { return begin(); } Iterator cend() const { return end(); } }; /** * This enumerator enumerates ruby columns in a segment. */ class MOZ_STACK_CLASS RubyColumnEnumerator { public: RubyColumnEnumerator(nsRubyBaseContainerFrame* aRBCFrame, const AutoRubyTextContainerArray& aRTCFrames); void Next(); bool AtEnd() const; uint32_t GetLevelCount() const { return mFrames.Length(); } nsRubyContentFrame* GetFrameAtLevel(uint32_t aIndex) const; void GetColumn(RubyColumn& aColumn) const; private: // Frames in this array are NOT necessary part of the current column. // When in doubt, use GetFrameAtLevel to access it. // See GetFrameAtLevel() and Next() for more info. AutoTArray<nsRubyContentFrame*, RTC_ARRAY_SIZE + 1> mFrames; // Whether we are on a column for intra-level whitespaces bool mAtIntraLevelWhitespace; }; /** * Stores block-axis leadings produced from ruby annotations. */ struct RubyBlockLeadings { nscoord mStart = 0; nscoord mEnd = 0; void Reset() { mStart = mEnd = 0; } void Update(nscoord aStart, nscoord aEnd) { mStart = std::max(mStart, aStart); mEnd = std::max(mEnd, aEnd); } void Update(const RubyBlockLeadings& aOther) { Update(aOther.mStart, aOther.mEnd); } }; } // namespace mozilla #endif /* !defined(mozilla_RubyUtils_h_) */