/*

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

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

#include "CSSPropertyNames.h"

#include "Document.h"

#include "Editor.h"

#include "Event.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "FocusController.h"

#include "FormDataList.h"

#include "Frame.h"

#include "HTMLFormElement.h"

#include "HTMLImageLoader.h"

#include "HTMLNames.h"

#include "KeyboardEvent.h"

#include "LocalizedStrings.h"

#include "MouseEvent.h"

#include "Page.h"

#include "RenderButton.h"

#include "RenderFileUploadControl.h"

#include "RenderImage.h"

#include "RenderText.h"

#include "RenderTextControl.h"

#include "RenderTheme.h"

#include "RenderSlider.h"

#include "SelectionController.h"

#include "TextBreakIterator.h"

#include "TextEvent.h"

using namespace std;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

const int maxSavedResults = 256;

// FIXME: According to HTML4, the length attribute's value can be arbitrarily

// large. However, due to http://bugs.webkit.org/show_bugs.cgi?id=14536 things

// get rather sluggish when a text field has a larger number of characters than

// this, even when just clicking in the text field.

static const int cMaxLen = 524288;

static int numGraphemeClusters(const StringImpl* s)

{

    if (!s)

        return 0;

    TextBreakIterator* it = characterBreakIterator(s->characters(), s->length());

    if (!it)

        return 0;

    int num = 0;

    while (textBreakNext(it) != TextBreakDone)

        ++num;

    return num;

}

static int numCharactersInGraphemeClusters(const StringImpl* s, int numGraphemeClusters)

{

    if (!s)

        return 0;

    TextBreakIterator* it = characterBreakIterator(s->characters(), s->length());

    if (!it)

        return 0;

    for (int i = 0; i < numGraphemeClusters; ++i)

        if (textBreakNext(it) == TextBreakDone)

            return s->length();

    return textBreakCurrent(it);

}

HTMLInputElement::HTMLInputElement(Document* doc, HTMLFormElement* f)

    : HTMLFormControlElementWithState(inputTag, doc, f)

{

    init();

}

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

    : HTMLFormControlElementWithState(tagName, doc, f)

{

    init();

}

void HTMLInputElement::init()

{

    m_imageLoader = 0;

    m_type = TEXT;

    m_maxLen = cMaxLen;

    m_size = 20;

    m_checked = false;

    m_defaultChecked = false;

    m_useDefaultChecked = true;

    m_indeterminate = false;

    m_haveType = false;

    m_activeSubmit = false;

    m_autocomplete = true;

    m_inited = false;

    m_autofilled = false;

    xPos = 0;

    yPos = 0;

    cachedSelStart = -1;

    cachedSelEnd = -1;

    m_maxResults = -1;

    if (form())

        m_autocomplete = form()->autoComplete();

}

HTMLInputElement::~HTMLInputElement()

{

    if (inputType() == PASSWORD)

        document()->unregisterForDidRestoreFromCacheCallback(this);

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

    delete m_imageLoader;

}

const AtomicString& HTMLInputElement::name() const

{

    return m_name.isNull() ? emptyAtom : m_name;

}

static inline HTMLFormElement::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) {

        // Unnamed radio buttons are never focusable (matches WinIE).

        if (name().isEmpty())

            return false;

        // 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()) {

        if (!restorePreviousSelection || cachedSelStart == -1)

            select();

        else

            // Restore the cached selection.

            setSelectionRange(cachedSelStart, cachedSelEnd); 

        if (document() && document()->frame())

            document()->frame()->revealSelection();

    } else

        HTMLFormControlElementWithState::updateFocusAppearance(restorePreviousSelection);

}

void HTMLInputElement::aboutToUnload()

{

    if (isTextField() && focused() && document()->frame())

        document()->frame()->textFieldDidEndEditing(this);

}

bool HTMLInputElement::shouldUseInputMethod() const

{

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

}

void HTMLInputElement::dispatchFocusEvent()

{

    if (isTextField()) {

        setAutofilled(false);

        if (inputType() == PASSWORD && document()->frame())

            document()->setUseSecureKeyboardEntryWhenActive(true);

    }

    HTMLFormControlElementWithState::dispatchFocusEvent();

}

void HTMLInputElement::dispatchBlurEvent()

{

    if (isTextField() && document()->frame()) {

        if (inputType() == PASSWORD)

            document()->setUseSecureKeyboardEntryWhenActive(false);

        document()->frame()->textFieldDidEndEditing(this);

    }

    HTMLFormControlElementWithState::dispatchBlurEvent();

}

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;

#if !PLATFORM(SYMBIAN)

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

        newType = SEARCH;

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

        newType = RANGE;

#endif

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

            bool wasAttached = m_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_value.isNull()) {

                setAttribute(valueAttr, m_value);

                m_value = String();

            }

            if (!didStoreValue && willStoreValue)

                m_value = constrainValue(getAttribute(valueAttr));

            else

                recheckValue();

            if (wasPasswordField && !isPasswordField)

                document()->unregisterForDidRestoreFromCacheCallback(this);

            else if (!wasPasswordField && isPasswordField)

                document()->registerForDidRestoreFromCacheCallback(this);

            if (didRespectHeightAndWidth != willRespectHeightAndWidth) {

                NamedMappedAttrMap* map = mappedAttributes();

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

                    attributeChanged(height, false);

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

                    attributeChanged(width, false);

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

                    attributeChanged(align, false);

            }

            if (wasAttached)

                attach();

            checkedRadioButtons(this).addButton(this);

        }

    }

    m_haveType = true;

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

        delete m_imageLoader;

        m_imageLoader = 0;

    }

}

const AtomicString& HTMLInputElement::type() const

{

    // needs to be lowercase according to DOM spec

    switch (inputType()) {

        case BUTTON: {

            static const AtomicString button("button");

            return button;

        }

        case CHECKBOX: {

            static const AtomicString checkbox("checkbox");

            return checkbox;

        }

        case FILE: {

            static const AtomicString file("file");

            return file;

        }

        case HIDDEN: {

            static const AtomicString hidden("hidden");

            return hidden;

        }

        case IMAGE: {

            static const AtomicString image("image");

            return image;

        }

        case ISINDEX:

            return emptyAtom;

        case PASSWORD: {

            static const AtomicString password("password");

            return password;

        }

        case RADIO: {

            static const AtomicString radio("radio");

            return radio;

        }

        case RANGE: {

            static const AtomicString range("range");

            return range;

        }

        case RESET: {

            static const AtomicString reset("reset");

            return reset;

        }

        case SEARCH: {

            static const AtomicString search("search");

            return search;

        }

        case SUBMIT: {

            static const AtomicString submit("submit");

            return submit;

        }

        case TEXT: {

            static const AtomicString text("text");

            return text;

        }

    }

    return emptyAtom;

}

bool HTMLInputElement::saveState(String& result) const

{

    switch (inputType()) {

        case BUTTON:

        case FILE:

        case HIDDEN:

        case IMAGE:

        case ISINDEX:

        case RANGE:

        case RESET:

        case SEARCH:

        case SUBMIT:

        case TEXT:

            result = value();

            return true;

        case CHECKBOX:

        case RADIO:

            result = checked() ? "on" : "off";

            return true;

        case PASSWORD:

            return false;

    }

    ASSERT_NOT_REACHED();

    return false;

}

void HTMLInputElement::restoreState(const String& state)

{

    ASSERT(inputType() != PASSWORD); // should never save/restore password fields

    switch (inputType()) {

        case BUTTON:

        case FILE:

        case HIDDEN:

        case IMAGE:

        case ISINDEX:

        case RANGE:

        case RESET:

        case SEARCH:

        case SUBMIT:

        case TEXT:

            setValue(state);

            break;

        case CHECKBOX:

        case RADIO:

            setChecked(state == "on");

            break;

        case PASSWORD:

            break;

    }

}

bool HTMLInputElement::canStartSelection() const

{

    if (!isTextField())

        return false;

    return HTMLFormControlElementWithState::canStartSelection();

}

bool HTMLInputElement::canHaveSelection() const

{

    return isTextField();

}

int HTMLInputElement::selectionStart() const

{

    if (!isTextField())

        return 0;

    if (document()->focusedNode() != this && cachedSelStart != -1)

        return cachedSelStart;

    if (!renderer())

        return 0;

    return static_cast<RenderTextControl*>(renderer())->selectionStart();

}

int HTMLInputElement::selectionEnd() const

{

    if (!isTextField())

        return 0;

    if (document()->focusedNode() != this && cachedSelEnd != -1)

        return cachedSelEnd;

    if (!renderer())

        return 0;

    return static_cast<RenderTextControl*>(renderer())->selectionEnd();

}

void HTMLInputElement::setSelectionStart(int start)

{

}

void HTMLInputElement::setSelectionEnd(int end)

{

}

void HTMLInputElement::select()

{

}

void HTMLInputElement::setSelectionRange(int start, int end)

{