/**

 * Copyright (C) 1999 Lars Knoll (knoll@kde.org)

 *           (C) 1999 Antti Koivisto (koivisto@kde.org)

 *           (C) 2000 Dirk Mueller (mueller@kde.org)

 *           (C) 2004 Allan Sandfeld Jensen (kde@carewolf.com)

 * Copyright (C) 2003, 2004, 2005, 2006, 2007 Apple Inc. All rights reserved.

 * Copyright (C) 2006 Andrew Wellington (proton@wiretapped.net)

 *

 * This library is free software; you can redistribute it and/or

 * modify it under the terms of the GNU Library General Public

 * License as published by the Free Software Foundation; either

 * version 2 of the License, or (at your option) any later version.

 *

 * This library is distributed in the hope that it will be useful,

 * but WITHOUT ANY WARRANTY; without even the implied warranty of

 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

 * Library General Public License for more details.

 *

 * You should have received a copy of the GNU Library General Public License

 * along with this library; see the file COPYING.LIB.  If not, write to

 * the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,

 * Boston, MA 02110-1301, USA.

 *

 */

#include "config.h"

#include "RenderContainer.h"

#include "AXObjectCache.h"

#include "Document.h"

#include "RenderCounter.h"

#include "RenderImage.h"

#include "RenderLayer.h"

#include "RenderListItem.h"

#include "RenderTable.h"

#include "RenderTextFragment.h"

#include "RenderView.h"

#include "htmlediting.h"

namespace WebCore {

RenderContainer::RenderContainer(Node* node)

    : RenderBox(node)

    , m_firstChild(0)

