[SCM] WebKit Debian packaging branch, debian/experimental, updated. upstream/1.3.3-9427-gc2be6fc
hyatt at apple.com
hyatt at apple.com
Wed Dec 22 13:52:59 UTC 2010
The following commit has been merged in the debian/experimental branch:
commit 8ce5916212d0dc65e333252aec1909f3936742e7
Author: hyatt at apple.com <hyatt at apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Date: Tue Sep 28 20:28:10 2010 +0000
https://bugs.webkit.org/show_bug.cgi?id=46750
Reviewed by Sam Weinig.
Rename the MarginInfo members and functions to be block-flow independent.
* rendering/RenderBlock.cpp:
(WebCore::RenderBlock::MarginInfo::MarginInfo):
(WebCore::RenderBlock::adjustPositionedBlock):
(WebCore::RenderBlock::adjustFloatingBlock):
(WebCore::RenderBlock::collapseMargins):
(WebCore::RenderBlock::clearFloatsIfNeeded):
(WebCore::RenderBlock::estimateVerticalPosition):
(WebCore::RenderBlock::setCollapsedBottomMargin):
(WebCore::RenderBlock::handleBottomOfBlock):
(WebCore::RenderBlock::layoutBlockChild):
(WebCore::RenderBlock::applyAfterBreak):
* rendering/RenderBlock.h:
(WebCore::RenderBlock::MarginInfo::setAtBeforeSideOfBlock):
(WebCore::RenderBlock::MarginInfo::setAtAfterSideOfBlock):
(WebCore::RenderBlock::MarginInfo::setMarginBeforeQuirk):
(WebCore::RenderBlock::MarginInfo::setMarginAfterQuirk):
(WebCore::RenderBlock::MarginInfo::setDeterminedMarginBeforeQuirk):
(WebCore::RenderBlock::MarginInfo::atBeforeSideOfBlock):
(WebCore::RenderBlock::MarginInfo::canCollapseWithMarginBefore):
(WebCore::RenderBlock::MarginInfo::canCollapseWithMarginAfter):
(WebCore::RenderBlock::MarginInfo::canCollapseMarginBeforeWithChildren):
(WebCore::RenderBlock::MarginInfo::canCollapseMarginAfterWithChildren):
(WebCore::RenderBlock::MarginInfo::determinedMarginBeforeQuirk):
(WebCore::RenderBlock::MarginInfo::marginBeforeQuirk):
(WebCore::RenderBlock::MarginInfo::marginAfterQuirk):
git-svn-id: http://svn.webkit.org/repository/webkit/trunk@68556 268f45cc-cd09-0410-ab3c-d52691b4dbfc
diff --git a/WebCore/ChangeLog b/WebCore/ChangeLog
index 1611ecc..3876395 100644
--- a/WebCore/ChangeLog
+++ b/WebCore/ChangeLog
@@ -1,3 +1,37 @@
+2010-09-28 David Hyatt <hyatt at apple.com>
+
+ Reviewed by Sam Weinig.
+
+ https://bugs.webkit.org/show_bug.cgi?id=46750
+
+ Rename the MarginInfo members and functions to be block-flow independent.
+
+ * rendering/RenderBlock.cpp:
+ (WebCore::RenderBlock::MarginInfo::MarginInfo):
+ (WebCore::RenderBlock::adjustPositionedBlock):
+ (WebCore::RenderBlock::adjustFloatingBlock):
+ (WebCore::RenderBlock::collapseMargins):
+ (WebCore::RenderBlock::clearFloatsIfNeeded):
+ (WebCore::RenderBlock::estimateVerticalPosition):
+ (WebCore::RenderBlock::setCollapsedBottomMargin):
+ (WebCore::RenderBlock::handleBottomOfBlock):
+ (WebCore::RenderBlock::layoutBlockChild):
+ (WebCore::RenderBlock::applyAfterBreak):
+ * rendering/RenderBlock.h:
+ (WebCore::RenderBlock::MarginInfo::setAtBeforeSideOfBlock):
+ (WebCore::RenderBlock::MarginInfo::setAtAfterSideOfBlock):
+ (WebCore::RenderBlock::MarginInfo::setMarginBeforeQuirk):
+ (WebCore::RenderBlock::MarginInfo::setMarginAfterQuirk):
+ (WebCore::RenderBlock::MarginInfo::setDeterminedMarginBeforeQuirk):
+ (WebCore::RenderBlock::MarginInfo::atBeforeSideOfBlock):
+ (WebCore::RenderBlock::MarginInfo::canCollapseWithMarginBefore):
+ (WebCore::RenderBlock::MarginInfo::canCollapseWithMarginAfter):
+ (WebCore::RenderBlock::MarginInfo::canCollapseMarginBeforeWithChildren):
+ (WebCore::RenderBlock::MarginInfo::canCollapseMarginAfterWithChildren):
+ (WebCore::RenderBlock::MarginInfo::determinedMarginBeforeQuirk):
+ (WebCore::RenderBlock::MarginInfo::marginBeforeQuirk):
+ (WebCore::RenderBlock::MarginInfo::marginAfterQuirk):
+
2010-09-28 Dan Bernstein <mitz at apple.com>
Reviewed by Darin Adler.
diff --git a/WebCore/rendering/RenderBlock.cpp b/WebCore/rendering/RenderBlock.cpp
index 1dba16c..7862e7b 100644
--- a/WebCore/rendering/RenderBlock.cpp
+++ b/WebCore/rendering/RenderBlock.cpp
@@ -78,7 +78,12 @@ static int gDelayUpdateScrollInfo = 0;
static DelayedUpdateScrollInfoSet* gDelayedUpdateScrollInfoSet = 0;
// Our MarginInfo state used when laying out block children.
-RenderBlock::MarginInfo::MarginInfo(RenderBlock* block, int top, int bottom)
+RenderBlock::MarginInfo::MarginInfo(RenderBlock* block, int beforeBorderPadding, int afterBorderPadding)
+ : m_atBeforeSideOfBlock(true)
+ , m_atAfterSideOfBlock(false)
+ , m_marginBeforeQuirk(false)
+ , m_marginAfterQuirk(false)
+ , m_determinedMarginBeforeQuirk(false)
{
// Whether or not we can collapse our own margins with our children. We don't do this
// if we had any border/padding (obviously), if we're the root or HTML elements, or if
@@ -87,25 +92,20 @@ RenderBlock::MarginInfo::MarginInfo(RenderBlock* block, int top, int bottom)
&& !block->isFloating() && !block->isTableCell() && !block->hasOverflowClip() && !block->isInlineBlockOrInlineTable()
&& !block->isBlockFlowRoot();
- m_canCollapseTopWithChildren = m_canCollapseWithChildren && (top == 0) && block->style()->marginTopCollapse() != MSEPARATE;
+ m_canCollapseMarginBeforeWithChildren = m_canCollapseWithChildren && (beforeBorderPadding == 0) && block->style()->marginTopCollapse() != MSEPARATE;
// If any height other than auto is specified in CSS, then we don't collapse our bottom
// margins with our children's margins. To do otherwise would be to risk odd visual
// effects when the children overflow out of the parent block and yet still collapse
// with it. We also don't collapse if we have any bottom border/padding.
- m_canCollapseBottomWithChildren = m_canCollapseWithChildren && (bottom == 0) &&
- (block->style()->height().isAuto() && block->style()->height().value() == 0) && block->style()->marginBottomCollapse() != MSEPARATE;
+ m_canCollapseMarginAfterWithChildren = m_canCollapseWithChildren && (afterBorderPadding == 0) &&
+ (block->style()->logicalHeight().isAuto() && block->style()->logicalHeight().value() == 0) && block->style()->marginBottomCollapse() != MSEPARATE;
m_quirkContainer = block->isTableCell() || block->isBody() || block->style()->marginTopCollapse() == MDISCARD ||
block->style()->marginBottomCollapse() == MDISCARD;
- m_atTopOfBlock = true;
- m_atBottomOfBlock = false;
-
- m_posMargin = m_canCollapseTopWithChildren ? block->maxTopMargin(true) : 0;
- m_negMargin = m_canCollapseTopWithChildren ? block->maxTopMargin(false) : 0;
-
- m_topQuirk = m_bottomQuirk = m_determinedTopQuirk = false;
+ m_posMargin = m_canCollapseMarginBeforeWithChildren ? block->maxTopMargin(true) : 0;
+ m_negMargin = m_canCollapseMarginAfterWithChildren ? block->maxTopMargin(false) : 0;
}
// -------------------------------------------------------------------------------------------------------
@@ -1332,7 +1332,7 @@ void RenderBlock::adjustPositionedBlock(RenderBox* child, const MarginInfo& marg
if (child->style()->hasStaticY()) {
int y = height();
- if (!marginInfo.canCollapseWithTop()) {
+ if (!marginInfo.canCollapseWithMarginBefore()) {
child->computeBlockDirectionMargins(this);
int marginTop = child->marginTop();
int collapsedTopPos = marginInfo.posMargin();
@@ -1366,10 +1366,10 @@ void RenderBlock::adjustFloatingBlock(const MarginInfo& marginInfo)
// Note also that the previous flow may collapse its margin into the top of
// our block. If this is the case, then we do not add the margin in to our
// height when computing the position of the float. This condition can be tested
- // for by simply calling canCollapseWithTop. See
+ // for by simply calling canCollapseWithMarginBefore. See
// http://www.hixie.ch/tests/adhoc/css/box/block/margin-collapse/046.html for
// an example of this scenario.
- int marginOffset = marginInfo.canCollapseWithTop() ? 0 : marginInfo.margin();
+ int marginOffset = marginInfo.canCollapseWithMarginBefore() ? 0 : marginInfo.margin();
setLogicalHeight(height() + marginOffset);
positionNewFloats();
setLogicalHeight(height() - marginOffset);
@@ -1481,7 +1481,7 @@ int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
// margins that will collapse with us.
bool topQuirk = child->isTopMarginQuirk() || style()->marginTopCollapse() == MDISCARD;
- if (marginInfo.canCollapseWithTop()) {
+ if (marginInfo.canCollapseWithMarginBefore()) {
// This child is collapsing with the top of the
// block. If it has larger margin values, then we need to update
// our own maximal values.
@@ -1492,12 +1492,12 @@ int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
// collapse it away, even if the margin is smaller (www.webreference.com
// has an example of this, a <dt> with 0.8em author-specified inside
// a <dl> inside a <td>.
- if (!marginInfo.determinedTopQuirk() && !topQuirk && (posTop-negTop)) {
+ if (!marginInfo.determinedMarginBeforeQuirk() && !topQuirk && (posTop-negTop)) {
setTopMarginQuirk(false);
- marginInfo.setDeterminedTopQuirk(true);
+ marginInfo.setDeterminedMarginBeforeQuirk(true);
}
- if (!marginInfo.determinedTopQuirk() && topQuirk && marginTop() == 0)
+ if (!marginInfo.determinedMarginBeforeQuirk() && topQuirk && marginTop() == 0)
// We have no top margin and our top child has a quirky margin.
// We will pick up this quirky margin and pass it through.
// This deals with the <td><div><p> case.
@@ -1506,8 +1506,8 @@ int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
setTopMarginQuirk(true);
}
- if (marginInfo.quirkContainer() && marginInfo.atTopOfBlock() && (posTop - negTop))
- marginInfo.setTopQuirk(topQuirk);
+ if (marginInfo.quirkContainer() && marginInfo.atBeforeSideOfBlock() && (posTop - negTop))
+ marginInfo.setMarginBeforeQuirk(topQuirk);
int beforeCollapseY = height();
int ypos = beforeCollapseY;
@@ -1524,7 +1524,7 @@ int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
marginInfo.setPosMarginIfLarger(child->maxBottomMargin(true));
marginInfo.setNegMarginIfLarger(child->maxBottomMargin(false));
- if (!marginInfo.canCollapseWithTop())
+ if (!marginInfo.canCollapseWithMarginBefore())
// We need to make sure that the position of the self-collapsing block
// is correct, since it could have overflowing content
// that needs to be positioned correctly (e.g., a block that
@@ -1536,9 +1536,9 @@ int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
setLogicalHeight(height() + marginInfo.margin() + child->marginTop());
ypos = height();
}
- else if (!marginInfo.atTopOfBlock() ||
- (!marginInfo.canCollapseTopWithChildren()
- && (!document()->inQuirksMode() || !marginInfo.quirkContainer() || !marginInfo.topQuirk()))) {
+ else if (!marginInfo.atBeforeSideOfBlock() ||
+ (!marginInfo.canCollapseMarginBeforeWithChildren()
+ && (!document()->inQuirksMode() || !marginInfo.quirkContainer() || !marginInfo.marginBeforeQuirk()))) {
// We're collapsing with a previous sibling's margins and not
// with the top of the block.
setLogicalHeight(height() + max(marginInfo.posMargin(), posTop) - max(marginInfo.negMargin(), negTop));
@@ -1549,7 +1549,7 @@ int RenderBlock::collapseMargins(RenderBox* child, MarginInfo& marginInfo)
marginInfo.setNegMargin(child->maxBottomMargin(false));
if (marginInfo.margin())
- marginInfo.setBottomQuirk(child->isBottomMarginQuirk() || style()->marginBottomCollapse() == MDISCARD);
+ marginInfo.setMarginAfterQuirk(child->isBottomMarginQuirk() || style()->marginBottomCollapse() == MDISCARD);
}
// If margins would pull us past the top of the next page, then we need to pull back and pretend like the margins
@@ -1597,14 +1597,14 @@ int RenderBlock::clearFloatsIfNeeded(RenderBox* child, MarginInfo& marginInfo, i
// Increase our height by the amount we had to clear.
setLogicalHeight(height() + heightIncrease);
- if (marginInfo.canCollapseWithTop()) {
+ if (marginInfo.canCollapseWithMarginBefore()) {
// We can no longer collapse with the top of the block since a clear
// occurred. The empty blocks collapse into the cleared block.
// FIXME: This isn't quite correct. Need clarification for what to do
// if the height the cleared block is offset by is smaller than the
// margins involved.
setMaxTopMargins(oldTopPosMargin, oldTopNegMargin);
- marginInfo.setAtTopOfBlock(false);
+ marginInfo.setAtBeforeSideOfBlock(false);
}
return yPos + heightIncrease;
@@ -1615,7 +1615,7 @@ int RenderBlock::estimateVerticalPosition(RenderBox* child, const MarginInfo& ma
// FIXME: We need to eliminate the estimation of vertical position, because when it's wrong we sometimes trigger a pathological
// relayout if there are intruding floats.
int yPosEstimate = height();
- if (!marginInfo.canCollapseWithTop()) {
+ if (!marginInfo.canCollapseWithMarginBefore()) {
int childMarginTop = child->selfNeedsLayout() ? child->marginTop() : child->collapsedMarginTop();
yPosEstimate += max(marginInfo.margin(), childMarginTop);
}
@@ -1697,15 +1697,15 @@ void RenderBlock::determineHorizontalPosition(RenderBox* child)
void RenderBlock::setCollapsedBottomMargin(const MarginInfo& marginInfo)
{
- if (marginInfo.canCollapseWithBottom() && !marginInfo.canCollapseWithTop()) {
+ if (marginInfo.canCollapseWithMarginAfter() && !marginInfo.canCollapseWithMarginBefore()) {
// Update our max pos/neg bottom margins, since we collapsed our bottom margins
// with our children.
setMaxBottomMargins(max(maxBottomPosMargin(), marginInfo.posMargin()), max(maxBottomNegMargin(), marginInfo.negMargin()));
- if (!marginInfo.bottomQuirk())
+ if (!marginInfo.marginAfterQuirk())
setBottomMarginQuirk(false);
- if (marginInfo.bottomQuirk() && marginBottom() == 0)
+ if (marginInfo.marginAfterQuirk() && marginBottom() == 0)
// We have no bottom margin and our last child has a quirky margin.
// We will pick up this quirky margin and pass it through.
// This deals with the <td><div><p> case.
@@ -1715,11 +1715,11 @@ void RenderBlock::setCollapsedBottomMargin(const MarginInfo& marginInfo)
void RenderBlock::handleBottomOfBlock(int top, int bottom, MarginInfo& marginInfo)
{
- marginInfo.setAtBottomOfBlock(true);
+ marginInfo.setAtAfterSideOfBlock(true);
// If we can't collapse with children then go ahead and add in the bottom margin.
- if (!marginInfo.canCollapseWithBottom() && !marginInfo.canCollapseWithTop()
- && (!document()->inQuirksMode() || !marginInfo.quirkContainer() || !marginInfo.bottomQuirk()))
+ if (!marginInfo.canCollapseWithMarginAfter() && !marginInfo.canCollapseWithMarginBefore()
+ && (!document()->inQuirksMode() || !marginInfo.quirkContainer() || !marginInfo.marginAfterQuirk()))
setLogicalHeight(height() + marginInfo.margin());
// Now add in our bottom border/padding.
@@ -1811,7 +1811,7 @@ void RenderBlock::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, int
// Do not allow a collapse if the margin top collapse style is set to SEPARATE.
if (child->style()->marginTopCollapse() == MSEPARATE) {
- marginInfo.setAtTopOfBlock(false);
+ marginInfo.setAtBeforeSideOfBlock(false);
marginInfo.clearMargin();
}
@@ -1857,7 +1857,7 @@ void RenderBlock::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, int
child->layout();
// Cache if we are at the top of the block right now.
- bool atTopOfBlock = marginInfo.atTopOfBlock();
+ bool atBeforeSideOfBlock = marginInfo.atBeforeSideOfBlock();
// Now determine the correct ypos based off examination of collapsing margin
// values.
@@ -1886,7 +1886,7 @@ void RenderBlock::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, int
if (paginationStrut) {
// We are willing to propagate out to our parent block as long as we were at the top of the block prior
// to collapsing our margins, and as long as we didn't clear or move as a result of other pagination.
- if (atTopOfBlock && oldY == yBeforeClear && !isPositioned() && !isTableCell()) {
+ if (atBeforeSideOfBlock && oldY == yBeforeClear && !isPositioned() && !isTableCell()) {
// FIXME: Should really check if we're exceeding the page height before propagating the strut, but we don't
// have all the information to do so (the strut only has the remaining amount to push). Gecko gets this wrong too
// and pushes to the next page anyway, so not too concerned about it.
@@ -1926,8 +1926,8 @@ void RenderBlock::layoutBlockChild(RenderBox* child, MarginInfo& marginInfo, int
// We are no longer at the top of the block if we encounter a non-empty child.
// This has to be done after checking for clear, so that margins can be reset if a clear occurred.
- if (marginInfo.atTopOfBlock() && !child->isSelfCollapsingBlock())
- marginInfo.setAtTopOfBlock(false);
+ if (marginInfo.atBeforeSideOfBlock() && !child->isSelfCollapsingBlock())
+ marginInfo.setAtBeforeSideOfBlock(false);
// Now place the child in the correct horizontal position
determineHorizontalPosition(child);
@@ -5934,7 +5934,7 @@ int RenderBlock::applyAfterBreak(RenderBox* child, int yPos, MarginInfo& marginI
bool checkPageBreaks = !checkColumnBreaks && view()->layoutState()->m_pageHeight; // FIXME: Once columns can print we have to check this.
bool checkAfterAlways = (checkColumnBreaks && child->style()->columnBreakAfter() == PBALWAYS) || (checkPageBreaks && child->style()->pageBreakAfter() == PBALWAYS);
if (checkAfterAlways && inNormalFlow(child)) {
- marginInfo.setBottomQuirk(true); // Cause margins to be discarded for any following content.
+ marginInfo.setMarginAfterQuirk(true); // Cause margins to be discarded for any following content.
if (checkColumnBreaks)
view()->layoutState()->addForcedColumnBreak(yPos);
return nextPageTop(yPos);
diff --git a/WebCore/rendering/RenderBlock.h b/WebCore/rendering/RenderBlock.h
index 2b4123c..032beb7 100644
--- a/WebCore/rendering/RenderBlock.h
+++ b/WebCore/rendering/RenderBlock.h
@@ -494,8 +494,8 @@ private:
class MarginInfo {
// Collapsing flags for whether we can collapse our margins with our children's margins.
bool m_canCollapseWithChildren : 1;
- bool m_canCollapseTopWithChildren : 1;
- bool m_canCollapseBottomWithChildren : 1;
+ bool m_canCollapseMarginBeforeWithChildren : 1;
+ bool m_canCollapseMarginAfterWithChildren : 1;
// Whether or not we are a quirky container, i.e., do we collapse away top and bottom
// margins in our container. Table cells and the body are the common examples. We
@@ -506,30 +506,30 @@ private:
// They may or may not collapse with the top margin of the block (|m_canCollapseTopWithChildren| tells us that), but they will
// always be collapsing with one another. This variable can remain set to true through multiple iterations
// as long as we keep encountering self-collapsing blocks.
- bool m_atTopOfBlock : 1;
+ bool m_atBeforeSideOfBlock : 1;
// This flag is set when we know we're examining bottom margins and we know we're at the bottom of the block.
- bool m_atBottomOfBlock : 1;
+ bool m_atAfterSideOfBlock : 1;
// These variables are used to detect quirky margins that we need to collapse away (in table cells
// and in the body element).
- bool m_topQuirk : 1;
- bool m_bottomQuirk : 1;
- bool m_determinedTopQuirk : 1;
+ bool m_marginBeforeQuirk : 1;
+ bool m_marginAfterQuirk : 1;
+ bool m_determinedMarginBeforeQuirk : 1;
// These flags track the previous maximal positive and negative margins.
int m_posMargin;
int m_negMargin;
public:
- MarginInfo(RenderBlock* b, int top, int bottom);
+ MarginInfo(RenderBlock* b, int beforeBorderPadding, int afterBorderPadding);
- void setAtTopOfBlock(bool b) { m_atTopOfBlock = b; }
- void setAtBottomOfBlock(bool b) { m_atBottomOfBlock = b; }
+ void setAtBeforeSideOfBlock(bool b) { m_atBeforeSideOfBlock = b; }
+ void setAtAfterSideOfBlock(bool b) { m_atAfterSideOfBlock = b; }
void clearMargin() { m_posMargin = m_negMargin = 0; }
- void setTopQuirk(bool b) { m_topQuirk = b; }
- void setBottomQuirk(bool b) { m_bottomQuirk = b; }
- void setDeterminedTopQuirk(bool b) { m_determinedTopQuirk = b; }
+ void setMarginBeforeQuirk(bool b) { m_marginBeforeQuirk = b; }
+ void setMarginAfterQuirk(bool b) { m_marginAfterQuirk = b; }
+ void setDeterminedMarginBeforeQuirk(bool b) { m_determinedMarginBeforeQuirk = 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; }
@@ -537,15 +537,15 @@ private:
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 atBeforeSideOfBlock() const { return m_atBeforeSideOfBlock; }
+ bool canCollapseWithMarginBefore() const { return m_atBeforeSideOfBlock && m_canCollapseMarginBeforeWithChildren; }
+ bool canCollapseWithMarginAfter() const { return m_atAfterSideOfBlock && m_canCollapseMarginAfterWithChildren; }
+ bool canCollapseMarginBeforeWithChildren() const { return m_canCollapseMarginBeforeWithChildren; }
+ bool canCollapseMarginAfterWithChildren() const { return m_canCollapseMarginAfterWithChildren; }
bool quirkContainer() const { return m_quirkContainer; }
- bool determinedTopQuirk() const { return m_determinedTopQuirk; }
- bool topQuirk() const { return m_topQuirk; }
- bool bottomQuirk() const { return m_bottomQuirk; }
+ bool determinedMarginBeforeQuirk() const { return m_determinedMarginBeforeQuirk; }
+ bool marginBeforeQuirk() const { return m_marginBeforeQuirk; }
+ bool marginAfterQuirk() const { return m_marginAfterQuirk; }
int posMargin() const { return m_posMargin; }
int negMargin() const { return m_negMargin; }
int margin() const { return m_posMargin - m_negMargin; }
--
WebKit Debian packaging
More information about the Pkg-webkit-commits
mailing list