1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
|
/* -*- 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/. */
/*
* 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 {
ConstrainHeight = 0x1,
CBWidthChanged = 0x2,
CBHeightChanged = 0x4,
CBWidthAndHeightChanged = CBWidthChanged | CBHeightChanged,
IsGridContainerCB = 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,
mozilla::OverflowAreas* aOverflowAreas);
using PostDestroyData = nsIFrame::PostDestroyData;
void DestroyFrames(nsIFrame* aDelegatingFrame, nsIFrame* aDestructRoot,
PostDestroyData& aPostDestroyData);
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 input. (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,
mozilla::OverflowAreas* 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___ */
|
