summaryrefslogtreecommitdiffstats
path: root/layout/generic/nsFrameList.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/nsFrameList.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/nsFrameList.h')
-rw-r--r--layout/generic/nsFrameList.h579
1 files changed, 579 insertions, 0 deletions
diff --git a/layout/generic/nsFrameList.h b/layout/generic/nsFrameList.h
new file mode 100644
index 000000000..7ee45a1ee
--- /dev/null
+++ b/layout/generic/nsFrameList.h
@@ -0,0 +1,579 @@
+/* -*- Mode: C++; tab-width: 2; indent-tabs-mode: nil; c-basic-offset: 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/. */
+
+#ifndef nsFrameList_h___
+#define nsFrameList_h___
+
+#include <stdio.h> /* for FILE* */
+#include "nsDebug.h"
+#include "nsTArrayForwardDeclare.h"
+#include "mozilla/ReverseIterator.h"
+
+#if defined(DEBUG) || defined(MOZ_DUMP_PAINTING)
+// DEBUG_FRAME_DUMP enables nsIFrame::List and related methods.
+// You can also define this in a non-DEBUG build if you need frame dumps.
+#define DEBUG_FRAME_DUMP 1
+#endif
+
+class nsContainerFrame;
+class nsIFrame;
+class nsIPresShell;
+class nsPresContext;
+
+namespace mozilla {
+namespace layout {
+ class FrameChildList;
+ enum FrameChildListID {
+ // The individual concrete child lists.
+ kPrincipalList = 0x1,
+ kPopupList = 0x2,
+ kCaptionList = 0x4,
+ kColGroupList = 0x8,
+ kSelectPopupList = 0x10,
+ kAbsoluteList = 0x20,
+ kFixedList = 0x40,
+ kOverflowList = 0x80,
+ kOverflowContainersList = 0x100,
+ kExcessOverflowContainersList = 0x200,
+ kOverflowOutOfFlowList = 0x400,
+ kFloatList = 0x800,
+ kBulletList = 0x1000,
+ kPushedFloatsList = 0x2000,
+ kBackdropList = 0x4000,
+ // A special alias for kPrincipalList that suppress the reflow request that
+ // is normally done when manipulating child lists.
+ kNoReflowPrincipalList = 0x8000
+ };
+} // namespace layout
+} // namespace mozilla
+
+// Uncomment this to enable expensive frame-list integrity checking
+// #define DEBUG_FRAME_LIST
+
+/**
+ * A class for managing a list of frames.
+ */
+class nsFrameList {
+public:
+ nsFrameList() :
+ mFirstChild(nullptr), mLastChild(nullptr)
+ {
+ }
+
+ nsFrameList(nsIFrame* aFirstFrame, nsIFrame* aLastFrame) :
+ mFirstChild(aFirstFrame), mLastChild(aLastFrame)
+ {
+ VerifyList();
+ }
+
+ nsFrameList(const nsFrameList& aOther) :
+ mFirstChild(aOther.mFirstChild), mLastChild(aOther.mLastChild)
+ {
+ }
+
+ /**
+ * Infallibly allocate a nsFrameList from the shell arena.
+ */
+ void* operator new(size_t sz, nsIPresShell* aPresShell);
+
+ /**
+ * Deallocate this list that was allocated from the shell arena.
+ * The list is required to be empty.
+ */
+ void Delete(nsIPresShell* aPresShell);
+
+ /**
+ * For each frame in this list: remove it from the list then call
+ * Destroy() on it.
+ */
+ void DestroyFrames();
+
+ /**
+ * For each frame in this list: remove it from the list then call
+ * DestroyFrom(aDestructRoot) on it.
+ */
+ void DestroyFramesFrom(nsIFrame* aDestructRoot);
+
+ void Clear() { mFirstChild = mLastChild = nullptr; }
+
+ void SetFrames(nsIFrame* aFrameList);
+
+ void SetFrames(nsFrameList& aFrameList) {
+ NS_PRECONDITION(!mFirstChild, "Losing frames");
+
+ mFirstChild = aFrameList.FirstChild();
+ mLastChild = aFrameList.LastChild();
+ aFrameList.Clear();
+ }
+
+ class Slice;
+
+ /**
+ * Append aFrameList to this list. If aParent is not null,
+ * reparents the newly added frames. Clears out aFrameList and
+ * returns a list slice represening the newly-appended frames.
+ */
+ Slice AppendFrames(nsContainerFrame* aParent, nsFrameList& aFrameList) {
+ return InsertFrames(aParent, LastChild(), aFrameList);
+ }
+
+
+ /**
+ * Append aFrame to this list. If aParent is not null,
+ * reparents the newly added frame.
+ */
+ void AppendFrame(nsContainerFrame* aParent, nsIFrame* aFrame) {
+ nsFrameList temp(aFrame, aFrame);
+ AppendFrames(aParent, temp);
+ }
+
+ /**
+ * Take aFrame out of the frame list. This also disconnects aFrame
+ * from the sibling list. The frame must be non-null and present on
+ * this list.
+ */
+ void RemoveFrame(nsIFrame* aFrame);
+
+ /**
+ * Take the frames after aAfterFrame out of the frame list. If
+ * aAfterFrame is null, removes the entire list.
+ * @param aAfterFrame a frame in this list, or null
+ * @return the removed frames, if any
+ */
+ nsFrameList RemoveFramesAfter(nsIFrame* aAfterFrame);
+
+ /**
+ * Take the first frame (if any) out of the frame list.
+ * @return the first child, or nullptr if the list is empty
+ */
+ nsIFrame* RemoveFirstChild();
+
+ /**
+ * The following two functions are intended to be used in concert for
+ * removing a frame from its frame list when the set of possible frame
+ * lists is known in advance, but the exact frame list is unknown.
+ * aFrame must be non-null.
+ * Example use:
+ * bool removed = frameList1.StartRemoveFrame(aFrame) ||
+ * frameList2.ContinueRemoveFrame(aFrame) ||
+ * frameList3.ContinueRemoveFrame(aFrame);
+ * MOZ_ASSERT(removed);
+ *
+ * @note One of the frame lists MUST contain aFrame, if it's on some other
+ * frame list then the example above will likely lead to crashes.
+ * This function is O(1).
+ * @return true iff aFrame was removed from /some/ list, not necessarily
+ * this one. If it was removed from a different list then it is
+ * guaranteed that that list is still non-empty.
+ * (this method is implemented in nsIFrame.h to be able to inline)
+ */
+ inline bool StartRemoveFrame(nsIFrame* aFrame);
+
+ /**
+ * Precondition: StartRemoveFrame MUST be called before this.
+ * This function is O(1).
+ * @see StartRemoveFrame
+ * @return true iff aFrame was removed from this list
+ * (this method is implemented in nsIFrame.h to be able to inline)
+ */
+ inline bool ContinueRemoveFrame(nsIFrame* aFrame);
+
+ /**
+ * Take aFrame out of the frame list and then destroy it.
+ * The frame must be non-null and present on this list.
+ */
+ void DestroyFrame(nsIFrame* aFrame);
+
+ /**
+ * Insert aFrame right after aPrevSibling, or prepend it to this
+ * list if aPrevSibling is null. If aParent is not null, also
+ * reparents newly-added frame. Note that this method always
+ * sets the frame's nextSibling pointer.
+ */
+ void InsertFrame(nsContainerFrame* aParent, nsIFrame* aPrevSibling,
+ nsIFrame* aFrame) {
+ nsFrameList temp(aFrame, aFrame);
+ InsertFrames(aParent, aPrevSibling, temp);
+ }
+
+
+ /**
+ * Inserts aFrameList into this list after aPrevSibling (at the beginning if
+ * aPrevSibling is null). If aParent is not null, reparents the newly added
+ * frames. Clears out aFrameList and returns a list slice representing the
+ * newly-inserted frames.
+ */
+ Slice InsertFrames(nsContainerFrame* aParent, nsIFrame* aPrevSibling,
+ nsFrameList& aFrameList);
+
+ class FrameLinkEnumerator;
+
+ /**
+ * Split this frame list such that all the frames before the link pointed to
+ * by aLink end up in the returned list, while the remaining frames stay in
+ * this list. After this call, aLink points to the beginning of this list.
+ */
+ nsFrameList ExtractHead(FrameLinkEnumerator& aLink);
+
+ /**
+ * Split this frame list such that all the frames coming after the link
+ * pointed to by aLink end up in the returned list, while the frames before
+ * that link stay in this list. After this call, aLink is at end.
+ */
+ nsFrameList ExtractTail(FrameLinkEnumerator& aLink);
+
+ nsIFrame* FirstChild() const {
+ return mFirstChild;
+ }
+
+ nsIFrame* LastChild() const {
+ return mLastChild;
+ }
+
+ nsIFrame* FrameAt(int32_t aIndex) const;
+ int32_t IndexOf(nsIFrame* aFrame) const;
+
+ bool IsEmpty() const {
+ return nullptr == mFirstChild;
+ }
+
+ bool NotEmpty() const {
+ return nullptr != mFirstChild;
+ }
+
+ bool ContainsFrame(const nsIFrame* aFrame) const;
+
+ /**
+ * Get the number of frames in this list. Note that currently the
+ * implementation has O(n) time complexity. Do not call it repeatedly in hot
+ * code.
+ */
+ int32_t GetLength() const;
+
+ /**
+ * If this frame list has only one frame, return that frame.
+ * Otherwise, return null.
+ */
+ nsIFrame* OnlyChild() const {
+ if (FirstChild() == LastChild()) {
+ return FirstChild();
+ }
+ return nullptr;
+ }
+
+ /**
+ * Call SetParent(aParent) for each frame in this list.
+ * @param aParent the new parent frame, must be non-null
+ */
+ void ApplySetParent(nsContainerFrame* aParent) const;
+
+ /**
+ * If this frame list is non-empty then append it to aLists as the
+ * aListID child list.
+ * (this method is implemented in FrameChildList.h for dependency reasons)
+ */
+ inline void AppendIfNonempty(nsTArray<mozilla::layout::FrameChildList>* aLists,
+ mozilla::layout::FrameChildListID aListID) const;
+
+ /**
+ * Return the frame before this frame in visual order (after Bidi reordering).
+ * If aFrame is null, return the last frame in visual order.
+ */
+ nsIFrame* GetPrevVisualFor(nsIFrame* aFrame) const;
+
+ /**
+ * Return the frame after this frame in visual order (after Bidi reordering).
+ * If aFrame is null, return the first frame in visual order.
+ */
+ nsIFrame* GetNextVisualFor(nsIFrame* aFrame) const;
+
+#ifdef DEBUG_FRAME_DUMP
+ void List(FILE* out) const;
+#endif
+
+ static inline const nsFrameList& EmptyList();
+
+ class Enumerator;
+
+ /**
+ * A class representing a slice of a frame list.
+ */
+ class Slice {
+ friend class Enumerator;
+
+ public:
+ // Implicit on purpose, so that we can easily create enumerators from
+ // nsFrameList via this impicit constructor.
+ MOZ_IMPLICIT Slice(const nsFrameList& aList) :
+#ifdef DEBUG
+ mList(aList),
+#endif
+ mStart(aList.FirstChild()),
+ mEnd(nullptr)
+ {}
+
+ Slice(const nsFrameList& aList, nsIFrame* aStart, nsIFrame* aEnd) :
+#ifdef DEBUG
+ mList(aList),
+#endif
+ mStart(aStart),
+ mEnd(aEnd)
+ {}
+
+ Slice(const Slice& aOther) :
+#ifdef DEBUG
+ mList(aOther.mList),
+#endif
+ mStart(aOther.mStart),
+ mEnd(aOther.mEnd)
+ {}
+
+ private:
+#ifdef DEBUG
+ const nsFrameList& mList;
+#endif
+ nsIFrame* const mStart; // our starting frame
+ const nsIFrame* const mEnd; // The first frame that is NOT in the slice.
+ // May be null.
+ };
+
+ class Enumerator {
+ public:
+ explicit Enumerator(const Slice& aSlice) :
+#ifdef DEBUG
+ mSlice(aSlice),
+#endif
+ mFrame(aSlice.mStart),
+ mEnd(aSlice.mEnd)
+ {}
+
+ Enumerator(const Enumerator& aOther) :
+#ifdef DEBUG
+ mSlice(aOther.mSlice),
+#endif
+ mFrame(aOther.mFrame),
+ mEnd(aOther.mEnd)
+ {}
+
+ bool AtEnd() const {
+ // Can't just check mEnd, because some table code goes and destroys the
+ // tail of the frame list (including mEnd!) while iterating over the
+ // frame list.
+ return !mFrame || mFrame == mEnd;
+ }
+
+ /* Next() needs to know about nsIFrame, and nsIFrame will need to
+ know about nsFrameList methods, so in order to inline this put
+ the implementation in nsIFrame.h */
+ inline void Next();
+
+ /**
+ * Get the current frame we're pointing to. Do not call this on an
+ * iterator that is at end!
+ */
+ nsIFrame* get() const {
+ NS_PRECONDITION(!AtEnd(), "Enumerator is at end");
+ return mFrame;
+ }
+
+ /**
+ * Get an enumerator that is just like this one, but not limited in terms of
+ * the part of the list it will traverse.
+ */
+ Enumerator GetUnlimitedEnumerator() const {
+ return Enumerator(*this, nullptr);
+ }
+
+#ifdef DEBUG
+ const nsFrameList& List() const { return mSlice.mList; }
+#endif
+
+ protected:
+ Enumerator(const Enumerator& aOther, const nsIFrame* const aNewEnd):
+#ifdef DEBUG
+ mSlice(aOther.mSlice),
+#endif
+ mFrame(aOther.mFrame),
+ mEnd(aNewEnd)
+ {}
+
+#ifdef DEBUG
+ /* Has to be an object, not a reference, since the slice could
+ well be a temporary constructed from an nsFrameList */
+ const Slice mSlice;
+#endif
+ nsIFrame* mFrame; // our current frame.
+ const nsIFrame* const mEnd; // The first frame we should NOT enumerate.
+ // May be null.
+ };
+
+ /**
+ * A class that can be used to enumerate links between frames. When created
+ * from an nsFrameList, it points to the "link" immediately before the first
+ * frame. It can then be advanced until it points to the "link" immediately
+ * after the last frame. At any position, PrevFrame() and NextFrame() are
+ * the frames before and after the given link. This means PrevFrame() is
+ * null when the enumerator is at the beginning of the list and NextFrame()
+ * is null when it's AtEnd().
+ */
+ class FrameLinkEnumerator : private Enumerator {
+ public:
+ friend class nsFrameList;
+
+ explicit FrameLinkEnumerator(const nsFrameList& aList) :
+ Enumerator(aList),
+ mPrev(nullptr)
+ {}
+
+ FrameLinkEnumerator(const FrameLinkEnumerator& aOther) :
+ Enumerator(aOther),
+ mPrev(aOther.mPrev)
+ {}
+
+ /* This constructor needs to know about nsIFrame, and nsIFrame will need to
+ know about nsFrameList methods, so in order to inline this put
+ the implementation in nsIFrame.h */
+ inline FrameLinkEnumerator(const nsFrameList& aList, nsIFrame* aPrevFrame);
+
+ void operator=(const FrameLinkEnumerator& aOther) {
+ NS_PRECONDITION(&List() == &aOther.List(), "Different lists?");
+ mFrame = aOther.mFrame;
+ mPrev = aOther.mPrev;
+ }
+
+ inline void Next();
+
+ bool AtEnd() const { return Enumerator::AtEnd(); }
+
+ nsIFrame* PrevFrame() const { return mPrev; }
+ nsIFrame* NextFrame() const { return mFrame; }
+
+ protected:
+ nsIFrame* mPrev;
+ };
+
+ class Iterator
+ {
+ public:
+ Iterator(const nsFrameList& aList, nsIFrame* aCurrent)
+ : mList(aList)
+ , mCurrent(aCurrent)
+ {}
+
+ Iterator(const Iterator& aOther)
+ : mList(aOther.mList)
+ , mCurrent(aOther.mCurrent)
+ {}
+
+ nsIFrame* operator*() const { return mCurrent; }
+
+ // The operators need to know about nsIFrame, hence the
+ // implementations are in nsIFrame.h
+ Iterator& operator++();
+ Iterator& operator--();
+
+ Iterator operator++(int) { auto ret = *this; ++*this; return ret; }
+ Iterator operator--(int) { auto ret = *this; --*this; return ret; }
+
+ friend bool operator==(const Iterator& aIter1, const Iterator& aIter2);
+ friend bool operator!=(const Iterator& aIter1, const Iterator& aIter2);
+
+ private:
+ const nsFrameList& mList;
+ nsIFrame* mCurrent;
+ };
+
+ typedef Iterator iterator;
+ typedef Iterator const_iterator;
+ typedef mozilla::ReverseIterator<Iterator> reverse_iterator;
+ typedef mozilla::ReverseIterator<Iterator> const_reverse_iterator;
+
+ iterator begin() const { return iterator(*this, mFirstChild); }
+ const_iterator cbegin() const { return begin(); }
+ iterator end() const { return iterator(*this, nullptr); }
+ const_iterator cend() const { return end(); }
+ reverse_iterator rbegin() const { return reverse_iterator(end()); }
+ const_reverse_iterator crbegin() const { return rbegin(); }
+ reverse_iterator rend() const { return reverse_iterator(begin()); }
+ const_reverse_iterator crend() const { return rend(); }
+
+private:
+ void operator delete(void*) = delete;
+
+#ifdef DEBUG_FRAME_LIST
+ void VerifyList() const;
+#else
+ void VerifyList() const {}
+#endif
+
+protected:
+ /**
+ * Disconnect aFrame from its siblings. This must only be called if aFrame
+ * is NOT the first or last sibling, because otherwise its nsFrameList will
+ * have a stale mFirst/LastChild pointer. This precondition is asserted.
+ * This function is O(1).
+ */
+ static void UnhookFrameFromSiblings(nsIFrame* aFrame);
+
+ nsIFrame* mFirstChild;
+ nsIFrame* mLastChild;
+};
+
+inline bool
+operator==(const nsFrameList::Iterator& aIter1,
+ const nsFrameList::Iterator& aIter2)
+{
+ MOZ_ASSERT(&aIter1.mList == &aIter2.mList,
+ "must not compare iterator from different list");
+ return aIter1.mCurrent == aIter2.mCurrent;
+}
+
+inline bool
+operator!=(const nsFrameList::Iterator& aIter1,
+ const nsFrameList::Iterator& aIter2)
+{
+ MOZ_ASSERT(&aIter1.mList == &aIter2.mList,
+ "Must not compare iterator from different list");
+ return aIter1.mCurrent != aIter2.mCurrent;
+}
+
+namespace mozilla {
+namespace layout {
+
+/**
+ * Simple "auto_ptr" for nsFrameLists allocated from the shell arena.
+ * The frame list given to the constructor will be deallocated (if non-null)
+ * in the destructor. The frame list must then be empty.
+ */
+class AutoFrameListPtr {
+public:
+ AutoFrameListPtr(nsPresContext* aPresContext, nsFrameList* aFrameList)
+ : mPresContext(aPresContext), mFrameList(aFrameList) {}
+ ~AutoFrameListPtr();
+ operator nsFrameList*() const { return mFrameList; }
+ nsFrameList* operator->() const { return mFrameList; }
+private:
+ nsPresContext* mPresContext;
+ nsFrameList* mFrameList;
+};
+
+namespace detail {
+union AlignedFrameListBytes {
+ void* ptr;
+ char bytes[sizeof(nsFrameList)];
+};
+extern const AlignedFrameListBytes gEmptyFrameListBytes;
+} // namespace detail
+
+} // namespace layout
+} // namespace mozilla
+
+/* static */ inline const nsFrameList&
+nsFrameList::EmptyList()
+{
+ return *reinterpret_cast<const nsFrameList*>(&mozilla::layout::detail::gEmptyFrameListBytes);
+}
+
+#endif /* nsFrameList_h___ */