/*

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

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

 *           (C) 2001 Peter Kelly (pmk@post.com)

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

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

#include "CSSStyleSelector.h"

#include "Document.h"

#include "Editor.h"

#include "ExceptionCode.h"

#include "FocusController.h"

#include "Frame.h"

#include "FrameView.h"

#include "HTMLElement.h"

#include "HTMLNames.h"

#include "KURL.h"

#include "NamedAttrMap.h"

#include "Page.h"

#include "RenderBlock.h"

#include "SelectionController.h"

#include "TextIterator.h"

#include "TextStream.h"

#include "XMLNames.h"

namespace WebCore {

using namespace HTMLNames;

using namespace XMLNames;

class ElementRareData {

public:

    ElementRareData(Element*);

    void resetComputedStyle(Element*);

    IntSize m_minimumSizeForResizing;

    RenderStyle* m_computedStyle;

    bool m_needsFocusAppearanceUpdateSoonAfterAttach;

};

typedef HashMap<const Element*, ElementRareData*> ElementRareDataMap;

static ElementRareDataMap& rareDataMap()

{

    static ElementRareDataMap* dataMap = new ElementRareDataMap;

    return *dataMap;

}

static ElementRareData* rareDataFromMap(const Element* element)

{

    return rareDataMap().get(element);

}

static inline IntSize defaultMinimumSizeForResizing()

{

    return IntSize(INT_MAX, INT_MAX);

}

inline ElementRareData::ElementRareData(Element* element)

    : m_minimumSizeForResizing(defaultMinimumSizeForResizing())

    , m_computedStyle(0)

    , m_needsFocusAppearanceUpdateSoonAfterAttach(false)

{

}

void ElementRareData::resetComputedStyle(Element* element)

{

    if (!m_computedStyle)

        return;

    m_computedStyle->deref(element->document()->renderArena());

    m_computedStyle = 0;

}

Element::Element(const QualifiedName& qName, Document *doc)

    : ContainerNode(doc)

    , m_tagName(qName)

{

}

Element::~Element()

{

    if (namedAttrMap)

        namedAttrMap->detachFromElement();

    if (!m_attrWasSpecifiedOrElementHasRareData)

        ASSERT(!rareDataMap().contains(this));

    else {

        ElementRareDataMap& dataMap = rareDataMap();

        ElementRareDataMap::iterator it = dataMap.find(this);

        ASSERT(it != dataMap.end());

        delete it->second;

        dataMap.remove(it);

    }

}

inline ElementRareData* Element::rareData()

{

    return m_attrWasSpecifiedOrElementHasRareData ? rareDataFromMap(this) : 0;

}

inline const ElementRareData* Element::rareData() const

{

    return m_attrWasSpecifiedOrElementHasRareData ? rareDataFromMap(this) : 0;

}

ElementRareData* Element::createRareData()

{

    if (m_attrWasSpecifiedOrElementHasRareData)

        return rareDataMap().get(this);

    ASSERT(!rareDataMap().contains(this));

    ElementRareData* data = new ElementRareData(this);

    rareDataMap().set(this, data);

    m_attrWasSpecifiedOrElementHasRareData = true;

    return data;

}

PassRefPtr<Node> Element::cloneNode(bool deep)

{

    ExceptionCode ec = 0;

    RefPtr<Element> clone = document()->createElementNS(namespaceURI(), nodeName(), ec);

    ASSERT(!ec);

    // clone attributes

    if (namedAttrMap)

        *clone->attributes() = *namedAttrMap;

    clone->copyNonAttributeProperties(this);

    if (deep)

        cloneChildNodes(clone.get());

    return clone.release();

}

void Element::removeAttribute(const QualifiedName& name, ExceptionCode& ec)

{

    if (namedAttrMap) {

        namedAttrMap->removeNamedItem(name, ec);

        if (ec == NOT_FOUND_ERR)

            ec = 0;

    }

}

void Element::setAttribute(const QualifiedName& name, const String &value)

{

    ExceptionCode ec = 0;

    setAttribute(name, value.impl(), ec);

}

// Virtual function, defined in base class.

NamedAttrMap *Element::attributes() const

{

    return attributes(false);

}

NamedAttrMap* Element::attributes(bool readonly) const

{

    updateStyleAttributeIfNeeded();

    if (!readonly && !namedAttrMap)

        createAttributeMap();

    return namedAttrMap.get();

}

Node::NodeType Element::nodeType() const

{

    return ELEMENT_NODE;

}

const AtomicStringList* Element::getClassList() const

{

    return 0;

}

const AtomicString& Element::getIDAttribute() const

{

    return namedAttrMap ? namedAttrMap->id() : nullAtom;

}

bool Element::hasAttribute(const QualifiedName& name) const

{

    return hasAttributeNS(name.namespaceURI(), name.localName());

}

const AtomicString& Element::getAttribute(const QualifiedName& name) const

{

    if (name == styleAttr)

        updateStyleAttributeIfNeeded();

    if (namedAttrMap)

        if (Attribute* a = namedAttrMap->getAttributeItem(name))

            return a->value();

    return nullAtom;

}

void Element::scrollIntoView(bool alignToTop) 

{

    document()->updateLayoutIgnorePendingStylesheets();

    IntRect bounds = getRect();    

    if (renderer()) {

        // Align to the top / bottom and to the closest edge.

        if (alignToTop)

            renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignToEdgeIfNeeded, RenderLayer::gAlignTopAlways);

        else

            renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignToEdgeIfNeeded, RenderLayer::gAlignBottomAlways);

    }

}

void Element::scrollIntoViewIfNeeded(bool centerIfNeeded)

{

    document()->updateLayoutIgnorePendingStylesheets();

    IntRect bounds = getRect();    

    if (renderer()) {

        if (centerIfNeeded)

            renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignCenterIfNeeded, RenderLayer::gAlignCenterIfNeeded);

        else

            renderer()->enclosingLayer()->scrollRectToVisible(bounds, RenderLayer::gAlignToEdgeIfNeeded, RenderLayer::gAlignToEdgeIfNeeded);

    }

}

void Element::scrollByUnits(int units, ScrollGranularity granularity)

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject *rend = renderer()) {

        if (rend->hasOverflowClip()) {

            ScrollDirection direction = ScrollDown;

            if (units < 0) {

                direction = ScrollUp;

                units = -units;

            }

            rend->layer()->scroll(direction, granularity, units);

        }

    }

}

void Element::scrollByLines(int lines)

{

    scrollByUnits(lines, ScrollByLine);

}

void Element::scrollByPages(int pages)

{

    scrollByUnits(pages, ScrollByPage);

}

int Element::offsetLeft()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->offsetLeft();

    return 0;

}

int Element::offsetTop()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->offsetTop();

    return 0;

}

int Element::offsetWidth()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->offsetWidth();

    return 0;

}

int Element::offsetHeight()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->offsetHeight();

    return 0;

}

Element* Element::offsetParent()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        if (RenderObject* offsetParent = rend->offsetParent())

            return static_cast<Element*>(offsetParent->element());

    return 0;

}

int Element::clientLeft()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->clientLeft();

    return 0;

}

int Element::clientTop()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->clientTop();

    return 0;

}

int Element::clientWidth()

{

    document()->updateLayoutIgnorePendingStylesheets();

    // When in strict mode, clientWidth for the document element should return the width of the containing frame.

    // When in quirks mode, clientWidth for the body element should return the width of the containing frame.

    bool inCompatMode = document()->inCompatMode();

    if ((!inCompatMode && document()->documentElement() == this) ||

        (inCompatMode && isHTMLElement() && document()->body() == this)) {

        if (FrameView* view = document()->view())

            return view->visibleWidth();

    }

    if (RenderObject* rend = renderer())

        return rend->clientWidth();

    return 0;

}

int Element::clientHeight()

{

    document()->updateLayoutIgnorePendingStylesheets();

    // When in strict mode, clientHeight for the document element should return the height of the containing frame.

    // When in quirks mode, clientHeight for the body element should return the height of the containing frame.

    bool inCompatMode = document()->inCompatMode();     

    if ((!inCompatMode && document()->documentElement() == this) ||

        (inCompatMode && isHTMLElement() && document()->body() == this)) {

        if (FrameView* view = document()->view())

            return view->visibleHeight();

    }

    if (RenderObject* rend = renderer())

        return rend->clientHeight();

    return 0;

}

int Element::scrollLeft()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->scrollLeft();

    return 0;

}

int Element::scrollTop()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->scrollTop();

    return 0;

}

void Element::setScrollLeft(int newLeft)

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject *rend = renderer())

        rend->setScrollLeft(newLeft);

}

void Element::setScrollTop(int newTop)

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject *rend = renderer())

        rend->setScrollTop(newTop);

}

int Element::scrollWidth()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->scrollWidth();

    return 0;

}

int Element::scrollHeight()

{

    document()->updateLayoutIgnorePendingStylesheets();

    if (RenderObject* rend = renderer())

        return rend->scrollHeight();

    return 0;

}

static inline bool inHTMLDocument(const Element* e)

{

    return e && e->document()->isHTMLDocument();

}

const AtomicString& Element::getAttribute(const String& name) const

{

    String localName = inHTMLDocument(this) ? name.lower() : name;

    if (localName == styleAttr.localName())

        updateStyleAttributeIfNeeded();

    if (namedAttrMap)

        if (Attribute* a = namedAttrMap->getAttributeItem(localName))

            return a->value();

    return nullAtom;

}

const AtomicString& Element::getAttributeNS(const String& namespaceURI, const String& localName) const

{

    return getAttribute(QualifiedName(nullAtom, localName, namespaceURI));

}

void Element::setAttribute(const String& name, const String& value, ExceptionCode& ec)

{

    if (!Document::isValidName(name)) {

        ec = INVALID_CHARACTER_ERR;

        return;

    }

    String localName = inHTMLDocument(this) ? name.lower() : name;

    // allocate attributemap if necessary

    Attribute* old = attributes(false)->getAttributeItem(localName);

    // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly

    if (namedAttrMap->isReadOnlyNode()) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    if (inDocument())

        document()->incDOMTreeVersion();

    if (localName == idAttr.localName())

        updateId(old ? old->value() : nullAtom, value);

    if (old && value.isNull())

        namedAttrMap->removeAttribute(old->name());

    else if (!old && !value.isNull())

        namedAttrMap->addAttribute(createAttribute(QualifiedName(nullAtom, localName, nullAtom), value.impl()));

    else if (old && !value.isNull()) {

        old->setValue(value);

        attributeChanged(old);

    }

}

void Element::setAttribute(const QualifiedName& name, StringImpl* value, ExceptionCode& ec)

{

    if (inDocument())

        document()->incDOMTreeVersion();

    // allocate attributemap if necessary

    Attribute* old = attributes(false)->getAttributeItem(name);

    // NO_MODIFICATION_ALLOWED_ERR: Raised when the node is readonly

    if (namedAttrMap->isReadOnlyNode()) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    if (name == idAttr)

        updateId(old ? old->value() : nullAtom, value);

    if (old && !value)

        namedAttrMap->removeAttribute(name);

    else if (!old && value)

        namedAttrMap->addAttribute(createAttribute(name, value));

    else if (old && value) {

        old->setValue(value);

        attributeChanged(old);

    }

}

Attribute* Element::createAttribute(const QualifiedName& name, StringImpl* value)

{

    return new Attribute(name, value);

}

void Element::setAttributeMap(NamedAttrMap* list)

{

    if (inDocument())

        document()->incDOMTreeVersion();

    // If setting the whole map changes the id attribute, we need to call updateId.

    Attribute *oldId = namedAttrMap ? namedAttrMap->getAttributeItem(idAttr) : 0;

    Attribute *newId = list ? list->getAttributeItem(idAttr) : 0;

    if (oldId || newId)

        updateId(oldId ? oldId->value() : nullAtom, newId ? newId->value() : nullAtom);

    if (namedAttrMap)

        namedAttrMap->element = 0;

    namedAttrMap = list;

    if (namedAttrMap) {

        namedAttrMap->element = this;

        unsigned len = namedAttrMap->length();

        for (unsigned i = 0; i < len; i++)

            attributeChanged(namedAttrMap->attrs[i]);

        // FIXME: What about attributes that were in the old map that are not in the new map?

    }

}

bool Element::hasAttributes() const

{

    updateStyleAttributeIfNeeded();

    return namedAttrMap && namedAttrMap->length() > 0;

}