From 36d22d82aa202bb199967e9512281e9a53db42c9 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Sun, 7 Apr 2024 21:33:14 +0200 Subject: Adding upstream version 115.7.0esr. Signed-off-by: Daniel Baumann --- layout/base/nsFrameTraversal.cpp | 446 +++++++++++++++++++++++++++++++++++++++ 1 file changed, 446 insertions(+) create mode 100644 layout/base/nsFrameTraversal.cpp (limited to 'layout/base/nsFrameTraversal.cpp') diff --git a/layout/base/nsFrameTraversal.cpp b/layout/base/nsFrameTraversal.cpp new file mode 100644 index 0000000000..68b8c42c3e --- /dev/null +++ b/layout/base/nsFrameTraversal.cpp @@ -0,0 +1,446 @@ +/* -*- 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/. */ + +#include "nsFrameTraversal.h" + +#include "nsCOMPtr.h" +#include "nsGkAtoms.h" + +#include "nsFrameList.h" +#include "nsPlaceholderFrame.h" +#include "nsPresContext.h" +#include "nsContainerFrame.h" + +using namespace mozilla; + +class nsFrameIterator : public nsIFrameEnumerator { + public: + NS_DECL_ISUPPORTS + + virtual void First() override; + virtual void Next() override; + virtual nsIFrame* CurrentItem() override; + virtual bool IsDone() override; + + virtual void Last() override; + virtual void Prev() override; + + nsFrameIterator(nsPresContext* aPresContext, nsIFrame* aStart, + nsIteratorType aType, bool aLockScroll, bool aFollowOOFs, + bool aSkipPopupChecks); + + protected: + virtual ~nsFrameIterator() = default; + + void setCurrent(nsIFrame* aFrame) { mCurrent = aFrame; } + nsIFrame* getCurrent() { return mCurrent; } + nsIFrame* getStart() { return mStart; } + nsIFrame* getLast() { return mLast; } + void setLast(nsIFrame* aFrame) { mLast = aFrame; } + int8_t getOffEdge() { return mOffEdge; } + void setOffEdge(int8_t aOffEdge) { mOffEdge = aOffEdge; } + + /* + Our own versions of the standard frame tree navigation + methods, which, if the iterator is following out-of-flows, + apply the following rules for placeholder frames: + + - If a frame HAS a placeholder frame, getting its parent + gets the placeholder's parent. + + - If a frame's first child or next/prev sibling IS a + placeholder frame, then we instead return the real frame. + + - If a frame HAS a placeholder frame, getting its next/prev + sibling gets the placeholder frame's next/prev sibling. + + These are all applied recursively to support multiple levels of + placeholders. + */ + + nsIFrame* GetParentFrame(nsIFrame* aFrame); + // like GetParentFrame but returns null once a popup frame is reached + nsIFrame* GetParentFrameNotPopup(nsIFrame* aFrame); + + nsIFrame* GetFirstChild(nsIFrame* aFrame); + nsIFrame* GetLastChild(nsIFrame* aFrame); + + nsIFrame* GetNextSibling(nsIFrame* aFrame); + nsIFrame* GetPrevSibling(nsIFrame* aFrame); + + /* + These methods are overridden by the bidi visual iterator to have the + semantics of "get first child in visual order", "get last child in visual + order", "get next sibling in visual order" and "get previous sibling in + visual order". + */ + + virtual nsIFrame* GetFirstChildInner(nsIFrame* aFrame); + virtual nsIFrame* GetLastChildInner(nsIFrame* aFrame); + + virtual nsIFrame* GetNextSiblingInner(nsIFrame* aFrame); + virtual nsIFrame* GetPrevSiblingInner(nsIFrame* aFrame); + + /** + * Return the placeholder frame for aFrame if it has one, otherwise return + * aFrame itself. + */ + nsIFrame* GetPlaceholderFrame(nsIFrame* aFrame); + bool IsPopupFrame(nsIFrame* aFrame); + + nsPresContext* const mPresContext; + const bool mLockScroll; + const bool mFollowOOFs; + const bool mSkipPopupChecks; + const nsIteratorType mType; + + private: + nsIFrame* const mStart; + nsIFrame* mCurrent; + nsIFrame* mLast; // the last one that was in current; + int8_t mOffEdge; // 0= no -1 to far prev, 1 to far next; +}; + +// Bidi visual iterator +class nsVisualIterator : public nsFrameIterator { + public: + nsVisualIterator(nsPresContext* aPresContext, nsIFrame* aStart, + nsIteratorType aType, bool aLockScroll, bool aFollowOOFs, + bool aSkipPopupChecks) + : nsFrameIterator(aPresContext, aStart, aType, aLockScroll, aFollowOOFs, + aSkipPopupChecks) {} + + protected: + nsIFrame* GetFirstChildInner(nsIFrame* aFrame) override; + nsIFrame* GetLastChildInner(nsIFrame* aFrame) override; + + nsIFrame* GetNextSiblingInner(nsIFrame* aFrame) override; + nsIFrame* GetPrevSiblingInner(nsIFrame* aFrame) override; +}; + +/************IMPLEMENTATIONS**************/ + +nsresult NS_CreateFrameTraversal(nsIFrameTraversal** aResult) { + NS_ENSURE_ARG_POINTER(aResult); + + nsCOMPtr t = new nsFrameTraversal(); + t.forget(aResult); + + return NS_OK; +} + +nsresult NS_NewFrameTraversal(nsIFrameEnumerator** aEnumerator, + nsPresContext* aPresContext, nsIFrame* aStart, + nsIteratorType aType, bool aVisual, + bool aLockInScrollView, bool aFollowOOFs, + bool aSkipPopupChecks) { + if (!aEnumerator || !aStart) return NS_ERROR_NULL_POINTER; + + if (aFollowOOFs) { + aStart = nsPlaceholderFrame::GetRealFrameFor(aStart); + } + + nsCOMPtr trav; + if (aVisual) { + trav = new nsVisualIterator(aPresContext, aStart, aType, aLockInScrollView, + aFollowOOFs, aSkipPopupChecks); + } else { + trav = new nsFrameIterator(aPresContext, aStart, aType, aLockInScrollView, + aFollowOOFs, aSkipPopupChecks); + } + trav.forget(aEnumerator); + return NS_OK; +} + +nsFrameTraversal::nsFrameTraversal() = default; + +nsFrameTraversal::~nsFrameTraversal() = default; + +NS_IMPL_ISUPPORTS(nsFrameTraversal, nsIFrameTraversal) + +NS_IMETHODIMP +nsFrameTraversal::NewFrameTraversal(nsIFrameEnumerator** aEnumerator, + nsPresContext* aPresContext, + nsIFrame* aStart, int32_t aType, + bool aVisual, bool aLockInScrollView, + bool aFollowOOFs, bool aSkipPopupChecks) { + return NS_NewFrameTraversal(aEnumerator, aPresContext, aStart, + static_cast(aType), aVisual, + aLockInScrollView, aFollowOOFs, aSkipPopupChecks); +} + +// nsFrameIterator implementation + +NS_IMPL_ISUPPORTS(nsFrameIterator, nsIFrameEnumerator) + +nsFrameIterator::nsFrameIterator(nsPresContext* aPresContext, nsIFrame* aStart, + nsIteratorType aType, bool aLockInScrollView, + bool aFollowOOFs, bool aSkipPopupChecks) + : mPresContext(aPresContext), + mLockScroll(aLockInScrollView), + mFollowOOFs(aFollowOOFs), + mSkipPopupChecks(aSkipPopupChecks), + mType(aType), + mStart(aStart), + mCurrent(aStart), + mLast(aStart), + mOffEdge(0) { + MOZ_ASSERT(!aFollowOOFs || !aStart->IsPlaceholderFrame(), + "Caller should have resolved placeholder frame"); +} + +nsIFrame* nsFrameIterator::CurrentItem() { + if (mOffEdge) return nullptr; + + return mCurrent; +} + +bool nsFrameIterator::IsDone() { return mOffEdge != 0; } + +void nsFrameIterator::First() { mCurrent = mStart; } + +static bool IsRootFrame(nsIFrame* aFrame) { return aFrame->IsCanvasFrame(); } + +void nsFrameIterator::Last() { + nsIFrame* result; + nsIFrame* parent = getCurrent(); + // If the current frame is a popup, don't move farther up the tree. + // Otherwise, get the nearest root frame or popup. + if (mSkipPopupChecks || !parent->IsMenuPopupFrame()) { + while (!IsRootFrame(parent) && (result = GetParentFrameNotPopup(parent))) + parent = result; + } + + while ((result = GetLastChild(parent))) { + parent = result; + } + + setCurrent(parent); + if (!parent) setOffEdge(1); +} + +void nsFrameIterator::Next() { + // recursive-oid method to get next frame + nsIFrame* result = nullptr; + nsIFrame* parent = getCurrent(); + if (!parent) parent = getLast(); + + if (mType == eLeaf) { + // Drill down to first leaf + while ((result = GetFirstChild(parent))) { + parent = result; + } + } else if (mType == ePreOrder) { + result = GetFirstChild(parent); + if (result) parent = result; + } + + if (parent != getCurrent()) { + result = parent; + } else { + while (parent) { + result = GetNextSibling(parent); + if (result) { + if (mType != ePreOrder) { + parent = result; + while ((result = GetFirstChild(parent))) { + parent = result; + } + result = parent; + } + break; + } + result = GetParentFrameNotPopup(parent); + if (!result || IsRootFrame(result) || + (mLockScroll && result->IsScrollFrame())) { + result = nullptr; + break; + } + if (mType == ePostOrder) { + break; + } + parent = result; + } + } + + setCurrent(result); + if (!result) { + setOffEdge(1); + setLast(parent); + } +} + +void nsFrameIterator::Prev() { + // recursive-oid method to get prev frame + nsIFrame* result = nullptr; + nsIFrame* parent = getCurrent(); + if (!parent) parent = getLast(); + + if (mType == eLeaf) { + // Drill down to last leaf + while ((result = GetLastChild(parent))) { + parent = result; + } + } else if (mType == ePostOrder) { + result = GetLastChild(parent); + if (result) parent = result; + } + + if (parent != getCurrent()) { + result = parent; + } else { + while (parent) { + result = GetPrevSibling(parent); + if (result) { + if (mType != ePostOrder) { + parent = result; + while ((result = GetLastChild(parent))) { + parent = result; + } + result = parent; + } + break; + } + result = GetParentFrameNotPopup(parent); + if (!result || IsRootFrame(result) || + (mLockScroll && result->IsScrollFrame())) { + result = nullptr; + break; + } + if (mType == ePreOrder) { + break; + } + parent = result; + } + } + + setCurrent(result); + if (!result) { + setOffEdge(-1); + setLast(parent); + } +} + +nsIFrame* nsFrameIterator::GetParentFrame(nsIFrame* aFrame) { + if (mFollowOOFs) aFrame = GetPlaceholderFrame(aFrame); + if (aFrame) return aFrame->GetParent(); + + return nullptr; +} + +nsIFrame* nsFrameIterator::GetParentFrameNotPopup(nsIFrame* aFrame) { + if (mFollowOOFs) aFrame = GetPlaceholderFrame(aFrame); + if (aFrame) { + nsIFrame* parent = aFrame->GetParent(); + if (!IsPopupFrame(parent)) return parent; + } + + return nullptr; +} + +nsIFrame* nsFrameIterator::GetFirstChild(nsIFrame* aFrame) { + nsIFrame* result = GetFirstChildInner(aFrame); + if (mLockScroll && result && result->IsScrollFrame()) return nullptr; + if (result && mFollowOOFs) { + result = nsPlaceholderFrame::GetRealFrameFor(result); + + if (IsPopupFrame(result)) result = GetNextSibling(result); + } + return result; +} + +nsIFrame* nsFrameIterator::GetLastChild(nsIFrame* aFrame) { + nsIFrame* result = GetLastChildInner(aFrame); + if (mLockScroll && result && result->IsScrollFrame()) return nullptr; + if (result && mFollowOOFs) { + result = nsPlaceholderFrame::GetRealFrameFor(result); + + if (IsPopupFrame(result)) result = GetPrevSibling(result); + } + return result; +} + +nsIFrame* nsFrameIterator::GetNextSibling(nsIFrame* aFrame) { + nsIFrame* result = nullptr; + if (mFollowOOFs) aFrame = GetPlaceholderFrame(aFrame); + if (aFrame) { + result = GetNextSiblingInner(aFrame); + if (result && mFollowOOFs) + result = nsPlaceholderFrame::GetRealFrameFor(result); + } + + if (mFollowOOFs && IsPopupFrame(result)) result = GetNextSibling(result); + + return result; +} + +nsIFrame* nsFrameIterator::GetPrevSibling(nsIFrame* aFrame) { + nsIFrame* result = nullptr; + if (mFollowOOFs) aFrame = GetPlaceholderFrame(aFrame); + if (aFrame) { + result = GetPrevSiblingInner(aFrame); + if (result && mFollowOOFs) + result = nsPlaceholderFrame::GetRealFrameFor(result); + } + + if (mFollowOOFs && IsPopupFrame(result)) result = GetPrevSibling(result); + + return result; +} + +nsIFrame* nsFrameIterator::GetFirstChildInner(nsIFrame* aFrame) { + return aFrame->PrincipalChildList().FirstChild(); +} + +nsIFrame* nsFrameIterator::GetLastChildInner(nsIFrame* aFrame) { + return aFrame->PrincipalChildList().LastChild(); +} + +nsIFrame* nsFrameIterator::GetNextSiblingInner(nsIFrame* aFrame) { + return aFrame->GetNextSibling(); +} + +nsIFrame* nsFrameIterator::GetPrevSiblingInner(nsIFrame* aFrame) { + return aFrame->GetPrevSibling(); +} + +nsIFrame* nsFrameIterator::GetPlaceholderFrame(nsIFrame* aFrame) { + if (MOZ_LIKELY(!aFrame || !aFrame->HasAnyStateBits(NS_FRAME_OUT_OF_FLOW))) { + return aFrame; + } + nsIFrame* placeholder = aFrame->GetPlaceholderFrame(); + return placeholder ? placeholder : aFrame; +} + +bool nsFrameIterator::IsPopupFrame(nsIFrame* aFrame) { + // If skipping popup checks, pretend this isn't one. + if (mSkipPopupChecks) { + return false; + } + return aFrame && aFrame->IsMenuPopupFrame(); +} + +// nsVisualIterator implementation + +nsIFrame* nsVisualIterator::GetFirstChildInner(nsIFrame* aFrame) { + return aFrame->PrincipalChildList().GetNextVisualFor(nullptr); +} + +nsIFrame* nsVisualIterator::GetLastChildInner(nsIFrame* aFrame) { + return aFrame->PrincipalChildList().GetPrevVisualFor(nullptr); +} + +nsIFrame* nsVisualIterator::GetNextSiblingInner(nsIFrame* aFrame) { + nsIFrame* parent = GetParentFrame(aFrame); + if (!parent) return nullptr; + return parent->PrincipalChildList().GetNextVisualFor(aFrame); +} + +nsIFrame* nsVisualIterator::GetPrevSiblingInner(nsIFrame* aFrame) { + nsIFrame* parent = GetParentFrame(aFrame); + if (!parent) return nullptr; + return parent->PrincipalChildList().GetPrevVisualFor(aFrame); +} -- cgit v1.2.3