/*

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

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

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

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

 * Copyright (C) 2007 Trolltech ASA

 *

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

#include "CString.h"

#include "ChildNodeList.h"

#include "DOMImplementation.h"

#include "Document.h"

#include "Element.h"

#include "ExceptionCode.h"

#include "Frame.h"

#include "HTMLNames.h"

#include "KURL.h"

#include "Logging.h"

#include "NamedAttrMap.h"

#include "RenderObject.h"

#include "Text.h"

#include "TextStream.h"

#include "XMLNames.h"

#include "htmlediting.h"

#include "kjs_binding.h"

namespace WebCore {

using namespace HTMLNames;

typedef HashSet<NodeList*> NodeListSet;

struct NodeListsNodeData {

    NodeListSet m_registeredLists;

    NodeList::Caches m_childNodeListCaches;

};

// NodeList that limits to a particular tag.

class TagNodeList : public NodeList {

public:

    TagNodeList(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName);

    virtual unsigned length() const;

    virtual Node* item(unsigned index) const;

private:

    virtual bool nodeMatches(Node*) const;

    AtomicString m_namespaceURI;

    AtomicString m_localName;

};

inline TagNodeList::TagNodeList(PassRefPtr<Node> rootNode, const AtomicString& namespaceURI, const AtomicString& localName)

    : NodeList(rootNode), m_namespaceURI(namespaceURI), m_localName(localName)

{

    ASSERT(m_namespaceURI.isNull() || !m_namespaceURI.isEmpty());

}

unsigned TagNodeList::length() const

{

    return recursiveLength();

}

Node* TagNodeList::item(unsigned index) const

{

    return recursiveItem(index);

}

bool TagNodeList::nodeMatches(Node* testNode) const

{

    if (!testNode->isElementNode())

        return false;

    if (m_namespaceURI != starAtom && m_namespaceURI != testNode->namespaceURI())

        return false;

    return m_localName == starAtom || m_localName == testNode->localName();

}

bool Node::isSupported(const String& feature, const String& version)

{

    return DOMImplementation::instance()->hasFeature(feature, version);

}

#ifndef NDEBUG

WTFLogChannel LogWebCoreNodeLeaks =  { 0x00000000, "", WTFLogChannelOn };

struct NodeCounter {

    static unsigned count; 

    ~NodeCounter() 

    { 

        if (count) 

            LOG(WebCoreNodeLeaks, "LEAK: %u Node\n", count); 

    }

};

unsigned NodeCounter::count = 0;

static NodeCounter nodeCounter;

static bool shouldIgnoreLeaks = false;

static HashSet<Node*> ignoreSet;

#endif

void Node::startIgnoringLeaks()

{

#ifndef NDEBUG

    shouldIgnoreLeaks = true;

#endif

}

void Node::stopIgnoringLeaks()

{

#ifndef NDEBUG

    shouldIgnoreLeaks = false;

#endif

}

Node::Node(Document *doc)

    : m_document(doc),

      m_previous(0),

      m_next(0),

      m_renderer(0),

      m_nodeLists(0),

      m_tabIndex(0),

      m_hasId(false),

      m_hasClass(false),

      m_attached(false),

      m_styleChange(NoStyleChange),

      m_hasChangedChild(false),

      m_inDocument(false),

      m_isLink(false),

      m_attrWasSpecifiedOrElementHasRareData(false),

      m_focused(false),

      m_active(false),

      m_hovered(false),

      m_inActiveChain(false),

      m_inDetach(false),

      m_dispatchingSimulatedEvent(false),

      m_inSubtreeMark(false)

{

#ifndef NDEBUG

    if (shouldIgnoreLeaks)

        ignoreSet.add(this);

    else

        ++NodeCounter::count;

#endif

}

void Node::setDocument(Document* doc)

{

    if (inDocument() || m_document == doc)

        return;

    willMoveToNewOwnerDocument();

    {

        KJS::JSLock lock;

        KJS::ScriptInterpreter::updateDOMNodeDocument(this, m_document.get(), doc);

    }    

    m_document = doc;

    didMoveToNewOwnerDocument();

}

Node::~Node()

{

#ifndef NDEBUG

    HashSet<Node*>::iterator it = ignoreSet.find(this);

    if (it != ignoreSet.end())

        ignoreSet.remove(it);

    else

        --NodeCounter::count;

#endif

    if (renderer())

        detach();

    delete m_nodeLists;

    if (m_previous)

        m_previous->setNextSibling(0);

    if (m_next)

        m_next->setPreviousSibling(0);

}

String Node::nodeValue() const

{

  return String();

}

void Node::setNodeValue(const String& /*nodeValue*/, ExceptionCode& ec)

