/**

 * 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 Apple Inc. All rights reserved.

 *

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

#include "CachedImage.h"

#include "Chrome.h"

#include "Document.h"

#include "Element.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "FloatRect.h"

#include "Frame.h"

#include "FrameView.h"

#include "GraphicsContext.h"

#include "HTMLNames.h"

#include "HTMLOListElement.h"

#include "HitTestRequest.h"

#include "HitTestResult.h"

#include "KURL.h"

#include "Page.h"

#include "PlatformScreen.h"

#include "Position.h"

#include "RenderArena.h"

#include "RenderCounter.h"

#include "RenderFlexibleBox.h"

#include "RenderImage.h"

#include "RenderInline.h"

#include "RenderListItem.h"

#include "RenderTableCell.h"

#include "RenderTableCol.h"

#include "RenderTableRow.h"

#include "RenderText.h"

#include "RenderTheme.h"

#include "RenderView.h"

#include "TextResourceDecoder.h"

#include "TextStream.h"

#include <algorithm>

using namespace std;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

#ifndef NDEBUG

static void* baseOfRenderObjectBeingDeleted;

#endif

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->m_next && contentData->m_type == CONTENT_OBJECT && doc != node) {

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

        image->setStyle(style);

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

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

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

        image->setIsAnonymousImage(true);

        return image;

    }

    RenderObject* o = 0;

    switch (style->display()) {

        case NONE:

            break;

        case INLINE:

            o = new (arena) RenderInline(node);

            break;

        case BLOCK:

            o = new (arena) RenderBlock(node);

            break;

        case INLINE_BLOCK:

            o = new (arena) RenderBlock(node);

            break;

        case LIST_ITEM:

            o = new (arena) RenderListItem(node);

            break;

        case RUN_IN:

        case COMPACT:

#if PLATFORM(SYMBIAN)

    case WAP_MARQUEE:

#endif

            o = new (arena) RenderBlock(node);

            break;

        case TABLE:

        case INLINE_TABLE:

            o = new (arena) RenderTable(node);

            break;

        case TABLE_ROW_GROUP:

        case TABLE_HEADER_GROUP:

        case TABLE_FOOTER_GROUP:

            o = new (arena) RenderTableSection(node);

            break;

        case TABLE_ROW:

            o = new (arena) RenderTableRow(node);

            break;

        case TABLE_COLUMN_GROUP:

        case TABLE_COLUMN:

            o = new (arena) RenderTableCol(node);

            break;

        case TABLE_CELL:

            o = new (arena) RenderTableCell(node);

            break;

        case TABLE_CAPTION:

            o = new (arena) RenderBlock(node);

            break;

        case BOX:

        case INLINE_BOX:

            o = new (arena) RenderFlexibleBox(node);

            break;

    }

    return o;

}

#ifndef NDEBUG

struct RenderObjectCounter {

    static int count;

    ~RenderObjectCounter() { if (count != 0) fprintf(stderr, "LEAK: %d RenderObject\n", count); }

};

int RenderObjectCounter::count;

static RenderObjectCounter renderObjectCounter;

#endif

RenderObject::RenderObject(Node* node)

    : CachedResourceClient()

    , m_style(0)

    , m_node(node)

    , m_parent(0)

    , m_previous(0)

    , m_next(0)

    , m_verticalPosition(PositionUndefined)

    , m_needsLayout(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_inline(true)

    , m_replaced(false)

    , m_isDragging(false)

    , m_hasLayer(false)

    , m_hasOverflowClip(false)

    , m_hasOverrideSize(false)

    , m_hasCounterNodeMap(false)

{

#ifndef NDEBUG

    ++RenderObjectCounter::count;

#endif

}

RenderObject::~RenderObject()

{

#ifndef NDEBUG

    --RenderObjectCounter::count;

#endif

}

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()->hasTagName(bodyTag);

}

bool RenderObject::isHR() const

{

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

}

bool RenderObject::isHTMLMarquee() const

{

#if PLATFORM(SYMBIAN)

    // Hack here: treat wap-marquee the same way as marquee element.

    return ( (element() && element()->renderer() == this && element()->hasTagName(marqueeTag))

                || (m_style && m_style->display() == WAP_MARQUEE));

#else

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

#endif

}

bool RenderObject::canHaveChildren() const

{

    return false;

}

RenderFlow* RenderObject::continuation() const

{

    return 0;

}

bool RenderObject::isInlineContinuation() const

{

    return false;

}

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

{

    ASSERT_NOT_REACHED();

}

RenderObject* RenderObject::removeChildNode(RenderObject*, bool)

{

    ASSERT_NOT_REACHED();

    return 0;

}

void RenderObject::removeChild(RenderObject*)

{

    ASSERT_NOT_REACHED();

}

void RenderObject::moveChildNode(RenderObject*)

{

    ASSERT_NOT_REACHED();

}

void RenderObject::appendChildNode(RenderObject*, bool)

{

    ASSERT_NOT_REACHED();

}

void RenderObject::insertChildNode(RenderObject*, RenderObject*, bool)

{

    ASSERT_NOT_REACHED();

}

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;

    RenderObject* o;

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

        o = parent();

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

            o = o->parent();

            if (o == stayWithin)

                return 0;

        }

        if (o)

            o = o->nextSibling();

    }

    return o;

}

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;

}

bool RenderObject::isEditable() const

{

    RenderText* textRenderer = 0;

    if (isText())

        textRenderer = static_cast<RenderText*>(const_cast<RenderObject*>(this));

    return style()->visibility() == VISIBLE &&

        element() && element()->isContentEditable() &&

        ((isBlockFlow() && !firstChild()) ||

        isReplaced() ||

        isBR() ||

        (textRenderer && textRenderer->firstTextBox()));

}

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(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(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()) {

        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 = layer();

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

        if (layer)

            return layer;

        curr = curr->parent();

    }

    return 0;

}

bool RenderObject::requiresLayer()

{

    return isRoot() || isPositioned() || isRelPositioned() || isTransparent() || hasOverflowClip();

}

RenderBlock* RenderObject::firstLineBlock() const

{

    return 0;

}

int RenderObject::offsetLeft() const

{

    RenderObject* offsetPar = offsetParent();

    if (!offsetPar)

        return 0;

    int x = xPos() - offsetPar->borderLeft();

    if (!isPositioned()) {

        if (isRelPositioned())

            x += static_cast<const RenderBox*>(this)->relativePositionOffsetX();

        RenderObject* curr = parent();

        while (curr && curr != offsetPar) {

            x += curr->xPos();

            curr = curr->parent();

        }

        if (offsetPar->isBody() && !offsetPar->isRelPositioned() && !offsetPar->isPositioned())

            x += offsetPar->xPos();

    }