/*

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

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

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

 * Copyright (C) 2010 Google 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 "HTMLInputElement.h"

#include "AXObjectCache.h"

#include "Attribute.h"

#include "BeforeTextInsertedEvent.h"

#include "CSSPropertyNames.h"

#include "ChromeClient.h"

#include "DateComponents.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 "FileSystem.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 "LegacyHTMLTreeBuilder.h"

#include "KeyboardEvent.h"

#include "LocalizedStrings.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 "ScriptEventListener.h"

#include "StepRange.h"

#include "StringHash.h"

#include "TextEvent.h"

#include <wtf/HashMap.h>

#include <wtf/MathExtras.h>

#include <wtf/StdLibExtras.h>

using namespace std;

namespace WebCore {

using namespace HTMLNames;

const int maxSavedResults = 256;

// Constant values for getAllowedValueStep().

static const double dateDefaultStep = 1.0;

static const double dateStepScaleFactor = 86400000.0;

static const double dateTimeDefaultStep = 60.0;

static const double dateTimeStepScaleFactor = 1000.0;

static const double monthDefaultStep = 1.0;

static const double monthStepScaleFactor = 1.0;

static const double numberDefaultStep = 1.0;

static const double numberStepScaleFactor = 1.0;

static const double timeDefaultStep = 60.0;

static const double timeStepScaleFactor = 1000.0;

static const double weekDefaultStep = 1.0;

static const double weekStepScaleFactor = 604800000.0;

// Constant values for minimum().

static const double numberDefaultMinimum = -DBL_MAX;

static const double rangeDefaultMinimum = 0.0;

// Constant values for maximum().

static const double numberDefaultMaximum = DBL_MAX;

static const double rangeDefaultMaximum = 100.0;

static const double defaultStepBase = 0.0;

static const double weekDefaultStepBase = -259200000.0; // The first day of 1970-W01.

static const double msecPerMinute = 60 * 1000;

static const double msecPerSecond = 1000;

static bool isNumberCharacter(UChar ch)

{

    return ch == '+' || ch == '-' || ch == '.' || ch == 'e' || ch == 'E'

        || ch >= '0' && ch <= '9';

}

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

    : HTMLTextFormControlElement(tagName, document, form)

    , 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));

}

PassRefPtr<HTMLInputElement> HTMLInputElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)

{

    return adoptRef(new HTMLInputElement(tagName, document, form));

}

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;

    return HTMLTextFormControlElement::autoComplete();

}

static inline CheckedRadioButtons& checkedRadioButtons(const HTMLInputElement* element)

{

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

        return form->checkedRadioButtons();

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

}

void HTMLInputElement::updateCheckedRadioButtons()

{

    if (attached() && checked())

        checkedRadioButtons(this).addButton(this);

    if (form()) {

        const Vector<HTMLFormControlElement*>& controls = form()->associatedElements();

        for (unsigned i = 0; i < controls.size(); ++i) {

            HTMLFormControlElement* control = controls[i];

            if (control->name() != name())

                continue;

            if (control->type() != type())

                continue;

            control->setNeedsValidityCheck();

        }

    } else {

        // FIXME: Traversing the document is inefficient.

        for (Node* node = document()->body(); node; node = node->traverseNextNode()) {

            if (!node->isElementNode())

                continue;

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

            if (element->formControlName() != name())

                continue;

            if (element->formControlType() != type())

                continue;

            HTMLFormControlElement* control = static_cast<HTMLFormControlElement*>(element);

            if (control->form())

                continue;

            control->setNeedsValidityCheck();

        }

    }

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

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

}

bool HTMLInputElement::valueMissing() const

{

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

        return false;

    switch (inputType()) {

    case DATE:

    case DATETIME:

    case DATETIMELOCAL:

    case EMAIL:

    case FILE:

    case MONTH:

    case NUMBER:

    case PASSWORD:

    case SEARCH:

    case TELEPHONE:

    case TEXT:

    case TIME:

    case URL:

    case WEEK:

        return value().isEmpty();

    case CHECKBOX:

        return !checked();

    case RADIO:

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

    case COLOR:

        return false;

    case BUTTON:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case RANGE:

    case RESET:

    case SUBMIT:

        break;

    }

    ASSERT_NOT_REACHED();

    return false;

}

bool HTMLInputElement::patternMismatch() const

{

    switch (inputType()) {

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case DATE:

    case DATETIME:

    case DATETIMELOCAL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case MONTH:

    case NUMBER:

    case RADIO:

    case RANGE:

    case RESET:

    case SUBMIT:

    case TIME:

    case WEEK:

        return false;

    case EMAIL:

    case PASSWORD:

    case SEARCH:

    case TELEPHONE:

    case TEXT:

    case URL:

        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 || 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 numGraphemeClusters(value()) > static_cast<unsigned>(max);

    }

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case DATE:

    case DATETIME:

    case DATETIMELOCAL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case MONTH:

    case NUMBER:

    case RADIO:

    case RANGE:

    case RESET:

    case SUBMIT:

    case TIME:

    case WEEK:

        return false;

    }

    ASSERT_NOT_REACHED();

    return false;

}

bool HTMLInputElement::rangeUnderflow() const

{

    const double nan = numeric_limits<double>::quiet_NaN();

    switch (inputType()) {

    case DATE:

    case DATETIME:

    case DATETIMELOCAL:

    case MONTH:

    case NUMBER:

    case TIME:

    case WEEK: {

        double doubleValue = parseToDouble(value(), nan);

        return isfinite(doubleValue) && doubleValue < minimum();

    }

    case RANGE: // Guaranteed by sanitization.

        ASSERT(parseToDouble(value(), nan) >= minimum());

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case EMAIL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case PASSWORD:

    case RADIO:

    case RESET:

    case SEARCH:

    case SUBMIT:

    case TELEPHONE:

    case TEXT:

    case URL:

        break;

    }

    return false;

}

bool HTMLInputElement::rangeOverflow() const

{

    const double nan = numeric_limits<double>::quiet_NaN();

    switch (inputType()) {

    case DATE:

    case DATETIME:

    case DATETIMELOCAL:

    case MONTH:

    case NUMBER:

    case TIME:

    case WEEK: {

        double doubleValue = parseToDouble(value(), nan);

        return isfinite(doubleValue) && doubleValue > maximum();

    }

    case RANGE: // Guaranteed by sanitization.

        ASSERT(parseToDouble(value(), nan) <= maximum());

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case EMAIL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case PASSWORD:

    case RADIO:

    case RESET:

    case SEARCH:

    case SUBMIT:

    case TELEPHONE:

    case TEXT:

    case URL:

        break;

    }

    return false;

}

double HTMLInputElement::minimum() const

{

    switch (inputType()) {

    case DATE:

        return parseToDouble(getAttribute(minAttr), DateComponents::minimumDate());

    case DATETIME:

    case DATETIMELOCAL:

        return parseToDouble(getAttribute(minAttr), DateComponents::minimumDateTime());

    case MONTH:

        return parseToDouble(getAttribute(minAttr), DateComponents::minimumMonth());

    case NUMBER:

        return parseToDouble(getAttribute(minAttr), numberDefaultMinimum);

    case RANGE:

        return parseToDouble(getAttribute(minAttr), rangeDefaultMinimum);

    case TIME:

        return parseToDouble(getAttribute(minAttr), DateComponents::minimumTime());

    case WEEK:

        return parseToDouble(getAttribute(minAttr), DateComponents::minimumWeek());

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case EMAIL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case PASSWORD:

    case RADIO:

    case RESET:

    case SEARCH:

    case SUBMIT:

    case TELEPHONE:

    case TEXT:

    case URL:

        break;

    }

    ASSERT_NOT_REACHED();

    return 0;

}

double HTMLInputElement::maximum() const

{

    switch (inputType()) {

    case DATE:

        return parseToDouble(getAttribute(maxAttr), DateComponents::maximumDate());

    case DATETIME:

    case DATETIMELOCAL:

        return parseToDouble(getAttribute(maxAttr), DateComponents::maximumDateTime());

    case MONTH:

        return parseToDouble(getAttribute(maxAttr), DateComponents::maximumMonth());

    case NUMBER:

        return parseToDouble(getAttribute(maxAttr), numberDefaultMaximum);

    case RANGE: {

        double max = parseToDouble(getAttribute(maxAttr), rangeDefaultMaximum);

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

        // Sets the maximum to the default or the minimum value.

        double min = minimum();

        if (max < min)

            max = std::max(min, rangeDefaultMaximum);

        return max;

    }

    case TIME:

        return parseToDouble(getAttribute(maxAttr), DateComponents::maximumTime());

    case WEEK:

        return parseToDouble(getAttribute(maxAttr), DateComponents::maximumWeek());

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case EMAIL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case PASSWORD:

    case RADIO:

    case RESET:

    case SEARCH:

    case SUBMIT:

    case TELEPHONE:

    case TEXT:

    case URL:

        break;

    }

    ASSERT_NOT_REACHED();

    return 0;

}

double HTMLInputElement::stepBase() const

{

    switch (inputType()) {

    case RANGE:

        return minimum();

    case DATE:

    case DATETIME:

    case DATETIMELOCAL:

    case MONTH:

    case NUMBER:

    case TIME:

        return parseToDouble(getAttribute(minAttr), defaultStepBase);

    case WEEK:

        return parseToDouble(getAttribute(minAttr), weekDefaultStepBase);

    case BUTTON:

    case CHECKBOX:

    case COLOR:

    case EMAIL:

    case FILE:

    case HIDDEN:

    case IMAGE:

    case ISINDEX:

    case PASSWORD:

    case RADIO:

    case RESET:

    case SEARCH:

    case SUBMIT:

    case TELEPHONE:

    case TEXT:

    case URL:

        break;

    }

    ASSERT_NOT_REACHED();

    return 0.0;

}