Changeset 126177 in webkit

Timestamp:

Aug 21, 2012 11:15:39 AM (12 years ago)

Author:

hyatt@apple.com

Message:

[New Multicolumn] Make column rules paint properly.
​https://bugs.webkit.org/show_bug.cgi?id=94616

Reviewed by Simon Fraser.

Make the new multi-column code paint column rules and also prepare it for painting
the actual column contents.

• rendering/RenderMultiColumnBlock.cpp:

(WebCore::RenderMultiColumnBlock::ensureColumnSets):
Remove the addRegionToThread call, since this is now done automatically in RenderRegion::insertedIntoTree.

• rendering/RenderMultiColumnBlock.h:

(WebCore::RenderMultiColumnBlock::flowThread):
Make public so that RenderMultiColumnSet can access it.

(RenderMultiColumnBlock):

• rendering/RenderMultiColumnSet.cpp:

(WebCore::RenderMultiColumnSet::columnGap):
Add a column gap fetch method. It's identical to the one on RenderBlock (which will eventually go away
when we kill the old multi-column code).

(WebCore::RenderMultiColumnSet::columnRectAt):
Also identical to the RenderBlock version of this method. Gets the rect for the nth column.

(WebCore::RenderMultiColumnSet::paintReplaced):
Subclass paintReplaced in order to do column rules and contents painting.

(WebCore::RenderMultiColumnSet::paintColumnRules):
(WebCore::RenderMultiColumnSet::paintColumnContents):
Similar to the methods on RenderBlock. The former paints the rules and the latter paints the contents of
the flow thread into the columns.

• rendering/RenderMultiColumnSet.h:

(RenderMultiColumnSet):
Add the declarations of all the new methods.

• rendering/RenderRegion.cpp:

(WebCore::RenderRegion::installFlowThread):
Added a new virtual function for installing flow threads when they didn't exist at construction time.
This only applies to actual CSS Regions, so the subclass of the method in RenderRegionSet just does
nothing.

(WebCore::RenderRegion::attachRegion):
Get the named flow thread code out of attachRegion, since it broke multi-column. Moved it into a
virtual function, installFlowThread, that is only used by actual CSS regions. Eventually we may
want a RenderRegion subclass that represents a region for a named flow thread only, but for now
let the code sit in installFlowThread in the base class.

• rendering/RenderRegion.h:

(RenderRegion):
Add installFlowThread declaration.

• rendering/RenderRegionSet.cpp:

(WebCore::RenderRegionSet::installFlowThread):
installFlowThread for region sets just does nothing, since we don't use named flow threads.

• rendering/RenderRegionSet.h:

(RenderRegionSet):
Add the override of installFlowThread.

Location:

trunk/Source/WebCore

Files:

• ChangeLog (modified) (1 diff)
• rendering/RenderMultiColumnBlock.cpp (modified) (1 diff)
• rendering/RenderMultiColumnBlock.h (modified) (2 diffs)
• rendering/RenderMultiColumnSet.cpp (modified) (2 diffs)
• rendering/RenderMultiColumnSet.h (modified) (1 diff)
• rendering/RenderRegion.cpp (modified) (2 diffs)
• rendering/RenderRegion.h (modified) (3 diffs)
• rendering/RenderRegionSet.cpp (modified) (1 diff)
• rendering/RenderRegionSet.h (modified) (1 diff)

trunk/Source/WebCore/ChangeLog

