Index: Source/core/rendering/RenderMultiColumnSet.h |
diff --git a/Source/core/rendering/RenderMultiColumnSet.h b/Source/core/rendering/RenderMultiColumnSet.h |
index 263055e34947fc87a7c3125c1b29bcdbd928f925..68674d967177294d9ab0231906837afce8f640e7 100644 |
--- a/Source/core/rendering/RenderMultiColumnSet.h |
+++ b/Source/core/rendering/RenderMultiColumnSet.h |
@@ -27,6 +27,7 @@ |
#ifndef RenderMultiColumnSet_h |
#define RenderMultiColumnSet_h |
+#include "core/rendering/MultiColumnRow.h" |
#include "core/rendering/RenderMultiColumnFlowThread.h" |
#include "core/rendering/RenderRegion.h" |
#include "wtf/Vector.h" |
@@ -50,16 +51,19 @@ namespace blink { |
// |
// Column spans result in the creation of new column sets, since a spanning renderer has to be |
// placed in between the column sets that come before and after the span. |
+// |
+// A multi column set has one or more column rows (MultiColumnRow objects). If we're inside another |
+// fragmentation context, there will be one row established for each outer fragmentainer (page, |
+// column, etc.) that this set lives in. If we're not inside another fragmentation context, on the |
+// other hand, there will only be one row. |
class RenderMultiColumnSet : public RenderRegion { |
Julien - ping for review
2015/01/29 17:37:47
It would be nice to know how much is left of Rende
mstensho (USE GERRIT)
2015/02/02 17:57:24
Yeah, those are interesting thoughts. I think Rend
|
public: |
- enum BalancedHeightCalculation { GuessFromFlowThreadPortion, StretchBySpaceShortage }; |
- |
static RenderMultiColumnSet* createAnonymous(RenderFlowThread*, RenderStyle* parentStyle); |
virtual bool isOfType(RenderObjectType type) const override { return type == RenderObjectRenderMultiColumnSet || RenderRegion::isOfType(type); } |
- virtual LayoutUnit pageLogicalWidth() const override final { return flowThread()->logicalWidth(); } |
- virtual LayoutUnit pageLogicalHeight() const override final { return m_columnHeight; } |
+ virtual LayoutUnit pageLogicalWidth() const final { return flowThread()->logicalWidth(); } |
+ virtual LayoutUnit pageLogicalHeight() const final; |
RenderBlockFlow* multiColumnBlockFlow() const { return toRenderBlockFlow(parent()); } |
RenderMultiColumnFlowThread* multiColumnFlowThread() const |
@@ -71,11 +75,9 @@ public: |
RenderMultiColumnSet* nextSiblingMultiColumnSet() const; |
RenderMultiColumnSet* previousSiblingMultiColumnSet() const; |
- void setLogicalTopInFlowThread(LayoutUnit); |
- LayoutUnit logicalTopInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().y() : flowThreadPortionRect().x(); } |
- LayoutUnit logicalHeightInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().height() : flowThreadPortionRect().width(); } |
- void setLogicalBottomInFlowThread(LayoutUnit); |
- LayoutUnit logicalBottomInFlowThread() const { return isHorizontalWritingMode() ? flowThreadPortionRect().maxY() : flowThreadPortionRect().maxX(); } |
+ LayoutUnit logicalTopInFlowThread() const; |
+ LayoutUnit logicalBottomInFlowThread() const; |
+ LayoutUnit logicalHeightInFlowThread() const { return logicalBottomInFlowThread() - logicalTopInFlowThread(); } |
// The used CSS value of column-count, i.e. how many columns there are room for without overflowing. |
unsigned usedColumnCount() const { return multiColumnFlowThread()->columnCount(); } |
@@ -86,10 +88,7 @@ public: |
// get from flow thread coordinates to visual coordinates. |
LayoutSize flowThreadTranslationAtOffset(LayoutUnit) const; |
- LayoutUnit heightAdjustedForSetOffset(LayoutUnit height) const; |
- |
- void updateMinimumColumnHeight(LayoutUnit height) { m_minimumColumnHeight = std::max(height, m_minimumColumnHeight); } |
- LayoutUnit minimumColumnHeight() const { return m_minimumColumnHeight; } |
+ void updateMinimumColumnHeight(LayoutUnit offsetInFlowThread, LayoutUnit height); |
// Add a content run, specified by its end position. A content run is appended at every |
// forced/explicit break and at the end of the column set. The content runs are used to |
@@ -100,13 +99,13 @@ public: |
// (Re-)calculate the column height if it's auto. This is first and foremost needed by sets that |
// are to balance the column height, but even when it isn't to be balanced, this is necessary if |
// the multicol container's height is constrained. |
- virtual bool recalculateColumnHeight(BalancedHeightCalculation); |
+ bool recalculateColumnHeight(BalancedColumnHeightCalculation); |
// Record space shortage (the amount of space that would have been enough to prevent some |
// element from being moved to the next column) at a column break. The smallest amount of space |
// shortage we find is the amount with which we will stretch the column height, if it turns out |
// after layout that the columns weren't tall enough. |
- void recordSpaceShortage(LayoutUnit spaceShortage); |
+ void recordSpaceShortage(LayoutUnit offsetInFlowThread, LayoutUnit); |
// Reset previously calculated column height. Will mark for layout if needed. |
void resetColumnHeight(); |
@@ -115,6 +114,7 @@ public: |
// happens at the beginning of flow thread layout, and when advancing from a previous column set |
// or spanner to this one. |
void beginFlow(LayoutUnit offsetInFlowThread); |
+ |
// Layout of flow thread content that was to be rendered inside this column set has |
// finished. This happens at end of flow thread layout, and when advancing to the next column |
// set or spanner. |
@@ -143,6 +143,29 @@ protected: |
RenderMultiColumnSet(RenderFlowThread*); |
private: |
+ MultiColumnRow* firstColumnRow() |
+ { |
+ // FIXME: support multiple rows. |
+ return &m_columnRow; |
+ } |
+ MultiColumnRow* lastColumnRow() |
Julien - ping for review
2015/01/29 17:37:47
Do we really want first / last? How about just som
mstensho (USE GERRIT)
2015/02/02 17:57:24
The first and the last groups are of special signi
|
+ { |
+ // FIXME: support multiple rows. |
+ return &m_columnRow; |
+ } |
+ MultiColumnRow* columnRowAtFlowThreadOffset(LayoutUnit); |
+ const MultiColumnRow* firstColumnRow() const |
+ { |
+ // FIXME: support multiple rows. |
+ return &m_columnRow; |
+ } |
+ const MultiColumnRow* lastColumnRow() const |
+ { |
+ // FIXME: support multiple rows. |
+ return &m_columnRow; |
+ } |
+ const MultiColumnRow* columnRowAtFlowThreadOffset(LayoutUnit) const; |
+ |
virtual void insertedIntoTree() override final; |
virtual void willBeRemovedFromTree() override final; |
@@ -156,82 +179,10 @@ private: |
virtual const char* renderName() const override; |
- LayoutUnit calculateMaxColumnHeight() const; |
- LayoutRect columnRectAt(unsigned index) const; |
- |
- |
- LayoutRect flowThreadPortionRectAt(unsigned index) const; |
- LayoutRect flowThreadPortionOverflowRect(const LayoutRect& flowThreadPortion, unsigned index, unsigned colCount, LayoutUnit colGap) const; |
- |
- enum ColumnIndexCalculationMode { |
- ClampToExistingColumns, // Stay within the range of already existing columns. |
- AssumeNewColumns // Allow column indices outside the range of already existing columns. |
- }; |
- unsigned columnIndexAtOffset(LayoutUnit, ColumnIndexCalculationMode = ClampToExistingColumns) const; |
- |
- void setAndConstrainColumnHeight(LayoutUnit); |
- |
- // Return the index of the content run with the currently tallest columns, taking all implicit |
- // breaks assumed so far into account. |
- unsigned findRunWithTallestColumns() const; |
- |
- // Given the current list of content runs, make assumptions about where we need to insert |
- // implicit breaks (if there's room for any at all; depending on the number of explicit breaks), |
- // and store the results. This is needed in order to balance the columns. |
- void distributeImplicitBreaks(); |
- |
- LayoutUnit calculateColumnHeight(BalancedHeightCalculation) const; |
- |
- LayoutUnit m_columnHeight; |
- |
- // The following variables are used when balancing the column set. |
- LayoutUnit m_maxColumnHeight; // Maximum column height allowed. |
- LayoutUnit m_minSpaceShortage; // The smallest amout of space shortage that caused a column break. |
- LayoutUnit m_minimumColumnHeight; |
- |
- // A run of content without explicit (forced) breaks; i.e. a flow thread portion between two |
- // explicit breaks, between flow thread start and an explicit break, between an explicit break |
- // and flow thread end, or, in cases when there are no explicit breaks at all: between flow |
- // thread portion start and flow thread portion end. We need to know where the explicit breaks |
- // are, in order to figure out where the implicit breaks will end up, so that we get the columns |
- // properly balanced. A content run starts out as representing one single column, and will |
- // represent one additional column for each implicit break "inserted" there. |
- class ContentRun { |
- public: |
- ContentRun(LayoutUnit breakOffset) |
- : m_breakOffset(breakOffset) |
- , m_assumedImplicitBreaks(0) { } |
- |
- unsigned assumedImplicitBreaks() const { return m_assumedImplicitBreaks; } |
- void assumeAnotherImplicitBreak() { m_assumedImplicitBreaks++; } |
- LayoutUnit breakOffset() const { return m_breakOffset; } |
- |
- // Return the column height that this content run would require, considering the implicit |
- // breaks assumed so far. |
- LayoutUnit columnLogicalHeight(LayoutUnit startOffset) const { return ceilf((m_breakOffset - startOffset).toFloat() / float(m_assumedImplicitBreaks + 1)); } |
- |
- private: |
- LayoutUnit m_breakOffset; // Flow thread offset where this run ends. |
- unsigned m_assumedImplicitBreaks; // Number of implicit breaks in this run assumed so far. |
- }; |
- Vector<ContentRun, 1> m_contentRuns; |
-}; |
+ virtual LayoutRect flowThreadPortionRect() const override; |
-inline void RenderMultiColumnSet::beginFlow(LayoutUnit offsetInFlowThread) |
-{ |
- // At this point layout is exactly at the beginning of this set. Store block offset from flow |
- // thread start. |
- setLogicalTopInFlowThread(offsetInFlowThread); |
-} |
- |
-inline void RenderMultiColumnSet::endFlow(LayoutUnit offsetInFlowThread) |
-{ |
- // At this point layout is exactly at the end of this set. Store block offset from flow thread |
- // start. This set is now considered "flowed", although we may have to revisit it later (with |
- // beginFlow()), e.g. if a subtree in the flow thread has to be laid out over again because the |
- // initial margin collapsing estimates were wrong. |
- setLogicalBottomInFlowThread(offsetInFlowThread); |
-} |
+ MultiColumnRow m_columnRow; // FIXME: Need to support multiple rows. |
+}; |
DEFINE_RENDER_OBJECT_TYPE_CASTS(RenderMultiColumnSet, isRenderMultiColumnSet()); |