mirror of
https://github.com/mozilla/gecko-dev.git
synced 2024-10-30 21:55:31 +00:00
f812426c42
Notes: * In CSSAlignUtils.h, I'm just adding a forward-decl for a type used there. * RubyUtils.h needs to #include nsIFrame.h -- a forward-declare won't suffice -- because it makes a nsIFrame method-call ("aFrame->GetType()"). * ScrollSnap.h uses the "Maybe" type and a unit defined in nsIScrollableFrame.h; hence it needs both of those headers. MozReview-Commit-ID: KuhJVh9RTjZ --HG-- extra : rebase_source : 062c1abfe9a1efeb7e241f38302c140075d2ae88
236 lines
7.0 KiB
C++
236 lines
7.0 KiB
C++
/* -*- 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 "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(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_) */
|