@@ +1 @@
+2012-08-21  David Hyatt  <hyatt@apple.com>
+
+        [New Multicolumn] Make column rules paint properly.
+        https://bugs.webkit.org/show_bug.cgi?id=94616
+
+        Reviewed by Simon Fraser.
+
+        Make the new multi-column code paint column rules and also prepare it for painting
+        the actual column contents.
+
+        * rendering/RenderMultiColumnBlock.cpp:
+        (WebCore::RenderMultiColumnBlock::ensureColumnSets):
+        Remove the addRegionToThread call, since this is now done automatically in RenderRegion::insertedIntoTree.
+        
+        * rendering/RenderMultiColumnBlock.h:
+        (WebCore::RenderMultiColumnBlock::flowThread):
+        Make public so that RenderMultiColumnSet can access it.
+        
+        (RenderMultiColumnBlock):
+        * rendering/RenderMultiColumnSet.cpp:
+        (WebCore::RenderMultiColumnSet::columnGap):
+        Add a column gap fetch method. It's identical to the one on RenderBlock (which will eventually go away
+        when we kill the old multi-column code).
+        
+        (WebCore::RenderMultiColumnSet::columnRectAt):
+        Also identical to the RenderBlock version of this method. Gets the rect for the nth column.
+        
+        (WebCore::RenderMultiColumnSet::paintReplaced):
+        Subclass paintReplaced in order to do column rules and contents painting.
+        
+        (WebCore::RenderMultiColumnSet::paintColumnRules):
+        (WebCore::RenderMultiColumnSet::paintColumnContents):
+        Similar to the methods on RenderBlock. The former paints the rules and the latter paints the contents of
+        the flow thread into the columns.
+        
+        * rendering/RenderMultiColumnSet.h:
+        (RenderMultiColumnSet):
+        Add the declarations of all the new methods.
+        
+        * rendering/RenderRegion.cpp:
+        (WebCore::RenderRegion::installFlowThread):
+        Added a new virtual function for installing flow threads when they didn't exist at construction time.
+        This only applies to actual CSS Regions, so the subclass of the method in RenderRegionSet just does
+        nothing.
+        
+        (WebCore::RenderRegion::attachRegion):
+        Get the named flow thread code out of attachRegion, since it broke multi-column. Moved it into a
+        virtual function, installFlowThread, that is only used by actual CSS regions. Eventually we may
+        want a RenderRegion subclass that represents a region for a named flow thread only, but for now
+        let the code sit in installFlowThread in the base class.
+        
+        * rendering/RenderRegion.h:
+        (RenderRegion):
+        Add installFlowThread declaration.
+        
+        * rendering/RenderRegionSet.cpp:
+        (WebCore::RenderRegionSet::installFlowThread):
+        installFlowThread for region sets just does nothing, since we don't use named flow threads.
+        
+        * rendering/RenderRegionSet.h:
+        (RenderRegionSet):
+        Add the override of installFlowThread.
+
 2012-08-21  Patrick Gansterer  <paroga@webkit.org>
 

trunk/Source/WebCore/rendering/RenderMultiColumnBlock.cpp

@@ -145 +145 @@
         columnSet->setStyle(RenderStyle::createAnonymousStyleWithDisplay(style(), BLOCK));
         RenderBlock::addChild(columnSet, firstChild());
-        flowThread()->addRegionToThread(columnSet);
     }
 }

trunk/Source/WebCore/rendering/RenderMultiColumnBlock.h

@@ -44 +44 @@
     unsigned columnCount() const { return m_columnCount; }
 
+    RenderMultiColumnFlowThread* flowThread() const { return m_flowThread; }
+
 private:
     virtual bool isRenderMultiColumnBlock() const { return true; }
@@ -58 +60 @@
 
     void ensureColumnSets();
-
-    RenderMultiColumnFlowThread* flowThread() const { return m_flowThread; }
 
     RenderMultiColumnFlowThread* m_flowThread;

trunk/Source/WebCore/rendering/RenderMultiColumnSet.cpp

@@ -25 +25 @@
 
 #include "config.h"
+#include "PaintInfo.h"
+#include "RenderMultiColumnFlowThread.h"
 #include "RenderMultiColumnSet.h"
 #include "RenderMultiColumnBlock.h"
@@ -61 +63 @@
 }
 
