static RenderObject* nextSiblingRenderer(const Text& textNode)
{
if (textNode.renderer())
return textNode.renderer()->nextSibling();
for (Node* sibling = NodeRenderingTraversal::nextSibling(&textNode); sibling; sibling = NodeRenderingTraversal::nextSibling(sibling)) {
RenderObject* renderer = sibling->renderer();
if (renderer && !isRendererReparented(renderer))
return renderer;
}
return 0;
}
static RenderObject* nextSiblingRenderer(const Element& element, const ContainerNode* renderingParentNode)
{
// Avoid an O(N^2) problem with this function by not checking for
// nextRenderer() when the parent element hasn't attached yet.
// FIXME: Why would we get here anyway if parent is not attached?
if (renderingParentNode && !renderingParentNode->attached())
return 0;
for (Node* sibling = NodeRenderingTraversal::nextSibling(&element); sibling; sibling = NodeRenderingTraversal::nextSibling(sibling)) {
RenderObject* renderer = sibling->renderer();
if (renderer && !isRendererReparented(renderer))
return renderer;
}
return 0;
}
RenderObject* NodeRenderingContext::nextRenderer() const
{
if (RenderObject* renderer = m_node->renderer())
return renderer->nextSibling();
Element* element = m_node->isElementNode() ? toElement(m_node) : 0;
if (element && element->shouldBeReparentedUnderRenderView(m_style.get())) {
// FIXME: Reparented renderers not in the top layer should probably be
// ordered in DOM tree order. We don't have a good way to do that yet,
// since NodeRenderingTraversal isn't aware of reparenting. It's safe to
// just append for now; it doesn't disrupt the top layer rendering as
// the layer collection in RenderLayer only requires that top layer
// renderers are orderered correctly relative to each other.
if (!element->isInTopLayer())
return 0;
const Vector<RefPtr<Element> >& topLayerElements = element->document()->topLayerElements();
size_t position = topLayerElements.find(element);
ASSERT(position != notFound);
for (size_t i = position + 1; i < topLayerElements.size(); ++i) {
if (RenderObject* renderer = topLayerElements[i]->renderer())
return renderer;
}
return 0;
}
if (m_parentFlowRenderer)
return m_parentFlowRenderer->nextRendererForNode(m_node);
// Avoid an O(N^2) problem with this function by not checking for
// nextRenderer() when the parent element hasn't attached yet.
if (m_renderingParent && !m_renderingParent->attached())
return 0;
for (Node* sibling = NodeRenderingTraversal::nextSibling(m_node); sibling; sibling = NodeRenderingTraversal::nextSibling(sibling)) {
RenderObject* renderer = sibling->renderer();
if (renderer && !isRendererReparented(renderer))
return renderer;
}
return 0;
}
RenderObject* NodeRenderingContext::previousRenderer() const
{
if (RenderObject* renderer = m_node->renderer())
return renderer->previousSibling();
// FIXME: This doesn't work correctly for reparented elements that are
// display: none. We'd need to duplicate the logic in nextRenderer, but since
// nothing needs that yet just assert.
ASSERT(!m_node->isElementNode() || !toElement(m_node)->shouldBeReparentedUnderRenderView(m_style.get()));
if (m_parentFlowRenderer)
return m_parentFlowRenderer->previousRendererForNode(m_node);
// FIXME: We should have the same O(N^2) avoidance as nextRenderer does
// however, when I tried adding it, several tests failed.
for (Node* sibling = NodeRenderingTraversal::previousSibling(m_node); sibling; sibling = NodeRenderingTraversal::previousSibling(sibling)) {
RenderObject* renderer = sibling->renderer();
if (renderer && !isRendererReparented(renderer))
return renderer;
}
return 0;
}
