/*

 * 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) 2004, 2005, 2006, 2007, 2008 Apple Inc. All rights reserved.

 * Copyright (C) 2009 Google Inc. All rights reserved.

 * Copyright (C) 2009 Torch Mobile Inc. All rights reserved. (http://www.torchmobile.com/)

 *

 * 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 "RenderObject.h"

#include "AXObjectCache.h"

#include "Chrome.h"

#include "CSSStyleSelector.h"

#include "DashArray.h"

#include "FloatQuad.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLNames.h"

#include "HitTestResult.h"

#include "Page.h"

#include "RenderArena.h"

#include "RenderCounter.h"

#include "RenderFlexibleBox.h"

#include "RenderImageGeneratedContent.h"

#include "RenderInline.h"

#include "RenderLayer.h"

#include "RenderListItem.h"

#include "RenderRuby.h"

#include "RenderRubyText.h"

#include "RenderTableCell.h"

#include "RenderTableCol.h"

#include "RenderTableRow.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "TransformState.h"

#include "htmlediting.h"

#include <algorithm>

#include <stdio.h>

#include <wtf/RefCountedLeakCounter.h>

#include <wtf/UnusedParam.h>

#if USE(ACCELERATED_COMPOSITING)

#include "RenderLayerCompositor.h"

#endif

#if ENABLE(WML)

#include "WMLNames.h"

#endif

#if ENABLE(SVG)

#include "RenderSVGResourceContainer.h"

#include "SVGRenderSupport.h"

#endif

using namespace std;

namespace WebCore {

using namespace HTMLNames;

#ifndef NDEBUG

static void* baseOfRenderObjectBeingDeleted;

#endif

bool RenderObject::s_affectsParentBlock = false;

void* RenderObject::operator new(size_t sz, RenderArena* renderArena) throw()

{

    return renderArena->allocate(sz);

}

void RenderObject::operator delete(void* ptr, size_t sz)

{

    ASSERT(baseOfRenderObjectBeingDeleted == ptr);

    // Stash size where destroy can find it.

    *(size_t *)ptr = sz;

}

RenderObject* RenderObject::createObject(Node* node, RenderStyle* style)

{

    Document* doc = node->document();

    RenderArena* arena = doc->renderArena();

    // Minimal support for content properties replacing an entire element.

    // Works only if we have exactly one piece of content and it's a URL.

    // Otherwise acts as if we didn't support this feature.

    const ContentData* contentData = style->contentData();

    if (contentData && !contentData->next() && contentData->isImage() && doc != node) {

        RenderImageGeneratedContent* image = new (arena) RenderImageGeneratedContent(node);

        image->setStyle(style);

        if (StyleImage* styleImage = contentData->image())

            image->setStyleImage(styleImage);

        return image;

    }

#if ENABLE(RUBY)

    if (node->hasTagName(rubyTag)) {

        if (style->display() == INLINE)

            return new (arena) RenderRubyAsInline(node);

        else if (style->display() == BLOCK)

            return new (arena) RenderRubyAsBlock(node);

    }

    // treat <rt> as ruby text ONLY if it still has its default treatment of block

    if (node->hasTagName(rtTag) && style->display() == BLOCK)

        return new (arena) RenderRubyText(node);

#endif

    switch (style->display()) {

        case NONE:

            return 0;

        case INLINE:

            return new (arena) RenderInline(node);

        case BLOCK:

        case INLINE_BLOCK:

        case RUN_IN:

        case COMPACT:

            return new (arena) RenderBlock(node);

        case LIST_ITEM:

            return new (arena) RenderListItem(node);

        case TABLE:

        case INLINE_TABLE:

            return new (arena) RenderTable(node);

        case TABLE_ROW_GROUP:

        case TABLE_HEADER_GROUP:

        case TABLE_FOOTER_GROUP:

            return new (arena) RenderTableSection(node);

        case TABLE_ROW:

            return new (arena) RenderTableRow(node);

        case TABLE_COLUMN_GROUP:

        case TABLE_COLUMN:

            return new (arena) RenderTableCol(node);

        case TABLE_CELL:

            return new (arena) RenderTableCell(node);

        case TABLE_CAPTION:

#if ENABLE(WCSS)

        // As per the section 17.1 of the spec WAP-239-WCSS-20011026-a.pdf, 

        // the marquee box inherits and extends the characteristics of the 

        // principal block box ([CSS2] section 9.2.1).

        case WAP_MARQUEE:

#endif

            return new (arena) RenderBlock(node);

        case BOX:

        case INLINE_BOX:

            return new (arena) RenderFlexibleBox(node);

    }

    return 0;

}

#ifndef NDEBUG 

static WTF::RefCountedLeakCounter renderObjectCounter("RenderObject");

#endif

RenderObject::RenderObject(Node* node)

    : CachedResourceClient()

    , m_style(0)

    , m_node(node)

    , m_parent(0)

    , m_previous(0)

    , m_next(0)

#ifndef NDEBUG

    , m_hasAXObject(false)

    , m_setNeedsLayoutForbidden(false)

#endif

    , m_needsLayout(false)

    , m_needsPositionedMovementLayout(false)

    , m_normalChildNeedsLayout(false)

    , m_posChildNeedsLayout(false)

    , m_prefWidthsDirty(false)

    , m_floating(false)

    , m_positioned(false)

    , m_relPositioned(false)

    , m_paintBackground(false)

    , m_isAnonymous(node == node->document())

    , m_isText(false)

    , m_isBox(false)

    , m_inline(true)

    , m_replaced(false)

    , m_isDragging(false)

    , m_hasLayer(false)

    , m_hasOverflowClip(false)

    , m_hasTransform(false)

    , m_hasReflection(false)

    , m_hasOverrideSize(false)

    , m_hasCounterNodeMap(false)

    , m_everHadLayout(false)

    , m_childrenInline(false)

    , m_topMarginQuirk(false) 

    , m_bottomMarginQuirk(false)

    , m_hasMarkupTruncation(false)

    , m_selectionState(SelectionNone)

    , m_hasColumns(false)

    , m_cellWidthChanged(false)

{

#ifndef NDEBUG

    renderObjectCounter.increment();

#endif

    ASSERT(node);

}

RenderObject::~RenderObject()

{

    ASSERT(!node() || documentBeingDestroyed() || !frame()->view() || frame()->view()->layoutRoot() != this);

#ifndef NDEBUG

    ASSERT(!m_hasAXObject);

    renderObjectCounter.decrement();

#endif

}

RenderTheme* RenderObject::theme() const

{

    ASSERT(document()->page());

    return document()->page()->theme();

}

bool RenderObject::isDescendantOf(const RenderObject* obj) const

{

    for (const RenderObject* r = this; r; r = r->m_parent) {

        if (r == obj)

            return true;

    }

    return false;

}

bool RenderObject::isBody() const

{

    return node() && node()->hasTagName(bodyTag);

}

bool RenderObject::isHR() const

{

    return node() && node()->hasTagName(hrTag);

}

bool RenderObject::isHTMLMarquee() const

{

    return node() && node()->renderer() == this && node()->hasTagName(marqueeTag);

}

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

{

    RenderObjectChildList* children = virtualChildren();

    ASSERT(children);

    if (!children)

        return;

    bool needsTable = false;

    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() && !children->firstChild() && !newChild->isTableCell())

            needsTable = false;

    }

    if (needsTable) {

        RenderTable* table;

        RenderObject* afterChild = beforeChild ? beforeChild->previousSibling() : children->lastChild();

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

            table = toRenderTable(afterChild);

        else {

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

            RefPtr<RenderStyle> newStyle = RenderStyle::create();

            newStyle->inheritFrom(style());

            newStyle->setDisplay(TABLE);

            table->setStyle(newStyle.release());

            addChild(table, beforeChild);

        }

        table->addChild(newChild);

    } else {

        // Just add it...

        children->insertChildNode(this, newChild, beforeChild);

    }

    RenderCounter::rendererSubtreeAttached(newChild);

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

        RefPtr<StringImpl> textToTransform = toRenderText(newChild)->originalText();

        if (textToTransform)

            toRenderText(newChild)->setText(textToTransform.release(), true);

    }

}

void RenderObject::removeChild(RenderObject* oldChild)

{

    RenderObjectChildList* children = virtualChildren();

    ASSERT(children);

    if (!children)

        return;

    // 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).

    if (oldChild->isFloatingOrPositioned())

        toRenderBox(oldChild)->removeFloatingOrPositionedChildFromBlockLists();

    children->removeChildNode(this, oldChild);

}

RenderObject* RenderObject::nextInPreOrder() const

{

    if (RenderObject* o = firstChild())

        return o;

    return nextInPreOrderAfterChildren();

}

RenderObject* RenderObject::nextInPreOrderAfterChildren() const

{

    RenderObject* o;

    if (!(o = nextSibling())) {

        o = parent();

        while (o && !o->nextSibling())

            o = o->parent();

        if (o)

            o = o->nextSibling();

    }

    return o;

}

RenderObject* RenderObject::nextInPreOrder(RenderObject* stayWithin) const

{

    if (RenderObject* o = firstChild())

        return o;

    return nextInPreOrderAfterChildren(stayWithin);

}

RenderObject* RenderObject::nextInPreOrderAfterChildren(RenderObject* stayWithin) const

{

    if (this == stayWithin)

        return 0;

    const RenderObject* current = this;

    RenderObject* next;

    while (!(next = current->nextSibling())) {

        current = current->parent();

        if (!current || current == stayWithin)

            return 0;

    }

    return next;

}

RenderObject* RenderObject::previousInPreOrder() const

{

    if (RenderObject* o = previousSibling()) {

        while (o->lastChild())

            o = o->lastChild();

        return o;

    }

    return parent();

}

RenderObject* RenderObject::childAt(unsigned index) const

{

    RenderObject* child = firstChild();

    for (unsigned i = 0; child && i < index; i++)

        child = child->nextSibling();

    return child;

}

RenderObject* RenderObject::firstLeafChild() const

{

    RenderObject* r = firstChild();

    while (r) {

        RenderObject* n = 0;

        n = r->firstChild();

        if (!n)

            break;

        r = n;

    }

    return r;

}

RenderObject* RenderObject::lastLeafChild() const

{

    RenderObject* r = lastChild();

    while (r) {

        RenderObject* n = 0;

        n = r->lastChild();

        if (!n)

            break;

        r = n;

    }

    return r;

}

static void addLayers(RenderObject* obj, RenderLayer* parentLayer, RenderObject*& newObject,

                      RenderLayer*& beforeChild)

{

    if (obj->hasLayer()) {

        if (!beforeChild && newObject) {

            // We need to figure out the layer that follows newObject.  We only do

            // this the first time we find a child layer, and then we update the

            // pointer values for newObject and beforeChild used by everyone else.

            beforeChild = newObject->parent()->findNextLayer(parentLayer, newObject);

            newObject = 0;

        }

        parentLayer->addChild(toRenderBoxModelObject(obj)->layer(), beforeChild);

        return;

    }

    for (RenderObject* curr = obj->firstChild(); curr; curr = curr->nextSibling())

        addLayers(curr, parentLayer, newObject, beforeChild);

}

void RenderObject::addLayers(RenderLayer* parentLayer, RenderObject* newObject)

{

    if (!parentLayer)

        return;

    RenderObject* object = newObject;

    RenderLayer* beforeChild = 0;

    WebCore::addLayers(this, parentLayer, object, beforeChild);

}

void RenderObject::removeLayers(RenderLayer* parentLayer)

{

    if (!parentLayer)

        return;

    if (hasLayer()) {

        parentLayer->removeChild(toRenderBoxModelObject(this)->layer());

        return;

    }

    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling())

        curr->removeLayers(parentLayer);

}

void RenderObject::moveLayers(RenderLayer* oldParent, RenderLayer* newParent)

{

    if (!newParent)

        return;

    if (hasLayer()) {

        RenderLayer* layer = toRenderBoxModelObject(this)->layer();

        ASSERT(oldParent == layer->parent());

        if (oldParent)

            oldParent->removeChild(layer);

        newParent->addChild(layer);

        return;

    }

    for (RenderObject* curr = firstChild(); curr; curr = curr->nextSibling())

        curr->moveLayers(oldParent, newParent);

}

RenderLayer* RenderObject::findNextLayer(RenderLayer* parentLayer, RenderObject* startPoint,

                                         bool checkParent)

{

    // Error check the parent layer passed in.  If it's null, we can't find anything.

    if (!parentLayer)

        return 0;

    // Step 1: If our layer is a child of the desired parent, then return our layer.

    RenderLayer* ourLayer = hasLayer() ? toRenderBoxModelObject(this)->layer() : 0;

    if (ourLayer && ourLayer->parent() == parentLayer)

        return ourLayer;

    // Step 2: If we don't have a layer, or our layer is the desired parent, then descend

    // into our siblings trying to find the next layer whose parent is the desired parent.

    if (!ourLayer || ourLayer == parentLayer) {

        for (RenderObject* curr = startPoint ? startPoint->nextSibling() : firstChild();

             curr; curr = curr->nextSibling()) {

            RenderLayer* nextLayer = curr->findNextLayer(parentLayer, 0, false);

            if (nextLayer)

                return nextLayer;

        }

    }

    // Step 3: If our layer is the desired parent layer, then we're finished.  We didn't

    // find anything.

    if (parentLayer == ourLayer)

        return 0;

    // Step 4: If |checkParent| is set, climb up to our parent and check its siblings that

    // follow us to see if we can locate a layer.

    if (checkParent && parent())

        return parent()->findNextLayer(parentLayer, this, true);

    return 0;

}

RenderLayer* RenderObject::enclosingLayer() const

{

    const RenderObject* curr = this;

    while (curr) {

        RenderLayer* layer = curr->hasLayer() ? toRenderBoxModelObject(curr)->layer() : 0;

        if (layer)

            return layer;

        curr = curr->parent();

    }

    return 0;

}