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
|
/*
* Copyright (C) 1999 Lars Knoll (knoll@kde.org)
* (C) 1999 Antti Koivisto (koivisto@kde.org)
* Copyright (C) 2003, 2006, 2007 Apple Inc. All rights reserved.
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Library General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Library General Public License for more details.
*
* You should have received a copy of the GNU Library General Public License
* along with this library; see the file COPYING.LIB. If not, write to
* the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*
*/
#ifndef RenderBox_h
#define RenderBox_h
#include "RenderObject.h"
namespace WebCore {
enum WidthType { Width, MinWidth, MaxWidth };
class RenderBox : public RenderObject {
public:
RenderBox(Node*);
virtual ~RenderBox();
virtual const char* renderName() const { return "RenderBox"; }
virtual void paint(PaintInfo&, int tx, int ty);
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
virtual void destroy();
virtual int minPrefWidth() const;
virtual int maxPrefWidth() const;
virtual int overrideSize() const;
virtual int overrideWidth() const;
virtual int overrideHeight() const;
virtual void setOverrideSize(int);
virtual FloatPoint localToAbsolute(FloatPoint localPoint = FloatPoint(), bool fixed = false, bool useTransforms = false) const;
virtual FloatPoint absoluteToLocal(FloatPoint containerPoint, bool fixed = false, bool useTransforms = false) const;
virtual FloatQuad localToAbsoluteQuad(const FloatQuad&, bool fixed = false) const;
virtual IntSize offsetFromContainer(RenderObject*) const;
virtual int xPos() const { return m_x; }
virtual int yPos() const { return m_y; }
virtual void setPos(int x, int y);
virtual int width() const { return m_width; }
virtual int height() const { return m_height; }
virtual void setWidth(int width) { m_width = width; }
virtual void setHeight(int height) { m_height = height; }
virtual int marginTop() const { return m_marginTop; }
virtual int marginBottom() const { return m_marginBottom; }
virtual int marginLeft() const { return m_marginLeft; }
virtual int marginRight() const { return m_marginRight; }
virtual IntRect borderBox() const { return IntRect(0, -borderTopExtra(), width(), height() + borderTopExtra() + borderBottomExtra()); }
int calcBorderBoxWidth(int width) const;
int calcBorderBoxHeight(int height) const;
int calcContentBoxWidth(int width) const;
int calcContentBoxHeight(int height) const;
virtual void borderFitAdjust(int& /*x*/, int& /*w*/) const { } // Shrink the box in which the border paints if border-fit is set.
// This method is now public so that centered objects like tables that are
// shifted right by left-aligned floats can recompute their left and
// right margins (so that they can remain centered after being
// shifted. -dwh
void calcHorizontalMargins(const Length& marginLeft, const Length& marginRight, int containerWidth);
virtual void position(InlineBox*);
virtual void dirtyLineBoxes(bool fullLayout, bool isRootLineBox = false);
// For inline replaced elements, this function returns the inline box that owns us. Enables
// the replaced RenderObject to quickly determine what line it is contained on and to easily
// iterate over structures on the line.
virtual InlineBox* inlineBoxWrapper() const { return m_inlineBoxWrapper; }
virtual void setInlineBoxWrapper(InlineBox* boxWrapper) { m_inlineBoxWrapper = boxWrapper; }
virtual void deleteLineBoxWrapper();
virtual int lowestPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
virtual int rightmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
virtual int leftmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;
virtual IntRect absoluteClippedOverflowRect();
virtual void computeAbsoluteRepaintRect(IntRect&, bool fixed = false);
IntSize offsetForPositionedInContainer(RenderObject*) const;
virtual void repaintDuringLayoutIfMoved(const IntRect&);
virtual int containingBlockWidth() const;
virtual void calcWidth();
virtual void calcHeight();
bool stretchesToViewHeight() const
{
return style()->htmlHacks() && style()->height().isAuto() && !isFloatingOrPositioned() && (isRoot() || isBody());
}
virtual IntSize intrinsicSize() const { return IntSize(); }
// Whether or not the element shrinks to its intrinsic width (rather than filling the width
// of a containing block). HTML4 buttons, <select>s, <input>s, legends, and floating/compact elements do this.
bool sizesToIntrinsicWidth(WidthType) const;
virtual bool stretchesToMinIntrinsicWidth() const { return false; }
int calcWidthUsing(WidthType, int containerWidth);
int calcHeightUsing(const Length& height);
int calcReplacedWidthUsing(Length width) const;
int calcReplacedHeightUsing(Length height) const;
virtual int calcReplacedWidth(bool includeMaxWidth = true) const;
virtual int calcReplacedHeight() const;
int calcPercentageHeight(const Length& height);
virtual int availableHeight() const;
int availableHeightUsing(const Length&) const;
void calcVerticalMargins();
int relativePositionOffsetX() const;
int relativePositionOffsetY() const;
IntSize relativePositionOffset() const { return IntSize(relativePositionOffsetX(), relativePositionOffsetY()); }
virtual RenderLayer* layer() const { return m_layer; }
virtual IntRect localCaretRect(InlineBox*, int caretOffset, int* extraWidthToEndOfLine = 0);
virtual void paintFillLayerExtended(const PaintInfo&, const Color&, const FillLayer*, int clipY, int clipHeight,
int tx, int ty, int width, int height, InlineFlowBox* = 0, CompositeOperator = CompositeSourceOver);
IntSize calculateBackgroundSize(const FillLayer*, int scaledWidth, int scaledHeight) const;
virtual int staticX() const;
virtual int staticY() const;
virtual void setStaticX(int staticX);
virtual void setStaticY(int staticY);
virtual IntRect getOverflowClipRect(int tx, int ty);
virtual IntRect getClipRect(int tx, int ty);
virtual void paintBoxDecorations(PaintInfo&, int tx, int ty);
virtual void paintMask(PaintInfo& paintInfo, int tx, int ty);
virtual void imageChanged(WrappedImagePtr, const IntRect* = 0);
// Called when a positioned object moves but doesn't change size. A simplified layout is done
// that just updates the object's position.
virtual void tryLayoutDoingPositionedMovementOnly()
{
int oldWidth = m_width;
calcWidth();
// If we shrink to fit our width may have changed, so we still need full layout.
if (oldWidth != m_width)
return;
calcHeight();
setNeedsLayout(false);
}
virtual IntRect maskClipRect();
protected:
virtual void styleWillChange(RenderStyle::Diff, const RenderStyle* newStyle);
virtual void styleDidChange(RenderStyle::Diff, const RenderStyle* oldStyle);
void paintFillLayer(const PaintInfo&, const Color&, const FillLayer*, int clipY, int clipHeight, int tx, int ty, int width, int height, CompositeOperator = CompositeSourceOver);
void paintFillLayers(const PaintInfo&, const Color&, const FillLayer*, int clipY, int clipHeight, int tx, int ty, int width, int height, CompositeOperator = CompositeSourceOver);
void paintMaskImages(const PaintInfo&, int clipY, int clipHeight, int tx, int ty, int width, int height);
#if PLATFORM(MAC)
void paintCustomHighlight(int tx, int ty, const AtomicString& type, bool behindText);
#endif
void calcAbsoluteHorizontal();
virtual bool shouldCalculateSizeAsReplaced() const { return isReplaced() && !isInlineBlockOrInlineTable(); }
private:
void paintRootBoxDecorations(PaintInfo&, int tx, int ty);
// Returns true if we did a full repaint
bool repaintLayerRectsForImage(WrappedImagePtr image, const FillLayer* layers, bool drawingBackground);
void calculateBackgroundImageGeometry(const FillLayer*, int tx, int ty, int w, int h, IntRect& destRect, IntPoint& phase, IntSize& tileSize);
int containingBlockWidthForPositioned(const RenderObject* containingBlock) const;
int containingBlockHeightForPositioned(const RenderObject* containingBlock) const;
void calcAbsoluteVertical();
void calcAbsoluteHorizontalValues(Length width, const RenderObject* cb, TextDirection containerDirection,
int containerWidth, int bordersPlusPadding,
Length left, Length right, Length marginLeft, Length marginRight,
int& widthValue, int& marginLeftValue, int& marginRightValue, int& xPos);
void calcAbsoluteVerticalValues(Length height, const RenderObject* cb,
int containerHeight, int bordersPlusPadding,
Length top, Length bottom, Length marginTop, Length marginBottom,
int& heightValue, int& marginTopValue, int& marginBottomValue, int& yPos);
void calcAbsoluteVerticalReplaced();
void calcAbsoluteHorizontalReplaced();
// This function calculates the minimum and maximum preferred widths for an object.
// These values are used in shrink-to-fit layout systems.
// These include tables, positioned objects, floats and flexible boxes.
virtual void calcPrefWidths() = 0;
protected:
// The width/height of the contents + borders + padding.
int m_width;
int m_height;
int m_x;
int m_y;
int m_marginLeft;
int m_marginRight;
int m_marginTop;
int m_marginBottom;
// The preferred width of the element if it were to break its lines at every possible opportunity.
int m_minPrefWidth;
// The preferred width of the element if it never breaks any lines at all.
int m_maxPrefWidth;
// A pointer to our layer if we have one.
RenderLayer* m_layer;
// For inline replaced elements, the inline box that owns us.
InlineBox* m_inlineBoxWrapper;
private:
// Used to store state between styleWillChange and styleDidChange
static bool s_wasFloating;
static bool s_hadOverflowClip;
};
} // namespace WebCore
#endif // RenderBox_h
|
