From 5f8de423f190bbb79a62f804151bc24824fa32d8 Mon Sep 17 00:00:00 2001 From: "Matt A. Tobin" Date: Fri, 2 Feb 2018 04:16:08 -0500 Subject: Add m-esr52 at 52.6.0 --- layout/generic/nsLineBox.h | 1782 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 1782 insertions(+) create mode 100644 layout/generic/nsLineBox.h (limited to 'layout/generic/nsLineBox.h') diff --git a/layout/generic/nsLineBox.h b/layout/generic/nsLineBox.h new file mode 100644 index 000000000..8f42b9e93 --- /dev/null +++ b/layout/generic/nsLineBox.h @@ -0,0 +1,1782 @@ +/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 2 -*- */ +// vim:cindent:ts=2:et:sw=2: +/* 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/. */ + +/* representation of one line within a block frame, a CSS line box */ + +#ifndef nsLineBox_h___ +#define nsLineBox_h___ + +#include "mozilla/Attributes.h" +#include "mozilla/Likely.h" + +#include "nsILineIterator.h" +#include "nsIFrame.h" +#include + +class nsLineBox; +class nsFloatCache; +class nsFloatCacheList; +class nsFloatCacheFreeList; + +// State cached after reflowing a float. This state is used during +// incremental reflow when we avoid reflowing a float. +class nsFloatCache { +public: + nsFloatCache(); +#ifdef NS_BUILD_REFCNT_LOGGING + ~nsFloatCache(); +#else + ~nsFloatCache() { } +#endif + + nsFloatCache* Next() const { return mNext; } + + nsIFrame* mFloat; // floating frame + +protected: + nsFloatCache* mNext; + + friend class nsFloatCacheList; + friend class nsFloatCacheFreeList; +}; + +//---------------------------------------- + +class nsFloatCacheList { +public: +#ifdef NS_BUILD_REFCNT_LOGGING + nsFloatCacheList(); +#else + nsFloatCacheList() : mHead(nullptr) { } +#endif + ~nsFloatCacheList(); + + bool IsEmpty() const { + return nullptr == mHead; + } + + bool NotEmpty() const { + return nullptr != mHead; + } + + nsFloatCache* Head() const { + return mHead; + } + + nsFloatCache* Tail() const; + + void DeleteAll(); + + nsFloatCache* Find(nsIFrame* aOutOfFlowFrame); + + // Remove a nsFloatCache from this list. Deleting this nsFloatCache + // becomes the caller's responsibility. + void Remove(nsFloatCache* aElement) { RemoveAndReturnPrev(aElement); } + + // Steal away aList's nsFloatCache objects and put them in this + // list. aList must not be empty. + void Append(nsFloatCacheFreeList& aList); + +protected: + nsFloatCache* mHead; + + // Remove a nsFloatCache from this list. Deleting this nsFloatCache + // becomes the caller's responsibility. Returns the nsFloatCache that was + // before aElement, or nullptr if aElement was the first. + nsFloatCache* RemoveAndReturnPrev(nsFloatCache* aElement); + + friend class nsFloatCacheFreeList; +}; + +//--------------------------------------- +// Like nsFloatCacheList, but with fast access to the tail + +class nsFloatCacheFreeList : private nsFloatCacheList { +public: +#ifdef NS_BUILD_REFCNT_LOGGING + nsFloatCacheFreeList(); + ~nsFloatCacheFreeList(); +#else + nsFloatCacheFreeList() : mTail(nullptr) { } + ~nsFloatCacheFreeList() { } +#endif + + // Reimplement trivial functions + bool IsEmpty() const { + return nullptr == mHead; + } + + nsFloatCache* Head() const { + return mHead; + } + + nsFloatCache* Tail() const { + return mTail; + } + + bool NotEmpty() const { + return nullptr != mHead; + } + + void DeleteAll(); + + // Steal away aList's nsFloatCache objects and put them on this + // free-list. aList must not be empty. + void Append(nsFloatCacheList& aList); + + void Append(nsFloatCache* aFloatCache); + + void Remove(nsFloatCache* aElement); + + // Remove an nsFloatCache object from this list and return it, or create + // a new one if this one is empty; Set its mFloat to aFloat. + nsFloatCache* Alloc(nsIFrame* aFloat); + +protected: + nsFloatCache* mTail; + + friend class nsFloatCacheList; +}; + +//---------------------------------------------------------------------- + +#define LINE_MAX_CHILD_COUNT INT32_MAX + +/** + * Function to create a line box and initialize it with a single frame. + * The allocation is infallible. + * If the frame was moved from another line then you're responsible + * for notifying that line using NoteFrameRemoved(). Alternatively, + * it's better to use the next function that does that for you in an + * optimal way. + */ +nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsIFrame* aFrame, + bool aIsBlock); +/** + * Function to create a line box and initialize it with aCount frames + * that are currently on aFromLine. The allocation is infallible. + */ +nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsLineBox* aFromLine, + nsIFrame* aFrame, int32_t aCount); + +class nsLineList; + +// don't use the following names outside of this file. Instead, use +// nsLineList::iterator, etc. These are just here to allow them to +// be specified as parameters to methods of nsLineBox. +class nsLineList_iterator; +class nsLineList_const_iterator; +class nsLineList_reverse_iterator; +class nsLineList_const_reverse_iterator; + +/** + * Users must have the class that is to be part of the list inherit + * from nsLineLink. If they want to be efficient, it should be the + * first base class. (This was originally nsCLink in a templatized + * nsCList, but it's still useful separately.) + */ + +class nsLineLink { + + public: + friend class nsLineList; + friend class nsLineList_iterator; + friend class nsLineList_reverse_iterator; + friend class nsLineList_const_iterator; + friend class nsLineList_const_reverse_iterator; + + private: + nsLineLink *_mNext; // or head + nsLineLink *_mPrev; // or tail + +}; + + +/** + * The nsLineBox class represents a horizontal line of frames. It contains + * enough state to support incremental reflow of the frames, event handling + * for the frames, and rendering of the frames. + */ +class nsLineBox final : public nsLineLink { +private: + nsLineBox(nsIFrame* aFrame, int32_t aCount, bool aIsBlock); + ~nsLineBox(); + + // Infallible overloaded new operator. Uses an arena (which comes from the + // presShell) to perform the allocation. + void* operator new(size_t sz, nsIPresShell* aPresShell); + void operator delete(void* aPtr, size_t sz) = delete; + +public: + // Use these functions to allocate and destroy line boxes + friend nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsIFrame* aFrame, + bool aIsBlock); + friend nsLineBox* NS_NewLineBox(nsIPresShell* aPresShell, nsLineBox* aFromLine, + nsIFrame* aFrame, int32_t aCount); + void Destroy(nsIPresShell* aPresShell); + + // mBlock bit + bool IsBlock() const { + return mFlags.mBlock; + } + bool IsInline() const { + return 0 == mFlags.mBlock; + } + + // mDirty bit + void MarkDirty() { + mFlags.mDirty = 1; + } + void ClearDirty() { + mFlags.mDirty = 0; + } + bool IsDirty() const { + return mFlags.mDirty; + } + + // mPreviousMarginDirty bit + void MarkPreviousMarginDirty() { + mFlags.mPreviousMarginDirty = 1; + } + void ClearPreviousMarginDirty() { + mFlags.mPreviousMarginDirty = 0; + } + bool IsPreviousMarginDirty() const { + return mFlags.mPreviousMarginDirty; + } + + // mHasClearance bit + void SetHasClearance() { + mFlags.mHasClearance = 1; + } + void ClearHasClearance() { + mFlags.mHasClearance = 0; + } + bool HasClearance() const { + return mFlags.mHasClearance; + } + + // mImpactedByFloat bit + void SetLineIsImpactedByFloat(bool aValue) { + mFlags.mImpactedByFloat = aValue; + } + bool IsImpactedByFloat() const { + return mFlags.mImpactedByFloat; + } + + // mLineWrapped bit + void SetLineWrapped(bool aOn) { + mFlags.mLineWrapped = aOn; + } + bool IsLineWrapped() const { + return mFlags.mLineWrapped; + } + + // mInvalidateTextRuns bit + void SetInvalidateTextRuns(bool aOn) { + mFlags.mInvalidateTextRuns = aOn; + } + bool GetInvalidateTextRuns() const { + return mFlags.mInvalidateTextRuns; + } + + // mResizeReflowOptimizationDisabled bit + void DisableResizeReflowOptimization() { + mFlags.mResizeReflowOptimizationDisabled = true; + } + void EnableResizeReflowOptimization() { + mFlags.mResizeReflowOptimizationDisabled = false; + } + bool ResizeReflowOptimizationDisabled() const { + return mFlags.mResizeReflowOptimizationDisabled; + } + + // mHasBullet bit + void SetHasBullet() { + mFlags.mHasBullet = true; + InvalidateCachedIsEmpty(); + } + void ClearHasBullet() { + mFlags.mHasBullet = false; + InvalidateCachedIsEmpty(); + } + bool HasBullet() const { + return mFlags.mHasBullet; + } + + // mHadFloatPushed bit + void SetHadFloatPushed() { + mFlags.mHadFloatPushed = true; + } + void ClearHadFloatPushed() { + mFlags.mHadFloatPushed = false; + } + bool HadFloatPushed() const { + return mFlags.mHadFloatPushed; + } + +private: + // Add a hash table for fast lookup when the line has more frames than this. + static const uint32_t kMinChildCountForHashtable = 200; + + /** + * Take ownership of aFromLine's hash table and remove the frames that + * stay on aFromLine from it, i.e. aFromLineNewCount frames starting with + * mFirstChild. This method is used to optimize moving a large number + * of frames from one line to the next. + */ + void StealHashTableFrom(nsLineBox* aFromLine, uint32_t aFromLineNewCount); + + /** + * Does the equivalent of this->NoteFrameAdded and aFromLine->NoteFrameRemoved + * for each frame on this line, but in a optimized way. + */ + void NoteFramesMovedFrom(nsLineBox* aFromLine); + + void SwitchToHashtable() + { + MOZ_ASSERT(!mFlags.mHasHashedFrames); + uint32_t count = GetChildCount(); + mFlags.mHasHashedFrames = 1; + uint32_t minLength = std::max(kMinChildCountForHashtable, + uint32_t(PLDHashTable::kDefaultInitialLength)); + mFrames = new nsTHashtable< nsPtrHashKey >(std::max(count, minLength)); + for (nsIFrame* f = mFirstChild; count-- > 0; f = f->GetNextSibling()) { + mFrames->PutEntry(f); + } + } + void SwitchToCounter() { + MOZ_ASSERT(mFlags.mHasHashedFrames); + uint32_t count = GetChildCount(); + delete mFrames; + mFlags.mHasHashedFrames = 0; + mChildCount = count; + } + +public: + int32_t GetChildCount() const { + return MOZ_UNLIKELY(mFlags.mHasHashedFrames) ? mFrames->Count() : mChildCount; + } + + /** + * Register that aFrame is now on this line. + */ + void NoteFrameAdded(nsIFrame* aFrame) { + if (MOZ_UNLIKELY(mFlags.mHasHashedFrames)) { + mFrames->PutEntry(aFrame); + } else { + if (++mChildCount >= kMinChildCountForHashtable) { + SwitchToHashtable(); + } + } + } + + /** + * Register that aFrame is not on this line anymore. + */ + void NoteFrameRemoved(nsIFrame* aFrame) { + MOZ_ASSERT(GetChildCount() > 0); + if (MOZ_UNLIKELY(mFlags.mHasHashedFrames)) { + mFrames->RemoveEntry(aFrame); + if (mFrames->Count() < kMinChildCountForHashtable) { + SwitchToCounter(); + } + } else { + --mChildCount; + } + } + + // mBreakType value + // Break information is applied *before* the line if the line is a block, + // or *after* the line if the line is an inline. Confusing, I know, but + // using different names should help. + using StyleClear = mozilla::StyleClear; + bool HasBreakBefore() const { + return IsBlock() && StyleClear::None != BreakType(); + } + void SetBreakTypeBefore(StyleClear aBreakType) { + MOZ_ASSERT(IsBlock(), "Only blocks have break-before"); + MOZ_ASSERT(aBreakType == StyleClear::None || + aBreakType == StyleClear::Left || + aBreakType == StyleClear::Right || + aBreakType == StyleClear::Both, + "Only float break types are allowed before a line"); + mFlags.mBreakType = static_cast(aBreakType); + } + StyleClear GetBreakTypeBefore() const { + return IsBlock() ? BreakType() : StyleClear::None; + } + + bool HasBreakAfter() const { + return !IsBlock() && StyleClear::None != BreakType(); + } + void SetBreakTypeAfter(StyleClear aBreakType) { + MOZ_ASSERT(!IsBlock(), "Only inlines have break-after"); + mFlags.mBreakType = static_cast(aBreakType); + } + bool HasFloatBreakAfter() const { + return !IsBlock() && + (StyleClear::Left == BreakType() || + StyleClear::Right == BreakType() || + StyleClear::Both == BreakType()); + } + StyleClear GetBreakTypeAfter() const { + return !IsBlock() ? BreakType() : StyleClear::None; + } + + // mCarriedOutBEndMargin value + nsCollapsingMargin GetCarriedOutBEndMargin() const; + // Returns true if the margin changed + bool SetCarriedOutBEndMargin(nsCollapsingMargin aValue); + + // mFloats + bool HasFloats() const { + return (IsInline() && mInlineData) && mInlineData->mFloats.NotEmpty(); + } + nsFloatCache* GetFirstFloat(); + void FreeFloats(nsFloatCacheFreeList& aFreeList); + void AppendFloats(nsFloatCacheFreeList& aFreeList); + bool RemoveFloat(nsIFrame* aFrame); + + // Combined area is the area of the line that should influence the + // overflow area of its parent block. The combined area should be + // used for painting-related things, but should never be used for + // layout (except for handling of 'overflow'). + void SetOverflowAreas(const nsOverflowAreas& aOverflowAreas); + mozilla::LogicalRect GetOverflowArea(nsOverflowType aType, + mozilla::WritingMode aWM, + const nsSize& aContainerSize) + { + return mozilla::LogicalRect(aWM, GetOverflowArea(aType), aContainerSize); + } + nsRect GetOverflowArea(nsOverflowType aType) { + return mData ? mData->mOverflowAreas.Overflow(aType) : GetPhysicalBounds(); + } + nsOverflowAreas GetOverflowAreas() { + if (mData) { + return mData->mOverflowAreas; + } + nsRect bounds = GetPhysicalBounds(); + return nsOverflowAreas(bounds, bounds); + } + nsRect GetVisualOverflowArea() + { return GetOverflowArea(eVisualOverflow); } + nsRect GetScrollableOverflowArea() + { return GetOverflowArea(eScrollableOverflow); } + + void SlideBy(nscoord aDBCoord, const nsSize& aContainerSize) { + NS_ASSERTION(aContainerSize == mContainerSize || + mContainerSize == nsSize(-1, -1), + "container size doesn't match"); + mContainerSize = aContainerSize; + mBounds.BStart(mWritingMode) += aDBCoord; + if (mData) { + // Use a null containerSize to convert vector from logical to physical. + const nsSize nullContainerSize; + nsPoint physicalDelta = + mozilla::LogicalPoint(mWritingMode, 0, aDBCoord). + GetPhysicalPoint(mWritingMode, nullContainerSize); + NS_FOR_FRAME_OVERFLOW_TYPES(otype) { + mData->mOverflowAreas.Overflow(otype) += physicalDelta; + } + } + } + + // Container-size for the line is changing (and therefore if writing mode + // was vertical-rl, the line will move physically; this is like SlideBy, + // but it is the container size instead of the line's own logical coord + // that is changing. + nsSize UpdateContainerSize(const nsSize aNewContainerSize) + { + NS_ASSERTION(mContainerSize != nsSize(-1, -1), "container size not set"); + nsSize delta = mContainerSize - aNewContainerSize; + mContainerSize = aNewContainerSize; + // this has a physical-coordinate effect only in vertical-rl mode + if (mWritingMode.IsVerticalRL() && mData) { + nsPoint physicalDelta(-delta.width, 0); + NS_FOR_FRAME_OVERFLOW_TYPES(otype) { + mData->mOverflowAreas.Overflow(otype) += physicalDelta; + } + } + return delta; + } + + void IndentBy(nscoord aDICoord, const nsSize& aContainerSize) { + NS_ASSERTION(aContainerSize == mContainerSize || + mContainerSize == nsSize(-1, -1), + "container size doesn't match"); + mContainerSize = aContainerSize; + mBounds.IStart(mWritingMode) += aDICoord; + } + + void ExpandBy(nscoord aDISize, const nsSize& aContainerSize) { + NS_ASSERTION(aContainerSize == mContainerSize || + mContainerSize == nsSize(-1, -1), + "container size doesn't match"); + mContainerSize = aContainerSize; + mBounds.ISize(mWritingMode) += aDISize; + } + + /** + * The logical ascent (distance from block-start to baseline) of the + * linebox is the logical ascent of the anonymous inline box (for + * which we don't actually create a frame) that wraps all the + * consecutive inline children of a block. + * + * This is currently unused for block lines. + */ + nscoord GetLogicalAscent() const { return mAscent; } + void SetLogicalAscent(nscoord aAscent) { mAscent = aAscent; } + + nscoord BStart() const { + return mBounds.BStart(mWritingMode); + } + nscoord BSize() const { + return mBounds.BSize(mWritingMode); + } + nscoord BEnd() const { + return mBounds.BEnd(mWritingMode); + } + nscoord IStart() const { + return mBounds.IStart(mWritingMode); + } + nscoord ISize() const { + return mBounds.ISize(mWritingMode); + } + nscoord IEnd() const { + return mBounds.IEnd(mWritingMode); + } + void SetBoundsEmpty() { + mBounds.IStart(mWritingMode) = 0; + mBounds.ISize(mWritingMode) = 0; + mBounds.BStart(mWritingMode) = 0; + mBounds.BSize(mWritingMode) = 0; + } + + static void DeleteLineList(nsPresContext* aPresContext, nsLineList& aLines, + nsIFrame* aDestructRoot, nsFrameList* aFrames); + + // search from end to beginning of [aBegin, aEnd) + // Returns true if it found the line and false if not. + // Moves aEnd as it searches so that aEnd points to the resulting line. + // aLastFrameBeforeEnd is the last frame before aEnd (so if aEnd is + // the end of the line list, it's just the last frame in the frame + // list). + static bool RFindLineContaining(nsIFrame* aFrame, + const nsLineList_iterator& aBegin, + nsLineList_iterator& aEnd, + nsIFrame* aLastFrameBeforeEnd, + int32_t* aFrameIndexInLine); + +#ifdef DEBUG_FRAME_DUMP + const char* BreakTypeToString(StyleClear aBreakType) const; + char* StateToString(char* aBuf, int32_t aBufSize) const; + + void List(FILE* out, int32_t aIndent, uint32_t aFlags = 0) const; + void List(FILE* out = stderr, const char* aPrefix = "", uint32_t aFlags = 0) const; + nsIFrame* LastChild() const; +#endif + +private: + int32_t IndexOf(nsIFrame* aFrame) const; +public: + + bool Contains(nsIFrame* aFrame) const { + return MOZ_UNLIKELY(mFlags.mHasHashedFrames) ? mFrames->Contains(aFrame) + : IndexOf(aFrame) >= 0; + } + + // whether the line box is "logically" empty (just like nsIFrame::IsEmpty) + bool IsEmpty() const; + + // Call this only while in Reflow() for the block the line belongs + // to, only between reflowing the line (or sliding it, if we skip + // reflowing it) and the end of reflowing the block. + bool CachedIsEmpty(); + + void InvalidateCachedIsEmpty() { + mFlags.mEmptyCacheValid = false; + } + + // For debugging purposes + bool IsValidCachedIsEmpty() { + return mFlags.mEmptyCacheValid; + } + +#ifdef DEBUG + static int32_t GetCtorCount(); +#endif + + nsIFrame* mFirstChild; + + mozilla::WritingMode mWritingMode; + + // Physical size. Use only for physical <-> logical coordinate conversion. + nsSize mContainerSize; + + private: + mozilla::LogicalRect mBounds; + + public: + const mozilla::LogicalRect& GetBounds() { return mBounds; } + nsRect GetPhysicalBounds() const + { + if (mBounds.IsAllZero()) { + return nsRect(0, 0, 0, 0); + } + + NS_ASSERTION(mContainerSize != nsSize(-1, -1), + "mContainerSize not initialized"); + return mBounds.GetPhysicalRect(mWritingMode, mContainerSize); + } + void SetBounds(mozilla::WritingMode aWritingMode, + nscoord aIStart, nscoord aBStart, + nscoord aISize, nscoord aBSize, + const nsSize& aContainerSize) + { + mWritingMode = aWritingMode; + mContainerSize = aContainerSize; + mBounds = mozilla::LogicalRect(aWritingMode, aIStart, aBStart, + aISize, aBSize); + } + void SetBounds(mozilla::WritingMode aWritingMode, + nsRect aRect, const nsSize& aContainerSize) + { + mWritingMode = aWritingMode; + mContainerSize = aContainerSize; + mBounds = mozilla::LogicalRect(aWritingMode, aRect, aContainerSize); + } + + // mFlags.mHasHashedFrames says which one to use + union { + nsTHashtable< nsPtrHashKey >* mFrames; + uint32_t mChildCount; + }; + + struct FlagBits { + uint32_t mDirty : 1; + uint32_t mPreviousMarginDirty : 1; + uint32_t mHasClearance : 1; + uint32_t mBlock : 1; + uint32_t mImpactedByFloat : 1; + uint32_t mLineWrapped: 1; + uint32_t mInvalidateTextRuns : 1; + // default 0 = means that the opt potentially applies to this line. + // 1 = never skip reflowing this line for a resize reflow + uint32_t mResizeReflowOptimizationDisabled: 1; + uint32_t mEmptyCacheValid: 1; + uint32_t mEmptyCacheState: 1; + // mHasBullet indicates that this is an inline line whose block's + // bullet is adjacent to this line and non-empty. + uint32_t mHasBullet : 1; + // Indicates that this line *may* have a placeholder for a float + // that was pushed to a later column or page. + uint32_t mHadFloatPushed : 1; + uint32_t mHasHashedFrames: 1; + uint32_t mBreakType : 4; + }; + + struct ExtraData { + explicit ExtraData(const nsRect& aBounds) : mOverflowAreas(aBounds, aBounds) { + } + nsOverflowAreas mOverflowAreas; + }; + + struct ExtraBlockData : public ExtraData { + explicit ExtraBlockData(const nsRect& aBounds) + : ExtraData(aBounds), + mCarriedOutBEndMargin() + { + } + nsCollapsingMargin mCarriedOutBEndMargin; + }; + + struct ExtraInlineData : public ExtraData { + explicit ExtraInlineData(const nsRect& aBounds) : ExtraData(aBounds) { + } + nsFloatCacheList mFloats; + }; + +protected: + nscoord mAscent; // see |SetAscent| / |GetAscent| + static_assert(sizeof(FlagBits) <= sizeof(uint32_t), + "size of FlagBits should not be larger than size of uint32_t"); + union { + uint32_t mAllFlags; + FlagBits mFlags; + }; + + StyleClear BreakType() const { + return static_cast(mFlags.mBreakType); + }; + + union { + ExtraData* mData; + ExtraBlockData* mBlockData; + ExtraInlineData* mInlineData; + }; + + void Cleanup(); + void MaybeFreeData(); +}; + +/** + * A linked list type where the items in the list must inherit from + * a link type to fuse allocations. + * + * API heavily based on the |list| class in the C++ standard. + */ + +class nsLineList_iterator { + public: + friend class nsLineList; + friend class nsLineList_reverse_iterator; + friend class nsLineList_const_iterator; + friend class nsLineList_const_reverse_iterator; + + typedef nsLineList_iterator iterator_self_type; + typedef nsLineList_reverse_iterator iterator_reverse_type; + + typedef nsLineBox& reference; + typedef const nsLineBox& const_reference; + + typedef nsLineBox* pointer; + typedef const nsLineBox* const_pointer; + + typedef uint32_t size_type; + typedef int32_t difference_type; + + typedef nsLineLink link_type; + +#ifdef DEBUG + nsLineList_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); } +#else + // Auto generated default constructor OK. +#endif + // Auto generated copy-constructor OK. + + inline iterator_self_type& + operator=(const iterator_self_type& aOther); + inline iterator_self_type& + operator=(const iterator_reverse_type& aOther); + + iterator_self_type& operator++() + { + mCurrent = mCurrent->_mNext; + return *this; + } + + iterator_self_type operator++(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mNext; + return rv; + } + + iterator_self_type& operator--() + { + mCurrent = mCurrent->_mPrev; + return *this; + } + + iterator_self_type operator--(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mPrev; + return rv; + } + + reference operator*() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return *static_cast(mCurrent); + } + + pointer operator->() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + pointer get() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + operator pointer() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + const_reference operator*() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return *static_cast(mCurrent); + } + + const_pointer operator->() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + +#ifndef __MWERKS__ + operator const_pointer() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } +#endif /* !__MWERKS__ */ + + iterator_self_type next() + { + iterator_self_type copy(*this); + return ++copy; + } + + const iterator_self_type next() const + { + iterator_self_type copy(*this); + return ++copy; + } + + iterator_self_type prev() + { + iterator_self_type copy(*this); + return --copy; + } + + const iterator_self_type prev() const + { + iterator_self_type copy(*this); + return --copy; + } + + // Passing by value rather than by reference and reference to const + // to keep AIX happy. + bool operator==(const iterator_self_type aOther) const + { + MOZ_ASSERT(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) const + { + MOZ_ASSERT(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + bool operator==(const iterator_self_type aOther) + { + MOZ_ASSERT(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) + { + MOZ_ASSERT(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + + private: + link_type *mCurrent; +#ifdef DEBUG + link_type *mListLink; // the list's link, i.e., the end +#endif +}; + +class nsLineList_reverse_iterator { + + public: + + friend class nsLineList; + friend class nsLineList_iterator; + friend class nsLineList_const_iterator; + friend class nsLineList_const_reverse_iterator; + + typedef nsLineList_reverse_iterator iterator_self_type; + typedef nsLineList_iterator iterator_reverse_type; + + typedef nsLineBox& reference; + typedef const nsLineBox& const_reference; + + typedef nsLineBox* pointer; + typedef const nsLineBox* const_pointer; + + typedef uint32_t size_type; + typedef int32_t difference_type; + + typedef nsLineLink link_type; + +#ifdef DEBUG + nsLineList_reverse_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); } +#else + // Auto generated default constructor OK. +#endif + // Auto generated copy-constructor OK. + + inline iterator_self_type& + operator=(const iterator_reverse_type& aOther); + inline iterator_self_type& + operator=(const iterator_self_type& aOther); + + iterator_self_type& operator++() + { + mCurrent = mCurrent->_mPrev; + return *this; + } + + iterator_self_type operator++(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mPrev; + return rv; + } + + iterator_self_type& operator--() + { + mCurrent = mCurrent->_mNext; + return *this; + } + + iterator_self_type operator--(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mNext; + return rv; + } + + reference operator*() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return *static_cast(mCurrent); + } + + pointer operator->() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + pointer get() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + operator pointer() + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + const_reference operator*() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return *static_cast(mCurrent); + } + + const_pointer operator->() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + +#ifndef __MWERKS__ + operator const_pointer() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } +#endif /* !__MWERKS__ */ + + // Passing by value rather than by reference and reference to const + // to keep AIX happy. + bool operator==(const iterator_self_type aOther) const + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) const + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + bool operator==(const iterator_self_type aOther) + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + + private: + link_type *mCurrent; +#ifdef DEBUG + link_type *mListLink; // the list's link, i.e., the end +#endif +}; + +class nsLineList_const_iterator { + public: + + friend class nsLineList; + friend class nsLineList_iterator; + friend class nsLineList_reverse_iterator; + friend class nsLineList_const_reverse_iterator; + + typedef nsLineList_const_iterator iterator_self_type; + typedef nsLineList_const_reverse_iterator iterator_reverse_type; + typedef nsLineList_iterator iterator_nonconst_type; + typedef nsLineList_reverse_iterator iterator_nonconst_reverse_type; + + typedef nsLineBox& reference; + typedef const nsLineBox& const_reference; + + typedef nsLineBox* pointer; + typedef const nsLineBox* const_pointer; + + typedef uint32_t size_type; + typedef int32_t difference_type; + + typedef nsLineLink link_type; + +#ifdef DEBUG + nsLineList_const_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); } +#else + // Auto generated default constructor OK. +#endif + // Auto generated copy-constructor OK. + + inline iterator_self_type& + operator=(const iterator_nonconst_type& aOther); + inline iterator_self_type& + operator=(const iterator_nonconst_reverse_type& aOther); + inline iterator_self_type& + operator=(const iterator_self_type& aOther); + inline iterator_self_type& + operator=(const iterator_reverse_type& aOther); + + iterator_self_type& operator++() + { + mCurrent = mCurrent->_mNext; + return *this; + } + + iterator_self_type operator++(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mNext; + return rv; + } + + iterator_self_type& operator--() + { + mCurrent = mCurrent->_mPrev; + return *this; + } + + iterator_self_type operator--(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mPrev; + return rv; + } + + const_reference operator*() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return *static_cast(mCurrent); + } + + const_pointer operator->() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + const_pointer get() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + +#ifndef __MWERKS__ + operator const_pointer() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } +#endif /* !__MWERKS__ */ + + const iterator_self_type next() const + { + iterator_self_type copy(*this); + return ++copy; + } + + const iterator_self_type prev() const + { + iterator_self_type copy(*this); + return --copy; + } + + // Passing by value rather than by reference and reference to const + // to keep AIX happy. + bool operator==(const iterator_self_type aOther) const + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) const + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + bool operator==(const iterator_self_type aOther) + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + + private: + const link_type *mCurrent; +#ifdef DEBUG + const link_type *mListLink; // the list's link, i.e., the end +#endif +}; + +class nsLineList_const_reverse_iterator { + public: + + friend class nsLineList; + friend class nsLineList_iterator; + friend class nsLineList_reverse_iterator; + friend class nsLineList_const_iterator; + + typedef nsLineList_const_reverse_iterator iterator_self_type; + typedef nsLineList_const_iterator iterator_reverse_type; + typedef nsLineList_iterator iterator_nonconst_reverse_type; + typedef nsLineList_reverse_iterator iterator_nonconst_type; + + typedef nsLineBox& reference; + typedef const nsLineBox& const_reference; + + typedef nsLineBox* pointer; + typedef const nsLineBox* const_pointer; + + typedef uint32_t size_type; + typedef int32_t difference_type; + + typedef nsLineLink link_type; + +#ifdef DEBUG + nsLineList_const_reverse_iterator() { memset(&mCurrent, 0xcd, sizeof(mCurrent)); } +#else + // Auto generated default constructor OK. +#endif + // Auto generated copy-constructor OK. + + inline iterator_self_type& + operator=(const iterator_nonconst_type& aOther); + inline iterator_self_type& + operator=(const iterator_nonconst_reverse_type& aOther); + inline iterator_self_type& + operator=(const iterator_self_type& aOther); + inline iterator_self_type& + operator=(const iterator_reverse_type& aOther); + + iterator_self_type& operator++() + { + mCurrent = mCurrent->_mPrev; + return *this; + } + + iterator_self_type operator++(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mPrev; + return rv; + } + + iterator_self_type& operator--() + { + mCurrent = mCurrent->_mNext; + return *this; + } + + iterator_self_type operator--(int) + { + iterator_self_type rv(*this); + mCurrent = mCurrent->_mNext; + return rv; + } + + const_reference operator*() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return *static_cast(mCurrent); + } + + const_pointer operator->() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + + const_pointer get() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } + +#ifndef __MWERKS__ + operator const_pointer() const + { + MOZ_ASSERT(mCurrent != mListLink, "running past end"); + return static_cast(mCurrent); + } +#endif /* !__MWERKS__ */ + + // Passing by value rather than by reference and reference to const + // to keep AIX happy. + bool operator==(const iterator_self_type aOther) const + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) const + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + bool operator==(const iterator_self_type aOther) + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent == aOther.mCurrent; + } + bool operator!=(const iterator_self_type aOther) + { + NS_ASSERTION(mListLink == aOther.mListLink, "comparing iterators over different lists"); + return mCurrent != aOther.mCurrent; + } + +//private: + const link_type *mCurrent; +#ifdef DEBUG + const link_type *mListLink; // the list's link, i.e., the end +#endif +}; + +class nsLineList { + + public: + + friend class nsLineList_iterator; + friend class nsLineList_reverse_iterator; + friend class nsLineList_const_iterator; + friend class nsLineList_const_reverse_iterator; + + typedef uint32_t size_type; + typedef int32_t difference_type; + + typedef nsLineLink link_type; + + private: + link_type mLink; + + public: + typedef nsLineList self_type; + + typedef nsLineBox& reference; + typedef const nsLineBox& const_reference; + + typedef nsLineBox* pointer; + typedef const nsLineBox* const_pointer; + + typedef nsLineList_iterator iterator; + typedef nsLineList_reverse_iterator reverse_iterator; + typedef nsLineList_const_iterator const_iterator; + typedef nsLineList_const_reverse_iterator const_reverse_iterator; + + nsLineList() + { + MOZ_COUNT_CTOR(nsLineList); + clear(); + } + + ~nsLineList() + { + MOZ_COUNT_DTOR(nsLineList); + } + + const_iterator begin() const + { + const_iterator rv; + rv.mCurrent = mLink._mNext; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + iterator begin() + { + iterator rv; + rv.mCurrent = mLink._mNext; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + iterator begin(nsLineBox* aLine) + { + iterator rv; + rv.mCurrent = aLine; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + const_iterator end() const + { + const_iterator rv; + rv.mCurrent = &mLink; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + iterator end() + { + iterator rv; + rv.mCurrent = &mLink; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + const_reverse_iterator rbegin() const + { + const_reverse_iterator rv; + rv.mCurrent = mLink._mPrev; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + reverse_iterator rbegin() + { + reverse_iterator rv; + rv.mCurrent = mLink._mPrev; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + reverse_iterator rbegin(nsLineBox* aLine) + { + reverse_iterator rv; + rv.mCurrent = aLine; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + const_reverse_iterator rend() const + { + const_reverse_iterator rv; + rv.mCurrent = &mLink; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + reverse_iterator rend() + { + reverse_iterator rv; + rv.mCurrent = &mLink; +#ifdef DEBUG + rv.mListLink = &mLink; +#endif + return rv; + } + + bool empty() const + { + return mLink._mNext == &mLink; + } + + // NOTE: O(N). + size_type size() const + { + size_type count = 0; + for (const link_type *cur = mLink._mNext; + cur != &mLink; + cur = cur->_mNext) + { + ++count; + } + return count; + } + + pointer front() + { + NS_ASSERTION(!empty(), "no element to return"); + return static_cast(mLink._mNext); + } + + const_pointer front() const + { + NS_ASSERTION(!empty(), "no element to return"); + return static_cast(mLink._mNext); + } + + pointer back() + { + NS_ASSERTION(!empty(), "no element to return"); + return static_cast(mLink._mPrev); + } + + const_pointer back() const + { + NS_ASSERTION(!empty(), "no element to return"); + return static_cast(mLink._mPrev); + } + + void push_front(pointer aNew) + { + aNew->_mNext = mLink._mNext; + mLink._mNext->_mPrev = aNew; + aNew->_mPrev = &mLink; + mLink._mNext = aNew; + } + + void pop_front() + // NOTE: leaves dangling next/prev pointers + { + NS_ASSERTION(!empty(), "no element to pop"); + link_type *newFirst = mLink._mNext->_mNext; + newFirst->_mPrev = &mLink; + // mLink._mNext->_mNext = nullptr; + // mLink._mNext->_mPrev = nullptr; + mLink._mNext = newFirst; + } + + void push_back(pointer aNew) + { + aNew->_mPrev = mLink._mPrev; + mLink._mPrev->_mNext = aNew; + aNew->_mNext = &mLink; + mLink._mPrev = aNew; + } + + void pop_back() + // NOTE: leaves dangling next/prev pointers + { + NS_ASSERTION(!empty(), "no element to pop"); + link_type *newLast = mLink._mPrev->_mPrev; + newLast->_mNext = &mLink; + // mLink._mPrev->_mPrev = nullptr; + // mLink._mPrev->_mNext = nullptr; + mLink._mPrev = newLast; + } + + // inserts x before position + iterator before_insert(iterator position, pointer x) + { + // use |mCurrent| to prevent DEBUG_PASS_END assertions + x->_mPrev = position.mCurrent->_mPrev; + x->_mNext = position.mCurrent; + position.mCurrent->_mPrev->_mNext = x; + position.mCurrent->_mPrev = x; + return --position; + } + + // inserts x after position + iterator after_insert(iterator position, pointer x) + { + // use |mCurrent| to prevent DEBUG_PASS_END assertions + x->_mNext = position.mCurrent->_mNext; + x->_mPrev = position.mCurrent; + position.mCurrent->_mNext->_mPrev = x; + position.mCurrent->_mNext = x; + return ++position; + } + + // returns iterator pointing to after the element + iterator erase(iterator position) + // NOTE: leaves dangling next/prev pointers + { + position->_mPrev->_mNext = position->_mNext; + position->_mNext->_mPrev = position->_mPrev; + return ++position; + } + + void swap(self_type& y) + { + link_type tmp(y.mLink); + y.mLink = mLink; + mLink = tmp; + + if (!empty()) { + mLink._mNext->_mPrev = &mLink; + mLink._mPrev->_mNext = &mLink; + } + + if (!y.empty()) { + y.mLink._mNext->_mPrev = &y.mLink; + y.mLink._mPrev->_mNext = &y.mLink; + } + } + + void clear() + // NOTE: leaves dangling next/prev pointers + { + mLink._mNext = &mLink; + mLink._mPrev = &mLink; + } + + // inserts the conts of x before position and makes x empty + void splice(iterator position, self_type& x) + { + // use |mCurrent| to prevent DEBUG_PASS_END assertions + position.mCurrent->_mPrev->_mNext = x.mLink._mNext; + x.mLink._mNext->_mPrev = position.mCurrent->_mPrev; + x.mLink._mPrev->_mNext = position.mCurrent; + position.mCurrent->_mPrev = x.mLink._mPrev; + x.clear(); + } + + // Inserts element *i from list x before position and removes + // it from x. + void splice(iterator position, self_type& x, iterator i) + { + NS_ASSERTION(!x.empty(), "Can't insert from empty list."); + NS_ASSERTION(position != i && position.mCurrent != i->_mNext, + "We don't check for this case."); + + // remove from |x| + i->_mPrev->_mNext = i->_mNext; + i->_mNext->_mPrev = i->_mPrev; + + // use |mCurrent| to prevent DEBUG_PASS_END assertions + // link into |this|, before-side + i->_mPrev = position.mCurrent->_mPrev; + position.mCurrent->_mPrev->_mNext = i.get(); + + // link into |this|, after-side + i->_mNext = position.mCurrent; + position.mCurrent->_mPrev = i.get(); + } + + // Inserts elements in [|first|, |last|), which are in |x|, + // into |this| before |position| and removes them from |x|. + void splice(iterator position, self_type& x, iterator first, + iterator last) + { + NS_ASSERTION(!x.empty(), "Can't insert from empty list."); + + if (first == last) + return; + + --last; // so we now want to move [first, last] + // remove from |x| + first->_mPrev->_mNext = last->_mNext; + last->_mNext->_mPrev = first->_mPrev; + + // use |mCurrent| to prevent DEBUG_PASS_END assertions + // link into |this|, before-side + first->_mPrev = position.mCurrent->_mPrev; + position.mCurrent->_mPrev->_mNext = first.get(); + + // link into |this|, after-side + last->_mNext = position.mCurrent; + position.mCurrent->_mPrev = last.get(); + } + +}; + + +// Many of these implementations of operator= don't work yet. I don't +// know why. + +#ifdef DEBUG + + // NOTE: ASSIGN_FROM is meant to be used *only* as the entire body + // of a function and therefore lacks PR_{BEGIN,END}_MACRO +#define ASSIGN_FROM(other_) \ + mCurrent = other_.mCurrent; \ + mListLink = other_.mListLink; \ + return *this; + +#else /* !NS_LINELIST_DEBUG_PASS_END */ + +#define ASSIGN_FROM(other_) \ + mCurrent = other_.mCurrent; \ + return *this; + +#endif /* !NS_LINELIST_DEBUG_PASS_END */ + +inline +nsLineList_iterator& +nsLineList_iterator::operator=(const nsLineList_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_iterator& +nsLineList_iterator::operator=(const nsLineList_reverse_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_reverse_iterator& +nsLineList_reverse_iterator::operator=(const nsLineList_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_reverse_iterator& +nsLineList_reverse_iterator::operator=(const nsLineList_reverse_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_iterator& +nsLineList_const_iterator::operator=(const nsLineList_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_iterator& +nsLineList_const_iterator::operator=(const nsLineList_reverse_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_iterator& +nsLineList_const_iterator::operator=(const nsLineList_const_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_iterator& +nsLineList_const_iterator::operator=(const nsLineList_const_reverse_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_reverse_iterator& +nsLineList_const_reverse_iterator::operator=(const nsLineList_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_reverse_iterator& +nsLineList_const_reverse_iterator::operator=(const nsLineList_reverse_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_reverse_iterator& +nsLineList_const_reverse_iterator::operator=(const nsLineList_const_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + +inline +nsLineList_const_reverse_iterator& +nsLineList_const_reverse_iterator::operator=(const nsLineList_const_reverse_iterator& aOther) +{ + ASSIGN_FROM(aOther) +} + + +//---------------------------------------------------------------------- + +class nsLineIterator final : public nsILineIterator +{ +public: + nsLineIterator(); + ~nsLineIterator(); + + virtual void DisposeLineIterator() override; + + virtual int32_t GetNumLines() override; + virtual bool GetDirection() override; + NS_IMETHOD GetLine(int32_t aLineNumber, + nsIFrame** aFirstFrameOnLine, + int32_t* aNumFramesOnLine, + nsRect& aLineBounds) override; + virtual int32_t FindLineContaining(nsIFrame* aFrame, int32_t aStartLine = 0) override; + NS_IMETHOD FindFrameAt(int32_t aLineNumber, + nsPoint aPos, + nsIFrame** aFrameFound, + bool* aPosIsBeforeFirstFrame, + bool* aPosIsAfterLastFrame) override; + + NS_IMETHOD GetNextSiblingOnLine(nsIFrame*& aFrame, int32_t aLineNumber) override; + NS_IMETHOD CheckLineOrder(int32_t aLine, + bool *aIsReordered, + nsIFrame **aFirstVisual, + nsIFrame **aLastVisual) override; + nsresult Init(nsLineList& aLines, bool aRightToLeft); + +private: + nsLineBox* PrevLine() { + if (0 == mIndex) { + return nullptr; + } + return mLines[--mIndex]; + } + + nsLineBox* NextLine() { + if (mIndex >= mNumLines - 1) { + return nullptr; + } + return mLines[++mIndex]; + } + + nsLineBox* LineAt(int32_t aIndex) { + if ((aIndex < 0) || (aIndex >= mNumLines)) { + return nullptr; + } + return mLines[aIndex]; + } + + nsLineBox** mLines; + int32_t mIndex; + int32_t mNumLines; + bool mRightToLeft; +}; + +#endif /* nsLineBox_h___ */ -- cgit v1.2.3