<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.1//EN"
"http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head><meta http-equiv="content-type" content="text/html; charset=utf-8" /><style type="text/css"><!--
#msg dl { border: 1px #006 solid; background: #369; padding: 6px; color: #fff; }
#msg dt { float: left; width: 6em; font-weight: bold; }
#msg dt:after { content:':';}
#msg dl, #msg dt, #msg ul, #msg li, #header, #footer { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; }
#msg dl a { font-weight: bold}
#msg dl a:link { color:#fc3; }
#msg dl a:active { color:#ff0; }
#msg dl a:visited { color:#cc6; }
h3 { font-family: verdana,arial,helvetica,sans-serif; font-size: 10pt; font-weight: bold; }
#msg pre { overflow: auto; background: #ffc; border: 1px #fc0 solid; padding: 6px; }
#msg ul, pre { overflow: auto; }
#header, #footer { color: #fff; background: #636; border: 1px #300 solid; padding: 6px; }
#patch { width: 100%; }
#patch h4 {font-family: verdana,arial,helvetica,sans-serif;font-size:10pt;padding:8px;background:#369;color:#fff;margin:0;}
#patch .propset h4, #patch .binary h4 {margin:0;}
#patch pre {padding:0;line-height:1.2em;margin:0;}
#patch .diff {width:100%;background:#eee;padding: 0 0 10px 0;overflow:auto;}
#patch .propset .diff, #patch .binary .diff {padding:10px 0;}
#patch span {display:block;padding:0 10px;}
#patch .modfile, #patch .addfile, #patch .delfile, #patch .propset, #patch .binary, #patch .copfile {border:1px solid #ccc;margin:10px 0;}
#patch ins {background:#dfd;text-decoration:none;display:block;padding:0 10px;}
#patch del {background:#fdd;text-decoration:none;display:block;padding:0 10px;}
#patch .lines, .info {color:#888;background:#fff;}
--></style>
<title>[20673] trunk/WebCore</title>
</head>
<body>
<div id="msg">
<dl>
<dt>Revision</dt> <dd><a href="http://trac.webkit.org/projects/webkit/changeset/20673">20673</a></dd>
<dt>Author</dt> <dd>antti</dd>
<dt>Date</dt> <dd>2007-04-02 18:01:09 -0700 (Mon, 02 Apr 2007)</dd>
</dl>
<h3>Log Message</h3>
<pre> Reviewed by Hyatt.
Render tree memory savings, part 3
These changes shrink all RenderBlocks by additional 28 bytes. Together with parts 1 and 2
RenderBlock goes from 172 bytes to 128 bytes, a saving of 26%.
- Pack bitfields together in RenderFlow
- Move top/bottom min/max margin values to a struct that is only allocated in case these
variables have non default values. Usually this is <5% of all blocks.
- Move rarely used column variables to hash
* rendering/RenderBlock.cpp:
(WebCore::ColumnInfo::ColumnInfo):
(WebCore::RenderBlock::RenderBlock):
(WebCore::RenderBlock::~RenderBlock):
(WebCore::RenderBlock::layoutBlock):
(WebCore::RenderBlock::collapseMargins):
(WebCore::RenderBlock::clearFloatsIfNeeded):
(WebCore::RenderBlock::setCollapsedBottomMargin):
(WebCore::RenderBlock::layoutBlockChildren):
(WebCore::RenderBlock::paintColumns):
(WebCore::RenderBlock::paintObject):
(WebCore::RenderBlock::fillSelectionGaps):
(WebCore::RenderBlock::lowestPosition):
(WebCore::RenderBlock::rightmostPosition):
(WebCore::RenderBlock::leftmostPosition):
(WebCore::RenderBlock::nodeAtPoint):
(WebCore::RenderBlock::hitTestColumns):
(WebCore::RenderBlock::positionForCoordinates):
(WebCore::RenderBlock::availableWidth):
(WebCore::RenderBlock::calcColumnWidth):
(WebCore::RenderBlock::setDesiredColumnCountAndWidth):
(WebCore::RenderBlock::desiredColumnWidth):
(WebCore::RenderBlock::desiredColumnCount):
(WebCore::RenderBlock::columnRects):
(WebCore::RenderBlock::layoutColumns):
(WebCore::RenderBlock::adjustPointToColumnContents):
(WebCore::RenderBlock::adjustRectForColumns):
(WebCore::RenderBlock::setMaxTopMargins):
(WebCore::RenderBlock::setMaxBottomMargins):
* rendering/RenderBlock.h:
(WebCore::RenderBlock::maxTopMargin):
(WebCore::RenderBlock::maxBottomMargin):
(WebCore::RenderBlock::maxTopPosMargin):
(WebCore::RenderBlock::maxTopNegMargin):
(WebCore::RenderBlock::maxBottomPosMargin):
(WebCore::RenderBlock::maxBottomNegMargin):
(WebCore::RenderBlock::initMaxMarginValues):
(WebCore::RenderBlock::MaxMargin::MaxMargin):
(WebCore::RenderBlock::MaxMargin::topPosDefault):
(WebCore::RenderBlock::MaxMargin::topNegDefault):
(WebCore::RenderBlock::MaxMargin::bottomPosDefault):
(WebCore::RenderBlock::MaxMargin::bottomNegDefault):
* rendering/RenderFlexibleBox.cpp:
(WebCore::RenderFlexibleBox::layoutBlock):
* rendering/RenderFlow.h:
(WebCore::RenderFlow::RenderFlow):
(WebCore::RenderFlow::hasColumns):
* rendering/RenderInline.cpp:
(WebCore::RenderInline::RenderInline):
* rendering/RenderInline.h:</pre>
<h3>Modified Paths</h3>
<ul>
<li><a href="#trunkWebCoreChangeLog">trunk/WebCore/ChangeLog</a></li>
<li><a href="#trunkWebCorerenderingRenderBlockcpp">trunk/WebCore/rendering/RenderBlock.cpp</a></li>
<li><a href="#trunkWebCorerenderingRenderBlockh">trunk/WebCore/rendering/RenderBlock.h</a></li>
<li><a href="#trunkWebCorerenderingRenderFlexibleBoxcpp">trunk/WebCore/rendering/RenderFlexibleBox.cpp</a></li>
<li><a href="#trunkWebCorerenderingRenderFlowh">trunk/WebCore/rendering/RenderFlow.h</a></li>
<li><a href="#trunkWebCorerenderingRenderInlinecpp">trunk/WebCore/rendering/RenderInline.cpp</a></li>
<li><a href="#trunkWebCorerenderingRenderInlineh">trunk/WebCore/rendering/RenderInline.h</a></li>
</ul>
</div>
<div id="patch">
<h3>Diff</h3>
<a id="trunkWebCoreChangeLog"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/ChangeLog (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/ChangeLog 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/ChangeLog 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -2,6 +2,71 @@
</span><span class="cx">
</span><span class="cx"> Reviewed by Hyatt.
</span><span class="cx">
</span><ins>+ Render tree memory savings, part 3
+
+ These changes shrink all RenderBlocks by additional 28 bytes. Together with parts 1 and 2
+ RenderBlock goes from 172 bytes to 128 bytes, a saving of 26%.
+
+ - Pack bitfields together in RenderFlow
+ - Move top/bottom min/max margin values to a struct that is only allocated in case these
+ variables have non default values. Usually this is <5% of all blocks.
+ - Move rarely used column variables to hash
+
+ * rendering/RenderBlock.cpp:
+ (WebCore::ColumnInfo::ColumnInfo):
+ (WebCore::RenderBlock::RenderBlock):
+ (WebCore::RenderBlock::~RenderBlock):
+ (WebCore::RenderBlock::layoutBlock):
+ (WebCore::RenderBlock::collapseMargins):
+ (WebCore::RenderBlock::clearFloatsIfNeeded):
+ (WebCore::RenderBlock::setCollapsedBottomMargin):
+ (WebCore::RenderBlock::layoutBlockChildren):
+ (WebCore::RenderBlock::paintColumns):
+ (WebCore::RenderBlock::paintObject):
+ (WebCore::RenderBlock::fillSelectionGaps):
+ (WebCore::RenderBlock::lowestPosition):
+ (WebCore::RenderBlock::rightmostPosition):
+ (WebCore::RenderBlock::leftmostPosition):
+ (WebCore::RenderBlock::nodeAtPoint):
+ (WebCore::RenderBlock::hitTestColumns):
+ (WebCore::RenderBlock::positionForCoordinates):
+ (WebCore::RenderBlock::availableWidth):
+ (WebCore::RenderBlock::calcColumnWidth):
+ (WebCore::RenderBlock::setDesiredColumnCountAndWidth):
+ (WebCore::RenderBlock::desiredColumnWidth):
+ (WebCore::RenderBlock::desiredColumnCount):
+ (WebCore::RenderBlock::columnRects):
+ (WebCore::RenderBlock::layoutColumns):
+ (WebCore::RenderBlock::adjustPointToColumnContents):
+ (WebCore::RenderBlock::adjustRectForColumns):
+ (WebCore::RenderBlock::setMaxTopMargins):
+ (WebCore::RenderBlock::setMaxBottomMargins):
+ * rendering/RenderBlock.h:
+ (WebCore::RenderBlock::maxTopMargin):
+ (WebCore::RenderBlock::maxBottomMargin):
+ (WebCore::RenderBlock::maxTopPosMargin):
+ (WebCore::RenderBlock::maxTopNegMargin):
+ (WebCore::RenderBlock::maxBottomPosMargin):
+ (WebCore::RenderBlock::maxBottomNegMargin):
+ (WebCore::RenderBlock::initMaxMarginValues):
+ (WebCore::RenderBlock::MaxMargin::MaxMargin):
+ (WebCore::RenderBlock::MaxMargin::topPosDefault):
+ (WebCore::RenderBlock::MaxMargin::topNegDefault):
+ (WebCore::RenderBlock::MaxMargin::bottomPosDefault):
+ (WebCore::RenderBlock::MaxMargin::bottomNegDefault):
+ * rendering/RenderFlexibleBox.cpp:
+ (WebCore::RenderFlexibleBox::layoutBlock):
+ * rendering/RenderFlow.h:
+ (WebCore::RenderFlow::RenderFlow):
+ (WebCore::RenderFlow::hasColumns):
+ * rendering/RenderInline.cpp:
+ (WebCore::RenderInline::RenderInline):
+ * rendering/RenderInline.h:
+
+2007-04-03 Antti Koivisto <antti@apple.com>
+
+ Reviewed by Hyatt.
+
</ins><span class="cx"> Fix asserts, these may also be called for rel positioned elements
</span><span class="cx">
</span><span class="cx"> * rendering/RenderBox.cpp:
</span></span></pre></div>
<a id="trunkWebCorerenderingRenderBlockcpp"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/rendering/RenderBlock.cpp (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/rendering/RenderBlock.cpp 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/rendering/RenderBlock.cpp 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -52,6 +52,19 @@
</span><span class="cx">
</span><span class="cx"> using namespace HTMLNames;
</span><span class="cx">
</span><ins>+struct ColumnInfo {
+ ColumnInfo()
+ : m_desiredColumnWidth(0)
+ , m_desiredColumnCount(1)
+ { }
+ int m_desiredColumnWidth;
+ unsigned m_desiredColumnCount;
+ Vector<IntRect> m_columnRects;
+};
+
+typedef WTF::HashMap<const RenderBox*, ColumnInfo*> ColumnInfoMap;
+static ColumnInfoMap* gColumnInfoMap = 0;
+
</ins><span class="cx"> // Our MarginInfo state used when laying out block children.
</span><span class="cx"> RenderBlock::MarginInfo::MarginInfo(RenderBlock* block, int top, int bottom)
</span><span class="cx"> {
</span><span class="lines">@@ -87,29 +100,28 @@
</span><span class="cx"> // -------------------------------------------------------------------------------------------------------
</span><span class="cx">
</span><span class="cx"> RenderBlock::RenderBlock(Node* node)
</span><del>-:RenderFlow(node)
</del><ins>+ : RenderFlow(node)
+ , m_floatingObjects(0)
+ , m_positionedObjects(0)
+ , m_maxMargin(0)
+ , m_overflowHeight(0)
+ , m_overflowWidth(0)
+ , m_overflowLeft(0)
+ , m_overflowTop(0)
</ins><span class="cx"> {
</span><del>- m_childrenInline = true;
- m_floatingObjects = 0;
- m_positionedObjects = 0;
- m_firstLine = false;
- m_hasMarkupTruncation = false;
- m_selectionState = SelectionNone;
- m_clearStatus = CNONE;
- m_maxTopPosMargin = m_maxTopNegMargin = m_maxBottomPosMargin = m_maxBottomNegMargin = 0;
- m_topMarginQuirk = m_bottomMarginQuirk = false;
- m_overflowHeight = m_overflowWidth = 0;
- m_overflowLeft = m_overflowTop = 0;
- m_desiredColumnCount = 1;
- m_desiredColumnWidth = 0;
- m_columnRects = 0;
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> RenderBlock::~RenderBlock()
</span><span class="cx"> {
</span><span class="cx"> delete m_floatingObjects;
</span><span class="cx"> delete m_positionedObjects;
</span><del>- delete m_columnRects;
</del><ins>+ delete m_maxMargin;
+
+ if (m_hasColumns) {
+ ColumnInfoMap::iterator it = gColumnInfoMap->find(this);
+ delete it->second;
+ gColumnInfoMap->remove(it);
+ }
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> void RenderBlock::setStyle(RenderStyle* _style)
</span><span class="lines">@@ -494,7 +506,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> int oldWidth = m_width;
</span><del>- int oldColumnWidth = m_desiredColumnWidth;
</del><ins>+ int oldColumnWidth = desiredColumnWidth();
</ins><span class="cx">
</span><span class="cx"> calcWidth();
</span><span class="cx"> calcColumnWidth();
</span><span class="lines">@@ -502,7 +514,7 @@
</span><span class="cx"> m_overflowWidth = m_width;
</span><span class="cx"> m_overflowLeft = 0;
</span><span class="cx">
</span><del>- if (oldWidth != m_width || oldColumnWidth != m_desiredColumnWidth)
</del><ins>+ if (oldWidth != m_width || oldColumnWidth != desiredColumnWidth())
</ins><span class="cx"> relayoutChildren = true;
</span><span class="cx">
</span><span class="cx"> clearFloats();
</span><span class="lines">@@ -531,7 +543,7 @@
</span><span class="cx"> if (element() && element()->hasTagName(formTag) && element()->isMalformed())
</span><span class="cx"> // See if this form is malformed (i.e., unclosed). If so, don't give the form
</span><span class="cx"> // a bottom margin.
</span><del>- m_maxBottomPosMargin = m_maxBottomNegMargin = 0;
</del><ins>+ setMaxBottomMargins(0, 0);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // For overflow:scroll blocks, ensure we have both scrollbars in place always.
</span><span class="lines">@@ -552,7 +564,7 @@
</span><span class="cx"> // Expand our intrinsic height to encompass floats.
</span><span class="cx"> int toAdd = borderBottom() + paddingBottom() + horizontalScrollbarHeight();
</span><span class="cx"> if (floatBottom() > (m_height - toAdd) && (isInlineBlockOrInlineTable() || isFloatingOrPositioned() || hasOverflowClip() ||
</span><del>- (parent() && parent()->isFlexibleBox() || hasColumns())))
</del><ins>+ (parent() && parent()->isFlexibleBox() || m_hasColumns)))
</ins><span class="cx"> m_height = floatBottom() + toAdd;
</span><span class="cx">
</span><span class="cx"> // Now lay out our columns within this intrinsic height, since they can slightly affect the intrinsic height as
</span><span class="lines">@@ -832,10 +844,8 @@
</span><span class="cx"> // This child is collapsing with the top of the
</span><span class="cx"> // block. If it has larger margin values, then we need to update
</span><span class="cx"> // our own maximal values.
</span><del>- if (!style()->htmlHacks() || !marginInfo.quirkContainer() || !topQuirk) {
- m_maxTopPosMargin = max(posTop, m_maxTopPosMargin);
- m_maxTopNegMargin = max(negTop, m_maxTopNegMargin);
- }
</del><ins>+ if (!style()->htmlHacks() || !marginInfo.quirkContainer() || !topQuirk)
+ setMaxTopMargins(max(posTop, maxTopPosMargin()), max(negTop, maxTopNegMargin()));
</ins><span class="cx">
</span><span class="cx"> // The minute any of the margins involved isn't a quirk, don't
</span><span class="cx"> // collapse it away, even if the margin is smaller (www.webreference.com
</span><span class="lines">@@ -952,8 +962,7 @@
</span><span class="cx"> // FIXME: This isn't quite correct. Need clarification for what to do
</span><span class="cx"> // if the height the cleared block is offset by is smaller than the
</span><span class="cx"> // margins involved.
</span><del>- m_maxTopPosMargin = oldTopPosMargin;
- m_maxTopNegMargin = oldTopNegMargin;
</del><ins>+ setMaxTopMargins(oldTopPosMargin, oldTopNegMargin);
</ins><span class="cx"> marginInfo.setAtTopOfBlock(false);
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -1042,8 +1051,7 @@
</span><span class="cx"> if (marginInfo.canCollapseWithBottom() && !marginInfo.canCollapseWithTop()) {
</span><span class="cx"> // Update our max pos/neg bottom margins, since we collapsed our bottom margins
</span><span class="cx"> // with our children.
</span><del>- m_maxBottomPosMargin = max(m_maxBottomPosMargin, marginInfo.posMargin());
- m_maxBottomNegMargin = max(m_maxBottomNegMargin, marginInfo.negMargin());
</del><ins>+ setMaxBottomMargins(max(maxBottomPosMargin(), marginInfo.posMargin()), max(maxBottomNegMargin(), marginInfo.negMargin()));
</ins><span class="cx">
</span><span class="cx"> if (!marginInfo.bottomQuirk())
</span><span class="cx"> m_bottomMarginQuirk = false;
</span><span class="lines">@@ -1113,8 +1121,8 @@
</span><span class="cx"> continue; // Skip the legend, since it has already been positioned up in the fieldset's border.
</span><span class="cx"> }
</span><span class="cx">
</span><del>- int oldTopPosMargin = m_maxTopPosMargin;
- int oldTopNegMargin = m_maxTopNegMargin;
</del><ins>+ int oldTopPosMargin = maxTopPosMargin();
+ int oldTopNegMargin = maxTopNegMargin();
</ins><span class="cx">
</span><span class="cx"> // Make sure we layout children if they need it.
</span><span class="cx"> // FIXME: Technically percentage height objects only need a relayout if their percentage isn't going to be turned into
</span><span class="lines">@@ -1341,10 +1349,11 @@
</span><span class="cx"> EBorderStyle ruleStyle = style()->columnRuleStyle();
</span><span class="cx"> int ruleWidth = style()->columnRuleWidth();
</span><span class="cx"> bool renderRule = !paintingFloats && ruleStyle > BHIDDEN && !ruleTransparent && ruleWidth <= colGap;
</span><del>- unsigned colCount = m_columnRects->size();
</del><ins>+ Vector<IntRect>* colRects = columnRects();
+ unsigned colCount = colRects->size();
</ins><span class="cx"> for (unsigned i = 0; i < colCount; i++) {
</span><span class="cx"> // For each rect, we clip to the rect, and then we adjust our coords.
</span><del>- IntRect colRect = m_columnRects->at(i);
</del><ins>+ IntRect colRect = colRects->at(i);
</ins><span class="cx"> colRect.move(tx, ty);
</span><span class="cx"> context->save();
</span><span class="cx">
</span><span class="lines">@@ -1479,7 +1488,7 @@
</span><span class="cx">
</span><span class="cx"> // 2. paint contents
</span><span class="cx"> if (paintPhase != PaintPhaseSelfOutline) {
</span><del>- if (hasColumns())
</del><ins>+ if (m_hasColumns)
</ins><span class="cx"> paintColumns(paintInfo, scrolledX, scrolledY);
</span><span class="cx"> else
</span><span class="cx"> paintContents(paintInfo, scrolledX, scrolledY);
</span><span class="lines">@@ -1488,12 +1497,12 @@
</span><span class="cx"> // 3. paint selection
</span><span class="cx"> // FIXME: Make this work with multi column layouts. For now don't fill gaps.
</span><span class="cx"> bool isPrinting = document()->printing();
</span><del>- if (!inlineFlow && !isPrinting && !hasColumns())
</del><ins>+ if (!inlineFlow && !isPrinting && !m_hasColumns)
</ins><span class="cx"> paintSelection(paintInfo, scrolledX, scrolledY); // Fill in gaps in selection on lines and between blocks.
</span><span class="cx">
</span><span class="cx"> // 4. paint floats.
</span><span class="cx"> if (!inlineFlow && (paintPhase == PaintPhaseFloat || paintPhase == PaintPhaseSelection)) {
</span><del>- if (hasColumns())
</del><ins>+ if (m_hasColumns)
</ins><span class="cx"> paintColumns(paintInfo, scrolledX, scrolledY, true);
</span><span class="cx"> else
</span><span class="cx"> paintFloats(paintInfo, scrolledX, scrolledY, paintPhase == PaintPhaseSelection);
</span><span class="lines">@@ -1649,7 +1658,7 @@
</span><span class="cx"> if (!isBlockFlow()) // FIXME: Make multi-column selection gap filling work someday.
</span><span class="cx"> return result;
</span><span class="cx">
</span><del>- if (hasColumns()) {
</del><ins>+ if (m_hasColumns) {
</ins><span class="cx"> // FIXME: We should learn how to gap fill multiple columns eventually.
</span><span class="cx"> lastTop = (ty - blockY) + height();
</span><span class="cx"> lastLeft = leftSelectionOffset(rootBlock, height());
</span><span class="lines">@@ -2264,9 +2273,10 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (hasColumns()) {
- for (unsigned i = 0; i < m_columnRects->size(); i++)
- bottom = max(bottom, m_columnRects->at(i).bottom());
</del><ins>+ if (m_hasColumns) {
+ Vector<IntRect>* colRects = columnRects();
+ for (unsigned i = 0; i < colRects->size(); i++)
+ bottom = max(bottom, colRects->at(i).bottom());
</ins><span class="cx"> return bottom;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2312,10 +2322,10 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (hasColumns()) {
</del><ins>+ if (m_hasColumns) {
</ins><span class="cx"> // This only matters for LTR
</span><span class="cx"> if (style()->direction() == LTR)
</span><del>- right = max(m_columnRects->last().right(), right);
</del><ins>+ right = max(columnRects()->last().right(), right);
</ins><span class="cx"> return right;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2366,10 +2376,10 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><del>- if (hasColumns()) {
</del><ins>+ if (m_hasColumns) {
</ins><span class="cx"> // This only matters for RTL
</span><span class="cx"> if (style()->direction() == RTL)
</span><del>- left = min(m_columnRects->last().x(), left);
</del><ins>+ left = min(columnRects()->last().x(), left);
</ins><span class="cx"> return left;
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2702,11 +2712,11 @@
</span><span class="cx"> m_layer->subtractScrollOffset(scrolledX, scrolledY);
</span><span class="cx">
</span><span class="cx"> // Hit test contents if we don't have columns.
</span><del>- if (!hasColumns() && hitTestContents(request, result, _x, _y, scrolledX, scrolledY, hitTestAction))
</del><ins>+ if (!m_hasColumns && hitTestContents(request, result, _x, _y, scrolledX, scrolledY, hitTestAction))
</ins><span class="cx"> return true;
</span><span class="cx">
</span><span class="cx"> // Hit test our columns if we do have them.
</span><del>- if (hasColumns() && hitTestColumns(request, result, _x, _y, scrolledX, scrolledY, hitTestAction))
</del><ins>+ if (m_hasColumns && hitTestColumns(request, result, _x, _y, scrolledX, scrolledY, hitTestAction))
</ins><span class="cx"> return true;
</span><span class="cx">
</span><span class="cx"> // Hit test floats.
</span><span class="lines">@@ -2752,8 +2762,9 @@
</span><span class="cx"> int currXOffset = 0;
</span><span class="cx"> int currYOffset = 0;
</span><span class="cx"> int colGap = columnGap();
</span><del>- for (unsigned i = 0; i < m_columnRects->size(); i++) {
- IntRect colRect = m_columnRects->at(i);
</del><ins>+ Vector<IntRect>* colRects = columnRects();
+ for (unsigned i = 0; i < colRects->size(); i++) {
+ IntRect colRect = colRects->at(i);
</ins><span class="cx"> colRect.move(tx, ty);
</span><span class="cx">
</span><span class="cx"> if (colRect.contains(x, y)) {
</span><span class="lines">@@ -2848,7 +2859,7 @@
</span><span class="cx"> int contentsY = y - borderTopExtra();
</span><span class="cx"> if (hasOverflowClip())
</span><span class="cx"> m_layer->scrollOffset(contentsX, contentsY);
</span><del>- if (hasColumns()) {
</del><ins>+ if (m_hasColumns) {
</ins><span class="cx"> IntPoint contentsPoint(contentsX, contentsY);
</span><span class="cx"> adjustPointToColumnContents(contentsPoint);
</span><span class="cx"> contentsX = contentsPoint.x();
</span><span class="lines">@@ -2956,8 +2967,8 @@
</span><span class="cx"> int RenderBlock::availableWidth() const
</span><span class="cx"> {
</span><span class="cx"> // If we have multiple columns, then the available width is reduced to our column width.
</span><del>- if (hasColumns())
- return m_desiredColumnWidth;
</del><ins>+ if (m_hasColumns)
+ return desiredColumnWidth();
</ins><span class="cx"> return contentWidth();
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -2971,30 +2982,32 @@
</span><span class="cx"> void RenderBlock::calcColumnWidth()
</span><span class="cx"> {
</span><span class="cx"> // Calculate our column width and column count.
</span><del>- m_desiredColumnCount = 1;
- m_desiredColumnWidth = contentWidth();
</del><ins>+ unsigned desiredColumnCount = 1;
+ int desiredColumnWidth = contentWidth();
</ins><span class="cx">
</span><span class="cx"> // For now, we don't support multi-column layouts when printing, since we have to do a lot of work for proper pagination.
</span><del>- if (document()->printing() || (style()->hasAutoColumnCount() && style()->hasAutoColumnWidth()))
</del><ins>+ if (document()->printing() || (style()->hasAutoColumnCount() && style()->hasAutoColumnWidth())) {
+ setDesiredColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
</ins><span class="cx"> return;
</span><ins>+ }
</ins><span class="cx">
</span><del>- int availWidth = m_desiredColumnWidth;
</del><ins>+ int availWidth = desiredColumnWidth;
</ins><span class="cx"> int colGap = columnGap();
</span><span class="cx">
</span><span class="cx"> if (style()->hasAutoColumnWidth()) {
</span><span class="cx"> int colCount = style()->columnCount();
</span><span class="cx"> if ((colCount - 1) * colGap < availWidth) {
</span><del>- m_desiredColumnCount = colCount;
- m_desiredColumnWidth = (availWidth - (m_desiredColumnCount - 1) * colGap) / m_desiredColumnCount;
</del><ins>+ desiredColumnCount = colCount;
+ desiredColumnWidth = (availWidth - (desiredColumnCount - 1) * colGap) / desiredColumnCount;
</ins><span class="cx"> } else if (colGap < availWidth) {
</span><del>- m_desiredColumnCount = availWidth / colGap;
- m_desiredColumnWidth = (availWidth - (m_desiredColumnCount - 1) * colGap) / m_desiredColumnCount;
</del><ins>+ desiredColumnCount = availWidth / colGap;
+ desiredColumnWidth = (availWidth - (desiredColumnCount - 1) * colGap) / desiredColumnCount;
</ins><span class="cx"> }
</span><span class="cx"> } else if (style()->hasAutoColumnCount()) {
</span><span class="cx"> int colWidth = static_cast<int>(style()->columnWidth());
</span><span class="cx"> if (colWidth < availWidth) {
</span><del>- m_desiredColumnCount = (availWidth + colGap) / (colWidth + colGap);
- m_desiredColumnWidth = (availWidth - (m_desiredColumnCount - 1) * colGap) / m_desiredColumnCount;
</del><ins>+ desiredColumnCount = (availWidth + colGap) / (colWidth + colGap);
+ desiredColumnWidth = (availWidth - (desiredColumnCount - 1) * colGap) / desiredColumnCount;
</ins><span class="cx"> }
</span><span class="cx"> } else {
</span><span class="cx"> // Both are set.
</span><span class="lines">@@ -3002,30 +3015,82 @@
</span><span class="cx"> int colCount = style()->columnCount();
</span><span class="cx">
</span><span class="cx"> if (colCount * colWidth + (colCount - 1) * colGap <= availWidth) {
</span><del>- m_desiredColumnCount = colCount;
- m_desiredColumnWidth = colWidth;
</del><ins>+ desiredColumnCount = colCount;
+ desiredColumnWidth = colWidth;
</ins><span class="cx"> } else if (colWidth < availWidth) {
</span><del>- m_desiredColumnCount = (availWidth + colGap) / (colWidth + colGap);
- m_desiredColumnWidth = (availWidth - (m_desiredColumnCount - 1) * colGap) / m_desiredColumnCount;
</del><ins>+ desiredColumnCount = (availWidth + colGap) / (colWidth + colGap);
+ desiredColumnWidth = (availWidth - (desiredColumnCount - 1) * colGap) / desiredColumnCount;
</ins><span class="cx"> }
</span><span class="cx"> }
</span><ins>+ setDesiredColumnCountAndWidth(desiredColumnCount, desiredColumnWidth);
</ins><span class="cx"> }
</span><span class="cx">
</span><ins>+void RenderBlock::setDesiredColumnCountAndWidth(int count, int width)
+{
+ if (count == 1) {
+ if (m_hasColumns) {
+ ColumnInfoMap::iterator it = gColumnInfoMap->find(this);
+ delete it->second;
+ gColumnInfoMap->remove(it);
+ m_hasColumns = false;
+ }
+ } else {
+ ColumnInfo* info;
+ if (m_hasColumns)
+ info = gColumnInfoMap->get(this);
+ else {
+ if (!gColumnInfoMap)
+ gColumnInfoMap = new ColumnInfoMap;
+ info = new ColumnInfo;
+ gColumnInfoMap->add(this, info);
+ m_hasColumns = true;
+ }
+ info->m_desiredColumnCount = count;
+ info->m_desiredColumnWidth = width;
+ }
+}
+
+int RenderBlock::desiredColumnWidth() const
+{
+ if (!m_hasColumns)
+ return contentWidth();
+ return gColumnInfoMap->get(this)->m_desiredColumnWidth;
+}
+
+unsigned RenderBlock::desiredColumnCount() const
+{
+ if (!m_hasColumns)
+ return 1;
+ return gColumnInfoMap->get(this)->m_desiredColumnCount;
+}
+
+Vector<IntRect>* RenderBlock::columnRects() const
+{
+ if (!m_hasColumns)
+ return 0;
+ return &gColumnInfoMap->get(this)->m_columnRects;
+}
+
</ins><span class="cx"> int RenderBlock::layoutColumns(int endOfContent)
</span><span class="cx"> {
</span><span class="cx"> // Don't do anything if we have no columns
</span><del>- if (!hasColumns())
</del><ins>+ if (!m_hasColumns)
</ins><span class="cx"> return -1;
</span><span class="cx">
</span><ins>+ ColumnInfo* info = gColumnInfoMap->get(this);
+ int desiredColumnWidth = info->m_desiredColumnWidth;
+ int desiredColumnCount = info->m_desiredColumnCount;
+ Vector<IntRect>* columnRects = &info->m_columnRects;
+
</ins><span class="cx"> bool computeIntrinsicHeight = (endOfContent == -1);
</span><span class="cx">
</span><span class="cx"> // Fill the columns in to the available height. Attempt to balance the height of the columns
</span><span class="cx"> int availableHeight = contentHeight();
</span><del>- int colHeight = computeIntrinsicHeight ? availableHeight / m_desiredColumnCount : availableHeight;
</del><ins>+ int colHeight = computeIntrinsicHeight ? availableHeight / desiredColumnCount : availableHeight;
</ins><span class="cx">
</span><span class="cx"> // Add in half our line-height to help with best-guess initial balancing.
</span><span class="cx"> int columnSlop = lineHeight(false) / 2;
</span><del>- int remainingSlopSpace = columnSlop * m_desiredColumnCount;
</del><ins>+ int remainingSlopSpace = columnSlop * desiredColumnCount;
</ins><span class="cx">
</span><span class="cx"> if (computeIntrinsicHeight)
</span><span class="cx"> colHeight += columnSlop;
</span><span class="lines">@@ -3033,8 +3098,7 @@
</span><span class="cx"> int colGap = columnGap();
</span><span class="cx">
</span><span class="cx"> // Compute a collection of column rects.
</span><del>- delete m_columnRects;
- m_columnRects = new Vector<IntRect>();
</del><ins>+ columnRects->clear();
</ins><span class="cx">
</span><span class="cx"> // Then we do a simulated "paint" into the column slices and allow the content to slightly adjust our individual column rects.
</span><span class="cx"> // FIXME: We need to take into account layers that are affected by the columns as well here so that they can have an opportunity
</span><span class="lines">@@ -3042,9 +3106,9 @@
</span><span class="cx"> RenderView* v = view();
</span><span class="cx"> int left = borderLeft() + paddingLeft();
</span><span class="cx"> int top = borderTop() + paddingTop();
</span><del>- int currX = style()->direction() == LTR ? borderLeft() + paddingLeft() : borderLeft() + paddingLeft() + contentWidth() - m_desiredColumnWidth;
</del><ins>+ int currX = style()->direction() == LTR ? borderLeft() + paddingLeft() : borderLeft() + paddingLeft() + contentWidth() - desiredColumnWidth;
</ins><span class="cx"> int currY = top;
</span><del>- unsigned colCount = m_desiredColumnCount;
</del><ins>+ unsigned colCount = desiredColumnCount;
</ins><span class="cx"> int maxColBottom = borderTop() + paddingTop();
</span><span class="cx"> int contentBottom = top + availableHeight;
</span><span class="cx"> for (unsigned i = 0; i < colCount; i++) {
</span><span class="lines">@@ -3053,19 +3117,18 @@
</span><span class="cx"> colHeight = availableHeight;
</span><span class="cx">
</span><span class="cx"> // This represents the real column position.
</span><del>- IntRect colRect(currX, top, m_desiredColumnWidth, colHeight);
</del><ins>+ IntRect colRect(currX, top, desiredColumnWidth, colHeight);
</ins><span class="cx">
</span><span class="cx"> // For the simulated paint, we pretend like everything is in one long strip.
</span><del>- IntRect pageRect(left, currY, m_desiredColumnWidth, colHeight);
</del><ins>+ IntRect pageRect(left, currY, desiredColumnWidth, colHeight);
</ins><span class="cx"> v->setPrintRect(pageRect);
</span><span class="cx"> v->setTruncatedAt(currY + colHeight);
</span><span class="cx"> GraphicsContext context((PlatformGraphicsContext*)0);
</span><span class="cx"> RenderObject::PaintInfo paintInfo(&context, pageRect, PaintPhaseForeground, false, 0, 0);
</span><span class="cx">
</span><del>- int oldColCount = m_desiredColumnCount;
- m_desiredColumnCount = 1;
</del><ins>+ m_hasColumns = false;
</ins><span class="cx"> paintObject(paintInfo, 0, 0);
</span><del>- m_desiredColumnCount = oldColCount;
</del><ins>+ m_hasColumns = true;
</ins><span class="cx">
</span><span class="cx"> int adjustedBottom = v->bestTruncatedAt();
</span><span class="cx"> if (adjustedBottom <= currY)
</span><span class="lines">@@ -3087,16 +3150,16 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> if (style()->direction() == LTR)
</span><del>- currX += m_desiredColumnWidth + colGap;
</del><ins>+ currX += desiredColumnWidth + colGap;
</ins><span class="cx"> else
</span><del>- currX -= (m_desiredColumnWidth + colGap);
</del><ins>+ currX -= (desiredColumnWidth + colGap);
</ins><span class="cx">
</span><span class="cx"> currY += colRect.height();
</span><span class="cx"> availableHeight -= colRect.height();
</span><span class="cx">
</span><span class="cx"> maxColBottom = max(colRect.bottom(), maxColBottom);
</span><span class="cx">
</span><del>- m_columnRects->append(colRect);
</del><ins>+ columnRects->append(colRect);
</ins><span class="cx">
</span><span class="cx"> // Start adding in more columns as long as there's still content left.
</span><span class="cx"> if (currY < endOfContent && i == colCount - 1)
</span><span class="lines">@@ -3104,7 +3167,7 @@
</span><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> m_overflowWidth = max(m_width, currX - colGap);
</span><del>- m_overflowLeft = min(0, currX + m_desiredColumnWidth + colGap);
</del><ins>+ m_overflowLeft = min(0, currX + desiredColumnWidth + colGap);
</ins><span class="cx">
</span><span class="cx"> m_overflowHeight = maxColBottom;
</span><span class="cx"> int toAdd = borderBottom() + paddingBottom() + horizontalScrollbarHeight();
</span><span class="lines">@@ -3115,7 +3178,7 @@
</span><span class="cx"> v->setPrintRect(IntRect());
</span><span class="cx"> v->setTruncatedAt(0);
</span><span class="cx">
</span><del>- ASSERT(m_columnRects && colCount == m_columnRects->size());
</del><ins>+ ASSERT(colCount == columnRects->size());
</ins><span class="cx">
</span><span class="cx"> return contentBottom;
</span><span class="cx"> }
</span><span class="lines">@@ -3123,17 +3186,19 @@
</span><span class="cx"> void RenderBlock::adjustPointToColumnContents(IntPoint& point) const
</span><span class="cx"> {
</span><span class="cx"> // Just bail if we have no columns.
</span><del>- if (!hasColumns() || !m_columnRects)
</del><ins>+ if (!m_hasColumns)
</ins><span class="cx"> return;
</span><ins>+
+ Vector<IntRect>* colRects = columnRects();
</ins><span class="cx">
</span><span class="cx"> // Determine which columns we intersect.
</span><span class="cx"> int colGap = columnGap();
</span><span class="cx"> int leftGap = colGap / 2;
</span><del>- IntPoint columnPoint(m_columnRects->at(0).location());
</del><ins>+ IntPoint columnPoint(colRects->at(0).location());
</ins><span class="cx"> int yOffset = 0;
</span><del>- for (unsigned i = 0; i < m_columnRects->size(); i++) {
</del><ins>+ for (unsigned i = 0; i < colRects->size(); i++) {
</ins><span class="cx"> // Add in half the column gap to the left and right of the rect.
</span><del>- IntRect colRect = m_columnRects->at(i);
</del><ins>+ IntRect colRect = colRects->at(i);
</ins><span class="cx"> IntRect gapAndColumnRect(colRect.x() - leftGap, colRect.y(), colRect.width() + colGap, colRect.height());
</span><span class="cx">
</span><span class="cx"> if (gapAndColumnRect.contains(point)) {
</span><span class="lines">@@ -3150,8 +3215,10 @@
</span><span class="cx"> void RenderBlock::adjustRectForColumns(IntRect& r) const
</span><span class="cx"> {
</span><span class="cx"> // Just bail if we have no columns.
</span><del>- if (!hasColumns() || !m_columnRects)
</del><ins>+ if (!m_hasColumns)
</ins><span class="cx"> return;
</span><ins>+
+ Vector<IntRect>* colRects = columnRects();
</ins><span class="cx">
</span><span class="cx"> // Begin with a result rect that is empty.
</span><span class="cx"> IntRect result;
</span><span class="lines">@@ -3160,8 +3227,8 @@
</span><span class="cx"> int currXOffset = 0;
</span><span class="cx"> int currYOffset = 0;
</span><span class="cx"> int colGap = columnGap();
</span><del>- for (unsigned i = 0; i < m_columnRects->size(); i++) {
- IntRect colRect = m_columnRects->at(i);
</del><ins>+ for (unsigned i = 0; i < colRects->size(); i++) {
+ IntRect colRect = colRects->at(i);
</ins><span class="cx">
</span><span class="cx"> IntRect repaintRect = r;
</span><span class="cx"> repaintRect.move(currXOffset, currYOffset);
</span><span class="lines">@@ -4154,6 +4221,28 @@
</span><span class="cx"> }
</span><span class="cx"> }
</span><span class="cx">
</span><ins>+void RenderBlock::setMaxTopMargins(int pos, int neg)
+{
+ if (!m_maxMargin) {
+ if (pos == MaxMargin::topPosDefault(this) && neg == MaxMargin::topNegDefault(this))
+ return;
+ m_maxMargin = new MaxMargin(this);
+ }
+ m_maxMargin->m_topPos = pos;
+ m_maxMargin->m_topNeg = neg;
+}
+
+void RenderBlock::setMaxBottomMargins(int pos, int neg)
+{
+ if (!m_maxMargin) {
+ if (pos == MaxMargin::bottomPosDefault(this) && neg == MaxMargin::bottomNegDefault(this))
+ return;
+ m_maxMargin = new MaxMargin(this);
+ }
+ m_maxMargin->m_bottomPos = pos;
+ m_maxMargin->m_bottomNeg = neg;
+}
+
</ins><span class="cx"> const char* RenderBlock::renderName() const
</span><span class="cx"> {
</span><span class="cx"> if (isBody())
</span></span></pre></div>
<a id="trunkWebCorerenderingRenderBlockh"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/rendering/RenderBlock.h (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/rendering/RenderBlock.h 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/rendering/RenderBlock.h 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -76,27 +76,24 @@
</span><span class="cx"> virtual bool isTopMarginQuirk() const { return m_topMarginQuirk; }
</span><span class="cx"> virtual bool isBottomMarginQuirk() const { return m_bottomMarginQuirk; }
</span><span class="cx">
</span><del>- virtual int maxTopMargin(bool positive) const { return positive ? m_maxTopPosMargin : m_maxTopNegMargin; }
- virtual int maxBottomMargin(bool positive) const { return positive ? m_maxBottomPosMargin : m_maxBottomNegMargin; }
</del><ins>+ virtual int maxTopMargin(bool positive) const { return positive ? maxTopPosMargin() : maxTopNegMargin(); }
+ virtual int maxBottomMargin(bool positive) const { return positive ? maxBottomPosMargin() : maxBottomNegMargin(); }
</ins><span class="cx">
</span><ins>+ 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);
+
</ins><span class="cx"> void initMaxMarginValues()
</span><span class="cx"> {
</span><del>- int margTop = marginTop();
- if (margTop >= 0) {
- m_maxTopPosMargin = margTop;
- m_maxTopNegMargin = 0;
- } else {
- m_maxTopNegMargin = -margTop;
- m_maxTopPosMargin = 0;
</del><ins>+ 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);
</ins><span class="cx"> }
</span><del>- int margBottom = marginBottom();
- if (margBottom >= 0) {
- m_maxBottomPosMargin = margBottom;
- m_maxBottomNegMargin = 0;
- } else {
- m_maxBottomNegMargin = -margBottom;
- m_maxBottomPosMargin = 0;
- }
</del><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> virtual void addChildToFlow(RenderObject* newChild, RenderObject* beforeChild);
</span><span class="lines">@@ -285,7 +282,11 @@
</span><span class="cx"> int heightForLineCount(int);
</span><span class="cx"> void clearTruncation();
</span><span class="cx">
</span><del>- virtual bool hasColumns() const { return m_desiredColumnCount > 1; }
</del><ins>+ int desiredColumnWidth() const;
+ unsigned desiredColumnCount() const;
+ Vector<IntRect>* columnRects() const;
+ void setDesiredColumnCountAndWidth(int count, int width);
+
</ins><span class="cx"> void adjustRectForColumns(IntRect&) const;
</span><span class="cx"> private:
</span><span class="cx"> void adjustPointToColumnContents(IntPoint&) const;
</span><span class="lines">@@ -436,33 +437,35 @@
</span><span class="cx"> private:
</span><span class="cx"> DeprecatedPtrList<FloatingObject>* m_floatingObjects;
</span><span class="cx"> DeprecatedPtrList<RenderObject>* m_positionedObjects;
</span><ins>+
+ // Allocated only when some of these fields have non-default values
+ 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;
+ };
</ins><span class="cx">
</span><del>- bool m_childrenInline : 1;
- bool m_firstLine : 1;
- unsigned m_clearStatus : 2; // EClear
- bool m_topMarginQuirk : 1;
- bool m_bottomMarginQuirk : 1;
- bool m_hasMarkupTruncation : 1;
- unsigned m_selectionState : 3; // SelectionState
</del><ins>+ MaxMargin* m_maxMargin;
</ins><span class="cx">
</span><span class="cx"> protected:
</span><del>- int m_maxTopPosMargin;
- int m_maxTopNegMargin;
- int m_maxBottomPosMargin;
- int m_maxBottomNegMargin;
-
</del><span class="cx"> // How much content overflows out of our block vertically or horizontally.
</span><span class="cx"> int m_overflowHeight;
</span><span class="cx"> int m_overflowWidth;
</span><span class="cx"> int m_overflowLeft;
</span><span class="cx"> int m_overflowTop;
</span><del>-
-private:
-
- // Column information.
- int m_desiredColumnWidth;
- unsigned m_desiredColumnCount;
- Vector<IntRect>* m_columnRects;
</del><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkWebCorerenderingRenderFlexibleBoxcpp"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/rendering/RenderFlexibleBox.cpp (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/rendering/RenderFlexibleBox.cpp 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/rendering/RenderFlexibleBox.cpp 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -314,11 +314,14 @@
</span><span class="cx"> // bottom margin max values to 0. This way we don't factor in the values
</span><span class="cx"> // twice when we collapse with our previous vertically adjacent and
</span><span class="cx"> // following vertically adjacent blocks.
</span><del>- if (m_maxBottomPosMargin > m_maxTopPosMargin)
- m_maxTopPosMargin = m_maxBottomPosMargin;
- if (m_maxBottomNegMargin > m_maxTopNegMargin)
- m_maxTopNegMargin = m_maxBottomNegMargin;
- m_maxBottomNegMargin = m_maxBottomPosMargin = 0;
</del><ins>+ int pos = maxTopPosMargin();
+ int neg = maxTopNegMargin();
+ if (maxBottomPosMargin() > pos)
+ pos = maxBottomPosMargin();
+ if (maxBottomNegMargin() > neg)
+ neg = maxBottomNegMargin();
+ setMaxTopMargins(pos, neg);
+ setMaxBottomMargins(0, 0);
</ins><span class="cx"> }
</span><span class="cx">
</span><span class="cx"> // Always ensure our overflow width is at least as large as our width.
</span></span></pre></div>
<a id="trunkWebCorerenderingRenderFlowh"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/rendering/RenderFlow.h (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/rendering/RenderFlow.h 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/rendering/RenderFlow.h 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -46,6 +46,15 @@
</span><span class="cx"> , m_firstLineBox(0)
</span><span class="cx"> , m_lastLineBox(0)
</span><span class="cx"> , m_lineHeight(-1)
</span><ins>+ , m_childrenInline(true)
+ , m_firstLine(false)
+ , m_clearStatus(CNONE)
+ , m_topMarginQuirk(false)
+ , m_bottomMarginQuirk(false)
+ , m_hasMarkupTruncation(false)
+ , m_selectionState(SelectionNone)
+ , m_hasColumns(false)
+ , m_isContinuation(false)
</ins><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span><span class="lines">@@ -90,7 +99,7 @@
</span><span class="cx"> void paintOutlineForLine(GraphicsContext*, int tx, int ty, const IntRect& prevLine, const IntRect& thisLine, const IntRect& nextLine);
</span><span class="cx"> void paintOutline(GraphicsContext*, int tx, int ty);
</span><span class="cx">
</span><del>- virtual bool hasColumns() const { return false; }
</del><ins>+ virtual bool hasColumns() const { return m_hasColumns; }
</ins><span class="cx">
</span><span class="cx"> private:
</span><span class="cx"> // An inline can be split with blocks occurring in between the inline content.
</span><span class="lines">@@ -107,6 +116,20 @@
</span><span class="cx"> InlineFlowBox* m_lastLineBox;
</span><span class="cx">
</span><span class="cx"> mutable short m_lineHeight;
</span><ins>+
+ // These bitfields are moved here from subclasses to pack them together
+ // from RenderBlock
+ bool m_childrenInline : 1;
+ bool m_firstLine : 1;
+ unsigned m_clearStatus : 2; // EClear
+ bool m_topMarginQuirk : 1;
+ bool m_bottomMarginQuirk : 1;
+ bool m_hasMarkupTruncation : 1;
+ unsigned m_selectionState : 3; // SelectionState
+ bool m_hasColumns : 1;
+
+ // from RenderInline
+ bool m_isContinuation : 1; // Whether or not we're a continuation of an inline.
</ins><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre></div>
<a id="trunkWebCorerenderingRenderInlinecpp"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/rendering/RenderInline.cpp (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/rendering/RenderInline.cpp 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/rendering/RenderInline.cpp 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -34,7 +34,6 @@
</span><span class="cx">
</span><span class="cx"> RenderInline::RenderInline(Node* node)
</span><span class="cx"> : RenderFlow(node)
</span><del>- , m_isContinuation(false)
</del><span class="cx"> {
</span><span class="cx"> }
</span><span class="cx">
</span></span></pre></div>
<a id="trunkWebCorerenderingRenderInlineh"></a>
<div class="modfile"><h4>Modified: trunk/WebCore/rendering/RenderInline.h (20672 => 20673)</h4>
<pre class="diff"><span>
<span class="info">--- trunk/WebCore/rendering/RenderInline.h 2007-04-03 00:22:30 UTC (rev 20672)
+++ trunk/WebCore/rendering/RenderInline.h 2007-04-03 01:01:09 UTC (rev 20673)
</span><span class="lines">@@ -78,8 +78,6 @@
</span><span class="cx"> protected:
</span><span class="cx"> static RenderInline* cloneInline(RenderFlow* src);
</span><span class="cx">
</span><del>-private:
- bool m_isContinuation : 1; // Whether or not we're a continuation of an inline.
</del><span class="cx"> };
</span><span class="cx">
</span><span class="cx"> } // namespace WebCore
</span></span></pre>
</div>
</div>
</body>
</html>