void RenderNamedFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
{
ASSERT(renderRegion);
m_regionRangeMap.clear();
m_regionList.remove(renderRegion);
if (renderRegion->parentNamedFlowThread()) {
if (!renderRegion->isValid()) {
renderRegion->parentNamedFlowThread()->m_observerThreadsSet.remove(this);
// No need to invalidate the regions rectangles. The removed region
// was not taken into account. Just return here.
return;
}
removeDependencyOnFlowThread(renderRegion->parentNamedFlowThread());
}
if (canBeDestroyed())
setMarkForDestruction();
// After removing all the regions in the flow the following layout needs to dispatch the regionLayoutUpdate event
if (m_regionList.isEmpty())
setDispatchRegionLayoutUpdateEvent(true);
invalidateRegions();
}
void RenderNamedFlowThread::checkInvalidRegions()
{
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
// The only reason a region would be invalid is because it has a parent flow thread.
ASSERT(region->isValid() || region->parentNamedFlowThread());
if (region->isValid() || region->parentNamedFlowThread()->dependsOn(this))
continue;
region->parentNamedFlowThread()->m_observerThreadsSet.remove(this);
addDependencyOnFlowThread(region->parentNamedFlowThread());
region->setIsValid(true);
invalidateRegions();
}
if (m_observerThreadsSet.isEmpty())
return;
// Notify all the flow threads that were dependent on this flow.
// Create a copy of the list first. That's because observers might change the list when calling checkInvalidRegions.
Vector<RenderNamedFlowThread*> observers;
copyToVector(m_observerThreadsSet, observers);
for (size_t i = 0; i < observers.size(); ++i) {
RenderNamedFlowThread* flowThread = observers.at(i);
flowThread->checkInvalidRegions();
}
}
void RenderNamedFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
{
ASSERT(renderRegion);
RenderNamedFlowFragment* renderNamedFlowFragment = toRenderNamedFlowFragment(renderRegion);
if (renderNamedFlowFragment->parentNamedFlowThread()) {
if (!renderNamedFlowFragment->isValid()) {
ASSERT(m_invalidRegionList.contains(renderNamedFlowFragment));
m_invalidRegionList.remove(renderNamedFlowFragment);
renderNamedFlowFragment->parentNamedFlowThread()->m_observerThreadsSet.remove(this);
// No need to invalidate the regions rectangles. The removed region
// was not taken into account. Just return here.
return;
}
removeDependencyOnFlowThread(renderNamedFlowFragment->parentNamedFlowThread());
}
ASSERT(m_regionList.contains(renderNamedFlowFragment));
bool wasFirst = m_regionList.first() == renderNamedFlowFragment;
m_regionList.remove(renderNamedFlowFragment);
if (canBeDestroyed())
setMarkForDestruction();
if (!m_regionList.isEmpty() && wasFirst)
updateWritingMode();
invalidateRegions();
}
void RenderNamedFlowThread::addRegionToThread(RenderRegion* renderRegion)
{
ASSERT(renderRegion);
if (m_regionList.isEmpty())
m_regionList.add(renderRegion);
else {
// Find the first region "greater" than renderRegion.
RenderRegionList::iterator it = m_regionList.begin();
while (it != m_regionList.end() && !compareRenderRegions(renderRegion, *it))
++it;
m_regionList.insertBefore(it, renderRegion);
}
resetMarkForDestruction();
ASSERT(!renderRegion->isValid());
if (renderRegion->parentNamedFlowThread()) {
if (renderRegion->parentNamedFlowThread()->dependsOn(this)) {
// Register ourself to get a notification when the state changes.
renderRegion->parentNamedFlowThread()->m_observerThreadsSet.add(this);
return;
}
addDependencyOnFlowThread(renderRegion->parentNamedFlowThread());
}
renderRegion->setIsValid(true);
invalidateRegions();
}
void RenderNamedFlowThread::checkInvalidRegions()
{
Vector<RenderNamedFlowFragment*> newValidFragments;
for (auto& region : m_invalidRegionList) {
RenderNamedFlowFragment* namedFlowFragment = toRenderNamedFlowFragment(region);
// The only reason a region would be invalid is because it has a parent flow thread.
ASSERT(!namedFlowFragment->isValid() && namedFlowFragment->parentNamedFlowThread());
if (namedFlowFragment->parentNamedFlowThread()->dependsOn(this))
continue;
newValidFragments.append(namedFlowFragment);
}
for (auto& namedFlowFragment : newValidFragments) {
m_invalidRegionList.remove(namedFlowFragment);
namedFlowFragment->parentNamedFlowThread()->m_observerThreadsSet.remove(this);
addFragmentToNamedFlowThread(namedFlowFragment);
}
if (!newValidFragments.isEmpty())
invalidateRegions();
if (m_observerThreadsSet.isEmpty())
return;
// Notify all the flow threads that were dependent on this flow.
// Create a copy of the list first. That's because observers might change the list when calling checkInvalidRegions.
Vector<RenderNamedFlowThread*> observers;
copyToVector(m_observerThreadsSet, observers);
for (auto& flowThread : observers)
flowThread->checkInvalidRegions();
}
void RenderFlowThread::addRegionToThread(RenderRegion* renderRegion)
{
ASSERT(renderRegion);
m_regionList.add(renderRegion);
renderRegion->setIsValid(true);
invalidateRegions();
}
void RenderFlowThread::removeRegionFromThread(RenderRegion* renderRegion)
{
ASSERT(renderRegion);
m_regionRangeMap.clear();
m_regionList.remove(renderRegion);
invalidateRegions();
}
void RenderNamedFlowThread::addRegionToThread(RenderRegion* renderRegion)
{
ASSERT(renderRegion);
ASSERT(!renderRegion->isValid());
resetMarkForDestruction();
if (renderRegion->parentNamedFlowThread() && renderRegion->parentNamedFlowThread()->dependsOn(this)) {
// The order of invalid regions is irrelevant.
m_invalidRegionList.add(renderRegion);
// Register ourself to get a notification when the state changes.
renderRegion->parentNamedFlowThread()->m_observerThreadsSet.add(this);
return;
}
addRegionToNamedFlowThread(renderRegion);
invalidateRegions();
}
void RenderFlowThread::markAutoLogicalHeightRegionsForLayout()
{
ASSERT(view()->layoutState());
ASSERT(view()->constrainedFlowThreadsLayoutPhase());
if (!hasAutoLogicalHeightRegions())
return;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->hasAutoLogicalHeight())
continue;
// FIXME: We need to find a way to avoid marking all the regions ancestors for layout
// as we are already inside layout.
region->setNeedsLayout(true);
}
invalidateRegions();
}
void RenderFlowThread::resetRegionsOverrideLogicalContentHeight()
{
ASSERT(view()->layoutState());
ASSERT(view()->normalLayoutPhase());
if (!hasAutoLogicalHeightRegions())
return;
for (RenderRegionList::iterator iter = m_regionList.begin(); iter != m_regionList.end(); ++iter) {
RenderRegion* region = *iter;
if (!region->hasAutoLogicalHeight())
continue;
region->clearOverrideLogicalContentHeight();
// FIXME: We need to find a way to avoid marking all the regions ancestors for layout
// as we are already inside layout.
region->setNeedsLayout(true);
}
// Make sure we don't skip any region breaks when we do the layout again.
// Using m_regionsInvalidated to force all the RenderFlowThread children do the layout again.
invalidateRegions();
}
void RenderMultiColumnFlowThread::autoGenerateRegionsToBlockOffset(LayoutUnit /*offset*/)
{
// This function ensures we have the correct column set information at all times.
// For a simple multi-column layout in continuous media, only one column set child is required.
// Once a column is nested inside an enclosing pagination context, the number of column sets
// required becomes 2n-1, where n is the total number of nested pagination contexts. For example:
//
// Column layout with no enclosing pagination model = 2 * 1 - 1 = 1 column set.
// Columns inside pages = 2 * 2 - 1 = 3 column sets (bottom of first page, all the subsequent pages, then the last page).
// Columns inside columns inside pages = 2 * 3 - 1 = 5 column sets.
//
// In addition, column spans will force a column set to "split" into before/after sets around the spanning element.
//
// Finally, we will need to deal with columns inside regions. If regions have variable widths, then there will need
// to be unique column sets created inside any region whose width is different from its surrounding regions. This is
// actually pretty similar to the spanning case, in that we break up the column sets whenever the width varies.
//
// FIXME: For now just make one column set. This matches the old multi-column code.
// Right now our goal is just feature parity with the old multi-column code so that we can switch over to the
// new code as soon as possible.
RenderMultiColumnSet* firstSet = toRenderMultiColumnSet(firstRegion());
if (firstSet)
return;
invalidateRegions();
RenderBlockFlow* parentBlock = toRenderBlockFlow(parent());
firstSet = new RenderMultiColumnSet(*this, RenderStyle::createAnonymousStyleWithDisplay(&parentBlock->style(), BLOCK));
firstSet->initializeStyle();
parentBlock->RenderBlock::addChild(firstSet);
// Even though we aren't placed yet, we can go ahead and set up our size. At this point we're
// typically in the middle of laying out the thread, attempting to paginate, and we need to do
// some rudimentary "layout" of the set now, so that pagination will work.
firstSet->prepareForLayout();
validateRegions();
}
void RenderMultiColumnFlowThread::flowThreadRelativeWillBeRemoved(RenderObject* relative)
{
if (m_beingEvacuated)
return;
invalidateRegions();
if (relative->isRenderMultiColumnSpannerPlaceholder()) {
// Remove the map entry for this spanner, but leave the actual spanner renderer alone. Also
// keep the reference to the spanner, since the placeholder may be about to be re-inserted
// in the tree.
ASSERT(relative->isDescendantOf(this));
m_spannerMap.remove(toRenderMultiColumnSpannerPlaceholder(relative)->spanner());
return;
}
if (relative->style().columnSpan() == ColumnSpanAll) {
if (relative->parent() != parent())
return; // not a valid spanner.
// The placeholder may already have been removed, but if it hasn't, do so now.
if (RenderMultiColumnSpannerPlaceholder* placeholder = m_spannerMap.get(toRenderBox(relative))) {
placeholder->parent()->removeChild(*placeholder);
m_spannerMap.remove(toRenderBox(relative));
}
if (RenderObject* next = relative->nextSibling()) {
if (RenderObject* previous = relative->previousSibling()) {
if (previous->isRenderMultiColumnSet() && next->isRenderMultiColumnSet()) {
// Merge two sets that no longer will be separated by a spanner.
next->destroy();
previous->setNeedsLayout();
}
}
}
}
// Note that we might end up with empty column sets if all column content is removed. That's no
// big deal though (and locating them would be expensive), and they will be found and re-used if
// content is added again later.
}
void RenderMultiColumnFlowThread::flowThreadDescendantInserted(RenderObject* descendant)
{
if (gShiftingSpanner || m_beingEvacuated || descendant->isInFlowRenderFlowThread())
return;
RenderObject* subtreeRoot = descendant;
for (; descendant; descendant = (descendant ? descendant->nextInPreOrder(subtreeRoot) : nullptr)) {
if (descendant->isRenderMultiColumnSpannerPlaceholder()) {
// A spanner's placeholder has been inserted. The actual spanner renderer is moved from
// where it would otherwise occur (if it weren't a spanner) to becoming a sibling of the
// column sets.
RenderMultiColumnSpannerPlaceholder* placeholder = toRenderMultiColumnSpannerPlaceholder(descendant);
if (placeholder->flowThread() != this) {
// This isn't our spanner! It shifted here from an ancestor multicolumn block. It's going to end up
// becoming our spanner instead, but for it to do that we first have to nuke the original spanner,
// and get the spanner content back into this flow thread.
RenderBox* spanner = placeholder->spanner();
// Get info for the move of the original content back into our flow thread.
RenderBoxModelObject* placeholderParent = toRenderBoxModelObject(placeholder->parent());
// We have to nuke the placeholder, since the ancestor already lost the mapping to it when
// we shifted the placeholder down into this flow thread.
RenderObject* placeholderNextSibling = placeholderParent->removeChild(*placeholder);
// Get the ancestor multicolumn flow thread to clean up its mess.
RenderBlockFlow* ancestorBlock = toRenderBlockFlow(spanner->parent());
ancestorBlock->multiColumnFlowThread()->flowThreadRelativeWillBeRemoved(spanner);
// Now move the original content into our flow thread. It will end up calling flowThreadDescendantInserted
// on the new content only, and everything will get set up properly.
ancestorBlock->moveChildTo(placeholderParent, spanner, placeholderNextSibling, true);
// Advance descendant.
descendant = placeholderNextSibling;
// If the spanner was the subtree root, then we're done, since there is nothing else left to insert.
if (!descendant)
return;
// Now that we have done this, we can continue past the spanning content, since we advanced
// descendant already.
if (descendant)
descendant = descendant->previousInPreOrder(subtreeRoot);
continue;
}
ASSERT(!m_spannerMap.get(placeholder->spanner()));
m_spannerMap.add(placeholder->spanner(), placeholder);
ASSERT(!placeholder->firstChild()); // There should be no children here, but if there are, we ought to skip them.
continue;
}
RenderBlockFlow* multicolContainer = multiColumnBlockFlow();
RenderObject* nextRendererInFlowThread = descendant->nextInPreOrderAfterChildren(this);
RenderObject* insertBeforeMulticolChild = nullptr;
if (isValidColumnSpanner(this, descendant)) {
// This is a spanner (column-span:all). Such renderers are moved from where they would
// otherwise occur in the render tree to becoming a direct child of the multicol container,
// so that they live among the column sets. This simplifies the layout implementation, and
// basically just relies on regular block layout done by the RenderBlockFlow that
// establishes the multicol container.
RenderBlockFlow* container = toRenderBlockFlow(descendant->parent());
RenderMultiColumnSet* setToSplit = nullptr;
if (nextRendererInFlowThread) {
setToSplit = findSetRendering(descendant);
if (setToSplit) {
setToSplit->setNeedsLayout();
insertBeforeMulticolChild = setToSplit->nextSibling();
}
}
// Moving a spanner's renderer so that it becomes a sibling of the column sets requires us
// to insert an anonymous placeholder in the tree where the spanner's renderer otherwise
// would have been. This is needed for a two reasons: We need a way of separating inline
// content before and after the spanner, so that it becomes separate line boxes. Secondly,
// this placeholder serves as a break point for column sets, so that, when encountered, we
// end flowing one column set and move to the next one.
RenderMultiColumnSpannerPlaceholder* placeholder = RenderMultiColumnSpannerPlaceholder::createAnonymous(this, toRenderBox(descendant), &container->style());
container->addChild(placeholder, descendant->nextSibling());
container->removeChild(*descendant);
// This is a guard to stop an ancestor flow thread from processing the spanner.
gShiftingSpanner = true;
multicolContainer->RenderBlock::addChild(descendant, insertBeforeMulticolChild);
gShiftingSpanner = false;
// The spanner has now been moved out from the flow thread, but we don't want to
// examine its children anyway. They are all part of the spanner and shouldn't trigger
// creation of column sets or anything like that. Continue at its original position in
// the tree, i.e. where the placeholder was just put.
if (subtreeRoot == descendant)
subtreeRoot = placeholder;
descendant = placeholder;
} else {
// This is regular multicol content, i.e. not part of a spanner.
if (nextRendererInFlowThread && nextRendererInFlowThread->isRenderMultiColumnSpannerPlaceholder()) {
// Inserted right before a spanner. Is there a set for us there?
RenderMultiColumnSpannerPlaceholder* placeholder = toRenderMultiColumnSpannerPlaceholder(nextRendererInFlowThread);
if (RenderObject* previous = placeholder->spanner()->previousSibling()) {
if (previous->isRenderMultiColumnSet())
continue; // There's already a set there. Nothing to do.
}
insertBeforeMulticolChild = placeholder->spanner();
} else if (RenderMultiColumnSet* lastSet = lastMultiColumnSet()) {
// This child is not an immediate predecessor of a spanner, which means that if this
// child precedes a spanner at all, there has to be a column set created for us there
// already. If it doesn't precede any spanner at all, on the other hand, we need a
// column set at the end of the multicol container. We don't really check here if the
// child inserted precedes any spanner or not (as that's an expensive operation). Just
// make sure we have a column set at the end. It's no big deal if it remains unused.
if (!lastSet->nextSibling())
continue;
}
}
// Need to create a new column set when there's no set already created. We also always insert
// another column set after a spanner. Even if it turns out that there are no renderers
// following the spanner, there may be bottom margins there, which take up space.
RenderMultiColumnSet* newSet = new RenderMultiColumnSet(*this, RenderStyle::createAnonymousStyleWithDisplay(&multicolContainer->style(), BLOCK));
newSet->initializeStyle();
multicolContainer->RenderBlock::addChild(newSet, insertBeforeMulticolChild);
invalidateRegions();
// We cannot handle immediate column set siblings at the moment (and there's no need for
// it, either). There has to be at least one spanner separating them.
ASSERT(!previousColumnSetOrSpannerSiblingOf(newSet) || !previousColumnSetOrSpannerSiblingOf(newSet)->isRenderMultiColumnSet());
ASSERT(!nextColumnSetOrSpannerSiblingOf(newSet) || !nextColumnSetOrSpannerSiblingOf(newSet)->isRenderMultiColumnSet());
}
}
