/*

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

#include "CSSPropertyNames.h"

#include "CharacterNames.h"

#include "Document.h"

#include "Event.h"

#include "EventHandler.h"

#include "EventNames.h"

#include "ExceptionCode.h"

#include "FormDataList.h"

#include "Frame.h"

#include "HTMLFormElement.h"

#include "HTMLNames.h"

#include "HTMLOptionElement.h"

#include "HTMLOptionsCollection.h"

#include "KeyboardEvent.h"

#include "MouseEvent.h"

#include "RenderListBox.h"

#include "RenderMenuList.h"

#include <math.h>

#include <wtf/Vector.h>

#if PLATFORM(MAC)

#define ARROW_KEYS_POP_MENU 1

#else

#define ARROW_KEYS_POP_MENU 0

#endif

using namespace std;

using namespace WTF;

using namespace Unicode;

namespace WebCore {

using namespace EventNames;

using namespace HTMLNames;

static const DOMTimeStamp typeAheadTimeout = 1000;

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

    : HTMLFormControlElementWithState(selectTag, doc, f)

    , m_minwidth(0)

    , m_size(0)

    , m_multiple(false)

    , m_recalcListItems(false)

    , m_lastOnChangeIndex(-1)

    , m_activeSelectionAnchorIndex(-1)

    , m_activeSelectionEndIndex(-1)

    , m_activeSelectionState(false)

    , m_repeatingChar(0)

    , m_lastCharTime(0)

{

}

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

    : HTMLFormControlElementWithState(tagName, doc, f)

    , m_minwidth(0)

    , m_size(0)

    , m_multiple(false)

    , m_recalcListItems(false)

    , m_lastOnChangeIndex(-1)

    , m_activeSelectionAnchorIndex(-1)

    , m_activeSelectionEndIndex(-1)

    , m_activeSelectionState(false)

    , m_repeatingChar(0)

    , m_lastCharTime(0)

{

}

bool HTMLSelectElement::checkDTD(const Node* newChild)

{

    // Make sure to keep <optgroup> in sync with this.

    return newChild->isTextNode() || newChild->hasTagName(optionTag) || newChild->hasTagName(optgroupTag) || newChild->hasTagName(hrTag) ||

           newChild->hasTagName(scriptTag);

}

void HTMLSelectElement::recalcStyle( StyleChange ch )

{

    if (hasChangedChild() && renderer()) {

        if (usesMenuList())

            static_cast<RenderMenuList*>(renderer())->setOptionsChanged(true);

        else

            static_cast<RenderListBox*>(renderer())->setOptionsChanged(true);

    }

    HTMLFormControlElementWithState::recalcStyle(ch);

}

const AtomicString& HTMLSelectElement::type() const

{

    static const AtomicString selectMultiple("select-multiple");

    static const AtomicString selectOne("select-one");

    return m_multiple ? selectMultiple : selectOne;

}

int HTMLSelectElement::selectedIndex() const

{

    // return the number of the first option selected

    unsigned index = 0;

    const Vector<HTMLElement*>& items = listItems();

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

        if (items[i]->hasLocalName(optionTag)) {

            if (static_cast<HTMLOptionElement*>(items[i])->selected())

                return index;

            index++;

        }

    }

    return -1;

}

int HTMLSelectElement::lastSelectedListIndex() const

{

    // return the number of the last option selected

    unsigned index = 0;

    bool found = false;

    const Vector<HTMLElement*>& items = listItems();

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

        if (items[i]->hasLocalName(optionTag)) {

            if (static_cast<HTMLOptionElement*>(items[i])->selected()) {

                index = i;

                found = true;

            }

        }

    }

    return found ? (int) index : -1;

}

void HTMLSelectElement::deselectItems(HTMLOptionElement* excludeElement)

{

    const Vector<HTMLElement*>& items = listItems();

    unsigned i;

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

        if (items[i]->hasLocalName(optionTag) && (items[i] != excludeElement)) {

            HTMLOptionElement* element = static_cast<HTMLOptionElement*>(items[i]);

            element->setSelectedState(false);

        }

    }

}

void HTMLSelectElement::setSelectedIndex(int optionIndex, bool deselect, bool fireOnChange)

{

    const Vector<HTMLElement*>& items = listItems();

    int listIndex = optionToListIndex(optionIndex);

    HTMLOptionElement* element = 0;

    if (!multiple())

        deselect = true;

    if (listIndex >= 0) {

        if (m_activeSelectionAnchorIndex < 0 || deselect)

            setActiveSelectionAnchorIndex(listIndex);

        if (m_activeSelectionEndIndex < 0 || deselect)

            setActiveSelectionEndIndex(listIndex);

        element = static_cast<HTMLOptionElement*>(items[listIndex]);

        element->setSelectedState(true);

    }

    if (deselect)

        deselectItems(element);

    scrollToSelection();

    // This only gets called with fireOnChange for menu lists. 

    if (fireOnChange && usesMenuList())

        menuListOnChange();

}

int HTMLSelectElement::activeSelectionStartListIndex() const

{

    if (m_activeSelectionAnchorIndex >= 0)

        return m_activeSelectionAnchorIndex;

    return optionToListIndex(selectedIndex());

}

int HTMLSelectElement::activeSelectionEndListIndex() const

{

    if (m_activeSelectionEndIndex >= 0)

        return m_activeSelectionEndIndex;

    return lastSelectedListIndex();

}

unsigned HTMLSelectElement::length() const

{

    unsigned len = 0;

    const Vector<HTMLElement*>& items = listItems();

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

        if (items[i]->hasLocalName(optionTag))

            ++len;

    }

    return len;

}

void HTMLSelectElement::add( HTMLElement *element, HTMLElement *before, ExceptionCode& ec)

{

    RefPtr<HTMLElement> protectNewChild(element); // make sure the element is ref'd and deref'd so we don't leak it

    if (!element || !(element->hasLocalName(optionTag) || element->hasLocalName(hrTag)))

        return;

    insertBefore(element, before, ec);

    if (!ec)

        setRecalcListItems();

}

void HTMLSelectElement::remove(int index)

{

    ExceptionCode ec = 0;

    int listIndex = optionToListIndex(index);

    const Vector<HTMLElement*>& items = listItems();

    if (listIndex < 0 || index >= int(items.size()))

        return; // ### what should we do ? remove the last item?

    Element *item = items[listIndex];

    ASSERT(item->parentNode());

    item->parentNode()->removeChild(item, ec);

    if (!ec)

        setRecalcListItems();

}

String HTMLSelectElement::value()

{

    unsigned i;

    const Vector<HTMLElement*>& items = listItems();

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

        if (items[i]->hasLocalName(optionTag) && static_cast<HTMLOptionElement*>(items[i])->selected())

            return static_cast<HTMLOptionElement*>(items[i])->value();

    }

    return String("");

}

void HTMLSelectElement::setValue(const String &value)

{

    if (value.isNull())

        return;

    // find the option with value() matching the given parameter

    // and make it the current selection.

    const Vector<HTMLElement*>& items = listItems();

    unsigned optionIndex = 0;

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

        if (items[i]->hasLocalName(optionTag)) {

            if (static_cast<HTMLOptionElement*>(items[i])->value() == value) {

                setSelectedIndex(optionIndex, true);

                return;

            }

            optionIndex++;

        }

}

bool HTMLSelectElement::saveState(String& value) const

{

    const Vector<HTMLElement*>& items = listItems();

    int l = items.size();

    Vector<char, 1024> characters(l);

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

        HTMLElement* e = items[i];

        bool selected = e->hasLocalName(optionTag) && static_cast<HTMLOptionElement*>(e)->selected();

        characters[i] = selected ? 'X' : '.';

    }

    value = String(characters.data(), l);

    return true;

}

void HTMLSelectElement::restoreState(const String& state)

{

    recalcListItems();

    const Vector<HTMLElement*>& items = listItems();

    int l = items.size();

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

        if (items[i]->hasLocalName(optionTag))

            static_cast<HTMLOptionElement*>(items[i])->setSelectedState(state[i] == 'X');

    setChanged();

}

bool HTMLSelectElement::insertBefore(PassRefPtr<Node> newChild, Node* refChild, ExceptionCode& ec)

{

    bool result = HTMLFormControlElementWithState::insertBefore(newChild, refChild, ec);

    if (result)

        setRecalcListItems();

    return result;

}

bool HTMLSelectElement::replaceChild(PassRefPtr<Node> newChild, Node *oldChild, ExceptionCode& ec)

{

    bool result = HTMLFormControlElementWithState::replaceChild(newChild, oldChild, ec);

    if (result)

        setRecalcListItems();

    return result;

}

bool HTMLSelectElement::removeChild(Node* oldChild, ExceptionCode& ec)

{

    bool result = HTMLFormControlElementWithState::removeChild(oldChild, ec);

    if (result)

        setRecalcListItems();

    return result;

}

bool HTMLSelectElement::appendChild(PassRefPtr<Node> newChild, ExceptionCode& ec)

{

    bool result = HTMLFormControlElementWithState::appendChild(newChild, ec);

    if (result)

        setRecalcListItems();

    return result;

}

ContainerNode* HTMLSelectElement::addChild(PassRefPtr<Node> newChild)

{

    ContainerNode* result = HTMLFormControlElementWithState::addChild(newChild);

    if (result)

        setRecalcListItems();

    return result;

}

void HTMLSelectElement::parseMappedAttribute(MappedAttribute *attr)

{

    bool oldUsesMenuList = usesMenuList();

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

        int oldSize = m_size;

        // Set the attribute value to a number.

        // This is important since the style rules for this attribute can determine the appearance property.

        int size = attr->value().toInt();

        String attrSize = String::number(size);

        if (attrSize != attr->value())

            attr->setValue(attrSize);

        m_size = max(size, 1);

        if ((oldUsesMenuList != usesMenuList() || !oldUsesMenuList && m_size != oldSize) && attached()) {

            detach();

            attach();

        }

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

        m_minwidth = max(attr->value().toInt(), 0);

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

        m_multiple = (!attr->isNull());

        if (oldUsesMenuList != usesMenuList() && attached()) {

            detach();

            attach();

        }

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

        // FIXME: ignore for the moment

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

        // Don't map 'align' attribute.  This matches what Firefox, Opera and IE do.

        // See http://bugs.webkit.org/show_bug.cgi?id=12072

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

        setHTMLEventListener(focusEvent, attr);

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

        setHTMLEventListener(blurEvent, attr);

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

        setHTMLEventListener(changeEvent, attr);

    } else

        HTMLFormControlElementWithState::parseMappedAttribute(attr);

}

bool HTMLSelectElement::isKeyboardFocusable(KeyboardEvent* event) const

{

    if (renderer())

        return isFocusable();

    return HTMLFormControlElementWithState::isKeyboardFocusable(event);

}

bool HTMLSelectElement::isMouseFocusable() const

{

    if (renderer())

        return isFocusable();

    return HTMLFormControlElementWithState::isMouseFocusable();

}

bool HTMLSelectElement::canSelectAll() const

{

    return !usesMenuList(); 

}

void HTMLSelectElement::selectAll()

{

    ASSERT(!usesMenuList());

    if (!renderer() || !multiple())

        return;

    // Save the selection so it can be compared to the new selectAll selection when we call onChange

    saveLastSelection();

    m_activeSelectionState = true;

    setActiveSelectionAnchorIndex(nextSelectableListIndex(-1));

    setActiveSelectionEndIndex(previousSelectableListIndex(-1));

    updateListBoxSelection(false);

    listBoxOnChange();

}

RenderObject *HTMLSelectElement::createRenderer(RenderArena *arena, RenderStyle *style)

{

    if (usesMenuList())

        return new (arena) RenderMenuList(this);

    return new (arena) RenderListBox(this);

}

bool HTMLSelectElement::appendFormData(FormDataList& list, bool)

{

    bool successful = false;

    const Vector<HTMLElement*>& items = listItems();

    unsigned i;

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

        if (items[i]->hasLocalName(optionTag)) {

            HTMLOptionElement *option = static_cast<HTMLOptionElement*>(items[i]);

            if (option->selected()) {

                list.appendData(name(), option->value());

                successful = true;

            }

        }

    }

    // ### this case should not happen. make sure that we select the first option

    // in any case. otherwise we have no consistency with the DOM interface. FIXME!

    // we return the first one if it was a combobox select

    if (!successful && !m_multiple && m_size <= 1 && items.size() &&

        (items[0]->hasLocalName(optionTag))) {

        HTMLOptionElement *option = static_cast<HTMLOptionElement*>(items[0]);

        if (option->value().isNull())

            list.appendData(name(), option->text().stripWhiteSpace());

        else

            list.appendData(name(), option->value());

        successful = true;

    }

    return successful;

}

int HTMLSelectElement::optionToListIndex(int optionIndex) const

{

    const Vector<HTMLElement*>& items = listItems();

    int listSize = (int)items.size();

    if (optionIndex < 0 || optionIndex >= listSize)

        return -1;

    int optionIndex2 = -1;

    for (int listIndex = 0; listIndex < listSize; listIndex++) {

        if (items[listIndex]->hasLocalName(optionTag)) {

            optionIndex2++;

            if (optionIndex2 == optionIndex)

                return listIndex;

        }

    }

    return -1;

}

int HTMLSelectElement::listToOptionIndex(int listIndex) const

{

    const Vector<HTMLElement*>& items = listItems();

    if (listIndex < 0 || listIndex >= int(items.size()) ||

        !items[listIndex]->hasLocalName(optionTag))

        return -1;

    int optionIndex = 0; // actual index of option not counting OPTGROUP entries that may be in list

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

        if (items[i]->hasLocalName(optionTag))

            optionIndex++;

    return optionIndex;

}

PassRefPtr<HTMLOptionsCollection> HTMLSelectElement::options()

{

    return new HTMLOptionsCollection(this);

}

void HTMLSelectElement::recalcListItems() const

{

    Node* current = firstChild();

    m_listItems.clear();

    HTMLOptionElement* foundSelected = 0;

    while (current) {

        if (current->hasTagName(optgroupTag) && current->firstChild()) {

            // ### what if optgroup contains just comments? don't want one of no options in it...

            m_listItems.append(static_cast<HTMLElement*>(current));

            current = current->firstChild();

        }

        if (current->hasTagName(optionTag)) {

            m_listItems.append(static_cast<HTMLElement*>(current));

            if (!foundSelected && (usesMenuList() || (!m_multiple && static_cast<HTMLOptionElement*>(current)->selected()))) {

                foundSelected = static_cast<HTMLOptionElement*>(current);

                foundSelected->setSelectedState(true);

            } else if (foundSelected && !m_multiple && static_cast<HTMLOptionElement*>(current)->selected()) {

                foundSelected->setSelectedState(false);

                foundSelected = static_cast<HTMLOptionElement*>(current);

            }

        }

        if (current->hasTagName(hrTag))

            m_listItems.append(static_cast<HTMLElement*>(current));

        Node* parent = current->parentNode();

        current = current->nextSibling();

        if (!current) {

            if (parent != this)

                current = parent->nextSibling();

        }

    }

    m_recalcListItems = false;

}