+LayoutUnit RenderMultiColumnSet::columnGap() const
+{
+    if (style()->hasNormalColumnGap())
+        return style()->fontDescription().computedPixelSize(); // "1em" is recommended as the normal gap setting. Matches <p> margins.
+    return static_cast<int>(style()->columnGap());
+}
+
+LayoutRect RenderMultiColumnSet::columnRectAt(unsigned index) const
+{
+    LayoutUnit colLogicalWidth = columnWidth();
+    LayoutUnit colLogicalHeight = columnHeight();
+    LayoutUnit colLogicalTop = borderBefore() + paddingBefore();
+    LayoutUnit colLogicalLeft = borderAndPaddingLogicalLeft();
+    int colGap = columnGap();
+    if (style()->isLeftToRightDirection())
+        colLogicalLeft += index * (colLogicalWidth + colGap);
+    else
+        colLogicalLeft += contentLogicalWidth() - colLogicalWidth - index * (colLogicalWidth + colGap);
+
+    if (isHorizontalWritingMode())
+        return LayoutRect(colLogicalLeft, colLogicalTop, colLogicalWidth, colLogicalHeight);
+    return LayoutRect(colLogicalTop, colLogicalLeft, colLogicalHeight, colLogicalWidth);
+}
+
+void RenderMultiColumnSet::paintReplaced(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+{
+    // FIXME: RenderRegions are replaced elements right now and so they only paint in the foreground phase.
+    // Columns should technically respect phases and allow for background/float/foreground overlap etc., just like
+    // RenderBlocks do. We can't correct this, however, until RenderRegions are changed to actually be
+    // RenderBlocks. Note this is a pretty minor issue, since the old column implementation clipped columns
+    // anyway, thus making it impossible for them to overlap one another. It's also really unlikely that the columns
+    // would overlap another block.
+    setRegionObjectsRegionStyle();
+    paintColumnRules(paintInfo, paintOffset);
+    paintColumnContents(paintInfo, paintOffset);
+    restoreRegionObjectsOriginalStyle();
+}
+
+void RenderMultiColumnSet::paintColumnRules(PaintInfo& paintInfo, const LayoutPoint& paintOffset)
+{
+    if (paintInfo.context->paintingDisabled())
+        return;
+
+    RenderStyle* blockStyle = toRenderMultiColumnBlock(parent())->style();
+    const Color& ruleColor = blockStyle->visitedDependentColor(CSSPropertyWebkitColumnRuleColor);
+    bool ruleTransparent = blockStyle->columnRuleIsTransparent();
+    EBorderStyle ruleStyle = blockStyle->columnRuleStyle();
+    LayoutUnit ruleThickness = blockStyle->columnRuleWidth();
+    LayoutUnit colGap = columnGap();
+    bool renderRule = ruleStyle > BHIDDEN && !ruleTransparent && ruleThickness <= colGap;
+    if (!renderRule)
+        return;
+
+    unsigned colCount = columnCount();
+
+    bool antialias = shouldAntialiasLines(paintInfo.context);
+
+    bool leftToRight = style()->isLeftToRightDirection();
+    LayoutUnit currLogicalLeftOffset = leftToRight ? ZERO_LAYOUT_UNIT : contentLogicalWidth();
+    LayoutUnit ruleAdd = borderAndPaddingLogicalLeft();
+    LayoutUnit ruleLogicalLeft = leftToRight ? ZERO_LAYOUT_UNIT : contentLogicalWidth();
+    LayoutUnit inlineDirectionSize = columnWidth();
+    BoxSide boxSide = isHorizontalWritingMode()
+        ? leftToRight ? BSLeft : BSRight
+        : leftToRight ? BSTop : BSBottom;
+
+    for (unsigned i = 0; i < colCount; i++) {
+        // Move to the next position.
+        if (leftToRight) {
+            ruleLogicalLeft += inlineDirectionSize + colGap / 2;
+            currLogicalLeftOffset += inlineDirectionSize + colGap;
+        } else {
+            ruleLogicalLeft -= (inlineDirectionSize + colGap / 2);
+            currLogicalLeftOffset -= (inlineDirectionSize + colGap);
+        }
+       
+        // Now paint the column rule.
+        if (i < colCount - 1) {
+            LayoutUnit ruleLeft = isHorizontalWritingMode() ? paintOffset.x() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd : paintOffset.x() + borderLeft() + paddingLeft();
+            LayoutUnit ruleRight = isHorizontalWritingMode() ? ruleLeft + ruleThickness : ruleLeft + contentWidth();
+            LayoutUnit ruleTop = isHorizontalWritingMode() ? paintOffset.y() + borderTop() + paddingTop() : paintOffset.y() + ruleLogicalLeft - ruleThickness / 2 + ruleAdd;
+            LayoutUnit ruleBottom = isHorizontalWritingMode() ? ruleTop + contentHeight() : ruleTop + ruleThickness;
+            IntRect pixelSnappedRuleRect = pixelSnappedIntRectFromEdges(ruleLeft, ruleTop, ruleRight, ruleBottom);
+            drawLineForBoxSide(paintInfo.context, pixelSnappedRuleRect.x(), pixelSnappedRuleRect.y(), pixelSnappedRuleRect.maxX(), pixelSnappedRuleRect.maxY(), boxSide, ruleColor, ruleStyle, 0, 0, antialias);
+        }
+        
+        ruleLogicalLeft = currLogicalLeftOffset;
+    }
+}
+
+void RenderMultiColumnSet::paintColumnContents(PaintInfo& /* paintInfo */, const LayoutPoint& /* paintOffset */)
+{
+    // For each rectangle, set it as the region rectangle and then let flow thread painting do the rest.
+    // We make multiple calls to paintIntoRegion, changing the rectangles each time.
+    if (!columnCount())
+        return;
+        
+    // FIXME: Implement.
+}
+
 const char* RenderMultiColumnSet::renderName() const
 {    

trunk/Source/WebCore/rendering/RenderMultiColumnSet.h

@@ -66 +66 @@
     virtual void computeLogicalHeight() OVERRIDE;
 
+    virtual void paintReplaced(PaintInfo&, const LayoutPoint& paintOffset) OVERRIDE;
+
     virtual LayoutUnit logicalWidthForFlowThreadContent() const OVERRIDE { return m_columnWidth; }
     virtual LayoutUnit logicalHeightForFlowThreadContent() const OVERRIDE { return m_columnHeight; } // FIXME: Will be wrong once we have multiple sets.
 
     virtual const char* renderName() const;
+    
+    void paintColumnRules(PaintInfo&, const LayoutPoint& paintOffset);
+    void paintColumnContents(PaintInfo&, const LayoutPoint& paintOffset);
+
+    LayoutUnit columnGap() const;
+    LayoutRect columnRectAt( unsigned index) const;
     
     unsigned m_columnCount;

trunk/Source/WebCore/rendering/RenderRegion.cpp

@@ -192 +192 @@
 }
 
-void RenderRegion::attachRegion()
+void RenderRegion::installFlowThread()
 {
     ASSERT(view());
-    ASSERT(!m_flowThread);
-    // Initialize the flow thread reference and create the flow thread object if needed.
-    // The flow thread lifetime is influenced by the number of regions attached to it,
-    // and we are attaching the region to the flow thread.
+
     m_flowThread = view()->flowThreadController()->ensureRenderFlowThreadWithName(style()->regionThread());
-
-    // A region is valid if it is not part of a circular reference, which is checked below
-    // and in RenderNamedFlowThread::addRegionToThread.
-    setIsValid(false);
 
     // By now the flow thread should already be added to the rendering tree,
@@ -215 +208 @@
             // Do not take into account a region that links a flow with itself. The dependency
             // cannot change, so it is not worth adding it to the list.
-            if (m_flowThread == m_parentNamedFlowThread) {
+            if (m_flowThread == m_parentNamedFlowThread)
                 m_flowThread = 0;
-                // This region is not valid for this flow thread (as being part of a circular dependency).
-                setIsValid(false);
-                return;
-            }
             break;
         }
     }
