From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- layout/generic/RubyUtils.h | 223 +++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 223 insertions(+) create mode 100644 layout/generic/RubyUtils.h (limited to 'layout/generic/RubyUtils.h') diff --git a/layout/generic/RubyUtils.h b/layout/generic/RubyUtils.h new file mode 100644 index 0000000000..cd2019d100 --- /dev/null +++ b/layout/generic/RubyUtils.h @@ -0,0 +1,223 @@ +/* -*- 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/. */ + +#ifndef mozilla_RubyUtils_h_ +#define mozilla_RubyUtils_h_ + +#include "nsCSSAnonBoxes.h" +#include "nsGkAtoms.h" +#include "nsIFrame.h" +#include "nsTArray.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(LayoutFrameType aFrameType) { + return aFrameType == mozilla::LayoutFrameType::RubyBase || + aFrameType == mozilla::LayoutFrameType::RubyText; + } + + static inline bool IsRubyContainerBox(LayoutFrameType aFrameType) { + return aFrameType == mozilla::LayoutFrameType::RubyBaseContainer || + aFrameType == mozilla::LayoutFrameType::RubyTextContainer; + } + + static inline bool IsRubyBox(LayoutFrameType aFrameType) { + return aFrameType == mozilla::LayoutFrameType::Ruby || + IsRubyContentBox(aFrameType) || IsRubyContainerBox(aFrameType); + } + + static inline bool IsExpandableRubyBox(nsIFrame* aFrame) { + mozilla::LayoutFrameType type = aFrame->Type(); + return IsRubyContentBox(type) || IsRubyContainerBox(type); + } + + static inline bool IsRubyPseudo(PseudoStyleType aPseudo) { + return aPseudo == PseudoStyleType::blockRubyContent || + aPseudo == PseudoStyleType::ruby || + aPseudo == PseudoStyleType::rubyBase || + aPseudo == PseudoStyleType::rubyText || + aPseudo == PseudoStyleType::rubyBaseContainer || + aPseudo == PseudoStyleType::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 { + 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 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 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_) */ -- cgit v1.2.3