    , m_lastChild(0)

{

}

RenderContainer::~RenderContainer()

{

}

void RenderContainer::destroy()

{

    destroyLeftoverChildren();

    RenderBox::destroy();

}

void RenderContainer::destroyLeftoverChildren()

{

    while (m_firstChild) {

        if (m_firstChild->isListMarker() || (m_firstChild->style()->styleType() == RenderStyle::FIRST_LETTER && !m_firstChild->isText()))

            m_firstChild->remove();  // List markers are owned by their enclosing list and so don't get destroyed by this container. Similarly, first letters are destroyed by their remaining text fragment.

        else {

        // Destroy any anonymous children remaining in the render tree, as well as implicit (shadow) DOM elements like those used in the engine-based text fields.

            if (m_firstChild->element())

                m_firstChild->element()->setRenderer(0);

            m_firstChild->destroy();

        }

    }

}

bool RenderContainer::canHaveChildren() const

{

    return true;

}

static void updateListMarkerNumbers(RenderObject* child)

{

    for (RenderObject* r = child; r; r = r->nextSibling())

        if (r->isListItem())

            static_cast<RenderListItem*>(r)->updateValue();

}

void RenderContainer::addChild(RenderObject* newChild, RenderObject* beforeChild)

{

    bool needsTable = false;

    if (newChild->isListItem())

        updateListMarkerNumbers(beforeChild ? beforeChild : m_lastChild);

    else if (newChild->isTableCol() && newChild->style()->display() == TABLE_COLUMN_GROUP)

        needsTable = !isTable();

    else if (newChild->isRenderBlock() && newChild->style()->display() == TABLE_CAPTION)

        needsTable = !isTable();

    else if (newChild->isTableSection())

        needsTable = !isTable();

    else if (newChild->isTableRow())

        needsTable = !isTableSection();

    else if (newChild->isTableCell()) {

        needsTable = !isTableRow();

        // I'm not 100% sure this is the best way to fix this, but without this

        // change we recurse infinitely when trying to render the CSS2 test page:

        // http://www.bath.ac.uk/%7Epy8ieh/internet/eviltests/htmlbodyheadrendering2.html.

        // See Radar 2925291.

        if (needsTable && isTableCell() && !m_firstChild && !newChild->isTableCell())

            needsTable = false;

    }

    if (needsTable) {

        RenderTable *table;

        if(!beforeChild)

            beforeChild = m_lastChild;

        if(beforeChild && beforeChild->isAnonymous() && beforeChild->isTable())

            table = static_cast<RenderTable*>(beforeChild);

        else {

            table = new (renderArena()) RenderTable(document() /* is anonymous */);

            RenderStyle *newStyle = new (renderArena()) RenderStyle;

            newStyle->inheritFrom(style());

            newStyle->setDisplay(TABLE);

            table->setStyle(newStyle);

            addChild(table, beforeChild);

        }

        table->addChild(newChild);

    } else {

        // just add it...

        insertChildNode(newChild, beforeChild);

    }

    if (newChild->isText() && newChild->style()->textTransform() == CAPITALIZE) {

        RefPtr<StringImpl> textToTransform = static_cast<RenderText*>(newChild)->originalText();

        if (textToTransform)

            static_cast<RenderText*>(newChild)->setText(textToTransform.release(), true);

    }

}

RenderObject* RenderContainer::removeChildNode(RenderObject* oldChild, bool fullRemove)

{

    ASSERT(oldChild->parent() == this);

    // So that we'll get the appropriate dirty bit set (either that a normal flow child got yanked or

    // that a positioned child got yanked).  We also repaint, so that the area exposed when the child

    // disappears gets repainted properly.

    if (!documentBeingDestroyed() && fullRemove) {

        oldChild->setNeedsLayoutAndPrefWidthsRecalc();

        oldChild->repaint();

    }

    // If we have a line box wrapper, delete it.

    oldChild->deleteLineBoxWrapper();

    if (!documentBeingDestroyed() && fullRemove) {

        // if we remove visible child from an invisible parent, we don't know the layer visibility any more

        RenderLayer* layer = 0;

        if (m_style->visibility() != VISIBLE && oldChild->style()->visibility() == VISIBLE && !oldChild->hasLayer()) {

            layer = enclosingLayer();

            layer->dirtyVisibleContentStatus();

        }

         // Keep our layer hierarchy updated.

        if (oldChild->firstChild() || oldChild->hasLayer()) {

            if (!layer) layer = enclosingLayer();            

            oldChild->removeLayers(layer);

        }

        // renumber ordered lists

        if (oldChild->isListItem())

            updateListMarkerNumbers(oldChild->nextSibling());

        if (oldChild->isPositioned() && childrenInline())

            dirtyLinesFromChangedChild(oldChild);

    }

    // If oldChild is the start or end of the selection, then clear the selection to

    // avoid problems of invalid pointers.

    // FIXME: The SelectionController should be responsible for this when it

    // is notified of DOM mutations.

    if (!documentBeingDestroyed() && oldChild->isSelectionBorder())

        view()->clearSelection();

    // remove the child

    if (oldChild->previousSibling())

        oldChild->previousSibling()->setNextSibling(oldChild->nextSibling());

    if (oldChild->nextSibling())

        oldChild->nextSibling()->setPreviousSibling(oldChild->previousSibling());

    if (m_firstChild == oldChild)

        m_firstChild = oldChild->nextSibling();

    if (m_lastChild == oldChild)

        m_lastChild = oldChild->previousSibling();

    oldChild->setPreviousSibling(0);

    oldChild->setNextSibling(0);

    oldChild->setParent(0);

    if (AXObjectCache::accessibilityEnabled())

        document()->axObjectCache()->childrenChanged(this);

    return oldChild;

}

void RenderContainer::removeChild(RenderObject* oldChild)

{

    // We do this here instead of in removeChildNode, since the only extremely low-level uses of remove/appendChildNode

    // cannot affect the positioned object list, and the floating object list is irrelevant (since the list gets cleared on

    // layout anyway).

    oldChild->removeFromObjectLists();

    removeChildNode(oldChild);

}

RenderObject* RenderContainer::beforeAfterContainer(RenderStyle::PseudoId type)

{

    if (type == RenderStyle::BEFORE) {

        RenderObject* first = this;

        do {

            // Skip list markers.

            first = first->firstChild();

            while (first && first->isListMarker())

                first = first->nextSibling();

        } while (first && first->isAnonymous() && first->style()->styleType() == RenderStyle::NOPSEUDO);

        if (first && first->style()->styleType() != type)

            return 0;

        return first;

    }

    if (type == RenderStyle::AFTER) {

        RenderObject* last = this;

        do {

            last = last->lastChild();

        } while (last && last->isAnonymous() && last->style()->styleType() == RenderStyle::NOPSEUDO && !last->isListMarker());

        if (last && last->style()->styleType() != type)

            return 0;

        return last;

    }

    ASSERT_NOT_REACHED();

    return 0;

}

void RenderContainer::updateBeforeAfterContent(RenderStyle::PseudoId type)

{

    // If this is an anonymous wrapper, then the parent applies its own pseudo-element style to it.

    if (parent() && parent()->createsAnonymousWrapper())

        return;

    updateBeforeAfterContentForContainer(type, this);

}

void RenderContainer::updateBeforeAfterContentForContainer(RenderStyle::PseudoId type, RenderContainer* styledObject)

{

    // In CSS2, before/after pseudo-content cannot nest.  Check this first.

    if (style()->styleType() == RenderStyle::BEFORE || style()->styleType() == RenderStyle::AFTER)

        return;

    RenderStyle* pseudoElementStyle = styledObject->getPseudoStyle(type);

    RenderObject* child = beforeAfterContainer(type);

    // Whether or not we currently have generated content attached.

    bool oldContentPresent = child;

    // Whether or not we now want generated content.  

    bool newContentWanted = pseudoElementStyle && pseudoElementStyle->display() != NONE;

    // For <q><p/></q>, if this object is the inline continuation of the <q>, we only want to generate

    // :after content and not :before content.

    if (newContentWanted && type == RenderStyle::BEFORE && isInlineContinuation())

        newContentWanted = false;

    // Similarly, if we're the beginning of a <q>, and there's an inline continuation for our object,

    // then we don't generate the :after content.

    if (newContentWanted && type == RenderStyle::AFTER && isRenderInline() && continuation())

        newContentWanted = false;

    // If we don't want generated content any longer, or if we have generated content, but it's no longer

    // identical to the new content data we want to build render objects for, then we nuke all

    // of the old generated content.

    if (!newContentWanted || (oldContentPresent && !child->style()->contentDataEquivalent(pseudoElementStyle))) {

        // Nuke the child. 

        if (child && child->style()->styleType() == type) {

            oldContentPresent = false;

            child->destroy();

            child = (type == RenderStyle::BEFORE) ? m_firstChild : m_lastChild;

        }

    }

    // If we have no pseudo-element style or if the pseudo-element style's display type is NONE, then we

    // have no generated content and can now return.

    if (!newContentWanted)

        return;

    if (isInlineFlow() && !pseudoElementStyle->isDisplayInlineType() && pseudoElementStyle->floating() == FNONE &&

        !(pseudoElementStyle->position() == AbsolutePosition || pseudoElementStyle->position() == FixedPosition))

        // According to the CSS2 spec (the end of section 12.1), the only allowed

        // display values for the pseudo style are NONE and INLINE for inline flows.

        // FIXME: CSS2.1 lifted this restriction, but block display types will crash.

        // For now we at least relax the restriction to allow all inline types like inline-block

        // and inline-table.

        pseudoElementStyle->setDisplay(INLINE);

    if (oldContentPresent) {

        if (child && child->style()->styleType() == type) {

            // We have generated content present still.  We want to walk this content and update our

            // style information with the new pseudo-element style.

            child->setStyle(pseudoElementStyle);

            // Note that if we ever support additional types of generated content (which should be way off

            // in the future), this code will need to be patched.

            for (RenderObject* genChild = child->firstChild(); genChild; genChild = genChild->nextSibling()) {

                if (genChild->isText())

                    // Generated text content is a child whose style also needs to be set to the pseudo-element style.

                    genChild->setStyle(pseudoElementStyle);

                else if (genChild->isImage()) {

                    // Images get an empty style that inherits from the pseudo.

                    RenderStyle* style = new (renderArena()) RenderStyle;

                    style->inheritFrom(pseudoElementStyle);

                    genChild->setStyle(style);

                } else

                    // Must be a first-letter container. updateFirstLetter() will take care of it.

                    ASSERT(genChild->style()->styleType() == RenderStyle::FIRST_LETTER);

            }

        }

        return; // We've updated the generated content. That's all we needed to do.

    }

    RenderObject* insertBefore = (type == RenderStyle::BEFORE) ? firstChild() : 0;

    // Generated content consists of a single container that houses multiple children (specified

    // by the content property).  This generated content container gets the pseudo-element style set on it.

    RenderObject* generatedContentContainer = 0;

    // Walk our list of generated content and create render objects for each.

    for (const ContentData* content = pseudoElementStyle->contentData(); content; content = content->m_next) {

        RenderObject* renderer = 0;

        switch (content->m_type) {

            case CONTENT_NONE:

                break;

            case CONTENT_TEXT:

                renderer = new (renderArena()) RenderTextFragment(document() /* anonymous object */, content->m_content.m_text);

                renderer->setStyle(pseudoElementStyle);

                break;

            case CONTENT_OBJECT:

                if (CachedResource* resource = content->m_content.m_object)

                    if (resource->type() == CachedResource::ImageResource) {

                        RenderImage* image = new (renderArena()) RenderImage(document()); // anonymous object

                        RenderStyle* style = new (renderArena()) RenderStyle;

                        style->inheritFrom(pseudoElementStyle);

                        image->setStyle(style);

                        image->setCachedImage(static_cast<CachedImage*>(resource));

                        image->setIsAnonymousImage(true);

                        renderer = image;

                    }

                break;

            case CONTENT_COUNTER:

                renderer = new (renderArena()) RenderCounter(document(), *content->m_content.m_counter);

                renderer->setStyle(pseudoElementStyle);

                break;

        }

        if (renderer) {

            if (!generatedContentContainer) {

                // Make a generated box that might be any display type now that we are able to drill down into children

                // to find the original content properly.

                generatedContentContainer = RenderObject::createObject(document(), pseudoElementStyle);

                generatedContentContainer->setStyle(pseudoElementStyle);

            }

            generatedContentContainer->addChild(renderer);

        }

    }

    // Add the pseudo after we've installed all our content so that addChild will be able to find the text

    // inside the inline for e.g., first-letter styling.

    if (generatedContentContainer)

        addChild(generatedContentContainer, insertBefore);

}

bool RenderContainer::isAfterContent(RenderObject* child) const

{

    if (!child)

        return false;

    if (child->style()->styleType() != RenderStyle::AFTER)

        return false;

    // Text nodes don't have their own styles, so ignore the style on a text node.

    if (child->isText() && !child->isBR())

        return false;

    return true;

}

void RenderContainer::appendChildNode(RenderObject* newChild, bool fullAppend)

{

    ASSERT(newChild->parent() == 0);

    ASSERT(!isBlockFlow() || (!newChild->isTableSection() && !newChild->isTableRow() && !newChild->isTableCell()));

    newChild->setParent(this);

    RenderObject* lChild = m_lastChild;

    if (lChild) {

        newChild->setPreviousSibling(lChild);

        lChild->setNextSibling(newChild);

    } else

        m_firstChild = newChild;

    m_lastChild = newChild;

    if (fullAppend) {

        // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children

        // and don't have a layer attached to ourselves.

        RenderLayer* layer = 0;

        if (newChild->firstChild() || newChild->hasLayer()) {

            layer = enclosingLayer();

            newChild->addLayers(layer, newChild);

        }

        // if the new child is visible but this object was not, tell the layer it has some visible content

        // that needs to be drawn and layer visibility optimization can't be used

        if (style()->visibility() != VISIBLE && newChild->style()->visibility() == VISIBLE && !newChild->hasLayer()) {

            if (!layer)

                layer = enclosingLayer();

            if (layer)

                layer->setHasVisibleContent(true);

        }

        if (!newChild->isFloatingOrPositioned() && childrenInline())

            dirtyLinesFromChangedChild(newChild);

    }

    newChild->setNeedsLayoutAndPrefWidthsRecalc(); // Goes up the containing block hierarchy.

    if (!normalChildNeedsLayout())

        setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child.

    if (AXObjectCache::accessibilityEnabled())

        document()->axObjectCache()->childrenChanged(this);

}

void RenderContainer::insertChildNode(RenderObject* child, RenderObject* beforeChild, bool fullInsert)

{

    if (!beforeChild) {

        appendChildNode(child);

        return;

    }

    ASSERT(!child->parent());

    while (beforeChild->parent() != this && beforeChild->parent()->isAnonymousBlock())

        beforeChild = beforeChild->parent();

    ASSERT(beforeChild->parent() == this);

    ASSERT(!isBlockFlow() || (!child->isTableSection() && !child->isTableRow() && !child->isTableCell()));

    if (beforeChild == m_firstChild)

        m_firstChild = child;

    RenderObject* prev = beforeChild->previousSibling();

    child->setNextSibling(beforeChild);

    beforeChild->setPreviousSibling(child);

    if(prev) prev->setNextSibling(child);

    child->setPreviousSibling(prev);

    child->setParent(this);

    if (fullInsert) {

        // Keep our layer hierarchy updated.  Optimize for the common case where we don't have any children

        // and don't have a layer attached to ourselves.

        RenderLayer* layer = 0;

        if (child->firstChild() || child->hasLayer()) {

            layer = enclosingLayer();

            child->addLayers(layer, child);

        }

        // if the new child is visible but this object was not, tell the layer it has some visible content

        // that needs to be drawn and layer visibility optimization can't be used

        if (style()->visibility() != VISIBLE && child->style()->visibility() == VISIBLE && !child->hasLayer()) {

            if (!layer)

                layer = enclosingLayer();

            if (layer)

                layer->setHasVisibleContent(true);

        }

        if (!child->isFloating() && childrenInline())

            dirtyLinesFromChangedChild(child);

    }

    child->setNeedsLayoutAndPrefWidthsRecalc();

    if (!normalChildNeedsLayout())

        setChildNeedsLayout(true); // We may supply the static position for an absolute positioned child.

    if (AXObjectCache::accessibilityEnabled())

        document()->axObjectCache()->childrenChanged(this);

}

void RenderContainer::layout()

{

    ASSERT(needsLayout());

    view()->pushLayoutState(this, IntSize(m_x, m_y));

    RenderObject* child = m_firstChild;

    while (child) {

        child->layoutIfNeeded();

        ASSERT(child->isRenderInline() || !child->needsLayout());

        child = child->nextSibling();

    }

    view()->popLayoutState();

    setNeedsLayout(false);

}

void RenderContainer::removeLeftoverAnonymousBlock(RenderBlock* child)

{

    ASSERT(child->isAnonymousBlock());

    ASSERT(!child->childrenInline());

    if (child->continuation()) 

        return;

    RenderObject* firstAnChild = child->firstChild();

    RenderObject* lastAnChild = child->lastChild();

    if (firstAnChild) {

        RenderObject* o = firstAnChild;

        while(o) {

            o->setParent(this);

            o = o->nextSibling();

        }

        firstAnChild->setPreviousSibling(child->previousSibling());

        lastAnChild->setNextSibling(child->nextSibling());

        if (child->previousSibling())

            child->previousSibling()->setNextSibling(firstAnChild);

        if (child->nextSibling())

            child->nextSibling()->setPreviousSibling(lastAnChild);

    } else {

        if (child->previousSibling())