{

    // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly

    if (isReadOnlyNode()) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    // by default nodeValue is null, so setting it has no effect

}

PassRefPtr<NodeList> Node::childNodes()

{

    if (!m_nodeLists)

        m_nodeLists = new NodeListsNodeData;

    return new ChildNodeList(this, &m_nodeLists->m_childNodeListCaches);

}

Node* Node::virtualFirstChild() const

{

    return 0;

}

Node* Node::virtualLastChild() const

{

    return 0;

}

Node *Node::lastDescendant() const

{

    Node *n = const_cast<Node *>(this);

    while (n && n->lastChild())

        n = n->lastChild();

    return n;

}

Node* Node::firstDescendant() const

{

    Node *n = const_cast<Node *>(this);

    while (n && n->firstChild())

        n = n->firstChild();

    return n;

}

bool Node::insertBefore(PassRefPtr<Node>, Node*, ExceptionCode& ec)

{

    ec = HIERARCHY_REQUEST_ERR;

    return false;

}

bool Node::replaceChild(PassRefPtr<Node>, Node*, ExceptionCode& ec)

{

    ec = HIERARCHY_REQUEST_ERR;

    return false;

}

bool Node::removeChild(Node*, ExceptionCode& ec)

{

    ec = NOT_FOUND_ERR;

    return false;

}

bool Node::appendChild(PassRefPtr<Node>, ExceptionCode& ec)

{

    ec = HIERARCHY_REQUEST_ERR;

    return false;

}

void Node::remove(ExceptionCode& ec)

{

    ref();

    if (Node *p = parentNode())

        p->removeChild(this, ec);

    else

        ec = HIERARCHY_REQUEST_ERR;

    deref();

}

bool Node::hasChildNodes(  ) const

{

  return false;

}

void Node::normalize ()

{

    ExceptionCode ec = 0;

    Node *child = firstChild();

    if (isElementNode()) {

        // Normalize any attribute children we might have 

        Element *element = static_cast<Element *>(this);

        NamedAttrMap *attrMap = element->attributes();

        if (attrMap) {

            unsigned numAttrs = attrMap->length();

            for (unsigned i = 0; i < numAttrs; i++) {

                Attribute *attribute = attrMap->attributeItem(i);

                Attr *attr = attribute->attr();

                if (attr)

                    attr->normalize();

            }

        }

    }

    // Recursively go through the subtree beneath us, normalizing all nodes. In the case

    // where there are two adjacent text nodes, they are merged together

    while (child) {

        Node *nextChild = child->nextSibling();

        if (nextChild && child->nodeType() == TEXT_NODE && nextChild->nodeType() == TEXT_NODE) {

            // Current child and the next one are both text nodes... merge them

            Text *currentText = static_cast<Text*>(child);

            Text *nextText = static_cast<Text*>(nextChild);

            currentText->appendData(nextText->data(),ec);

            if (ec)

                return;

            nextChild->remove(ec);

            if (ec)

                return;

        }

        else {

            child->normalize();

            child = nextChild;

        }

    }

    // Check if we have a single empty text node left and remove it if so

    child = firstChild();

    if (child && !child->nextSibling() && child->isTextNode()) {

        Text *text = static_cast<Text*>(child);

        if (text->data().isEmpty())

            child->remove(ec);

    }

}

const AtomicString& Node::prefix() const

{

    // For nodes other than elements and attributes, the prefix is always null

    return nullAtom;

}

void Node::setPrefix(const AtomicString& /*prefix*/, ExceptionCode& ec)

{

    // The spec says that for nodes other than elements and attributes, prefix is always null.

    // It does not say what to do when the user tries to set the prefix on another type of

    // node, however Mozilla throws a NAMESPACE_ERR exception.

    ec = NAMESPACE_ERR;

}

const AtomicString& Node::localName() const

{

    return emptyAtom;

}

const AtomicString& Node::namespaceURI() const

{

    return nullAtom;

}

ContainerNode* Node::addChild(PassRefPtr<Node>)

