gecko-dev/layout/generic/RubyUtils.h
Daniel Holbert 680815cd6e Bug 1412346 part 5: (automated patch) Switch a bunch of C++ files in layout to use our standard mode lines. r=jfkthame
This patch was generated automatically by the "modeline.py" script, available
here: https://github.com/amccreight/moz-source-tools/blob/master/modeline.py

For every file that is modified in this patch, the changes are as follows:
 (1) The patch changes the file to use the exact C++ mode lines from the
     Mozilla coding style guide, available here:
https://developer.mozilla.org/en-US/docs/Mozilla/Developer_guide/Coding_Style#Mode_Line

 (2) The patch deletes any blank lines between the mode line & the MPL
     boilerplate comment.

 (3) If the file previously had the mode lines and MPL boilerplate in a
     single contiguous C++ comment, then the patch splits them into
     separate C++ comments, to match the boilerplate in the coding style.

MozReview-Commit-ID: EuRsDue63tK

--HG--
extra : rebase_source : 3356d4b80ff6213935192e87cdbc9103fec6084c
2017-10-27 10:33:53 -07:00

236 lines
7.1 KiB
C++

/* -*- 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(nsAtom* 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_) */