+}
+
+void RenderRegion::attachRegion()
+{
+    if (documentBeingDestroyed())
+        return;
+    
+    // A region starts off invalid.
+    setIsValid(false);
+
+    // Initialize the flow thread reference and create the flow thread object if needed.
+    // The flow thread lifetime is influenced by the number of regions attached to it,
+    // and we are attaching the region to the flow thread.
+    installFlowThread();
+    
+    if (!m_flowThread)
+        return;
 
     m_flowThread->addRegionToThread(this);

trunk/Source/WebCore/rendering/RenderRegion.h

@@ -98 +98 @@
     virtual LayoutUnit logicalHeightForFlowThreadContent() const;
 
+protected:
+    void setRegionObjectsRegionStyle();
+    void restoreRegionObjectsOriginalStyle();
+    
 private:
     virtual const char* renderName() const { return "RenderRegion"; }
@@ -104 +108 @@
     virtual void willBeRemovedFromTree() OVERRIDE;
 
+    virtual void installFlowThread();
+
     PassRefPtr<RenderStyle> computeStyleInRegion(const RenderObject*);
     void computeChildrenStyleInRegion(const RenderObject*);
-    void setRegionObjectsRegionStyle();
-    void restoreRegionObjectsOriginalStyle();
     void setObjectStyleInRegion(RenderObject*, PassRefPtr<RenderStyle>, bool objectRegionStyleCached);
     void printRegionObjectsStyles();
@@ -113 +117 @@
     void checkRegionStyle();
 
+protected:
     RenderFlowThread* m_flowThread;
 
+private:
     // If this RenderRegion is displayed as part of another named flow,
     // we need to create a dependency tree, so that layout of the

trunk/Source/WebCore/rendering/RenderRegionSet.cpp

@@ -34 +34 @@
 }
 
+void RenderRegionSet::installFlowThread()
+{
+    // We don't have to do anything, since we were able to connect the flow thread
+    // in the constructor.
 }
+
+}

trunk/Source/WebCore/rendering/RenderRegionSet.h

@@ -51 +51 @@
     
 private:
+    virtual void installFlowThread() OVERRIDE;
+
     virtual const char* renderName() const = 0;
 };