[New Multicolumn] Layout support for column-span:all.

Source/core/rendering/RenderMultiColumnFlowThread.cpp

 /*
  * Copyright (C) 2012 Apple Inc.  All rights reserved.
  *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
@@ skipping 14 matching lines @@
 
 #include "config.h"
 #include "core/rendering/RenderMultiColumnFlowThread.h"
 
 #include "core/rendering/RenderMultiColumnSet.h"
 #include "core/rendering/RenderMultiColumnSpannerPlaceholder.h"
 
 namespace blink {
 
 RenderMultiColumnFlowThread::RenderMultiColumnFlowThread()
-    : m_columnCount(1)
+    : m_lastSetWorkedOn(0)
+    , m_columnCount(1)
     , m_columnHeightAvailable(0)
     , m_inBalancingPass(false)
     , m_needsColumnHeightsRecalculation(false)
     , m_progressionIsInline(true)
     , m_isBeingEvacuated(false)
 {
     setFlowThreadState(InsideInFlowThread);
 }
 
 RenderMultiColumnFlowThread::~RenderMultiColumnFlowThread()
@@ skipping 97 matching lines @@
 }
 
 bool RenderMultiColumnFlowThread::needsNewWidth() const
 {
     LayoutUnit newWidth;
     unsigned dummyColumnCount; // We only care if used column-width changes.
     calculateColumnCountAndWidth(newWidth, dummyColumnCount);
     return newWidth != logicalWidth();
 }
 
+RenderMultiColumnSet* RenderMultiColumnFlowThread::columnSetAtBlockOffset(LayoutUnit offset) const
+{
+    if (m_lastSetWorkedOn) {
+        // Layout in progress. We are calculating the set heights as we speak, so the column set range
+        // information is not up-to-date.
+        return m_lastSetWorkedOn;
+    }
+
+    ASSERT(!m_regionsInvalidated);
+    if (m_multiColumnSetList.isEmpty())
+        return 0;
+    if (offset <= 0)
+        return m_multiColumnSetList.first();
+
+    MultiColumnSetSearchAdapter adapter(offset);
+    m_multiColumnSetIntervalTree.allOverlapsWithAdapter<MultiColumnSetSearchAdapter>(adapter);
+
+    // If no set was found, the offset is in the flow thread overflow.
+    if (!adapter.result() && !m_multiColumnSetList.isEmpty())
+        return m_multiColumnSetList.last();
+    return adapter.result();
+}
+
 void RenderMultiColumnFlowThread::layoutColumns(bool relayoutChildren, SubtreeLayoutScope& layoutScope)
 {
     if (relayoutChildren)
         layoutScope.setChildNeedsLayout(this);
 
+    m_needsColumnHeightsRecalculation = false;
     if (!needsLayout()) {
         // Just before the multicol container (our parent RenderBlockFlow) finishes laying out, it
         // will call recalculateColumnHeights() on us unconditionally, but we only want that method
         // to do any work if we actually laid out the flow thread. Otherwise, the balancing
         // machinery would kick in needlessly, and trigger additional layout passes. Furthermore, we
         // actually depend on a proper flowthread layout pass in order to do balancing, since it's
         // flowthread layout that sets up content runs.
-        m_needsColumnHeightsRecalculation = false;
         return;
     }
 
-    for (RenderBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingBox()) {
+    for (RenderBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingMultiColumnBox()) {
         if (!columnBox->isRenderMultiColumnSet()) {
             ASSERT(columnBox->isRenderMultiColumnSpannerPlaceholder()); // no other type is expected.
+            m_needsColumnHeightsRecalculation = true;
             continue;
         }
         RenderMultiColumnSet* columnSet = toRenderMultiColumnSet(columnBox);
         if (!m_inBalancingPass) {
             // This is the initial layout pass. We need to reset the column height, because contents
             // typically have changed.
             columnSet->resetColumnHeight();
         }
+        if (!m_needsColumnHeightsRecalculation)
+            m_needsColumnHeightsRecalculation = columnSet->heightIsAuto();
     }
 
     invalidateRegions();
-    m_needsColumnHeightsRecalculation = heightIsAuto();
     layout();
 }
 
 bool RenderMultiColumnFlowThread::recalculateColumnHeights()
 {
     // All column sets that needed layout have now been laid out, so we can finally validate them.
     validateRegions();
 
     if (!m_needsColumnHeightsRecalculation)
         return false;
@@ skipping 126 matching lines @@
 {
     // Detach all column sets from the flow thread. Cannot destroy them at this point, since they
     // are siblings of this object, and there may be pointers to this object's sibling somewhere
     // further up on the call stack.
     for (RenderMultiColumnSet* columnSet = firstMultiColumnSet(); columnSet; columnSet = columnSet->nextSiblingMultiColumnSet())
         columnSet->detachRegion();
     multiColumnBlockFlow()->resetMultiColumnFlowThread();
     RenderFlowThread::willBeRemovedFromTree();
 }
 
+LayoutUnit RenderMultiColumnFlowThread::skipColumnSpanner(RenderBox* renderer, LayoutUnit logicalTopInFlowThread)
+{
+    ASSERT(renderer->isColumnSpanAll());
+    RenderMultiColumnSpannerPlaceholder* placeholder = renderer->spannerPlaceholder();
+    LayoutUnit adjustment;
+    RenderBox* previousColumnBox = placeholder->previousSiblingMultiColumnBox();
+    if (previousColumnBox && previousColumnBox->isRenderMultiColumnSet()) {
+        // Pad flow thread offset to a column boundary, so that any column content that's supposed
+        // to come after the spanner doesn't bleed into the column row preceding the spanner.
+        RenderMultiColumnSet* previousSet = toRenderMultiColumnSet(previousColumnBox);
+        if (previousSet->pageLogicalHeight()) {
+            LayoutUnit columnLogicalTopInFlowThread = previousSet->pageLogicalTopForOffset(logicalTopInFlowThread);
+            if (columnLogicalTopInFlowThread != logicalTopInFlowThread) {
+                adjustment = columnLogicalTopInFlowThread + previousSet->pageLogicalHeight() - logicalTopInFlowThread;
+                logicalTopInFlowThread += adjustment;
+            }
+        }
+        previousSet->endFlow(logicalTopInFlowThread);
+    }
+    RenderBox* nextColumnBox = placeholder->nextSiblingMultiColumnBox();
+    if (nextColumnBox && nextColumnBox->isRenderMultiColumnSet()) {
+        RenderMultiColumnSet* nextSet = toRenderMultiColumnSet(nextColumnBox);
+        m_lastSetWorkedOn = nextSet;
+        nextSet->beginFlow(logicalTopInFlowThread);
+    }
+    return adjustment;
+}
+
 void RenderMultiColumnFlowThread::flowThreadDescendantWasInserted(RenderObject* descendant)
 {
     ASSERT(!m_isBeingEvacuated);
     // Go through the subtree that was just inserted and create column sets (needed by regular
     // column content) and spanner placeholders (one needed by each spanner).
     for (RenderObject* renderer = descendant; renderer; renderer = renderer->nextInPreOrder(descendant)) {
         if (containingColumnSpannerPlaceholder(renderer))
             continue; // Inside a column spanner. Nothing to do, then.
         if (descendantIsValidColumnSpanner(renderer)) {
             // This renderer is a spanner, so it needs to establish a spanner placeholder.
@@ skipping 43 matching lines @@
 
 void RenderMultiColumnFlowThread::updateLogicalWidth()
 {
     LayoutUnit columnWidth;
     calculateColumnCountAndWidth(columnWidth, m_columnCount);
     setLogicalWidth(columnWidth);
 }
 
 void RenderMultiColumnFlowThread::layout()
 {
+    ASSERT(!m_lastSetWorkedOn);
+    m_lastSetWorkedOn = firstMultiColumnSet();
+    if (m_lastSetWorkedOn)
+        m_lastSetWorkedOn->beginFlow(LayoutUnit());
     RenderFlowThread::layout();
     if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) {
-        if (!lastSet->nextSiblingMultiColumnBox())
+        ASSERT(lastSet == m_lastSetWorkedOn);
+        if (!lastSet->nextSiblingMultiColumnBox()) {
+            lastSet->endFlow(logicalHeight());
             lastSet->expandToEncompassFlowThreadContentsIfNeeded();
+        }
     }
+    m_lastSetWorkedOn = 0;
 }
 
 void RenderMultiColumnFlowThread::setPageBreak(LayoutUnit offset, LayoutUnit spaceShortage)
 {
     // Only positive values are interesting (and allowed) here. Zero space shortage may be reported
     // when we're at the top of a column and the element has zero height. Ignore this, and also
     // ignore any negative values, which may occur when we set an early break in order to honor
     // widows in the next column.
     if (spaceShortage <= 0)
         return;
 
     if (RenderMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset))
         multicolSet->recordSpaceShortage(spaceShortage);
 }
 
 void RenderMultiColumnFlowThread::updateMinimumPageHeight(LayoutUnit offset, LayoutUnit minHeight)
 {
     if (RenderMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset))
         multicolSet->updateMinimumColumnHeight(minHeight);
 }
 
-RenderMultiColumnSet* RenderMultiColumnFlowThread::columnSetAtBlockOffset(LayoutUnit /*offset*/) const
-{
-    // For now there's only one column set, so this is easy:
-    return firstMultiColumnSet();
-}
-
 bool RenderMultiColumnFlowThread::addForcedRegionBreak(LayoutUnit offset, RenderObject* /*breakChild*/, bool /*isBefore*/, LayoutUnit* offsetBreakAdjustment)
 {
     if (RenderMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset)) {
         multicolSet->addContentRun(offset);
         if (offsetBreakAdjustment)
             *offsetBreakAdjustment = pageLogicalHeightForOffset(offset) ? pageRemainingLogicalHeightForOffset(offset, IncludePageBoundary) : LayoutUnit();
         return true;
     }
     return false;
 }
 
 bool RenderMultiColumnFlowThread::isPageLogicalHeightKnown() const
 {
     if (RenderMultiColumnSet* columnSet = lastMultiColumnSet())
         return columnSet->pageLogicalHeight();
     return false;
 }
 
 }