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
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
|
/* -*- 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 nsTableWrapperFrame_h__
#define nsTableWrapperFrame_h__
#include "mozilla/Attributes.h"
#include "mozilla/Maybe.h"
#include "nscore.h"
#include "nsContainerFrame.h"
#include "nsCellMap.h"
#include "nsTableFrame.h"
/**
* Primary frame for a table element,
* the nsTableWrapperFrame contains 0 or one caption frame, and a nsTableFrame
* pseudo-frame (referred to as the "inner frame').
*/
class nsTableWrapperFrame : public nsContainerFrame
{
public:
NS_DECL_QUERYFRAME
NS_DECL_FRAMEARENA_HELPERS
NS_DECL_QUERYFRAME_TARGET(nsTableWrapperFrame)
/** instantiate a new instance of nsTableRowFrame.
* @param aPresShell the pres shell for this frame
*
* @return the frame that was created
*/
friend nsTableWrapperFrame* NS_NewTableWrapperFrame(nsIPresShell* aPresShell,
nsStyleContext* aContext);
// nsIFrame overrides - see there for a description
virtual void DestroyFrom(nsIFrame* aDestructRoot) override;
virtual const nsFrameList& GetChildList(ChildListID aListID) const override;
virtual void GetChildLists(nsTArray<ChildList>* aLists) const override;
virtual void SetInitialChildList(ChildListID aListID,
nsFrameList& aChildList) override;
virtual void AppendFrames(ChildListID aListID,
nsFrameList& aFrameList) override;
virtual void InsertFrames(ChildListID aListID,
nsIFrame* aPrevFrame,
nsFrameList& aFrameList) override;
virtual void RemoveFrame(ChildListID aListID,
nsIFrame* aOldFrame) override;
virtual nsContainerFrame* GetContentInsertionFrame() override {
return PrincipalChildList().FirstChild()->GetContentInsertionFrame();
}
#ifdef ACCESSIBILITY
virtual mozilla::a11y::AccType AccessibleType() override;
#endif
virtual void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists) override;
void BuildDisplayListForInnerTable(nsDisplayListBuilder* aBuilder,
const nsRect& aDirtyRect,
const nsDisplayListSet& aLists);
virtual nscoord GetLogicalBaseline(mozilla::WritingMode aWritingMode) const override;
bool GetNaturalBaselineBOffset(mozilla::WritingMode aWM,
BaselineSharingGroup aBaselineGroup,
nscoord* aBaseline) const override
{
auto innerTable = InnerTableFrame();
nscoord offset;
if (innerTable->GetNaturalBaselineBOffset(aWM, aBaselineGroup, &offset)) {
auto bStart = innerTable->BStart(aWM, mRect.Size());
if (aBaselineGroup == BaselineSharingGroup::eFirst) {
*aBaseline = offset + bStart;
} else {
auto bEnd = bStart + innerTable->BSize(aWM);
*aBaseline = BSize(aWM) - (bEnd - offset);
}
return true;
}
return false;
}
virtual nscoord GetMinISize(nsRenderingContext *aRenderingContext) override;
virtual nscoord GetPrefISize(nsRenderingContext *aRenderingContext) override;
virtual mozilla::LogicalSize
ComputeAutoSize(nsRenderingContext* aRenderingContext,
mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorder,
const mozilla::LogicalSize& aPadding,
ComputeSizeFlags aFlags) override;
/** process a reflow command for the table.
* This involves reflowing the caption and the inner table.
* @see nsIFrame::Reflow */
virtual void Reflow(nsPresContext* aPresContext,
ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
/**
* Get the "type" of the frame
*
* @see nsGkAtoms::tableWrapperFrame
*/
virtual nsIAtom* GetType() const override;
#ifdef DEBUG_FRAME_DUMP
virtual nsresult GetFrameName(nsAString& aResult) const override;
#endif
virtual nsStyleContext* GetParentStyleContext(nsIFrame** aProviderFrame) const override;
/**
* Return the content for the cell at the given row and column.
*/
nsIContent* GetCellAt(uint32_t aRowIdx, uint32_t aColIdx) const;
/**
* Return the number of rows in the table.
*/
int32_t GetRowCount() const
{
return InnerTableFrame()->GetRowCount();
}
/**
* Return the number of columns in the table.
*/
int32_t GetColCount() const
{
return InnerTableFrame()->GetColCount();
}
/**
* Return the index of the cell at the given row and column.
*/
int32_t GetIndexByRowAndColumn(int32_t aRowIdx, int32_t aColIdx) const
{
nsTableCellMap* cellMap = InnerTableFrame()->GetCellMap();
if (!cellMap)
return -1;
return cellMap->GetIndexByRowAndColumn(aRowIdx, aColIdx);
}
/**
* Get the row and column indices for the cell at the given index.
*/
void GetRowAndColumnByIndex(int32_t aCellIdx, int32_t* aRowIdx,
int32_t* aColIdx) const
{
*aRowIdx = *aColIdx = 0;
nsTableCellMap* cellMap = InnerTableFrame()->GetCellMap();
if (cellMap) {
cellMap->GetRowAndColumnByIndex(aCellIdx, aRowIdx, aColIdx);
}
}
/**
* return the frame for the cell at the given row and column.
*/
nsTableCellFrame* GetCellFrameAt(uint32_t aRowIdx, uint32_t aColIdx) const
{
nsTableCellMap* map = InnerTableFrame()->GetCellMap();
if (!map) {
return nullptr;
}
return map->GetCellInfoAt(aRowIdx, aColIdx);
}
/**
* Return the col span of the cell at the given row and column indices.
*/
uint32_t GetEffectiveColSpanAt(uint32_t aRowIdx, uint32_t aColIdx) const
{
nsTableCellMap* map = InnerTableFrame()->GetCellMap();
return map->GetEffectiveColSpan(aRowIdx, aColIdx);
}
/**
* Return the effective row span of the cell at the given row and column.
*/
uint32_t GetEffectiveRowSpanAt(uint32_t aRowIdx, uint32_t aColIdx) const
{
nsTableCellMap* map = InnerTableFrame()->GetCellMap();
return map->GetEffectiveRowSpan(aRowIdx, aColIdx);
}
/**
* The CB size to use for the inner table frame if we're a grid item.
*/
NS_DECLARE_FRAME_PROPERTY_DELETABLE(GridItemCBSizeProperty, mozilla::LogicalSize);
protected:
explicit nsTableWrapperFrame(nsStyleContext* aContext);
virtual ~nsTableWrapperFrame();
void InitChildReflowInput(nsPresContext& aPresContext,
ReflowInput& aReflowInput);
// Get a NS_STYLE_CAPTION_SIDE_* value, or NO_SIDE if no caption is present.
// (Remember that caption-side values are interpreted logically, despite
// having "physical" names.)
uint8_t GetCaptionSide();
bool HasSideCaption() {
uint8_t captionSide = GetCaptionSide();
return captionSide == NS_STYLE_CAPTION_SIDE_LEFT ||
captionSide == NS_STYLE_CAPTION_SIDE_RIGHT;
}
uint8_t GetCaptionVerticalAlign();
void SetDesiredSize(uint8_t aCaptionSide,
const mozilla::LogicalSize& aInnerSize,
const mozilla::LogicalSize& aCaptionSize,
const mozilla::LogicalMargin& aInnerMargin,
const mozilla::LogicalMargin& aCaptionMargin,
nscoord& aISize,
nscoord& aBSize,
mozilla::WritingMode aWM);
nsresult GetCaptionOrigin(uint32_t aCaptionSide,
const mozilla::LogicalSize& aContainBlockSize,
const mozilla::LogicalSize& aInnerSize,
const mozilla::LogicalMargin& aInnerMargin,
const mozilla::LogicalSize& aCaptionSize,
mozilla::LogicalMargin& aCaptionMargin,
mozilla::LogicalPoint& aOrigin,
mozilla::WritingMode aWM);
nsresult GetInnerOrigin(uint32_t aCaptionSide,
const mozilla::LogicalSize& aContainBlockSize,
const mozilla::LogicalSize& aCaptionSize,
const mozilla::LogicalMargin& aCaptionMargin,
const mozilla::LogicalSize& aInnerSize,
mozilla::LogicalMargin& aInnerMargin,
mozilla::LogicalPoint& aOrigin,
mozilla::WritingMode aWM);
// reflow the child (caption or innertable frame)
void OuterBeginReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
const ReflowInput& aOuterRI,
mozilla::Maybe<ReflowInput>& aChildRI,
nscoord aAvailISize);
void OuterDoReflowChild(nsPresContext* aPresContext,
nsIFrame* aChildFrame,
const ReflowInput& aChildRI,
ReflowOutput& aMetrics,
nsReflowStatus& aStatus);
// Set the overflow areas in our reflow metrics
void UpdateOverflowAreas(ReflowOutput& aMet);
// Get the margin.
void GetChildMargin(nsPresContext* aPresContext,
const ReflowInput& aOuterRI,
nsIFrame* aChildFrame,
nscoord aAvailableWidth,
mozilla::LogicalMargin& aMargin);
virtual bool IsFrameOfType(uint32_t aFlags) const override
{
return nsContainerFrame::IsFrameOfType(aFlags &
(~eCanContainOverflowContainers));
}
nsTableFrame* InnerTableFrame() const
{
return static_cast<nsTableFrame*>(mFrames.FirstChild());
}
/**
* Helper for ComputeAutoSize.
* Compute the margin-box inline size of aChildFrame given the inputs.
* If aMarginResult is non-null, fill it with the part of the
* margin-isize that was contributed by the margin.
*/
nscoord ChildShrinkWrapISize(nsRenderingContext* aRenderingContext,
nsIFrame* aChildFrame,
mozilla::WritingMode aWM,
mozilla::LogicalSize aCBSize,
nscoord aAvailableISize,
nscoord* aMarginResult = nullptr) const;
private:
nsFrameList mCaptionFrames;
};
#endif
|
