/*

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

 *           (C) 2006 Alexey Proskuryakov (ap@nypop.com)

 * Copyright (C) 2007 Samuel Weinig (sam@webkit.org)

 *

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

#include "AXObjectCache.h"

#include "CSSPropertyNames.h"

#include "ChromeClient.h"

#include "Document.h"

#include "Editor.h"

#include "Event.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "File.h"

#include "FileList.h"

#include "FocusController.h"

#include "FormDataList.h"

#include "Frame.h"

#include "HTMLDataListElement.h"

#include "HTMLFormElement.h"

#include "HTMLImageLoader.h"

#include "HTMLNames.h"

#include "HTMLOptionElement.h"

#include "ScriptEventListener.h"

#include "KeyboardEvent.h"

#include "LocalizedStrings.h"

#include "MappedAttribute.h"

#include "MouseEvent.h"

#include "Page.h"

#include "RegularExpression.h"

#include "RenderButton.h"

#include "RenderFileUploadControl.h"

#include "RenderImage.h"

#include "RenderSlider.h"

#include "RenderText.h"

#include "RenderTextControlSingleLine.h"

#include "RenderTheme.h"

#include "TextEvent.h"

#include <wtf/MathExtras.h>

#include <wtf/StdLibExtras.h>

using namespace std;

namespace WebCore {

using namespace HTMLNames;

const int maxSavedResults = 256;

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

    : HTMLTextFormControlElement(tagName, doc, f)

    , m_xPos(0)

    , m_yPos(0)

    , m_maxResults(-1)

    , m_type(TEXT)

    , m_checked(false)

    , m_defaultChecked(false)

    , m_useDefaultChecked(true)

    , m_indeterminate(false)

    , m_haveType(false)

    , m_activeSubmit(false)

    , m_autocomplete(Uninitialized)

    , m_autofilled(false)

    , m_inited(false)

{

    ASSERT(hasTagName(inputTag) || hasTagName(isindexTag));

}

HTMLInputElement::~HTMLInputElement()

{

    if (needsActivationCallback())

        document()->unregisterForDocumentActivationCallbacks(this);

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

    // Need to remove this from the form while it is still an HTMLInputElement,

    // so can't wait for the base class's destructor to do it.

    removeFromForm();

}

const AtomicString& HTMLInputElement::formControlName() const

{

    return m_data.name();

}

bool HTMLInputElement::autoComplete() const

{

    if (m_autocomplete != Uninitialized)

        return m_autocomplete == On;

    // Assuming we're still in a Form, respect the Form's setting

    if (HTMLFormElement* form = this->form())

        return form->autoComplete();

    // The default is true

    return true;

}

bool HTMLInputElement::valueMissing() const

{

    if (!isRequiredFormControl() || readOnly() || disabled())

        return false;

    switch (inputType()) {

        case TEXT:

        case SEARCH:

        case URL:

        case TELEPHONE:

        case EMAIL:

        case PASSWORD:

        case NUMBER:

        case FILE:

            return value().isEmpty();

        case CHECKBOX:

            return !checked();

        case RADIO:

            return !document()->checkedRadioButtons().checkedButtonForGroup(name());

        case COLOR:

            return false;

        case HIDDEN:

        case RANGE:

        case SUBMIT:

        case IMAGE:

        case RESET:

        case BUTTON:

        case ISINDEX:

            break;

    }

    ASSERT_NOT_REACHED();

    return false;

}

bool HTMLInputElement::patternMismatch() const

{

    switch (inputType()) {

        case ISINDEX:

        case CHECKBOX:

        case RADIO:

        case SUBMIT:

        case RESET:

        case FILE:

        case HIDDEN:

        case IMAGE:

        case BUTTON:

        case RANGE:

        case NUMBER:

        case COLOR:

            return false;

        case TEXT:

        case SEARCH:

        case URL:

        case TELEPHONE:

        case EMAIL:

        case PASSWORD:

            const AtomicString& pattern = getAttribute(patternAttr);

            String value = this->value();

            // Empty values can't be mismatched

            if (pattern.isEmpty() || value.isEmpty())

                return false;

            RegularExpression patternRegExp(pattern, TextCaseSensitive);

            int matchLength = 0;

            int valueLength = value.length();

            int matchOffset = patternRegExp.match(value, 0, &matchLength);

            return matchOffset != 0 || matchLength != valueLength;

    }

    ASSERT_NOT_REACHED();

    return false;

}

bool HTMLInputElement::tooLong() const

{

    switch (inputType()) {

    case EMAIL:

    case PASSWORD:

    case SEARCH:

    case TELEPHONE:

    case TEXT:

    case URL: {

        int max = maxLength();

        if (max < 0)

            return false;

        // Return false for the default value even if it is longer than maxLength.

        bool userEdited = !m_data.value().isNull();

        if (!userEdited)

            return false;

        return value().length() > static_cast<unsigned>(max);

    }

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case NUMBER:

    case RADIO:

    case RANGE:

    case RESET:

    case SUBMIT:

        return false;

    }

    ASSERT_NOT_REACHED();

    return false;

}

bool HTMLInputElement::rangeUnderflow() const

{

    if (inputType() == NUMBER) {

        double min = 0.0;

        double doubleValue = 0.0;

        if (formStringToDouble(getAttribute(minAttr), &min) && formStringToDouble(value(), &doubleValue))

            return doubleValue < min;

    } else if (inputType() == RANGE) {

        double doubleValue;

        if (formStringToDouble(value(), &doubleValue))

            return doubleValue < rangeMinimum();

    }

    return false;

}

bool HTMLInputElement::rangeOverflow() const

{

    if (inputType() == NUMBER) {

        double max = 0.0;

        double doubleValue = 0.0;

        if (formStringToDouble(getAttribute(maxAttr), &max) && formStringToDouble(value(), &doubleValue))

            return doubleValue > max;

    } else if (inputType() == RANGE) {

        double doubleValue;

        if (formStringToDouble(value(), &doubleValue))

            return doubleValue > rangeMaximum();

    }

    return false;

}

double HTMLInputElement::rangeMinimum() const

{

    ASSERT(inputType() == RANGE);

    // The range type's "default minimum" is 0.

    double min = 0.0;

    formStringToDouble(getAttribute(minAttr), &min);

    return min;

}

double HTMLInputElement::rangeMaximum() const

{

    ASSERT(inputType() == RANGE);

    // The range type's "default maximum" is 100.

    static const double defaultMaximum = 100.0;

    double max = defaultMaximum;

    formStringToDouble(getAttribute(maxAttr), &max);

    const double min = rangeMinimum();

    if (max < min) {

        // A remedy for the inconsistent min/max values.

        // Sets the maxmimum to the default (100.0) or the minimum value.

        max = min < defaultMaximum ? defaultMaximum : min;

    }

    return max;

}

static inline CheckedRadioButtons& checkedRadioButtons(const HTMLInputElement *element)

{

    if (HTMLFormElement* form = element->form())

        return form->checkedRadioButtons();

    return element->document()->checkedRadioButtons();

}

bool HTMLInputElement::isKeyboardFocusable(KeyboardEvent* event) const

{

    // If text fields can be focused, then they should always be keyboard focusable

    if (isTextField())

        return HTMLFormControlElementWithState::isFocusable();

    // If the base class says we can't be focused, then we can stop now.

    if (!HTMLFormControlElementWithState::isKeyboardFocusable(event))

        return false;

    if (inputType() == RADIO) {

        // Never allow keyboard tabbing to leave you in the same radio group.  Always

        // skip any other elements in the group.

        Node* currentFocusedNode = document()->focusedNode();

        if (currentFocusedNode && currentFocusedNode->hasTagName(inputTag)) {

            HTMLInputElement* focusedInput = static_cast<HTMLInputElement*>(currentFocusedNode);

            if (focusedInput->inputType() == RADIO && focusedInput->form() == form() &&

                focusedInput->name() == name())

                return false;

        }

        // Allow keyboard focus if we're checked or if nothing in the group is checked.

        return checked() || !checkedRadioButtons(this).checkedButtonForGroup(name());

    }

    return true;

}

bool HTMLInputElement::isMouseFocusable() const

{

    if (isTextField())

        return HTMLFormControlElementWithState::isFocusable();

    return HTMLFormControlElementWithState::isMouseFocusable();

}

void HTMLInputElement::updateFocusAppearance(bool restorePreviousSelection)

{        

    if (isTextField())

        InputElement::updateFocusAppearance(m_data, this, this, restorePreviousSelection);

    else

        HTMLFormControlElementWithState::updateFocusAppearance(restorePreviousSelection);

}

void HTMLInputElement::aboutToUnload()

{

    InputElement::aboutToUnload(this, this);

}

bool HTMLInputElement::shouldUseInputMethod() const

{

    return m_type == TEXT || m_type == SEARCH || m_type == ISINDEX;

}

void HTMLInputElement::handleFocusEvent()

{

    InputElement::dispatchFocusEvent(this, this);

    if (isTextField())

        m_autofilled = false;

}

void HTMLInputElement::handleBlurEvent()

{

    InputElement::dispatchBlurEvent(this, this);

}

void HTMLInputElement::setType(const String& t)

{

    if (t.isEmpty()) {

        int exccode;

        removeAttribute(typeAttr, exccode);

    } else

        setAttribute(typeAttr, t);

}

void HTMLInputElement::setInputType(const String& t)

{

    InputType newType;

    if (equalIgnoringCase(t, "password"))

        newType = PASSWORD;

    else if (equalIgnoringCase(t, "checkbox"))

        newType = CHECKBOX;

    else if (equalIgnoringCase(t, "radio"))

        newType = RADIO;

    else if (equalIgnoringCase(t, "submit"))

        newType = SUBMIT;

    else if (equalIgnoringCase(t, "reset"))

        newType = RESET;

    else if (equalIgnoringCase(t, "file"))

        newType = FILE;

    else if (equalIgnoringCase(t, "hidden"))

        newType = HIDDEN;

    else if (equalIgnoringCase(t, "image"))

        newType = IMAGE;

    else if (equalIgnoringCase(t, "button"))

        newType = BUTTON;

    else if (equalIgnoringCase(t, "khtml_isindex"))

        newType = ISINDEX;

    else if (equalIgnoringCase(t, "search"))

        newType = SEARCH;

    else if (equalIgnoringCase(t, "range"))

        newType = RANGE;

    else if (equalIgnoringCase(t, "email"))

        newType = EMAIL;

    else if (equalIgnoringCase(t, "number"))

        newType = NUMBER;

    else if (equalIgnoringCase(t, "tel"))

        newType = TELEPHONE;

    else if (equalIgnoringCase(t, "url"))

        newType = URL;

    else if (equalIgnoringCase(t, "color"))

        newType = COLOR;

    else

        newType = TEXT;

    // IMPORTANT: Don't allow the type to be changed to FILE after the first

    // type change, otherwise a JavaScript programmer would be able to set a text

    // field's value to something like /etc/passwd and then change it to a file field.

    if (inputType() != newType) {

        if (newType == FILE && m_haveType)

            // Set the attribute back to the old value.

            // Useful in case we were called from inside parseMappedAttribute.

            setAttribute(typeAttr, type());

        else {

            checkedRadioButtons(this).removeButton(this);

            if (newType == FILE && !m_fileList)

                m_fileList = FileList::create();

            bool wasAttached = attached();

            if (wasAttached)

                detach();

            bool didStoreValue = storesValueSeparateFromAttribute();

            bool wasPasswordField = inputType() == PASSWORD;

            bool didRespectHeightAndWidth = respectHeightAndWidthAttrs();

            m_type = newType;

            bool willStoreValue = storesValueSeparateFromAttribute();

            bool isPasswordField = inputType() == PASSWORD;

            bool willRespectHeightAndWidth = respectHeightAndWidthAttrs();

            if (didStoreValue && !willStoreValue && !m_data.value().isNull()) {

                setAttribute(valueAttr, m_data.value());

                m_data.setValue(String());

            }

            if (!didStoreValue && willStoreValue)

                m_data.setValue(sanitizeValue(getAttribute(valueAttr)));

            else

                InputElement::updateValueIfNeeded(m_data, this);

            if (wasPasswordField && !isPasswordField)

                unregisterForActivationCallbackIfNeeded();

            else if (!wasPasswordField && isPasswordField)

                registerForActivationCallbackIfNeeded();

            if (didRespectHeightAndWidth != willRespectHeightAndWidth) {

                NamedMappedAttrMap* map = mappedAttributes();

                ASSERT(map);

                if (Attribute* height = map->getAttributeItem(heightAttr))

                    attributeChanged(height, false);

                if (Attribute* width = map->getAttributeItem(widthAttr))

                    attributeChanged(width, false);

                if (Attribute* align = map->getAttributeItem(alignAttr))

                    attributeChanged(align, false);

            }

            if (wasAttached) {

                attach();

                if (document()->focusedNode() == this)

                    updateFocusAppearance(true);

            }

            checkedRadioButtons(this).addButton(this);

        }

        InputElement::notifyFormStateChanged(this);

        updateValidity();

    }

    m_haveType = true;

    if (inputType() != IMAGE && m_imageLoader)

        m_imageLoader.clear();

}

const AtomicString& HTMLInputElement::formControlType() const

{

    // needs to be lowercase according to DOM spec

    switch (inputType()) {

        case BUTTON: {

            DEFINE_STATIC_LOCAL(const AtomicString, button, ("button"));

            return button;

        }

        case CHECKBOX: {

            DEFINE_STATIC_LOCAL(const AtomicString, checkbox, ("checkbox"));

            return checkbox;

        }

        case COLOR: {

            DEFINE_STATIC_LOCAL(const AtomicString, color, ("color"));

            return color;

        }

        case EMAIL: {

            DEFINE_STATIC_LOCAL(const AtomicString, email, ("email"));

            return email;

        }

        case FILE: {

            DEFINE_STATIC_LOCAL(const AtomicString, file, ("file"));

            return file;

        }

        case HIDDEN: {

            DEFINE_STATIC_LOCAL(const AtomicString, hidden, ("hidden"));

            return hidden;

        }

        case IMAGE: {

            DEFINE_STATIC_LOCAL(const AtomicString, image, ("image"));

            return image;

        }

        case ISINDEX:

            return emptyAtom;

        case NUMBER: {

            DEFINE_STATIC_LOCAL(const AtomicString, number, ("number"));

            return number;

        }

        case PASSWORD: {

            DEFINE_STATIC_LOCAL(const AtomicString, password, ("password"));

            return password;

        }

        case RADIO: {

            DEFINE_STATIC_LOCAL(const AtomicString, radio, ("radio"));