/*

 * 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.

 *           (C) 2006 Alexey Proskuryakov (ap@nypop.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 "HTMLFormControlElement.h"

#include "Attribute.h"

#include "CharacterNames.h"

#include "Chrome.h"

#include "ChromeClient.h"

#include "Document.h"

#include "ElementRareData.h"

#include "Event.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "Frame.h"

#include "HTMLFormElement.h"

#include "HTMLInputElement.h"

#include "HTMLNames.h"

#include "LegacyHTMLTreeBuilder.h"

#include "LegacyHTMLDocumentParser.h"

#include "LabelsNodeList.h"

#include "Page.h"

#include "RenderBox.h"

#include "RenderTextControl.h"

#include "RenderTheme.h"

#include "ScriptEventListener.h"

#include "ValidityState.h"

#include <wtf/Vector.h>

namespace WebCore {

using namespace HTMLNames;

HTMLFormControlElement::HTMLFormControlElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)

    : HTMLElement(tagName, document)

    , m_form(form)

    , m_disabled(false)

    , m_readOnly(false)

    , m_required(false)

    , m_valueMatchesRenderer(false)

    , m_willValidateInitialized(false)

    , m_willValidate(true)

    , m_isValid(true)

{

    if (!m_form)

        m_form = findFormAncestor();

    if (m_form)

        m_form->registerFormElement(this);

}

HTMLFormControlElement::~HTMLFormControlElement()

{

    if (m_form)

        m_form->removeFormElement(this);

}

bool HTMLFormControlElement::formNoValidate() const

{

    return !getAttribute(formnovalidateAttr).isNull();

}

ValidityState* HTMLFormControlElement::validity()

{

    if (!m_validityState)

        m_validityState = ValidityState::create(this);

    return m_validityState.get();

}

void HTMLFormControlElement::parseMappedAttribute(Attribute* attr)

{

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

        bool oldDisabled = m_disabled;

        m_disabled = !attr->isNull();

        if (oldDisabled != m_disabled) {

            setNeedsStyleRecalc();

            if (renderer() && renderer()->style()->hasAppearance())

                renderer()->theme()->stateChanged(renderer(), EnabledState);

        }

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

        bool oldReadOnly = m_readOnly;

        m_readOnly = !attr->isNull();

        if (oldReadOnly != m_readOnly) {

            setNeedsStyleRecalc();

            if (renderer() && renderer()->style()->hasAppearance())

                renderer()->theme()->stateChanged(renderer(), ReadOnlyState);

        }

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

        bool oldRequired = m_required;

        m_required = !attr->isNull();

        if (oldRequired != m_required) {

            setNeedsValidityCheck();

            setNeedsStyleRecalc(); // Updates for :required :optional classes.

        }

    } else

        HTMLElement::parseMappedAttribute(attr);

    setNeedsWillValidateCheck();

}

void HTMLFormControlElement::attach()

{

    ASSERT(!attached());

    HTMLElement::attach();

    // The call to updateFromElement() needs to go after the call through

    // to the base class's attach() because that can sometimes do a close

    // on the renderer.

    if (renderer())

        renderer()->updateFromElement();

    // Focus the element if it should honour its autofocus attribute.

    // We have to determine if the element is a TextArea/Input/Button/Select,

    // if input type hidden ignore autofocus. So if disabled or readonly.

    bool isInputTypeHidden = false;

    if (hasTagName(inputTag))

        isInputTypeHidden = static_cast<HTMLInputElement*>(this)->isInputTypeHidden();

    if (autofocus() && renderer() && !document()->ignoreAutofocus() && !isReadOnlyFormControl() &&

            ((hasTagName(inputTag) && !isInputTypeHidden) || hasTagName(selectTag) ||

              hasTagName(buttonTag) || hasTagName(textareaTag)))

         focus();

}

void HTMLFormControlElement::insertedIntoTree(bool deep)

{

    if (!m_form) {

        // This handles the case of a new form element being created by

        // JavaScript and inserted inside a form.  In the case of the parser

        // setting a form, we will already have a non-null value for m_form, 

        // and so we don't need to do anything.

        m_form = findFormAncestor();

        if (m_form)

            m_form->registerFormElement(this);

        else

            document()->checkedRadioButtons().addButton(this);

    }

    HTMLElement::insertedIntoTree(deep);

}

static inline Node* findRoot(Node* n)

{

    Node* root = n;

    for (; n; n = n->parentNode())

        root = n;

    return root;

}

void HTMLFormControlElement::removedFromTree(bool deep)

{

    // If the form and element are both in the same tree, preserve the connection to the form.

    // Otherwise, null out our form and remove ourselves from the form's list of elements.

    LegacyHTMLTreeBuilder* treeBuilder = 0;

    if (DocumentParser* parser = document()->parser())

        treeBuilder = parser->htmlTreeBuilder();

    if (m_form && !(treeBuilder && treeBuilder->isHandlingResidualStyleAcrossBlocks()) && findRoot(this) != findRoot(m_form)) {

        m_form->removeFormElement(this);

        m_form = 0;

    }

    HTMLElement::removedFromTree(deep);

}

const AtomicString& HTMLFormControlElement::formControlName() const

{

    const AtomicString& name = fastGetAttribute(nameAttr);

    return name.isNull() ? emptyAtom : name;

}

void HTMLFormControlElement::setName(const AtomicString& value)

{

    setAttribute(nameAttr, value);

}

void HTMLFormControlElement::dispatchFormControlChangeEvent()

{

    dispatchEvent(Event::create(eventNames().changeEvent, true, false));

}

void HTMLFormControlElement::setDisabled(bool b)

{

    setAttribute(disabledAttr, b ? "" : 0);

}

bool HTMLFormControlElement::autofocus() const

{

    return hasAttribute(autofocusAttr);

}

bool HTMLFormControlElement::required() const

{

    return m_required;

}

static void updateFromElementCallback(Node* node)

{

    ASSERT_ARG(node, node->isElementNode());

    ASSERT_ARG(node, static_cast<Element*>(node)->isFormControlElement());

    ASSERT(node->renderer());

    if (RenderObject* renderer = node->renderer())

        renderer->updateFromElement();

}

void HTMLFormControlElement::recalcStyle(StyleChange change)

{

    HTMLElement::recalcStyle(change);

    // updateFromElement() can cause the selection to change, and in turn

    // trigger synchronous layout, so it must not be called during style recalc.

    if (renderer())

        queuePostAttachCallback(updateFromElementCallback, this);

}

bool HTMLFormControlElement::supportsFocus() const

{

    return !disabled();

}

bool HTMLFormControlElement::isFocusable() const

{

    if (!renderer() || 

        !renderer()->isBox() || toRenderBox(renderer())->size().isEmpty())

        return false;

    // HTMLElement::isFocusable handles visibility and calls suportsFocus which

    // will cover the disabled case.

    return HTMLElement::isFocusable();

}

bool HTMLFormControlElement::isKeyboardFocusable(KeyboardEvent* event) const

{

    if (isFocusable())

        if (document()->frame())

            return document()->frame()->eventHandler()->tabsToAllControls(event);

    return false;

}

bool HTMLFormControlElement::isMouseFocusable() const

{

#if PLATFORM(GTK)

    return HTMLElement::isMouseFocusable();

#else

    return false;

#endif

}

short HTMLFormControlElement::tabIndex() const

{

    // Skip the supportsFocus check in HTMLElement.

    return Element::tabIndex();

}

bool HTMLFormControlElement::recalcWillValidate() const

{

    // FIXME: Should return false if this element has a datalist element as an

    // ancestor. See HTML5 4.10.10 'The datalist element.'

    return !m_disabled && !m_readOnly;

}

bool HTMLFormControlElement::willValidate() const

{

    if (!m_willValidateInitialized) {

        m_willValidateInitialized = true;

        m_willValidate = recalcWillValidate();

    } else {

        // If the following assertion fails, setNeedsWillValidateCheck() is not

        // called correctly when something which changes recalcWillValidate() result

        // is updated.

        ASSERT(m_willValidate == recalcWillValidate());

    }

    return m_willValidate;

}

void HTMLFormControlElement::setNeedsWillValidateCheck()

{

    // We need to recalculate willValidte immediately because willValidate

    // change can causes style change.

    bool newWillValidate = recalcWillValidate();

    if (m_willValidateInitialized && m_willValidate == newWillValidate)

        return;

    m_willValidateInitialized = true;

    m_willValidate = newWillValidate;

    setNeedsStyleRecalc();

    // FIXME: Show/hide a validation message.

}

String HTMLFormControlElement::validationMessage()

{

    return validity()->validationMessage();

}

bool HTMLFormControlElement::checkValidity(Vector<RefPtr<HTMLFormControlElement> >* unhandledInvalidControls)

{

    if (!willValidate() || isValidFormControlElement())

        return true;

    // An event handler can deref this object.

    RefPtr<HTMLFormControlElement> protector(this);

    RefPtr<Document> originalDocument(document());

    bool needsDefaultAction = dispatchEvent(Event::create(eventNames().invalidEvent, false, true));

    if (needsDefaultAction && unhandledInvalidControls && inDocument() && originalDocument == document())

        unhandledInvalidControls->append(this);

    return false;

}

bool HTMLFormControlElement::isValidFormControlElement()

{

    // If the following assertion fails, setNeedsValidityCheck() is not called

    // correctly when something which changes validity is updated.

    ASSERT(m_isValid == validity()->valid());

    return m_isValid;

}

void HTMLFormControlElement::setNeedsValidityCheck()

{

    bool newIsValid = validity()->valid();

    if (willValidate() && newIsValid != m_isValid) {

        // Update style for pseudo classes such as :valid :invalid.

        setNeedsStyleRecalc();

    }

    m_isValid = newIsValid;

    // FIXME: show/hide a validation message.

}

void HTMLFormControlElement::setCustomValidity(const String& error)

{

    validity()->setCustomErrorMessage(error);

}

void HTMLFormControlElement::dispatchFocusEvent()

{

    if (document()->page())

        document()->page()->chrome()->client()->formDidFocus(this);

    HTMLElement::dispatchFocusEvent();

}

void HTMLFormControlElement::dispatchBlurEvent()

{

    if (document()->page())

        document()->page()->chrome()->client()->formDidBlur(this);

    HTMLElement::dispatchBlurEvent();

}

HTMLFormElement* HTMLFormControlElement::virtualForm() const

{

    return m_form;

}

bool HTMLFormControlElement::isDefaultButtonForForm() const

{

    return isSuccessfulSubmitButton() && m_form && m_form->defaultButton() == this;

}

void HTMLFormControlElement::removeFromForm()

{

    if (!m_form)

        return;

    m_form->removeFormElement(this);

    m_form = 0;

}

bool HTMLFormControlElement::isLabelable() const

{

    // FIXME: Add meterTag and outputTag to the list once we support them.

    return hasTagName(buttonTag) || hasTagName(inputTag) || hasTagName(keygenTag)

#if ENABLE(METER_TAG)

        || hasTagName(meterTag)

#endif

#if ENABLE(PROGRESS_TAG)

        || hasTagName(progressTag)

#endif

        || hasTagName(selectTag) || hasTagName(textareaTag);

}

PassRefPtr<NodeList> HTMLFormControlElement::labels()

{

    if (!isLabelable())

        return 0;

    if (!document())

        return 0;

    NodeRareData* data = Node::ensureRareData();

    if (!data->nodeLists()) {

        data->setNodeLists(NodeListsNodeData::create());

        document()->addNodeListCache();

    }

    return LabelsNodeList::create(this);

}

HTMLFormControlElementWithState::HTMLFormControlElementWithState(const QualifiedName& tagName, Document* doc, HTMLFormElement* f)

    : HTMLFormControlElement(tagName, doc, f)

{

    document()->registerFormElementWithState(this);

}

HTMLFormControlElementWithState::~HTMLFormControlElementWithState()

{

    document()->unregisterFormElementWithState(this);

}

void HTMLFormControlElementWithState::willMoveToNewOwnerDocument()

{

    document()->unregisterFormElementWithState(this);

    HTMLFormControlElement::willMoveToNewOwnerDocument();

}

void HTMLFormControlElementWithState::didMoveToNewOwnerDocument()

{

    document()->registerFormElementWithState(this);

    HTMLFormControlElement::didMoveToNewOwnerDocument();

}

bool HTMLFormControlElementWithState::autoComplete() const

{

    if (!form())

        return true;

    return form()->autoComplete();

}

bool HTMLFormControlElementWithState::shouldSaveAndRestoreFormControlState() const

{

    // We don't save/restore control state in a form with autocomplete=off.

    return autoComplete();

}

void HTMLFormControlElementWithState::finishParsingChildren()

{

    HTMLFormControlElement::finishParsingChildren();

    // We don't save state of a control with shouldSaveAndRestoreFormControlState()=false.

    // But we need to skip restoring process too because a control in another

    // form might have the same pair of name and type and saved its state.

    if (!shouldSaveAndRestoreFormControlState())

        return;

    Document* doc = document();

    if (doc->hasStateForNewFormElements()) {

        String state;

        if (doc->takeStateForFormElement(name().impl(), type().impl(), state))

            restoreFormControlState(state);

    }

}

void HTMLFormControlElementWithState::defaultEventHandler(Event* event)

{

    if (event->type() == eventNames().webkitEditableContentChangedEvent && renderer() && renderer()->isTextControl()) {

        toRenderTextControl(renderer())->subtreeHasChanged();

        return;

    }

    HTMLFormControlElement::defaultEventHandler(event);

}

HTMLTextFormControlElement::HTMLTextFormControlElement(const QualifiedName& tagName, Document* doc, HTMLFormElement* form)

    : HTMLFormControlElementWithState(tagName, doc, form)

{

}

HTMLTextFormControlElement::~HTMLTextFormControlElement()

{

}

void HTMLTextFormControlElement::dispatchFocusEvent()

{

    if (supportsPlaceholder())

        updatePlaceholderVisibility(false);

    handleFocusEvent();

    HTMLFormControlElementWithState::dispatchFocusEvent();

}

void HTMLTextFormControlElement::dispatchBlurEvent()

{

    if (supportsPlaceholder())

        updatePlaceholderVisibility(false);

    handleBlurEvent();

    HTMLFormControlElementWithState::dispatchBlurEvent();

}

String HTMLTextFormControlElement::strippedPlaceholder() const

{

    // According to the HTML5 specification, we need to remove CR and LF from

    // the attribute value.

    const AtomicString& attributeValue = getAttribute(placeholderAttr);

    if (!attributeValue.contains(newlineCharacter) && !attributeValue.contains(carriageReturn))

        return attributeValue;

    Vector<UChar> stripped;

    unsigned length = attributeValue.length();

    stripped.reserveCapacity(length);

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

        UChar character = attributeValue[i];

        if (character == newlineCharacter || character == carriageReturn)

            continue;

        stripped.append(character);

    }

    return String::adopt(stripped);

}

static bool isNotLineBreak(UChar ch) { return ch != newlineCharacter && ch != carriageReturn; }

bool HTMLTextFormControlElement::isPlaceholderEmpty() const

{

    const AtomicString& attributeValue = getAttribute(placeholderAttr);