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
|
/* -*- 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"
namespace mozilla {
class PresShell;
} // namespace mozilla
/**
* 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(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(
mozilla::PresShell* aPresShell, ComputedStyle* aStyle);
// nsIFrame overrides - see there for a description
void Destroy(DestroyContext&) override;
const nsFrameList& GetChildList(ChildListID aListID) const override;
void GetChildLists(nsTArray<ChildList>* aLists) const override;
void SetInitialChildList(ChildListID aListID,
nsFrameList&& aChildList) override;
void AppendFrames(ChildListID aListID, nsFrameList&& aFrameList) override;
void InsertFrames(ChildListID aListID, nsIFrame* aPrevFrame,
const nsLineList::iterator* aPrevFrameLine,
nsFrameList&& aFrameList) override;
void RemoveFrame(DestroyContext&, ChildListID, nsIFrame*) override;
nsContainerFrame* GetContentInsertionFrame() override {
return PrincipalChildList().FirstChild()->GetContentInsertionFrame();
}
#ifdef ACCESSIBILITY
mozilla::a11y::AccType AccessibleType() override;
#endif
void BuildDisplayList(nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists) override;
void BuildDisplayListForInnerTable(nsDisplayListBuilder* aBuilder,
const nsDisplayListSet& aLists);
nscoord SynthesizeFallbackBaseline(
mozilla::WritingMode aWM,
BaselineSharingGroup aBaselineGroup) const override;
Maybe<nscoord> GetNaturalBaselineBOffset(
mozilla::WritingMode aWM, BaselineSharingGroup aBaselineGroup,
BaselineExportContext aExportContext) const override;
nscoord GetMinISize(gfxContext* aRenderingContext) override;
nscoord GetPrefISize(gfxContext* aRenderingContext) override;
SizeComputationResult ComputeSize(
gfxContext* aRenderingContext, mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorderPadding,
const mozilla::StyleSizeOverrides& aSizeOverrides,
mozilla::ComputeSizeFlags aFlags) override;
mozilla::LogicalSize ComputeAutoSize(
gfxContext* aRenderingContext, mozilla::WritingMode aWM,
const mozilla::LogicalSize& aCBSize, nscoord aAvailableISize,
const mozilla::LogicalSize& aMargin,
const mozilla::LogicalSize& aBorderPadding,
const mozilla::StyleSizeOverrides& aSizeOverrides,
mozilla::ComputeSizeFlags aFlags) override;
/** process a reflow command for the table.
* This involves reflowing the caption and the inner table.
* @see nsIFrame::Reflow */
void Reflow(nsPresContext* aPresContext, ReflowOutput& aDesiredSize,
const ReflowInput& aReflowInput,
nsReflowStatus& aStatus) override;
#ifdef DEBUG_FRAME_DUMP
nsresult GetFrameName(nsAString& aResult) const override;
#endif
ComputedStyle* GetParentComputedStyle(
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);
}
protected:
explicit nsTableWrapperFrame(ComputedStyle* aStyle,
nsPresContext* aPresContext,
ClassID aID = kClassID);
virtual ~nsTableWrapperFrame();
using MaybeCaptionSide = Maybe<mozilla::StyleCaptionSide>;
// Get a StyleCaptionSide value, or Nothing if no caption is present.
//
// (Remember that caption-side values are interpreted logically, despite
// having "physical" names.)
MaybeCaptionSide GetCaptionSide() const;
mozilla::StyleVerticalAlignKeyword GetCaptionVerticalAlign() const;
nscoord ComputeFinalBSize(const MaybeCaptionSide&,
const mozilla::LogicalSize& aInnerSize,
const mozilla::LogicalSize& aCaptionSize,
const mozilla::LogicalMargin& aCaptionMargin,
const mozilla::WritingMode aWM) const;
nsresult GetCaptionOrigin(mozilla::StyleCaptionSide,
const mozilla::LogicalSize& aContainBlockSize,
const mozilla::LogicalSize& aInnerSize,
const mozilla::LogicalSize& aCaptionSize,
mozilla::LogicalMargin& aCaptionMargin,
mozilla::LogicalPoint& aOrigin,
mozilla::WritingMode aWM);
nsresult GetInnerOrigin(const MaybeCaptionSide&,
const mozilla::LogicalSize& aContainBlockSize,
const mozilla::LogicalSize& aCaptionSize,
const mozilla::LogicalMargin& aCaptionMargin,
const mozilla::LogicalSize& aInnerSize,
mozilla::LogicalPoint& aOrigin,
mozilla::WritingMode aWM);
// Create and init the child reflow input, using passed-in aChildRI, so that
// caller can use it after we return.
//
// @param aBSizeOccupiedByCaption the block size occupied by the caption
// within our content box.
void CreateReflowInputForInnerTable(
nsPresContext* aPresContext, nsTableFrame* aTableFrame,
const ReflowInput& aOuterRI, Maybe<ReflowInput>& aChildRI,
const nscoord aAvailISize, nscoord aBSizeOccupiedByCaption = 0) const;
void CreateReflowInputForCaption(nsPresContext* aPresContext,
nsIFrame* aCaptionFrame,
const ReflowInput& aOuterRI,
Maybe<ReflowInput>& aChildRI,
const nscoord aAvailISize) const;
// Reflow the child (caption or inner table frame).
void ReflowChild(nsPresContext* aPresContext, nsIFrame* aChildFrame,
const ReflowInput& aChildRI, ReflowOutput& aMetrics,
nsReflowStatus& aStatus);
// Set the overflow areas in our reflow metrics
void UpdateOverflowAreas(ReflowOutput& aMet);
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 the frame given the inputs.
*
* Note: CaptionShrinkWrapISize doesn't need StyleSizeOverrides parameter.
*/
mozilla::LogicalSize InnerTableShrinkWrapSize(
gfxContext* aRenderingContext, nsTableFrame* aTableFrame,
mozilla::WritingMode aWM, const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize,
const mozilla::StyleSizeOverrides& aSizeOverrides,
mozilla::ComputeSizeFlags aFlag) const;
mozilla::LogicalSize CaptionShrinkWrapSize(
gfxContext* aRenderingContext, nsIFrame* aCaptionFrame,
mozilla::WritingMode aWM, const mozilla::LogicalSize& aCBSize,
nscoord aAvailableISize, mozilla::ComputeSizeFlags aFlag) const;
/**
* Create a new StyleSize by reducing the size by aAmountToReduce.
*
* @param aStyleSize must be a Length.
*/
mozilla::StyleSize ReduceStyleSizeBy(const mozilla::StyleSize& aStyleSize,
const nscoord aAmountToReduce) const;
/**
* Compute StyleSizeOverrides for inner table frame given the overrides of the
* table wrapper frame.
*/
mozilla::StyleSizeOverrides ComputeSizeOverridesForInnerTable(
const nsTableFrame* aTableFrame,
const mozilla::StyleSizeOverrides& aWrapperSizeOverrides,
const mozilla::LogicalSize& aBorderPadding,
nscoord aBSizeOccupiedByCaption) const;
private:
nsFrameList mCaptionFrames;
};
#endif
|
