#ifndef RenderBlock_h
#define RenderBlock_h
#include "DeprecatedPtrList.h"
#include "GapRects.h"
#include "RenderFlow.h"
#include "RootInlineBox.h"
#include <wtf/ListHashSet.h>
namespace WebCore {
class InlineIterator;
class BidiRun;
class Position;
class RootInlineBox;
template <class Iterator, class Run> class BidiResolver;
typedef BidiResolver<InlineIterator, BidiRun> InlineBidiResolver;
enum CaretType { CursorCaret, DragCaret };
class RenderBlock : public RenderFlow {
public:
RenderBlock(Node*);
virtual ~RenderBlock();
virtual const char* renderName() const;
virtual int lineHeight(bool firstLine, bool isRootLineBox = false) const;
virtual int baselinePosition(bool firstLine, bool isRootLineBox = false) const;
virtual bool isRenderBlock() const { return true; }
virtual bool isBlockFlow() const { return (!isInline() || isReplaced()) && !isTable(); }
virtual bool isInlineBlockOrInlineTable() const { return isInline() && isReplaced(); }
virtual bool childrenInline() const { return m_childrenInline; }
virtual void setChildrenInline(bool b) { m_childrenInline = b; }
void makeChildrenNonInline(RenderObject* insertionPoint = 0);
void deleteLineBoxTree();
virtual int overflowHeight(bool includeInterior = true) const;
virtual int overflowWidth(bool includeInterior = true) const;
virtual int overflowLeft(bool includeInterior = true) const;
virtual int overflowTop(bool includeInterior = true) const;
virtual IntRect overflowRect(bool includeInterior = true) const;
virtual void setOverflowHeight(int h) { m_overflowHeight = h; }
virtual void setOverflowWidth(int w) { m_overflowWidth = w; }
void addVisualOverflow(const IntRect&);
virtual bool isSelfCollapsingBlock() const;
virtual bool isTopMarginQuirk() const { return m_topMarginQuirk; }
virtual bool isBottomMarginQuirk() const { return m_bottomMarginQuirk; }
virtual int maxTopMargin(bool positive) const { return positive ? maxTopPosMargin() : maxTopNegMargin(); }
virtual int maxBottomMargin(bool positive) const { return positive ? maxBottomPosMargin() : maxBottomNegMargin(); }
int maxTopPosMargin() const { return m_maxMargin ? m_maxMargin->m_topPos : MaxMargin::topPosDefault(this); }
int maxTopNegMargin() const { return m_maxMargin ? m_maxMargin->m_topNeg : MaxMargin::topNegDefault(this); }
int maxBottomPosMargin() const { return m_maxMargin ? m_maxMargin->m_bottomPos : MaxMargin::bottomPosDefault(this); }
int maxBottomNegMargin() const { return m_maxMargin ? m_maxMargin->m_bottomNeg : MaxMargin::bottomNegDefault(this); }
void setMaxTopMargins(int pos, int neg);
void setMaxBottomMargins(int pos, int neg);
void initMaxMarginValues()
{
if (m_maxMargin) {
m_maxMargin->m_topPos = MaxMargin::topPosDefault(this);
m_maxMargin->m_topNeg = MaxMargin::topNegDefault(this);
m_maxMargin->m_bottomPos = MaxMargin::bottomPosDefault(this);
m_maxMargin->m_bottomNeg = MaxMargin::bottomNegDefault(this);
}
}
virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild);
virtual void removeChild(RenderObject*);
virtual void repaintOverhangingFloats(bool paintAllDescendants);
virtual void layout();
virtual void layoutBlock(bool relayoutChildren);
void layoutBlockChildren(bool relayoutChildren, int& maxFloatBottom);
void layoutInlineChildren(bool relayoutChildren, int& repaintTop, int& repaintBottom);
void layoutPositionedObjects(bool relayoutChildren);
void insertPositionedObject(RenderBox*);
void removePositionedObject(RenderBox*);
void removePositionedObjects(RenderBlock*);
void addPercentHeightDescendant(RenderBox*);
static void removePercentHeightDescendant(RenderBox*);
virtual void positionListMarker() { }
virtual void borderFitAdjust(int& x, int& w) const;
virtual RenderObject* layoutLegend(bool ) { return 0; }
struct FloatWithRect {
FloatWithRect(RenderBox* f)
: object(f)
, rect(IntRect(f->x() - f->marginLeft(), f->y() - f->marginTop(), f->width() + f->marginLeft() + f->marginRight(), f->height() + f->marginTop() + f->marginBottom()))
{
}
RenderBox* object;
IntRect rect;
};
void bidiReorderLine(InlineBidiResolver&, const InlineIterator& end);
RootInlineBox* determineStartPosition(bool& fullLayout, InlineBidiResolver&, Vector<FloatWithRect>& floats, unsigned& numCleanFloats);
RootInlineBox* determineEndPosition(RootInlineBox* startBox, InlineIterator& cleanLineStart,
BidiStatus& cleanLineBidiStatus,
int& yPos);
bool matchedEndLine(const InlineBidiResolver&, const InlineIterator& endLineStart, const BidiStatus& endLineStatus,
RootInlineBox*& endLine, int& endYPos, int& repaintBottom, int& repaintTop);
bool generatesLineBoxesForInlineChild(RenderObject*);
void skipTrailingWhitespace(InlineIterator&);
int skipLeadingWhitespace(InlineBidiResolver&);
void fitBelowFloats(int widthToFit, int& availableWidth);
InlineIterator findNextLineBreak(InlineBidiResolver&, EClear* clear = 0);
RootInlineBox* constructLine(unsigned runCount, BidiRun* firstRun, BidiRun* lastRun, bool lastLine, RenderObject* endObject);
InlineFlowBox* createLineBoxes(RenderObject*);
void computeHorizontalPositionsForLine(RootInlineBox*, BidiRun* firstRun, BidiRun* trailingSpaceRun, bool reachedEnd);
void computeVerticalPositionsForLine(RootInlineBox*, BidiRun*);
void checkLinesForOverflow();
void deleteEllipsisLineBoxes();
void checkLinesForTextOverflow();
virtual void paint(PaintInfo&, int tx, int ty);
virtual void paintObject(PaintInfo&, int tx, int ty);
void paintFloats(PaintInfo&, int tx, int ty, bool preservePhase = false);
void paintContents(PaintInfo&, int tx, int ty);
void paintColumns(PaintInfo&, int tx, int ty, bool paintFloats = false);
void paintChildren(PaintInfo&, int tx, int ty);
void paintEllipsisBoxes(PaintInfo&, int tx, int ty);
void paintSelection(PaintInfo&, int tx, int ty);
void paintCaret(PaintInfo&, int tx, int ty, CaretType);
void insertFloatingObject(RenderBox*);
void removeFloatingObject(RenderBox*);
bool positionNewFloats();
void clearFloats();
int getClearDelta(RenderBox* child);
void markAllDescendantsWithFloatsForLayout(RenderBox* floatToRemove = 0, bool inLayout = true);
void markPositionedObjectsForLayout();
virtual bool containsFloats() { return m_floatingObjects && !m_floatingObjects->isEmpty(); }
virtual bool containsFloat(RenderObject*);
virtual bool avoidsFloats() const;
virtual bool hasOverhangingFloats() { return !hasColumns() && floatBottom() > height(); }
void addIntrudingFloats(RenderBlock* prev, int xoffset, int yoffset);
int addOverhangingFloats(RenderBlock* child, int xoffset, int yoffset, bool makeChildPaintOtherFloats);
int nextFloatBottomBelow(int) const;
int floatBottom() const;
inline int leftBottom();
inline int rightBottom();
IntRect floatRect() const;
virtual int lineWidth(int) const;
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;
int rightOffset() const;
int rightRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
int rightOffset(int y) const { return rightRelOffset(y, rightOffset(), true); }
int leftOffset() const;
int leftRelOffset(int y, int fixedOffset, bool applyTextIndent = true, int* heightRemaining = 0) const;
int leftOffset(int y) const { return leftRelOffset(y, leftOffset(), true); }
virtual bool nodeAtPoint(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
virtual bool hitTestColumns(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
virtual bool hitTestContents(const HitTestRequest&, HitTestResult&, int x, int y, int tx, int ty, HitTestAction);
virtual bool isPointInOverflowControl(HitTestResult&, int x, int y, int tx, int ty);
virtual VisiblePosition positionForCoordinates(int x, int y);
virtual int availableWidth() const;
virtual void calcPrefWidths();
void calcInlinePrefWidths();
void calcBlockPrefWidths();
virtual int getBaselineOfFirstLineBox() const;
virtual int getBaselineOfLastLineBox() const;
RootInlineBox* firstRootBox() const { return static_cast<RootInlineBox*>(firstLineBox()); }
RootInlineBox* lastRootBox() const { return static_cast<RootInlineBox*>(lastLineBox()); }
bool containsNonZeroBidiLevel() const;
virtual RenderBlock* firstLineBlock() const;
virtual void updateFirstLetter();
bool inRootBlockContext() const;
void setHasMarkupTruncation(bool b = true) { m_hasMarkupTruncation = b; }
bool hasMarkupTruncation() const { return m_hasMarkupTruncation; }
virtual bool hasSelectedChildren() const { return m_selectionState != SelectionNone; }
virtual SelectionState selectionState() const { return static_cast<SelectionState>(m_selectionState); }
virtual void setSelectionState(SelectionState s);
virtual IntRect selectionRectForRepaint(RenderBox* repaintContainer, bool )
{
return selectionGapRectsForRepaint(repaintContainer);
}
GapRects selectionGapRectsForRepaint(RenderBox* repaintContainer);
virtual bool shouldPaintSelectionGaps() const;
bool isSelectionRoot() const;
GapRects fillSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,
int& lastTop, int& lastLeft, int& lastRight, const PaintInfo* = 0);
GapRects fillInlineSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,
int& lastTop, int& lastLeft, int& lastRight, const PaintInfo*);
GapRects fillBlockSelectionGaps(RenderBlock* rootBlock, int blockX, int blockY, int tx, int ty,
int& lastTop, int& lastLeft, int& lastRight, const PaintInfo*);
IntRect fillVerticalSelectionGap(int lastTop, int lastLeft, int lastRight, int bottomY, RenderBlock* rootBlock,
int blockX, int blockY, const PaintInfo*);
IntRect fillLeftSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock,
int blockX, int blockY, int tx, int ty, const PaintInfo*);
IntRect fillRightSelectionGap(RenderObject* selObj, int xPos, int yPos, int height, RenderBlock* rootBlock,
int blockX, int blockY, int tx, int ty, const PaintInfo*);
IntRect fillHorizontalSelectionGap(RenderObject* selObj, int xPos, int yPos, int width, int height, const PaintInfo*);
void getHorizontalSelectionGapInfo(SelectionState, bool& leftGap, bool& rightGap);
int leftSelectionOffset(RenderBlock* rootBlock, int y);
int rightSelectionOffset(RenderBlock* rootBlock, int y);
RootInlineBox* lineAtIndex(int);
int lineCount();
int heightForLineCount(int);
void clearTruncation();
int immediateLineCount();
void adjustComputedFontSizes(float size, float visibleWidth);
void resetComputedFontSize() {
m_widthForTextAutosizing = -1;
m_lineCountForTextAutosizing = NOT_SET;
}
int desiredColumnWidth() const;
unsigned desiredColumnCount() const;
Vector<IntRect>* columnRects() const;
void setDesiredColumnCountAndWidth(int count, int width);
void adjustRectForColumns(IntRect&) const;
void addContinuationWithOutline(RenderFlow*);
void paintContinuationOutlines(PaintInfo&, int tx, int ty);
private:
void adjustPointToColumnContents(IntPoint&) const;
void adjustForBorderFit(int x, int& left, int& right) const;
void markLinesDirtyInVerticalRange(int top, int bottom);
protected:
virtual void styleWillChange(StyleDifference, const RenderStyle* newStyle);
virtual void styleDidChange(StyleDifference, const RenderStyle* oldStyle);
void newLine(EClear);
virtual bool hasLineIfEmpty() const;
bool layoutOnlyPositionedObjects();
private:
Position positionForBox(InlineBox*, bool start = true) const;
Position positionForRenderer(RenderObject*, bool start = true) const;
void offsetForContents(int& tx, int& ty) const;
int columnGap() const;
void calcColumnWidth();
int layoutColumns(int endOfContent = -1);
bool expandsToEncloseOverhangingFloats() const;
protected:
struct FloatingObject {
enum Type {
FloatLeft,
FloatRight
};
FloatingObject(Type type)
: m_renderer(0)
, m_top(0)
, m_bottom(0)
, m_left(0)
, m_width(0)
, m_type(type)
, m_shouldPaint(true)
, m_isDescendant(false)
{
}
Type type() { return static_cast<Type>(m_type); }
RenderBox* m_renderer;
int m_top;
int m_bottom;
int m_left;
int m_width;
unsigned m_type : 1; bool m_shouldPaint : 1;
bool m_isDescendant : 1;
};
class MarginInfo {
bool m_canCollapseWithChildren : 1;
bool m_canCollapseTopWithChildren : 1;
bool m_canCollapseBottomWithChildren : 1;
bool m_quirkContainer : 1;
bool m_atTopOfBlock : 1;
bool m_atBottomOfBlock : 1;
bool m_selfCollapsingBlockClearedFloat : 1;
bool m_topQuirk : 1;
bool m_bottomQuirk : 1;
bool m_determinedTopQuirk : 1;
int m_posMargin;
int m_negMargin;
public:
MarginInfo(RenderBlock* b, int top, int bottom);
void setAtTopOfBlock(bool b) { m_atTopOfBlock = b; }
void setAtBottomOfBlock(bool b) { m_atBottomOfBlock = b; }
void clearMargin() { m_posMargin = m_negMargin = 0; }
void setSelfCollapsingBlockClearedFloat(bool b) { m_selfCollapsingBlockClearedFloat = b; }
void setTopQuirk(bool b) { m_topQuirk = b; }
void setBottomQuirk(bool b) { m_bottomQuirk = b; }
void setDeterminedTopQuirk(bool b) { m_determinedTopQuirk = b; }
void setPosMargin(int p) { m_posMargin = p; }
void setNegMargin(int n) { m_negMargin = n; }
void setPosMarginIfLarger(int p) { if (p > m_posMargin) m_posMargin = p; }
void setNegMarginIfLarger(int n) { if (n > m_negMargin) m_negMargin = n; }
void setMargin(int p, int n) { m_posMargin = p; m_negMargin = n; }
bool atTopOfBlock() const { return m_atTopOfBlock; }
bool canCollapseWithTop() const { return m_atTopOfBlock && m_canCollapseTopWithChildren; }
bool canCollapseWithBottom() const { return m_atBottomOfBlock && m_canCollapseBottomWithChildren; }
bool canCollapseTopWithChildren() const { return m_canCollapseTopWithChildren; }
bool canCollapseBottomWithChildren() const { return m_canCollapseBottomWithChildren; }
bool selfCollapsingBlockClearedFloat() const { return m_selfCollapsingBlockClearedFloat; }
bool quirkContainer() const { return m_quirkContainer; }
bool determinedTopQuirk() const { return m_determinedTopQuirk; }
bool topQuirk() const { return m_topQuirk; }
bool bottomQuirk() const { return m_bottomQuirk; }
int posMargin() const { return m_posMargin; }
int negMargin() const { return m_negMargin; }
int margin() const { return m_posMargin - m_negMargin; }
};
void adjustPositionedBlock(RenderBox* child, const MarginInfo&);
void adjustFloatingBlock(const MarginInfo&);
RenderBox* handleSpecialChild(RenderBox* child, const MarginInfo&, bool& handled);
RenderBox* handleFloatingChild(RenderBox* child, const MarginInfo&, bool& handled);
RenderBox* handlePositionedChild(RenderBox* child, const MarginInfo&, bool& handled);
RenderBox* handleRunInChild(RenderBox* child, bool& handled);
void collapseMargins(RenderBox* child, MarginInfo&, int yPosEstimate);
void clearFloatsIfNeeded(RenderBox* child, MarginInfo&, int oldTopPosMargin, int oldTopNegMargin);
int estimateVerticalPosition(RenderBox* child, const MarginInfo&);
void determineHorizontalPosition(RenderBox* child);
void handleBottomOfBlock(int top, int bottom, MarginInfo&);
void setCollapsedBottomMargin(const MarginInfo&);
private:
typedef ListHashSet<RenderBox*>::const_iterator Iterator;
DeprecatedPtrList<FloatingObject>* m_floatingObjects;
ListHashSet<RenderBox*>* m_positionedObjects;
struct MaxMargin {
MaxMargin(const RenderBlock* o)
: m_topPos(topPosDefault(o))
, m_topNeg(topNegDefault(o))
, m_bottomPos(bottomPosDefault(o))
, m_bottomNeg(bottomNegDefault(o))
{
}
static int topPosDefault(const RenderBlock* o) { return o->marginTop() > 0 ? o->marginTop() : 0; }
static int topNegDefault(const RenderBlock* o) { return o->marginTop() < 0 ? -o->marginTop() : 0; }
static int bottomPosDefault(const RenderBlock* o) { return o->marginBottom() > 0 ? o->marginBottom() : 0; }
static int bottomNegDefault(const RenderBlock* o) { return o->marginBottom() < 0 ? -o->marginBottom() : 0; }
int m_topPos;
int m_topNeg;
int m_bottomPos;
int m_bottomNeg;
};
MaxMargin* m_maxMargin;
protected:
int m_overflowHeight;
int m_overflowWidth;
int m_overflowLeft;
int m_overflowTop;
int m_widthForTextAutosizing;
};
}
#endif // RenderBlock_h