summaryrefslogtreecommitdiffstats
path: root/layout/generic/RubyUtils.h
diff options
context:
space:
mode:
authorMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
committerMatt A. Tobin <mattatobin@localhost.localdomain>2018-02-02 04:16:08 -0500
commit5f8de423f190bbb79a62f804151bc24824fa32d8 (patch)
tree10027f336435511475e392454359edea8e25895d /layout/generic/RubyUtils.h
parent49ee0794b5d912db1f95dce6eb52d781dc210db5 (diff)
downloadUXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.gz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.lz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.tar.xz
UXP-5f8de423f190bbb79a62f804151bc24824fa32d8.zip
Add m-esr52 at 52.6.0
Diffstat (limited to 'layout/generic/RubyUtils.h')
-rw-r--r--layout/generic/RubyUtils.h234
1 files changed, 234 insertions, 0 deletions
diff --git a/layout/generic/RubyUtils.h b/layout/generic/RubyUtils.h
new file mode 100644
index 000000000..8c9545f70
--- /dev/null
+++ b/layout/generic/RubyUtils.h
@@ -0,0 +1,234 @@
+/* -*- 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_) */