RenderTreeBuilderMultiColumn.cpp [plain text]
#include "config.h"
#include "RenderTreeBuilderMultiColumn.h"
#include "RenderBlockFlow.h"
#include "RenderChildIterator.h"
#include "RenderMultiColumnFlow.h"
#include "RenderMultiColumnSet.h"
#include "RenderMultiColumnSpannerPlaceholder.h"
#include "RenderTreeBuilder.h"
#include "RenderTreeBuilderBlock.h"
namespace WebCore {
static RenderMultiColumnSet* findSetRendering(const RenderMultiColumnFlow& fragmentedFlow, const RenderObject& renderer)
{
for (auto* multicolSet = fragmentedFlow.firstMultiColumnSet(); multicolSet; multicolSet = multicolSet->nextSiblingMultiColumnSet()) {
if (multicolSet->containsRendererInFragmentedFlow(renderer))
return multicolSet;
}
return nullptr;
}
static RenderObject* spannerPlacehoderCandidate(const RenderObject& renderer, const RenderMultiColumnFlow& stayWithin)
{
if (renderer.isOutOfFlowPositioned())
return nullptr;
ASSERT(renderer.isDescendantOf(&stayWithin));
auto* current = &renderer;
while (true) {
auto* nextSibling = current->nextSibling();
while (nextSibling && nextSibling->isOutOfFlowPositioned())
nextSibling = nextSibling->nextSibling();
if (nextSibling)
return nextSibling;
current = current->parent();
if (!current || current == &stayWithin || current->isOutOfFlowPositioned())
return nullptr;
}
return nullptr;
}
static bool isValidColumnSpanner(const RenderMultiColumnFlow& fragmentedFlow, const RenderObject& descendant)
{
ASSERT(descendant.isDescendantOf(&fragmentedFlow));
if (!is<RenderBox>(descendant))
return false;
auto& descendantBox = downcast<RenderBox>(descendant);
if (descendantBox.isFloatingOrOutOfFlowPositioned())
return false;
if (descendantBox.style().columnSpan() != ColumnSpan::All)
return false;
auto* parent = descendantBox.parent();
if (!is<RenderBlockFlow>(*parent) || parent->childrenInline()) {
return false;
}
auto* enclosingFragmentedFlow = descendantBox.enclosingFragmentedFlow();
if (enclosingFragmentedFlow != &fragmentedFlow)
return false;
for (auto* ancestor = descendantBox.containingBlock(); ancestor; ancestor = ancestor->containingBlock()) {
if (is<RenderView>(*ancestor))
return false;
if (is<RenderFragmentedFlow>(*ancestor)) {
return ancestor == &fragmentedFlow;
}
if (is<RenderBlockFlow>(*ancestor) && downcast<RenderBlockFlow>(*ancestor).willCreateColumns())
return false;
ASSERT(ancestor->style().columnSpan() != ColumnSpan::All || !isValidColumnSpanner(fragmentedFlow, *ancestor));
if (ancestor->isUnsplittableForPagination())
return false;
}
ASSERT_NOT_REACHED();
return false;
}
RenderTreeBuilder::MultiColumn::MultiColumn(RenderTreeBuilder& builder)
: m_builder(builder)
{
}
void RenderTreeBuilder::MultiColumn::updateAfterDescendants(RenderBlockFlow& flow)
{
bool needsFragmentedFlow = flow.requiresColumns(flow.style().columnCount());
bool hasFragmentedFlow = flow.multiColumnFlow();
if (!hasFragmentedFlow && needsFragmentedFlow) {
createFragmentedFlow(flow);
return;
}
if (hasFragmentedFlow && !needsFragmentedFlow) {
destroyFragmentedFlow(flow);
return;
}
}
void RenderTreeBuilder::MultiColumn::createFragmentedFlow(RenderBlockFlow& flow)
{
flow.setChildrenInline(false); flow.deleteLines();
auto* enclosingflow = flow.enclosingFragmentedFlow();
if (is<RenderMultiColumnFlow>(enclosingflow)) {
auto& spanners = downcast<RenderMultiColumnFlow>(enclosingflow)->spannerMap();
Vector<RenderMultiColumnSpannerPlaceholder*> placeholdersToDelete;
for (auto& spannerAndPlaceholder : spanners) {
auto& placeholder = *spannerAndPlaceholder.value;
if (!placeholder.isDescendantOf(&flow))
continue;
placeholdersToDelete.append(&placeholder);
}
for (auto* placeholder : placeholdersToDelete) {
auto* spanner = placeholder->spanner();
if (!spanner) {
ASSERT_NOT_REACHED();
continue;
}
auto& spannerOriginalParent = *placeholder->parent();
auto spannerToReInsert = m_builder.detach(*spanner->parent(), *spanner);
m_builder.attach(spannerOriginalParent, WTFMove(spannerToReInsert));
}
}
auto newFragmentedFlow = WebCore::createRenderer<RenderMultiColumnFlow>(flow.document(), RenderStyle::createAnonymousStyleWithDisplay(flow.style(), DisplayType::Block));
newFragmentedFlow->initializeStyle();
auto& fragmentedFlow = *newFragmentedFlow;
m_builder.blockBuilder().attach(flow, WTFMove(newFragmentedFlow), nullptr);
m_builder.moveChildren(flow, fragmentedFlow, flow.firstChild(), &fragmentedFlow, RenderTreeBuilder::NormalizeAfterInsertion::Yes);
if (flow.isFieldset()) {
for (auto& box : childrenOfType<RenderBox>(fragmentedFlow)) {
if (box.isLegend())
m_builder.move(fragmentedFlow, flow, box, RenderTreeBuilder::NormalizeAfterInsertion::Yes);
}
}
flow.setMultiColumnFlow(fragmentedFlow);
}
void RenderTreeBuilder::MultiColumn::destroyFragmentedFlow(RenderBlockFlow& flow)
{
auto& multiColumnFlow = *flow.multiColumnFlow();
multiColumnFlow.deleteLines();
auto& spanners = multiColumnFlow.spannerMap();
Vector<RenderMultiColumnSpannerPlaceholder*> placeholdersToDelete;
for (auto& spannerAndPlaceholder : spanners)
placeholdersToDelete.append(spannerAndPlaceholder.value.get());
Vector<std::pair<RenderElement*, RenderPtr<RenderObject>>> parentAndSpannerList;
for (auto* placeholder : placeholdersToDelete) {
auto* spannerOriginalParent = placeholder->parent();
if (spannerOriginalParent == &multiColumnFlow)
spannerOriginalParent = &flow;
auto* spanner = placeholder->spanner();
parentAndSpannerList.append(std::make_pair(spannerOriginalParent, m_builder.detach(*spanner->parent(), *spanner)));
}
while (auto* columnSet = multiColumnFlow.firstMultiColumnSet())
m_builder.destroy(*columnSet);
flow.clearMultiColumnFlow();
m_builder.moveAllChildren(multiColumnFlow, flow, RenderTreeBuilder::NormalizeAfterInsertion::Yes);
m_builder.destroy(multiColumnFlow);
for (auto& parentAndSpanner : parentAndSpannerList)
m_builder.attach(*parentAndSpanner.first, WTFMove(parentAndSpanner.second));
}
RenderObject* RenderTreeBuilder::MultiColumn::resolveMovedChild(RenderFragmentedFlow& enclosingFragmentedFlow, RenderObject* beforeChild)
{
if (!beforeChild)
return nullptr;
if (!is<RenderBox>(*beforeChild))
return beforeChild;
if (!is<RenderMultiColumnFlow>(enclosingFragmentedFlow))
return beforeChild;
if (beforeChild->style().columnSpan() != ColumnSpan::All)
return beforeChild;
if (auto* placeholder = downcast<RenderMultiColumnFlow>(enclosingFragmentedFlow).findColumnSpannerPlaceholder(downcast<RenderBox>(beforeChild)))
return placeholder;
return beforeChild;
}
static bool gShiftingSpanner = false;
void RenderTreeBuilder::MultiColumn::multiColumnDescendantInserted(RenderMultiColumnFlow& flow, RenderObject& newDescendant)
{
if (gShiftingSpanner || newDescendant.isInFlowRenderFragmentedFlow())
return;
auto* subtreeRoot = &newDescendant;
auto* descendant = subtreeRoot;
while (descendant) {
if (is<RenderMultiColumnFlow>(*descendant)) {
descendant = descendant->nextSibling();
continue;
}
if (is<RenderMultiColumnSpannerPlaceholder>(*descendant)) {
RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*descendant);
ASSERT(!flow.spannerMap().get(placeholder.spanner()));
flow.spannerMap().add(placeholder.spanner(), makeWeakPtr(downcast<RenderMultiColumnSpannerPlaceholder>(descendant)));
ASSERT(!placeholder.firstChild()); } else
descendant = processPossibleSpannerDescendant(flow, subtreeRoot, *descendant);
if (descendant)
descendant = descendant->nextInPreOrder(subtreeRoot);
}
}
RenderObject* RenderTreeBuilder::MultiColumn::processPossibleSpannerDescendant(RenderMultiColumnFlow& flow, RenderObject*& subtreeRoot, RenderObject& descendant)
{
RenderBlockFlow* multicolContainer = flow.multiColumnBlockFlow();
RenderObject* nextRendererInFragmentedFlow = spannerPlacehoderCandidate(descendant, flow);
RenderObject* insertBeforeMulticolChild = nullptr;
RenderObject* nextDescendant = &descendant;
if (isValidColumnSpanner(flow, descendant)) {
RenderBlockFlow* container = downcast<RenderBlockFlow>(descendant.parent());
RenderMultiColumnSet* setToSplit = nullptr;
if (nextRendererInFragmentedFlow) {
setToSplit = findSetRendering(flow, descendant);
if (setToSplit) {
setToSplit->setNeedsLayout();
insertBeforeMulticolChild = setToSplit->nextSibling();
}
}
auto newPlaceholder = RenderMultiColumnSpannerPlaceholder::createAnonymous(flow, downcast<RenderBox>(descendant), container->style());
auto& placeholder = *newPlaceholder;
m_builder.attach(*container, WTFMove(newPlaceholder), descendant.nextSibling());
auto takenDescendant = m_builder.detach(*container, descendant);
gShiftingSpanner = true;
m_builder.blockBuilder().attach(*multicolContainer, WTFMove(takenDescendant), insertBeforeMulticolChild);
gShiftingSpanner = false;
if (subtreeRoot == &descendant)
subtreeRoot = &placeholder;
nextDescendant = &placeholder;
} else {
if (is<RenderMultiColumnSpannerPlaceholder>(nextRendererInFragmentedFlow)) {
RenderMultiColumnSpannerPlaceholder& placeholder = downcast<RenderMultiColumnSpannerPlaceholder>(*nextRendererInFragmentedFlow);
if (RenderObject* previous = placeholder.spanner()->previousSibling()) {
if (is<RenderMultiColumnSet>(*previous))
return nextDescendant; }
insertBeforeMulticolChild = placeholder.spanner();
} else if (RenderMultiColumnSet* lastSet = flow.lastMultiColumnSet()) {
if (!lastSet->nextSibling())
return nextDescendant;
}
}
auto newSet = createRenderer<RenderMultiColumnSet>(flow, RenderStyle::createAnonymousStyleWithDisplay(multicolContainer->style(), DisplayType::Block));
newSet->initializeStyle();
auto& set = *newSet;
m_builder.blockBuilder().attach(*multicolContainer, WTFMove(newSet), insertBeforeMulticolChild);
flow.invalidateFragments();
ASSERT_UNUSED(set, !RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(&set)
|| !RenderMultiColumnFlow::previousColumnSetOrSpannerSiblingOf(&set)->isRenderMultiColumnSet());
ASSERT(!RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(&set)
|| !RenderMultiColumnFlow::nextColumnSetOrSpannerSiblingOf(&set)->isRenderMultiColumnSet());
return nextDescendant;
}
void RenderTreeBuilder::MultiColumn::handleSpannerRemoval(RenderMultiColumnFlow& flow, RenderObject& spanner)
{
if (auto placeholder = flow.spannerMap().take(&downcast<RenderBox>(spanner)))
m_builder.destroy(*placeholder);
if (auto* next = spanner.nextSibling()) {
if (auto* previous = spanner.previousSibling()) {
if (previous->isRenderMultiColumnSet() && next->isRenderMultiColumnSet()) {
m_builder.destroy(*next);
previous->setNeedsLayout();
}
}
}
}
void RenderTreeBuilder::MultiColumn::multiColumnRelativeWillBeRemoved(RenderMultiColumnFlow& flow, RenderObject& relative)
{
flow.invalidateFragments();
if (is<RenderMultiColumnSpannerPlaceholder>(relative)) {
ASSERT(relative.isDescendantOf(&flow));
flow.spannerMap().remove(downcast<RenderMultiColumnSpannerPlaceholder>(relative).spanner());
return;
}
if (relative.style().columnSpan() == ColumnSpan::All) {
if (relative.parent() != flow.parent())
return;
handleSpannerRemoval(flow, relative);
}
}
RenderObject* RenderTreeBuilder::MultiColumn::adjustBeforeChildForMultiColumnSpannerIfNeeded(RenderObject& beforeChild)
{
if (!is<RenderBox>(beforeChild))
return &beforeChild;
auto* nextSibling = beforeChild.nextSibling();
if (!nextSibling)
return &beforeChild;
if (!is<RenderMultiColumnSet>(*nextSibling))
return &beforeChild;
auto* multiColumnFlow = downcast<RenderMultiColumnSet>(*nextSibling).multiColumnFlow();
if (!multiColumnFlow)
return &beforeChild;
return multiColumnFlow->findColumnSpannerPlaceholder(downcast<RenderBox>(&beforeChild));
}
}