{

    return 0;

}

bool Node::isContentEditable() const

{

    return parent() && parent()->isContentEditable();

}

bool Node::isContentRichlyEditable() const

{

    return parent() && parent()->isContentRichlyEditable();

}

bool Node::shouldUseInputMethod() const

{

    return isContentEditable();

}

IntRect Node::getRect() const

{

    int _x, _y;

    if (renderer() && renderer()->absolutePosition(_x, _y))

        return IntRect( _x, _y, renderer()->width(), renderer()->height() + renderer()->borderTopExtra() + renderer()->borderBottomExtra());

    return IntRect();

}

void Node::setChanged(StyleChangeType changeType)

{

    if ((changeType != NoStyleChange) && !attached()) // changed compared to what?

        return;

    if (!(changeType == InlineStyleChange && m_styleChange == FullStyleChange))

        m_styleChange = changeType;

    if (m_styleChange != NoStyleChange) {

        for (Node* p = parentNode(); p; p = p->parentNode())

            p->setHasChangedChild(true);

        document()->setDocumentChanged(true);

    }

}

bool Node::isFocusable() const

{

    return false;

}

bool Node::isKeyboardFocusable(KeyboardEvent*) const

{

    return isFocusable();

}

bool Node::isMouseFocusable() const

{

    return isFocusable();

}

unsigned Node::nodeIndex() const

{

    Node *_tempNode = previousSibling();

    unsigned count=0;

    for( count=0; _tempNode; count++ )

        _tempNode = _tempNode->previousSibling();

    return count;

}

void Node::registerNodeList(NodeList* list)

{

    if (!m_nodeLists)

        m_nodeLists = new NodeListsNodeData;

    else if (m_nodeLists->m_registeredLists.isEmpty()) 

        m_nodeLists->m_childNodeListCaches.reset();

    m_nodeLists->m_registeredLists.add(list);

    m_document->addNodeList();

}

void Node::unregisterNodeList(NodeList* list)

{

    ASSERT(m_nodeLists);

    m_document->removeNodeList();

    m_nodeLists->m_registeredLists.remove(list);

}

void Node::notifyLocalNodeListsAttributeChanged()

{

    if (!m_nodeLists)

        return;

    NodeListSet::iterator end = m_nodeLists->m_registeredLists.end();

    for (NodeListSet::iterator i = m_nodeLists->m_registeredLists.begin(); i != end; ++i)

        (*i)->rootNodeAttributeChanged();

}

void Node::notifyNodeListsAttributeChanged()

{

    for (Node *n = this; n; n = n->parentNode())

        n->notifyLocalNodeListsAttributeChanged();

}

void Node::notifyLocalNodeListsChildrenChanged()

{

    if (!m_nodeLists)

        return;

    m_nodeLists->m_childNodeListCaches.reset();

    NodeListSet::iterator end = m_nodeLists->m_registeredLists.end();

    for (NodeListSet::iterator i = m_nodeLists->m_registeredLists.begin(); i != end; ++i)

        (*i)->rootNodeChildrenChanged();

}

void Node::notifyNodeListsChildrenChanged()

{

    for (Node *n = this; n; n = n->parentNode())

        n->notifyLocalNodeListsChildrenChanged();

}

unsigned Node::childNodeCount() const

{

    return 0;

}

Node *Node::childNode(unsigned /*index*/) const

{

    return 0;

}

Node *Node::traverseNextNode(const Node *stayWithin) const

{

    if (firstChild()) {

        ASSERT(!stayWithin || firstChild()->isDescendantOf(stayWithin));

        return firstChild();

    }

    if (this == stayWithin)

        return 0;

    if (nextSibling()) {

        ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));

        return nextSibling();

    }

    const Node *n = this;

    while (n && !n->nextSibling() && (!stayWithin || n->parentNode() != stayWithin))

        n = n->parentNode();

    if (n) {

        ASSERT(!stayWithin || !n->nextSibling() || n->nextSibling()->isDescendantOf(stayWithin));

        return n->nextSibling();

    }

    return 0;

}

Node *Node::traverseNextSibling(const Node *stayWithin) const

{

    if (this == stayWithin)

        return 0;

    if (nextSibling()) {

        ASSERT(!stayWithin || nextSibling()->isDescendantOf(stayWithin));

        return nextSibling();