https://bugs.webkit.org/show_bug.cgi?id=46750
authorhyatt@apple.com <hyatt@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 28 Sep 2010 20:28:10 +0000 (20:28 +0000)
committerhyatt@apple.com <hyatt@apple.com@268f45cc-cd09-0410-ab3c-d52691b4dbfc>
Tue, 28 Sep 2010 20:28:10 +0000 (20:28 +0000)
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: https://svn.webkit.org/repository/webkit/trunk@68556 268f45cc-cd09-0410-ab3c-d52691b4dbfc

WebCore/ChangeLog
WebCore/rendering/RenderBlock.cpp
WebCore/rendering/RenderBlock.h

index 1611ecc..3876395 100644 (file)
@@ -1,3 +1,37 @@
+2010-09-28  David Hyatt  <hyatt@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@apple.com>
 
         Reviewed by Darin Adler.
index 1dba16c..7862e7b 100644 (file)
@@ -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);
index 2b4123c..032beb7 100644 (file)
@@ -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; }