Initial support for nested multicol layout.

Source/core/layout/LayoutMultiColumnFlowThread.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 10 matching lines @@
  * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  * OF THIS SOFTWARE, EVEN IF  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 
 #include "config.h"
 #include "core/layout/LayoutMultiColumnFlowThread.h"
 
 #include "core/layout/LayoutMultiColumnSet.h"
 #include "core/layout/LayoutMultiColumnSpannerPlaceholder.h"
+#include "core/layout/MultiColumnFragmentainerGroup.h"
 
 namespace blink {
 
 LayoutMultiColumnFlowThread::LayoutMultiColumnFlowThread()
     : m_lastSetWorkedOn(nullptr)
     , m_columnCount(1)
     , m_columnHeightAvailable(0)
     , m_inBalancingPass(false)
     , m_needsColumnHeightsRecalculation(false)
     , m_progressionIsInline(true)
@@ skipping 222 matching lines @@
     destroy();
 }
 
 LayoutSize LayoutMultiColumnFlowThread::columnOffset(const LayoutPoint& point) const
 {
     if (!hasValidColumnSetInfo())
         return LayoutSize(0, 0);
 
     LayoutPoint flowThreadPoint = flipForWritingMode(point);
     LayoutUnit blockOffset = isHorizontalWritingMode() ? flowThreadPoint.y() : flowThreadPoint.x();
-    LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(blockOffset);
-    if (!columnSet)
-        return LayoutSize(0, 0);
-    return columnSet->flowThreadTranslationAtOffset(blockOffset);
+    return flowThreadTranslationAtOffset(blockOffset);
 }
 
 bool LayoutMultiColumnFlowThread::needsNewWidth() const
 {
     LayoutUnit newWidth;
     unsigned dummyColumnCount; // We only care if used column-width changes.
     calculateColumnCountAndWidth(newWidth, dummyColumnCount);
     return newWidth != logicalWidth();
 }
 
+bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
+{
+    if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
+        return columnSet->isPageLogicalHeightKnown();
+    return false;
+}
+
+LayoutSize LayoutMultiColumnFlowThread::flowThreadTranslationAtOffset(LayoutUnit offsetInFlowThread) const
+{
+    LayoutMultiColumnSet* columnSet = columnSetAtBlockOffset(offsetInFlowThread);
+    if (!columnSet)
+        return LayoutSize(0, 0);
+    return columnSet->flowThreadTranslationAtOffset(offsetInFlowThread);
+}
+
 LayoutPoint LayoutMultiColumnFlowThread::visualPointToFlowThreadPoint(const LayoutPoint& visualPoint) const
 {
     LayoutUnit blockOffset = isHorizontalWritingMode() ? visualPoint.y() : visualPoint.x();
     const LayoutMultiColumnSet* columnSet = nullptr;
     for (const LayoutMultiColumnSet* candidate = firstMultiColumnSet(); candidate; candidate = candidate->nextSiblingMultiColumnSet()) {
         columnSet = candidate;
         if (candidate->logicalBottom() > blockOffset)
             break;
     }
     return columnSet ? columnSet->visualPointToFlowThreadPoint(toLayoutPoint(visualPoint + location() - columnSet->location())) : visualPoint;
@@ skipping 40 matching lines @@
     if (!needsLayout()) {
         // Just before the multicol container (our parent LayoutBlockFlow) 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.
         return;
     }
 
+    m_blockOffsetInEnclosingFlowThread = enclosingFlowThread() ? multiColumnBlockFlow()->offsetFromLogicalTopOfFirstPage() : LayoutUnit();
+
     for (LayoutBox* columnBox = firstMultiColumnBox(); columnBox; columnBox = columnBox->nextSiblingMultiColumnBox()) {
         if (!columnBox->isLayoutMultiColumnSet()) {
             ASSERT(columnBox->isLayoutMultiColumnSpannerPlaceholder()); // no other type is expected.
             m_needsColumnHeightsRecalculation = true;
             continue;
         }
         LayoutMultiColumnSet* columnSet = toLayoutMultiColumnSet(columnBox);
         if (!m_inBalancingPass) {
             // This is the initial layout pass. We need to reset the column height, because contents
             // typically have changed.
@@ skipping 57 matching lines @@
 
     // We may have a new containing block, since we're no longer a spanner. Mark it for relayout.
     spannerObjectInFlowThread->containingBlock()->setNeedsLayoutAndPrefWidthsRecalc(LayoutInvalidationReason::ColumnsChanged);
 
     // Now generate a column set for this ex-spanner, if needed and none is there for us already.
     flowThreadDescendantWasInserted(spannerObjectInFlowThread);
 
     return true;
 }
 
+LayoutMultiColumnFlowThread* LayoutMultiColumnFlowThread::enclosingFlowThread() const
+{
+    if (multiColumnBlockFlow()->isInsideFlowThread())
+        return toLayoutMultiColumnFlowThread(locateFlowThreadContainingBlockOf(*multiColumnBlockFlow()));
+    return nullptr;
+}
+
+bool LayoutMultiColumnFlowThread::hasFragmentainerGroupForColumnAt(LayoutUnit offsetInFlowThread) const
+{
+    // If there's no enclosing flow thread, there'll always be only one fragmentainer group, and it
+    // can hold as many columns as we like. We shouldn't even be here in that case.
+    ASSERT(enclosingFlowThread());
+
+    LayoutMultiColumnSet* lastColumnSet = lastMultiColumnSet();
+    if (!lastColumnSet) {
+        ASSERT_NOT_REACHED();
+        return true;
+    }
+    if (lastColumnSet->logicalTopInFlowThread() > offsetInFlowThread)
+        return true;
+    const MultiColumnFragmentainerGroup& lastRow = lastColumnSet->lastFragmentainerGroup();
+    if (lastRow.logicalTopInFlowThread() > offsetInFlowThread)
+        return true;
+    return offsetInFlowThread - lastRow.logicalTopInFlowThread() < lastRow.logicalHeight() * lastColumnSet->usedColumnCount();
+}
+
+void LayoutMultiColumnFlowThread::appendNewFragmentainerGroupIfNeeded(LayoutUnit offsetInFlowThread)
+{
+    LayoutMultiColumnFlowThread* enclosingFlowThread = this->enclosingFlowThread();
+    if (!enclosingFlowThread)
+        return; // Not nested. We'll never need more rows than the one we already have then.
+    if (!hasFragmentainerGroupForColumnAt(offsetInFlowThread)) {
+        // We have run out of columns here, so we add another row to hold more columns. When we add
+        // a new row, it implicitly means that we're inserting another column in our enclosing
+        // multicol container. That in turn may mean that we've run out of columns there too.
+        const MultiColumnFragmentainerGroup& newRow = lastMultiColumnSet()->appendNewFragmentainerGroup();
+        enclosingFlowThread->appendNewFragmentainerGroupIfNeeded(newRow.blockOffsetInEnclosingFlowThread());
+    }
+}
+
 void LayoutMultiColumnFlowThread::calculateColumnCountAndWidth(LayoutUnit& width, unsigned& count) const
 {
     LayoutBlock* columnBlock = multiColumnBlockFlow();
     const ComputedStyle* columnStyle = columnBlock->style();
     LayoutUnit availableWidth = columnBlock->contentLogicalWidth();
     LayoutUnit columnGap = columnBlock->columnGap();
     LayoutUnit computedColumnWidth = max<LayoutUnit>(1, LayoutUnit(columnStyle->columnWidth()));
     unsigned computedColumnCount = max<int>(1, columnStyle->columnCount());
 
     ASSERT(!columnStyle->hasAutoColumnCount() || !columnStyle->hasAutoColumnWidth());
@@ skipping 475 matching lines @@
 {
     if (LayoutMultiColumnSet* multicolSet = columnSetAtBlockOffset(offset)) {
         multicolSet->addContentRun(offset);
         if (offsetBreakAdjustment)
             *offsetBreakAdjustment = pageLogicalHeightForOffset(offset) ? pageRemainingLogicalHeightForOffset(offset, AssociateWithFormerPage) : LayoutUnit();
         return true;
     }
     return false;
 }
 
-bool LayoutMultiColumnFlowThread::isPageLogicalHeightKnown() const
-{
-    if (LayoutMultiColumnSet* columnSet = lastMultiColumnSet())
-        return columnSet->isPageLogicalHeightKnown();
-    return false;
-}
-
 }