HTMLSelectElement.cpp [plain text]
#include "config.h"
#include "HTMLSelectElement.h"
#include "AXObjectCache.h"
#include "Attribute.h"
#include "Chrome.h"
#include "ChromeClient.h"
#include "EventNames.h"
#include "FormDataList.h"
#include "Frame.h"
#include "HTMLFormElement.h"
#include "HTMLNames.h"
#include "HTMLOptGroupElement.h"
#include "HTMLOptionElement.h"
#include "HTMLOptionsCollection.h"
#include "KeyboardEvent.h"
#include "MouseEvent.h"
#include "NodeRenderingContext.h"
#include "Page.h"
#include "RenderListBox.h"
#include "RenderMenuList.h"
#include "RenderTheme.h"
#include "ScriptEventListener.h"
#include "SpatialNavigation.h"
#include <wtf/text/StringBuilder.h>
#include <wtf/unicode/Unicode.h>
using namespace std;
using namespace WTF::Unicode;
namespace WebCore {
using namespace HTMLNames;
static const unsigned maxSelectItems = 10000;
static const DOMTimeStamp typeAheadTimeout = 1000;
HTMLSelectElement::HTMLSelectElement(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
: HTMLFormControlElementWithState(tagName, document, form)
, m_lastCharTime(0)
, m_size(0)
, m_lastOnChangeIndex(-1)
, m_activeSelectionAnchorIndex(-1)
, m_activeSelectionEndIndex(-1)
, m_repeatingChar(0)
, m_isProcessingUserDrivenChange(false)
, m_multiple(false)
, m_activeSelectionState(false)
, m_shouldRecalcListItems(false)
{
ASSERT(hasTagName(selectTag));
}
PassRefPtr<HTMLSelectElement> HTMLSelectElement::create(const QualifiedName& tagName, Document* document, HTMLFormElement* form)
{
ASSERT(tagName.matches(selectTag));
return adoptRef(new HTMLSelectElement(tagName, document, form));
}
const AtomicString& HTMLSelectElement::formControlType() const
{
DEFINE_STATIC_LOCAL(const AtomicString, selectMultiple, ("select-multiple"));
DEFINE_STATIC_LOCAL(const AtomicString, selectOne, ("select-one"));
return m_multiple ? selectMultiple : selectOne;
}
void HTMLSelectElement::deselectItems(HTMLOptionElement* excludeElement)
{
deselectItemsWithoutValidation(excludeElement);
setNeedsValidityCheck();
}
void HTMLSelectElement::optionSelectedByUser(int optionIndex, bool fireOnChangeNow, bool allowMultipleSelection)
{
if (!usesMenuList()) {
updateSelectedState(optionIndex, allowMultipleSelection, false);
setNeedsValidityCheck();
if (fireOnChangeNow)
listBoxOnChange();
return;
}
if (optionIndex == selectedIndex())
return;
selectOption(optionIndex, DeselectOtherOptions | (fireOnChangeNow ? DispatchChangeEvent : 0) | UserDriven);
}
bool HTMLSelectElement::hasPlaceholderLabelOption() const
{
if (multiple() || size() > 1)
return false;
int listIndex = optionToListIndex(0);
ASSERT(listIndex >= 0);
if (listIndex < 0)
return false;
HTMLOptionElement* option = static_cast<HTMLOptionElement*>(listItems()[listIndex]);
return !listIndex && option->value().isEmpty();
}
bool HTMLSelectElement::valueMissing() const
{
if (!isRequiredFormControl())
return false;
int firstSelectionIndex = selectedIndex();
return firstSelectionIndex < 0 || (!firstSelectionIndex && hasPlaceholderLabelOption());
}
void HTMLSelectElement::listBoxSelectItem(int listIndex, bool allowMultiplySelections, bool shift, bool fireOnChangeNow)
{
if (!multiple())
optionSelectedByUser(listToOptionIndex(listIndex), fireOnChangeNow, false);
else {
updateSelectedState(listIndex, allowMultiplySelections, shift);
setNeedsValidityCheck();
if (fireOnChangeNow)
listBoxOnChange();
}
}
bool HTMLSelectElement::usesMenuList() const
{
const Page* page = document()->page();
RefPtr<RenderTheme> renderTheme = page ? page->theme() : RenderTheme::defaultTheme();
if (renderTheme->delegatesMenuListRendering())
return true;
return !m_multiple && m_size <= 1;
}
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();
}
void HTMLSelectElement::add(HTMLElement* element, HTMLElement* before, ExceptionCode& ec)
{
RefPtr<HTMLElement> protectNewChild(element);
if (!element || !(element->hasLocalName(optionTag) || element->hasLocalName(hrTag)))
return;
insertBefore(element, before, ec);
setNeedsValidityCheck();
}
void HTMLSelectElement::remove(int optionIndex)
{
int listIndex = optionToListIndex(optionIndex);
if (listIndex < 0)
return;
ExceptionCode ec;
listItems()[listIndex]->remove(ec);
}
void HTMLSelectElement::remove(HTMLOptionElement* option)
{
if (option->ownerSelectElement() != this)
return;
ExceptionCode ec;
option->remove(ec);
}
String HTMLSelectElement::value() const
{
const Vector<HTMLElement*>& items = listItems();
for (unsigned 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 "";
}
void HTMLSelectElement::setValue(const String &value)
{
if (value.isNull()) {
setSelectedIndex(-1);
return;
}
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);
return;
}
optionIndex++;
}
}
setSelectedIndex(-1);
}
bool HTMLSelectElement::isPresentationAttribute(const QualifiedName& name) const
{
if (name == alignAttr) {
return false;
}
return HTMLFormControlElementWithState::isPresentationAttribute(name);
}
void HTMLSelectElement::parseAttribute(Attribute* attr)
{
if (attr->name() == sizeAttr) {
int oldSize = m_size;
int size = attr->value().toInt();
String attrSize = String::number(size);
if (attrSize != attr->value()) {
if (Attribute* sizeAttribute = getAttributeItem(sizeAttr))
sizeAttribute->setValue(attrSize);
}
size = max(size, 1);
if (oldSize != size)
updateListItemSelectedStates();
m_size = size;
setNeedsValidityCheck();
if (m_size != oldSize && attached()) {
reattach();
setRecalcListItems();
}
} else if (attr->name() == multipleAttr)
parseMultipleAttribute(attr);
else if (attr->name() == accesskeyAttr) {
} else if (attr->name() == onchangeAttr)
setAttributeEventListener(eventNames().changeEvent, createAttributeEventListener(this, attr));
else
HTMLFormControlElementWithState::parseAttribute(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();
}
RenderObject* HTMLSelectElement::createRenderer(RenderArena* arena, RenderStyle*)
{
if (usesMenuList())
return new (arena) RenderMenuList(this);
return new (arena) RenderListBox(this);
}
bool HTMLSelectElement::childShouldCreateRenderer(const NodeRenderingContext& childContext) const
{
return childContext.isOnUpperEncapsulationBoundary() && HTMLFormControlElementWithState::childShouldCreateRenderer(childContext);
}
HTMLCollection* HTMLSelectElement::selectedOptions()
{
if (!m_selectedOptionsCollection)
m_selectedOptionsCollection = HTMLCollection::create(this, SelectedOptions);
return m_selectedOptionsCollection.get();
}
HTMLOptionsCollection* HTMLSelectElement::options()
{
if (!m_optionsCollection)
m_optionsCollection = HTMLOptionsCollection::create(this);
return m_optionsCollection.get();
}
void HTMLSelectElement::updateListItemSelectedStates()
{
if (m_shouldRecalcListItems)
recalcListItems();
}
void HTMLSelectElement::childrenChanged(bool changedByParser, Node* beforeChange, Node* afterChange, int childCountDelta)
{
setRecalcListItems();
setNeedsValidityCheck();
HTMLFormControlElementWithState::childrenChanged(changedByParser, beforeChange, afterChange, childCountDelta);
if (AXObjectCache::accessibilityEnabled() && renderer())
renderer()->document()->axObjectCache()->childrenChanged(renderer());
}
void HTMLSelectElement::optionElementChildrenChanged()
{
setRecalcListItems();
setNeedsValidityCheck();
if (AXObjectCache::accessibilityEnabled() && renderer())
renderer()->document()->axObjectCache()->childrenChanged(renderer());
}
void HTMLSelectElement::accessKeyAction(bool sendMouseEvents)
{
focus();
dispatchSimulatedClick(0, sendMouseEvents);
}
void HTMLSelectElement::setMultiple(bool multiple)
{
bool oldMultiple = this->multiple();
int oldSelectedIndex = selectedIndex();
setAttribute(multipleAttr, multiple ? "" : 0);
if (oldMultiple != this->multiple())
setSelectedIndex(oldSelectedIndex);
}
void HTMLSelectElement::setSize(int size)
{
setAttribute(sizeAttr, String::number(size));
}
Node* HTMLSelectElement::namedItem(const AtomicString& name)
{
return options()->namedItem(name);
}
Node* HTMLSelectElement::item(unsigned index)
{
return options()->item(index);
}
void HTMLSelectElement::setOption(unsigned index, HTMLOptionElement* option, ExceptionCode& ec)
{
ec = 0;
if (index > maxSelectItems - 1)
index = maxSelectItems - 1;
int diff = index - length();
RefPtr<HTMLElement> before = 0;
if (diff > 0) {
setLength(index, ec);
} else if (diff < 0) {
before = toHTMLElement(options()->item(index+1));
remove(index);
}
if (!ec) {
add(option, before.get(), ec);
if (diff >= 0 && option->selected())
optionSelectionStateChanged(option, true);
}
}
void HTMLSelectElement::setLength(unsigned newLen, ExceptionCode& ec)
{
ec = 0;
if (newLen > maxSelectItems)
newLen = maxSelectItems;
int diff = length() - newLen;
if (diff < 0) { do {
RefPtr<Element> option = document()->createElement(optionTag, false);
ASSERT(option);
add(toHTMLElement(option.get()), 0, ec);
if (ec)
break;
} while (++diff);
} else {
const Vector<HTMLElement*>& items = listItems();
Vector<RefPtr<Element> > itemsToRemove;
size_t optionIndex = 0;
for (size_t i = 0; i < items.size(); ++i) {
Element* item = items[i];
if (item->hasLocalName(optionTag) && optionIndex++ >= newLen) {
ASSERT(item->parentNode());
itemsToRemove.append(item);
}
}
for (size_t i = 0; i < itemsToRemove.size(); ++i) {
Element* item = itemsToRemove[i].get();
if (item->parentNode())
item->parentNode()->removeChild(item, ec);
}
}
setNeedsValidityCheck();
}
bool HTMLSelectElement::isRequiredFormControl() const
{
return required();
}
int HTMLSelectElement::nextValidIndex(int listIndex, SkipDirection direction, int skip) const
{
ASSERT(direction == -1 || direction == 1);
const Vector<HTMLElement*>& listItems = this->listItems();
int lastGoodIndex = listIndex;
int size = listItems.size();
for (listIndex += direction; listIndex >= 0 && listIndex < size; listIndex += direction) {
--skip;
if (!listItems[listIndex]->disabled() && listItems[listIndex]->hasTagName(optionTag)) {
lastGoodIndex = listIndex;
if (skip <= 0)
break;
}
}
return lastGoodIndex;
}
int HTMLSelectElement::nextSelectableListIndex(int startIndex) const
{
return nextValidIndex(startIndex, SkipForwards, 1);
}
int HTMLSelectElement::previousSelectableListIndex(int startIndex) const
{
if (startIndex == -1)
startIndex = listItems().size();
return nextValidIndex(startIndex, SkipBackwards, 1);
}
int HTMLSelectElement::firstSelectableListIndex() const
{
const Vector<HTMLElement*>& items = listItems();
int index = nextValidIndex(items.size(), SkipBackwards, INT_MAX);
if (static_cast<size_t>(index) == items.size())
return -1;
return index;
}
int HTMLSelectElement::lastSelectableListIndex() const
{
return nextValidIndex(-1, SkipForwards, INT_MAX);
}
int HTMLSelectElement::nextSelectableListIndexPageAway(int startIndex, SkipDirection direction) const
{
const Vector<HTMLElement*>& items = listItems();
int pageSize = 0;
if (renderer()->isListBox())
pageSize = toRenderListBox(renderer())->size() - 1;
int edgeIndex = (direction == SkipForwards) ? 0 : (items.size() - 1);
int skipAmount = pageSize + ((direction == SkipForwards) ? startIndex : (edgeIndex - startIndex));
return nextValidIndex(edgeIndex, direction, skipAmount);
}
void HTMLSelectElement::selectAll()
{
ASSERT(!usesMenuList());
if (!renderer() || !m_multiple)
return;
saveLastSelection();
m_activeSelectionState = true;
setActiveSelectionAnchorIndex(nextSelectableListIndex(-1));
setActiveSelectionEndIndex(previousSelectableListIndex(-1));
updateListBoxSelection(false);
listBoxOnChange();
setNeedsValidityCheck();
}
void HTMLSelectElement::saveLastSelection()
{
if (usesMenuList()) {
m_lastOnChangeIndex = selectedIndex();
return;
}
m_lastOnChangeSelection.clear();
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
m_lastOnChangeSelection.append(element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected());
}
}
void HTMLSelectElement::setActiveSelectionAnchorIndex(int index)
{
m_activeSelectionAnchorIndex = index;
m_cachedStateForActiveSelection.clear();
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
m_cachedStateForActiveSelection.append(element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected());
}
}
void HTMLSelectElement::setActiveSelectionEndIndex(int index)
{
m_activeSelectionEndIndex = index;
}
void HTMLSelectElement::updateListBoxSelection(bool deselectOtherOptions)
{
ASSERT(renderer() && (renderer()->isListBox() || m_multiple));
ASSERT(!listItems().size() || m_activeSelectionAnchorIndex >= 0);
unsigned start = min(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
unsigned end = max(m_activeSelectionAnchorIndex, m_activeSelectionEndIndex);
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
if (!element->hasTagName(optionTag) || toHTMLOptionElement(element)->disabled())
continue;
if (i >= start && i <= end)
toHTMLOptionElement(element)->setSelectedState(m_activeSelectionState);
else if (deselectOtherOptions || i >= m_cachedStateForActiveSelection.size())
toHTMLOptionElement(element)->setSelectedState(false);
else
toHTMLOptionElement(element)->setSelectedState(m_cachedStateForActiveSelection[i]);
}
scrollToSelection();
setNeedsValidityCheck();
}
void HTMLSelectElement::listBoxOnChange()
{
ASSERT(!usesMenuList() || m_multiple);
const Vector<HTMLElement*>& items = listItems();
if (m_lastOnChangeSelection.isEmpty() || m_lastOnChangeSelection.size() != items.size()) {
dispatchFormControlChangeEvent();
return;
}
bool fireOnChange = false;
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
bool selected = element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected();
if (selected != m_lastOnChangeSelection[i])
fireOnChange = true;
m_lastOnChangeSelection[i] = selected;
}
if (fireOnChange)
dispatchFormControlChangeEvent();
}
void HTMLSelectElement::dispatchChangeEventForMenuList()
{
ASSERT(usesMenuList());
int selected = selectedIndex();
if (m_lastOnChangeIndex != selected && m_isProcessingUserDrivenChange) {
m_lastOnChangeIndex = selected;
m_isProcessingUserDrivenChange = false;
dispatchFormControlChangeEvent();
}
}
void HTMLSelectElement::scrollToSelection()
{
if (usesMenuList())
return;
if (RenderObject* renderer = this->renderer())
toRenderListBox(renderer)->selectionChanged();
}
void HTMLSelectElement::setOptionsChangedOnRenderer()
{
if (RenderObject* renderer = this->renderer()) {
if (usesMenuList())
toRenderMenuList(renderer)->setOptionsChanged(true);
else
toRenderListBox(renderer)->setOptionsChanged(true);
}
}
const Vector<HTMLElement*>& HTMLSelectElement::listItems() const
{
if (m_shouldRecalcListItems)
recalcListItems();
else {
#if !ASSERT_DISABLED
Vector<HTMLElement*> items = m_listItems;
recalcListItems(false);
ASSERT(items == m_listItems);
#endif
}
return m_listItems;
}
void HTMLSelectElement::setRecalcListItems()
{
m_shouldRecalcListItems = true;
m_activeSelectionAnchorIndex = -1;
setOptionsChangedOnRenderer();
setNeedsStyleRecalc();
if (!inDocument() && m_optionsCollection)
m_optionsCollection->invalidateCacheIfNeeded();
}
void HTMLSelectElement::recalcListItems(bool updateSelectedStates) const
{
m_listItems.clear();
m_shouldRecalcListItems = false;
HTMLOptionElement* foundSelected = 0;
HTMLOptionElement* firstOption = 0;
for (Node* currentNode = this->firstChild(); currentNode;) {
if (!currentNode->isHTMLElement()) {
currentNode = currentNode->traverseNextSibling(this);
continue;
}
HTMLElement* current = toHTMLElement(currentNode);
if (current->hasTagName(optgroupTag)) {
m_listItems.append(current);
if (current->firstChild()) {
currentNode = current->firstChild();
continue;
}
}
if (current->hasTagName(optionTag)) {
m_listItems.append(current);
if (updateSelectedStates && !m_multiple) {
HTMLOptionElement* option = toHTMLOptionElement(current);
if (!firstOption)
firstOption = option;
if (option->selected()) {
if (foundSelected)
foundSelected->setSelectedState(false);
foundSelected = option;
} else if (m_size <= 1 && !foundSelected && !option->disabled()) {
foundSelected = option;
foundSelected->setSelectedState(true);
}
}
}
if (current->hasTagName(hrTag))
m_listItems.append(current);
currentNode = currentNode->traverseNextSibling(this);
}
if (!foundSelected && m_size <= 1 && firstOption && !firstOption->selected())
firstOption->setSelectedState(true);
}
int HTMLSelectElement::selectedIndex() const
{
unsigned index = 0;
const Vector<HTMLElement*>& items = listItems();
for (size_t i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
if (element->hasTagName(optionTag)) {
if (toHTMLOptionElement(element)->selected())
return index;
++index;
}
}
return -1;
}
void HTMLSelectElement::setSelectedIndex(int index)
{
selectOption(index, DeselectOtherOptions);
}
void HTMLSelectElement::optionSelectionStateChanged(HTMLOptionElement* option, bool optionIsSelected)
{
ASSERT(option->ownerSelectElement() == this);
if (optionIsSelected)
selectOption(option->index());
else if (!usesMenuList())
selectOption(-1);
else
selectOption(nextSelectableListIndex(-1));
}
void HTMLSelectElement::selectOption(int optionIndex, SelectOptionFlags flags)
{
bool shouldDeselect = !m_multiple || (flags & DeselectOtherOptions);
const Vector<HTMLElement*>& items = listItems();
int listIndex = optionToListIndex(optionIndex);
HTMLElement* element = 0;
if (listIndex >= 0) {
element = items[listIndex];
if (element->hasTagName(optionTag)) {
if (m_activeSelectionAnchorIndex < 0 || shouldDeselect)
setActiveSelectionAnchorIndex(listIndex);
if (m_activeSelectionEndIndex < 0 || shouldDeselect)
setActiveSelectionEndIndex(listIndex);
toHTMLOptionElement(element)->setSelectedState(true);
}
}
if (shouldDeselect)
deselectItemsWithoutValidation(element);
if (RenderObject* renderer = this->renderer())
renderer->updateFromElement();
scrollToSelection();
if (usesMenuList()) {
m_isProcessingUserDrivenChange = flags & UserDriven;
if (flags & DispatchChangeEvent)
dispatchChangeEventForMenuList();
if (RenderObject* renderer = this->renderer()) {
if (usesMenuList())
toRenderMenuList(renderer)->didSetSelectedIndex(listIndex);
else if (renderer->isListBox())
toRenderListBox(renderer)->selectionChanged();
}
}
setNeedsValidityCheck();
if (Frame* frame = document()->frame())
frame->page()->chrome()->client()->formStateDidChange(this);
}
int HTMLSelectElement::optionToListIndex(int optionIndex) const
{
const Vector<HTMLElement*>& items = listItems();
int listSize = static_cast<int>(items.size());
if (optionIndex < 0 || optionIndex >= listSize)
return -1;
int optionIndex2 = -1;
for (int listIndex = 0; listIndex < listSize; ++listIndex) {
if (items[listIndex]->hasTagName(optionTag)) {
++optionIndex2;
if (optionIndex2 == optionIndex)
return listIndex;
}
}
return -1;
}
int HTMLSelectElement::listToOptionIndex(int listIndex) const
{
const Vector<HTMLElement*>& items = listItems();
if (listIndex < 0 || listIndex >= static_cast<int>(items.size()) || !items[listIndex]->hasTagName(optionTag))
return -1;
int optionIndex = 0;
for (int i = 0; i < listIndex; ++i) {
if (items[i]->hasTagName(optionTag))
++optionIndex;
}
return optionIndex;
}
void HTMLSelectElement::dispatchFocusEvent(PassRefPtr<Node> oldFocusedNode)
{
if (usesMenuList())
saveLastSelection();
HTMLFormControlElementWithState::dispatchFocusEvent(oldFocusedNode);
}
void HTMLSelectElement::dispatchBlurEvent(PassRefPtr<Node> newFocusedNode)
{
if (usesMenuList())
dispatchChangeEventForMenuList();
HTMLFormControlElementWithState::dispatchBlurEvent(newFocusedNode);
}
void HTMLSelectElement::deselectItemsWithoutValidation(HTMLElement* excludeElement)
{
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
if (element != excludeElement && element->hasTagName(optionTag))
toHTMLOptionElement(element)->setSelectedState(false);
}
}
bool HTMLSelectElement::saveFormControlState(String& value) const
{
const Vector<HTMLElement*>& items = listItems();
size_t length = items.size();
StringBuilder builder;
builder.reserveCapacity(length);
for (unsigned i = 0; i < length; ++i) {
HTMLElement* element = items[i];
bool selected = element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected();
builder.append(selected ? 'X' : '.');
}
value = builder.toString();
return true;
}
void HTMLSelectElement::restoreFormControlState(const String& state)
{
recalcListItems();
const Vector<HTMLElement*>& items = listItems();
size_t length = items.size();
for (size_t i = 0; i < length; ++i) {
HTMLElement* element = items[i];
if (element->hasTagName(optionTag))
toHTMLOptionElement(element)->setSelectedState(state[i] == 'X');
}
setOptionsChangedOnRenderer();
setNeedsValidityCheck();
}
void HTMLSelectElement::parseMultipleAttribute(const Attribute* attribute)
{
bool oldUsesMenuList = usesMenuList();
m_multiple = !attribute->isNull();
setNeedsValidityCheck();
if (oldUsesMenuList != usesMenuList())
reattachIfAttached();
}
bool HTMLSelectElement::appendFormData(FormDataList& list, bool)
{
const AtomicString& name = formControlName();
if (name.isEmpty())
return false;
bool successful = false;
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
if (element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected() && !toHTMLOptionElement(element)->disabled()) {
list.appendData(name, toHTMLOptionElement(element)->value());
successful = true;
}
}
return successful;
}
void HTMLSelectElement::reset()
{
HTMLOptionElement* firstOption = 0;
HTMLOptionElement* selectedOption = 0;
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
HTMLElement* element = items[i];
if (!element->hasTagName(optionTag))
continue;
if (items[i]->fastHasAttribute(selectedAttr)) {
if (selectedOption && !m_multiple)
selectedOption->setSelectedState(false);
toHTMLOptionElement(element)->setSelectedState(true);
selectedOption = toHTMLOptionElement(element);
} else
toHTMLOptionElement(element)->setSelectedState(false);
if (!firstOption)
firstOption = toHTMLOptionElement(element);
}
if (!selectedOption && firstOption && !m_multiple && m_size <= 1)
firstOption->setSelectedState(true);
setOptionsChangedOnRenderer();
setNeedsStyleRecalc();
setNeedsValidityCheck();
}
#if !PLATFORM(WIN) || OS(WINCE)
bool HTMLSelectElement::platformHandleKeydownEvent(KeyboardEvent* event)
{
const Page* page = document()->page();
RefPtr<RenderTheme> renderTheme = page ? page->theme() : RenderTheme::defaultTheme();
if (!renderTheme->popsMenuByArrowKeys())
return false;
if (!isSpatialNavigationEnabled(document()->frame())) {
if (event->keyIdentifier() == "Down" || event->keyIdentifier() == "Up") {
focus();
if (!renderer())
return true;
saveLastSelection();
if (RenderMenuList* menuList = toRenderMenuList(renderer()))
menuList->showPopup();
event->setDefaultHandled();
}
return true;
}
return false;
}
#endif
void HTMLSelectElement::menuListDefaultEventHandler(Event* event)
{
const Page* page = document()->page();
RefPtr<RenderTheme> renderTheme = page ? page->theme() : RenderTheme::defaultTheme();
if (event->type() == eventNames().keydownEvent) {
if (!renderer() || !event->isKeyboardEvent())
return;
if (platformHandleKeydownEvent(static_cast<KeyboardEvent*>(event)))
return;
if (isSpatialNavigationEnabled(document()->frame())) {
if (!m_activeSelectionState)
return;
}
const String& keyIdentifier = static_cast<KeyboardEvent*>(event)->keyIdentifier();
bool handled = true;
const Vector<HTMLElement*>& listItems = this->listItems();
int listIndex = optionToListIndex(selectedIndex());
if (keyIdentifier == "Down" || keyIdentifier == "Right")
listIndex = nextValidIndex(listIndex, SkipForwards, 1);
else if (keyIdentifier == "Up" || keyIdentifier == "Left")
listIndex = nextValidIndex(listIndex, SkipBackwards, 1);
else if (keyIdentifier == "PageDown")
listIndex = nextValidIndex(listIndex, SkipForwards, 3);
else if (keyIdentifier == "PageUp")
listIndex = nextValidIndex(listIndex, SkipBackwards, 3);
else if (keyIdentifier == "Home")
listIndex = nextValidIndex(-1, SkipForwards, 1);
else if (keyIdentifier == "End")
listIndex = nextValidIndex(listItems.size(), SkipBackwards, 1);
else
handled = false;
if (handled && static_cast<size_t>(listIndex) < listItems.size())
selectOption(listToOptionIndex(listIndex), DeselectOtherOptions | DispatchChangeEvent | UserDriven);
if (handled)
event->setDefaultHandled();
}
if (event->type() == eventNames().keypressEvent) {
if (!renderer() || !event->isKeyboardEvent())
return;
int keyCode = static_cast<KeyboardEvent*>(event)->keyCode();
bool handled = false;
if (keyCode == ' ' && isSpatialNavigationEnabled(document()->frame())) {
m_activeSelectionState = !m_activeSelectionState;
event->setDefaultHandled();
return;
}
if (renderTheme->popsMenuBySpaceOrReturn()) {
if (keyCode == ' ' || keyCode == '\r') {
focus();
if (!renderer())
return;
saveLastSelection();
if (RenderMenuList* menuList = toRenderMenuList(renderer()))
menuList->showPopup();
handled = true;
}
} else if (renderTheme->popsMenuByArrowKeys()) {
if (keyCode == ' ') {
focus();
if (!renderer())
return;
saveLastSelection();
if (RenderMenuList* menuList = toRenderMenuList(renderer()))
menuList->showPopup();
handled = true;
} else if (keyCode == '\r') {
if (form())
form()->submitImplicitly(event, false);
dispatchChangeEventForMenuList();
handled = true;
}
}
if (handled)
event->setDefaultHandled();
}
if (event->type() == eventNames().mousedownEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton) {
focus();
if (renderer() && renderer()->isMenuList()) {
if (RenderMenuList* menuList = toRenderMenuList(renderer())) {
if (menuList->popupIsVisible())
menuList->hidePopup();
else {
saveLastSelection();
menuList->showPopup();
}
}
}
event->setDefaultHandled();
}
}
void HTMLSelectElement::updateSelectedState(int listIndex, bool multi, bool shift)
{
ASSERT(listIndex >= 0);
saveLastSelection();
m_activeSelectionState = true;
bool shiftSelect = m_multiple && shift;
bool multiSelect = m_multiple && multi && !shift;
HTMLElement* clickedElement = listItems()[listIndex];
if (clickedElement->hasTagName(optionTag)) {
if (toHTMLOptionElement(clickedElement)->selected() && multiSelect)
m_activeSelectionState = false;
if (!m_activeSelectionState)
toHTMLOptionElement(clickedElement)->setSelectedState(false);
}
if (!shiftSelect && !multiSelect)
deselectItemsWithoutValidation(clickedElement);
if (m_activeSelectionAnchorIndex < 0 && !multiSelect)
setActiveSelectionAnchorIndex(selectedIndex());
if (clickedElement->hasTagName(optionTag) && !toHTMLOptionElement(clickedElement)->disabled())
toHTMLOptionElement(clickedElement)->setSelectedState(true);
if (m_activeSelectionAnchorIndex < 0 || !shiftSelect)
setActiveSelectionAnchorIndex(listIndex);
setActiveSelectionEndIndex(listIndex);
updateListBoxSelection(!multiSelect);
}
void HTMLSelectElement::listBoxDefaultEventHandler(Event* event)
{
const Vector<HTMLElement*>& listItems = this->listItems();
if (event->type() == eventNames().mousedownEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton) {
focus();
if (!renderer())
return;
MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), false, true));
int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toSize(localOffset));
if (listIndex >= 0) {
#if PLATFORM(MAC) || (PLATFORM(CHROMIUM) && OS(DARWIN))
updateSelectedState(listIndex, mouseEvent->metaKey(), mouseEvent->shiftKey());
#else
updateSelectedState(listIndex, mouseEvent->ctrlKey(), mouseEvent->shiftKey());
#endif
if (Frame* frame = document()->frame())
frame->eventHandler()->setMouseDownMayStartAutoscroll();
event->setDefaultHandled();
}
} else if (event->type() == eventNames().mousemoveEvent && event->isMouseEvent() && !toRenderBox(renderer())->canBeScrolledAndHasScrollableArea()) {
MouseEvent* mouseEvent = static_cast<MouseEvent*>(event);
if (mouseEvent->button() != LeftButton || !mouseEvent->buttonDown())
return;
IntPoint localOffset = roundedIntPoint(renderer()->absoluteToLocal(mouseEvent->absoluteLocation(), false, true));
int listIndex = toRenderListBox(renderer())->listIndexAtOffset(toSize(localOffset));
if (listIndex >= 0) {
if (m_multiple) {
setActiveSelectionEndIndex(listIndex);
updateListBoxSelection(false);
} else {
setActiveSelectionAnchorIndex(listIndex);
setActiveSelectionEndIndex(listIndex);
updateListBoxSelection(true);
}
event->setDefaultHandled();
}
} else if (event->type() == eventNames().mouseupEvent && event->isMouseEvent() && static_cast<MouseEvent*>(event)->button() == LeftButton && document()->frame()->eventHandler()->autoscrollRenderer() != renderer()) {
listBoxOnChange();
} else if (event->type() == eventNames().keydownEvent) {
if (!event->isKeyboardEvent())
return;
const String& keyIdentifier = static_cast<KeyboardEvent*>(event)->keyIdentifier();
bool handled = false;
int endIndex = 0;
if (m_activeSelectionEndIndex < 0) {
if (keyIdentifier == "Down" || keyIdentifier == "PageDown") {
int startIndex = lastSelectedListIndex();
handled = true;
if (keyIdentifier == "Down")
endIndex = nextSelectableListIndex(startIndex);
else
endIndex = nextSelectableListIndexPageAway(startIndex, SkipForwards);
} else if (keyIdentifier == "Up" || keyIdentifier == "PageUp") {
int startIndex = optionToListIndex(selectedIndex());
handled = true;
if (keyIdentifier == "Up")
endIndex = previousSelectableListIndex(startIndex);
else
endIndex = nextSelectableListIndexPageAway(startIndex, SkipBackwards);
}
} else {
if (keyIdentifier == "Down") {
endIndex = nextSelectableListIndex(m_activeSelectionEndIndex);
handled = true;
} else if (keyIdentifier == "Up") {
endIndex = previousSelectableListIndex(m_activeSelectionEndIndex);
handled = true;
} else if (keyIdentifier == "PageDown") {
endIndex = nextSelectableListIndexPageAway(m_activeSelectionEndIndex, SkipForwards);
handled = true;
} else if (keyIdentifier == "PageUp") {
endIndex = nextSelectableListIndexPageAway(m_activeSelectionEndIndex, SkipBackwards);
handled = true;
}
}
if (keyIdentifier == "Home") {
endIndex = firstSelectableListIndex();
handled = true;
} else if (keyIdentifier == "End") {
endIndex = lastSelectableListIndex();
handled = true;
}
if (isSpatialNavigationEnabled(document()->frame()))
if (keyIdentifier == "Left" || keyIdentifier == "Right" || ((keyIdentifier == "Down" || keyIdentifier == "Up") && endIndex == m_activeSelectionEndIndex))
return;
if (endIndex >= 0 && handled) {
saveLastSelection();
ASSERT_UNUSED(listItems, !listItems.size() || static_cast<size_t>(endIndex) < listItems.size());
setActiveSelectionEndIndex(endIndex);
bool selectNewItem = !m_multiple || static_cast<KeyboardEvent*>(event)->shiftKey() || !isSpatialNavigationEnabled(document()->frame());
if (selectNewItem)
m_activeSelectionState = true;
bool deselectOthers = !m_multiple || (!static_cast<KeyboardEvent*>(event)->shiftKey() && selectNewItem);
if (m_activeSelectionAnchorIndex < 0 || deselectOthers) {
if (deselectOthers)
deselectItemsWithoutValidation();
setActiveSelectionAnchorIndex(m_activeSelectionEndIndex);
}
toRenderListBox(renderer())->scrollToRevealElementAtListIndex(endIndex);
if (selectNewItem) {
updateListBoxSelection(deselectOthers);
listBoxOnChange();
} else
scrollToSelection();
event->setDefaultHandled();
}
} else if (event->type() == eventNames().keypressEvent) {
if (!event->isKeyboardEvent())
return;
int keyCode = static_cast<KeyboardEvent*>(event)->keyCode();
if (keyCode == '\r') {
if (form())
form()->submitImplicitly(event, false);
event->setDefaultHandled();
} else if (m_multiple && keyCode == ' ' && isSpatialNavigationEnabled(document()->frame())) {
m_activeSelectionState = !m_activeSelectionState;
updateSelectedState(listToOptionIndex(m_activeSelectionEndIndex), true , false );
listBoxOnChange();
event->setDefaultHandled();
}
}
}
void HTMLSelectElement::defaultEventHandler(Event* event)
{
if (!renderer())
return;
if (usesMenuList())
menuListDefaultEventHandler(event);
else
listBoxDefaultEventHandler(event);
if (event->defaultHandled())
return;
if (event->type() == eventNames().keypressEvent && event->isKeyboardEvent()) {
KeyboardEvent* keyboardEvent = static_cast<KeyboardEvent*>(event);
if (!keyboardEvent->ctrlKey() && !keyboardEvent->altKey() && !keyboardEvent->metaKey() && isPrintableChar(keyboardEvent->charCode())) {
typeAheadFind(keyboardEvent);
event->setDefaultHandled();
return;
}
}
HTMLFormControlElementWithState::defaultEventHandler(event);
}
int HTMLSelectElement::lastSelectedListIndex() const
{
const Vector<HTMLElement*>& items = listItems();
for (size_t i = items.size(); i;) {
HTMLElement* element = items[--i];
if (element->hasTagName(optionTag) && toHTMLOptionElement(element)->selected())
return i;
}
return -1;
}
static String stripLeadingWhiteSpace(const String& string)
{
int length = string.length();
int i;
for (i = 0; i < length; ++i) {
if (string[i] != noBreakSpace && (string[i] <= 0x7F ? !isASCIISpace(string[i]) : (direction(string[i]) != WhiteSpaceNeutral)))
break;
}
return string.substring(i, length - i);
}
void HTMLSelectElement::typeAheadFind(KeyboardEvent* event)
{
if (event->timeStamp() < m_lastCharTime)
return;
DOMTimeStamp delta = event->timeStamp() - m_lastCharTime;
m_lastCharTime = event->timeStamp();
UChar c = event->charCode();
String prefix;
int searchStartOffset = 1;
if (delta > typeAheadTimeout) {
prefix = String(&c, 1);
m_typedString = prefix;
m_repeatingChar = c;
} else {
m_typedString.append(c);
if (c == m_repeatingChar) {
prefix = String(&c, 1);
} else {
m_repeatingChar = 0;
prefix = m_typedString;
searchStartOffset = 0;
}
}
const Vector<HTMLElement*>& items = listItems();
int itemCount = items.size();
if (itemCount < 1)
return;
int selected = selectedIndex();
int index = (optionToListIndex(selected >= 0 ? selected : 0) + searchStartOffset) % itemCount;
ASSERT(index >= 0);
String prefixWithCaseFolded(prefix.foldCase());
for (int i = 0; i < itemCount; ++i, index = (index + 1) % itemCount) {
HTMLElement* element = items[index];
if (!element->hasTagName(optionTag) || toHTMLOptionElement(element)->disabled())
continue;
String text = toHTMLOptionElement(element)->textIndentedToRespectGroupLabel();
if (stripLeadingWhiteSpace(text).foldCase().startsWith(prefixWithCaseFolded)) {
selectOption(listToOptionIndex(index), DeselectOtherOptions | DispatchChangeEvent | UserDriven);
if (!usesMenuList())
listBoxOnChange();
setOptionsChangedOnRenderer();
setNeedsStyleRecalc();
return;
}
}
}
Node::InsertionNotificationRequest HTMLSelectElement::insertedInto(Node* insertionPoint)
{
recalcListItems();
HTMLFormControlElementWithState::insertedInto(insertionPoint);
return InsertionDone;
}
void HTMLSelectElement::accessKeySetSelectedIndex(int index)
{
if (!focused())
accessKeyAction(false);
const Vector<HTMLElement*>& items = listItems();
int listIndex = optionToListIndex(index);
if (listIndex >= 0) {
HTMLElement* element = items[listIndex];
if (element->hasTagName(optionTag)) {
if (toHTMLOptionElement(element)->selected())
toHTMLOptionElement(element)->setSelectedState(false);
else
selectOption(index, DispatchChangeEvent | UserDriven);
}
}
if (usesMenuList())
dispatchChangeEventForMenuList();
else
listBoxOnChange();
scrollToSelection();
}
unsigned HTMLSelectElement::length() const
{
unsigned options = 0;
const Vector<HTMLElement*>& items = listItems();
for (unsigned i = 0; i < items.size(); ++i) {
if (items[i]->hasTagName(optionTag))
++options;
}
return options;
}
#ifndef NDEBUG
HTMLSelectElement* toHTMLSelectElement(Node* node)
{
ASSERT(!node || node->hasTagName(selectTag));
return static_cast<HTMLSelectElement*>(node);
}
const HTMLSelectElement* toHTMLSelectElement(const Node* node)
{
ASSERT(!node || node->hasTagName(selectTag));
return static_cast<const HTMLSelectElement*>(node);
}
#endif
}