/*

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

 *           (C) 1999 Antti Koivisto (koivisto@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 "HTMLElement.h"

#include "CSSPropertyNames.h"

#include "CSSValueKeywords.h"

#include "DocumentFragment.h"

#include "Event.h"

#include "EventListener.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "Frame.h"

#include "HTMLBRElement.h"

#include "HTMLDocument.h"

#include "HTMLElementFactory.h"

#include "HTMLFormElement.h"

#include "HTMLNames.h"

#include "HTMLTokenizer.h"

#include "RenderWordBreak.h"

#include "Settings.h"

#include "Text.h"

#include "TextIterator.h"

#include "XMLTokenizer.h"

#include "markup.h"

#if PLATFORM(SYMBIAN)

#include "Page.h"

#include "Chrome.h" 

#endif 

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

using std::min;

using std::max;

HTMLElement::HTMLElement(const QualifiedName& tagName, Document *doc)

    : StyledElement(tagName, doc)

{

}

HTMLElement::~HTMLElement()

{

}

String HTMLElement::nodeName() const

{

    // FIXME: Would be nice to have an atomicstring lookup based off uppercase chars that does not have to copy

    // the string on a hit in the hash.

    if (document()->isHTMLDocument())

        return tagQName().localName().impl()->upper();

    return Element::nodeName();

}

HTMLTagStatus HTMLElement::endTagRequirement() const

{

    if (hasLocalName(wbrTag))

        return TagStatusForbidden;

    if (hasLocalName(dtTag) || hasLocalName(ddTag))

        return TagStatusOptional;

    // Same values as <span>.  This way custom tag name elements will behave like inline spans.

    return TagStatusRequired;

}

int HTMLElement::tagPriority() const

{

    if (hasLocalName(wbrTag))

        return 0;

    if (hasLocalName(addressTag) || hasLocalName(ddTag) || hasLocalName(dtTag) || hasLocalName(noscriptTag))

        return 3;

    if (hasLocalName(centerTag) || hasLocalName(nobrTag))

        return 5;

    if (hasLocalName(noembedTag) || hasLocalName(noframesTag))

        return 10;

    // Same values as <span>.  This way custom tag name elements will behave like inline spans.

    return 1;

}

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

{

    RefPtr<HTMLElement> clone = HTMLElementFactory::createHTMLElement(tagQName().localName(), document(), 0, false);

    if (!clone)

        return 0;

    if (namedAttrMap)

        *clone->attributes() = *namedAttrMap;

    clone->copyNonAttributeProperties(this);

    if (deep)

        cloneChildNodes(clone.get());

    return clone.release();

}

bool HTMLElement::mapToEntry(const QualifiedName& attrName, MappedAttributeEntry& result) const

{

    if (attrName == alignAttr ||

        attrName == contenteditableAttr) {

        result = eUniversal;

        return false;

    }

    if (attrName == dirAttr) {

        result = hasLocalName(bdoTag) ? eBDO : eUniversal;

        return false;

    }

    return StyledElement::mapToEntry(attrName, result);

}

void HTMLElement::parseMappedAttribute(MappedAttribute *attr)

{

    if (attr->name() == idAttr || attr->name() == classAttr || attr->name() == styleAttr)

        return StyledElement::parseMappedAttribute(attr);

    String indexstring;

    if (attr->name() == alignAttr) {

        if (equalIgnoringCase(attr->value(), "middle"))

            addCSSProperty(attr, CSS_PROP_TEXT_ALIGN, "center");

        else

            addCSSProperty(attr, CSS_PROP_TEXT_ALIGN, attr->value());

    } else if (attr->name() == contenteditableAttr) {

        setContentEditable(attr);

    } else if (attr->name() == tabindexAttr) {

        indexstring = getAttribute(tabindexAttr);

        if (indexstring.length())

            // Clamp tabindex to the range of 'short' to match Firefox's behavior.

            setTabIndex(max(static_cast<int>(std::numeric_limits<short>::min()), min(indexstring.toInt(), static_cast<int>(std::numeric_limits<short>::max()))));

    } else if (attr->name() == langAttr) {

        // FIXME: Implement

    } else if (attr->name() == dirAttr) {

        addCSSProperty(attr, CSS_PROP_DIRECTION, attr->value());

        addCSSProperty(attr, CSS_PROP_UNICODE_BIDI, hasLocalName(bdoTag) ? CSS_VAL_BIDI_OVERRIDE : CSS_VAL_EMBED);

    }

// standard events

    else if (attr->name() == onclickAttr) {

        setHTMLEventListener(clickEvent, attr);

    } else if (attr->name() == oncontextmenuAttr) {

        setHTMLEventListener(contextmenuEvent, attr);

    } else if (attr->name() == ondblclickAttr) {

        setHTMLEventListener(dblclickEvent, attr);

    } else if (attr->name() == onmousedownAttr) {

        setHTMLEventListener(mousedownEvent, attr);

    } else if (attr->name() == onmousemoveAttr) {

        setHTMLEventListener(mousemoveEvent, attr);

    } else if (attr->name() == onmouseoutAttr) {

        setHTMLEventListener(mouseoutEvent, attr);

    } else if (attr->name() == onmouseoverAttr) {

        setHTMLEventListener(mouseoverEvent, attr);

    } else if (attr->name() == onmouseupAttr) {

        setHTMLEventListener(mouseupEvent, attr);

    } else if (attr->name() == onmousewheelAttr) {

        setHTMLEventListener(mousewheelEvent, attr);

    } else if (attr->name() == onfocusAttr) {

        setHTMLEventListener(focusEvent, attr);

    } else if (attr->name() == onblurAttr) {

        setHTMLEventListener(blurEvent, attr);

    } else if (attr->name() == onkeydownAttr) {

        setHTMLEventListener(keydownEvent, attr);

    } else if (attr->name() == onkeypressAttr) {

        setHTMLEventListener(keypressEvent, attr);

    } else if (attr->name() == onkeyupAttr) {

        setHTMLEventListener(keyupEvent, attr);

    } else if (attr->name() == onscrollAttr) {

        setHTMLEventListener(scrollEvent, attr);

    } else if (attr->name() == onbeforecutAttr) {

        setHTMLEventListener(beforecutEvent, attr);

    } else if (attr->name() == oncutAttr) {

        setHTMLEventListener(cutEvent, attr);

    } else if (attr->name() == onbeforecopyAttr) {

        setHTMLEventListener(beforecopyEvent, attr);

    } else if (attr->name() == oncopyAttr) {

        setHTMLEventListener(copyEvent, attr);

    } else if (attr->name() == onbeforepasteAttr) {

        setHTMLEventListener(beforepasteEvent, attr);

    } else if (attr->name() == onpasteAttr) {

        setHTMLEventListener(pasteEvent, attr);

    } else if (attr->name() == ondragenterAttr) {

        setHTMLEventListener(dragenterEvent, attr);

    } else if (attr->name() == ondragoverAttr) {

        setHTMLEventListener(dragoverEvent, attr);

    } else if (attr->name() == ondragleaveAttr) {

        setHTMLEventListener(dragleaveEvent, attr);

    } else if (attr->name() == ondropAttr) {

        setHTMLEventListener(dropEvent, attr);

    } else if (attr->name() == ondragstartAttr) {

        setHTMLEventListener(dragstartEvent, attr);

    } else if (attr->name() == ondragAttr) {

        setHTMLEventListener(dragEvent, attr);

    } else if (attr->name() == ondragendAttr) {

        setHTMLEventListener(dragendEvent, attr);

    } else if (attr->name() == onselectstartAttr) {

        setHTMLEventListener(selectstartEvent, attr);

    } else if (attr->name() == onsubmitAttr) {

        setHTMLEventListener(submitEvent, attr);

    } else if (attr->name() == onerrorAttr) {

        setHTMLEventListener(errorEvent, attr);

    }

}

String HTMLElement::innerHTML() const

{

    return createMarkup(this, ChildrenOnly);

}

String HTMLElement::outerHTML() const

{

    return createMarkup(this);

}

PassRefPtr<DocumentFragment> HTMLElement::createContextualFragment(const String &html)

{

    // the following is in accordance with the definition as used by IE

    if (endTagRequirement() == TagStatusForbidden)

        return 0;

    if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||

        hasLocalName(headTag) || hasLocalName(styleTag) || hasLocalName(titleTag))

        return 0;

    RefPtr<DocumentFragment> fragment = new DocumentFragment(document());

    if (document()->isHTMLDocument())

         parseHTMLDocumentFragment(html, fragment.get());

    else {

        if (!parseXMLDocumentFragment(html, fragment.get(), this))

            // FIXME: We should propagate a syntax error exception out here.

            return 0;

    }

    // Exceptions are ignored because none ought to happen here.

    int ignoredExceptionCode;

    // we need to pop <html> and <body> elements and remove <head> to

    // accommodate folks passing complete HTML documents to make the

    // child of an element.

    RefPtr<Node> nextNode;

    for (RefPtr<Node> node = fragment->firstChild(); node; node = nextNode) {

        nextNode = node->nextSibling();

        if (node->hasTagName(htmlTag) || node->hasTagName(bodyTag)) {

            Node *firstChild = node->firstChild();

            if (firstChild)

                nextNode = firstChild;

            RefPtr<Node> nextChild;

            for (RefPtr<Node> child = firstChild; child; child = nextChild) {

                nextChild = child->nextSibling();

                node->removeChild(child.get(), ignoredExceptionCode);

                ASSERT(!ignoredExceptionCode);

                fragment->insertBefore(child, node.get(), ignoredExceptionCode);

                ASSERT(!ignoredExceptionCode);

            }

            fragment->removeChild(node.get(), ignoredExceptionCode);

            ASSERT(!ignoredExceptionCode);

        } else if (node->hasTagName(headTag)) {

            fragment->removeChild(node.get(), ignoredExceptionCode);

            ASSERT(!ignoredExceptionCode);

        }

    }

    return fragment.release();

}

static inline bool hasOneChild(ContainerNode* node)

{

    Node* firstChild = node->firstChild();

    return firstChild && !firstChild->nextSibling();

}

static inline bool hasOneTextChild(ContainerNode* node)

{

    return hasOneChild(node) && node->firstChild()->isTextNode();

}

static void replaceChildrenWithFragment(HTMLElement* element, PassRefPtr<DocumentFragment> fragment, ExceptionCode& ec)

{

    if (!fragment->firstChild()) {

        element->removeChildren();

        return;

    }

    if (hasOneTextChild(element) && hasOneTextChild(fragment.get())) {

        static_cast<Text*>(element->firstChild())->setData(static_cast<Text*>(fragment->firstChild())->string(), ec);

        return;

    }

    if (hasOneChild(element)) {

        element->replaceChild(fragment, element->firstChild(), ec);

        return;

    }

    #if PLATFORM(SYMBIAN) 

     #endif 

    element->removeChildren();

    element->appendChild(fragment, ec);

}

static void replaceChildrenWithText(HTMLElement* element, const String& text, ExceptionCode& ec)

{

    if (hasOneTextChild(element)) {

        static_cast<Text*>(element->firstChild())->setData(text, ec);

        return;

    }

    RefPtr<Text> textNode = new Text(element->document(), text);

    if (hasOneChild(element)) {

        element->replaceChild(textNode.release(), element->firstChild(), ec);

        return;

    }

    #if PLATFORM(SYMBIAN) 

         element->document()->page()->chrome()->setElementVisibilityChanged(true); 

     #endif 

    element->removeChildren();

    element->appendChild(textNode.release(), ec);

}

void HTMLElement::setInnerHTML(const String& html, ExceptionCode& ec)

{

    RefPtr<DocumentFragment> fragment = createContextualFragment(html);

    if (!fragment) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    replaceChildrenWithFragment(this, fragment.release(), ec);

}

void HTMLElement::setOuterHTML(const String& html, ExceptionCode& ec)

{

    Node* p = parent();

    if (!p || !p->isHTMLElement()) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    HTMLElement* parent = static_cast<HTMLElement*>(p);

    RefPtr<DocumentFragment> fragment = parent->createContextualFragment(html);

    if (!fragment) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    // FIXME: Why doesn't this have code to merge neighboring text nodes the way setOuterText does?

    parent->replaceChild(fragment.release(), this, ec);

}

void HTMLElement::setInnerText(const String& text, ExceptionCode& ec)

{

    // follow the IE specs about when this is allowed

    if (endTagRequirement() == TagStatusForbidden) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||

        hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) || 

        hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||

        hasLocalName(trTag)) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    // FIXME: This doesn't take whitespace collapsing into account at all.

    if (!text.contains('\n') && !text.contains('\r')) {

        if (text.isEmpty()) {

            removeChildren();

            return;

        }

        replaceChildrenWithText(this, text, ec);

        return;

    }

    // FIXME: Do we need to be able to detect preserveNewline style even when there's no renderer?

    // FIXME: Can the renderer be out of date here? Do we need to call updateRendering?

    // For example, for the contents of textarea elements that are display:none?

    RenderObject* r = renderer();

    if (r && r->style()->preserveNewline()) {

        if (!text.contains('\r')) {

            replaceChildrenWithText(this, text, ec);

            return;

        }

        String textWithConsistentLineBreaks = text;

        textWithConsistentLineBreaks.replace("\r\n", "\n");

        textWithConsistentLineBreaks.replace('\r', '\n');

        replaceChildrenWithText(this, textWithConsistentLineBreaks, ec);

        return;

    }

    // Add text nodes and <br> elements.

    ec = 0;

    RefPtr<DocumentFragment> fragment = new DocumentFragment(document());

    int lineStart = 0;

    UChar prev = 0;

    int length = text.length();

    for (int i = 0; i < length; ++i) {

        UChar c = text[i];

        if (c == '\n' || c == '\r') {

            if (i > lineStart) {

                fragment->appendChild(new Text(document(), text.substring(lineStart, i - lineStart)), ec);

                if (ec)

                    return;

            }

            if (!(c == '\n' && i != 0 && prev == '\r')) {

                fragment->appendChild(new HTMLBRElement(document()), ec);

                if (ec)

                    return;

            }

            lineStart = i + 1;

        }

        prev = c;

    }

    if (length > lineStart)

        fragment->appendChild(new Text(document(), text.substring(lineStart, length - lineStart)), ec);

    replaceChildrenWithFragment(this, fragment.release(), ec);

}

void HTMLElement::setOuterText(const String &text, ExceptionCode& ec)

{

    // follow the IE specs about when this is allowed

    if (endTagRequirement() == TagStatusForbidden) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    if (hasLocalName(colTag) || hasLocalName(colgroupTag) || hasLocalName(framesetTag) ||

        hasLocalName(headTag) || hasLocalName(htmlTag) || hasLocalName(tableTag) || 

        hasLocalName(tbodyTag) || hasLocalName(tfootTag) || hasLocalName(theadTag) ||

        hasLocalName(trTag)) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    Node* parent = parentNode();

    if (!parent) {

        ec = NO_MODIFICATION_ALLOWED_ERR;

        return;

    }

    // FIXME: This creates a new text node even when the text is empty.

    // FIXME: This creates a single text node even when the text has CR and LF

    // characters in it. Instead it should create <br> elements.

    RefPtr<Text> t = new Text(document(), text);

    ec = 0;

    parent->replaceChild(t, this, ec);

    if (ec)

        return;

    // is previous node a text node? if so, merge into it

    Node* prev = t->previousSibling();

    if (prev && prev->isTextNode()) {

        Text* textPrev = static_cast<Text*>(prev);

        textPrev->appendData(t->data(), ec);

        if (ec)

            return;

        t->remove(ec);

        if (ec)

            return;

        t = textPrev;

    }

    // is next node a text node? if so, merge it in

    Node* next = t->nextSibling();

    if (next && next->isTextNode()) {

        Text* textNext = static_cast<Text*>(next);

        t->appendData(textNext->data(), ec);

        if (ec)

            return;

        textNext->remove(ec);

        if (ec)

            return;

    }

}

void HTMLElement::addHTMLAlignment(MappedAttribute* attr)

{

    // vertical alignment with respect to the current baseline of the text

    // right or left means floating images

    int propfloat = -1;

    int propvalign = -1;

    const AtomicString& alignment = attr->value();

    if (equalIgnoringCase(alignment, "absmiddle")) {

        propvalign = CSS_VAL_MIDDLE;

    } else if (equalIgnoringCase(alignment, "absbottom")) {

        propvalign = CSS_VAL_BOTTOM;

    } else if (equalIgnoringCase(alignment, "left")) {

        propfloat = CSS_VAL_LEFT;

        propvalign = CSS_VAL_TOP;

    } else if (equalIgnoringCase(alignment, "right")) {

        propfloat = CSS_VAL_RIGHT;

        propvalign = CSS_VAL_TOP;

    } else if (equalIgnoringCase(alignment, "top")) {

        propvalign = CSS_VAL_TOP;

    } else if (equalIgnoringCase(alignment, "middle")) {

        propvalign = CSS_VAL__WEBKIT_BASELINE_MIDDLE;

    } else if (equalIgnoringCase(alignment, "center")) {

        propvalign = CSS_VAL_MIDDLE;

    } else if (equalIgnoringCase(alignment, "bottom")) {

        propvalign = CSS_VAL_BASELINE;