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()); } }