Beispiel #1
0
bool Text::textRendererIsNeeded(const NodeRenderingContext& context)
{
    if (isEditingText())
        return true;

    if (!length())
        return false;

    if (context.style()->display() == NONE)
        return false;

    if (!containsOnlyWhitespace())
        return true;

    RenderObject* parent = context.parentRenderer();
    if (!parent->canHaveWhitespaceChildren())
        return false;

    if (context.style()->preserveNewline()) // pre/pre-wrap/pre-line always make renderers.
        return true;

    RenderObject* prev = context.previousRenderer();
    if (prev && prev->isBR()) // <span><br/> <br/></span>
        return false;

    if (parent->isRenderInline()) {
        // <span><div/> <div/></span>
        if (prev && !prev->isInline())
            return false;
    } else {
        if (parent->isRenderBlock() && !parent->childrenInline() && (!prev || !prev->isInline()))
            return false;

        // Avoiding creation of a Renderer for the text node is a non-essential memory optimization.
        // So to avoid blowing up on very wide DOMs, we limit the number of siblings to visit.
        unsigned maxSiblingsToVisit = 50;

        RenderObject* first = parent->firstChild();
        while (first && first->isFloatingOrOutOfFlowPositioned() && maxSiblingsToVisit--)
            first = first->nextSibling();
        if (!first || context.nextRenderer() == first)
            // Whitespace at the start of a block just goes away.  Don't even
            // make a render object for this text.
            return false;
    }
    return true;
}
Beispiel #2
0
bool Text::textRendererIsNeeded(const RenderStyle& style, const RenderObject& parent)
{
    if (isEditingText())
        return true;

    if (!length())
        return false;

    if (style.display() == NONE)
        return false;

    if (style.requiresOnlyBlockChildren())
        return false;

    if (!containsOnlyWhitespace())
        return true;

    if (!parent.canHaveWhitespaceChildren())
        return false;

    if (style.preserveNewline()) // pre/pre-wrap/pre-line always make renderers.
        return true;

    RenderObject* prev;
    for (Node* sibling = this->previousSibling(); sibling; sibling = sibling->previousSibling()) {
        if ((prev = sibling->renderer()))
            break;
    }

    if (parent.isRenderInline()) {
        // <span><div/> <div/></span>
        if (prev && !prev->isInline())
            return false;
    } else {
        if (parent.isRenderBlock() && !parent.isRenderParagraph() && (!prev || !prev->isInline()))
            return false;

        // Avoiding creation of a Renderer for the text node is a non-essential memory optimization.
        // So to avoid blowing up on very wide DOMs, we limit the number of siblings to visit.
        unsigned maxSiblingsToVisit = 50;

        RenderObject* first = parent.slowFirstChild();
        while (first && first->isFloatingOrOutOfFlowPositioned() && maxSiblingsToVisit--)
            first = first->nextSibling();

        if (!first) {
            // If the block has nothing but white-space we ignore it
            return false;
        }

        for (Node* sibling = this->nextSibling(); sibling; sibling = sibling->nextSibling()) {
            if (RenderObject* nextRenderer = sibling->renderer()) {
                if (nextRenderer == first) {
                    // Whitespace at the start of a block just goes away.  Don't even
                    // make a render object for this text.
                    return false;
                }
                break;
            }
        }

    }
    return true;
}