1 /*

     2  * This file is part of the render object implementation for KHTML.

     3  *

     4  * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

     5  *           (C) 1999 Antti Koivisto (koivisto@kde.org)

     6  *           (C) 2007 David Smith (catfish.man@gmail.com)

     7  * Copyright (C) 2003, 2004, 2005, 2006 Apple Computer, Inc.

     8  *

     9  * This library is free software; you can redistribute it and/or

    10  * modify it under the terms of the GNU Library General Public

    11  * License as published by the Free Software Foundation; either

    12  * version 2 of the License, or (at your option) any later version.

    13  *

    14  * This library is distributed in the hope that it will be useful,

    15  * but WITHOUT ANY WARRANTY; without even the implied warranty of

    16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

    17  * Library General Public License for more details.

    18  *

    19  * You should have received a copy of the GNU Library General Public License

    20  * along with this library; see the file COPYING.LIB.  If not, write to

    21  * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

    22  * Boston, MA 02110-1301, USA.

    23  */

    24 

    25 #ifndef RenderBlock_h

    26 #define RenderBlock_h

    27 

    28 #include "DeprecatedPtrList.h"

    29 #include "GapRects.h"

    30 #include "RenderFlow.h"

    31 #include "RootInlineBox.h"

    32 #include <wtf/ListHashSet.h>

    33 

    34 namespace WebCore {

    35 

    36 class BidiIterator;

    37 class BidiRun;

    38 class Position;

    39 class RootInlineBox;

    40 

    41 template <class Iterator, class Run> class BidiResolver;

    42 typedef BidiResolver<BidiIterator, BidiRun> BidiState;

    43 

    44 enum CaretType { CursorCaret, DragCaret };

    45 

    46 class RenderBlock : public RenderFlow {

    47 public:

    48     RenderBlock(Node*);

    49     virtual ~RenderBlock();

    50 

    51     virtual const char* renderName() const;

    52 

    53     // These two functions are overridden for inline-block.

    54     virtual short lineHeight(bool firstLine, bool isRootLineBox = false) const;

    55     virtual short baselinePosition(bool firstLine, bool isRootLineBox = false) const;

    56 

    57     virtual bool isRenderBlock() const { return true; }

    58     virtual bool isBlockFlow() const { return (!isInline() || isReplaced()) && !isTable(); }

    59     virtual bool isInlineFlow() const { return isInline() && !isReplaced(); }

    60     virtual bool isInlineBlockOrInlineTable() const { return isInline() && isReplaced(); }

    61 

    62     virtual bool childrenInline() const { return m_childrenInline; }

    63     virtual void setChildrenInline(bool b) { m_childrenInline = b; }

    64     void makeChildrenNonInline(RenderObject* insertionPoint = 0);

    65     void deleteLineBoxTree();

    66 

    67     // The height (and width) of a block when you include overflow spillage out of the bottom

    68     // of the block (e.g., a <div style="height:25px"> that has a 100px tall image inside

    69     // it would have an overflow height of borderTop() + paddingTop() + 100px.

    70     virtual int overflowHeight(bool includeInterior = true) const;

    71     virtual int overflowWidth(bool includeInterior = true) const;

    72     virtual int overflowLeft(bool includeInterior = true) const;

    73     virtual int overflowTop(bool includeInterior = true) const;

    74     virtual IntRect overflowRect(bool includeInterior = true) const;

    75     virtual void setOverflowHeight(int h) { m_overflowHeight = h; }

    76     virtual void setOverflowWidth(int w) { m_overflowWidth = w; }

    77 

    78     void addVisualOverflow(const IntRect&);

    79 

    80     virtual bool isSelfCollapsingBlock() const;

    81     virtual bool isTopMarginQuirk() const { return m_topMarginQuirk; }

    82     virtual bool isBottomMarginQuirk() const { return m_bottomMarginQuirk; }

    83 

    84     virtual int maxTopMargin(bool positive) const { return positive ? maxTopPosMargin() : maxTopNegMargin(); }

    85     virtual int maxBottomMargin(bool positive) const { return positive ? maxBottomPosMargin() : maxBottomNegMargin(); }

    86 

    87     int maxTopPosMargin() const { return m_maxMargin ? m_maxMargin->m_topPos : MaxMargin::topPosDefault(this); }

    88     int maxTopNegMargin() const { return m_maxMargin ? m_maxMargin->m_topNeg : MaxMargin::topNegDefault(this); }

    89     int maxBottomPosMargin() const { return m_maxMargin ? m_maxMargin->m_bottomPos : MaxMargin::bottomPosDefault(this); }

    90     int maxBottomNegMargin() const { return m_maxMargin ? m_maxMargin->m_bottomNeg : MaxMargin::bottomNegDefault(this); }

    91     void setMaxTopMargins(int pos, int neg);

    92     void setMaxBottomMargins(int pos, int neg);

    93     

    94     void initMaxMarginValues()

    95     {

    96         if (m_maxMargin) {

    97             m_maxMargin->m_topPos = MaxMargin::topPosDefault(this);

    98             m_maxMargin->m_topNeg = MaxMargin::topNegDefault(this);

    99             m_maxMargin->m_bottomPos = MaxMargin::bottomPosDefault(this);

   100             m_maxMargin->m_bottomNeg = MaxMargin::bottomNegDefault(this);

   101         }

   102     }

   103 

   104     virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild);

   105     virtual void removeChild(RenderObject*);

   106 

   107     virtual void repaintOverhangingFloats(bool paintAllDescendants);

   108 

   109     virtual void setStyle(RenderStyle*);

   110 

   111     virtual void layout();

   112     virtual void layoutBlock(bool relayoutChildren);

   113     void layoutBlockChildren(bool relayoutChildren);

   114     void layoutInlineChildren(bool relayoutChildren, int& repaintTop, int& repaintBottom);

   115 

   116     void layoutPositionedObjects(bool relayoutChildren);

   117     void insertPositionedObject(RenderObject*);

   118     void removePositionedObject(RenderObject*);

   119     virtual void removePositionedObjects(RenderBlock*);

   120 

   121     virtual void positionListMarker() { }

   122 

   123     virtual void borderFitAdjust(int& x, int& w) const; // Shrink the box in which the border paints if border-fit is set.

   124 

   125     // Called to lay out the legend for a fieldset.

   126     virtual RenderObject* layoutLegend(bool relayoutChildren) { return 0; };

   127 

   128     // the implementation of the following functions is in bidi.cpp

   129     void bidiReorderLine(const BidiIterator& start, const BidiIterator& end, BidiState&);

   130     RootInlineBox* determineStartPosition(bool fullLayout, BidiIterator& start, BidiState&);

   131     RootInlineBox* determineEndPosition(RootInlineBox* startBox, BidiIterator& cleanLineStart,

   132                                         BidiStatus& cleanLineBidiStatus,

   133                                         int& yPos);

   134     bool matchedEndLine(const BidiIterator& start, const BidiStatus& status,

   135                         const BidiIterator& endLineStart, const BidiStatus& endLineStatus,

   136                         RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop);

   137     bool generatesLineBoxesForInlineChild(RenderObject*);

   138     int skipWhitespace(BidiIterator&, BidiState&);

   139     BidiIterator findNextLineBreak(BidiIterator& start, BidiState& info);

   140     RootInlineBox* constructLine(const BidiIterator& start, const BidiIterator& end);

   141     InlineFlowBox* createLineBoxes(RenderObject*);

   142     void computeHorizontalPositionsForLine(RootInlineBox*, bool reachedEnd);

   143     void computeVerticalPositionsForLine(RootInlineBox*);

   144     void checkLinesForOverflow();

   145     void deleteEllipsisLineBoxes();

   146     void checkLinesForTextOverflow();

   147     // end bidi.cpp functions

   148 

   149     virtual void paint(PaintInfo&, int tx, int ty);

   150     virtual void paintObject(PaintInfo&, int tx, int ty);

   151     void paintFloats(PaintInfo&, int tx, int ty, bool paintSelection = false);

   152     void paintContents(PaintInfo&, int tx, int ty);

   153     void paintColumns(PaintInfo&, int tx, int ty, bool paintFloats = false);

   154     void paintChildren(PaintInfo&, int tx, int ty);

   155     void paintEllipsisBoxes(PaintInfo&, int tx, int ty);

   156     void paintSelection(PaintInfo&, int tx, int ty);

   157     void paintCaret(PaintInfo&, CaretType);

   158     

   159     void insertFloatingObject(RenderObject*);

   160     void removeFloatingObject(RenderObject*);

   161 

   162     // called from lineWidth, to position the floats added in the last line.

   163     void positionNewFloats();

   164     void clearFloats();

   165     int getClearDelta(RenderObject* child);

   166     virtual void markAllDescendantsWithFloatsForLayout(RenderObject* floatToRemove = 0);

   167     void markPositionedObjectsForLayout();

   168 

   169     // FIXME: containsFloats() should not return true if the floating objects list

   170     // is empty. However, layoutInlineChildren() relies on the current behavior.

   171     // http://bugs.webkit.org/show_bug.cgi?id=7395#c3

   172     virtual bool containsFloats() { return m_floatingObjects; }

   173     virtual bool containsFloat(RenderObject*);

   174 

   175     virtual bool avoidsFloats() const;

   176 

   177     virtual bool hasOverhangingFloats() { return !hasColumns() && floatBottom() > m_height; }

   178     void addIntrudingFloats(RenderBlock* prev, int xoffset, int yoffset);

   179     void addOverhangingFloats(RenderBlock* child, int xoffset, int yoffset);

   180 

   181     int nearestFloatBottom(int height) const;

   182     int floatBottom() const;

   183     inline int leftBottom();

   184     inline int rightBottom();

   185     IntRect floatRect() const;

   186 

   187     virtual int lineWidth(int y) const;

   188     virtual int lowestPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;

   189     virtual int rightmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;

   190     virtual int leftmostPosition(bool includeOverflowInterior = true, bool includeSelf = true) const;

   191 

   192     int rightOffset() const;

   193     int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;

   194     int rightOffset(int y) const { return rightRelOffset(y, rightOffset(), true); }

   195 

   196     int leftOffset() const;

   197     int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;

   198     int leftOffset(int y) const { return leftRelOffset(y, leftOffset(), true); }

   199 

   200     virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);

   201     virtual bool hitTestColumns(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);

   202     virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);

   203 

   204     virtual bool isPointInOverflowControl(HitTestResult&, int x, int y, int tx, int ty);

   205 

   206     virtual VisiblePosition positionForCoordinates(int x, int y);

   207     

   208     // Block flows subclass availableWidth to handle multi column layout (shrinking the width available to children when laying out.)

   209     virtual int availableWidth() const;

   210     

   211     virtual void calcPrefWidths();

   212     void calcInlinePrefWidths();

   213     void calcBlockPrefWidths();

   214 

   215     virtual int getBaselineOfFirstLineBox() const;

   216     virtual int getBaselineOfLastLineBox() const;

   217 

   218     RootInlineBox* firstRootBox() const { return static_cast<RootInlineBox*>(firstLineBox()); }

   219     RootInlineBox* lastRootBox() const { return static_cast<RootInlineBox*>(lastLineBox()); }

   220 

   221     // Obtains the nearest enclosing block (including this block) that contributes a first-line style to our inline

   222     // children.

   223     virtual RenderBlock* firstLineBlock() const;

   224     virtual void updateFirstLetter();

   225 

   226     bool inRootBlockContext() const;

   227 

   228     void setHasMarkupTruncation(bool b = true) { m_hasMarkupTruncation = b; }

   229     bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }

   230 

   231     virtual bool hasSelectedChildren() const { return m_selectionState != SelectionNone; }

   232     virtual SelectionState selectionState() const { return static_cast<SelectionState>(m_selectionState); }

   233     virtual void setSelectionState(SelectionState s);

   234 

   235     struct BlockSelectionInfo {

   236         RenderBlock* m_block;

   237         GapRects m_rects;

   238         SelectionState m_state;

   239 

   240         BlockSelectionInfo()

   241             : m_block(0)

   242             , m_state(SelectionNone)

   243         {

   244         }

   245 

   246         BlockSelectionInfo(RenderBlock* b)

   247             : m_block(b)

   248             , m_rects(b->needsLayout() ? GapRects() : b->selectionGapRects())

   249             , m_state(b->selectionState())

   250         { 

   251         }

   252 

   253         RenderBlock* block() const { return m_block; }

   254         GapRects rects() const { return m_rects; }

   255         SelectionState state() const { return m_state; }

   256     };

   257 

   258     virtual IntRect selectionRect(bool) { return selectionGapRects(); }

   259     GapRects selectionGapRects();

   260     virtual bool shouldPaintSelectionGaps() const;

   261     bool isSelectionRoot() const;

   262     GapRects fillSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,

   263                                int& lastTop, int& lastLeft, int& lastRight, const PaintInfo* = 0);

   264     GapRects fillInlineSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,

   265                                      int& lastTop, int& lastLeft, int& lastRight, const PaintInfo*);

   266     GapRects fillBlockSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,

   267                                     int& lastTop, int& lastLeft, int& lastRight, const PaintInfo*);

   268     IntRect fillVerticalSelectionGap(int lastTop, int lastLeft, int lastRight, int bottomY, RenderBlock* rootBlock,

   269                                      int blockX, int blockY, const PaintInfo*);

   270     IntRect fillLeftSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock, 

   271                                  int blockX, int blockY, int tx, int ty, const PaintInfo*);

   272     IntRect fillRightSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock,

   273                                   int blockX, int blockY, int tx, int ty, const PaintInfo*);

   274     IntRect fillHorizontalSelectionGap(RenderObject* selObj, int xPos, int yPos, int width, int height, const PaintInfo*);

   275 

   276     void getHorizontalSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);

   277     int leftSelectionOffset(RenderBlock* rootBlock, int y);

   278     int rightSelectionOffset(RenderBlock* rootBlock, int y);

   279 

   280 #ifndef NDEBUG

   281     virtual void dump(TextStream*, DeprecatedString ind = "") const;

   282 #endif

   283 

   284     // Helper methods for computing line counts and heights for line counts.

   285     RootInlineBox* lineAtIndex(int);

   286     int lineCount();

   287     int heightForLineCount(int);

   288     void clearTruncation();

   289 

   290     int desiredColumnWidth() const;

   291     unsigned desiredColumnCount() const;

   292     Vector<IntRect>* columnRects() const;

   293     void setDesiredColumnCountAndWidth(int count, int width);

   294     

   295     void adjustRectForColumns(IntRect&) const;

   296 

   297     void addContinuationWithOutline(RenderFlow*);

   298     void paintContinuationOutlines(PaintInfo&, int tx, int ty);

   299 

   300 private:

   301     void adjustPointToColumnContents(IntPoint&) const;

   302     void adjustForBorderFit(int x, int& left, int& right) const; // Helper function for borderFitAdjust

   303 

   304 protected:

   305     void newLine();

   306     virtual bool hasLineIfEmpty() const;

   307     bool layoutOnlyPositionedObjects();

   308 

   309 private:

   310     Position positionForBox(InlineBox*, bool start = true) const;

   311     Position positionForRenderer(RenderObject*, bool start = true) const;

   312 

   313     int columnGap() const;

   314     void calcColumnWidth();

   315     int layoutColumns(int endOfContent = -1);

   316 

   317 protected:

   318     struct FloatingObject {

   319         enum Type {

   320             FloatLeft,

   321             FloatRight

   322         };

   323 

   324         FloatingObject(Type type)

   325             : node(0)

   326             , startY(0)

   327             , endY(0)

   328             , left(0)

   329             , width(0)

   330             , m_type(type)

   331             , noPaint(false)

   332         {

   333         }

   334 

   335         Type type() { return static_cast<Type>(m_type); }

   336 

   337         RenderObject* node;

   338         int startY;

   339         int endY;

   340         int left;

   341         int width;

   342         unsigned m_type : 1; // Type (left or right aligned)

   343         bool noPaint : 1;

   344     };

   345 

   346     // The following helper functions and structs are used by layoutBlockChildren.

   347     class CompactInfo {

   348         // A compact child that needs to be collapsed into the margin of the following block.

   349         RenderObject* m_compact;

   350 

   351         // The block with the open margin that the compact child is going to place itself within.

   352         RenderObject* m_block;

   353 

   354     public:

   355         RenderObject* compact() const { return m_compact; }

   356         RenderObject* block() const { return m_block; }

   357         bool matches(RenderObject* child) const { return m_compact && m_block == child; }

   358 

   359         void clear() { set(0, 0); }

   360         void set(RenderObject* c, RenderObject* b) { m_compact = c; m_block = b; }

   361 

   362         CompactInfo() { clear(); }

   363     };

   364 

   365     class MarginInfo {

   366         // Collapsing flags for whether we can collapse our margins with our children's margins.

   367         bool m_canCollapseWithChildren : 1;

   368         bool m_canCollapseTopWithChildren : 1;

   369         bool m_canCollapseBottomWithChildren : 1;

   370 

   371         // Whether or not we are a quirky container, i.e., do we collapse away top and bottom

   372         // margins in our container.  Table cells and the body are the common examples. We

   373         // also have a custom style property for Safari RSS to deal with TypePad blog articles.

   374         bool m_quirkContainer : 1;

   375 

   376         // This flag tracks whether we are still looking at child margins that can all collapse together at the beginning of a block.  

   377         // They may or may not collapse with the top margin of the block (|m_canCollapseTopWithChildren| tells us that), but they will

   378         // always be collapsing with one another.  This variable can remain set to true through multiple iterations 

   379         // as long as we keep encountering self-collapsing blocks.

   380         bool m_atTopOfBlock : 1;

   381 

   382         // This flag is set when we know we're examining bottom margins and we know we're at the bottom of the block.

   383         bool m_atBottomOfBlock : 1;

   384 

   385         // If our last normal flow child was a self-collapsing block that cleared a float,

   386         // we track it in this variable.

   387         bool m_selfCollapsingBlockClearedFloat : 1;

   388 

   389         // These variables are used to detect quirky margins that we need to collapse away (in table cells

   390         // and in the body element).

   391         bool m_topQuirk : 1;

   392         bool m_bottomQuirk : 1;

   393         bool m_determinedTopQuirk : 1;

   394 

   395         // These flags track the previous maximal positive and negative margins.

   396         int m_posMargin;

   397         int m_negMargin;

   398 

   399     public:

   400         MarginInfo(RenderBlock* b, int top, int bottom);

   401 

   402         void setAtTopOfBlock(bool b) { m_atTopOfBlock = b; }

   403         void setAtBottomOfBlock(bool b) { m_atBottomOfBlock = b; }

   404         void clearMargin() { m_posMargin = m_negMargin = 0; }

   405         void setSelfCollapsingBlockClearedFloat(bool b) { m_selfCollapsingBlockClearedFloat = b; }

   406         void setTopQuirk(bool b) { m_topQuirk = b; }

   407         void setBottomQuirk(bool b) { m_bottomQuirk = b; }

   408         void setDeterminedTopQuirk(bool b) { m_determinedTopQuirk = b; }

   409         void setPosMargin(int p) { m_posMargin = p; }

   410         void setNegMargin(int n) { m_negMargin = n; }

   411         void setPosMarginIfLarger(int p) { if (p > m_posMargin) m_posMargin = p; }

   412         void setNegMarginIfLarger(int n) { if (n > m_negMargin) m_negMargin = n; }

   413 

   414         void setMargin(int p, int n) { m_posMargin = p; m_negMargin = n; }

   415 

   416         bool atTopOfBlock() const { return m_atTopOfBlock; }

   417         bool canCollapseWithTop() const { return m_atTopOfBlock && m_canCollapseTopWithChildren; }

   418         bool canCollapseWithBottom() const { return m_atBottomOfBlock && m_canCollapseBottomWithChildren; }

   419         bool canCollapseTopWithChildren() const { return m_canCollapseTopWithChildren; }

   420         bool canCollapseBottomWithChildren() const { return m_canCollapseBottomWithChildren; }

   421         bool selfCollapsingBlockClearedFloat() const { return m_selfCollapsingBlockClearedFloat; }

   422         bool quirkContainer() const { return m_quirkContainer; }

   423         bool determinedTopQuirk() const { return m_determinedTopQuirk; }

   424         bool topQuirk() const { return m_topQuirk; }

   425         bool bottomQuirk() const { return m_bottomQuirk; }

   426         int posMargin() const { return m_posMargin; }

   427         int negMargin() const { return m_negMargin; }

   428         int margin() const { return m_posMargin - m_negMargin; }

   429     };

   430 

   431     void adjustPositionedBlock(RenderObject* child, const MarginInfo&);

   432     void adjustFloatingBlock(const MarginInfo&);

   433     RenderObject* handleSpecialChild(RenderObject* child, const MarginInfo&, CompactInfo&, bool& handled);

   434     RenderObject* handleFloatingChild(RenderObject* child, const MarginInfo&, bool& handled);

   435     RenderObject* handlePositionedChild(RenderObject* child, const MarginInfo&, bool& handled);

   436     RenderObject* handleCompactChild(RenderObject* child, CompactInfo&, bool& handled);

   437     RenderObject* handleRunInChild(RenderObject* child, bool& handled);

   438     void collapseMargins(RenderObject* child, MarginInfo&, int yPosEstimate);

   439     void clearFloatsIfNeeded(RenderObject* child, MarginInfo&, int oldTopPosMargin, int oldTopNegMargin);

   440     void insertCompactIfNeeded(RenderObject* child, CompactInfo&);

   441     int estimateVerticalPosition(RenderObject* child, const MarginInfo&);

   442     void determineHorizontalPosition(RenderObject* child);

   443     void handleBottomOfBlock(int top, int bottom, MarginInfo&);

   444     void setCollapsedBottomMargin(const MarginInfo&);

   445     // End helper functions and structs used by layoutBlockChildren.

   446 

   447 private:

   448     typedef ListHashSet<RenderObject*>::const_iterator Iterator;

   449     DeprecatedPtrList<FloatingObject>* m_floatingObjects;

   450     ListHashSet<RenderObject*>* m_positionedObjects;

   451          

   452      // Allocated only when some of these fields have non-default values

   453      struct MaxMargin {

   454          MaxMargin(const RenderBlock* o) 

   455              : m_topPos(topPosDefault(o))

   456              , m_topNeg(topNegDefault(o))

   457              , m_bottomPos(bottomPosDefault(o))

   458              , m_bottomNeg(bottomNegDefault(o))

   459              { 

   460              }

   461          static int topPosDefault(const RenderBlock* o) { return o->marginTop() > 0 ? o->marginTop() : 0; }

   462          static int topNegDefault(const RenderBlock* o) { return o->marginTop() < 0 ? -o->marginTop() : 0; }

   463          static int bottomPosDefault(const RenderBlock* o) { return o->marginBottom() > 0 ? o->marginBottom() : 0; }

   464          static int bottomNegDefault(const RenderBlock* o) { return o->marginBottom() < 0 ? -o->marginBottom() : 0; }

   465          

   466          int m_topPos;

   467          int m_topNeg;

   468          int m_bottomPos;

   469          int m_bottomNeg;

   470      };

   471 

   472     MaxMargin* m_maxMargin;

   473 

   474 protected:

   475     // How much content overflows out of our block vertically or horizontally.

   476     int m_overflowHeight;

   477     int m_overflowWidth;

   478     int m_overflowLeft;

   479     int m_overflowTop;

   480 };

   481 

   482 } // namespace WebCore

   483 

   484 #endif // RenderBlock_h