/* -*- 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/. */ /* * code for managing absolutely positioned children of a rendering * object that is a containing block for them */ #ifndef nsAbsoluteContainingBlock_h___ #define nsAbsoluteContainingBlock_h___ #include "nsFrameList.h" #include "nsIFrame.h" #include "mozilla/TypedEnumBits.h" class nsContainerFrame; class nsPresContext; /** * This class contains the logic for being an absolute containing block. This * class is used within viewport frames (for frames representing content with * fixed position) and blocks (for frames representing absolutely positioned * content), since each set of frames is absolutely positioned with respect to * its parent. * * There is no principal child list, just a named child list which contains * the absolutely positioned frames (kAbsoluteList or kFixedList). * * All functions include as the first argument the frame that is delegating * the request. */ class nsAbsoluteContainingBlock { using ReflowInput = mozilla::ReflowInput; public: typedef nsIFrame::ChildListID ChildListID; explicit nsAbsoluteContainingBlock(ChildListID aChildListID) #ifdef DEBUG : mChildListID(aChildListID) #endif { MOZ_ASSERT(mChildListID == nsIFrame::kAbsoluteList || mChildListID == nsIFrame::kFixedList, "should either represent position:fixed or absolute content"); } const nsFrameList& GetChildList() const { return mAbsoluteFrames; } void AppendChildList(nsTArray<nsIFrame::ChildList>* aLists, ChildListID aListID) const { NS_ASSERTION(aListID == mChildListID, "wrong list ID"); GetChildList().AppendIfNonempty(aLists, aListID); } void SetInitialChildList(nsIFrame* aDelegatingFrame, ChildListID aListID, nsFrameList& aChildList); void AppendFrames(nsIFrame* aDelegatingFrame, ChildListID aListID, nsFrameList& aFrameList); void InsertFrames(nsIFrame* aDelegatingFrame, ChildListID aListID, nsIFrame* aPrevFrame, nsFrameList& aFrameList); void RemoveFrame(nsIFrame* aDelegatingFrame, ChildListID aListID, nsIFrame* aOldFrame); enum class AbsPosReflowFlags { eConstrainHeight = 0x1, eCBWidthChanged = 0x2, eCBHeightChanged = 0x4, eCBWidthAndHeightChanged = eCBWidthChanged | eCBHeightChanged, eIsGridContainerCB = 0x8, }; /** * Called by the delegating frame after it has done its reflow first. This * function will reflow any absolutely positioned child frames that need to * be reflowed, e.g., because the absolutely positioned child frame has * 'auto' for an offset, or a percentage based width or height. * * @param aOverflowAreas, if non-null, is unioned with (in the local * coordinate space) the overflow areas of the absolutely positioned * children. * * @param aReflowStatus is assumed to be already-initialized, e.g. with the * status of the delegating frame's main reflow. This function merges in the * statuses of the absolutely positioned children's reflows. * * @param aFlags zero or more AbsPosReflowFlags */ void Reflow(nsContainerFrame* aDelegatingFrame, nsPresContext* aPresContext, const ReflowInput& aReflowInput, nsReflowStatus& aReflowStatus, const nsRect& aContainingBlock, AbsPosReflowFlags aFlags, nsOverflowAreas* aOverflowAreas); void DestroyFrames(nsIFrame* aDelegatingFrame, nsIFrame* aDestructRoot); bool HasAbsoluteFrames() const { return mAbsoluteFrames.NotEmpty(); } /** * Mark our size-dependent absolute frames with NS_FRAME_HAS_DIRTY_CHILDREN * so that we'll make sure to reflow them. */ void MarkSizeDependentFramesDirty(); /** * Mark all our absolute frames with NS_FRAME_IS_DIRTY. */ void MarkAllFramesDirty(); protected: /** * Returns true if the position of aFrame depends on the position of * its placeholder or if the position or size of aFrame depends on a * containing block dimension that changed. */ bool FrameDependsOnContainer(nsIFrame* aFrame, bool aCBWidthChanged, bool aCBHeightChanged); /** * After an abspos child's size is known, this method can be used to * resolve size-dependent values in the ComputedLogicalOffsets on its * reflow state. (This may involve resolving the inline dimension of * aLogicalCBSize, too; hence, that variable is an in/outparam.) * * aKidSize, aMargin, aOffsets, and aLogicalCBSize are all expected to be * represented in terms of the absolute containing block's writing-mode. */ void ResolveSizeDependentOffsets(nsPresContext* aPresContext, ReflowInput& aKidReflowInput, const mozilla::LogicalSize& aKidSize, const mozilla::LogicalMargin& aMargin, mozilla::LogicalMargin* aOffsets, mozilla::LogicalSize* aLogicalCBSize); void ReflowAbsoluteFrame(nsIFrame* aDelegatingFrame, nsPresContext* aPresContext, const ReflowInput& aReflowInput, const nsRect& aContainingBlockRect, AbsPosReflowFlags aFlags, nsIFrame* aKidFrame, nsReflowStatus& aStatus, nsOverflowAreas* aOverflowAreas); /** * Mark our absolute frames dirty. * @param aMarkAllDirty if true, all will be marked with NS_FRAME_IS_DIRTY. * Otherwise, the size-dependant ones will be marked with * NS_FRAME_HAS_DIRTY_CHILDREN. */ void DoMarkFramesDirty(bool aMarkAllDirty); protected: nsFrameList mAbsoluteFrames; // additional named child list #ifdef DEBUG ChildListID const mChildListID; // kFixedList or kAbsoluteList #endif }; namespace mozilla { MOZ_MAKE_ENUM_CLASS_BITWISE_OPERATORS(nsAbsoluteContainingBlock::AbsPosReflowFlags) } #endif /* nsnsAbsoluteContainingBlock_h___ */