64f09fc295c5a17afabd12e19256183318ee02df
[WebKit-https.git] / WebCore / rendering / RenderObject.h
1 /*
2  * This file is part of the html renderer for KDE.
3  *
4  * Copyright (C) 2000 Lars Knoll (knoll@kde.org)
5  *           (C) 2000 Antti Koivisto (koivisto@kde.org)
6  *           (C) 2000 Dirk Mueller (mueller@kde.org)
7  *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)
8  * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.
9  *
10  * This library is free software; you can redistribute it and/or
11  * modify it under the terms of the GNU Library General Public
12  * License as published by the Free Software Foundation; either
13  * version 2 of the License, or (at your option) any later version.
14  *
15  * This library is distributed in the hope that it will be useful,
16  * but WITHOUT ANY WARRANTY; without even the implied warranty of
17  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
18  * Library General Public License for more details.
19  *
20  * You should have received a copy of the GNU Library General Public License
21  * along with this library; see the file COPYING.LIB.  If not, write to
22  * the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
23  * Boston, MA 02111-1307, USA.
24  *
25  */
26
27 #ifndef RenderObject_h
28 #define RenderObject_h
29
30 #include "CachedResourceClient.h"
31 #include "DeprecatedValueList.h"
32 #include "RenderStyle.h"
33 #include "ScrollBar.h"
34 #include "VisiblePosition.h"
35 #include <wtf/HashMap.h>
36
37 /*
38  *  The painting of a layer occurs in three distinct phases.  Each phase involves
39  *  a recursive descent into the layer's render objects. The first phase is the background phase.
40  *  The backgrounds and borders of all blocks are painted.  Inlines are not painted at all.
41  *  Floats must paint above block backgrounds but entirely below inline content that can overlap them.
42  *  In the foreground phase, all inlines are fully painted.  Inline replaced elements will get all
43  *  three phases invoked on them during this phase.
44  */
45
46 namespace WebCore {
47
48 class AffineTransform;
49 class CollapsedBorderValue;
50 class Color;
51 class CounterNode;
52 class Document;
53 class Element;
54 class Event;
55 class FloatRect;
56 class FrameView;
57 class HTMLAreaElement;
58 class InlineBox;
59 class InlineFlowBox;
60 class PlatformScrollbar;
61 class Position;
62 class RenderArena;
63 class RenderBlock;
64 class RenderFlow;
65 class RenderFrameSet;
66 class RenderLayer;
67 class RenderTable;
68 class RenderText;
69 class RenderView;
70 class String;
71 class TextStream;
72 class VisiblePosition;
73
74 enum PaintPhase {
75     PaintPhaseBlockBackground,
76     PaintPhaseChildBlockBackground,
77     PaintPhaseChildBlockBackgrounds,
78     PaintPhaseFloat,
79     PaintPhaseForeground,
80     PaintPhaseOutline,
81     PaintPhaseChildOutlines,
82     PaintPhaseSelfOutline,
83     PaintPhaseSelection,
84     PaintPhaseCollapsedTableBorders
85 };
86
87 enum PaintRestriction {
88     PaintRestrictionNone,
89     PaintRestrictionSelectionOnly,
90     PaintRestrictionSelectionOnlyWhiteText
91 };
92
93 enum HitTestFilter {
94     HitTestAll,
95     HitTestSelf,
96     HitTestDescendants
97 };
98
99 enum HitTestAction {
100     HitTestBlockBackground,
101     HitTestChildBlockBackground,
102     HitTestChildBlockBackgrounds,
103     HitTestFloat,
104     HitTestForeground
105 };
106
107 struct DashboardRegionValue
108 {
109     String label;
110     IntRect bounds;
111     IntRect clip;
112     int type;
113
114     bool operator==(const DashboardRegionValue& o) const
115     {
116         return type == o.type && bounds == o.bounds && label == o.label;
117     }
118 };
119
120 // FIXME: This should be a HashSequencedSet, but we don't have that data structure yet.
121 // This means the paint order of outlines will be wrong, although this is a minor issue.
122 typedef HashSet<RenderFlow*> RenderFlowSequencedSet;
123
124 /**
125  * Base Class for all rendering tree objects.
126  */
127 class RenderObject : public CachedResourceClient
128 {
129 public:
130     // Anonymous objects should pass the document as their node, and they will then automatically be
131     // marked as anonymous in the constructor.
132     RenderObject(Node* node);
133     virtual ~RenderObject();
134
135     RenderObject *parent() const { return m_parent; }
136     bool isDescendantOf(const RenderObject *obj) const;
137
138     RenderObject *previousSibling() const { return m_previous; }
139     RenderObject *nextSibling() const { return m_next; }
140
141     virtual RenderObject *firstChild() const { return 0; }
142     virtual RenderObject *lastChild() const { return 0; }
143
144     RenderObject* nextInPreOrder() const;
145     RenderObject* nextInPreOrderAfterChildren() const;
146     RenderObject* previousInPreOrder() const;
147     RenderObject* childAt(unsigned) const;
148
149     RenderObject *nextEditable() const; 
150     RenderObject *previousEditable() const; 
151
152     RenderObject *firstLeafChild() const;
153     RenderObject *lastLeafChild() const;
154     
155     virtual RenderLayer* layer() const { return 0; }
156     RenderLayer* enclosingLayer() const;
157     void addLayers(RenderLayer* parentLayer, RenderObject* newObject);
158     void removeLayers(RenderLayer* parentLayer);
159     void moveLayers(RenderLayer* oldParent, RenderLayer* newParent);
160     RenderLayer* findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint,
161                                bool checkParent=true);
162     virtual void positionChildLayers() { }
163     virtual bool requiresLayer();
164     
165     virtual IntRect getOverflowClipRect(int tx, int ty) { return IntRect(0,0,0,0); }
166     virtual IntRect getClipRect(int tx, int ty) { return IntRect(0,0,0,0); }
167     bool hasClip() { return isPositioned() &&  style()->hasClip(); }
168     
169     virtual int getBaselineOfFirstLineBox() const { return -1; } 
170     virtual int getBaselineOfLastLineBox() const { return -1; }
171     virtual bool isEmpty() const { return firstChild() == 0; }
172         
173     virtual bool isEdited() const { return false; }
174     virtual void setEdited(bool) { return; };
175     
176     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline
177     // children.
178     virtual RenderBlock* firstLineBlock() const;
179     virtual void updateFirstLetter();
180     
181     // Called when an object that was floating or positioned becomes a normal flow object
182     // again.  We have to make sure the render tree updates as needed to accommodate the new
183     // normal flow object.
184     void handleDynamicFloatPositionChange();
185
186     // This function is a convenience helper for creating an anonymous block that inherits its
187     // style from this RenderObject.
188     RenderBlock* createAnonymousBlock();
189     
190     // Whether or not a positioned element requires normal flow x/y to be computed
191     // to determine its position.
192     bool hasStaticX() const;
193     bool hasStaticY() const;
194     virtual void setStaticX(int staticX) {};
195     virtual void setStaticY(int staticY) {};
196     virtual int staticX() const { return 0; }
197     virtual int staticY() const { return 0; }
198     
199     CounterNode* findCounter(const String& counterName, bool willNeedLayout = false,
200         bool usesSeparator = false, bool createIfNotFound = true);
201
202 public:
203     // RenderObject tree manipulation
204     //////////////////////////////////////////
205     virtual bool canHaveChildren() const;
206     virtual void addChild(RenderObject *newChild, RenderObject *beforeChild = 0);
207     virtual void removeChild(RenderObject *oldChild);
208     virtual bool createsAnonymousWrapper() const { return false; }
209
210     // raw tree manipulation
211     virtual RenderObject* removeChildNode(RenderObject* child);
212     virtual void appendChildNode(RenderObject* child);
213     virtual void insertChildNode(RenderObject* child, RenderObject* before);
214     //////////////////////////////////////////
215
216 protected:
217     //////////////////////////////////////////
218     // Helper functions. Dangerous to use!
219     void setPreviousSibling(RenderObject *previous) { m_previous = previous; }
220     void setNextSibling(RenderObject *next) { m_next = next; }
221     void setParent(RenderObject *parent) { m_parent = parent; }
222     //////////////////////////////////////////
223 private:
224     void addAbsoluteRectForLayer(IntRect& result);
225
226 public:
227     virtual const char *renderName() const { return "RenderObject"; }
228 #ifndef NDEBUG
229     DeprecatedString information() const;
230     virtual void dump(TextStream *stream, DeprecatedString ind = "") const;
231     void showTreeForThis() const;
232 #endif
233
234     static RenderObject *createObject(Node* node, RenderStyle* style);
235
236     // Overloaded new operator.  Derived classes must override operator new
237     // in order to allocate out of the RenderArena.
238     void* operator new(size_t sz, RenderArena* renderArena) throw();    
239
240     // Overridden to prevent the normal delete from being called.
241     void operator delete(void* ptr, size_t sz);
242         
243 private:
244     // The normal operator new is disallowed on all render objects.
245     void* operator new(size_t sz) throw();
246     
247 public:
248     RenderArena* renderArena() const;
249     
250     // some helper functions...
251     virtual bool isRenderBlock() const { return false; }
252     virtual bool isRenderInline() const { return false; }
253     virtual bool isInlineFlow() const { return false; }
254     virtual bool isBlockFlow() const { return false; }
255     virtual bool isInlineBlockOrInlineTable() const { return false; }
256     virtual bool childrenInline() const { return false; }
257     virtual void setChildrenInline(bool b) { };
258
259     virtual RenderFlow* continuation() const;
260     virtual bool isInlineContinuation() const;
261     
262     virtual bool isListItem() const { return false; }
263     virtual bool isListMarker() const { return false; }
264     virtual bool isCounter() const { return false; }
265     virtual bool isRenderView() const { return false; }
266     bool isRoot() const;
267     bool isBody() const;
268     bool isHR() const;
269     virtual bool isBR() const { return false; }
270     virtual bool isTableCell() const { return false; }
271     virtual bool isTableRow() const { return false; }
272     virtual bool isTableSection() const { return false; }
273     virtual bool isTableCol() const { return false; }
274     virtual bool isTable() const { return false; }
275     virtual bool isWidget() const { return false; }
276     virtual bool isFormElement() const { return false; }
277     virtual bool isImage() const { return false; }
278     virtual bool isTextArea() const { return false; }
279     virtual bool isTextField() const { return false; }
280     virtual bool isFrameSet() const { return false; }
281     virtual bool isApplet() const { return false; }
282     virtual bool isMenuList() const { return false; }
283     virtual bool isListBox() const { return false; }
284     
285 #ifdef SVG_SUPPORT
286     virtual bool isKCanvasContainer() const { return false; }
287     virtual bool isRenderPath() const { return false; }
288     virtual FloatRect relativeBBox(bool includeStroke = true) const;
289     // We may eventually want to make these non-virtual
290     virtual AffineTransform localTransform() const;
291     virtual void setLocalTransform(const AffineTransform&);
292     virtual AffineTransform absoluteTransform() const;
293 #endif
294     
295     virtual bool isEditable() const;
296
297     bool isHTMLMarquee() const;
298     
299     bool isAnonymous() const { return m_isAnonymous; }
300     void setIsAnonymous(bool b) { m_isAnonymous = b; }
301     bool isAnonymousBlock() const { return m_isAnonymous && 
302                                            style()->display() == BLOCK && 
303                                            style()->styleType() == RenderStyle::NOPSEUDO &&
304                                            !isListMarker(); }
305     
306     bool isFloating() const { return m_floating; }
307     bool isPositioned() const { return m_positioned; } // absolute or fixed positioning
308     bool isRelPositioned() const { return m_relPositioned; } // relative positioning
309     bool isText() const  { return m_isText; }
310     bool isInline() const { return m_inline; }  // inline object
311     bool isCompact() const { return style()->display() == COMPACT; } // compact object
312     bool isRunIn() const { return style()->display() == RUN_IN; } // run-in object
313     bool isDragging() const;
314     bool isReplaced() const { return m_replaced; } // a "replaced" element (see CSS)
315     bool shouldPaintBackgroundOrBorder() const { return m_paintBackground; }
316     bool mustRepaintBackgroundOrBorder() const;
317     bool needsLayout() const   { return m_needsLayout || m_normalChildNeedsLayout || m_posChildNeedsLayout; }
318     bool selfNeedsLayout() const { return m_needsLayout; }
319     bool posChildNeedsLayout() const { return m_posChildNeedsLayout; }
320     bool normalChildNeedsLayout() const { return m_normalChildNeedsLayout; }
321     bool minMaxKnown() const{ return m_minMaxKnown; }
322     bool recalcMinMax() const { return m_recalcMinMax; }
323     bool isSelectionBorder() const;
324     
325     bool hasOverflowClip() const { return m_hasOverflowClip; }
326     
327     bool hasAutoVerticalScrollbar() const { return hasOverflowClip() && (style()->overflowY() == OAUTO || style()->overflowY() == OOVERLAY); }
328     bool hasAutoHorizontalScrollbar() const { return hasOverflowClip() && (style()->overflowX() == OAUTO || style()->overflowX() == OOVERLAY); }
329
330     bool scrollsOverflow() const { return scrollsOverflowX() || scrollsOverflowY(); }
331     bool scrollsOverflowX() const { return hasOverflowClip() && (style()->overflowX() == OSCROLL || hasAutoHorizontalScrollbar()); }
332     bool scrollsOverflowY() const { return hasOverflowClip() && (style()->overflowY() == OSCROLL || hasAutoVerticalScrollbar()); }
333     
334     bool includeVerticalScrollbarSize() const { return hasOverflowClip() && (style()->overflowY() == OSCROLL || style()->overflowY() == OAUTO); }
335     bool includeHorizontalScrollbarSize() const { return hasOverflowClip() && (style()->overflowX() == OSCROLL || style()->overflowX() == OAUTO); }
336
337     RenderStyle* getPseudoStyle(RenderStyle::PseudoId pseudo, RenderStyle* parentStyle = 0) const;
338     
339     void updateDragState(bool dragOn);
340
341     RenderView* view() const;
342
343     // don't even think about making this method virtual!
344     Node* element() const { return m_isAnonymous ? 0 : m_node; }
345     Document* document() const { return m_node->document(); }
346     void setNode(Node* node) { m_node = node; }
347     Node* node() const { return m_node; }
348     
349    /**
350      * returns the object containing this one. can be different from parent for
351      * positioned elements
352      */
353     RenderObject *container() const;
354     RenderObject* hoverAncestor() const;
355
356     virtual void markAllDescendantsWithFloatsForLayout(RenderObject* floatToRemove = 0);
357     void markContainingBlocksForLayout(bool scheduleRelayout = true);
358     void setNeedsLayout(bool b, bool markParents = true);
359     void setChildNeedsLayout(bool b, bool markParents = true);
360     void setMinMaxKnown(bool b=true) {
361         m_minMaxKnown = b;
362         if ( !b ) {
363             RenderObject *o = this;
364             RenderObject *root = this;
365             while( o ) { // ### && !o->m_recalcMinMax ) {
366                 o->m_recalcMinMax = true;
367                 root = o;
368                 o = o->m_parent;
369             }
370         }
371     }
372
373     void setNeedsLayoutAndMinMaxRecalc() {
374         setMinMaxKnown(false);
375         setNeedsLayout(true);
376     }
377     
378     void setPositioned(bool b=true)  { m_positioned = b;  }
379     void setRelPositioned(bool b=true) { m_relPositioned = b; }
380     void setFloating(bool b=true) { m_floating = b; }
381     void setInline(bool b=true) { m_inline = b; }
382     void setShouldPaintBackgroundOrBorder(bool b=true) { m_paintBackground = b; }
383     void setRenderText() { m_isText = true; }
384     void setReplaced(bool b=true) { m_replaced = b; }
385     void setHasOverflowClip(bool b = true) { m_hasOverflowClip = b; }
386
387     void scheduleRelayout();
388     
389     void updateBackgroundImages(RenderStyle* oldStyle);
390
391     virtual InlineBox* createInlineBox(bool makePlaceHolderBox, bool isRootLineBox, bool isOnlyRun=false);
392     virtual void dirtyLineBoxes(bool fullLayout, bool isRootLineBox=false);
393     
394     // For inline replaced elements, this function returns the inline box that owns us.  Enables
395     // the replaced RenderObject to quickly determine what line it is contained on and to easily
396     // iterate over structures on the line.
397     virtual InlineBox* inlineBoxWrapper() const;
398     virtual void setInlineBoxWrapper(InlineBox* b);
399     virtual void deleteLineBoxWrapper();
400
401     virtual InlineBox *inlineBox(int offset=0, EAffinity affinity = UPSTREAM);
402     
403     // for discussion of lineHeight see CSS2 spec
404     virtual short lineHeight( bool firstLine, bool isRootLineBox=false ) const;
405     // for the vertical-align property of inline elements
406     // the difference between this objects baseline position and the lines baseline position.
407     virtual short verticalPositionHint( bool firstLine ) const;
408     // the offset of baseline from the top of the object.
409     virtual short baselinePosition( bool firstLine, bool isRootLineBox=false ) const;
410     // width of tab character
411     int tabWidth() const;
412
413     /*
414      * Paint the object and its children, clipped by (x|y|w|h).
415      * (tx|ty) is the calculated position of the parent
416      */
417     struct PaintInfo {
418         PaintInfo(GraphicsContext* _p, const IntRect& _r, PaintPhase _phase, bool _forceWhiteText, RenderObject* _paintingRoot, RenderFlowSequencedSet* _outlineObjects)
419             : p(_p), r(_r), phase(_phase), forceWhiteText(_forceWhiteText), paintingRoot(_paintingRoot), outlineObjects(_outlineObjects) {}
420         GraphicsContext* p;
421         IntRect r;
422         PaintPhase phase;
423         bool forceWhiteText;
424         RenderObject* paintingRoot; // used to draw just one element and its visual kids
425         RenderFlowSequencedSet* outlineObjects; // used to list outlines that should be painted by a block with inline children
426     };
427     virtual void paint(PaintInfo&, int tx, int ty);
428     void paintBorder(GraphicsContext*, int tx, int ty, int w, int h, const RenderStyle*, bool begin = true, bool end = true);
429     bool paintBorderImage(GraphicsContext*, int tx, int ty, int w, int h, const RenderStyle* style);
430     void paintOutline(GraphicsContext*, int tx, int ty, int w, int h, const RenderStyle* style);
431
432     // RenderBox implements this.
433     virtual void paintBoxDecorations(PaintInfo&, int tx, int ty) {}
434
435     virtual void paintBackgroundExtended(GraphicsContext*, const Color&, const BackgroundLayer*, int clipy, int cliph,
436         int tx, int ty, int w, int height, int bleft, int bright, int pleft, int pright) {}
437
438     /*
439      * This function calculates the minimum & maximum width that the object
440      * can be set to.
441      *
442      * when the Element calls setMinMaxKnown(true), calcMinMaxWidth() will
443      * be no longer called.
444      *
445      * when a element has a fixed size, m_minWidth and m_maxWidth should be
446      * set to the same value. This has the special meaning that m_width,
447      * contains the actual value.
448      *
449      * assumes calcMinMaxWidth has already been called for all children.
450      */
451     virtual void calcMinMaxWidth() { }
452
453     /*
454      * Does the min max width recalculations after changes.
455      */
456     void recalcMinMaxWidths();
457
458     /*
459      * Calculates the actual width of the object (only for non inline
460      * objects)
461      */
462     virtual void calcWidth() {}
463
464     /*
465      * This function should cause the Element to calculate its
466      * width and height and the layout of its content
467      *
468      * when the Element calls setNeedsLayout(false), layout() is no
469      * longer called during relayouts, as long as there is no
470      * style sheet change. When that occurs, m_needsLayout will be
471      * set to true and the Element receives layout() calls
472      * again.
473      */
474     virtual void layout() = 0;
475
476     /* This function performs a layout only if one is needed. */
477     void layoutIfNeeded() { if (needsLayout()) layout(); }
478
479     // used for element state updates that can not be fixed with a
480     // repaint and do not need a relayout
481     virtual void updateFromElement() {};
482
483     virtual int availableHeight() const { return 0; }
484
485     virtual void updateWidgetPosition();
486     
487     void addDashboardRegions(Vector<DashboardRegionValue>&);
488     void collectDashboardRegions(Vector<DashboardRegionValue>&);
489
490     // does a query on the rendertree and finds the innernode
491     // and overURL for the given position
492     // if readonly == false, it will recalc hover styles accordingly
493     class NodeInfo {
494     public:
495         NodeInfo(bool readonly, bool active, bool mouseMove = false)
496             : m_innerNode(0), m_innerNonSharedNode(0), m_innerURLElement(0), 
497               m_scrollbar(0), m_readonly(readonly), m_active(active), m_mouseMove(mouseMove)
498             { }
499
500         Node* innerNode() const { return m_innerNode; }
501         Node* innerNonSharedNode() const { return m_innerNonSharedNode; }
502         Element* URLElement() const { return m_innerURLElement; }
503         PlatformScrollbar* scrollbar() const { return m_scrollbar; }
504         bool readonly() const { return m_readonly; }
505         bool active() const { return m_active; }
506         bool mouseMove() const { return m_mouseMove; }
507         
508         void setInnerNode(Node* n) { m_innerNode = n; }
509         void setInnerNonSharedNode(Node* n) { m_innerNonSharedNode = n; }
510         void setURLElement(Element* n) { m_innerURLElement = n; }
511         void setScrollbar(PlatformScrollbar* s) { m_scrollbar = s; }
512
513     private:
514         Node* m_innerNode;
515         Node* m_innerNonSharedNode;
516         Element* m_innerURLElement;
517         PlatformScrollbar* m_scrollbar;
518         bool m_readonly;
519         bool m_active;
520         bool m_mouseMove;
521     };
522
523     // Used to signal a specific subrect within an object that must be repainted after
524     // layout is complete.
525     struct RepaintInfo {
526         RenderObject* m_object;
527         IntRect m_repaintRect;
528     
529         RepaintInfo(RenderObject* o, const IntRect& r) :m_object(o), m_repaintRect(r) {}
530     };
531     
532     bool hitTest(NodeInfo& info, int x, int y, int tx, int ty, HitTestFilter hitTestFilter = HitTestAll);
533     virtual bool nodeAtPoint(NodeInfo& info, int x, int y, int tx, int ty,
534                              HitTestAction hitTestAction);
535     void setInnerNode(NodeInfo& info);
536
537     virtual VisiblePosition positionForCoordinates(int x, int y);
538     VisiblePosition positionForPoint(const IntPoint& point) { return positionForCoordinates(point.x(), point.y()); }
539     
540     virtual void dirtyLinesFromChangedChild(RenderObject* child);
541     
542     // Set the style of the object and update the state of the object accordingly.
543     virtual void setStyle(RenderStyle* style);
544
545     // Updates only the local style ptr of the object.  Does not update the state of the object,
546     // and so only should be called when the style is known not to have changed (or from setStyle).
547     void setStyleInternal(RenderStyle* style);
548
549     // returns the containing block level element for this element.
550     RenderBlock *containingBlock() const;
551
552     // return just the width of the containing block
553     virtual int containingBlockWidth() const;
554     // return just the height of the containing block
555     virtual int containingBlockHeight() const;
556
557     // size of the content area (box size minus padding/border)
558     virtual int contentWidth() const { return 0; }
559     virtual int contentHeight() const { return 0; }
560
561     // intrinsic extend of replaced elements. undefined otherwise
562     virtual int intrinsicWidth() const { return 0; }
563     virtual int intrinsicHeight() const { return 0; }
564
565     // used by flexible boxes to impose a flexed width/height override
566     virtual int overrideSize() const { return 0; }
567     virtual int overrideWidth() const { return 0; }
568     virtual int overrideHeight() const { return 0; }
569     virtual void setOverrideSize(int s) {}
570
571     // relative to parent node
572     virtual void setPos( int /*xPos*/, int /*yPos*/ ) { }
573     virtual void setWidth( int /*width*/ ) { }
574     virtual void setHeight( int /*height*/ ) { }
575
576     virtual int xPos() const { return 0; }
577     virtual int yPos() const { return 0; }
578
579     // calculate client position of box
580     virtual bool absolutePosition(int &/*xPos*/, int &/*yPos*/, bool fixed = false);
581     
582     // This function is used to deal with the extra top space that can occur in table cells (called borderTopExtra).
583     // The children of the cell do not factor this space in, so we have to add it in.  Any code that wants to
584     // accurately deal with the contents of a cell must call this function instad of absolutePosition.
585     void absolutePositionForContent(int& xPos, int& yPos, bool fixed = false) {
586         absolutePosition(xPos, yPos, fixed);
587         yPos += borderTopExtra();
588     }
589
590     // width and height are without margins but include paddings and borders
591     virtual int width() const { return 0; }
592     virtual int height() const { return 0; }
593
594     virtual IntRect borderBox() const { return IntRect(0, 0, width(), height()); }
595
596     // The height of a block when you include normal flow overflow spillage out of the bottom
597     // of the block (e.g., a <div style="height:25px"> that has a 100px tall image inside
598     // it would have an overflow height of borderTop() + paddingTop() + 100px.
599     virtual int overflowHeight(bool includeInterior=true) const { return height(); }
600     virtual int overflowWidth(bool includeInterior=true) const { return width(); }
601     virtual void setOverflowHeight(int) {}
602     virtual void setOverflowWidth(int) {}
603     virtual int overflowLeft(bool includeInterior=true) const { return 0; }
604     virtual int overflowTop(bool includeInterior=true) const { return 0; }
605     virtual IntRect overflowRect(bool includeInterior=true) const { return borderBox(); }
606
607     // IE extensions. Used to calculate offsetWidth/Height.  Overridden by inlines (RenderFlow) 
608     // to return the remaining width on a given line (and the height of a single line). -dwh
609     virtual int offsetWidth() const { return width(); }
610     virtual int offsetHeight() const { return height() + borderTopExtra() + borderBottomExtra(); }
611     
612     // IE exxtensions.  Also supported by Gecko.  We override in render flow to get the
613     // left and top correct. -dwh
614     virtual int offsetLeft() const;
615     virtual int offsetTop() const;
616     virtual RenderObject* offsetParent() const;
617
618     // More IE extensions.  clientWidth and clientHeight represent the interior of an object
619     // excluding border and scrollbar.  clientLeft/Top are just the borderLeftWidth and borderTopWidth.
620     int clientLeft() const { return borderLeft(); }
621     int clientTop() const { return borderTop(); }
622     int clientWidth() const;
623     int clientHeight() const;
624
625     // scrollWidth/scrollHeight will be the same as clientWidth/clientHeight unless the
626     // object has overflow:hidden/scroll/auto specified and also has overflow.
627     // scrollLeft/Top return the current scroll position.  These methods are virtual so that objects like
628     // textareas can scroll shadow content (but pretend that they are the objects that are
629     // scrolling).
630     virtual int scrollLeft() const;
631     virtual int scrollTop() const;
632     virtual int scrollWidth() const;
633     virtual int scrollHeight() const;
634     virtual void setScrollLeft(int);
635     virtual void setScrollTop(int);
636
637     virtual bool scroll(ScrollDirection direction, ScrollGranularity granularity, float multiplier=1.0);
638     virtual bool shouldAutoscroll() const;
639     virtual void autoscroll();
640
641     // The following seven functions are used to implement collapsing margins.
642     // All objects know their maximal positive and negative margins.  The
643     // formula for computing a collapsed margin is |maxPosMargin|-|maxNegmargin|.
644     // For a non-collapsing, e.g., a leaf element, this formula will simply return
645     // the margin of the element.  Blocks override the maxTopMargin and maxBottomMargin
646     // methods.
647     virtual bool isSelfCollapsingBlock() const { return false; }
648     virtual int collapsedMarginTop() const 
649         { return maxTopMargin(true)-maxTopMargin(false); }
650     virtual int collapsedMarginBottom() const 
651         { return maxBottomMargin(true)-maxBottomMargin(false); }
652     virtual bool isTopMarginQuirk() const { return false; }
653     virtual bool isBottomMarginQuirk() const { return false; }
654     virtual int maxTopMargin(bool positive) const {
655         if (positive)
656             if (marginTop() > 0)
657                 return marginTop();
658             else
659                 return 0;
660         else
661             if (marginTop() < 0)
662                 return 0 - marginTop();
663             else
664                 return 0;
665     }
666     virtual int maxBottomMargin(bool positive) const {
667         if (positive)
668             if (marginBottom() > 0)
669                 return marginBottom();
670             else
671                 return 0;
672         else
673             if (marginBottom() < 0)
674                 return 0 - marginBottom();
675             else
676                 return 0;
677     }
678
679     virtual int marginTop() const { return 0; }
680     virtual int marginBottom() const { return 0; }
681     virtual int marginLeft() const { return 0; }
682     virtual int marginRight() const { return 0; }
683
684     // Virtual since table cells override 
685     virtual int paddingTop() const;
686     virtual int paddingBottom() const;
687     virtual int paddingLeft() const;
688     virtual int paddingRight() const;
689     
690     virtual int borderTop() const { return style()->borderTopWidth(); }
691     virtual int borderBottom() const { return style()->borderBottomWidth(); }
692     virtual int borderTopExtra() const { return 0; }
693     virtual int borderBottomExtra() const { return 0; }
694     virtual int borderLeft() const { return style()->borderLeftWidth(); }
695     virtual int borderRight() const { return style()->borderRightWidth(); }
696
697     virtual void lineBoxRects(Vector<IntRect>&);
698
699     virtual void absoluteRects(Vector<IntRect>&, int tx, int ty);
700     IntRect absoluteBoundingBoxRect();
701     
702     // the rect that will be painted if this object is passed as the paintingRoot
703     IntRect paintingRootRect(IntRect& topLevelRect);
704
705     virtual void addFocusRingRects(GraphicsContext*, int tx, int ty);
706
707     virtual int minWidth() const { return 0; }
708     virtual int maxWidth() const { return 0; }
709
710     RenderStyle* style() const { return m_style; }
711     RenderStyle* firstLineStyle() const;
712     RenderStyle* style(bool firstLine) const { return firstLine ? firstLineStyle() : style(); }
713
714
715     void getTextDecorationColors(int decorations, Color& underline, Color& overline,
716                                  Color& linethrough, bool quirksMode=false);
717
718     enum BorderSide {
719         BSTop, BSBottom, BSLeft, BSRight
720     };
721     void drawBorderArc(GraphicsContext*, int x, int y, float thickness, IntSize radius, int angleStart,
722         int angleSpan, BorderSide, Color, const Color& textcolor, EBorderStyle, bool firstCorner);
723     void drawBorder(GraphicsContext*, int x1, int y1, int x2, int y2, BorderSide,
724         Color, const Color& textcolor, EBorderStyle, int adjbw1, int adjbw2);
725
726     virtual void setTable(RenderTable*) {};
727
728     // Used by collapsed border tables.
729     virtual void collectBorders(DeprecatedValueList<CollapsedBorderValue>&);
730
731     // Repaint the entire object.  Called when, e.g., the color of a border changes, or when a border
732     // style changes.
733     void repaint(bool immediate = false);
734
735     // Repaint a specific subrectangle within a given object.  The rect |r| is in the object's coordinate space.
736     void repaintRectangle(const IntRect& r, bool immediate = false);
737     
738     // Repaint only if our old bounds and new bounds are different.
739     bool repaintAfterLayoutIfNeeded(const IntRect& oldBounds, const IntRect& oldFullBounds);
740
741     // Repaint only if the object moved.
742     virtual void repaintDuringLayoutIfMoved(int oldX, int oldY);
743
744     // Called to repaint a block's floats.
745     virtual void repaintOverhangingFloats(bool paintAllDescendants = false);
746
747     // Called before layout to repaint all dirty children (with selfNeedsLayout() set).
748     virtual void repaintObjectsBeforeLayout();
749
750     bool checkForRepaintDuringLayout() const;
751
752     // Returns the rect that should be repainted whenever this object changes.  The rect is in the view's
753     // coordinate space.  This method deals with outlines and overflow.
754     virtual IntRect getAbsoluteRepaintRect();
755
756     IntRect getAbsoluteRepaintRectWithOutline(int ow);
757
758     virtual void getAbsoluteRepaintRectIncludingFloats(IntRect& bounds, IntRect& boundsWithChildren);
759
760     // Given a rect in the object's coordinate space, this method converts the rectangle to the view's
761     // coordinate space.
762     virtual void computeAbsoluteRepaintRect(IntRect& r, bool f=false);
763     
764     virtual unsigned int length() const { return 1; }
765
766     bool isFloatingOrPositioned() const { return (isFloating() || isPositioned()); };
767     virtual bool containsFloats() { return false; }
768     virtual bool containsFloat(RenderObject* o) { return false; }
769     virtual bool hasOverhangingFloats() { return false; }
770     virtual bool expandsToEncloseOverhangingFloats() const { return isFloating() && style()->height().isAuto(); }
771     virtual IntRect floatRect() const { return borderBox(); }
772
773     virtual void removePositionedObjects(RenderBlock*) { }
774
775     virtual bool avoidsFloats() const;
776     bool usesLineWidth() const;
777
778     // positioning of inline children (bidi)
779     virtual void position(InlineBox*) { }
780
781     bool isTransparent() const { return style()->opacity() < 1.0f; }
782     float opacity() const { return style()->opacity(); }
783
784     // Applied as a "slop" to dirty rect checks during the outline painting phase's dirty-rect checks.
785     int maximalOutlineSize(PaintPhase p) const;
786
787     enum SelectionState {
788         SelectionNone, // The object is not selected.
789         SelectionStart, // The object either contains the start of a selection run or is the start of a run
790         SelectionInside, // The object is fully encompassed by a selection run
791         SelectionEnd, // The object either contains the end of a selection run or is the end of a run
792         SelectionBoth // The object contains an entire run or is the sole selected object in that run
793     };
794
795     // The current selection state for an object.  For blocks, the state refers to the state of the leaf
796     // descendants (as described above in the SelectionState enum declaration).
797     virtual SelectionState selectionState() const { return SelectionNone; }
798     
799     // Sets the selection state for an object.
800     virtual void setSelectionState(SelectionState s) { if (parent()) parent()->setSelectionState(s); }
801
802     // A single rectangle that encompasses all of the selected objects within this object.  Used to determine the tightest
803     // possible bounding box for the selection.
804     virtual IntRect selectionRect() { return IntRect(); }
805     
806     // Whether or not an object can be part of the leaf elements of the selection.
807     virtual bool canBeSelectionLeaf() const { return false; }
808
809     // Whether or not a block has selected children.
810     virtual bool hasSelectedChildren() const { return false; }
811
812     // Whether or not a selection can be attempted on this object.
813     bool canSelect() const;
814
815     // Whether or not a selection can be attempted on this object.  Should only be called right before actually beginning a selection,
816     // since it fires the selectstart DOM event.
817     bool shouldSelect() const;
818     
819     // Obtains the selection colors that should be used when painting a selection.
820     Color selectionBackgroundColor() const;
821     Color selectionForegroundColor() const;
822
823     // Whether or not a given block needs to paint selection gaps.
824     virtual bool shouldPaintSelectionGaps() const { return false; }
825
826     // This struct is used when the selection changes to cache the old and new state of the selection for each RenderObject.
827     struct SelectionInfo {
828         RenderObject* m_object;
829         IntRect m_rect;
830         RenderObject::SelectionState m_state;
831
832         RenderObject* object() const { return m_object; }
833         IntRect rect() const { return m_rect; }
834         SelectionState state() const { return m_state; }
835         
836         SelectionInfo() { m_object = 0; m_state = SelectionNone; }
837         SelectionInfo(RenderObject* o) :m_object(o), m_rect(o->selectionRect()), m_state(o->selectionState()) {}
838     };
839
840     Node* draggableNode(bool dhtmlOK, bool uaOK, int x, int y, bool& dhtmlWillDrag) const;
841
842     /**
843      * Returns the content coordinates of the caret within this render object.
844      * @param offset zero-based offset determining position within the render object.
845      * @param override @p true if input overrides existing characters,
846      * @p false if it inserts them. The width of the caret depends on this one.
847      * @param extraWidthToEndOfLine optional out arg to give extra width to end of line -
848      * useful for character range rect computations
849      */
850     virtual IntRect caretRect(int offset, EAffinity affinity = UPSTREAM, int *extraWidthToEndOfLine = 0);
851
852     virtual int lowestPosition(bool includeOverflowInterior=true, bool includeSelf=true) const { return 0; }
853     virtual int rightmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const { return 0; }
854     virtual int leftmostPosition(bool includeOverflowInterior=true, bool includeSelf=true) const { return 0; }
855     
856     virtual void calcVerticalMargins() {}
857     void removeFromObjectLists();
858
859     // When performing a global document tear-down, the renderer of the document is cleared.  We use this
860     // as a hook to detect the case of document destruction and don't waste time doing unnecessary work.
861     bool documentBeingDestroyed() const;
862
863     virtual void destroy();
864
865     const Font& font(bool firstLine) const {
866         return style(firstLine)->font();
867     }
868
869     // Virtual function helpers for CSS3 Flexible Box Layout
870     virtual bool isFlexibleBox() const { return false; }
871     virtual bool isFlexingChildren() const { return false; }
872     virtual bool isStretchingChildren() const { return false; }
873
874     // Convenience, to avoid repeating the code to dig down to get this.
875     UChar backslashAsCurrencySymbol() const;
876
877     virtual int caretMinOffset() const;
878     virtual int caretMaxOffset() const;
879     virtual unsigned caretMaxRenderedOffset() const;
880
881     virtual int previousOffset (int current) const;
882     virtual int nextOffset (int current) const;
883
884     virtual void imageChanged(CachedImage*);
885     virtual bool willRenderImage(CachedImage*);
886
887     virtual void selectionStartEnd(int& spos, int& epos);
888
889     RenderObject* paintingRootForChildren(PaintInfo &i) const {
890         // if we're the painting root, kids draw normally, and see root of 0
891         return (!i.paintingRoot || i.paintingRoot == this) ? 0 : i.paintingRoot;
892     }
893
894     bool shouldPaintWithinRoot(PaintInfo &i) const {
895         return !i.paintingRoot || i.paintingRoot == this;
896     }
897     
898 protected:
899     virtual void printBoxDecorations(GraphicsContext*, int /*x*/, int /*y*/,
900         int /*w*/, int /*h*/, int /*tx*/, int /*ty*/) {}
901
902     virtual IntRect viewRect() const;
903
904     void remove() { if (parent()) parent()->removeChild(this); }
905
906     void invalidateVerticalPositions();
907     short getVerticalPosition(bool firstLine) const;
908
909     virtual void removeLeftoverAnonymousBoxes();
910     
911     void arenaDelete(RenderArena*, void* objectBase);
912
913 private:
914     RenderStyle* m_style;
915
916     Node* m_node;
917
918     RenderObject *m_parent;
919     RenderObject *m_previous;
920     RenderObject *m_next;
921
922     mutable short m_verticalPosition;
923
924     bool m_needsLayout               : 1;
925     bool m_normalChildNeedsLayout    : 1;
926     bool m_posChildNeedsLayout       : 1;
927     bool m_minMaxKnown               : 1;
928     bool m_floating                  : 1;
929
930     bool m_positioned                : 1;
931     bool m_relPositioned             : 1;
932     bool m_paintBackground           : 1; // if the box has something to paint in the
933                                           // background painting phase (background, border, etc)
934
935     bool m_isAnonymous               : 1;
936     bool m_recalcMinMax              : 1;
937     bool m_isText                    : 1;
938     bool m_inline                    : 1;
939     bool m_replaced                  : 1;
940     bool m_isDragging                : 1;
941     
942     bool m_hasOverflowClip           : 1;
943     
944     bool m_hasCounterNodeMap         : 1;
945
946     friend class RenderListItem;
947     friend class RenderContainer;
948     friend class RenderView;
949 };
950
951
952 enum VerticalPositionHint {
953     PositionTop = -0x4000,
954     PositionBottom = 0x4000,
955     PositionUndefined = 0x3fff
956 };
957
958 } //namespace
959
960 #ifndef NDEBUG
961 // Outside the WebCore namespace for ease of invocation from gdb.
962 void showTree(const WebCore::RenderObject*);
963 #endif
964
965
966 #endif